gap-4r6p5/0000755000175000017500000000000012174560030011127 5ustar billbillgap-4r6p5/doc/0000755000175000017500000000000012174560027011702 5ustar billbillgap-4r6p5/doc/tut/0000755000175000017500000000000012174560027012516 5ustar billbillgap-4r6p5/doc/tut/opers.xml0000644000175000017500000004602712172557252014405 0ustar billbill

Operations and Methods

Attributes In the preceding chapters, we have seen how to obtain information about mathematical objects in ⪆: We have to pass the object as an argument to a function. For example, if G is a group one can call Size( G ), and the function will return a value, in our example an integer which is the size of G. Computing the size of a group generally requires a substantial amount of work, therefore it seems desirable to store the size somewhere once it has been calculated. You should imagine that ⪆ stores the size in some place associated with the object G when Size( G ) is executed for the first time, and if this function call is executed again later, the size is simply looked up and returned, without further computation.

getter setter tester methods This means that the behavior of the function has to depend on whether the size for the argument G is already known, and if not, that the size must be stored after it has been calculated. These two extra tasks are done by two other functions that accompany Size( G ), namely the tester HasSize( G ) and the setter SetSize( G, size ). The tester returns true or false according to whether G has already stored its size, and the setter puts size into a place from where G can directly look it up. The function itself is called the getter, and from the preceding discussion we see that there must really be at least two methods for the getter: One method is used when the tester returns false; it is the method which first does the real computation and then executes the setter with the computed value. A second method is used when the tester returns true; it simply returns the stored value. This second method is also called the system getter. ⪆ functions for which several methods can be available are called operations, so is an example of an operation.

G := Group(List([1..3], i-> Random(SymmetricGroup(53))));; gap> Size( G ); time > 0; # the time may of course vary on your machine 4274883284060025564298013753389399649690343788366813724672000000000000 true gap> Size( G ); time; 4274883284060025564298013753389399649690343788366813724672000000000000 0 ]]>

The convenient thing for the user is that ⪆ automatically chooses the right method for the getter, i.e., it calls a real-work getter at most once and the system getter in all subsequent occurrences. At most once because the value of a function call like Size( G ) can also be set for G before the getter is called at all; for example, one can call the setter directly if one knows the size.

The size of a group is an example of a class of things which in ⪆ are called attributes. Every attribute in ⪆ is represented by a triple of a getter, a setter and a tester. When a new attribute is declared, all three functions are created together and the getter contains references to the other two. This is necessary because when the getter is called, it must first consult the tester, and perhaps execute the setter in the end. Therefore the getter could be implemented as follows: The only function which depends on the mathematical nature of the attribute is the real-work getter, and this is of course what the programmer of an attribute has to install. In both cases, the getter returns the same value, which we also call the value of the attribute (properly: the value of the attribute for the object obj). By the way: The names for setter and tester of an attribute are always composed from the prefix Set resp. Has and the name of the getter.

As a (not typical) example, note that the ⪆ function , although it takes only one argument, is of course not an attribute, because otherwise the first random element of a group would be stored by the setter and returned over and over again by the system getter every time is called in the sequel.

There is a general important rule about attributes: Once the value of an attribute for an object has been set, it cannot be reset, i.e., it cannot be changed any more. This is achieved by having two methods not only for the getter but also for the setter: If an object already has an attribute value stored, i.e., if the tester returns true, the setter simply does nothing.

G := SymmetricGroup(8);; Size(G); 40320 gap> SetSize( G, 0 ); Size( G ); 40320 ]]>

Summary. In this section we have introduced attributes as triples of getter, setter and tester and we have explained how these three functions work together behind the scene to provide automatic storage and look-up of values that have once been calculated. We have seen that there can be several methods for the same function among which ⪆ automatically selects an appropriate one.

Properties and Filters filters methods Certain attributes, like , are boolean-valued. Such attributes are known to ⪆ as properties, because their values are stored in a slightly different way. A property also has a getter, a setter and a tester, but in this case, the getter as well as the tester returns a boolean value. Therefore ⪆ stores both values in the same way, namely as bits in a boolean list, thereby treating property getters and all testers (of attributes or properties) uniformly. These boolean-valued functions are called filters. You can imagine a filter as a switch which is set either to true or to false. For every ⪆ object there is a boolean list which has reserved a bit for every filter ⪆ knows about. Strictly speaking, there is one bit for every simple filter, and these simple filters can be combined with and to form other filters (which are then true if and only if all the corresponding bits are set to true). For example, the filter IsPermGroup and IsSolvableGroup is made up from several simple filters.

Since they allow only two values, the bits which represent filters can be compared very quickly, and the scheme by which ⪆ chooses the method, e.g., for a getter or a setter (as we have seen in the previous section), is mostly based on the examination of filters, not on the examination of other attribute values. Details of this method selection are described in chapter .

We only present the following rule of thumb here: Each installed method for an attribute, say , has a required filter, which is made up from certain simple filters which must yield true for the argument obj for this method to be applicable. To execute a call of Size( obj ), ⪆ selects among all applicable methods the one whose required filter combines the most simple filters; the idea behind is that the more an algorithm requires of obj, the more efficient it is expected to be. For example, if obj is a permutation group that is not (known to be) solvable, a method with required filter IsPermGroup and IsSolvableGroup is not applicable, whereas a method with required filter can be chosen. On the other hand, if obj was known to be solvable, the method with required filter IsPermGroup and IsSolvableGroup would be preferred to the one with required filter .

It may happen that a method is applicable for a given argument but cannot compute the desired value. In such cases, the method will execute the statement TryNextMethod();, TryNextMethod and ⪆ calls the next applicable method. For example, describes an algorithm to compute the size of a solvable permutation group, which can be used also to decide whether or not a permutation group is solvable. Suppose that the function size_solvable implements this algorithm, and that is returns the order of the group if it is solvable and fail otherwise. Then we can install the following method for with required filter . fail then return value; else TryNextMethod(); fi; end; ]]> This method can then be tried on every permutation group (whether known to be solvable or not), and it would include a mandatory solvability test.

If no applicable method (or no next applicable method) is found, ⪆ stops with an error message of the form

You would get an error message as above if you asked for Size( 1 ). The message simply says that there is no method installed for calculating the size of 1. Section contains more information on how to deal with these messages.

Summary. In this section we have introduced properties as special attributes, and filters as the general concept behind property getters and attribute testers. The values of the filters of an object govern how the object is treated in the selection of methods for operations.

Immediate and True Methods methods methods In the example in Section , we have mentioned that the operation has a method for solvable permutation groups that is so far superior to the method for general permutation groups that it seems worthwhile to try it even if nothing is known about solvability of the group of which the is to be calculated. There are other examples where certain methods are even cheaper to execute. For example, if the size of a group is known it is easy to check whether it is odd, and if so, the Feit-Thompson theorem allows us to set to true for this group. ⪆ utilizes this celebrated theorem by having an immediate method for with required filter HasSize which checks parity of the size and either sets or does nothing, i.e., calls TryNextMethod(). These immediate methods are executed automatically for an object whenever the value of a filter changes, so solvability of a group will automatically be detected when an odd size has been calculated for it (and therefore the value of HasSize for that group has changed to true).

Some methods are even more immediate, because they do not require any calculation at all: They allow a filter to be set if another filter is also set. In other words, they model a mathematical implication like IsGroup and IsCyclic implies IsSolvableGroup and such implications can be installed in ⪆ as true methods. To execute true methods, ⪆ only needs to do some bookkeeping with its filters, therefore true methods are much faster than immediate methods.

How immediate and true methods are installed is described in and .

Operations and Method Selection operations The method selection is not only used to select methods for attribute getters but also for arbitrary operations, which can have more than one argument. In this case, there is a required filter for each argument (which must yield true for the corresponding arguments).

Additionally, a method with at least two arguments may require a certain relation between the arguments, which is expressed in terms of the families of the arguments. For example, the methods for ConjugateGroup( grp, elm ) require that elm lies in the family of elements from which grp is made, i.e., that the family of elm equals the elements family of grp.

For permutation groups, the situation is quite easy: all permutations form one family, , and each collection of permutations, for example each permutation group, each coset of a permutation group, or each dense list of permutations, lies in CollectionsFamily( PermutationsFamily ).

For other kinds of group elements, the situation can be different. Every call of constructs a new family of free group elements. ⪆ refuses to compute One( FreeGroup( 1 ) ) * One( FreeGroup( 1 ) ) because the two operands of the multiplication lie in different families and no method is installed for this case.

For further information on family relations, see .

KnownPropertiesOfObject KnownTruePropertiesOfObject KnownAttributesOfObject If you want to know which properties are already known for an object obj, or which properties are known to be true, you can use the functions KnownPropertiesOfObject( obj ) resp. KnownTruePropertiesOfObject( obj ). This will print a list of names of properties. These names are also the identifiers of the property getters, by which you can retrieve the value of the properties (and confirm that they are really true). Analogously, there is the function which lists the names of the known attributes, leaving out the properties.

ApplicableMethod Since ⪆ lets you know what it already knows about an object, it is only natural that it also lets you know what methods it considers applicable for a certain method, and in what order it will try them (in case TryNextMethod() occurs). ApplicableMethod( opr, [ arg_1, arg_2, ... ] ) returns the first applicable method for the call opr( arg_1, arg_2, ... ). More generally, ApplicableMethod( opr, [ ... ], 0, nr ) returns the nrth applicable method (i.e., the one that would be chosen after nr-1 calls of TryNextMethod) and if nr = "all", the sorted list of all applicable methods is returned. For details, see .

TraceMethods If you want to see which methods are chosen for certain operations while ⪆ code is being executed, you can call the function with a list of these operations as arguments.

TraceMethods( [ Size ] ); gap> g:= Group( (1,2,3), (1,2) );; Size( g ); #I Size: for a permutation group #I Setter(Size): system setter #I Size: system getter #I Size: system getter 6 ]]>

The system getter is called once to fetch the freshly computed value for returning to the user. The second call is triggered by an immediate method. To find out by which, we can trace the immediate methods by saying TraceImmediateMethods( true ).

TraceImmediateMethods( true ); gap> g:= Group( (1,2,3), (1,2) );; #I immediate: Size #I immediate: IsCyclic #I immediate: IsCommutative #I immediate: IsTrivial gap> Size( g ); #I Size: for a permutation group #I immediate: IsNonTrivial #I immediate: Size #I immediate: IsFreeAbelian #I immediate: IsTorsionFree #I immediate: IsNonTrivial #I immediate: GeneralizedPcgs #I Setter(Size): system setter #I Size: system getter #I immediate: IsPerfectGroup #I Size: system getter #I immediate: IsEmpty 6 gap> TraceImmediateMethods( false ); gap> UntraceMethods( [ Size ] ); ]]>

The last two lines switch off tracing again. We now see that the system getter was called by the immediate method for . Also the above-mentioned immediate method for was not used because the solvability of g was already found out during the size calculation (cf. the example in Section ).

Summary. In this section and the last we have looked some more behind the scenes and seen that ⪆ automatically executes immediate and true methods to deduce information about objects that is cheaply available. We have seen how this can be supervised by tracing the methods.

gap-4r6p5/doc/tut/runexamples.g0000644000175000017500000000234712172557252015243 0ustar billbill# This runs the examples from the tutorial manual chapter-wise and indicates # differences in files EXAMPLEDIFFSnr where nr is the number of the chapter. SaveWorkspace("wsp"); for i in [1..Length(exstut)] do Print("Checking tut, Chapter ",i,"\n"); resfile := Concatenation( "EXAMPLEDIFFS", ListWithIdenticalEntries(2-Length(String(i)),'0'), String(i) ); RemoveFile(resfile); Exec(Concatenation("echo 'RunExamples(exstut{[", String(i), "]}", # By default compare up to whitespace, so some editing wrt. line breaks # or other whitespace in example output is accepted. # Comment the "WS" for comparison with \=. # Uncomment the "WSRS" or "RS" to change the source code to the # current output. ", WS", ## ", RS", ## ", WSRS", ");' | ../../bin/gap.sh -b -r -A -q -L wsp > ", resfile )); str := StringFile(resfile); if str{[Length(str)-22..Length(str)]} = "# Running list 1 . . .\n" then RemoveFile(resfile); else pos := PositionSublist(str, "# Running list 1 . . .\n"); FileString(resfile, str{[pos+23..Length(str)]}); Print(" found differences in tut, see file ", resfile, "\n"); fi; od; RemoveFile("wsp"); QUIT; gap-4r6p5/doc/tut/makedocreldata.g0000644000175000017500000000056412172557252015637 0ustar billbill############################################################################# ## ## values for the `MakeGAPDocDoc' call that builds the Tutorial ## GAPInfo.ManualDataTut:= rec( pathtodoc:= ".", main:= "main.xml", bookname:= "tut", pathtoroot:= "../..", files:= [ ], );; ############################################################################# ## #E gap-4r6p5/doc/tut/group.xml0000644000175000017500000014446012172557252014411 0ustar billbill

Groups and Homomorphisms In this chapter we will show some computations with groups. The examples deal mostly with permutation groups, because they are the easiest to input. The functions mentioned here, like , or , however, are the same for all kinds of groups, although the algorithms which compute the information of course will be different in most cases.

Permutation groups Permutation groups are so easy to input because their elements, i.e., permutations, are so easy to type: they are entered and displayed in disjoint cycle notation. So let's construct a permutation group:

s8 := Group( (1,2), (1,2,3,4,5,6,7,8) ); Group([ (1,2), (1,2,3,4,5,6,7,8) ]) ]]>

We formed the group generated by the permutations (1,2) and (1,2,3,4,5,6,7,8), which is well known to be the symmetric group S_8 on eight points, and assigned it to the identifier s8. Now S_8 contains the alternating group on eight points which can be described in several ways, e.g., as the group of all even permutations in s8, or as its derived subgroup.

a8 := DerivedSubgroup( s8 ); Group([ (1,2,3), (2,3,4), (2,4)(3,5), (2,6,4), (2,4)(5,7), (2,8,6,4)(3,5) ]) gap> Size( a8 ); IsAbelian( a8 ); IsPerfect( a8 ); 20160 false true ]]>

Once information about a group like s8 or a8 has been computed, it is stored in the group so that it can simply be looked up when it is required again. This holds for all pieces of information in the previous example. Namely, a8 stores its order and that it is nonabelian and perfect, and s8 stores its derived subgroup a8. Had we computed a8 as CommutatorSubgroup( s8, s8 ), however, it would not have been stored, because it would then have been computed as a function of two arguments, and hence one could not attribute it to just one of them. (Of course the function can compute the commutator subgroup of two arbitrary subgroups.) The situation is a bit different for Sylow p-subgroups: The function also requires two arguments, namely a group and a prime p, but the result is stored in the group –namely together with the prime p in a list that can be accessed with ComputedSylowSubgroups, but we won't dwell on the details here.

syl2 := SylowSubgroup( a8, 2 );; Size( syl2 ); 64 gap> Normalizer( a8, syl2 ) = syl2; true gap> cent := Centralizer( a8, Centre( syl2 ) );; Size( cent ); 192 gap> DerivedSeries( cent );; List( last, Size ); [ 192, 96, 32, 2, 1 ] ]]>

We have typed double semicolons after some commands to avoid the output of the groups (which would be printed by their generator lists). Nevertheless, the beginner is encouraged to type a single semicolon instead and study the full output. This remark also applies for the rest of this tutorial.

With the next examples, we want to calculate a subgroup of a8, then its normalizer and finally determine the structure of the extension. We begin by forming a subgroup generated by three commuting involutions, i.e., a subgroup isomorphic to the additive group of the vector space 2^3.

elab := Group( (1,2)(3,4)(5,6)(7,8), (1,3)(2,4)(5,7)(6,8), > (1,5)(2,6)(3,7)(4,8) );; gap> Size( elab ); 8 gap> IsElementaryAbelian( elab ); true ]]>

As usual, ⪆ prints the group by giving all its generators. This can be annoying, especially if there are many of them or if they are of huge degree. It also makes it difficult to recognize a particular group when there are already several around. Note that although it is no problem for us to specify a particular group to ⪆, by using well-chosen identifiers such as a8 and elab, it is impossible for ⪆ to use these identifiers when printing a group for us, because the group does not know which identifier(s) point to it, in fact there can be several. In order to give a name to the group itself (rather than to the identifier), you can use the function . We do this with the name 2^3 here which reflects the mathematical properties of the group. From now on, ⪆ will use this name when printing the group for us, but we still cannot use this name to specify the group to ⪆, because the name does not know to which group it was assigned (after all, you could assign the same name to several groups). When talking to the computer, you must always use identifiers.

SetName( elab, "" ); elab; gap> norm := Normalizer( a8, elab );; Size( norm ); 1344 ]]>

homomorphism Now that we have the subgroup norm of order 1344 and its subgroup elab, we want to look at its factor group. But since we also want to find preimages of factor group elements in norm, we really want to look at the natural homomorphism defined on norm with kernel elab and whose image is the factor group.

hom := NaturalHomomorphismByNormalSubgroup( norm, elab ); gap> f := Image( hom ); Group([ (), (), (), (4,5)(6,7), (4,6)(5,7), (2,3)(6,7), (2,4)(3,5), (1,2)(5,6) ]) gap> Size( f ); 168 ]]>

The factor group is again represented as a permutation group (its first three generators are trivial, meaning that the first three generators of the preimage are in the kernel of hom). However, the action domain of this factor group has nothing to do with the action domain of norm. (It only happens that both are subsets of the natural numbers.) We can now form images and preimages under the natural homomorphism. The set of preimages of an element under hom is a coset modulo elab. We use the function here because hom is not a bijection, so an element of the range can have several preimages or none at all.

ker:= Kernel( hom ); gap> x := (1,8,3,5,7,6,2);; Image( hom, x ); (1,7,5,6,2,3,4) gap> coset := PreImages( hom, last ); RightCoset(,(2,8,6,7,3,4,5)) ]]>

Note that ⪆ is free to choose any representative for the coset of preimages. Of course the quotient of two representatives lies in the kernel of the homomorphism.

rep:= Representative( coset ); (2,8,6,7,3,4,5) gap> x * rep^-1 in ker; true ]]>

The factor group f is a simple group, i.e., it has no non-trivial normal subgroups. ⪆ can detect this fact, and it can then also find the name by which this simple group is known among group theorists. (Such names are of course not available for non-simple groups.)

IsSimple( f ); IsomorphismTypeInfoFiniteSimpleGroup( f ); true rec( name := "A(1,7) = L(2,7) ~ B(1,7) = O(3,7) ~ C(1,7) = S(2,7) ~ 2A(1,\ 7) = U(2,7) ~ A(2,2) = L(3,2)", parameter := [ 2, 7 ], series := "L" ) gap> SetName( f, "L_3(2)" ); ]]>

We give f the name L_3(2) because the last part of the name string reveals that it is isomorphic to the simple linear group L_3(2). This group, however, also has a lot of other names. Names that are connected with a = sign are different names for the same matrix group, e.g., A(2,2) is the Lie type notation for the classical notation L(3,2). Other pairs of names are connected via ~, these then specify other classical groups that are isomorphic to that linear group (e.g., the symplectic group S(2,7), whose Lie type notation would be C(1,7)).

The group norm acts on the eight elements of its normal subgroup elab by conjugation, yielding a representation of L_3(2) in s8 which leaves one point fixed (namely point 1). The image of this representation can be computed with the function ; it is even contained in the group norm and we can show that norm is indeed a split extension of the elementary abelian group 2^3 with this image of L_3(2).

op := Action( norm, elab ); Group([ (), (), (), (5,6)(7,8), (5,7)(6,8), (3,4)(7,8), (3,5)(4,6), (2,3)(6,7) ]) gap> IsSubgroup( a8, op ); IsSubgroup( norm, op ); true true gap> IsTrivial( Intersection( elab, op ) ); true gap> SetName( norm, "2^3:L_3(2)" ); ]]>

By the way, you should not try the operator < instead of the function . Something like

elab < a8; false ]]>

will not cause an error, but the result does not signify anything about the inclusion of one group in another; < tests which of the two groups is less in some total order. On the other hand, the equality operator = in fact does test the equality of its arguments.

Summary. In this section we have used the elementary group functions to determine the structure of a normalizer. We have assigned names to the involved groups which reflect their mathematical structure and &GAP; uses these names when printing the groups.

Actions of Groups In order to get another representation of a8, we consider another action, namely that on the elements of a certain conjugacy class by conjugation.

In the following example we temporarily increase the line length limit from its default value 80 to 82 in order to make the long expression fit into one line.

ccl := ConjugacyClasses( a8 );; Length( ccl ); 14 gap> List( ccl, c -> Order( Representative( c ) ) ); [ 1, 2, 2, 3, 6, 3, 4, 4, 5, 15, 15, 6, 7, 7 ] gap> List( ccl, Size ); [ 1, 210, 105, 112, 1680, 1120, 2520, 1260, 1344, 1344, 1344, 3360, 2880, 2880 ] ]]>

Note the difference between (which means the element order), (which means the size of the conjugacy class) and (which means the length of a list). We choose to let a8 operate on the class of length 112.

class := First( ccl, c -> Size(c) = 112 );; gap> op := Action( a8, AsList( class ),OnPoints );; ]]>

We use here to convert the conjugacy class into a list of its elements whereas we wrote Action( norm, elab ) directly in the previous section. The reason is that the elementary abelian group elab can be quickly enumerated by &GAP; whereas the standard enumeration method for conjugacy classes is slower than just explicit calculation of the elements. However, &GAP; is reluctant to construct explicit element lists, because for really large groups this direct method is infeasible.

Note also the function , used to find the first element in a list which passes some test.

In this example, we have specified the action function in this example, which is defined as OnPoints( d, g ) = d ^ g. This caret operator denotes conjugation in a group if both arguments d and g are group elements (contained in a common group), but it also denotes the natural action of permutations on positive integers (and exponentiation of integers as well, of course). It is in fact the default action and will be supplied by the system if not given. Another common action is for example always assumes , which means right multiplication, defined as d * g. (Group actions in &GAP; are always from the right.)

We now have a permutation representation op on 112 points, which we test for primitivity. If it is not primitive, we can obtain a minimal block system (i.e., one where the blocks have minimal length) by the function .

IsPrimitive( op, [ 1 .. 112 ] ); false gap> blocks := Blocks( op, [ 1 .. 112 ] );; ]]>

Note that we must specify the domain of the action. You might think that the functions and could use [ 1 .. 112 ] as default domain if no domain was given. But this is not so easy, for example would the default domain of Group( (2,3,4) ) be [ 1 .. 4 ] or [ 2 .. 4 ]? To avoid confusion, all action functions require that you specify the domain of action. If we had specified [ 1 .. 113 ] in the primitivity test above, point 113 would have been a fixpoint (and the action would not even have been transitive).

Now blocks is a list of blocks (i.e., a list of lists), which we do not print here for the sake of saving paper (try it for yourself). In fact all we want to know is the size of the blocks, or rather how many there are (the product of these two numbers must of course be 112). Then we can obtain a new permutation group of the corresponding degree by letting op act on these blocks setwise.

Length( blocks[1] ); Length( blocks ); 2 56 gap> op2 := Action( op, blocks, OnSets );; gap> IsPrimitive( op2, [ 1 .. 56 ] ); true ]]>

Note that we give a third argument (the action function ) to indicate that the action is not the default action on points but an action on sets of elements given as sorted lists. (Section  lists all actions that are pre-defined by &GAP;.)

The action of op on the given block system gave us a new representation on 56 points which is primitive, i.e., the point stabilizer is a maximal subgroup. We compute its preimage in the representation on eight points using the associated action homomorphisms (which of course in this case are monomorphisms). We construct the composition of two homomorphisms with the * operator, reading left-to-right.

ophom := ActionHomomorphism( a8, op );; gap> ophom2 := ActionHomomorphism( op, op2 );; gap> composition := ophom * ophom2;; gap> stab := Stabilizer( op2, 2 );; gap> preim := PreImages( composition, stab ); Group([ (1,4,2), (3,6,7), (3,8,5,7,6), (1,4)(7,8) ]) ]]>

Alternatively, it is possible to create action homomorphisms immediately (without creating the action first) by giving the same set of arguments to . nophom := ActionHomomorphism( a8, AsList(class) ); gap> IsSurjective(nophom); false gap> Image(nophom,(1,2,3)); (2,43,14)(3,44,20)(4,45,26)(5,46,32)(6,47,38)(8,13,48)(9,19,53)(10,25, 58)(11,31,63)(12,37,68)(15,49,73)(16,50,74)(17,51,75)(18,52,76)(21,54, 77)(22,55,78)(23,56,79)(24,57,80)(27,59,81)(28,60,82)(29,61,83)(30,62, 84)(33,64,85)(34,65,86)(35,66,87)(36,67,88)(39,69,89)(40,70,90)(41,71, 91)(42,72,92) ]]>

In this situation, however (for performance reasons, avoiding computation an image that might never be needed) the homomorphism is defined to be not into the Image of the action, but into the full symmetric group, i.e. it is not automatically surjective. Surjectivity can be enforced by giving the string "surjective" as an extra last argument. The Image of the action homomorphism of course is the same group in either case. Size(Range(nophom)); 1974506857221074023536820372759924883412778680349753377966562950949028\ 5896977181144089422435502777936659795733823785363827233491968638562181\ 1850780464277094400000000000000000000000000 gap> Size(Range(ophom)); 20160 gap> nophom := ActionHomomorphism( a8, AsList(class),"surjective" ); gap> Size(Range(nophom)); 20160 ]]>

Continuing the example, the normalizer of an element in the conjugacy class class is a group of order 360, too. In fact, it is a conjugate of the maximal subgroup we had found before, and a conjugating element in a8 is found by the function .

sgp := Normalizer( a8, Subgroup(a8,[Representative(class)]) );; gap> Size( sgp ); 360 gap> RepresentativeAction( a8, sgp, preim ); (2,4,3) ]]>

homomorphism homomorphism enumerator transversal canonical position One of the most prominent actions of a group is on the cosets of a subgroup. Naïvely this can be done by constructing the cosets and acting on them by right multiplication. cosets:=RightCosets(a8,norm);; gap> op:=Action(a8,cosets,OnRight); Group([ (1,2,3)(4,6,5)(7,8,9)(10,12,11)(13,14,15), (1,3,2)(4,9,13)(5,11,7)(6,15,10)(8,12,14), (1,13)(2,7)(3,10)(4,11)(5,15)(6,9), (1,8,13)(2,7,12)(3,9,5)(4,14,11)(6,10,15), (2,3)(4,14)(5,7)(8,13)(9,12)(10,15), (1,8)(2,3,11,6)(4,12,10,15)(5,7,14,9) ]) gap> NrMovedPoints(op); 15 ]]>

A problem with this approach is that creating (and storing) all cosets can be very memory intensive if the subgroup index gets large. Because of this, &GAP; provides special objects which act like a list of elements, but do not actually store elements but compute them on the go. Such a simulated list is called an enumerator. The easiest example of this concept is the of a group. While it behaves like a list of elements, it requires far less storage, and is applicable to potentially huge groups for which it would be completely infeasible to write down all elements: enum:=Enumerator(SymmetricGroup(20)); gap> Length(enum); 2432902008176640000 gap> enum[123456789012345]; (1,4,15,3,14,11,8,17,6,18,5,7,20,13,10,9,2,12) gap> Position(enum,(1,2,3,4,5,6,7,8,9,10)); 71948729603 ]]>

For the action on cosets the object of interest is the of a subgroup. Again, it does not write out actual elements and thus can be created even for subgroups of large index. t:=RightTransversal(a8,norm); RightTransversal(Alt( [ 1 .. 8 ] ),2^3:L_3(2)) gap> t[7]; (4,6,5) gap> Position(t,(4,6,7,8,5)); 8 gap> Position(t,(1,2,3)); fail ]]>

For the action on cosets there is the added complication that not every group element is in the transversal (as the last example shows) but the action on cosets of a subgroup usually will not preserve a chosen set of coset representatives. Because of this issue, all action functionality actually uses instead of . In general, for elements contained in a list, returns the same as Position. If the element is not contained in the list (and for special lists, such as transversals), PositionCanonical returns the list element representing the same objects, e.g. the transversal element representing the same coset. PositionCanonical(t,(1,2,3)); 2 gap> t[2]; (6,7,8) gap> t[2]/(1,2,3); (1,3,2)(6,7,8) gap> last in norm; true ]]> Thus, acting on a RightTransversal with the OnRight action will in fact (in a slight abuse of definitions) produce the action of a group on cosets of a subgroup and is in general the most efficient way of creating this action. Action(a8,RightTransversal(a8,norm),OnRight); Group([ (1,2,3)(4,6,5)(7,8,9)(10,12,11)(13,14,15), (1,3,2)(4,9,13)(5,11,7)(6,15,10)(8,12,14), (1,13)(2,7)(3,10)(4,11)(5,15)(6,9), (1,8,13)(2,7,12)(3,9,5)(4,14,11)(6,10,15), (2,3)(4,14)(5,7)(8,13)(9,12)(10,15), (1,8)(2,3,11,6)(4,12,10,15)(5,7,14,9) ]) ]]>

Summary. In this section we have learned how groups can operate on &GAP; objects such as integers and group elements. We have used , among others, to construct the corresponding actions and homomorphisms and have seen how transversals can be used to create the action on cosets of a subgroup.

Subgroups as Stabilizers Action functions can also be used without constructing external sets. We will try to find several subgroups in a8 as stabilizers of such actions. One subgroup is immediately available, namely the stabilizer of one point. The index of the stabilizer must of course be equal to the length of the orbit, i.e., 8.

u8 := Stabilizer( a8, 1 ); Group([ (2,3,4), (2,4)(3,5), (2,6,4), (2,4)(5,7), (2,8,6,4)(3,5) ]) gap> Index( a8, u8 ); 8 gap> Orbit( a8, 1 ); Length( last ); [ 1, 3, 2, 4, 5, 6, 7, 8 ] 8 ]]>

This gives us a hint how to find further subgroups. Each subgroup is the stabilizer of a point of an appropriate transitive action (namely the action on the cosets of that subgroup or another action that is equivalent to this action). So the question is how to find other actions. The obvious thing is to operate on pairs of points. So using the function we first generate a list of all pairs.

pairs := Tuples( [1..8], 2 );; ]]>

Now we would like to have a8 operate on this domain. But we cannot use the default action because powering a list by a permutation via the caret operator ^ is not defined. So we must tell the functions from the actions package how the group elements operate on the elements of the domain (here and below, the word package refers to the &GAP; functionality for group actions, not to a &GAP; package). In our example we can do this by simply passing as an optional last argument. All functions from the actions package accept such an optional argument that describes the action. One example is .

IsTransitive( a8, pairs, OnPairs ); false ]]>

The action is of course not transitive, since the pairs [ 1, 1 ] and [ 1, 2 ] cannot lie in the same orbit. So we want to find out what the orbits are. The function does that for us. It returns a list of all the orbits. We look at the orbit lengths and representatives for the orbits.

orbs := Orbits( a8, pairs, OnPairs );; Length( orbs ); 2 gap> List( orbs, Length ); [ 8, 56 ] gap> List( orbs, o -> o[1] ); [ [ 1, 1 ], [ 1, 2 ] ] ]]>

The action of a8 on the first orbit (this is the one containing [1,1], try [1,1] in orbs[1]) is of course equivalent to the original action, so we ignore it and work with the second orbit.

u56 := Stabilizer( a8, orbs[2][1], OnPairs );; Index( a8, u56 ); 56 ]]>

So now we have found a second subgroup. To make the following computations a little bit easier and more efficient we would now like to work on the points [ 1 .. 56 ] instead of the list of pairs. The function does what we need. It creates a homomorphism defined on a8 whose image is a new group that acts on [ 1 .. 56 ] in the same way that a8 acts on the second orbit.

h56 := ActionHomomorphism( a8, orbs[2], OnPairs );; gap> a8_56 := Image( h56 );; ]]>

We would now like to know if the subgroup u56 of index 56 that we found is maximal or not. As we have used already in Section , a subgroup is maximal if and only if the action on the cosets of this subgroup is primitive.

IsPrimitive( a8_56, [1..56] ); false ]]>

Remember that we can leave out the function if we mean but that we have to specify the action domain for all action functions.

We see that a8_56 is not primitive. This means of course that the action of a8 on orb[2] is not primitive, because those two actions are equivalent. So the stabilizer u56 is not maximal. Let us try to find its supergroups. We use the function to find a block system. The (optional) third argument in the following example tells that we want a block system where 1 and 14 lie in one block.

blocks := Blocks( a8_56, [1..56], [1,14] ); [ [ 1, 3, 4, 5, 6, 14, 31 ], [ 2, 13, 15, 16, 17, 23, 24 ], [ 7, 8, 22, 34, 37, 47, 49 ], [ 9, 11, 18, 20, 35, 38, 48 ], [ 10, 25, 26, 27, 32, 39, 50 ], [ 12, 28, 29, 30, 33, 36, 40 ], [ 19, 21, 42, 43, 45, 46, 55 ], [ 41, 44, 51, 52, 53, 54, 56 ] ] ]]>

The result is a list of sets, such that a8_56 acts on those sets. Now we would like the stabilizer of this action on the sets. Because we want to operate on the sets we have to pass as third argument.

u8_56 := Stabilizer( a8_56, blocks[1], OnSets );; gap> Index( a8_56, u8_56 ); 8 gap> u8b := PreImages( h56, u8_56 );; Index( a8, u8b ); 8 gap> IsConjugate( a8, u8, u8b ); true ]]>

So we have found a supergroup of u56 that is conjugate in a8 to u8. This is not surprising, since u8 is a point stabilizer, and u56 is a two point stabilizer in the natural action of a8 on eight points.

Here is a warning: If you specify as third argument to a function like , you have to make sure that the point (i.e. the second argument) is indeed a set. Otherwise you will get a puzzling error message or even wrong results! In the above example, the second argument blocks[1] came from the function , which returns a list of sets, so everything was OK.

Actually there is a third block system of a8_56 that gives rise to a third subgroup.

blocks := Blocks( a8_56, [1..56], [1,13] );; gap> u28_56 := Stabilizer( a8_56, [1,13], OnSets );; gap> u28 := PreImages( h56, u28_56 );; gap> Index( a8, u28 ); 28 ]]>

We know that the subgroup u28 of index 28 is maximal, because we know that a8 has no subgroups of index 2, 4, or 7. However we can also quickly verify this by checking that a8_56 acts primitively on the 28 blocks.

IsPrimitive( a8_56, blocks, OnSets ); true ]]>

is not only applicable to groups like a8 but also to their subgroups like u56. So another method to find a new subgroup is to compute the stabilizer of another point in u56. Note that u56 already leaves 1 and 2 fixed.

u336 := Stabilizer( u56, 3 );; gap> Index( a8, u336 ); 336 ]]>

Other functions are also applicable to subgroups. In the following we show that u336 acts regularly on the 60 triples of [ 4 .. 8 ] which contain no element twice. We construct the list of these 60 triples with the function (using as the natural generalization of ) and then pass it as action domain to the function . The positive result of the regularity test means that this action is equivalent to the actions of u336 on its 60 elements from the right.

IsRegular( u336, Orbit( u336, [4,5,6], OnTuples ), OnTuples ); true ]]>

Just as we did in the case of the action on the pairs above, we now construct a new permutation group that acts on [ 1 .. 336 ] in the same way that a8 acts on the cosets of u336. But this time we let a8 operate on a right transversal, just like norm did in the natural homomorphism above.

t := RightTransversal( a8, u336 );; gap> a8_336 := Action( a8, t, OnRight );; ]]>

To find subgroups above u336 we again look for nontrivial block systems.

blocks := Blocks( a8_336, [1..336] );; blocks[1]; [ 1, 43, 85 ] ]]>

We see that the union of u336 with its 43rd and its 85th coset is a subgroup in a8_336, its index is 112. We can obtain it as the closure of u336 with a representative of the 43rd coset, which can be found as the 43rd element of the transversal t. Note that in the representation a8_336 on 336 points, this subgroup corresponds to the stabilizer of the block [ 1, 43, 85 ].

u112 := ClosureGroup( u336, t[43] );; gap> Index( a8, u112 ); 112 ]]>

Above this subgroup of index 112 lies a subgroup of index 56, which is not conjugate to u56. In fact, unlike u56 it is maximal. We obtain this subgroup in the same way that we obtained u112, this time forcing two points, namely 7 and 43 into the first block.

blocks := Blocks( a8_336, [1..336], [1,7,43] );; gap> Length( blocks ); 56 gap> u56b := ClosureGroup( u112, t[7] );; Index( a8, u56b ); 56 gap> IsPrimitive( a8_336, blocks, OnSets ); true ]]>

We already mentioned in Section  that there is another standard action of permutations, namely the conjugation. E.g., since no other action is specified in the following example, simply acts via , and because perm_1 ^ perm_2 is defined as the conjugation of perm_2 on perm_1, in fact we compute the length of the conjugacy class of (1,2)(3,4)(5,6)(7,8).

OrbitLength( a8, (1,2)(3,4)(5,6)(7,8) ); 105 gap> orb := Orbit( a8, (1,2)(3,4)(5,6)(7,8) );; gap> u105 := Stabilizer( a8, (1,2)(3,4)(5,6)(7,8) );; Index( a8, u105 ); 105 ]]>

Note that although the length of a conjugacy class of any element g in any finite group G can be computed as OrbitLength( G, g ), the command Size( ConjugacyClass( G, g ) ) is probably more efficient.

Size( ConjugacyClass( a8, (1,2)(3,4)(5,6)(7,8) ) ); 105 ]]>

Of course the stabilizer u105 is in fact the centralizer of the element (1,2)(3,4)(5,6)(7,8). notices that and computes the stabilizer using the centralizer algorithm for permutation groups. In the usual way we now look for the subgroups above u105.

blocks := Blocks( a8, orb );; Length( blocks ); 15 gap> blocks[1]; [ (1,2)(3,4)(5,6)(7,8), (1,3)(2,4)(5,8)(6,7), (1,4)(2,3)(5,7)(6,8), (1,5)(2,6)(3,8)(4,7), (1,6)(2,5)(3,7)(4,8), (1,7)(2,8)(3,6)(4,5), (1,8)(2,7)(3,5)(4,6) ] ]]>

To find the subgroup of index 15 we again use closure. Now we must be a little bit careful to avoid confusion. u105 is the stabilizer of (1,2)(3,4)(5,6)(7,8). We know that there is a correspondence between the points of the orbit and the cosets of u105. The point (1,2)(3,4)(5,6)(7,8) corresponds to u105. To get the subgroup above u105 that has index 15 in a8, we must form the closure of u105 with an element of the coset that corresponds to any other point in the first block. If we choose the point (1,3)(2,4)(5,8)(6,7), we must use an element of a8 that maps (1,2)(3,4)(5,6)(7,8) to (1,3)(2,4)(5,8)(6,7). The function does what we need. It takes a group and two points and returns an element of the group that maps the first point to the second. In fact it also allows you to specify the action as an optional fourth argument as usual, but we do not need this here. If no such element exists in the group, i.e., if the two points do not lie in one orbit under the group, returns fail.

rep := RepresentativeAction( a8, (1,2)(3,4)(5,6)(7,8), > (1,3)(2,4)(5,8)(6,7) ); (2,3)(6,8) gap> u15 := ClosureGroup( u105, rep );; Index( a8, u15 ); 15 ]]>

u15 is of course a maximal subgroup, because a8 has no subgroups of index 3 or 5. There is in fact another class of subgroups of index 15 above u105 that we get by adding (2,3)(6,7) to u105.

u15b := ClosureGroup( u105, (2,3)(6,7) );; Index( a8, u15b ); 15 gap> RepresentativeAction( a8, u15, u15b ); fail ]]>

tells us that there is no element g in a8 such that u15 ^ g = u15b. Because ^ also denotes the conjugation of subgroups this tells us that u15 and u15b are not conjugate.

Summary. In this section we have demonstrated some functions from the actions package. There is a whole class of functions that we did not mention, namely those that take a single element instead of a whole group as first argument, e.g., and . These are fully described in Chapter .

Group Homomorphisms by Images We have already seen examples of group homomorphisms in the last sections, namely natural homomorphisms and action homomorphisms. In this section we will show how to construct a group homomorphism G \rightarrow H by specifying a generating set for G and the images of these generators in H. We use the function GroupHomomorphismByImages( G, H, gens, imgs ) where gens is a generating set for G and imgs is a list whose ith entry is the image of gens[i] under the homomorphism.

s4 := Group((1,2,3,4),(1,2));; s3 := Group((1,2,3),(1,2));; gap> hom := GroupHomomorphismByImages( s4, s3, > GeneratorsOfGroup(s4), [(1,2),(2,3)] ); [ (1,2,3,4), (1,2) ] -> [ (1,2), (2,3) ] gap> Kernel( hom ); Group([ (1,4)(2,3), (1,3)(2,4) ]) gap> Image( hom, (1,2,3) ); (1,2,3) gap> Image( hom, DerivedSubgroup(s4) ); Group([ (1,3,2), (1,2,3) ]) ]]>

PreImage( hom, (1,2,3) ); Error, must be an inj. and surj. mapping called from ( ) called from read-eval-loop Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can 'return;' to continue brk> quit; ]]>

PreImagesRepresentative( hom, (1,2,3) ); (1,4,2) gap> PreImage( hom, TrivialSubgroup(s3) ); # the kernel Group([ (1,4)(2,3), (1,3)(2,4) ]) ]]>

This homomorphism from S_4 onto S_3 is well known from elementary group theory. Images of elements and subgroups under hom can be calculated with the function . But since the mapping hom is not bijective, we cannot use the function for preimages of elements (they can have several preimages). Instead, we have to use , which returns one preimage if at least one exists (and would return fail if none exists, which cannot occur for our surjective hom). On the other hand, we can use for the preimage of a set (which always exists, even if it is empty).

Suppose we mistype the input when trying to construct a homomorphism as below.

GroupHomomorphismByImages( s4, s3, > GeneratorsOfGroup(s4), [(1,2,3),(2,3)] ); fail ]]>

There is no such homomorphism, hence fail is returned. But note that because of this, must do some checks, and this was also done for the mapping hom above. One can avoid these checks if one is sure that the desired homomorphism really exists. For that, the function can be used; the NC stands for no check.

But note that horrible things can happen if is used when the input does not describe a homomorphism.

hom2 := GroupHomomorphismByImagesNC( s4, s3, > GeneratorsOfGroup(s4), [(1,2,3),(2,3)] ); [ (1,2,3,4), (1,2) ] -> [ (1,2,3), (2,3) ] gap> Size( Kernel(hom2) ); 24 ]]>

In other words, &GAP; claims that the kernel is the full s4, yet hom2 obviously has some non-trivial images! Clearly there is no such thing as a homomorphism which maps an element of order 4 (namely, (1,2,3,4)) to an element of order 3 (namely, (1,2,3)). But if you use the command , &GAP; trusts you.

IsGroupHomomorphism( hom2 ); true ]]>

And then it produces serious nonsense if the thing is not a homomorphism, as seen above!

Besides the safe command , which returns fail if the requested homomorphism does not exist, there is the function , which returns a general mapping (that is, a possibly multi-valued mapping) that can be tested with .

hom2 := GroupGeneralMappingByImages( s4, s3, > GeneratorsOfGroup(s4), [(1,2,3),(2,3)] );; gap> IsGroupHomomorphism( hom2 ); false ]]>

group general mappingcokernelkernel GroupHomomorphismByImages vs. GroupGeneralMappingByImages But the possibility of testing for being a homomorphism is not the only reason why &GAP; offers group general mappings. Another (more important?) reason is that their existence allows reversal of arrows in a homomorphism such as our original hom. By this we mean the with left and right sides exchanged, in which case it is of course merely a .

rev := GroupGeneralMappingByImages( s3, s4, > [(1,2),(2,3)], GeneratorsOfGroup(s4) );; ]]>

Now hom maps a to b if and only if rev maps b to a, for a \in s4 and b \in s3. Since every such b has four preimages under hom, it now has four images under rev. Just as the four preimages form a coset of the kernel V_4 \leq s4 of hom, they also form a coset of the cokernel V_4 \leq s4 of rev. The cokernel itself is the set of all images of One( s3 ). (It is a normal subgroup in the group of all images under rev.) The operation returns the identity element of a group. And this is why &GAP; wants to perform such a reversal of arrows: it calculates the kernel of a homomorphism like hom as the cokernel of the reversed group general mapping (here rev).

CoKernel( rev ); Group([ (1,4)(2,3), (1,3)(2,4) ]) ]]>

group general mapping group general mapping The reason why rev is not a homomorphism is that it is not single-valued (because hom was not injective). But there is another critical condition: If we reverse the arrows of a non-surjective homomorphism, we obtain a group general mapping which is not defined everywhere, i.e., which is not total (although it will be single-valued if the original homomorphism is injective). &GAP; requires that a group homomorphism be both single-valued and total, so you will get fail if you say GroupHomomorphismByImages( G, H, gens, imgs ) where gens does not generate G (even if this would give a decent homomorphism on the subgroup generated by gens). For a full description, see Chapter .

The last example of this section shows that the notion of kernel and cokernel naturally extends even to the case where neither hom2 nor its inverse general mapping (with arrows reversed) is a homomorphism.

CoKernel( hom2 ); Kernel( hom2 ); Group([ (2,3), (1,3) ]) Group([ (3,4), (2,3,4), (1,2,4) ]) gap> IsGroupHomomorphism( InverseGeneralMapping( hom2 ) ); false ]]>

Summary. In this section we have constructed homomorphisms by specifying images for a set of generators. We have seen that by reversing the direction of the mapping, we get group general mappings, which need not be single-valued (unless the mapping was injective) nor total (unless the mapping was surjective).

Nice Monomorphisms For some types of groups, the best method to calculate in an isomorphic group in a better representation (say, a permutation group). We call an injective homomorphism, that will give such an isomorphic image a nice monomorphism.

For example in the case of a matrix group we can take the action on the underlying vector space (or a suitable subset) to obtain such a monomorphism:

grp:=GL(2,3);; gap> dom:=GF(3)^2;; gap> hom := ActionHomomorphism( grp, dom );; IsInjective( hom ); true gap> p := Image( hom,grp ); Group([ (4,7)(5,8)(6,9), (2,7,6)(3,4,8) ]) ]]>

To demonstrate the technique of nice monomorphisms, we compute the conjugacy classes of the permutation group and lift them back into the matrix group with the monomorphism hom. Lifting back a conjugacy class means finding the preimage of the representative and of the centralizer; the latter is called in &GAP; (because conjugacy classes are represented as external sets, see Section ).

pcls := ConjugacyClasses( p );; gcls := [ ];; gap> for pc in pcls do > gc:=ConjugacyClass(grp, > PreImagesRepresentative(hom,Representative(pc))); > SetStabilizerOfExternalSet(gc,PreImage(hom, > StabilizerOfExternalSet(pc))); > Add( gcls, gc ); > od; gap> List( gcls, Size ); [ 1, 8, 12, 1, 8, 6, 6, 6 ] ]]>

All the steps we have made above are automatically performed by &GAP; if you simply ask for ConjugacyClasses( grp ), provided that &GAP; already knows that grp is finite (e.g., because you asked IsFinite( grp ) before). The reason for this is that a finite matrix group like grp is handled by a nice monomorphism. For such groups, &GAP; uses the command to construct a monomorphism (such as the hom in the previous example) and then proceeds as we have done above.

grp:=GL(2,3);; gap> IsHandledByNiceMonomorphism( grp ); true gap> hom := NiceMonomorphism( grp ); gap> p :=Image(hom,grp); Group([ (4,7)(5,8)(6,9), (2,7,6)(3,4,8) ]) gap> cc := ConjugacyClasses( grp );; ForAll(cc, x-> x in gcls); true gap> ForAll(gcls, x->x in cc); # cc and gcls might be ordered differently true ]]>

Note that a nice monomorphism might be defined on a larger group than grp –so we have to use Image( hom, grp ) and not only Image( hom ).

Nice monomorphisms are not only used for matrix groups, but also for other kinds of groups in which one cannot calculate easily enough. As another example, let us show that the automorphism group of the quaternion group of order 8 is isomorphic to the symmetric group of degree 4 by examining the nice object associated with that automorphism group.

p:=Group((1,7,6,8)(2,5,3,4), (1,2,6,3)(4,8,5,7));; gap> aut := AutomorphismGroup( p );; NiceMonomorphism(aut);; gap> niceaut := NiceObject( aut ); Group([ (1,4,2,3), (1,5,4)(2,6,3), (1,2)(3,4), (3,4)(5,6) ]) gap> IsomorphismGroups( niceaut, SymmetricGroup( 4 ) ); [ (1,4,2,3), (1,5,4)(2,6,3), (1,2)(3,4), (3,4)(5,6) ] -> [ (1,3,4,2), (1,4,2), (1,4)(2,3), (1,2)(3,4) ] ]]>

The range of a nice monomorphism is in most cases a permutation group, because nice monomorphisms are mostly action homomorphisms. In some cases, like in our last example, the group is solvable and you might prefer a pc group as nice object. You cannot change the nice monomorphism of the automorphism group (because it is the value of the attribute ), but you can compose it with an isomorphism from the permutation group to a pc group to obtain your personal nicer monomorphism. If you reconstruct the automorphism group, you can even prescribe it this nicer monomorphism as its , because a newly-constructed group will not yet have a set.

nicer := NiceMonomorphism(aut) * IsomorphismPcGroup(niceaut);; gap> aut2 := GroupByGenerators( GeneratorsOfGroup( aut ) );; gap> SetIsHandledByNiceMonomorphism( aut2, true ); gap> SetNiceMonomorphism( aut2, nicer ); gap> NiceObject( aut2 ); # a pc group Group([ f1*f2, f2^2*f3, f4, f3 ]) ]]>

The star * denotes composition of mappings from the left to the right, as we have seen in Section above. Reconstructing the automorphism group may of course result in the loss of other information &GAP; had already gathered, besides the (not-so-)nice monomorphism.

Summary. In this section we have seen how calculations in groups can be carried out in isomorphic images in nicer groups. We have seen that &GAP; pursues this technique automatically for certain classes of groups, e.g., for matrix groups that are known to be finite.

Further Information about Groups and Homomorphisms Groups and the functions for groups are treated in Chapter . There are several chapters dealing with groups in specific representations, for example Chapter  on permutation groups, on polycyclic (including finite solvable) groups, on matrix groups and on finitely presented groups. Chapter  deals with group actions. Group homomorphisms are the subject of Chapter .
gap-4r6p5/doc/tut/lists.xml0000644000175000017500000012040512172557252014404 0ustar billbill

Lists and Records arrays, see lists Modern mathematics, especially algebra, is based on set theory. When sets are represented in a computer, they inadvertently turn into lists. That's why we start our survey of the various objects &GAP; can handle with a description of lists and their manipulation. &GAP; regards sets as a special kind of lists, namely as lists without holes or duplicates whose entries are ordered with respect to the precedence relation <.

After the introduction of the basic manipulations with lists in , some difficulties concerning identity and mutability of lists are discussed in  and . Sets, ranges, row vectors, and matrices are introduced as special kinds of lists in , , . Handy list operations are shown in . Finally we explain how to use records in .

Plain Lists lists A list is a collection of objects separated by commas and enclosed in brackets. Let us for example construct the list primes of the first ten prime numbers.

primes:= [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]; [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 ] ]]>

The next two primes are 31 and 37. They may be appended to the existing list by the function Append which takes the existing list as its first and another list as a second argument. The second argument is appended to the list primes and no value is returned. Note that by appending another list the object primes is changed.

Append(primes, [31, 37]); gap> primes; [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37 ] ]]>

You can as well add single new elements to existing lists by the function Add which takes the existing list as its first argument and a new element as its second argument. The new element is added to the list primes and again no value is returned but the list primes is changed.

Add(primes, 41); gap> primes; [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41 ] ]]>

Single elements of a list are referred to by their position in the list. To get the value of the seventh prime, that is the seventh entry in our list primes, you simply type

primes[7]; 17 ]]>

This value can be handled like any other value, for example multiplied by 2 or assigned to a variable. On the other hand this mechanism allows one to assign a value to a position in a list. So the next prime 43 may be inserted in the list directly after the last occupied position of primes. This last occupied position is returned by the function Length.

Length(primes); 13 gap> primes[14]:= 43; 43 gap> primes; [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43 ] ]]>

Note that this operation again has changed the object primes. The next position after the end of a list is not the only position capable of taking a new value. If you know that 71 is the 20th prime, you can enter it right now in the 20th position of primes. This will result in a list with holes which is however still a list and now has length 20.

primes[20]:= 71; 71 gap> primes; [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43,,,,,, 71 ] gap> Length(primes); 20 ]]>

The list itself however must exist before a value can be assigned to a position of the list. This list may be the empty list [ ].

lll[1]:= 2; Error, Variable: 'lll' must have a value gap> lll:= []; lll[1]:= 2; [ ] 2 ]]>

Of course existing entries of a list can be changed by this mechanism, too. We will not do it here because primes then may no longer be a list of primes. Try for yourself to change the 17 in the list into a 9.

To get the position of 17 in the list primes use the function which takes the list as its first argument and the element as its second argument and returns the position of the first occurrence of the element 17 in the list primes. If the element is not contained in the list then will return the special object fail.

Position(primes, 17); 7 gap> Position(primes, 20); fail ]]>

In all of the above changes to the list primes, the list has been automatically resized. There is no need for you to tell &GAP; how big you want a list to be. This is all done dynamically.

It is not necessary for the objects collected in a list to be of the same type.

lll:= [true, "This is a String",,, 3]; [ true, "This is a String",,, 3 ] ]]>

In the same way a list may be part of another list.

lll[3]:= [4,5,6];; lll; [ true, "This is a String", [ 4, 5, 6 ],, 3 ] ]]>

A list may even be part of itself.

lll[4]:= lll; [ true, "This is a String", [ 4, 5, 6 ], ~, 3 ] ]]>

Now the tilde in the fourth position of lll denotes the object that is currently printed. Note that the result of the last operation is the actual value of the object lll on the right hand side of the assignment. In fact it is identical to the value of the whole list lll on the left hand side of the assignment.

strings lists A string is a special type of list, namely a dense list of characters, where dense means that the list has no holes. Here, characters are special &GAP; objects representing an element of the character set of the operating system. The input of printable characters is by enclosing them in single quotes '. A string literal can either be entered as the list of characters or by writing the characters between doublequotes ". Strings are handled specially by . You can learn much more about strings in the reference manual.

s1 := ['H','a','l','l','o',' ','w','o','r','l','d','.']; "Hallo world." gap> s1 = "Hallo world."; true gap> s1[7]; 'w' ]]>

Sublists of lists can easily be extracted and assigned using the operator list{ positions }.

sl := lll{ [ 1, 2, 3 ] }; [ true, "This is a String", [ 4, 5, 6 ] ] gap> sl{ [ 2, 3 ] } := [ "New String", false ]; [ "New String", false ] gap> sl; [ true, "New String", false ] ]]>

This way you get a new list whose i-th entry is that element of the original list whose position is the i-th entry of the argument in the curly braces.

Identical Lists lists This second section about lists is dedicated to the subtle difference between equality and identity of lists. It is really important to understand this difference in order to understand how complex data structures are realized in &GAP;. This section applies to all &GAP; objects that have subobjects, e.g., to lists and to records. After reading the section  about records you should return to this section and translate it into the record context.

Two lists are equal if all their entries are equal. This means that the equality operator = returns true for the comparison of two lists if and only if these two lists are of the same length and for each position the values in the respective lists are equal.

numbers := primes;; numbers = primes; true ]]>

We assigned the list primes to the variable numbers and, of course they are equal as they have both the same length and the same entries. Now we will change the third number to 4 and compare the result again with primes.

numbers[3]:= 4;; numbers = primes; true ]]>

You see that numbers and primes are still equal, check this by printing the value of primes. The list primes is no longer a list of primes! What has happened? The truth is that the lists primes and numbers are not only equal but they are also identical. primes and numbers are two variables pointing to the same list. If you change the value of the subobject numbers[3] of numbers this will also change primes. Variables do not point to a certain block of storage memory but they do point to an object that occupies storage memory. So the assignment numbers := primes did not create a new list in a different place of memory but only created the new name numbers for the same old list of primes.

From this we see that the same object can have several names.

If you want to change a list with the contents of primes independently from primes you will have to make a copy of primes by the function ShallowCopy which takes an object as its argument and returns a copy of the argument. (We will first restore the old value of primes.)

primes[3]:= 5;; primes; [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43,,,,,, 71 ] gap> numbers:= ShallowCopy(primes);; numbers = primes; true gap> numbers[3]:= 4;; numbers = primes; false ]]>

Now numbers is no longer equal to primes and primes still is a list of primes. Check this by printing the values of numbers and primes.

Lists and records can be changed this way because &GAP; objects of these types have subobjects. To clarify this statement consider the following assignments.

i:= 1;; j:= i;; i:= i+1;; ]]>

By adding 1 to i the value of i has changed. What happens to j? After the second statement j points to the same object as i, namely to the integer 1. The addition does not change the object 1 but creates a new object according to the instruction i+1. It is actually the assignment that changes the value of i. Therefore j still points to the object 1. Integers (like permutations and booleans) have no subobjects. Objects of these types cannot be changed but can only be replaced by other objects. And a replacement does not change the values of other variables. In the above example an assignment of a new value to the variable numbers would also not change the value of primes.

Finally try the following examples and explain the results.

l:= [];; l:= [l]; [ [ ] ] gap> l[1]:= l; [ ~ ] ]]>

Now return to Section  and find out whether the functions and change their arguments.

Immutability &GAP; has a mechanism that protects lists against changes like the ones that have bothered us in Section . The function takes as argument a list and returns an immutable copy of it, i.e., a list which looks exactly like the old one, but has two extra properties: (1) The new list is immutable, i.e., the list itself and its subobjects cannot be changed. (2) In constructing the copy, every part of the list that can be changed has been copied, so that changes to the old list will not affect the new one. In other words, the new list has no mutable subobjects in common with the old list.

list := [ 1, 2, "three", [ 4 ] ];; copy := Immutable( list );; gap> list[3][5] := 'w';; list; copy; [ 1, 2, "threw", [ 4 ] ] [ 1, 2, "three", [ 4 ] ] gap> copy[3][5] := 'w'; Lists Assignment: must be a mutable list not in any function Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can 'return;' and ignore the assignment to continue brk> quit; ]]>

As a consequence of these rules, in the immutable copy of a list which contains an already immutable list as subobject, this immutable subobject need not be copied, because it is unchangeable. Immutable lists are useful in many complex &GAP; objects, for example as generator lists of groups. By making them immutable, &GAP; ensures that no generators can be added to the list, removed or exchanged. Such changes would of course lead to serious inconsistencies with other knowledge that may already have been calculated for the group.

A converse function to is , which produces a new mutable list whose i-th entry is the i-th entry of the old list. The single entries are not copied, they are just placed in the new list. If the old list is immutable, and hence the list entries are immutable themselves, the result of is mutable only on the top level.

It should be noted that also other objects than lists can appear in mutable or immutable form. Records (see Section ) provide another example.

Sets lists family &GAP; knows several special kinds of lists. A set in &GAP; is a list that contains no holes (such a list is called dense) and whose elements are strictly sorted w.r.t. <; in particular, a set cannot contain duplicates. (More precisely, the elements of a set in &GAP; are required to lie in the same family, but roughly this means that they can be compared using the < operator.)

This provides a natural model for mathematical sets whose elements are given by an explicit enumeration.

&GAP; also calls a set a strictly sorted list, and the function tests whether a given list is a set. It returns a boolean value. For almost any list whose elements are contained in the same family, there exists a corresponding set. This set is constructed by the function which takes the list as its argument and returns a set obtained from this list by ignoring holes and duplicates and by sorting the elements.

The elements of the sets used in the examples of this section are strings.

fruits:= ["apple", "strawberry", "cherry", "plum"]; [ "apple", "strawberry", "cherry", "plum" ] gap> IsSSortedList(fruits); false gap> fruits:= Set(fruits); [ "apple", "cherry", "plum", "strawberry" ] ]]>

Note that the original list fruits is not changed by the function . We have to make a new assignment to the variable fruits in order to make it a set.

The operator in is used to test whether an object is an element of a set. It returns a boolean value true or false.

"apple" in fruits; true gap> "banana" in fruits; false ]]>

The operator in can also be applied to ordinary lists. It is however much faster to perform a membership test for sets since sets are always sorted and a binary search can be used instead of a linear search. New elements may be added to a set by the function which takes the set fruits as its first argument and an element as its second argument and adds the element to the set if it wasn't already there. Note that the object fruits is changed.

AddSet(fruits, "banana"); gap> fruits; # The banana is inserted in the right place. [ "apple", "banana", "cherry", "plum", "strawberry" ] gap> AddSet(fruits, "apple"); gap> fruits; # fruits has not changed. [ "apple", "banana", "cherry", "plum", "strawberry" ] ]]>

Note that inserting new elements into a set with is usually more expensive than simply adding new elements at the end of a list.

Sets can be intersected by the function and united by the function which both take two sets as their arguments and return the intersection resp. union of the two sets as a new object.

breakfast:= ["tea", "apple", "egg"]; [ "tea", "apple", "egg" ] gap> Intersection(breakfast, fruits); [ "apple" ] ]]>

The arguments of the functions and could be ordinary lists, while their result is always a set. Note that in the preceding example at least one argument of was not a set. The functions and also form the intersection resp. union of two sets. They will however not return the result but change their first argument to be the result. Try them carefully.

Ranges A range is a finite arithmetic progression of integers. This is another special kind of list. A range is described by the first two values and the last value of the arithmetic progression which are given in the form [first,second..last]. In the usual case of an ascending list of consecutive integers the second entry may be omitted.

[1..999999]; # a range of almost a million numbers [ 1 .. 999999 ] gap> [1, 2..999999]; # this is equivalent [ 1 .. 999999 ] gap> [1, 3..999999]; # here the step is 2 [ 1, 3 .. 999999 ] gap> Length( last ); 500000 gap> [ 999999, 999997 .. 1 ]; [ 999999, 999997 .. 1 ] ]]>

This compact printed representation of a fairly long list corresponds to a compact internal representation. The function tests whether an object is a range, the function changes the representation of a list that is in fact a range to this compact internal representation.

a:= [-2,-1,0,1,2,3,4,5]; [ -2, -1, 0, 1, 2, 3, 4, 5 ] gap> IsRange( a ); true gap> ConvertToRangeRep( a );; a; [ -2 .. 5 ] gap> a[1]:= 0;; IsRange( a ); false ]]>

Note that this change of representation does not change the value of the list a. The list a still behaves in any context in the same way as it would have in the long representation.

For and While Loops loop loop

Given a list pp of permutations we can form their product by means of a for loop instead of writing down the product explicitly.

pp:= [ (1,3,2,6,8)(4,5,9), (1,6)(2,7,8), (1,5,7)(2,3,8,6), > (1,8,9)(2,3,5,6,4), (1,9,8,6,3,4,7,2)];; gap> prod:= (); () gap> for p in pp do > prod:= prod*p; > od; gap> prod; (1,8,4,2,3,6,5,9) ]]>

First a new variable prod is initialized to the identity permutation (). Then the loop variable p takes as its value one permutation after the other from the list pp and is multiplied with the present value of prod resulting in a new value which is then assigned to prod.

The for loop has the following syntax

for var in list do statements od;

The effect of the for loop is to execute the statements for every element of the list. A for loop is a statement and therefore terminated by a semicolon. The list of statements is enclosed by the keywords do and od (reverse do). A for loop returns no value. Therefore we had to ask explicitly for the value of prod in the preceding example.

The for loop can loop over any kind of list, even a list with holes. In many programming languages the for loop has the form

for var from first to last do statements od;

In &GAP; this is merely a special case of the general for loop as defined above where the list in the loop body is a range (see ):

for var in [first..last] do statements od;

You can for instance loop over a range to compute the factorial 15! of the number 15 in the following way.

ff:= 1; 1 gap> for i in [1..15] do > ff:= ff * i; > od; gap> ff; 1307674368000 ]]>

The while loop has the following syntax

while condition do statements od;

The while loop loops over the statements as long as the condition evaluates to true. Like the for loop the while loop is terminated by the keyword od followed by a semicolon.

We can use our list primes to perform a very simple factorization. We begin by initializing a list factors to the empty list. In this list we want to collect the prime factors of the number 1333. Remember that a list has to exist before any values can be assigned to positions of the list. Then we will loop over the list primes and test for each prime whether it divides the number. If it does we will divide the number by that prime, add it to the list factors and continue.

n:= 1333;; gap> factors:= [];; gap> for p in primes do > while n mod p = 0 do > n:= n/p; > Add(factors, p); > od; > od; gap> factors; [ 31, 43 ] gap> n; 1 ]]>

As n now has the value 1 all prime factors of 1333 have been found and factors contains a complete factorization of 1333. This can of course be verified by multiplying 31 and 43.

This loop may be applied to arbitrary numbers in order to find prime factors. But as primes is not a complete list of all primes this loop may fail to find all prime factors of a number greater than 2000, say. You can try to improve it in such a way that new primes are added to the list primes if needed.

You have already seen that list objects may be changed. This of course also holds for the list in a loop body. In most cases you have to be careful not to change this list, but there are situations where this is quite useful. The following example shows a quick way to determine the primes smaller than 1000 by a sieve method. Here we will make use of the function Unbind to delete entries from a list, and the if statement covered in .

primes:= [];; gap> numbers:= [2..1000];; gap> for p in numbers do > Add(primes, p); > for n in numbers do > if n mod p = 0 then > Unbind(numbers[n-1]); > fi; > od; > od; ]]>

The inner loop removes all entries from numbers that are divisible by the last detected prime p. This is done by the function Unbind which deletes the binding of the list position numbers[n-1] to the value n so that afterwards numbers[n-1] no longer has an assigned value. The next element encountered in numbers by the outer loop necessarily is the next prime.

In a similar way it is possible to enlarge the list which is looped over. This yields a nice and short orbit algorithm for the action of a group, for example.

More about for and while loops can be found in the sections  and .

List Operations There is a more comfortable way than that given in the previous section to compute the product of a list of numbers or permutations.

Product([1..15]); 1307674368000 gap> Product(pp); (1,8,4,2,3,6,5,9) ]]>

The function takes a list as its argument and computes the product of the elements of the list. This is possible whenever a multiplication of the elements of the list is defined. So executes a loop over all elements of the list.

There are other often used loops available as functions. Guess what the function does. The function may take a list and a function as its arguments. It will then apply the function to each element of the list and return the corresponding list of results. A list of cubes is produced as follows with the function cubed from Section .

cubed:= x -> x^3;; gap> List([2..10], cubed); [ 8, 27, 64, 125, 216, 343, 512, 729, 1000 ] ]]>

To add all these cubes we might apply the function to the last list. But we may as well give the function cubed to as an additional argument.

Sum(last) = Sum([2..10], cubed); true ]]>

The primes less than 30 can be retrieved out of the list primes from Section  by the function . This function takes the list primes and a property as its arguments and will return the list of those elements of primes which have this property. Such a property will be represented by a function that returns a boolean value. In this example the property of being less than 30 can be represented by the function x -> x < 30 since x < 30 will evaluate to true for values x less than 30 and to false otherwise.

Filtered(primes, x -> x < 30); [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 ] ]]>

We have already mentioned the operator { } that forms sublists. It takes a list of positions as its argument and will return the list of elements from the original list corresponding to these positions.

primes{ [1 .. 10] }; [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 ] ]]>

Finally we mention the function that checks whether a property holds for all elements of a list. It takes as its arguments a list and a function that returns a boolean value. checks whether the function returns true for all elements of the list.

list:= [ 1, 2, 3, 4 ];; gap> ForAll( list, x -> x > 0 ); true gap> ForAll( list, x -> x in primes ); false ]]>

You will find more predefined for loops in chapter .

Vectors and Matrices vectors matrices This section describes how &GAP; uses lists to represent row vectors and matrices. A row vector is a dense list of elements from a common field. A matrix is a dense list of row vectors over a common field and of equal length.

v:= [3, 6, 2, 5/2];; IsRowVector(v); true ]]>

Row vectors may be added and multiplied by scalars from their field. Multiplication of row vectors of equal length results in their scalar product.

2 * v; v * 1/3; [ 6, 12, 4, 5 ] [ 1, 2, 2/3, 5/6 ] gap> v * v; # the scalar product of `v' with itself 221/4 ]]>

Note that the expression v * 1/3 is actually evaluated by first multiplying v by 1 (which yields again v) and by then dividing by 3. This is also an allowed scalar operation. The expression v/3 would result in the same value.

Such arithmetical operations (if the results are again vectors) result in mutable vectors except if the operation is binary and both operands are immutable; thus the vectors shown in the examples above are all mutable.

So if you want to produce a mutable list with 100 entries equal to 25, you can simply say 25 + 0 * [ 1 .. 100 ]. Note that ranges are also vectors (over the rationals), and that [ 1 .. 100 ] is mutable.

A matrix is a dense list of row vectors of equal length.

m:= [[1,-1, 1], > [2, 0,-1], > [1, 1, 1]]; [ [ 1, -1, 1 ], [ 2, 0, -1 ], [ 1, 1, 1 ] ] gap> m[2][1]; 2 ]]>

Syntactically a matrix is a list of lists. So the number 2 in the second row and the first column of the matrix m is referred to as the first element of the second element of the list m via m[2][1].

A matrix may be multiplied by scalars, row vectors and other matrices. (If the row vectors and matrices involved in such a multiplication do not have suitable dimensions then the missing entries are treated as zeros, so the results may look unexpectedly in such cases.)

[1, 0, 0] * m; [ 1, -1, 1 ] gap> [1, 0, 0, 2] * m; [ 1, -1, 1 ] gap> m * [1, 0, 0]; [ 1, 2, 1 ] gap> m * [1, 0, 0, 2]; [ 1, 2, 1 ] ]]>

Note that multiplication of a row vector with a matrix will result in a linear combination of the rows of the matrix, while multiplication of a matrix with a row vector results in a linear combination of the columns of the matrix. In the latter case the row vector is considered as a column vector.

A vector or matrix of integers can also be multiplied with a finite field scalar and vice versa. Such products result in a matrix over the finite field with the integers mapped into the finite field in the obvious way. Finite field matrices are nicer to read when they are Displayed rather than Printed. (Here we write Z(q) to denote a primitive root of the finite field with q elements.)

Display( m * One( GF(5) ) ); 1 4 1 2 . 4 1 1 1 gap> Display( m^2 * Z(2) + m * Z(4) ); z = Z(4) z^1 z^1 z^2 1 1 z^2 z^1 z^1 z^2 ]]>

Submatrices can easily be extracted using the expression mat{rows}{columns}. They can also be assigned to, provided the big matrix is mutable (which it is not if it is the result of an arithmetical operation, see above).

sm := m{ [ 1, 2 ] }{ [ 2, 3 ] }; [ [ -1, 1 ], [ 0, -1 ] ] gap> sm{ [ 1, 2 ] }{ [2] } := [[-2],[0]];; sm; [ [ -1, -2 ], [ 0, 0 ] ] ]]>

The first curly brackets contain the selection of rows, the second that of columns.

Matrices appear not only in linear algebra, but also as group elements, provided they are invertible. Here we have the opportunity to meet a group-theoretical function, namely , which computes the order of a group element.

Order( m * One( GF(5) ) ); 8 gap> Order( m ); infinity ]]>

For matrices whose entries are more complex objects, for example rational functions, &GAP;'s methods might not be able to prove that the matrix has infinite order, and one gets the following warning. might be infinite ]]> In such a case, if the order of the matrix really is infinite, you will have to interrupt &GAP; by pressing ctl-C (followed by ctl-D or quit; to leave the break loop).

To prove that the order of m is infinite, we also could look at the minimal polynomial of m over the rationals.

f:= MinimalPolynomial( Rationals, m );; Factors( f ); [ x_1-2, x_1^2+3 ] ]]>

returns a list of irreducible factors of the polynomial f. The first irreducible factor X-2 reveals that 2 is an eigenvalue of m, hence its order cannot be finite.

Plain Records A record provides another way to build new data structures. Like a list a record contains subobjects. In a record the elements, the so-called record components, are not indexed by numbers but by names.

In this section you will see how to define and how to use records. Records are changed by assignments to record components or by unbinding record components.

Initially a record is defined as a comma separated list of assignments to its record components.

date:= rec(year:= 1997, > month:= "Jul", > day:= 14); rec( day := 14, month := "Jul", year := 1997 ) ]]>

The value of a record component is accessible by the record name and the record component name separated by one dot as the record component selector.

date.year; 1997 ]]>

Assignments to new record components are possible in the same way. The record is automatically resized to hold the new component.

date.time:= rec(hour:= 19, minute:= 23, second:= 12); rec( hour := 19, minute := 23, second := 12 ) gap> date; rec( day := 14, month := "Jul", time := rec( hour := 19, minute := 23, second := 12 ), year := 1997 ) ]]>

Records are objects that may be changed. An assignment to a record component changes the original object. The remarks made in Sections  and about identity and mutability of lists are also true for records.

Sometimes it is interesting to know which components of a certain record are bound. This information is available from the function , which takes a record as its argument and returns a list of names of all bound components of this record as a list of strings.

RecNames(date); [ "time", "year", "month", "day" ] ]]>

Now return to Sections and and find out what these sections mean for records.

Further Information about Lists (The following cross-references point to the &GAP; Reference Manual.)

You will find more about lists, sets, and ranges in Chapter , in particular more about identical lists in Section . A more detailed description of strings is contained in Chapter . Fields are described in Chapter , some known fields in &GAP; are described in Chapters , , and . Row vectors and matrices are described in more detail in Chapters  and . Vector spaces are described in Chapter , further matrix related structures are described in Chapters , , and .

You will find more list operations in Chapter .

Records and functions for records are described in detail in Chapter .

gap-4r6p5/doc/tut/domain.xml0000644000175000017500000003131412172557252014515 0ustar billbill

Domains Domain is &GAP;'s name for structured sets. We already saw examples of domains in Chapters  and : the groups s8 and a8 in Section  are domains, likewise the field f and the vector space v in Section  are domains. They were constructed by functions such as and , and they could be passed as arguments to other functions such as and .

Domains as Sets First of all, a domain D is a set. If D is finite then a list with the elements of this set can be computed with the functions and . For infinite D, and may work, but it is also possible that one gets an error message.

Domains can be used as arguments of set functions such as and . &GAP; tries to return a domain in these cases, moreover it tries to return a domain with as much structure as possible. For example, the intersection of two groups is (either empty or) again a group, and &GAP; will try to return it as a group. For , the situation is different because the union of two groups is in general not a group.

g:= Group( (1,2), (3,4) );; gap> h:= Group( (3,4), (5,6) );; gap> Intersection( g, h ); Group([ (3,4) ]) ]]>

Two domains are regarded as equal w.r.t. the operator = if and only if they are equal as sets, regardless of the additional structure of the domains.

mats:= [ [ [ 0*Z(2), Z(2)^0 ], [ Z(2)^0, 0*Z(2) ] ], > [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] ];; gap> Ring( mats ) = VectorSpace( GF(2), mats ); true ]]>

Additionally, a domain is regarded as equal to the sorted list of its elements.

g:= Group( (1,2) );; gap> l:= AsSortedList( g ); [ (), (1,2) ] gap> g = l; true gap> IsGroup( l ); IsList( g ); false false ]]>

Algebraic Structure The additional structure of D is constituted by the facts that D is known to be closed under certain operations such as addition or multiplication, and that these operations have additional properties. For example, if D is a group then it is closed under multiplication (D \times D \rightarrow D, (g,h) \mapsto g * h), under taking inverses (D \rightarrow D, g \mapsto g^{-1}) and under taking the identity g^0 of each element g in D; additionally, the multiplication in D is associative.

The same set of elements can carry different algebraic structures. For example, a semigroup is defined as being closed under an associative multiplication, so each group is also a semigroup. Likewise, a monoid is defined as a semigroup D in which the identity g^0 is defined for every element g, so each group is a monoid, and each monoid is a semigroup.

Other examples of domains are vector spaces, which are defined as additive groups that are closed under (left) multiplication with elements in a certain domain of scalars. Also conjugacy classes in a group D are domains, they are closed under the conjugation action of D.

Notions of Generation GeneratorsOfSomething We have seen that a domain is closed under certain operations. Usually a domain is constructed as the closure of some elements under these operations. In this situation, we say that the elements generate the domain.

For example, a list of matrices of the same shape over a common field can be used to generate an additive group or a vector space over a suitable field; if the matrices are square then we can also use the matrices as generators of a semigroup, a ring, or an algebra. We illustrate some of these possibilities:

mats:= [ [ [ 0*Z(2), Z(2)^0 ], > [ Z(2)^0, 0*Z(2) ] ], > [ [ Z(2)^0, 0*Z(2) ], > [ 0*Z(2), Z(2)^0 ] ] ];; gap> Size( AdditiveMagma( mats ) ); 4 gap> Size( VectorSpace( GF(8), mats ) ); 64 gap> Size( Algebra( GF(2), mats ) ); 4 gap> Size( Group( mats ) ); 2 ]]> Each combination of operations under which a domain could be closed gives a notion of generation. So each group has group generators, and since it is a monoid, one can also ask for monoid generators of a group.

Note that one cannot simply ask for the generators of a domain, it is always necessary to specify what notion of generation is meant. Access to the different generators is provided by functions with names of the form GeneratorsOfSomething. For example, denotes group generators, denotes monoid generators, and so on. The result of is of course to be understood relative to the field of scalars of the vector space in question.

GeneratorsOfVectorSpace( GF(4)^2 ); [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ] ] gap> v:= AsVectorSpace( GF(2), GF(4)^2 );; gap> GeneratorsOfVectorSpace( v ); [ [ Z(2)^0, 0*Z(2) ], [ 0*Z(2), Z(2)^0 ], [ Z(2^2), 0*Z(2) ], [ 0*Z(2), Z(2^2) ] ] ]]>

Domain Constructors Something A group can be constructed from a list of group generators gens by Group( gens ), likewise one can construct rings and algebras with the functions and .

Note that it is not always or completely checked that gens is in fact a valid list of group generators, for example whether the elements of gens can be multiplied or whether they are invertible. This means that &GAP; trusts you, at least to some extent, that the desired domain Something( gens ) does exist.

Forming Closures of Domains ClosureSomething Besides constructing domains from generators, one can also form the closure of a given domain with an element or another domain. There are different notions of closure, one has to specify one according to the desired result and the structure of the given domain. The functions to compute closures have names such as ClosureSomething. For example, if D is a group and one wants to construct the group generated by D and an element g then one can use ClosureGroup( D, g ).
Changing the Structure AsSomething The same set of elements can have different algebraic structures. For example, it may happen that a monoid M does in fact contain the inverses of all of its elements, and thus M is equal to the group formed by the elements of M.

m:= Monoid( mats );; gap> m = Group( mats ); true gap> IsGroup( m ); false ]]>

The last result in the above example may be surprising. But the monoid m is not regarded as a group in &GAP;, and moreover there is no way to turn m into a group. Let us formulate this as a rule:

The set of operations under which the domain is closed is fixed in the construction of a domain, and cannot be changed later.

(Contrary to this, a domain can acquire knowledge about properties such as whether the multiplication is associative or commutative.)

If one needs a domain with a different structure than the given one, one can construct a new domain with the required structure. The functions that do these constructions have names such as AsSomething, they return a domain that has the same elements as the argument in question but the structure Something. In the above situation, one can use .

g:= AsGroup( m );; gap> m = g; true gap> IsGroup( g ); true ]]>

If it is impossible to construct the desired domain, the AsSomething functions return fail.

AsVectorSpace( GF(4), GF(2)^2 ); fail ]]>

The functions and mentioned above do not return domains, but they fit into the general pattern in the sense that they forget all the structure of the argument, including the fact that it is a domain, and return a list with the same elements as the argument has.

Subdomains Subsomething SubsomethingNC It is possible to construct a domain as a subset of an existing domain. The respective functions have names such as Subsomething, they return domains with the structure Something. (Note that the second s in Subsomething is not capitalized.) For example, if one wants to deal with the subgroup of the domain D that is generated by the elements in the list gens, one can use Subgroup( D, gens ). It is not required that D is itself a group, only that the group generated by gens must be a subset of D.

The superset of a domain S that was constructed by a Subsomething function can be accessed as Parent( S ).

g:= SymmetricGroup( 5 );; gap> gens:= [ (1,2), (1,2,3,4) ];; gap> s:= Subgroup( g, gens );; gap> h:= Group( gens );; gap> s = h; true gap> Parent( s ) = g; true ]]>

Many functions return subdomains of their arguments, for example the result of SylowSubgroup( G ) is a group with parent group G.

If you are sure that the domain Something( gens ) is contained in the domain D then you can also call SubsomethingNC( D, gens ) instead of Subsomething( D, gens ). The NC stands for no check, and the functions whose names end with NC omit the check of containment.

Further Information about Domains More information about domains can be found in Chapter . Many other other chapters deal with specific types of domain such as groups, vector spaces or algebras.
gap-4r6p5/doc/tut/algvspc.xml0000644000175000017500000005412212172557252014707 0ustar billbill Vector Spaces and Algebras This chapter contains an introduction into vector spaces and algebras in &GAP;.
Vector Spaces

A vector space over the field F is an additive group that is closed under scalar multiplication with elements in F. In &GAP;, only those domains that are constructed as vector spaces are regarded as vector spaces. In particular, an additive group that does not know about an acting domain of scalars is not regarded as a vector space in &GAP;.

Probably the most common F-vector spaces in &GAP; are so-called row spaces. They consist of row vectors, that is, lists whose elements lie in F. In the following example we compute the vector space spanned by the row vectors [ 1, 1, 1 ] and [ 1, 0, 2 ] over the rationals.

F:= Rationals;; gap> V:= VectorSpace( F, [ [ 1, 1, 1 ], [ 1, 0, 2 ] ] ); gap> [ 2, 1, 3 ] in V; true ]]>

The full row space F^n is created by commands like:

F:= GF( 7 );; gap> V:= F^3; # The full row space over F of dimension 3. ( GF(7)^3 ) gap> [ 1, 2, 3 ] * One( F ) in V; true ]]>

In the same way we can also create matrix spaces. Here the short notation field^[dim1,dim2] can be used:

m1:= [ [ 1, 2 ], [ 3, 4 ] ];; m2:= [ [ 0, 1 ], [ 1, 0 ] ];; gap> V:= VectorSpace( Rationals, [ m1, m2 ] ); gap> m1+m2 in V; true gap> W:= Rationals^[3,2]; ( Rationals^[ 3, 2 ] ) gap> [ [ 1, 1 ], [ 2, 2 ], [ 3, 3 ] ] in W; true ]]>

A field is naturally a vector space over itself.

IsVectorSpace( Rationals ); true ]]>

If \Phi is an algebraic extension of F, then \Phi is also a vector space over F (and indeed over any subfield of \Phi that contains F). This field F is stored in the attribute . In &GAP;, the default is to view fields as vector spaces over their prime fields. By the function , we can view fields as vector spaces over fields other than the prime field.

F:= GF( 16 );; gap> LeftActingDomain( F ); GF(2) gap> G:= AsVectorSpace( GF( 4 ), F ); AsField( GF(2^2), GF(2^4) ) gap> F = G; true gap> LeftActingDomain( G ); GF(2^2) ]]>

A vector space has three important attributes: its field of definition, its dimension and a basis. We already encountered the function in the example above. It extracts the field of definition of a vector space. The function provides the dimension of the vector space.

F:= GF( 9 );; gap> m:= [ [ Z(3)^0, 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0, Z(3)^0 ] ];; gap> V:= VectorSpace( F, m ); gap> Dimension( V ); 2 gap> W:= AsVectorSpace( GF( 3 ), V ); gap> V = W; true gap> Dimension( W ); 4 gap> LeftActingDomain( W ); GF(3) ]]>

One of the most important attributes is a basis. For a given basis B of V, every vector v in V can be expressed uniquely as v = \sum_{b \in B} c_b b, with coefficients c_b \in F.

In &GAP;, bases are special lists of vectors. They are used mainly for the computation of coefficients and linear combinations.

Given a vector space V, a basis of V is obtained by simply applying the function to V. The vectors that form the basis are extracted from the basis by .

m1:= [ [ 1, 2 ], [ 3, 4 ] ];; m2:= [ [ 1, 1 ], [ 1, 0 ] ];; gap> V:= VectorSpace( Rationals, [ m1, m2 ] ); gap> B:= Basis( V ); SemiEchelonBasis( , ... ) gap> BasisVectors( Basis( V ) ); [ [ [ 1, 2 ], [ 3, 4 ] ], [ [ 0, 1 ], [ 2, 4 ] ] ] ]]>

The coefficients of a vector relative to a given basis are found by the function . Furthermore, linear combinations of the basis vectors are constructed using .

V:= VectorSpace( Rationals, [ [ 1, 2 ], [ 3, 4 ] ] ); gap> B:= Basis( V ); SemiEchelonBasis( , ... ) gap> BasisVectors( Basis( V ) ); [ [ 1, 2 ], [ 0, 1 ] ] gap> Coefficients( B, [ 1, 0 ] ); [ 1, -2 ] gap> LinearCombination( B, [ 1, -2 ] ); [ 1, 0 ] ]]>

In the above examples we have seen that &GAP; often chooses the basis it wants to work with. It is also possible to construct bases with prescribed basis vectors by giving a list of these vectors as second argument to .

V:= VectorSpace( Rationals, [ [ 1, 2 ], [ 3, 4 ] ] );; gap> B:= Basis( V, [ [ 1, 0 ], [ 0, 1 ] ] ); SemiEchelonBasis( , [ [ 1, 0 ], [ 0, 1 ] ] ) gap> Coefficients( B, [ 1, 2 ] ); [ 1, 2 ] ]]>

We can construct subspaces and quotient spaces of vector spaces. The natural projection map (constructed by ), connects a vector space with its quotient space.

V:= Rationals^4; ( Rationals^4 ) gap> W:= Subspace( V, [ [ 1, 2, 3, 4 ], [ 0, 9, 8, 7 ] ] ); gap> VmodW:= V/W; ( Rationals^2 ) gap> h:= NaturalHomomorphismBySubspace( V, W ); ( Rationals^2 )> gap> Image( h, [ 1, 2, 3, 4 ] ); [ 0, 0 ] gap> PreImagesRepresentative( h, [ 1, 0 ] ); [ 1, 0, 0, 0 ] ]]>

Algebras If a multiplication is defined for the elements of a vector space, and if the vector space is closed under this multiplication then it is called an algebra. For example, every field is an algebra:

f:= GF(8); IsAlgebra( f ); GF(2^3) true ]]>

One of the most important classes of algebras are sub-algebras of matrix algebras. On the set of all n \times n matrices over a field F it is possible to define a multiplication in many ways. The most frequent are the ordinary matrix multiplication and the Lie multiplication.

Each matrix constructed as [ row1, row2, \ldots ] is regarded by &GAP; as an ordinary matrix, its multiplication is the ordinary associative matrix multiplication. The sum and product of two ordinary matrices are again ordinary matrices.

The full matrix associative algebra can be created as follows:

F:= GF( 9 );; gap> A:= F^[3,3]; ( GF(3^2)^[ 3, 3 ] ) ]]>

An algebra can be constructed from generators using the function . It takes as arguments the field of coefficients and a list of generators. Of course the coefficient field and the generators must fit together; if we want to construct an algebra of ordinary matrices, we may take the field generated by the entries of the generating matrices, or a subfield or extension field.

m1:= [ [ 1, 1 ], [ 0, 0 ] ];; m2:= [ [ 0, 0 ], [ 0, 1 ] ];; gap> A:= Algebra( Rationals, [ m1, m2 ] ); ]]>

An interesting class of algebras for which many special algorithms are implemented is the class of Lie algebras. They arise for example as algebras of matrices whose product is defined by the Lie bracket [ A, B ] = A * B - B * A, where * denotes the ordinary matrix product.

Since the multiplication of objects in &GAP; is always assumed to be the operation * (resp. the infix operator *), and since there is already the ordinary matrix product defined for ordinary matrices, as mentioned above, we must use a different construction for matrices that occur as elements of Lie algebras. Such Lie matrices can be constructed by from ordinary matrices, the sum and product of Lie matrices are again Lie matrices.

m:= LieObject( [ [ 1, 1 ], [ 1, 1 ] ] ); LieObject( [ [ 1, 1 ], [ 1, 1 ] ] ) gap> m*m; LieObject( [ [ 0, 0 ], [ 0, 0 ] ] ) gap> IsOrdinaryMatrix( m1 ); IsOrdinaryMatrix( m ); true false gap> IsLieMatrix( m1 ); IsLieMatrix( m ); false true ]]>

Given a field F and a list mats of Lie objects over F, we can construct the Lie algebra generated by mats using the function . Alternatively, if we do not want to be bothered with the function , we can use the function that takes a field and a list of ordinary matrices, and constructs the Lie algebra generated by the corresponding Lie matrices. Note that this means that the ordinary matrices used in the call of are not contained in the returned Lie algebra.

m1:= [ [ 0, 1 ], [ 0, 0 ] ];; gap> m2:= [ [ 0, 0 ], [ 1, 0 ] ];; gap> L:= LieAlgebra( Rationals, [ m1, m2 ] ); gap> m1 in L; false ]]>

A second way of creating an algebra is by specifying a multiplication table. Let A be a finite dimensional algebra with basis (x_1, x_2, \ldots, x_n), then for 1 \leq i, j \leq n the product x_i x_j is a linear combination of basis elements, i.e., there are c_{ij}^k in the ground field such that x_i x_j = \sum_{k=1}^n c_{ij}^k x_k. It is not difficult to show that the constants c_{ij}^k determine the multiplication completely. Therefore, the c_{ij}^k are called structure constants. In &GAP; we can create a finite dimensional algebra by specifying an array of structure constants.

In &GAP; such a table of structure constants is represented using lists. The obvious way to do this would be to construct a three-dimensional list T such that T[i][j][k] equals c_{ij}^k. But it often happens that many of these constants vanish. Therefore a more complicated structure is used in order to be able to omit the zeros. A multiplication table of an n-dimensional algebra is an n \times n array T such that T[i][j] describes the product of the i-th and the j-th basis element. This product is encoded in the following way. The entry T[i][j] is a list of two elements. The first of these is a list of indices k such that c_{ij}^k is nonzero. The second list contains the corresponding constants c_{ij}^k. Suppose, for example, that S is the table of an algebra with basis (x_1, x_2, \ldots, x_8) and that S[3][7] equals [ [ 2, 4, 6 ], [ 1/2, 2, 2/3 ] ]. Then in the algebra we have the relation x_3 x_7 = (1/2) x_2 + 2 x_4 + (2/3) x_6. Furthermore, if S[6][1] = [ [ ], [ ] ] then the product of the sixth and first basis elements is zero.

Finally two numbers are added to the table. The first number can be 1, -1, or 0. If it is 1, then the table is known to be symmetric, i.e., c_{ij}^k = c_{ji}^k. If this number is -1, then the table is known to be antisymmetric (this happens for instance when the algebra is a Lie algebra). The remaining case, 0, occurs in all other cases. The second number that is added is the zero element of the field over which the algebra is defined.

Empty structure constants tables are created by the function , which takes a dimension d, a zero element z, and optionally one of the strings "symmetric", "antisymmetric", and returns an empty structure constants table T corresponding to a d-dimensional algebra over a field with zero element z. Structure constants can be entered into the table T using the function . It takes four arguments, namely T, two indices i and j, and a list of the form [ c_{ij}^{{k_1}}, k_1, c_{ij}^{{k_2}}, k_2, \ldots ]. In this call to SetEntrySCTable, the product of the i-th and the j-th basis vector in any algebra described by T is set to \sum_l c_{ij}^{{k_l}} x_{{k_l}}. (Note that in the empty table, this product was zero.) If T knows that it is (anti)symmetric, then at the same time also the product of the j-th and the i-th basis vector is set appropriately.

In the following example we temporarily increase the line length limit from its default value 80 to 82 in order to make the long output expression fit into one line.

T:= EmptySCTable( 2, 0, "symmetric" ); [ [ [ [ ], [ ] ], [ [ ], [ ] ] ], [ [ [ ], [ ] ], [ [ ], [ ] ] ], 1, 0 ] gap> SetEntrySCTable( T, 1, 2, [1/2,1,1/3,2] ); T; [ [ [ [ ], [ ] ], [ [ 1, 2 ], [ 1/2, 1/3 ] ] ], [ [ [ 1, 2 ], [ 1/2, 1/3 ] ], [ [ ], [ ] ] ], 1, 0 ] ]]>

If we have defined a structure constants table, then we can construct the corresponding algebra by .

A:= AlgebraByStructureConstants( Rationals, T ); ]]>

If we know that a structure constants table defines a Lie algebra, then we can construct the corresponding Lie algebra by ; the algebra returned by this function knows that it is a Lie algebra, so &GAP; need not check the Jacobi identity.

T:= EmptySCTable( 2, 0, "antisymmetric" );; gap> SetEntrySCTable( T, 1, 2, [2/3,1] ); gap> L:= LieAlgebraByStructureConstants( Rationals, T ); ]]>

In &GAP; an algebra is naturally a vector space. Hence all the functionality for vector spaces is also available for algebras.

F:= GF(2);; gap> z:= Zero( F );; o:= One( F );; gap> T:= EmptySCTable( 3, z, "antisymmetric" );; gap> SetEntrySCTable( T, 1, 2, [ o, 1, o, 3 ] ); gap> SetEntrySCTable( T, 1, 3, [ o, 1 ] ); gap> SetEntrySCTable( T, 2, 3, [ o, 3 ] ); gap> A:= AlgebraByStructureConstants( F, T ); gap> Dimension( A ); 3 gap> LeftActingDomain( A ); GF(2) gap> Basis( A ); CanonicalBasis( ) ]]>

Subalgebras and ideals of an algebra can be constructed by specifying a set of generators for the subalgebra or ideal. The quotient space of an algebra by an ideal is naturally an algebra itself.

In the following example we temporarily increase the line length limit from its default value 80 to 81 in order to make the long output expression fit into one line.

m:= [ [ 1, 2, 3 ], [ 0, 1, 6 ], [ 0, 0, 1 ] ];; gap> A:= Algebra( Rationals, [ m ] );; gap> subA:= Subalgebra( A, [ m-m^2 ] ); gap> Dimension( subA ); 2 gap> idA:= Ideal( A, [ m-m^3 ] ); , (1 generators)> gap> Dimension( idA ); 2 gap> B:= A/idA; ]]>

The call B:= A/idA creates a new algebra that does not know about its connection with A. If we want to connect an algebra with its factor via a homomorphism, then we first have to create the homomorphism (). After this we create the factor algebra from the homomorphism by the function . In the next example we divide an algebra A by its radical and lift the central idempotents of the factor to the original algebra A.

m1:=[[1,0,0],[0,2,0],[0,0,3]];; gap> m2:=[[0,1,0],[0,0,2],[0,0,0]];; gap> A:= Algebra( Rationals, [ m1, m2 ] );; gap> Dimension( A ); 6 gap> R:= RadicalOfAlgebra( A ); gap> h:= NaturalHomomorphismByIdeal( A, R ); -> > gap> AmodR:= ImagesSource( h ); gap> id:= CentralIdempotentsOfAlgebra( AmodR ); [ v.3, v.2+(-3)*v.3, v.1+(-2)*v.2+(3)*v.3 ] gap> PreImagesRepresentative( h, id[1] ); [ [ 0, 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 1 ] ] gap> PreImagesRepresentative( h, id[2] ); [ [ 0, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 0 ] ] gap> PreImagesRepresentative( h, id[3] ); [ [ 1, 0, 0 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ] ]]>

Structure constants tables for the simple Lie algebras are present in &GAP;. They can be constructed using the function . The Lie algebras constructed by this function come with a root system attached.

L:= SimpleLieAlgebra( "G", 2, Rationals ); gap> R:= RootSystem( L ); gap> PositiveRoots( R ); [ [ 2, -1 ], [ -3, 2 ], [ -1, 1 ], [ 1, 0 ], [ 3, -1 ], [ 0, 1 ] ] gap> CartanMatrix( R ); [ [ 2, -1 ], [ -3, 2 ] ] ]]>

Another example of algebras is provided by quaternion algebras. We define a quaternion algebra over an extension field of the rationals, namely the field generated by \sqrt{{5}}. (The number EB(5) is equal to 1/2 (-1+\sqrt{{5}}). The field is printed as NF(5,[ 1, 4 ]).)

b5:= EB(5); E(5)+E(5)^4 gap> q:= QuaternionAlgebra( FieldByGenerators( [ b5 ] ) ); gap> gens:= GeneratorsOfAlgebra( q ); [ e, i, j, k ] gap> e:= gens[1];; i:= gens[2];; j:= gens[3];; k:= gens[4];; gap> IsAssociative( q ); true gap> IsCommutative( q ); false gap> i*j; j*i; k (-1)*k gap> One( q ); e ]]>

If the coefficient field is a real subfield of the complex numbers then the quaternion algebra is in fact a division ring.

IsDivisionRing( q ); true gap> Inverse( e+i+j ); (1/3)*e+(-1/3)*i+(-1/3)*j ]]>

So &GAP; knows about this fact. As in any ring, we can look at groups of units. (The function used below computes the unique algebraic conjugate of an element in a quadratic subfield of a cyclotomic field.)

c5:= StarCyc( b5 ); E(5)^2+E(5)^3 gap> g1:= 1/2*( b5*e + i - c5*j ); (1/2*E(5)+1/2*E(5)^4)*e+(1/2)*i+(-1/2*E(5)^2-1/2*E(5)^3)*j gap> Order( g1 ); 5 gap> g2:= 1/2*( -c5*e + i + b5*k ); (-1/2*E(5)^2-1/2*E(5)^3)*e+(1/2)*i+(1/2*E(5)+1/2*E(5)^4)*k gap> Order( g2 ); 10 gap> g:=Group( g1, g2 );; #I default `IsGeneratorsOfMagmaWithInverses' method returns `true' for [ (1/2*E(5)+1/2*E(5)^4)*e+(1/2)*i+(-1/2*E(5)^2-1/2*E(5)^3)*j, (-1/2*E(5)^2-1/2*E(5)^3)*e+(1/2)*i+(1/2*E(5)+1/2*E(5)^4)*k ] gap> Size( g ); 120 gap> IsPerfect( g ); true ]]>

Since there is only one perfect group of order 120, up to isomorphism, we see that the group g is isomorphic to SL_2(5). As usual, a permutation representation of the group can be constructed using a suitable action of the group.

cos:= RightCosets( g, Subgroup( g, [ g1 ] ) );; gap> Length( cos ); 24 gap> hom:= ActionHomomorphism( g, cos, OnRight );; gap> im:= Image( hom ); Group([ (2,3,5,9,15)(4,7,12,8,14)(10,17,23,20,24)(11,19,22,16,13), (1,2,4,8,3,6,11,20,17,19)(5,10,18,7,13,22,12,21,24,15)(9,16)(14,23) ]) gap> Size( im ); 120 ]]>

To get a matrix representation of g or of the whole algebra q, we must specify a basis of the vector space on which the algebra acts, and compute the linear action of elements w.r.t. this basis.

bas:= CanonicalBasis( q );; gap> BasisVectors( bas ); [ e, i, j, k ] gap> op:= OperationAlgebraHomomorphism( q, bas, OnRight ); matrices of dim. 4> gap> ImagesRepresentative( op, e ); [ [ 1, 0, 0, 0 ], [ 0, 1, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 0, 0, 1 ] ] gap> ImagesRepresentative( op, i ); [ [ 0, 1, 0, 0 ], [ -1, 0, 0, 0 ], [ 0, 0, 0, -1 ], [ 0, 0, 1, 0 ] ] gap> ImagesRepresentative( op, g1 ); [ [ 1/2*E(5)+1/2*E(5)^4, 1/2, -1/2*E(5)^2-1/2*E(5)^3, 0 ], [ -1/2, 1/2*E(5)+1/2*E(5)^4, 0, -1/2*E(5)^2-1/2*E(5)^3 ], [ 1/2*E(5)^2+1/2*E(5)^3, 0, 1/2*E(5)+1/2*E(5)^4, -1/2 ], [ 0, 1/2*E(5)^2+1/2*E(5)^3, 1/2, 1/2*E(5)+1/2*E(5)^4 ] ] ]]>

Further Information about Vector Spaces and Algebras More information about vector spaces can be found in Chapter . Chapter  deals with the functionality for general algebras. Furthermore, concerning special functions for Lie algebras, there is Chapter .
gap-4r6p5/doc/tut/migrat.xml0000644000175000017500000014652312172557252014542 0ustar billbill Migrating to &GAP; 4 This chapter is intended to give users who have experience with &GAP; 3 some information about what has changed in &GAP; 4.

In particular, it informs about changed command line options (see ), the new global variable fail (see ), some functions that have changed their behaviour (see ) or their names (see ), and some conventions used for variable names (see ).

Then the new concepts of &GAP; 4 are sketched, first that of mutability or immutability (see ), with the explanation of related changes in functions that copy objects (see ), then the concepts of operations and method selection, which are compared with the use of operations records in &GAP; 3 (see , , and ).

More local changes affect the concepts of notions of generation (see ), of parents (see ), of homomorphisms (see , , and ), how elements in finitely presented groups are treated (see ), how information about progress of computations can be obtained (see ), and how one gets information in a break loop (see ).

While a &GAP; 3 compatibility mode is provided (see ), its use will disable some of the new features of &GAP; 4. Also it certainly can only try to provide partial compatibility.

For a detailed explanation of the new features and concepts of &GAP; 4, see the manual Programming in GAP.

Changed Command Line Options In &GAP; 4, the -l option is used to specify the root directory (see ) of the &GAP; distribution, which is the directory containing the lib and doc subdirectories. Note that in &GAP; 3 this option was used to specify the path to the lib directory.

The -h option of &GAP; 3 has been removed, the path(s) for the documentation are deduced automatically in &GAP; 4.

The option -g is now used to print information only about full garbage collections. The new option -g -g generates information about partial garbage collections too.

Fail There is a new global variable fail instead of false

in &GAP; 4. It is intended as a return value of a function for the case that it could not perform its task. For example, Inverse returns fail if it is called with a singular matrix, and Position returns fail if the second argument is not contained in the list given as first argument.

&GAP; 3 handled such situations by either signalling an error, for example if it was asked for the inverse of a singular matrix, or by (mis)using false as return value, as in the example Position. Note that in the first example, in &GAP; 3 it was necessary to check the invertibility of a matrix before one could safely ask for its inverse, which meant that roughly the same work was done twice.

Changed Functionality Some functions that were already available in &GAP; 3 behave differently in &GAP; 4. This section lists them.

The &GAP; 3 manual promised that pnt would be the first entry of the resulting orbit. This was wrong already there in a few cases, therefore &GAP; 4 does not promise anything about the ordering of points in an orbit.

only takes the element g and computes its multiplicative order. Calling Order with two arguments is permitted only in the &GAP; 3 compatibility mode, see . (Note that it does not make sense anymore to specify a group as first argument w.r.t. which the order of the second argument shall be computed, see .)

If obj is not contained in the list list then fail is returned in &GAP; 4 (see ), whereas false was returned in &GAP; 3.

In &GAP; 3, this function took either two or three arguments, the optional argument K being a subgroup of G that stabilizes prop in the sense that for any element g in G, either all elements or no element in the coset g * K have the property prop.

The &GAP; 4 function ElementProperty, however, takes between two and four arguments, and the subgroup K known from &GAP; 3 has to be entered as the fourth argument not the third. (The third argument in the &GAP; 4 function denotes a subgroup U stabilizing prop in the sense that either all elements or no element in right cosets U * g have the property prop.)

(This discrepancy was discovered only in March 2002, short before the release of &GAP; 4.3.)

Objects may appear on the screen in a different way, depending on whether they are printed by the read eval print loop or by an explicit call of Print. The reason is that the read eval print loop calls the operation ViewObj and not PrintObj, whereas Print calls PrintObj for each of its arguments. This permits the installation of methods for printing objects in a short form in the read eval print loop while retaining Print to display the object completely. See also Section .

(PrintObj is installed as standard method ViewObj, so it is not really necessary to have a ViewObj method for an object.)

In &GAP; 3, PrintTo could be (mis)used to redirect the text printed by a function (that is, not only the output of a function) to a file by entering the function call as second argument. This was used mainly in order to avoid many calls of AppendTo. In &GAP; 4, this feature has disappeared. One can use streams (see Chapter ) instead in order to write files efficiently.

Changed Variable Names AgGroup ApplyFunc Backtrace CharTable Denominator DepthVector Elements IsBijection IsFunc IsMat IsRec IsSet LengthWord NOfCyc Numerator RandomInvertableMat RecFields X Some functions have changed their name without changing the functionality. A -- probably incomplete -- list follows

See Section  for a way to make the old names available again.

Naming Conventions The way functions are named has been unified in &GAP; 4. This might help to memorize or even guess names of library functions.

If a variable name consists of several words then the first letter of each word is capitalized.

If the first part of the name of a function is a verb then the function may modify its argument(s) but does not return anything, for example Append appends the list given as second argument to the list given as first argument. Otherwise the function returns an object without changing the arguments, for example Concatenation returns the concatenation of the lists given as arguments.

If the name of a function contains the word By then the return value is thought of as built in a certain way from the parts given as arguments. For example, GroupByGenerators returns a group built from its group generators, and creating a group as a factor group of a given group by a normal subgroup can be done by taking the image of NaturalHomomorphismByNormalSubgroup (see also ). Other examples of By functions are GroupHomomorphismByImages and UnivariateLaurentPolynomialByCoefficients.

If the name of a function contains the word Of then the return value is thought of as information deduced from the arguments. Usually such functions are attributes (see  in this Tutorial and ). Examples are GeneratorsOfGroup, which returns a list of generators for the group entered as argument, or DiagonalOfMat.

For the setter and tester functions of an attribute attr (see  in this Tutorial and ) the names Setattr resp. Hasattr are available.

If the name of a function fun1 ends with NC then there is another function fun2 with the same name except that the NC is missing. NC stands for no check. When fun2 is called then it checks whether its arguments are valid, and if so then it calls fun1. The functions SubgroupNC and Subgroup are a typical example.

The idea is that the possibly time consuming check of the arguments can be omitted if one is sure that they are unnecessary. For example, if an algorithm produces generators of the derived subgroup of a group then it is guaranteed that they lie in the original group; Subgroup would check this, and SubgroupNC omits the check.

Needless to say, all these rules are not followed slavishly, for example there is one operation Zero instead of two operations ZeroOfElement and ZeroOfAdditiveGroup.

Immutable Objects &GAP; 4 supports immutable objects. Such objects cannot be changed, attempting to do so issues an error. Typically attribute values are immutable, and also the results of those binary arithmetic operations where both arguments are immutable, see Section . For example, [ 1 .. 100 ] + [ 1 .. 100 ] is a mutable list and 2 * Immutable( [ 1 .. 100 ] ) is an immutable list, both are equal to the (mutable) list [ 2, 4 .. 200 ].

There is no way to make an immutable object mutable, one can only get a mutable copy by ShallowCopy. The other way round, MakeImmutable makes a (mutable or immutable) object and all its subobjects immutable; one must be very careful to use MakeImmutable only for those objects that are really newly created, for such objects the advantage over Immutable is that no copy is made.

More about immutability can be found in Sections  in this tutorial and .

Copy StructuralCopy ShallowCopy The function Copy of &GAP; 3 is not supported in &GAP; 4. This function was used to create a copy cop of its argument obj with the properties that cop and obj had no subobjects in common and that if two subobjects of obj were identical then also the corresponding subobjects of cop were identical.

The possibility of having immutable objects (see ) can and should be used to avoid unnecessary copying. Namely, given an immutable object one needs to copy it only if one wants to get a modified object, and in such a situation usually it is sufficient to use ShallowCopy, or at least one knows how deep one must copy in order to do the changes one has in mind.

For example, suppose you have a matrix group, and you want to construct a list of matrices by modifying the group generators. This list of generators is immutable, so you call ShallowCopy to get a mutable list that contains the same matrices. If you only want to exchange some of them, or to append some other matrices, this shallow copy is already what you need. So suppose that you are interested in a list of matrices where some rows are also changed. For that, you call ShallowCopy for the matrices in question, and you get matrices whose rows can be changed. If you want to change single entries in some rows, ShallowCopy must be called to get mutable copies of these rows. Note that in all these situations there is no danger to change, i.e., to destroy the original generators of the matrix group.

If one needs the facility of the Copy function of &GAP; 3 to get a copy with the same structure then one can use the new &GAP; 4 function StructuralCopy. It returns a structural copy that has no mutable subobject in common with its argument. So if StructuralCopy is called with an immutable object then this object itself is returned, and if StructuralCopy is called with a mutable list of immutable objects then a shallow copy of this list is returned.

Note that ShallowCopy now is an operation. So if you create your own type of (copyable) objects then you must define what a shallow copy of these objects is, and install an appropriate method.

Attributes vs. Record Components In &GAP; 3, many complex objects were represented via records, for example all domains. Information about these objects was stored in components of these records. For the user, this was usually not relevant, since there were functions for computing information about the objects in question. For example, if one was interested in the size of a group then one could call Size.

But since it was guaranteed that the size of a domain D was stored as value of the component size, it was allowed to access D.size if this component was bound, and a check for this was possible via IsBound( D.size ).

In &GAP; 4, only the access via functions is admissible. One reason is the following basic rule.

From the information that a given &GAP; 4 object is for example a domain, one cannot conclude that this object has a certain representation.

For attributes like Size, &GAP; 4 provides two related functions, the setter and the tester of the attribute, which can be used to set an attribute value and to check whether the value of an attribute is already stored for an object (see also ). For example, if D is a domain in &GAP; 4 then HasSize( D ) is true if the size of D is already stored, and false otherwise. In the latter case, if you know that the size of D is size then you may store it by SetSize( D, size ).

Besides the flexibility in the internal representation of objects, storing information only via function calls has also the advantage that &GAP; 4 is able to draw conclusions automatically. For example, as soon as it is stored that a group is nilpotent, it is also stored that it is solvable, see Chapters  and  for the details.

As a consequence, you cannot put your favourite information into a domain D by assigning it to a new component like D.myPrivateInfo. Instead you can introduce a new attribute and then use its setter, see .

Different Notions of Generation As in &GAP; 3, a domain in &GAP; 4 is a structured set.

The same set can have different structures, for example a field can be regarded as a ring or as an algebra or vector space over a subfield.

In &GAP; 3, however, an object representing a ring did not represent a field, and an object representing a field did not represent a ring. One reason for this was that the record component generators was used to denote the appropriate generators of the domain. For a ring R, the component R.generators was a list of ring generators, and for a field F, F.generators was a list of field generators.

&GAP; 4 cleans this up, see . It supports many different notions of generation, for example one can ask for magma generators of a group or for generators of a field as an additive group. A subtle but important distinction is that between generators of an algebra and of an algebra-with-one.

So the attributes GeneratorsOfGroup, GeneratorsOfMagma, GeneratorsOfRing, GeneratorsOfField, GeneratorsOfVectorSpace, and so on, replace the access to the generators component.

Operations Records Already in &GAP; 3 there were several functions that were applicable to many different kinds of objects, for example Size could be applied to any domain, and the binary infix multiplication * could be used to multiply two matrices, an integer with a row vector, or a permutation with a permutation group. This was implemented as follows. Functions like Size and * tried to find out what situation was described by its arguments, and then it called a more specific function to compute the desired information. These more specific functions, let us call them methods as they are also called in &GAP; 4, were stored in so-called operations records of the arguments.

For example, every domain in &GAP; 3 was represented as a record, and the operations record was stored in the record component operations. If Size was called for the domain then the method to compute the size of the domain was found as value of the Size component of the operations record.

This was fine for functions taking only one argument, and in principle it is possible that for those functions an object stored an optimal method in its operations record. But in the case of more arguments this is not possible. In a multiplication of two objects in &GAP; 3, one had to choose between the methods stored in the operations records of the arguments, and if for example the method stored for the left operand was called, this method had to handle all possible right operands.

So operations records turned out to be not flexible enough. In &GAP; 4, operations records are not supported (see  for a possibility to use your &GAP; 3 code that utilizes operations records, at least to some extent). A detailed description of the new mechanism to select methods can be found in Chapter .

An important point is that the new mechanism allows &GAP; to take the relation between arguments into account. So it is possible (and recommended) to install different methods for different relations between the arguments. Note that such methods need not do the extensive argument checking that was necessary in &GAP; 3, because most of the checks are done already by the method selection mechanism.

Operations vs. Dispatcher Functions &GAP; 3 functions like Size, CommutatorSubgroup, or SylowSubgroup did mainly call an appropriate method (see ) after they had checked their arguments. Such functions were called dispatchers in &GAP; 3. In &GAP; 4, many dispatchers have been replaced by operations, due to the fact that methods are no longer stored in operations records (see  for the details).

Most dispatchers taking only one argument were treated in a special way in &GAP; 3, they had the additional task of storing computed values and using these values in subsequent calls. For example, the dispatcher Size first checked whether the size of the argument was already stored, and if so then this value was returned; otherwise a method was called, the value returned by this method was stored in the argument, and then returned by Size.

In &GAP; 4, computed values of operations that take one argument (these operations are called attributes) are also stored, only the mechanism to achieve this has changed, see  and .

So the behaviour of Size is the same in &GAP; 3 and &GAP; 4. But note that in &GAP; 4, it is not possible to access D.size, see . As described in , &GAP; 4 does not admit bypassing the dispatcher by calling for example D.operations.Size. This was done in &GAP; 3 often for efficiency reasons, but the method selection mechanism of &GAP; 4 is fast enough to make this unnecessary.

If you had written your own dispatchers and put your own methods into existing operations records then this code will not work in &GAP; 4. See  and  for a description of how to define operations and to install methods.

Finally, some functions in &GAP; 3 were hidden in operations records, e.g., PermGroupOps.MovedPoints. These functions became proper operations in &GAP; 4.

Parents and Subgroups In &GAP; 3 there was a strict distinction between parent groups and subgroups. The use of the name parent (instead of supergroup) was chosen to indicate that the parent of an object was more than just useful information. In fact the main reason for the introduction of parents was to provide a common roof for example for all groups of polycyclic words that belonged to the same PC-presentation, or for all subgroups of a finitely presented group (see ). A subgroup was never a parent group, and it was possible to create subgroups only of parent groups.

In &GAP; 4 this common roof is provided already by the concept of families, see . Thus it is no longer compulsory to use parent groups at all. On the other hand, parents may be used in &GAP; 4 to provide information about an object, for example the normalizer of a group in its parent group may be stored as an attribute value. Note that there is no restriction on the supergroup that is set to be the parent, it is possible to create a subgroup of any group, this group then being the parent of the new subgroup. This permits for example chains of subgroups with respective parents, of arbitrary length.

As a consequence, the Parent command cannot be used in &GAP; 4 to test whether the two arguments of CommutatorSubgroup fit together, this is now a question that concerns the relation between the families of the groups. So the 2-argument version of Parent and the now meaningless function IsParent have been abolished.

Homomorphisms vs. General Mappings In &GAP; 3 there had been a confusion between group homomorphisms and general mappings, as GroupHomomorphismByImages created only a general mapping that did not store whether it was a mapping. This caused expensive, unwanted, and unnecessary tests whether the mapping was in fact a group homomorphism. Moreover, the official workaround to set some components of the mapping record was quite unwieldy.

In &GAP; 4, GroupHomomorphismByImages checks whether the desired mapping is indeed a group homomorphism; if so then this property is stored in the returned mapping, otherwise fail is returned. If you want to avoid the checks then you can use GroupHomomorphismByImagesNC. If you want to check whether a general mapping that respects the group operations is really a group homomorphism, you can construct it via GroupGeneralMappingByImages and then call IsGroupHomomorphism for it. (Note that IsGroupHomomorphism returns true if and only if both IsGroupGeneralMapping and IsMapping do, so one does in fact check IsMapping in this case.)

There is no function IsHomomorphism in &GAP; 4, since there are several different operations with respect to which a mapping can be a homomorphism.

Homomorphisms vs. Factor Structures If F is a factor structure of G, with kernel N, complete information about the connection between F and G is provided by the natural homomorphism.

In &GAP; 3, the official way to construct this natural homomorphism was to create first the factor structure F, and then to call NaturalHomomorphism with the arguments G and F. For that, the data necessary to compute the homomorphism was stored in F when F was constructed.

In &GAP; 4, factor structures are not treated in a special way, in particular they do not store information about a homomorphism. Instead, the more natural way is taken to construct the natural homomorphism from G and N by NaturalHomomorphismByNormalSubgroup if N is a normal subgroup of the group G, or by NaturalHomomorphismByIdeal if N is an ideal in the ring G. The factor F can then be accessed as the image of this homomorphism, and of course G is the preimage and N is the kernel.

Note that &GAP; 4 does not guarantee anything about the representation of the factor F, it may be a permutation group or a polycyclically presented group or another kind of group. Also note that a natural homomorphism need not be surjective.

A consequence of this change is that &GAP; 4 does not allow you to construct a natural homomorphism from the groups G and F.

The other common type of homomorphism in &GAP; 3, operation homomorphisms, have been replaced (just a name change) by action homomorphisms, which are handled in a similar fashion. That is, an action homomorphism is constructed from an acting group, an action domain, and a function describing the operation. The permutation group arising by the induced action is then the image of this operation homomorphism.

The &GAP; 3 function Operation is still supported, under the name Action, but from the original group and the result of Action it is not possible to construct the action homomorphism.

Isomorphisms vs. Isomorphic Structures In &GAP; 3, a different representation of a group could be obtained by calling AgGroup to get an isomorphic polycyclically presented group, PermGroup to get an isomorphic permutation group, and so on. The returned objects stored an isomorphism in the record component bijection.

For the same reason as in , &GAP; 4 puts emphasis on the isomorphism, and the isomorphic object in the desired representation can be accessed as its image. So you can call IsomorphismPcGroup or IsomorphismPermGroup in order to get an isomorphism to a polycyclically presented group or a permutation group, respectively, and then call Image to get the isomorphic group.

Note that the image of an action homomorphism with trivial kernel is also an isomorphic permutation group, but an action homomorphism need not be surjective, since it may be easier to define it into the full symmetric group.

Further note that in &GAP; 3, a usual application of isomorphisms to polycyclically presented groups was to utilize the usually more effective algorithms for solvable groups. However, the new concept of polycyclic generating systems in &GAP; 4 makes it possible to apply these algorithms to arbitrary solvable groups, independent of the representation. For example, &GAP; 4 can handle polycyclic generating systems of solvable permutation groups. So in many cases, a change of the representation for efficiency reasons may be not necessary any longer.

In general IsomorphismFpGroup will define a presentation on generators chosen by the algorithm. The corresponding elements of the original group can be obtained by the command

PreImagesRepresentative(isofp,i)); ]]>

If a presentation in the given generators is needed, the command IsomorphismFpGroupByGenerators(G, gens) will produce one.

Elements of Finitely Presented Groups Strictly speaking, &GAP; 3 did not support elements of finitely presented groups. Instead, the words in abstract generators of the underlying free groups were (mis)used. This caused problems whenever calculations with elements were involved, the most obvious ones being wrong results of element comparisons. Also functions that should in principle work for any group were not applicable to finitely presented groups. In effect, a finitely presented group had to be treated in a special way in &GAP; 3.

&GAP; 4 distinguishes free groups and their elements from finitely presented groups and their elements. Comparing two elements of a finitely presented group will yield either the correct result or no result at all.

Note that in &GAP; 4, the arithmetic and comparison operations for group elements do not depend on a context provided by a group that contains the elements. In particular, in &GAP; 4 it is not meaningful to call Order( G, g ) for a group G and an element g.

Polynomials In &GAP; 3, polynomials were defined over a field. So a polynomial over GF(3) was different from a polynomial over GF(9), even if the coefficients were exactly the same.

&GAP; 4 defines polynomials only over a characteristic. This makes it possible for example to multiply a polynomial over GF(3) with a polynomial over GF(9) without the need to convert the former to the larger field.

However it has an effect on the result of DefaultRing for polynomials: In &GAP; 3 the default ring for a polynomial was the polynomial ring of the field over which the polynomial was defined. In &GAP; 4 no field is associated, so (to avoid having to define the algebraic closure as the only other sensible alternative) the default ring of a polynomial is the DefaultRing of its coefficients.

This has an effect on Factors: If no ring is given, a polynomial is factorized over its DefaultRing and so Factors(poly) might return different results.

To be safe from this problem, if you are not working over prime fields, rather call Factors(pring,poly) with the appropriate polynomial ring and change your code accordingly.

The Info Mechanism Sometimes it is useful to get information about the progress of a calculation. Many &GAP; functions contain statements to display such information under certain conditions.

In &GAP; 3, these statements were calls to functions such as InfoGroup1 or InfoGroup2, and if the user assigned Print to these variables then this had the effect to switch on the printing of information. InfoGroup2 was used for more detailed information than InfoGroup1. One could switch off the printing again by assigning Ignore to the variables, and Ignore was also the default value.

&GAP; 4 uses one function Info for the same purpose, which is a function that takes as first argument an info class such as InfoGroup, as second argument an info level, and the print statements as remaining arguments. The level of an info class class is set to level by calling SetInfoLevel( class, level ). An Info statement is printed only if its second argument is smaller than or equal to the current info level.

test:= function( obj ) > Info( InfoGroup, 2, "This is useful, isn't it?" ); > return obj; > end;; gap> test( 1 ); 1 gap> SetInfoLevel( InfoGroup, 2 ); gap> test( 1 ); #I This is useful, isn't it? 1 ]]>

As in &GAP; 3, if an info statement is ignored then its arguments are not evaluated.

Debugging Backtrace DownEnv Where If &GAP; 4 runs into an error or is interrupted, it enters a break loop. The command Where( number ), which replaces Backtrace of &GAP; 3, can be used to display number lines of information about the current function call stack.

As in &GAP; 3, access is only possible to the variables of the current level in the function stack, but in &GAP; 4 the function DownEnv, with a positive or negative integer as argument, permits one to step down or up in the stack.

When interrupting, the first line printed by Where actually may be one level higher, as shown below.

OnBreak := function() Where(0); end;; # eliminate back-tracing on gap> # entry to break loop gap> test:= function( n ) > if n > 3 then Error( "!\n" ); fi; test( n+1 ); end;; gap> test( 1 ); Error, ! Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can 'return;' to continue brk> Where(); called from test( n + 1 ); called from test( n + 1 ); called from test( n + 1 ); called from ( ) called from read-eval-loop brk> n; 4 brk> DownEnv(); brk> n; 3 brk> Where(); called from test( n + 1 ); called from test( n + 1 ); called from ( ) called from read-eval-loop brk> DownEnv( 2 ); brk> n; 1 brk> Where(); called from ( ) called from read-eval-loop brk> DownEnv( -2 ); brk> n; 3 brk> quit; gap> OnBreak := Where;; # restore OnBreak to its default value ]]>

For purposes of debugging, it can be helpful sometimes, to see what information is stored within an object. In &GAP; 3 this was possible using RecFields because the objects in question were represented via records. For component objects, &GAP; 4 permits the same by NamesOfComponents( object ), which will list all components present.

Compatibility Mode For users who want to use &GAP; 3 code with as little changes as possible, a compatibility mode is provided by &GAP; 4. This mode must be turned on explicitly by the user.

It should be noted that this compatibility mode has not been tested thoroughly.

The compatibility mode can be turned on by loading some of the following files with ReadLib. The different files address different aspects of compatibility.

compat3a.g makes some &GAP; 3 function names available that were changed in &GAP; 4, and provides code for some &GAP; 3 features that were deliberately left out from the &GAP; 4 library. For example, almost all variable names concerning character theory that are mentioned in the &GAP; 3 manual, such as CharTable and SubgroupFusions, are available after compat3a.g has been read; the only exceptions are names of operations records. compat3b.g implements the availability of components of domains; besides components that have no meaning for the rest of the &GAP; 4 library, such as D.myInfo, there are components associated to attributes; for example D.size is redirected to the call of the attribute Size, IsBound( D.size ) to the call of its tester, and D.size:= val to the call of its setter. (An important special case is the component operations, see below.) compat3c.g permits you to implement your own elements represented as records, and using operations records to provide a Print method and the basic arithmetic operations. When using operations records, it is probably a good idea to use immutable operations records; for example, if the results of arithmetic operations are records with operations records then this avoids to create shallow copies of the operations records in the call to Immutable for the results.

The following features are accessible only via starting &GAP; with the command line option -O and may damage some features of &GAP; 4 permanently for the current session.

With this option, also the files listed above are read automatically.

compat3d.g provides some &GAP; 3 functions like Domain, simulates the &GAP; 3 behaviour of IsString (to convert a list to string representation if possible), and replaces fail by false; these changes destroy parts of the functionality of &GAP; 4.

Some words concerning the simulation of operations records may be necessary.

The operations records of the &GAP; 3 library, such as DomainOps and GroupOps, are available only for access to their components, whose values are &GAP; 4 operations; for example, the value of both DomainOps.Size and GroupOps.Size is the operation Size. So it is not safely possible to delegate from a Size method in another operations record to DomainOps.Size. Also it is not possible to change these predefined operations records.

If one wants to install individual methods for a given object obj via the mechanism of operations records then one can construct a new operations record with OperationsRecord, assign the desired methods to components of this record, and then assign the operations record to obj.operations. Whenever an operation that is associated with a component nam of the operations record is called with obj as first argument, the value of nam is chosen as the method.

In the case of the binary operations =, <, +, -, *, /, Comm, and LeftQuotient, this also happens if obj is the right-hand argument. As in &GAP; 3, if both arguments of one of the above binary operations have operations records containing a function for this operation, then the function in the operations record of the right-hand argument is chosen.

We give a small example how the compatibility mode works.

Suppose we want to deal with new objects that are derived from known field elements by distorting their multiplication. Namely, let a' and b' be the new objects corresponding to the field elements a, b, and define a' * b' = a b - a - b + 2.

In &GAP; 3, this problem was solved by representing each new object by a record that stored the corresponding old object and an operations record, where the latter was a record containing the functions applicable to the new object. After the library file compat3c.g has been read, we can use this construction of the operations record and of the new objects. Note that operations records must be created with the function OperationsRecord (this was also the norm in &GAP; 3), starting with an empty record would not work. For our intended application, we thus start with the following two lines of code.

ReadLib( "compat3c.g" ); gap> MyOps:= OperationsRecord( "MyOps" );; HasMyOps := NewFilter( "HasMyOps" ); ]]>

In order to make the translation from &GAP; 3 code to &GAP; 4 easier, &GAP; prints the definition of filters associated with operations records and the method installations for operations corresponding to components of the operations records. The output line printed by &GAP; after the call of OperationsRecord is one such case.

Now we add our multiplication function to the operations record, and again &GAP; 4 prints a translation to &GAP; 4 code.

MyOps.\* := function( a, b ) > return rec( x:= a.x * b.x - a.x - b.x + 2, > operations := MyOps ); > end;; # If the following method installation matches the requirements # of the operation `PROD' then `InstallMethod' should be used. # It might be useful to replace the rank `SUM_FLAGS' by `0'. InstallOtherMethod( PROD, "for object with `MyOps' as first argument", true, [ HasMyOps, IsObject ], SUM_FLAGS, MyOps.\* ); # For binary infix operators, a second method is installed # for the case that the object with `MyOps' is the right operand; # since this case has higher priority in GAP 3, the method is # installed with higher rank `SUM_FLAGS + 1'. InstallOtherMethod( PROD, "for object with `MyOps' as second argument", true, [ IsObject, HasMyOps ], SUM_FLAGS + 1, MyOps.\* ); ]]>

Let us look how this installation works.

a:= rec( x:= 3, operations:= MyOps ); rec( x := 3, operations := MyOps ) gap> b:= rec( x:= 5, operations:= MyOps ); rec( x := 5, operations := MyOps ) gap> a * b; rec( x := 9, operations := MyOps ) ]]>

(In more complicated cases, we might run into problems, but this was already the case in &GAP; 3. For example, suppose we want to support the multiplication of two operands having different operations records; then it is not clear which of the two multiplication functions is to be chosen, and in &GAP; 3, the only way out was to change the multiplication functions, in order to make them aware of such situations.)

If we are now interested to translate the code to &GAP; 4 in the sense that no compatibility mode is needed, we can use what &GAP; 4 has printed above. (The same example is dealt with in Chapter .)

The objects will no longer be records with operations component. Instead of records we may use so-called component objects with record-like access to components, and instead of the operations component, we give the objects a type that has the filter HasMyOps set.

(More about families and representations in this context can be found in the chapter of Programming in &GAP; mentioned above.)

The next step is to write a function that creates a new object. It may look as follows.

The multiplication function shall return an object with the filter HasMyOp, so we change it as follows.

MyMult := function( a, b ) > return MyObject( x:= a!.x * b!.x - a!.x - b!.x + 2 ); > end;; ]]>

Note that the component access for these objects works via !. instead of .; further note that no operations record needs to appear here, the filter takes its role.

Finally, we install the multiplication for at least one argument with the new filter, as had been printed by &GAP; 4 in the session shown above.

And now it works (again).

a:= MyObject( 3 ); gap> b:= MyObject( 5 ); gap> a * b; gap> last!.x 9 ]]>

We may install a method to print our objects in a nice way; we could have done this for the operations record MyOps in the compatibility mode, the printed output would look similar to the following.

Now output looks as follows.

a; b; a * b; MyObject( 3 ) MyObject( 5 ) MyObject( 9 ) ]]>

Maybe now we want to improve the installation. The multiplication function we want to use is apparently thought only for the case that both operands have the filter HasMyOps (and a component x). So it is reasonable to replace the two methods for the multiplication by one method for which both arguments are required to have the filter.

At first sight, the &GAP; 4 approach seems to be much more complicated. But the last example shows that in &GAP; 4, each method can be installed more specifically for the appropriate situation. Moreover, it is for example possible to install a method for the multiplication of an integer and a HasMyOps object; note that --contrary to the situation in &GAP; 3-- such a method is independent from already existing methods in the sense that these need not be changed when new functionality is added.

Another example that uses this part of the compatibility mode can be found in the file tst/compat3.tst of the &GAP; 4 distribution. gap-4r6p5/doc/tut/extractexamples.g0000644000175000017500000000152012172557252016101 0ustar billbill# This code extracts the examples from the ref manual chapter-wise and # stores this in a workspace. Read("makedocreldata.g"); exstut := ExtractExamples(GAPInfo.ManualDataTut.pathtodoc, GAPInfo.ManualDataTut.main, GAPInfo.ManualDataTut.files, "Chapter"); RS := rec(changeSources := true); WS := rec(compareFunction := "uptowhitespace"); WSRS := rec(changeSources := true, compareFunction := "uptowhitespace"); WriteTutExamplesTst := function(fnam) local ch, i, a; PrintTo(fnam,"gap> save:=SizeScreen();; SizeScreen([72,save[2]]);;\n"); for i in [1..Length(exstut)] do ch := exstut[i]; AppendTo(fnam, "\n#### Tutorial, Chapter ",i," ####\n", "gap> START_TEST(\"", i, "\");\n"); for a in ch do AppendTo(fnam, "\n# ",a[2], a[1]); od; od; AppendTo(fnam, "gap> SizeScreen(save);;\n"); end; gap-4r6p5/doc/tut/function.xml0000644000175000017500000002760412172557252015102 0ustar billbill

Functions You have already seen how to use functions in the &GAP; library, i.e., how to apply them to arguments.

In this section you will see how to write functions in the &GAP; language. You will also see how to use the if statement and declare local variables with the local statement in the function definition. Loop constructions via while and for are discussed further, as are recursive functions.

Writing Functions

Writing a function that prints hello, world. on the screen is a simple exercise in &GAP;.

sayhello:= function() > Print("hello, world.\n"); > end; function( ) ... end ]]>

This function when called will only execute the Print statement in the second line. This will print the string hello, world. on the screen followed by a newline character \n that causes the &GAP; prompt to appear on the next line rather than immediately following the printed characters.

The function definition has the following syntax.

function( arguments ) statements end

A function definition starts with the keyword function followed by the formal parameter list arguments enclosed in parenthesis ( ). The formal parameter list may be empty as in the example. Several parameters are separated by commas. Note that there must be no semicolon behind the closing parenthesis. The function definition is terminated by the keyword end.

A &GAP; function is an expression like an integer, a sum or a list. Therefore it may be assigned to a variable. The terminating semicolon in the example does not belong to the function definition but terminates the assignment of the function to the name sayhello. Unlike in the case of integers, sums, and lists the value of the function sayhello is echoed in the abbreviated fashion function( ) ... end. This shows the most interesting part of a function: its formal parameter list (which is empty in this example). The complete value of sayhello is returned if you use the function .

Print(sayhello, "\n"); function ( ) Print( "hello, world.\n" ); return; end ]]>

Note the additional newline character "\n" in the statement. It is printed after the object sayhello to start a new line. The extra return statement is inserted by &GAP; to simplify the process of executing the function.

The newly defined function sayhello is executed by calling sayhello() with an empty argument list.

sayhello(); hello, world. ]]>

However, this is not a typical example as no value is returned but only a string is printed.

If Statements In the following example we define a function sign which determines the sign of an integer.

sign:= function(n) > if n < 0 then > return -1; > elif n = 0 then > return 0; > else > return 1; > fi; > end; function( n ) ... end gap> sign(0); sign(-99); sign(11); 0 -1 1 ]]>

This example also introduces the if statement which is used to execute statements depending on a condition. The if statement has the following syntax.

if condition then statements elif condition then statements else statements fi

There may be several elif parts. The elif part as well as the else part of the if statement may be omitted. An if statement is no expression and can therefore not be assigned to a variable. Furthermore an if statement does not return a value.

Fibonacci numbers are defined recursively by f(1) = f(2) = 1 and f(n) = f(n-1) + f(n-2) for n \geq 3. Since functions in &GAP; may call themselves, a function fib that computes Fibonacci numbers can be implemented basically by typing the above equations. (Note however that this is a very inefficient way to compute f(n).)

fib:= function(n) > if n in [1, 2] then > return 1; > else > return fib(n-1) + fib(n-2); > fi; > end; function( n ) ... end gap> fib(15); 610 ]]>

There should be additional tests for the argument n being a positive integer. This function fib might lead to strange results if called with other arguments. Try inserting the necessary tests into this example.

Local Variables A function gcd that computes the greatest common divisor of two integers by Euclid's algorithm will need a variable in addition to the formal arguments.

gcd:= function(a, b) > local c; > while b <> 0 do > c:= b; > b:= a mod b; > a:= c; > od; > return c; > end; function( a, b ) ... end gap> gcd(30, 63); 3 ]]>

The additional variable c is declared as a local variable in the local statement of the function definition. The local statement, if present, must be the first statement of a function definition. When several local variables are declared in only one local statement they are separated by commas.

The variable c is indeed a local variable, that is local to the function gcd. If you try to use the value of c in the main loop you will see that c has no assigned value unless you have already assigned a value to the variable c in the main loop. In this case the local nature of c in the function gcd prevents the value of the c in the main loop from being overwritten.

c:= 7;; gap> gcd(30, 63); 3 gap> c; 7 ]]>

We say that in a given scope an identifier identifies a unique variable. A scope is a lexical part of a program text. There is the global scope that encloses the entire program text, and there are local scopes that range from the function keyword, denoting the beginning of a function definition, to the corresponding end keyword. A local scope introduces new variables, whose identifiers are given in the formal argument list and the local declaration of the function. The usage of an identifier in a program text refers to the variable in the innermost scope that has this identifier as its name.

Recursion We have already seen recursion in the function fib in Section . Here is another, slightly more complicated example.

We will now write a function to determine the number of partitions of a positive integer. A partition of a positive integer is a descending list of numbers whose sum is the given integer. For example [4,2,1,1] is a partition of 8. Note that there is just one partition of 0, namely [ ]. The complete set of all partitions of an integer n may be divided into subsets with respect to the largest element. The number of partitions of n therefore equals the sum of the numbers of partitions of n-i with elements less than or equal to i for all possible i. More generally the number of partitions of n with elements less than m is the sum of the numbers of partitions of n-i with elements less than i for i less than m and n. This description yields the following function.

nrparts:= function(n) > local np; > np:= function(n, m) > local i, res; > if n = 0 then > return 1; > fi; > res:= 0; > for i in [1..Minimum(n,m)] do > res:= res + np(n-i, i); > od; > return res; > end; > return np(n,n); > end; function( n ) ... end ]]>

We wanted to write a function that takes one argument. We solved the problem of determining the number of partitions in terms of a recursive procedure with two arguments. So we had to write in fact two functions. The function nrparts that can be used to compute the number of partitions indeed takes only one argument. The function np takes two arguments and solves the problem in the indicated way. The only task of the function nrparts is to call np with two equal arguments.

We made np local to nrparts. This illustrates the possibility of having local functions in &GAP;. It is however not necessary to put it there. np could as well be defined on the main level, but then the identifier np would be bound and could not be used for other purposes, and if it were used the essential function np would no longer be available for nrparts.

Now have a look at the function np. It has two local variables res and i. The variable res is used to collect the sum and i is a loop variable. In the loop the function np calls itself again with other arguments. It would be very disturbing if this call of np was to use the same i and res as the calling np. Since the new call of np creates a new scope with new variables this is fortunately not the case.

Note that the formal parameters n and m of np are treated like local variables.

(Regardless of the recursive structure of an algorithm it is often cheaper (in terms of computing time) to avoid a recursive implementation if possible (and it is possible in this case), because a function call is not very cheap.)

Further Information about Functions The function syntax is described in Section . The if statement is described in more detail in Section . More about Fibonacci numbers is found in Section and more about partitions in Section .
gap-4r6p5/doc/tut/makedocrel-new.g0000644000175000017500000000203312172557252015565 0ustar billbill## this creates the documentation, needs: ## GAPDoc package, latex, pdflatex, mkindex ## LoadPackage( "GAPDoc" ); Reread ("../conv/MakeLaTeX.gi"); Reread ("../conv/MakeHTML.gi"); Reread ("../conv/MakeText.gi"); Reread ("../conv/MakeBWText.gi"); Read ("../conv/BuildManual.g"); Read( "makedocreldata.g" ); Exec( "ln -s -f ../conv/manual.css manual.css" ); Exec( "ln -s -f ../conv/java.css java.css" ); Exec( "ln -s -f ../conv/toggle.js toggle.js" ); Exec( "ln -s -f ../conv/open.png open.png" ); Exec( "ln -s -f ../conv/closed.png closed.png" ); Exec( "ln -s -f ../conv/empty.png empty.png" ); if not IsDirectoryPath ("textmarkup") then Exec ("mkdir textmarkup"); fi; BuildManuals (rec( bookname := GAPInfo.ManualDataTut.bookname, pathtodoc := GAPInfo.ManualDataTut.pathtodoc, main := GAPInfo.ManualDataTut.main, pathtoroot := GAPInfo.ManualDataTut.pathtoroot, files := GAPInfo.ManualDataTut.files, htmlspecial := ["MathJax"])); ############################################################################# ## #E gap-4r6p5/doc/tut/main.xml0000644000175000017500000000360612172557252014175 0ustar billbill Atlas"> —---"> <#Include SYSTEM "../versiondata"> ]> GAP — A Tutorial Release &VERSIONNUMBER;, &RELEASEDAY; The GAP Group support@gap-system.org http://www.gap-system.org Copyright ©right; (1987-&RELEASEYEAR;) for the core part of the &GAP; system by the &GAP; Group.

Most parts of this distribution, including the core part of the &GAP; system are distributed under the terms of the GNU General Public License, see http://www.gnu.org/licenses/gpl.html or the file GPL in the etc directory of the &GAP; installation.

More detailed information about copyright and licenses of parts of this distribution can be found in .

&GAP; is developed over a long time and has many authors and contributors. More detailed information can be found in . <#Include SYSTEM "preface.xml"> <#Include SYSTEM "introduc.xml"> <#Include SYSTEM "lists.xml"> <#Include SYSTEM "function.xml"> <#Include SYSTEM "group.xml"> <#Include SYSTEM "algvspc.xml"> <#Include SYSTEM "domain.xml"> <#Include SYSTEM "opers.xml"> gap-4r6p5/doc/tut/introduc.xml0000644000175000017500000010144412172557252015077 0ustar billbill

A First Session with &GAP;

This tutorial introduces you to the &GAP; system. It is written with users in mind who have just managed to start &GAP; for the first time on their computer and want to learn the basic facts about &GAP; by playing around with some instructive examples. Therefore, this tutorial contains at many places examples consisting of several lines of input (which you should type on your terminal) followed by the corresponding output ( which &GAP; produces as an answer to your input).

We encourage you to actually run through these examples on your computer. This will support your feeling for &GAP; as a tool, which is the leading aim of this tutorial. Do not believe any statement in it as long as you cannot verify it for your own version of &GAP;. You will learn to distinguish between small deviations of the behavior of your personal &GAP; from the printed examples and serious nonsense.

Since the printing routines of &GAP; are in some sense machine dependent you will for instance encounter a different layout of the printed objects in different environments. But the contents should always be the same. In case you encounter serious nonsense it is highly recommended that you send a bug report to support@gap-system.org.

The examples in this tutorial should explain everything you have to know in order to be able to use &GAP;. The reference manual then gives a more systematic treatment of the various types of objects that &GAP; can manipulate. It seems desirable neither to start this systematic course with the most elementary (and most boring) structures, nor to confront you with all the complex data types before you know how they are composed from elementary structures. For this reason this tutorial wants to provide you with a basic understanding of &GAP; objects, on which the reference manual will then build when it explains everything in detail. So after having mastered this tutorial, you can immediately plunge into the exciting parts of &GAP; and only read detailed information about elementary things (in the reference manual) when you really need them.

Each chapter of this tutorial contains a section with references to the reference manual at the end.

Starting and Leaving &GAP;

starting &GAP; leaving &GAP; quit If the program is correctly installed then you usually start &GAP; by simply typing gap at the prompt of your operating system followed by the Return key, sometimes this is also called the Newline key.

&GAP; answers your request with its beautiful banner and then it shows its own prompt gap> asking you for further input. (You can avoid the banner with the command line option -b; more command line options are described in Section .)

]]>

The usual way to end a &GAP; session is to type quit; at the gap> prompt. Do not omit the semicolon!

quit; $ ]]>

On some systems you could type Ctrl-D to yield the same effect. In any situation &GAP; is ended by typing Ctrl-C twice within a second. Here as always, a combination like Ctrl-D means that you have to press the D key while you hold down the Ctrl key.

On some systems (for example the Apple Macintosh) minor changes might be necessary. This is explained in &GAP; installation instructions (see the INSTALL file in the &GAP; root directory, or the &GAP; website).

whitespace In most places whitespace characters (i.e. Spaces, Tabs and Returns) are insignificant for the meaning of &GAP; input. Identifiers and keywords must however not contain any whitespace. On the other hand, sometimes there must be whitespace around identifiers and keywords to separate them from each other and from numbers. We will use whitespace to format more complicated commands for better readability.

comments A comment in &GAP; starts with the symbol # and continues to the end of the line. Comments are treated like whitespace by &GAP;. We use comments in the printed examples in this tutorial to explain certain lines of input or output.

Loading Source Code from a File loading source code from a file reading source code from a file Read The most convenient way of creating larger pieces of &GAP; code is to write them to some text file. For this purpose you can simply use your favorite text editor. You can load such a file into &GAP; using the function:

Read("../../GAPProgs/Example.g"); ]]>

You can either give the full absolute path name of the source file or its relative path name from the &GAP; root directory (the directory containing bin/, doc/, lib/, etc.).

The Read Evaluate Print Loop read evaluate print loop &GAP; is an interactive system. It continuously executes a read evaluate print loop. Each expression you type at the keyboard is read by &GAP;, evaluated, and then the result is shown.

The interactive nature of &GAP; allows you to type an expression at the keyboard and see its value immediately. You can define a function and apply it to arguments to see how it works. You may even write whole programs containing lots of functions and test them without leaving the program.

When your program is large it will be more convenient to write it on a file and then read that file into &GAP;. Preparing your functions in a file has several advantages. You can compose your functions more carefully in a file (with your favorite text editor), you can correct errors without retyping the whole function and you can keep a copy for later use. Moreover you can write lots of comments into the program text, which are ignored by &GAP;, but are very useful for human readers of your program text. &GAP; treats input from a file in the same way that it treats input from the keyboard. Further details can be found in section .

A simple calculation with &GAP; is as easy as one can imagine. You type the problem just after the prompt, terminate it with a semicolon and then pass the problem to the program with the Return key. For example, to multiply the difference between 9 and 7 by the sum of 5 and 6, that is to calculate (9 - 7) * (5 + 6), you type exactly this last sequence of symbols followed by ; and Return.

(9 - 7) * (5 + 6); 22 gap> ]]>

Then &GAP; echoes the result 22 on the next line and shows with the prompt that it is ready for the next problem. Henceforth, we will no longer print this additional prompt.

line editing If you make a mistake while typing the line, but before typing the final Return, you can use the Delete key (or sometimes Backspace key) to delete the last typed character. You can also move the cursor back and forward in the line with Ctrl-B and Ctrl-F and insert or delete characters anywhere in the line. The line editing commands are fully described in section .

If you did omit the semicolon at the end of the line but have already typed Return, then &GAP; has read everything you typed, but does not know that the command is complete. The program is waiting for further input and indicates this with a partial prompt >. This problem is solved by simply typing the missing semicolon on the next line of input. Then the result is printed and the normal prompt returns.

(9 - 7) * (5 + 6) > ; 22 ]]>

So the input can consist of several lines, and &GAP; prints a partial prompt > in each input line except the first, until the command is completed with a semicolon. (&GAP; may already evaluate part of the input when Return is typed, so for long calculations it might take some time until the partial prompt appears.) Whenever you see the partial prompt and you cannot decide what &GAP; is still waiting for, then you have to type semicolons until the normal prompt returns. In every situation the exact meaning of the prompt gap> is that the program is waiting for a new problem.

But even if you mistyped the command more seriously, you do not have to type it all again. Suppose you mistyped or forgot the last closing parenthesis. Then your command is syntactically incorrect and &GAP; will notice it, incapable of computing the desired result.

(9 - 7) * (5 + 6; Syntax error: ) expected (9 - 7) * (5 + 6; ^ ]]>

line editing Instead of the result an error message occurs indicating the place where an unexpected symbol occurred with an arrow sign ^ under it. As a computer program cannot know what your intentions really were, this is only a hint. But in this case &GAP; is right by claiming that there should be a closing parenthesis before the semicolon. Now you can type Ctrl-P to recover the last line of input. It will be written after the prompt with the cursor in the first position. Type Ctrl-E to take the cursor to the end of the line, then Ctrl-B to move the cursor one character back. The cursor is now on the position of the semicolon. Enter the missing parenthesis by simply typing ). Now the line is correct and may be passed to &GAP; by hitting the Return key. Note that for this action it is not necessary to move the cursor past the last character of the input line.

Each line of commands you type is sent to &GAP; for evaluation by pressing Return regardless of the position of the cursor in that line. We will no longer mention the Return key from now on.

break loops Sometimes a syntax error will cause &GAP; to enter a break loop. This is indicated by the special prompt brk>. If another syntax error occurs while &GAP; is in a break loop, the prompt will change to brk_02>, brk_03> and so on. You can leave the current break loop and exit to the next outer one by either typing quit; or by hitting Ctrl-D. Eventually &GAP; will return to its normal state and show its normal prompt gap> again.

Constants and Operators constantsoperators In an expression like (9 - 7) * (5 + 6) the constants 5, 6, 7, and 9 are being composed by the operators +, * and - to result in a new value.

There are three kinds of operators in &GAP;, arithmetical operators, comparison operators, and logical operators. You have already seen that it is possible to form the sum, the difference, and the product of two integer values. There are some more operators applicable to integers in &GAP;. Of course integers may be divided by each other, possibly resulting in noninteger rational values.

12345/25; 2469/5 ]]>

Note that the numerator and denominator are divided by their greatest common divisor and that the result is uniquely represented as a division instruction.

The next self-explanatory example demonstrates negative numbers.

-3; 17 - 23; -3 -6 ]]>

The exponentiation operator is written as ^. This operation in particular might lead to very large numbers. This is no problem for &GAP; as it can handle numbers of (almost) any size.

3^132; 955004950796825236893190701774414011919935138974343129836853841 ]]>

The mod operator allows you to compute one value modulo another.

17 mod 3; 2 ]]>

Note that there must be whitespace around the keyword mod in this example since 17mod3 or 17mod would be interpreted as identifiers. The whitespace around operators that do not consist of letters, e.g., the operators * and -, is not necessary.

&GAP; knows a precedence between operators that may be overridden by parentheses.

(9 - 7) * 5 = 9 - 7 * 5; false ]]>

Besides these arithmetical operators there are comparison operators in &GAP;. A comparison results in a boolean value which is another kind of constant. The comparison operators =, <>, <, <=, > and >=, test for equality, inequality, less than, less than or equal, greater than and greater than or equal, respectively.

10^5 < 10^4; false ]]>

The boolean values true and false can be manipulated via logical operators, i. e., the unary operator not and the binary operators and and or. Of course boolean values can be compared, too.

not true; true and false; true or false; false false true gap> 10 > 0 and 10 < 100; true ]]>

Another important type of constants in &GAP; are permutations. They are written in cycle notation and they can be multiplied.

(1,2,3); (1,2,3) gap> (1,2,3) * (1,2); (2,3) ]]>

The inverse of the permutation (1,2,3) is denoted by (1,2,3)^-1. Moreover the caret operator ^ is used to determine the image of a point under a permutation and to conjugate one permutation by another.

(1,2,3)^-1; (1,3,2) gap> 2^(1,2,3); 3 gap> (1,2,3)^(1,2); (1,3,2) ]]>

The various other constants that &GAP; can deal with will be introduced when they are used, for example there are elements of finite fields such as Z(8), and complex roots of unity such as E(4).

The last type of constants we want to mention here are the characters, which are simply objects in &GAP; that represent arbitrary characters from the character set of the operating system. Character literals can be entered in &GAP; by enclosing the character in singlequotes '.

'a'; 'a' gap> '*'; '*' ]]>

There are no operators defined for characters except that characters can be compared.

In this section you have seen that values may be preceded by unary operators and combined by binary operators placed between the operands. There are rules for precedence which may be overridden by parentheses. A comparison results in a boolean value. Boolean values are combined via logical operators. Moreover you have seen that &GAP; handles numbers of arbitrary size. Numbers and boolean values are constants. There are other types of constants in &GAP; like permutations. You are now in a position to use &GAP; as a simple desktop calculator.

Variables versus Objects variablesassignmentidentifierobjects objects The constants described in the last section are specified by certain combinations of digits and minus signs (in the case of integers) or digits, commas and parentheses (in the case of permutations). These sequences of characters always have the same meaning to &GAP;. On the other hand, there are variables, specified by a sequence of letters and digits (including at least one letter), and their meaning depends on what has been assigned to them. An assignment is done by a &GAP; command sequence_of_letters_and_digits := meaning, where the sequence on the left hand side is called the identifier of the variable and it serves as its name. The meaning on the right hand side can be a constant like an integer or a permutation, but it can also be almost any other &GAP; object. From now on, we will use the term object to denote something that can be assigned to a variable.

There must be no whitespace between the : and the = in the assignment operator. Also do not confuse the assignment operator with the single equality sign = which in &GAP; is only used for the test of equality.

a:= (9 - 7) * (5 + 6); 22 gap> a; 22 gap> a * (a + 1); 506 gap> a = 10; false gap> a:= 10; 10 gap> a * (a + 1); 110 ]]>

After an assignment the assigned object is echoed on the next line. The printing of the object of a statement may be in every case prevented by typing a double semicolon.

w:= 2;; ]]>

After the assignment the variable evaluates to that object if evaluated. Thus it is possible to refer to that object by the name of the variable in any situation.

This is in fact the whole secret of an assignment. An identifier is bound to an object and from this moment points to that object. Nothing more. This binding is changed by the next assignment to that identifier. An identifier does not denote a block of memory as in some other programming languages. It simply points to an object, which has been given its place in memory by the &GAP; storage manager. This place may change during a &GAP; session, but that doesn't bother the identifier. The identifier points to the object, not to a place in the memory.

For the same reason it is not the identifier that has a type but the object. This means on the other hand that the identifier a which now is bound to an integer object may in the same session point to any other object regardless of its type.

Identifiers may be sequences of letters and digits containing at least one letter. For example abc and a0bc1 are valid identifiers. But also 123a is a valid identifier as it cannot be confused with any number. Just 1234 indicates the number 1234 and cannot be at the same time the name of a variable.

Since &GAP; distinguishes upper and lower case, a1 and A1 are different identifiers. Keywords such as quit must not be used as identifiers. You will see more keywords in the following sections.

In the remaining part of this manual we will ignore the difference between variables, their names (identifiers), and the objects they point to. It may be useful to think from time to time about what is really meant by terms such as the integer w.

There are some predefined variables coming with &GAP;. Many of them you will find in the remaining chapters of this manual, since functions are also referred to via identifiers.

You can get an overview of all &GAP; variables by entering NamesGVars(). Many of these are predefined. If you are interested in the variables you have defined yourself in the current &GAP; session, you can enter NamesUserGVars().

NamesUserGVars(); [ "a", "w" ] ]]>

This seems to be the right place to state the following rule: The name of every global variable in the &GAP; library starts with a capital letter. Thus if you choose only names starting with a small letter for your own variables you will not attempt to overwrite any predefined variable. (Note that most of the predefined variables are read-only, and trying to change their values will result in an error message.)

There are some further interesting variables one of which will be introduced now.

last last2 last3 Whenever &GAP; returns an object by printing it on the next line this object is assigned to the variable last. So if you computed

(9 - 7) * (5 + 6); 22 ]]>

and forgot to assign the object to the variable a for further use, you can still do it by the following assignment.

a:= last; 22 ]]>

Moreover there are variables last2 and last3, you can guess their values.

In this section you have seen how to assign objects to variables. These objects can later be accessed through the name of the variable, its identifier. You have also encountered the useful concept of the last variables storing the latest returned objects. And you have learned that a double semicolon prevents the result of a statement from being printed.

Objects vs. Elements objects elements In the last section we mentioned that every object is given a certain place in memory by the &GAP; storage manager (although that place may change in the course of a &GAP; session). In this sense, objects at different places in memory are never equal, and if the object pointed to by the variable a (to be more precise, the variable with identifier a) is equal to the object pointed to by the variable b, then we should better say that they are not only equal but identical. &GAP; provides the function to test whether this is the case.

a:= (1,2);; IsIdenticalObj( a, a ); true gap> b:= (1,2);; IsIdenticalObj( a, b ); false gap> b:= a;; IsIdenticalObj( a, b ); true ]]>

IsIdenticalObj

As the above example indicates, &GAP; objects a and b can be unequal although they are equal from a mathematical point of view, i.e., although we should have a = b. It may be that the objects a and b are stored in different places in memory, or it may be that we have an equivalence relation defined on the set of objects under which a and b belong to the same equivalence class. For example, if a = x^3 and b = x^{{-5}} are words in the finitely presented group \langle x \mid x^2 = 1 \rangle, we would have a = b in that group.

&GAP; uses the equality operator = to denote such a mathematical equality, not the identity of objects. Hence we often have a = b although IsIdenticalObj( a, b ) = false. The operator = defines an equivalence relation on the set of all &GAP; objects, and we call the corresponding equivalence classes elements. Phrasing it differently, the same element may be represented by various &GAP; objects.

Non-trivial examples of elements that are represented by different objects (objects that really look different, not ones that are merely stored in different memory places) will occur only when we will be considering composite objects such as lists or domains.

About Functions A program written in the &GAP; language is called a function. Functions are special &GAP; objects. Most of them behave like mathematical functions. They are applied to objects and will return a new object depending on the input. The function , for example, can be applied to an integer and will return the factorial of this integer.

Factorial(17); 355687428096000 ]]>

Applying a function to arguments means to write the arguments in parentheses following the function. Several arguments are separated by commas, as for the function which computes the greatest common divisor of two integers.

Gcd(1234, 5678); 2 ]]>

There are other functions that do not return an object but only produce a side effect, for example changing one of their arguments. These functions are sometimes called procedures. The function is only called for the side effect of printing something on the screen.

Print(1234, "\n"); 1234 ]]>

In order to be able to compose arbitrary text with , this function itself will not produce a line break after printing. Thus we had another newline character "\n" printed to start a new line.

Some functions will both change an argument and return an object such as the function that sorts a list and returns the permutation of the list elements that it has performed. You will not understand right now what it means to change an object. We will return to this subject several times in the next sections.

maps-to operator A comfortable way to define a function yourself is the maps-to operator -> consisting of a minus sign and a greater sign with no whitespace between them. The function cubed which maps a number to its cube is defined on the following line.

cubed:= x -> x^3; function( x ) ... end ]]>

After the function has been defined, it can now be applied.

cubed(5); 125 ]]>

More complicated functions, especially functions with more than one argument cannot be defined in this way. You will see how to write your own &GAP; functions in Section .

In this section you have seen &GAP; objects of type function. You have learned how to apply a function to arguments. This yields as result a new object or a side effect. A side effect may change an argument of the function. Moreover you have seen an easy way to define a function in &GAP; with the maps-to operator.

Help The content of the &GAP; manuals is also available as on-line help. A &GAP; session loads a long list of index entries. This typically contains all chapter and section headers, all names of documented functions, operations and so on, as well as some explicit index entries defined in the manuals.

The format of a query is as follows.

?[book:][?]topic

A simple example would be to type ?help at the &GAP; prompt. If there is a single section with index entry topic then this is displayed directly.

If there are several matches you get an overview like in the example below.

?sets Help: several entries match this topic - type ?2 to get match [2] [1] Tutorial: Sets [2] Reference: Sets [3] Reference: sets [4] Reference: Sets of Subgroups [5] Reference: setstabilizer ]]>

&GAP;'s manuals consist of several books, which are indicated before the colon in the list above. A help query can be restricted to one book by using the optional book: part. For example ?tut : sets will display the first of these help sections. More precisely, the parts of the string book which are separated by white space are interpreted as beginnings of the first words in the name of the book. Try ?books to see the list of available books and their names.

The search for a matching topic (and optional book) is done case insensitively. If there is another ? before the topic, then a substring search for topic is performed on all index entries. Otherwise the parts of topic which are separated by white space are considered as beginnings of the first words in an index entry.

White space is normalized in the search string (and the index entries).

Examples. All the following queries lead to the chapter of the reference manual which explains the use of &GAP;'s help system in more detail.

?Reference: The Help System gap> ? REF : t h s gap> ?ref:? help system ]]>

The query ??sets shows all help sections in all books whose index entries contain the substring sets.

As mentioned in the example above a complete list of commands for the help system is available in Section ?Ref: The Help System of the reference manual. In particular there are commands to browse through the help sections, see ?Ref: Browsing through the Sections and there is a way to influence the way how the help sections are displayed, see ?Ref: SetHelpViewer. For example you can use an external pager program, a Web browser, dvi-previewer and/or pdf-viewer for reading &GAP;'s online help.

Further Information introducing the System For large amounts of input data, it might be advisable to write your input first into a file, and then read this into &GAP;; see , for this.

The definition of the &GAP; syntax can be looked up in Chapter . A complete list of command line editing facilities is found in Section . The break loop is described in Section .

Operators are explained in more detail in Sections  and . You will find more information about boolean values in Chapters  and . Permutations are described in Chapter  and characters in Chapter .

Variables and assignments are described in more detail in  and . A complete list of keywords is contained in .

More about functions can be found in  and .

gap-4r6p5/doc/tut/authors.xml0000644000175000017500000001620012172557252014730 0ustar billbill The following list gives the authors (indicated by A) who designed the code in the first place, as well as the current maintainers (indicated by M) of the various modules of which &GAP; is composed.

Since the process of modularization was started only recently, there might be omissions both in scope and in contributors. The compilers of the manual apologize for any such errors and promise to rectify them in future editions.

Kernel Frank Celler (A), Steve Linton (AM), Frank Lübeck (AM), Werner Nickel (AM), Martin Schönert (A) Automorphism groups of finite pc groups Bettina Eick (A), Werner Nickel (M) Binary Relations Robert Morse (AM), Andrew Solomon (A) Characters and Character Degrees of certain solvable groups Hans Ulrich Besche (A), Thomas Breuer (AM) Classes in nonsolvable groups Alexander Hulpke (AM) Classical Groups Thomas Breuer (AM), Frank Celler (A), Stefan Kohl (AM), Frank Lübeck (AM), Heiko Theißen (A) Congruences of magmas, semigroups and monoids Robert Morse (AM), Andrew Solomon (A) Cosets and Double Cosets Alexander Hulpke (AM) Cyclotomics Thomas Breuer (AM) Dixon-Schneider Algorithm Alexander Hulpke (AM) Documentation Utilities Frank Celler (A), Heiko Theißen (A), Alexander Hulpke (A), Willem de Graaf (A), Steve Linton (A), Werner Nickel (A), Greg Gamble (AM) Factor groups Alexander Hulpke (AM) Finitely presented groups Volkmar Felsch (A), Alexander Hulpke (AM), Martin Schönert (A) Finitely presented monoids and semigroups Isabel Araújo (A), Derek Holt (A), Alexander Hulpke (A), James Mitchell (M), Götz Pfeiffer (A), Andrew Solomon (A) &GAP; for MacOS Burkhard Höfling (AM) Group actions Heiko Theißen (A) and Alexander Hulpke (AM) Homomorphism search Alexander Hulpke (AM) Homomorphisms for finitely presented groups Alexander Hulpke (AM) Identification of Galois groups Alexander Hulpke (AM) Intersection of subgroups of finite pc groups Frank Celler (A), Bettina Eick (A), Werner Nickel (M) Irreducible Modules over finite fields for finite pc groups Bettina Eick (AM) Isomorphism testing with random methods Hans Ulrich Besche (AM), Bettina Eick (AM) Lie algebras Thomas Breuer (A), Craig Struble (A), Juergen Wisliceny (A), Willem A. de Graaf (AM) Monomiality Questions Thomas Breuer (AM), Erzsébet Horváth (A) Multiplier and Schur cover Werner Nickel (AM), Alexander Hulpke (AM) One-Cohomology and Complements Frank Celler (A) and Alexander Hulpke (AM) Partition Backtrack algorithm Heiko Theißen (A), Alexander Hulpke (M) Permutation group composition series Ákos Seress (AM) Permutation group homomorphisms Ákos Seress (AM), Heiko Theißen (A), Alexander Hulpke (M) Permutation Group Pcgs Heiko Theißen (A), Alexander Hulpke (M) Possible Permutation Characters Thomas Breuer (AM), Götz Pfeiffer (A) Possible Class Fusions, Possible Power Maps Thomas Breuer (AM) Primitive groups library Heiko Theißen (A), Colva Roney-Dougal (AM) Properties and attributes of finite pc groups Frank Celler (A), Bettina Eick (A), Werner Nickel (M) Random Schreier-Sims Ákos Seress (AM) Rational Functions Frank Celler (A) and Alexander Hulpke (AM) Semigroup relations Isabel Araújo (A), Robert F. Morse (AM), Andrew Solomon (A) Special Pcgs for finite pc groups Bettina Eick (AM) Stabilizer Chains Ákos Seress (AM), Heiko Theißen (A), Alexander Hulpke (M) Strings and Characters Martin Schönert (A), Frank Celler (A), Thomas Breuer (A), Frank Lübeck (AM) Structure Descriptions for Finite Groups Stefan Kohl (AM), Markus Püschel (A), Sebastian Egner (A) Subgroup lattice Martin Schönert (A), Alexander Hulpke (AM) Subgroup lattice for solvable groups Alexander Hulpke (AM) Subgroup presentations Volkmar Felsch (A), Werner Nickel (M) The Help System Frank Celler (A), Frank Lübeck (AM) Tietze transformations Volkmar Felsch (A), Werner Nickel (M) Transformation semigroups Isabel Araújo (A), Robert Arthur (A), Robert F. Morse (AM), Andrew Solomon (A) Transitive groups library Alexander Hulpke (AM) Two-cohomology and extensions of finite pc groups Bettina Eick (AM) gap-4r6p5/doc/tut/makedocrel.g0000644000175000017500000000163412172557252015004 0ustar billbill## this creates the documentation, needs: GAPDoc package, latex, pdflatex, ## mkindex, dvips ## Read( "makedocreldata.g" ); SetGapDocLaTeXOptions("nocolor"); MakeGAPDocDoc( GAPInfo.ManualDataTut.pathtodoc, GAPInfo.ManualDataTut.main, GAPInfo.ManualDataTut.files, GAPInfo.ManualDataTut.bookname, GAPInfo.ManualDataTut.pathtoroot, "MathJax" );; Exec ("mv -f manual.pdf manual-bw.pdf"); SetGapDocLaTeXOptions("color"); MakeGAPDocDoc( GAPInfo.ManualDataTut.pathtodoc, GAPInfo.ManualDataTut.main, GAPInfo.ManualDataTut.files, GAPInfo.ManualDataTut.bookname, GAPInfo.ManualDataTut.pathtoroot, "MathJax" );; GAPDocManualLabFromSixFile( "tut", "manual.six" );; CopyHTMLStyleFiles("."); ############################################################################# ## #E gap-4r6p5/doc/tut/preface.xml0000644000175000017500000000456412172557252014662 0ustar billbill Preface Welcome to &GAP;. This preface serves not only to introduce this manual, the &GAP; Tutorial, but also as an introduction to the system as a whole.

&GAP; stands for Groups, Algorithms and Programming. The name was chosen to reflect the aim of the system, which is introduced in this tutorial manual. Since that choice, the system has become somewhat broader, and you will also find information about algorithms and programming for other algebraic structures, such as semigroups and algebras.

In addition to this manual, there is the &GAP; Reference Manual (see ) containing detailed documentation of the mathematical functionality of &GAP;, and the manual called &GAP; - Changes from Earlier Versions (see ) which describes most essential changes from previous &GAP; releases.

A lot of the functionality of the system and a number of contributed extensions are provided as &GAP; packages and each of these has its own manual.

Subsequent sections of this preface explain the structure of the system and list sources of further information about &GAP;.

The &GAP; System <#Include SYSTEM "../ref/overview.xml">
Further Information about &GAP; <#Include SYSTEM "../ref/moreinfo.xml">
gap-4r6p5/doc/changes/0000755000175000017500000000000012174560027013312 5ustar billbillgap-4r6p5/doc/changes/changes45.xml0000644000175000017500000015314412172557252015631 0ustar billbill Changes between &GAP; 4.4 and &GAP; 4.5 This chapter lists most important changes between &GAP; 4.4.12 and the first public release of &GAP; 4.5. It also contains information about subsequent update releases for &GAP; 4.5. It is not meant to serve as a complete account on all improvements; instead, it should be viewed as an introduction to &GAP; 4.5, accompanying its release announcement.
Changes in the core &GAP; system introduced in &GAP; 4.5 In this section we list most important new features and bugfixes in the core system introduced in &GAP; 4.5. For the list of changes in the interface between the core system and packages as well as for an overview of new and updated packages, see Section . Improved functionality Performance improvements: GMP support The &GAP; kernel now uses GMP (GNU multiple precision arithmetic library, http://gmplib.org/) for faster large integer arithmetic. Improved performance for records with large number of components. Speedup of hash tables implementation at the &GAP; library level. is now much more efficient, in particular for large objects. Speedups in the computation of low index subgroups, Tietze transformations, calculating high powers of matrices over finite fields, , etc. New and improved kernel functionality: By default, the &GAP; kernel compiles with the GMP and readline libraries. The GMP library is supplied with &GAP; and we recommend that you use the version we supply. There are some problems with some other versions. It is also possible to compile the &GAP; kernel with the system GMP if your system has it. The readline library must be installed on your system in advance to be used with &GAP;. Floats Floating point literals are now supported in the &GAP; language, so that, floating point numbers can be entered in &GAP; expressions in a natural way. Support for floats is now properly documented, see . &GAP; has an interface using which packages may add new floating point implementations and integrate them with the parser. In particular, we expect that there will soon be a package that implements arbitrary precision floating point arithmetic. The Mersenne twister random number generator has been made independent of endianness, so that random seeds can now be transferred between architectures. See for details. Defaults for -m and -o options have been increased. Changes have been made to the way that &GAP; obtains memory from the Operating System, to make &GAP; more compatible with C libraries. A new -s option has been introduced to control or turn off the new behaviour, see . The filename and lines from which a function was read can now be recovered using , and . This allows you, for example, to implement a function such as to show the file containing the source code of a function or a method in a pager, see . was made into an operation so that it can be used to define behaviour of a non-function when called as a function. Improvements to the cyclotomic number arithmetic for fields with large conductors. Better and more flexible viewing of some large objects. Opportunity to interrupt some long kernel computations, e.g. multiplication of compressed matrices, intercepting Ctrl-C in designated places in the kernel code by means of a special kernel function for that purpose. ELM_LIST now allows you to install methods where the second argument is NOT a positive integer. Kernel function to get the list of names of files and subdirectories in a directory. Kernel functions for Kronecker product of compressed matrices, see . New and improved library functionality: Data libraries Extensions of data libraries: Functions and iterators are now available to create and enumerate simple groups by their order up to isomorphism: , , and . See also packages CTblLib, IRREDSOL and Smallsemi listed in Section . Many more methods are now available for the built-in floating point numbers, see . The bound for the proper primality test in increased up to 10^{18}. Improved code for determining transversal and double coset representatives in large groups. Improvements in for S_n. Smith normal form of a matrix may be computed over arbitrary euclidean rings, see . Improved algorithms to determine the subgroup lattice of a group, as well as the function to save the lattice structure in .dot file to view it e.g. with GraphViz. Special teaching mode which simplifies some output and provides more basic functionality, see . Functionality specific for use in undergraduate abstract algebra courses, e.g. checksums (); string/integer list conversion; rings of small orders; the function to set display names for objects for more informative examples, e.g. constructing groups from named objects, such as, for example, R90 for a 90-degree rotation). Functions and which provide uniform access to default directories under Windows, Mac OS X and Unix. Improved methods for hashing when computing orbits. Functionality to call external binaries under Windows. Symplectic groups over residue class rings, see . Basic version of the simplex algorithm for matrices. New functions, operations and attributes: , for lists, , , and others. The behaviour of statements can now be configured per info class, this applies to the way the arguments are printed and to the output stream, see . New function which is a more flexible and informative substitute of operation. ConnectGroupAndCharacterTable is replaced by more robust function . Many problems in &GAP; have have been fixed, among them the following: Polynomial factorisation over rationals could miss factors of degree greater than deg(f)/2 if they have very small coefficients, while the cofactor has large coefficients. called on a group and a normal subgroup did not properly calculate maximal inclusion relationships. and called for a group character could return a perhaps too large result. called for an element of a finite field that was created with ran into an error. did not accept a list with one character as a second argument. Composing a homomorphism from a permutation group to a finitely presented group with another homomorphism could give wrong results. For certain arguments, the function returned wrong results. In the table of marks of cyclic groups, value was wrong. The function returned a perhaps wrong result when the second argument was a positive integer (not a record) and the trivial character of the character table given as the first argument was not the first in the list of irreducibles. &GAP; crashed when the intersection of ranges became empty. IsPSL, and in turn , erroneously recognised non-PSL groups of the right order as PSL. The semidirect product method for pcgs computable groups sometimes tried to use finite presentations which were not polycyclic. This usually happened when the groups were not pc groups, and there was a very low risk of getting a wrong result. The membership test for a group of finite field elements ran into an error if the zero element of the field was given as the first argument. Constant polynomials were not recognised as univariate in any variable. The kernel recursion depth counter was not reset properly when running into many break loops. &GAP; did not behave well when printing of a (large) object was interrupted with Ctrl-C. Now the object is no longer corrupted and the indentation level is reset. Potentially incompatible changes: The zero polynomial now has degree -infinity, see . Multiple unary + or - signs are no longer allowed (to avoid confusion with increment/decrement operators from other programming languages). Due to changes to improve the performance of records with large number of components, the ordering of record components in View'ed records has changed. Due to improvements for vectors over finite fields, certain objects have more limitations on changing their base field. For example, one can not create a compressed matrix over GF(2) and then assign an element of GF(4) to one of its entries. Completion files (withdrawn) &GAP; 3 compatibility mode (withdrawn) No longer supported: Completion files mechanism. &GAP; 3 compatibility mode. &GAP; compiler (no longer recommended) In addition, we no longer recommend using the &GAP; compiler gac to compile &GAP; code to C, and may withdraw it in future releases. Compiling &GAP; code only ever gave a substantial speedup for rather specific types of calculation, and much more benefit can usually be achieved quite easily by writing a small number of key functions in C and loading them into the kernel as described in . The gac script will remain available as a convenient way of compiling such kernel modules from C.

Also, the following functions and operations were made obsolete: AffineOperation, AffineOperationLayer, FactorCosetOperation, DisplayRevision, ProductPol, TeXObj, LaTeXObj. Changes in distribution formats tools archive The &GAP; 4.5 source distribution has the form of a single archive containing the core system and the most recent stable versions of all currently redistributed packages. There are no optional archives to download: the TomLib package now contains all its tables of marks in one archive; we do not provide separate versions of manuals for Internet Explorer, and the former tools archive is now included as an archive in the etc directory. To unpack and install the archive, user the script etc/install-tools.sh.

Bugfixes and packages archives (withdrawn) We no longer distribute separate bugfix archives when the core &GAP; system changes, or updated packages archives when a redistributed package is updated. Instead, the single &GAP; source distribution archive will be labelled by the version of the core &GAP; system and also by a timestamp. This archive contains the core system and the stable versions of the relevant packages on that date. To upgrade, you simply replace the whole directory containing the &GAP; installation, and rebuild binaries for the &GAP; kernel and packages. For new versions of packages, we will also continue to redistribute individual package archives so it will be possible to update a single package without changing the rest of the &GAP; installation.

Furthermore, by default &GAP; will now automatically read a user-specific &GAP; root directory (unless &GAP; is called with the -r option). All user settings can be made in that directory, so there will be no risk of them being lost during an update (see Section below for more details). Private packages can also be installed in this directory for the same reason.

There are some changes in archive formats used for the distribution: we continue to provide .tar.gz, .tar.bz2 and -win.zip archives. We have added .zip, and stopped providing .zoo archives. We no longer provide GAP binaries for Mac OS 9 (Classic) any more. For installations from source on Mac OS X one may follow the instructions for UNIX.

&GAP; binary distributions With the release of &GAP; 4.5, we also encourage more users to take advantage of the increasingly mature binary distributions which are now available. These include: The binary rsync distribution for &GAP; on Linux PCs with i686 or x86_64 compatible processors provided by Frank Lübeck, see http://www.math.rwth-aachen.de/~Frank.Luebeck/gap/rsync. BOB, a tool for Linux and Mac OS X to download and build &GAP; and its packages from source provided by M. Neunhöffer: http://www-groups.mcs.st-and.ac.uk/~neunhoef/Computer/Software/Gap/bob.html. The &GAP; installer for Windows provided by Alexander Konovalov: http://www.gap-system.org/ukrgap/wininst/. In the near future, we also hope to have a binary distribution for Mac OS X.

Internally, we now have infrastructure to support more robust and frequent releases, and an improved system to fetch and test new versions of the increasingly large number of packages. The Example package documents technical requirements for packages, many of which are checked automatically by our systems. This will allow us to check the compatibility of packages with the system and with other packages more thoroughly before publishing them on the &GAP; website. Improvements to the user interface readline support User interface customisation By default, &GAP; now uses the readline library for command line editing. It provides such advantages as working with unicode terminals, nicer handling of long input lines, improved TAB-completion and flexible configuration. For further details, see .

We have extended facilities for user interface customisation. By default &GAP; automatically scans a user specific &GAP; root directory (unless &GAP; is called with the -r option). The name of this user specific directory depends on the operating system and is contained in GAPInfo.UserGapRoot. This directory can be used to tell &GAP; about personal preferences, to load some additional code, to install additional packages, or to overwrite some &GAP; files, see . Instead of a single .gaprc file we now use more flexible setup based on two files: gap.ini which is read early in the startup process, and gaprc which is read after the startup process, but before the first input file given on the command line. These files may be located in the user specific &GAP; root directory GAPInfo.UserGapRoot which by default is the first &GAP; root directory, see . For compatibility, the .gaprc file is still read if the directory GAPInfo.UserGapRoot does not exist. See for the instructions how to migrate your old setup.

Furthermore, there are functions to deal with user preferences, for example, to specify how &GAP;'s online help is shown or whether the coloured prompt should be used. Calls to set user preferences may appear in the user's gap.ini file, as explained in .

In the Windows version, we include a new shell which uses the mintty terminal in addition to the two previously used shells (Windows command line and RXVT). The mintty shell is now recommended. It supports Unicode encoding and has flexible configurations options. Also, &GAP; under Windows now starts in the %HOMEDRIVE%%HOMEPATH% directory, which is the user's home directory. Besides this, a larger workspace is now permitted without a need to modify the Windows registry.

Other changes in the user interface include: the command line history is now implemented at the &GAP; level, it can be stored on quitting a &GAP; session and reread when starting a new session, see . SetPrintFormattingStatus("stdout",false); may be used to switch off the automatic line breaking in terminal output, see . &GAP; supports terminals with up to 4096 columns (extendable at compile time). Directories in -l command-line option can now be specified starting with ~/, see . Large integers are now displayed by a short string showing the first and last few digits, and the threshold to trigger this behaviour is user configurable (call UserPreference("MaxBitsIntView") to see the default value). The &GAP; banner has been made more compact and informative. now supports the Google Chrome browser. Multiple matches in the &GAP; online help are displayed via a function from the Browse package, which is loaded in the default configuration. This feature can be replaced by the known pager using the command SetUserPreference( "browse", "SelectHelpMatches", false ); Better documentation MathJax support The main &GAP; manuals have been converted to the &GAPDoc; format provided by the &GAPDoc; package by Frank Lübeck and Max Neunhöffer (http://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc). This documentation format is already used by many packages and is now recommended for all &GAP; documentation.

Besides improvements to the documentation layout in all formats (text, PDF and HTML), the new &GAP; manuals incorporate a large number of corrections, clarifications, additions and updated examples.

We now provide two HTML versions of the manual, one of them with MathJax (www.mathjax.org) support for better display of mathematical symbols. Also, there are two PDF versions of the manual - a coloured and a monochrome one.

Several separate manuals now became parts of the &GAP; Reference manual. Thus, now there are three main &GAP; manual books: &GAP; Tutorial (see )

&GAP; Reference manual (see ) &GAP; - Changes from Earlier Versions (this manual) Note that there is no index file combining these three manuals. Instead of that, please use the &GAP; help system which will search all of these and about 100 package manuals.

Packages in &GAP; 4.5 Here we list most important changes affecting packages and present new or essentially changed packages. For the changes in the core &GAP; system, see Section . Interface between the core system and packages Namespaces The package loading mechanism has been improved. The most important new feature is that all dependencies are evaluated in advance and then used to determine the order in which package files are read. This allows &GAP; to handle cyclic dependencies as well as situations where package A requires package B to be loaded completely before any file of package A is read. To avoid distortions of the order in which packages will be loaded, package authors are strongly discouraged from calling and in a package code in order to determine whether some other package will be loaded before or together with the current package - instead, one should use . In addition, there is now a better error management if package loading fails for packages that use the new functionality to log package loading messages (see and the rest of the Chapter which documents how to use &GAP; packages), and package authors are very much encouraged to use these logging facilities.

In &GAP; 4.4 certain packages were marked as autoloaded and would be loaded, if present, when &GAP; started up. In &GAP; 4.5, this notion is divided into three. Certain packages are recorded as needed by the &GAP; system and others as suggested, in the same way that packages may need or suggest other packages. If a needed package is not loadable, &GAP; will not start. Currently only &GAPDoc; is needed. If a suggested package is loadable, it will be loaded. Typically these are packages which install better methods for Operations and Objects already present in &GAP;. Finally, the user preferences mechanism can be used to specify additional packages that should be loaded if possible. By default this includes most packages that were autoloaded in &GAP; 4.4.12, see .

&GAP; packages may now use local namespaces to avoid name clashes for global variables introduced in other packages or in the &GAP; library, see .

All guidance on how to develop a &GAP; package has been consolidated in the Example package which also contains a checklist for upgrading a &GAP; package to &GAP; 4.5, see .

New and updated packages since &GAP; 4.4.12 At the time of the release of &GAP; 4.4.12 there were 75 packages redistributed with &GAP; (including the TomLib which was distributed in the core &GAP; archive). The first public release of &GAP; 4.5 contains precisely 99 packages.

The new packages that have been added to the redistribution since the release of &GAP; 4.4.12 are: Citrus package by J.D. Mitchell for computations with transformation semigroups and monoids (this package is a replacement of the Monoid package). cvec package by M. Neunhöffer, providing an implementation of compact vectors over finite fields. fwtree package by B. Eick and T. Rossmann for computing trees related to some pro-p-groups of finite width. GBNP package by A.M. Cohen and J.W. Knopper, providing algorithms for computing Grobner bases of noncommutative polynomials over fields with respect to the total degree first then lexicographical ordering. genss package by M. Neunhöffer and F. Noeske, implementing the randomised Schreier-Sims algorithm to compute a stabiliser chain and a base and a strong generating set for arbitrary finite groups. HAPprime package by P. Smith, extending the HAP package with an implementation of memory-efficient algorithms for the calculation of resolutions of small prime-power groups. hecke package by D. Traytel, providing functions for calculating decomposition matrices of Hecke algebras of the symmetric groups and q-Schur algebras (this package is a port of the &GAP; 3 package Specht 2.4 to &GAP; 4). Homalg project by M. Barakat, S. Gutsche, M. Lange-Hegermann et al., containing the following packages for the homological algebra: homalg, ExamplesForHomalg, Gauss, GaussForHomalg, GradedModules, GradedRingForHomalg, HomalgToCAS, IO_ForHomalg, LocalizeRingForHomalg, MatricesForHomalg, Modules, RingsForHomalg and SCO (see http://homalg.math.rwth-aachen.de/). MapClass package by A. James, K. Magaard and S. Shpectorov to calculate the mapping class group orbits for a given finite group. recogbase package by M. Neunhöffer and A. Seress, providing a framework to implement group recognition methods in a generic way (suitable, in particular, for permutation groups, matrix groups, projective groups and black box groups). recog package by M. Neunhöffer, A. Seress, N. Ankaralioglu, P. Brooksbank, F. Celler, S. Howe, M. Law, S. Linton, G. Malle, A. Niemeyer, E. O'Brien and C.M. Roney-Dougal, extending the recogbase package and provides a collection of methods for the constructive recognition of groups (mostly intended for permutation groups, matrix groups and projective groups). SCSCP package by A. Konovalov and S. Linton, implementing the Symbolic Computation Software Composability Protocol (SCSCP, see http://www.symbolic-computation.org/scscp) for &GAP;, which provides interfaces to link a &GAP; instance with another copy of &GAP; or other SCSCP-compliant system running locally or remotely. simpcomp package by F. Effenberger and J. Spreer for working with simplicial complexes. Smallsemi package by A. Distler and J.D. Mitchell, containing the data library of all semigroups with at most 8 elements as well as various information about them. SymbCompCC package by D. Feichtenschlager for computations with parametrised presentations for finite p-groups of fixed coclass. Furthermore, some packages have been upgraded substantially since the &GAP; 4.4.12 release: Alnuth package by B. Assmann, A. Distler and B. Eick uses an interface to PARI/GP system instead of the interface to KANT (thanks to B. Allombert for the GP code for the new interface and help with the transition) and now also works under Windows. CTblLib package (the &GAP; Character Table Library) by T. Breuer has been extended by many new character tables, a few bugs have been fixed, and new features have been added, for example concerning the relation to &GAP;'s group libraries, better search facilities, and interactive overviews. For details, see the package manual. DESIGN package by L.H. Soicher: The functions PointBlockIncidenceMatrix, ConcurrenceMatrix, and InformationMatrix compute matrices associated with block designs. The function BlockDesignEfficiency computes certain statistical efficiency measures of a 1-(v,k,r) design, using exact algebraic computation. Example package by W. Nickel, G. Gamble and A. Konovalov has a more detailed and up-to-date guidance on developing a &GAP; package, see . FR package by L. Bartholdi now uses floating-point numbers to compute approximations of rational maps given by their group-theoretical description. The GAPDoc package by F. Lübeck and M. Neunhöffer provides various improvements, for example: The layout of the text version of the manuals can be configured quite freely, several standard themes are provided. The display is now adjusted to the current screen width. Some details of the layout of the HTML version of the manuals can now be configured by the user. All manuals are available with and without MathJax support for display of mathematical formulae. The text and HTML versions of manuals make more use of unicode characters (but the text version is also still reasonably good on terminals with latin1 or ASCII encoding). The PDF version of the manuals uses better fonts. Of course, there are various improvements for authors of manuals as well, for example new functions and for automatic testing and correcting of manual examples. Gpd package by E.J. Moore and C.D. Wensley has been substantially rewritten. The main extensions provide functions for: Subgroupoids of a direct product with complete graph groupoid, specified by a root group and choice of rays. Automorphisms of finite groupoids - by object permutations; by root group automorphisms; and by ray images. The automorphism group of a finite groupoid together with an isomorphism to a quotient of permutation groups. Homogeneous groupoids (unions of isomorphic groupoids) and their morphisms, in particular homogeneous discrete groupoids: the latter are used in constructing crossed modules of groupoids in the XMod package. GRAPE package by L.H. Soicher: With much help from A. Hulpke, the interface between GRAPE and dreadnaut is now done entirely in &GAP; code. A 32-bit nauty/dreadnaut binary for Windows (XP and later) is included with GRAPE, so now GRAPE provides full functionality under Windows, with no installation necessary. Graphs with ordered partitions of their vertices into colour-classes are now handled by the graph automorphism group and isomorphism testing functions. An automorphism of a graph with colour-classes is an automorphism of the graph which additionally preserves the list of colour-classes (classwise), and an isomorphism from one graph with colour-classes to a second is a graph isomorphism from the first graph to the second which additionally maps the first list of colour-classes to the second (classwise). The &GAP; code and old standalone programs for the undocumented functions Enum and EnumColadj have been removed as their functionality can now largely be handled by current documented &GAP; and GRAPE functions. IO package by M. Neunhöffer: New build system to allow for more flexibility regarding the use of compiler options and adjusting to &GAP; 4.5. New functions to access time like IO_gettimeofday, IO_gmtime and IO_localtime. Some parallel skeletons built on fork like: ParListByFork, ParMapReduceByFork, ParTakeFirstResultByFork and ParWorkerFarmByFork. IOHub objects for automatic I/O multiplexing. New functions IO_gethostbyname and IO_getsockname. IRREDSOL package by B. Höfling now covers all irreducible soluble subgroups of GL(n,q) for q^n < 1000000 and primitive soluble permutation groups of degree < 1000000 (previously, the bound was 65536). It also has faster group recognition and adds a few omissions for GL(3,8) and GL(6,5). ParGAP package by G. Cooperman is now compiled using a system-wide MPI implementation by default to facilitate running it on proper clusters. There is also an option to build it with the MPINU library which is still supplied with the package (thanks to P. Smith for upgrading ParGAP build process). OpenMath package by M. Costantini, A. Konovalov, M. Nicosia and A. Solomon now supports much more OpenMath symbols to facilitate communication by the remote procedure call protocol implemented in the SCSCP package. Also, a third-party external library to support binary OpenMath encoding has been replaced by a proper implementation made entirely in &GAP;. Orb package by J. Müller, M. Neunhöffer and F. Noeske:

There have been numerous improvements to this package: A new fast implementation of AVL trees (balanced binary trees) in C. New interface to hash table functionality and implementation in C for speedup. Some new hash functions for various object types like transformations. New function ORB_EstimateOrbitSize using the birthday paradox. Improved functionality for product replacer objects. New tree hash tables. New functionality to compute weak and strong orbits for semigroups and monoids. OrbitGraph for Orb orbits. Fast C kernel methods for the following functions:

PermLeftQuoTransformationNC, MappingPermSetSet, MappingPermListList, ImageSetOfTransformation, and KernelOfTransformation. New build system to allow for more flexibility regarding the use of compiler options and to adjust to &GAP; 4.5. RCWA package by S. Kohl among the new features and other improvements has the following: A database of all 52394 groups generated by 3 class transpositions of &ZZ; which interchange residue classes with modulus less than or equal to 6. This database contains the orders and the moduli of all of these groups. Also it provides information on what is known about which of these groups are equal and how their finite and infinite orbits on &ZZ; look like. More routines for investigating the action of an rcwa group on &ZZ;. Examples are a routine which attempts to find out whether a given rcwa group acts transitively on the set of nonnegative integers in its support and a routine which looks for finite orbits on the set of all residue classes of &ZZ;. Ability to deal with rcwa permutations of &ZZ;^2. Important methods have been made more efficient in terms of runtime and memory consumption. The output has been improved. For example, rcwa permutations are now Display'ed in ASCII text resembling &LaTeX; output. The XGAP package by F. Celler and M. Neunhöffer can now be used on 64-bit architectures (thanks to N. Eldredge and M. Horn for sending patches). Furthermore, there is now an export to XFig option (thanks to Russ Woodroofe for this patch). The help system in XGAP has been adjusted to &GAP; 4.5. Packages under Windows Additionally, some packages with kernel modules or external binaries are now available in Windows. The -win.zip archive and the &GAP; installer for Windows include working versions of the following packages: Browse, cvec, EDIM, GRAPE, IO and orb, which were previously unavailable for Windows users. Finally, the following packages are withdrawn: IF package by M. Costantini is unmaintained and no longer usable. More advanced functionality for interfaces to other computer algebra systems is now available in the SCSCP package by A. Konovalov and S. Linton. Monoid package by J. Mitchell is superseded by the Citrus package by the same author. NQL package by R. Hartung has been withdrawn by the author.

&GAP; 4.5.5 (July 2012) Fixed bugs which could lead to crashes: For small primes (compact fields) ZmodnZObj(r,p) now returns the corresponding FFE to avoid crashes when compacting matrices. [Reported by Ignat Soroko] Other fixed bugs: Fixed a bug in for fp groups causing infinite recursion, which could, for example, be triggered by computing automorphism groups. Previously, the list of factors of a polynomial was mutable, and hence could be accidentally corrupted by callers. Now the list of irreducible factors is stored immutable. To deal with implicit reliance on old code, always a shallow copy is returned. [reported by Jakob Kroeker] Computing high powers of matrices ran into an error for matrices in the format of the cvec package. Now the library function also works with these matrices. [reported by Klaus Lux] The pseudo tty code which is responsible for spawning subprocesses has been partially rewritten to allow more than 128 subprocesses on certain systems. This mechanism is for example used by ANUPQ and nq packages to compute group quotients via an external program. Previously, on Mac OS X this could be done precisely 128 times, and then an error would occur. That is, one could e.g. compute 128 nilpotent quotients, and then had to restart &GAP; to compute more. This also affected other systems, such as OpenBSD, where it now also works correctly. On Mac OS X, using &GAP; compiled against GNU readline 6.2, pasting text into the terminal session would result in this text appearing very slowly, with a 0.1 sec delay between each keystroke. This is not the case with versions 6.1 and older, and has been reported to the GNU readline team. In the meantime, we work around this issue in most situations by setting rl_event_hook only if OnCharReadHookActive is set. ran into a break loop in case of several undeclared user preferences. [Reported by James Mitchell] &GAP; did not start correctly if the user preference "InfoPackageLoadingLevel" was set to a number >= 3. The reason is that PrintFormattedString was called before it was installed. The current fix is a temporary solution. The "hints" member of TypOutputFile used to contain 3*100 entries, yet addLineBreakHint would write entries with index up to and including 3*99+3=300, leading to a buffer overflow. This would end up overwriting the "stream" member with -1. Fixed by incrementing the size of "hints" to 301. [Reported by Jakob Kroeker] The function IsDocumentedWord tested the given word against strings obtained by splitting help matches at non-letter characters. This way, variable names containing underscores or digits were erroneously not regarded as documented, and certain substrings of these names were erroneously regarded as documented. On Windows, an error occurred if one tried to use the default Windows browser as a help viewer (see ). Now the browser opens the top of the correspoding manual chapter. The current fix is a temporary solution since the problem remains with the positioning at the required manual section. Improved functionality: on Windows now produces the gap.ini file with Windows style line breaks. Also, an info message is now printed if an existing gap.ini file was moved to a backup file gap.ini.bak. The CTblLib and TomLib packages are removed from the list of suggested packages of the core part of &GAP;. Instead they are added to the default list of the user preference "PackagesToLoad". This way it is possible to configure &GAP; to not load these packages via changing the default value of "PackagesToLoad". The conjugacy test in S_n for intransitive subgroups was improved. This deals with inefficiency issue in the case reported by Stefan Kohl. Added InstallAndCallPostRestore to lib/system.g and call it in lib/init.g instead of CallAndInstallPostRestore for the function that reads the files listed in &GAP; command line. This fixes the problem reported by Yevgen Muntyan when was used in a file listed in &GAP; command line (before, according to the documentation, was only allowed at the main &GAP; prompt). There is now a new user preference PackagesToIgnore, see . It contains a list of names of packages that shall be regarded as not available at all in the current session, both for autoloading and for later calls of . This preference is useful for testing purposes if one wants to run some code without loading certain packages.
&GAP; 4.5.6 (September 2012) Improved functionality: The argument of can now start with ~/ which is expanded to the users home directory. Added the method for for . [Suggested by Attila Egri-Nagy]. Changed kernel tables such that list access functionality for T_SINGULAR objects can be installed by methods at the &GAP; level. In case of saved history, UP arrow after starting &GAP; yields last stored line. The user preference HistoryMaxLines is now used when storing and saving history (see ). Fixed bugs which could lead to crashes: A crash occuring during garbage collection following a call to AClosVec for a GF(2) code. [Reported by Volker Braun] A crash when parsing certain syntactically invalid code. [Reported by multiple users] Fixed and improved command line editing without readline support. Fixed a segfault which could be triggered by a combination of UP and DOWN arrows. [Reported by James Mitchell] Fixed a bug in the kernel code for floats that caused a crash on SPARC Solaris in 32-bit mode. [Reported by Volker Braun] Other fixed bugs: Very large (more than 1024 digit) integers were not being coded correctly in function bodies unless the integer limb size was 16 bits. [Reported by Stefan Kohl] An old variable was used in assertion, causing errors in a debugging compilation. [Reported by Volker Braun] The environment variable PAGER is now correctly interpreted when it contains the full path to the pager program. Furthermore, if the external pager less is found from the environment it is made sure that the option -r is used (same for more -f). [Reported by Benjamin Lorenz] Fixed a bug in PermliftSeries. [Reported by Aiichi Yamasaki] Fixed discarder function in lattice computation to distinguish general and zuppo discarder. [Reported by Leonard Soicher] The and constructors did not correctly handle GL(filter,dim,ring). The names of two primitive groups of degree 64 were incorrect. The method for groups handled by a nice monomorphism sometimes could produce an error in situations where it should return false. This only happened when using SeedFaithfulAction to influence how builds the nice monomorphims for a matrix groups. Wrong method was removed to fix delegations accordingly to . Fixed a method for which, after Gaussian elimination, did not check that the coefficients actually lie in the left-acting-domain of the vector space. This could lead to a wrong answer in a vector space membership test. [Reported by Kevin Watkins] Improved documentation: Removed outdated statements from the documentation of which now non-ambiguosly states that StructureDescription is not an isomorphism invariant: non-isomorphic groups can have the same string value, and two isomorphic groups in different representations can produce different strings. &GAP; now allows overloading of a loaded help book by another one. In this case, only a warning is printed and no error is raised. This makes sense if a book of a not loaded package is loaded in a workspace and then &GAP; is started with a root path that contains a newer version. [Reported by Sebastian Gutsche] Provided a better description of user preferences mechanism () and a hint to familiarise with them using function to create a file which contains descriptions of all known user preferences and also sets those user preferences which currently do not have their default value. One can then edit that file to customize (further) the user preferences for future &GAP; sessions. New packages added for the redistribution with &GAP;: AutoDoc package by S. Gutsche, providing tools for automated generation of GAPDoc manuals. Convex package by S. Gutsche, which provides structures and algorithms for convex geometry. PolymakeInterface package by T. Baechler and S. Gutsche, providing a link to the callable library of the polymake system (http://www.polymake.org). ToolsForHomalg package by M. Barakat, S. Gutsche and M. Lange-Hegermann, which provides some auxiliary functionality for the homalg project (http://homalg.math.rwth-aachen.de/).
&GAP; 4.5.7 (December 2012) Fixed bugs which could lead to crashes: Closing with LogInputTo (or LogOutputTo) a logfile opened with left the data structures corrupted, resulting in a crash. On 32-bit systems we can have long integers n such that Log2Int(n) is not an immediate integer. In such cases Log2Int gave wrong or corrupted results which in turn could crash &GAP;, e.g., in ViewObj(n). Some patterns of use of and were leading to a segfault. Other fixed bugs: Viewing of long negative integers was broken, because it went into a break loop. Division by zero in (n not prime) produced invalid objects. [Reported by Mark Dickinson] Fixed a bug in determining multiplicative inverse for a zero polynomial. Fixed a bug causing infinite recursion in . A workaround was added to deal with a package method creating pcgs for permutation groups for which the entry permpcgsNormalSteps is missing. For a semigroup of associative words that is not the full semigroup of all associative words, the methods for and called one another causing infinite recursion. The 64-bit version of the gac script produced wrong (>= 2^31) CRC values because of an integer conversion problem. It was not possible to compile &GAP; on some systems where HAVE_SELECT detects as false. Numbers in memory options on the command line exceeding 2^32 could not be parsed correctly, even on 64-bit systems. [Reported by Volker Braun] New packages added for the redistribution with &GAP;: Float package by L. Bartholdi, which extends &GAP; floating-point capabilities by providing new floating-point handlers for high-precision real, interval and complex arithmetic using MPFR, MPFI, MPC or CXSC external libraries. It also contains a very high-performance implementation of the LLL (Lenstra-Lenstra-Lovász) lattice reduction algorithm via the external library FPLLL. ToricVarieties package by S. Gutsche, which provides data structures to handle toric varieties by their commutative algebra structure and by their combinatorics.
gap-4r6p5/doc/changes/makedocreldata.g0000644000175000017500000000060012172557252016422 0ustar billbill############################################################################# ## ## values for the `MakeGAPDocDoc' call that builds the Changes Manual ## GAPInfo.ManualDataChanges:= rec( pathtodoc:= ".", main:= "main.xml", bookname:= "changes", pathtoroot:= "../..", files:= [ ], );; ############################################################################# ## #E gap-4r6p5/doc/changes/changes46.xml0000644000175000017500000004155612172557252015635 0ustar billbill Changes between &GAP; 4.5 and &GAP; 4.6 This chapter lists most important changes between &GAP; 4.5.7 and &GAP; 4.6.2 (i.e. between the last release of &GAP; 4.5 and the first public release of &GAP; 4.6). It also contains information about subsequent update releases for &GAP; 4.6.
&GAP; 4.6.2 (February 2013) Changes in the core &GAP; system Improved and extended functionality: It is now possible to declare a name as an operation with two or more arguments (possibly several times) and THEN declare it as an attribute. Previously this was only possible in the other order. This should make the system more independent of the order in which packages are loaded. Words in fp groups are now printed in factorised form if possible and not too time-consuming, i.e. a*b*a*b*a*b will be printed as (a*b)^3. Added methods to calculate Hall subgroups in nonsolvable groups. Added a generic method for and a better generic method for for groups. Improvements to action homomorphisms: image of an element can use existing stabiliser chain of the image group (to reduce the number of images to compute), preimages under linear/projective action homomorphisms use linear algebra to avoid factorisation. To improve efficiency, additional code was added to make sure that the HomePcgs of a permutation group is in IsPcgsPermGroupRep representation in more cases. Added an operation with arguments being a function f of one argument and a list l to be sorted in such a way that l(f[i]) <= l(f[i+1]). Added a kernel function MEET_BLIST which returns true if the two boolean lists have true in any common position and false otherwise. This is useful for representing subsets of a fixed set by boolean lists. When assigning to a position in a compressed FFE vector &GAP; now checks to see if the value being assigned can be converted into an internal FFE element if it isn't one already. This uses new attribute , for which methods are installed for internal FFEs, Conway FFEs and ZmodpZ objects. Replaced method for fields by method to improve the way how polynomial rings over algebraic extenstions of fields are displayed. Made the info string (optional 2nd argument to ) behave similarly to the info string in . In particular, now always prints the name of the operation. Syntax errors such as Unbind(x,1) had the unhelpful property that x got unbound before the syntax error was reported. A specific check was added to catch this and similar cases a little earlier. Allow a GAPARGS parameter to the top-level &GAP; Makefile to pass extra arguments to the &GAP; used for manual building. Added an attribute for Lie objects. The function now became an attribute. [suggested by Mohamed Barakat] Added an operation with a kernel method for internal permutations and a generic method. Added a method for to support large finite fields. [reported by Inneke van Gelder] Fixed bugs which could lead to crashes: The extremely old DEBUG_DEADSONS_BAGS compile-time option has not worked correctly for many years and indeed crashes &GAP;. The type of bug it is there to detect has not arisen in many years and we have certainly not used this option, so it has been removed. [Reported by Volker Braun] Other fixed bugs: Scanning of floating point literals collided with iterated use of integers as record field elements in expressions like r.1.2. Fixed two potential problems in NorSerPermPcgs, one corrupting some internal data and one possibly mixing up different pcgs. Fixed a performance problem with . [reported by John Bamberg] Fixed a bug in that caused some .csv files being parsed incorrectly. No longer supported: The file lib/consistency.g, which contained three undocumented auxiliary functions, has been removed from the library. In addition, the global record Revision is now deprecated, so there is no need to bind its components in &GAP; packages. New and updated packages since &GAP; 4.5.4 Packages, new At the time of the release of &GAP; 4.5 there were 99 packages redistributed with &GAP;. The first public release of &GAP; 4.6 contains 106 packages.

The new packages that have been added to the redistribution since the release of &GAP; 4.5.4 are: AutoDoc package by S. Gutsche, providing tools for automated generation of GAPDoc manuals. Congruence package by A. Konovalov, which provides functions to construct various canonical congruence subgroups in SL_2(&ZZ;), and also intersections of a finite number of such subgroups, implements the algorithm for generating Farey symbols for congruence subgroups and uses it to produce a system of independent generators for these subgroups. Convex package by S. Gutsche, which provides structures and algorithms for convex geometry. Float package by L. Bartholdi, which extends &GAP; floating-point capabilities by providing new floating-point handlers for high-precision real, interval and complex arithmetic using MPFR, MPFI, MPC or CXSC external libraries. It also contains a very high-performance implementation of the LLL (Lenstra-Lenstra-Lovász) lattice reduction algorithm via the external library FPLLL. PolymakeInterface package by T. Baechler and S. Gutsche, providing a link to the callable library of the polymake system (http://www.polymake.org). ToolsForHomalg package by M. Barakat, S. Gutsche and M. Lange-Hegermann, which provides some auxiliary functionality for the homalg project (http://homalg.math.rwth-aachen.de/). ToricVarieties package by S. Gutsche, which provides data structures to handle toric varieties by their commutative algebra structure and by their combinatorics. Packages, upgraded Furthermore, some packages have been upgraded substantially since the &GAP; 4.5.4 release: Starting from 2.x.x, the functionality for iterated monodromy groups has been moved from the FR package by L. Bartholdi to a separate package IMG (currently undeposited, available from https://github.com/laurentbartholdi/img). This completely removes the dependency of FR on external library modules, and should make its installation much easier.

&GAP; 4.6.3 (March 2013) Improved functionality: Several changes were made to and . First off, the documentation was changed to properly state that these functions support arbitrary rings, and not just fields. Also, more usage examples were added to the manual.

For NullMat, it is now also always possible to specify a ring element instead of a ring, and this is documented. This matches existing IdentityMat behavior, and partially worked before (undocumented), but in some cases could run into error or infinite recursion.

In the other direction, if a finite field element, IdentityMat now really creates a matrix over the smallest field containing that element. Previously, a matrix over the prime field was created instead, contrary to the documentation.

Furthermore, IdentityMat over small finite fields is now substantially faster when creating matrices of large dimension (say a thousand or so).

Finally, and were explicitly declared obsolete (and may be removed in &GAP; 4.7). They actually were deprecated since &GAP; 4.1, and their use discouraged by the manual. Code using them should switch to respectively . Two new methods were added for solvable and perfect groups, handling these cases optimally. Moreover, the existing generic method was improved by changing it to use . Previously, it would always compute the derived series from scratch and then throw away the result. A new method for groups handled by a nice monomorphisms was added, similar to the existing method. This is useful if the nice monomorphism is already mapping into a pc or pcp group. Added a special method for if the group is known to be abelian. Fixed bugs: Fixed a bug in computing r^e mod m in a special case when e=0 and m=0. [Reported by Ignat Soroko] now better checks its arguments to avoid an infinite loop when being asked for a q-adic representation for q=1. [Reported by Ignat Soroko] Methods for SylowSubgroupOp (see ) for symmetric and alternating group did not always set and for the returned Sylow subgroup. Display of matrices consisting of Conway field elements (which are displayed as polynomials) did not print constant 1 terms. Added an extra check and a better error message in the method to access natural generators of domains using the . operator (see ). Trying to solve the word problem in an fp group where one or more generators has a name of more than one alphabetic character led to a break loop. Provided the default method for as a temporary workaround for the problem which may cause returning wrong results or producing an error when being called for a non-prime field. A bug in the &GAP; kernel caused RNamObj to error out when called with a string that had the property set (regardless of whether it was set to true or false). This in turn would lead to strange (and inappropriate) errors when using such a string to access entries of a record. &GAP; can store vectors over small finite fields (size at most 256) in a special internal data representation where each entry of the vector uses exactly one byte. Due to an off-by-one bug, the case of a field with exactly 256 elements was not handled properly. As a result, &GAP; failed to convert a vector to the special data representation, which in some situations could lead to a crash. The off-by-one error was fixed and now vectors over GF(256) work as expected. A bug in the code for accessing sublist via the list{poss} syntax could lead to &GAP; crashing. Specifically, if the list was a compressed vector over a finite field, and the sublist syntax was nested, as in vec{poss1}{poss2}. This now correctly triggers an error instead of crashing. New packages added for the redistribution with &GAP;: SpinSym package by L. Maas, which contains Brauer tables of Schur covers of symmetric and alternating groups and provides some related functionalities.

&GAP; 4.6.4 (April 2013) New functionality: New command line option -O was introduced to disable loading obsolete variables. This option may be used, for example, to check that they are not used in a &GAP; package or one's own &GAP; code. For further details see and . Fixed bugs which could lead to incorrect results: Fixed the bug in which may cause returning true instead of false. [Reported by Lev Glebsky] Fixed bugs which could lead to crashes: Fixed the kernel method for which did not raise an error in case of empty lists, but corrupted the object. The error message in a library method is also improved. [Reported by Roberto Ràdina] Fixed bugs that could lead to break loops: Fixed requirements in a method to multiply a list and an algebraic element. [Reported by Sebastian Gutsche] Fixed a bug in entering a break loop when being called on a homomorphism whose image is not a permutation group. [Reported by Sebastian Gutsche] Fixed a bug in which occured, for example, in some calls of [Reported by Ramon Esteban-Romero] Fixed a problem with displaying function fields, e.g. Field(Indeterminate(Rationals,"x")). [Reported by Jan Willem Knopper] Fixed two bugs in the code for for polynomial rings. [Reported by Martin Leuner] Added missing method for for -infinity. Fixed the bug with not recognising product action properly in some cases. The method for for straight line programs had a bug which triggered an error, if the straight line program contained unnecessary steps.
&GAP; 4.6.5 (July 2013) Improved functionality: and now better check their arguments and provide a sensible error message if being called without arguments. Also, both variants of calling them are now documented. Library methods for are now replaced by faster ones using the kernel functionality instead of making expensive zipped lists. Fixed bugs which could lead to incorrect results: wrongly produced a large integer when there were too many leading zeros. [Reported by Joe Bohanon] Fixed bugs that could lead to break loops: A bug that may occur in some cases while calling . [Reported by Izumi Miyamoto] The new code for semidirect products of permutation groups, introduced in &GAP; 4.6, had a bug which was causing problems for . [Reported by Graham Ellis]
gap-4r6p5/doc/changes/changes44.xml0000644000175000017500000017715312172557252015636 0ustar billbill Overview of updates for &GAP; 4.4 This chapter lists changes in the main system (excluding packages) that have been corrected or added in bugfixes and updates for &GAP; 4.4.
&GAP; 4.4 Bugfix 2 (April 2004) Fixed bugs which could lead to crashes: A crash when incorrect types of arguments are passed to FileString. Other fixed bugs: A bug in DerivedSubgroupTom and DerivedSubgroupsTom. An error in the inversion of certain ZmodnZObj elements. A wrong display string of the numerator in rational functions returned by MolienSeriesWithGivenDenominator (in the case that the constant term of this numerator is zero).
&GAP; 4.4 Bugfix 3 (May 2004) Fixed bugs which could produce wrong results: Incorrect setting of system variables (e.g., home directory and command line options) after loading a workspace. Wrong handling of integer literals within functions or loops on 64-bit architectures (only integers in the range from 2^{28} to 2^{60}). Fixed bugs which could lead to crashes: A problem in the installation of the multiplication routine for matrices that claimed to be applicable for more general list multiplications. A problem when computing weight distributions of codes with weights > 2^{28}. Other fixed bugs: Problems with the online help with some manual sections. Problems of the online help on Windows systems. A problem in GQuotients when mapping from a finitely presented group which has a free direct factor. A bug in the function DisplayRevision. The trivial finitely presented group on no generators was not recognized as finitely presented. A problem with Process. A problem when intersecting subgroups of finitely presented groups that are represented in quotient representation with the quotient not apermutation group. A bug in the generic Intersection2 method for vector spaces, in the case that both spaces are trivial. Enable ReeGroup(q) for q = 3.
&GAP; 4.4 Bugfix 4 (December 2004) Fixed bugs which could produce wrong results: An error in the Order method for matrices over cyclotomic fields which caused this method to return infinity for matrices of finite order in certain cases. Representations computed by IrreducibleRepresentations in characteristic 0 erraneously claimed to be faithful. A primitive representation of degree 574 for PSL(2,41) has been missing in the classification on which the &GAP; library was built. A bug in Append for compressed vectors over GF(2): if the length of the result is 1 mod 32 (or 64) the last entry was forgotten to copy. A problem with the Ree group Ree(3) of size 1512 claiming to be simple. An error in the membership test for groups GU(n,q) and SU(n,q) for non-prime q. An error in the kernel code for ranges which caused e.g. -1 in [1..2] to return true. An error recording boolean lists in saved workspaces. A problem in the selection function for primitive and transitive groups if no degree is given. ReducedConfluentRewritingSystem returning a cached result that might not conform to the ordering specified. Other fixed bugs: A problem with the function SuggestUpdates to check for the most recent version of packages available. A problem that caused MatrixOfAction to produce an error when the algebra module was constructed as a direct sum. Problems with computing n-th power maps of character tables, where n is negative and the table does not yet store its irreducible characters. Element conjugacy in large-base permutation groups sometimes was unnecessarily inefficient. A missing method for getting the letter representation of an associate word in straight line program representation. A problem with the construction of vector space bases where the given list of basis vectors is itself an object that was returned by Basis. A problem of AbelianInvariantsMultiplier insisting that a result of IsomorphismFpGroup is known to be surjective. An error in the routine for Resultant if one of the polynomials has degree zero.
&GAP; 4.4 Update 5 (May 2005) Fixed bugs which could produce wrong results: returned a meaningless group object instead of signaling an error when it was called with an empty list of generators. When computing preimages under an embedding into a direct product of permutation groups, if the element was not in the image of the embedding then a permutation had been returned instead of fail. Two problems with for polynomials. [Reported by Jack Schmidt] Some methods for computing the sum of ideals returned the first summand instead of the sum. [Reported by Alexander Konovalov] Wrong result in for pc groups. The function erroneously ignored leading non-digit characters.

A new feature in the corrected version is an optional third argument "equal", which causes the function to return true only if the first two arguments describe equal version numbers; documentation is available in the ext-manual. This new feature is used in , now one can require a specific version of a package.

The library code still contained parts of the handling of completion files for packages, which does not work and therefore had already been removed from the documentation. This code has now been removed.

Now a new component PreloadFile is supported in files; if it is bound then the file in question is read immediately before the package or its documentation is loaded. The result of for strings not in that occur as list entries or record components was erroneously missing the double quotes around the strings. A bug which caused to return a pcgs which is not induced wrt. the parent pcgs of pcgs. This may cause unpredictable behaviour, e. g. when SiftedPcElement is used subsequently. [Reported by Alexander Konovalov] Fixed a bug in SmallGroupsInformation(512). with exponent 1 for compressed vectors did not reduce (a copy of) the input vector before returning it. [Reported by Frank Lübeck] Sorting a mutable non-plain list (e.g., a compressed matrix over fields of order < 257) could potentially destroy that object. [Reported by Alexander Hulpke] Under rare circumstances computing the closure of a permutation group by a normalizing element could produce a corrupted stabilizer chain. (The underlying algorithm uses random elements, probability of failure was below 1 percent). [Reported by Thomas Breuer] Fixed bugs which could lead to crashes: Some code and comments in the &GAP; kernel assumed that there is no garbage collection during the core printing function Pr, which is not correct. This could cause &GAP; in rare cases to crash during printing permutations, cyclotomics or strings with zero bytes. [Reported by Warwick Harvey] Other fixed bugs: A rare problem with the choice of prime in the Dixon-Schneider algorithm for computing the character table of a group. [Reported by Jack Schmidt] for trivial permutation groups returned a strange object. A problem with running into an infinite loop. Adding linear mappings with different image domains was not possible. [Reported by Pasha Zusmanovich] Multiplying group ring elements with rationals was not possible. [Reported by Laurent Bartholdi] now works for finite fields of size larger than 2^{28}. [Reported by Jack Schmidt] Univariate polynomial creators did modify the coefficient list passed. [Reported by Jürgen Müller] Fixed to accept arguments not in IsStringRep; the argument is now first converted if necessary. [Reported by Kenn Heinrich] The library code for stabilizer chains contained quite some explicit references to the identity (). This is unfortunate if one works with permutation groups, the elements of which are not plain permutations but objects which carry additional information like a memory, how they were obtained from the group generators. For such cases it is much cleaner to use the One(...) operation instead of (), such that the library code can be used for a richer class of group objects. This fix contains only rather trivial changes () to One(...) which were carefully checked by me. The tests for permutation groups all run without a problem. However, it is relatively difficult to provide test code for this particular change, since the "improvement" only shows up when one generates new group objects. This is for example done in the package recog which is in preparation. [Reported by Akos Seress and Max Neunhöffer] Using {} to select elements of a known inhomogenous dense list produced a list that might falsely claim to be known inhomogenous, which could lead to a segfault if the list typing code tried to mark it homogenous, since the code intended to catch such errors also had a bug. [Reported by Steve Linton] The record for the generic iterator construction of subspaces domains of non-row spaces was not complete. When a workspace has been created without packages(-A option) and is loaded into a &GAP; session without packages (same option) then an error message is printed. So far the functions and are essentially the same except that IsPrimeInt issues an additional warning when (non-proven) probable primes are considered as primes.

These warnings now print the probable primes in question as well; if a probable prime is used several times then the warning is also printed several times; there is no longer a warning for some known large primes; the warnings can be switched off. See for more details.

If we get a reasonable primality test in &GAP; we will change the definition of IsPrimeInt to do a proper test. Corrected some names of primitive groups in degree 26. [Reported by Robert F. Bailey] New or improved functionality: Several changes for : many new pre-computed polynomials put data in several separate files (only read when needed) added info on origins of pre-computed polynomials improved performance of and for p < 256 improved documentation of ConwayPolynomial added and documented new functions and Added method for for extensions of finite fields. Added more help viewers for the HTML version of the documentation (firefox, mozilla, konqueror, w3m, safari). New function . (Users of former versions of a colorprompt.g file: Now you just need a ColorPrompt(true); in your .gaprc file.) Specialised kernel functions to support GUAVA 2.0. &GAP; will only load GUAVA in version at least 2.002 after this update. Now there is a kernel function CYC_LIST for converting a list of rationals into a cyclotomic, without arithmetics overhead. New functions and for computing continued fraction expansions and continued fraction approximations of real roots of polynomials with integer coefficients. A method for computing structure descriptions for finite groups, available via . This change contains the new, extended version of the SmallGroups package. For example, the groups of orders p^4, p^5, p^6 for arbitrary primes p, the groups of square-free order and the groups of cube-free order at most 50000 are included now. For more detailed information see the announcement of the extended package. The function ShowPackageVariables gives an overview of the global variables in a package. It is thought as a utility for package authors and referees. (It uses the new function IsDocumentedVariable.) The mechanisms for testing &GAP; has been improved: The information whether a test file belongs to the list in tst/testall.g is now stored in the test file itself. Some targets for testing have been added to the Makefile in the &GAP; root directory, the output of the tests goes to the new directory dev/log. Utility functions for testing are in the new file tst/testutil.g. Now the loops over (some or all) files tst/*.tst can be performed with a function call, and the file tst/testall.g can be created automatically; the file tst/testfull.g is now obsolete. The remormalization of the scaling factors can now be done using a &GAP; function, so the file tst/renorm.g is obsolete. Now the functions START_TEST and STOP_TEST use components in GAPInfo instead of own globals, and the random number generator is always reset in START_TEST. GAPInfo.SystemInformation now takes two arguments, now one can use it easier in the tests. is now an attribute, and the construction of a magma, monoid, etc. from multiplication tables has been unified.

&GAP; 4.4 Update 6 (September 2005) Attribution of bugfixes and improved functionalities to those who reported or provided these, respectively, is still fairly incomplete and inconsistent with this update. We apologise for this fact and will discuss until the next update how to improve this feature.

Fixed bugs which could produce wrong results: The perfect group library does not contain any information on the trivial group, so the trivial group must be handled specially. and NrPerfectLibraryGroups were changed to indicate that the trivial group is not part of the library. The descriptions of PerfectGroup(734832,3) and PerfectGroup(864000,3) were corrected in the library of perfect groups. The functions and may have produced wrong results without warning [Reported by Colin Ingalls]. These problems are fixed. However, the methods currently used can be expected to be slower than the ones used before; we hope to fix this in the next version of &GAP;. and for permutation groups sometimes returned groups with an incorrect stabilizer chain due to a missing verification step after a random Schreier Sims. for FpGroups did unnecessary rewrites. The alternating group A_3 incorrectly claimed to be not simple. for straight line program elements gave a wrong result. is defined to return fail for trivial groups, but if the group was constructed as a factor or subgroup of a known p-group, the value of p was retained. The functions and did not work correctly when one asked for a particular version of the package, via a version number starting with the character =, in the sense that a version with a larger version number was loaded if it was available. [Reported by Burkhard Höfling] The generator names constructed by were nonsense. The undocumented function (but recently advertised on gap-dev) COPY_LIST_ENTRIES did not handle overlapping source and destination areas correctly in some cases. The elements in a free magma ring have the filter set whenever the elements in the underlying magma and in the coefficients ring have this filter set. [Reported by Randy Cone] The function must not be used for objects in the filter IsFamily because these objects are compared via . [Reported by Max Neunhöffer] Fixed bugs which could lead to crashes: Problem in composition series for permutation groups for non-Frobenius groups with regular point stabilizer. After lots of computations with compressed GF(2) vectors &GAP; occasionally crashed. The reason were three missing CHANGED_BAGs in SemiEchelonPListGF2Vecs. They were missing, because a garbage collection could be triggered during the computation such that newly created bags could become old. It is not possible to provide test code because the error condition cannot easily be reproduced. [Reported by Klaus Lux] Minor bug that crashed &GAP;: The type of IMPLICATIONS could not be determined in a fresh session. [Reported by Marco Costantini] caused an infinite loop if called as the first line of a function called from another function. Other fixed bugs: Wrong choice of prime in Dixon-Schneider if prime is bigger than group order (if group has large exponent). Groebner basis code ran into problems when comparing monomial orderings. When testing for conjugacy of a primitive group to an imprimitive group,&GAP; runs into an error in EARNS calculation. [Reported by John Jones] The centre of a magma is commonly defined to be the set of elements that commute and associate with all elements. The previous definition left out associate and caused problems with extending the functionality to nonassociative loops. [Reported by Petr Vojtechovsky] New kernel methods for taking the intersection and difference between sets of substantially different sizes give a big performance increase. The commands and are faster and should run much less often into inefficient tests. The perfect group library, see , is split into several files which are loaded and unloaded to keep memory usage down. The global variable PERFSELECT is a blist which indicates which orders are currently loaded. An off-by-one error wrongly added the last order of the previous file into the list of valid orders when a new file was loaded. A subsequent access to this order raises an error. Up to now, the method installed for testing the membership of rationals in the field of rationals via was not called; instead a more general method was used that called and thus was much slower. Now the special method has been ranked up by changing the requirements in the method installation. Fixed a bug in APPEND_VEC8BIT, which was triggered in the following situation: Let e be the number of field elements stored in one byte. If a compressed 8bit-vector v had length not divisible by e and another compressed 8-bit vector w was appended, such that the sum of the lengths became divisible by e, then one 0 byte too much was written, which destroyed the TNUM of the next &GAP; object in memory. [Reported by Klaus Lux] returned fail if the cycle was not a contiguous subset of the specified domain. [Reported by Luc Teirlinck] Now correctly returns fail for zeros in finite fields (and does no longer enter a break loop). Up to now, ignored the attribute if the argument was a group that knew that it was solvable. The function Debug now prints a meaningful message if the user tries to debug an operation. Also, the help file for vi is now available in the case of several &GAP; root directories. It is no longer possible to create corrupt objects via ranges of length >2^{28}, resp. >2^{60} (depending on the architecture). The limitation concerning the arguments of ranges is documented. [Reported by Stefan Kohl] Now and are available for ordinary character tables. Now the operation is an attribute, and there is another new attribute that points back to the original table; this is used for computing the Brauer tables of those tables in the character table library that are computed using CharacterTableIsoclinic. Now avoids calling , since is sufficient. Now works also for the table of the trivial group. Restrictions of character objects know that they are characters.

A few formulations in the documentation concerning character tables have been improved slightly. Up to now, has rarely been set. Now many basic operations such as set this attribute on the returned result. Computing an enumerator for a semigroup required too much time because it used all elements instead of the given generators. [Reported by Manuel Delgado] Avoid potential error message when working with automorphism groups. Fixed wrong page references in manual indices. Make MutableCopyMat an operation and install the former function which does call with the default method for lists. Also use this in a few appropriate places. An old DEC compiler doesn't like C preprocessor directives that are preceded by whitespace. Removed such whitespace. [Reported by Chris Wensley] New or improved functionality: The primitive groups library has been extended to degree 2499. New operation and extended functionality of with an optional argument giving the position of the insertion. They are based on an efficient kernel function COPY_LIST_ENTRIES. Added fast kernel implementation of Tarjan's algorithm for strongly connected components of a directed graph. Now can be used with larger numbers. (Made internal function TraceModQF non-recursive.) A new operation and a corresponding method for rationals. A new operation has been added, and a corresponding method for integers has been installed. This method allows one to specify the amount of work to be spent on looking for factors. The generators of full s. c. algebras can now be accessed with the dot operator. [Reported by Marcus Bishop] New Conway polynomials computed by Kate Minola, John Bray, Richard Parker. A new attribute . The code has been written by Alexander Hulpke. The functions , , , and have been turned into operations, to admit the installation of methods for arguments other than integers. Up to now, one could assign only lists with . Now also records are admitted. now admits entering a list of strings instead of a list of required filters. Each such string must evaluate to a filter when used as the argument of . The advantage of this variant is that these strings are used to compose an info string (which is shown by ApplicableMethod) that reflects exactly the required filters. In test files that are read with , the assertion level is set to 2 between START_TEST and STOP_TEST. This may result in runtimes for the tests that are substantially longer than the usual runtimes with default assertion level 0. In particular this is the reason why some of the standard test files require more time in &GAP; 4.4.6 than in &GAP; 4.4.5. Some very basic functionality for floats.

&GAP; 4.4 Update 7 (March 2006) New or improved functionality: The functionality for character tables has been extended by addition of an option to show power maps and centralizer orders in a format similar to that used in the ATLAS. Furthermore the options handling is now hierarchical, in order to admit more flexible overloading. For the function , there is now an iterator variant LowIndexSubgroupsFpGroupIterator. [Suggested (and based on code contributed) by Michael Hartley] Semigroup functionality in &GAP; has been improved and extended. Green's relations are now stored differently, making the system more amenable to new methods for computing these relations in special cases. It is now possible to calculate Green's classes etc. without computing the entire semigroup or necessarily loading the package MONOID. Furthermore, the Froidure-Pin algorithm has now been implemented in &GAP;. Functionality for creating free products of any list of groups for which a finite presentation can be determined had been added. This function returns a finitely presented group. This functionality includes the Embedding operation. As an application of this new code a specialized direct product operation has been added for finitely presented groups which returns a finitely presented group. This application includes Embedding and Projection functionality. Some new Straight Line Program (SLP) functionality has been added. The new functions take given SLPs and create new ones by restricting to a subset of the results, or to an intermediate result or by calculating the product of the results of two SLPs. New code has been added to allow group elements with memory; that is, they store automatically how they were derived from some given set of generators. Note that there is not yet documentation for this functionality, but some packages already use it. New code has been added to handle matrices and vectors in such a way that they do not change their representation in a generic manner. The method for p-solvable p-modular Brauer tables now keeps the order of the irreducibles in the ordinary table. &GAP; can now handle any finite field for which the Conway polynomial is known or can be computed. New Conway polynomials provided by John Bray and Kate Minola have been added. The methods for strings (filenames) and streams now automatically set the screen width (see ) to 80 before the tests, and reset it afterwards. Now a few more checks are done during the configure phase of compiling for future use of some I/O functions of the C-library in a package. Also the path to the &GAP; binaries for the &GAP; compiler is now handled via autoconf. Finally, now autoconf version 2.59 is used. Fixed bugs which could produce wrong results: Some technical errors in the functions for compressed vectors and matrices which could lead to corruption of internal data structures and so to crashes or conceivably to wrong results. [Reported by Roman Schmied] A potential problem in the generic method for the undocumented operation DirectFactorsOfGroup: It was silently assumed that delivers the trivial subgroup as first and the whole group as last entry of the resulting list. The code for sublists of compressed vectors created by vec{range} may write one byte beyond the space allocated for the new vector, overwriting part of the next object in the workspace. Thanks to Jack Schmidt for narrowing down the problem. Given a class function object of value zero, an method for a class function erroneously did not return fail. [Reported by Jack Schmidt] The method for a class function erroneously returned a finite number if one of the values was nonreal, not a cyclotomic integer, and had norm 1. Two missing perfect groups were added, and the permutation degree lowered on the perfect groups with the largest degrees. [Reported by Jack Schmidt] When a character table was displayed with , the centralizer order displayed for the first class shown was not correct if it did not involve all prime divisors of the group. [Reported by Jack Schmidt] The first argument of the function must be a field. This is checked from now on. [Reported by Laurent Bartholdi] Up to now, it was possible to create a group object from a semigroup of cyclotomics using , although groups of cyclotomics are not admissible. [Reported by Alexander Konovalov] The documentation of CharacteristicPolynomial(F,mat) was ambiguous if FieldOfMatrix(mat) <= F < DefaultFieldOfMatrix(mat). In particular, the result was representation dependent. This was fixed by introducing a second field which specifies the vector space which mat acts upon. [Reported by Jack Schmidt] AssociatedReesMatrixSemigroupOfDClass produced an incorrect sandwich matrix for the semigroup created. This matrix is an attribute set when creating the Rees matrix semigroup but is not used for creating the semigroup. The incorrect result was returned when SandwichMatrix was called. [Reported by Nelson Silva and Joao Araujo] The literal "compiled" was given an incorrect length. The kernel was then unable to find compiled library code as the search path was incorrect. Also the documentation example had an error in the path used to invoke the gac compiler. The twisting group in a generic wreath product might have had intransitive action. [Reported by Laurent Bartholdi] There was an arithmetic bug in the polynomial reduction code. Fixed bugs which could lead to crashes: Bug 1 in the list of fixed bugs which could lead to wrong results could also potentially lead to crashes. Other fixed bugs: The matrices of invariant forms stored as values of the attributes , , and , for matrix groups over finite fields, are now in the (compressed) format returned by . String now returns an immutable string, by making a copy before changing the argument. permutation^0 and permutation^1 were not handled with special code in the kernel, hence were very slow for big permutations. [Reported by Max Neunhöffer] Added code to cache the induced pcgs for an arbitrary parent pcgs. (This code was formerly part of the CRISP package.) This fix consists of numerous changes to improve support for direct products, including: - new methods for PcgsElementaryAbelianSeries, PcgsChiefSeries, ExponentsOfPcElement, DepthOfPcElement for direct products - fixed EnumeratorOfPcgs to test for membership first - new methods for membership test in groups which have an induced pcgs - added GroupOfPcgs attribute to pcgs in various methods - fixed declarations of PcgsElementaryAbelianSeries, PcgsChiefSeries (the declared argument was a pcgs, not a group) [Reported by Roman Schmied] Corrected a term ordering problem encountered by the basis construction code for finite dimensional vector spaces of multivariate rational functions. [Reported by Jan Draisma] When the factor of a finite dimensional group ring by an ideal was formed, a method intended for free algebras modulo relations was used, and the returned factor algebra could be used for (almost) nothing. [Reported by Heiko Dietrich] Up to now, ran into an error when one asked for the n-th power map where n was not a small integer. This happened in some &GAP; library functions if the exponent of the character table in question was not a small integer. Up to now, the test whether a finite field element was contained in a group of finite field elements ran into an error if the element was not in the field generated by the group elements. [Reported by Heiko Dietrich] Conjugacy classes of natural (special) linear groups are now always returned with trivial class first. Up to now, it could happen that reduced an entry in its second argument to a list containing only one integer but did not replace the list by that integer; according to the conventions, this replacement should be done. The functions PrintTo and AppendTo did not work correctly for streams. [Reported by Marco Costantini] The function Basis did not return a value when it was called with the argument Rationals. [Reported by Klaus Lux] For certain matrix groups, the function StructureDescription raised an error message. The reason for this was that a trivial method for IsGeneralLinearGroup for matrix groups in lib/grpmat.gi which is ranked higher than the nontrivial method for generic groups in lib/grpnames.gi called the operation IsNaturalGL, for which there was no nontrivial method available. [Reported by Nilo de Roock] Action on sets of length 1 was not correctly handled. [Reported by Mathieu Dutour] Now WriteByte admits writing zero characters to all streams. [Reported by Marco Costantini] The conjugacy test for subgroups tests for elementary abelian regular normal subgroup (EARNS) conjugacy. The fix will catch this in the case that the second group has no EARNS. [Reported by Andrew Johnson] So far, the UNIX installation didn't result in a correct gap.sh if the installation path contained space characters. Now it should handle this case correctly, as well as other unusual characters in path names (except for double quotes).
&GAP; 4.4 Update 8 (September 2006) New or improved functionality: A function with underlying operation PositionsOp, which returns the list of all positions at which a given object appears in a given list. now returns fail when the element is not a power of the base. It is now allowed to continue long integers, strings or identifiers by ending a line with a backslash or with a backslash and carriage return character. So, files with &GAP; code and DOS/Windows-style line breaks are now valid input on all architectures. The command line for starting the session and the system environment are now available in GAPInfo.SystemCommandLine and GAPInfo.SystemEnvironment. Names of all bound global variables and all component names are available on &GAP; level. Added a few new Conway polynomials computed by Kate Minola and John Bray. There is a new concept of random sources, see , which provides random number generators which are independent of each other. There is kernel code for the Mersenne twister random number generator (based on the code by Makoto Matsumoto distributed at http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html). It provides fast 32-bit pseudorandom integers with a period of length 2^{19937}-1 and a 623-dimensional equidistribution. The library methods for random elements of lists and for random (long) integers are using the Mersenne twister now.

In line editing mode (usual input mode without -n option) in lines starting with gap> , > or brk> this beginning part is immediately removed. This is a convenient feature that allows one to cut and paste input lines from other sessions or from manual examples into the current session. Fixed bugs which could produce wrong results: The function returned coefficient vectors also in certain situations where in fact no decomposition exists. This happened only if the matrix entered as the first argument contained irrational values and a row in the matrix entered as the second argument did not respect the algebraic conjugacy relations between the columns of the first argument. So there was no problem for the usual cases that the two matrices are integral or that they are lists of Brauer characters. [Reported by Jürgen Müller] PC group homomorphisms can claim a wrong kernel after composition. [Reported by Serge Bouc] The return value of had an inconsistent defining structure constants table for the case of coefficients fields not containing the integer zero. [Reported by Gábor Nagy] The manual guarantees that a conjugator automorphism has a conjugating element in the group if possible. This was not guaranteed. for symmetric groups gave a wrong result if fixed points were prescribed for base. Contrary to what is documented the function POW_OBJ_INT returned an immutable result for POW_OBJ_INT(m,1) for a mutable object m. This is triggered by the code m^1. for a group had a problem if the group had lots of equal generators. The produced elements were extremely poorly distributed in that case. This is now fixed for the case that elements of the group can easily be sorted. Fixed the bug that the type of a boolean list (see ) was computed wrongly: The type previously had IS_PLIST_REP instead of IS_BLIST_REP in its filter list. did not respect a special method for right transversals. [Reported by Steve Costenoble] Wrong results for for some arguments on 64 bit systems only. [Reported by Robert Morse] When prescribing a subgroup to be included, the low index algorithm for fp groups sometimes returned subgroups which are in fact conjugate. (No subgroups are missing.) [Reported by Ignaz Soroko] Fixed bugs which could lead to crashes: The command line option -x allowed arguments > 256 which can then result in internal buffers overflowing. Now bigger numbers in the argument are equivalent to -x 256. [Reported by Michael Hartley] Other fixed bugs: Two special methods for the operation were not correct, such that composing (and multiplying) certain group homomorphisms did not work. [Reported by Peter Mayr] In the definition of , it had been stated erroneously that the value must lie in the field of p^n-th roots of unity; the correct condition is that the value must lie in the field of (p^n-1)-th roots of unity. [Reported by Jack Schmidt] The function failed when one of the factors was known to be infinite. For a linear action homomorphism PreImageElm was very slow because there was no good method to check for injectivity, which is needed for nearly all good methods for PreImageElm. This change adds such a new method for IsInjective. [Reported by Akos Seress] Rare errors in the complement routine for permutation groups. Blocks code now uses jellyfish-style random elements to avoid bad Schreier trees. A method for has been added. Such a method was missing so far. Corrected to handle the trivial group correctly. Added new methods that follow immediately from computing the Schur Cover of a group. The attribute , the operations and , and the property are added to the library with documentation and references. Display the correct expression in a call stack trace if an operation was called somewhere up due to the evaluation of a unary or binary operation. Made StripMemory an operation rather than a global function. Added ForgetMemory operation. Adjust things slightly to make later conversion to new vectors/matrices easier. Nothing of this should be visible. Corrected some details in the documentation of the &GAP; language. [Reported by Alexander Konovalov] Now is much faster on long mutable plain lists. (The former operation is substituted by a function and a new operation PositionSortedOp.) [Reported by Silviu Radu] Now it is possible to switch repeated warnings off when working with iterative polynomial rings.

&GAP; 4.4 Update 9 (November 2006) Fixed bugs which could produce wrong results: The methods of for reading from files or terminals returned wrong results for characters in the range [128..255]. [Reported by Yevgen Muntyan] Other fixed bugs: A method for the operation did not succeed. A fix for Orbits with a set of points as a seed. Added a generic method such that works with all types of lists. Fixed a problem in choosing the prime in the Dixon-Schneider algorithm. [Reported by Toshio Sumi] New or improved functionality: ReducedOrdinary was used in the manual, but was not documented, being a synonym for the documented ReducedCharacters. Changed manual examples to use the latter form. [Reported by Vahid Dabbaghian]
&GAP; 4.4 Update 10 (October 2007) New or improved functionality: Files in the cnf directory of the &GAP; distribution are now archived as binary files. Now &GAP; can be installed with UNIX or with WINDOWS style line breaks on any system and should work without problems. Since large finite fields are available, some restrictions in the code for computing irreducible modules over finite fields are no longer necessary. (They had been introduced in order to give better error messages.) Made PositionSublist faster in case the search string does not contain repetitive patterns. The function MakeImmutable now returns its argument. Dynamically loaded modules now work on Mac OS X. As a consequence, this allows to work with the Browse, EDIM and IO packages on Mac OS X. Introduced ViewObj and PrintObj methods for algebraic number fields. Made them applicable to AlgebraicExtension by adding the property IsNumberField in the infinite field case. The function is documented now. The function now accepts also Brauer characters as arguments. The function now accepts also a list of field elements instead of a field. Also, now the comparison of return values (w.r.t. equality, containment) yields true if the parameters coincide and the ground fields fit. The function is now documented. Lists in &GAP; sometimes occupy memory for possible additional entries. Now plain lists and strings read by &GAP; and the lists returned by only occupy the memory they really need. For more details see the documentation of the new function . There are some new Conway polynomials in characteristic 2 and 3 provided by Kate Minola. A new operation MemoryUsage determines the memory usage in bytes of an object and all its subobjects. It does not consider families and types but handles arbitrary self-referential structures of objects. Fixed bugs which could produce wrong results: When forming the semidirect product of a matrix group with a vector space over a non-prime field the embedding of the vector space gave a wrong result. [Reported by anvita21] DefaultRing failed for constant polynomials over nonprime fields. [Reported by Stefan Kohl] The method in ffeconway.gi that gets coefficients WRT to the canonical basis of the field from the representation is only correct if the basis is over the prime field. Added a TryNextMethod if this is not the case. [Reported by Alla Detinko] Creating a large (>2^{16}) field over a non-prime subfield went completely wrong. [Reported by Jack Schmidt, from Alla Detinko] A method for Coefficients for Conway polynomial FFEs didn't check that the basis provided was the canonical basis of the RIGHT field. [Reported by Bettina Eick] An elementary abelian series was calculated wrongly. [Reported by N. Sieben] Orbits on sets of transformations failed. Wrong methods for and have been removed. These methods were based on the assumption that one can obtain a set of ring generators by taking the union of a known set of field generators, the set of the inverses of these field generators and {1}. The name of a group of order 117600 and degree 50 was incorrect in the Primitive Permutation Groups library. In particular, a group was wrongly labelled as PGL(2, 49). There was a possible error in SubgroupsSolvableGroup when computing subgroups within a subgroup. An error in 2-Cohomology computation for pc groups was fixed. IsConjugate used normality in a wrong supergroup Fixed bugs which could lead to crashes: &GAP; crashed when the PATH environment variable was not set. [Reported by Robert F. Morse] &GAP; could crash when started with option -x 1. Now the number of columns is initialized with at least 2. [Reported by Robert F. Morse] After loading a saved workspace &GAP; crashed when one tried to slice a compressed vector over a field with 2 < q <= 256 elements, which had already existed in the saved workspace. [Reported by Laurent Bartholdi] FFECONWAY.WriteOverSmallestCommonField tripped up when the common field is smaller than the field over which some of the vector elements are written, because it did a test based on the degree of the element, not the field it is written over. [Reported by Thomas Breuer] Fixed the following error: When an FFE in the Conway polynomial representation actually lied in a field that is handled in the internal representation (eg GF(3)) and you tried to write it over a bigger field that is ALSO handled internally (eg GF(9)) you got an element written over the larger field, but in the Conway polynomial representation, which is forbidden. [Reported by Jack Schmidt] Attempting to compress a vector containing elements of a small finite field represented as elements of a bigger (external) field caused a segfault. [Reported by Edmund Robertson] &GAP; crashed when BlistList was called with a range and a list containing large integers or non-integers. [Reported by Laurent Bartholdi] &GAP; no longer crashes when OnTuples is called with a list that contains holes. [Reported by Thomas Breuer] Other fixed bugs: Socle for the trivial group could produce an error message. ran into an error for immutable strings without trailing slash as argument. [Reported by Thomas Breuer] The functions and did not work for general linear mappings with trivial (pre)image. [Reported by Alper Odabas] Creating an enumerator for a prime field with more than 65536 elements ran into an infinite recursion. [Reported by Akos Seress] The performance of List, Filtered, Number, ForAll and ForAny if applied to non-internally represented lists was improved. Also the performance of iterators for lists was slightly improved. Finite field elements now know that they can be sorted easily which improves performance in certain lookups. A method for was missing for the case that exactly one argument is an inhomogeneous list. [Reported by Laurent Bartholdi] Long integers in expressions are now printed (was not yet implemented). [Reported by Thomas Breuer] Fixed kernel function for printing records. New C library interfaces (e.g., to ncurses in the Browse package) need some more memory to be allocated with malloc. The default value of &GAP; -a option is now 2m>. Avoid warnings about pointer types by newer gcc compilers. IsBound(l[pos]) was failing for a large integer pos only when coded (e.g. in a loop or function body). ZmodpZObj is now a synonym for ZmodnZObj such that from now on such objects print in a way that can be read back into &GAP;. The outdated note that binary streams are not yet implemented has been removed.
&GAP; 4.4 Update 11 (December 2008) Fixed bugs which could produce wrong results: on objects with no subobjects left them in the cache and thus reported 0 in subsequent calls to MemoryUsage for the same object. [Reported by Stefan Kohl] might be missing characters. [Reported by Angel del Rio] Up to now, it was allowed to call the function with a field and a list of matrices such that the entries of the matrices were not contained in the field; in this situation, the result did not fit to the documentation. Now the entries of the matrices are required to lie in the field, if not then an error is signaled. For those finite fields that are regarded as field extensions over non-prime fields (one can construct such fields with ), the function erroneously returned a polynomial w.r.t. the extension of the prime field. [Reported by Stefan Kohl] Since the release of &GAP; 4.4.10, the return values of the function were not consistent w.r.t. the attribute ; the returned list could have length four or five. Now always the list of elements of the canonical basis is returned. calculated a wrong ordering in certain cases. [Reported by Paul Smith] The (&GAP; kernel) method for the operation for ranges had two bugs, which could yield a result range with either too few or too many elements. As a consequence, for example the results for ranges could be wrong. [Reported by Matthew Fayers] Fixed a bug in the short-form display of elements of larger finite fields, a bug in some cross-field conversions and some inefficiencies and a missing method in the code. [Reported by Jia Huang] In rare cases returned a wrong normal form (the version without transforming matrices did not have this problem). This is fixed. [Reported by Alexander Hulpke] The variant of the function that takes a string as its first argument returned wrong results if the last character of this string was a closing bracket. The code for central series in a permutation group used too tight a bound and thus falsely return a nilpotent permutation group as non-nilpotent. Fixed bugs which could lead to crashes: Under certain circumstances the kernel code for position in blists would access a memory location just after the end of the blist. If this location was not accessible, a crash could result. This was corrected and the code was cleaned up. [Reported by Alexander Hulpke] Other fixed bugs: The function can be called with a positive integer instead of a group, and then returns information about the simple group(s) of this order. (This feature is currently undocumented.) For the argument 1, however, it ran into an infinite loop. A lookup in an empty dictionary entered a break loop. Now returns fail. [Reported by Laurent Bartholdi] The c++ keyword and can no longer be used as a macro parameter in the kernel. [Reported by Paul Smith] The operation has methods designed to handle maps between permutation groups in a two-step approach, but did not reliably trigger the second step. This has now been fixed, preventing a slow infinite loop repeating the first step. This was normally only seen as part of a larger calculation. There were two methods for the operation which have implicitly assumed that finiteness of a collection can always be decided. Now, these methods check for and prior to calling . Made error message in case of corrupted help book information (manual.six file) shorter and more informative. [Reported by Alexander Hulpke] &GAP; cannot call methods with more than six arguments. Now the functions , , and signal an error if one attempts to declare an operation or to install a method with more than six arguments. Up to now, had a special method for general mappings, which was much worse than the generic method; this special method has now been removed. When printing elements of an algebraic extension parentheses around coefficients were missing. [Reported by Maxim Hendriks] New or improved functionality: Make dynamic loading of modules possible on CYGWIN using a DLL based approach. Also move to using autoconf version 2.61. One can now call , etc. with the return value of the function . The function returned fail for results that require a finite field with more than 65536 elements. Meanwhile &GAP; can handle larger finite fields, so this restriction was removed. (It is still possible that returns fail.) Methods for testing membership in general linear groups and special linear groups over the integers have been added. Methods for and ViewString for full row modules have been added. Further, a default method for has been added, which returns false for objects which are not free left modules. A ViewString method for objects with name has been added. The method for for polynomial rings has been improved, and methods for and ViewString for polynomial rings have been added. now works with huge n. The function is now documented. The return values of the function now store that they are division rings (if optional parameters are given then of course ths depends on these parameters).
&GAP; 4.4 Update 12 (December 2008) Fixed bugs which could lead to crashes: A bug whereby leaving an incomplete statement on a line (for instance typing while and then return) when prompt colouring was in use could lead to &GAP; crashing. Other fixed bugs: A bug which made the command-line editor unusable in a 64-bit version of &GAP; on Mac OS X.
gap-4r6p5/doc/changes/main.xml0000644000175000017500000000424412172557252014770 0ustar billbill Atlas"> —---"> <#Include SYSTEM "../versiondata"> ]> GAP - Changes from Earlier Versions Release &VERSIONNUMBER;, &RELEASEDAY; The GAP Group support@gap-system.org http://www.gap-system.org Copyright ©right; (1987-&RELEASEYEAR;) for the core part of the &GAP; system by the &GAP; Group.

Most parts of this distribution, including the core part of the &GAP; system are distributed under the terms of the GNU General Public License, see http://www.gnu.org/licenses/gpl.html or the file GPL in the etc directory of the &GAP; installation.

More detailed information about copyright and licenses of parts of this distribution can be found in Section of the &GAP; reference manual.

&GAP; is developed over a long time and has many authors and contributors. More detailed information can be found in Section of the &GAP; reference manual. <#Include SYSTEM "preface.xml"> <#Include SYSTEM "changes46.xml"> <#Include SYSTEM "changes45.xml"> <#Include SYSTEM "changes44.xml"> <#Include SYSTEM "../ref/changes.xml"> gap-4r6p5/doc/changes/makedocrel.g0000644000175000017500000000211612172557252015574 0ustar billbill## this creates the documentation, needs: GAPDoc package, latex, pdflatex, ## mkindex, dvips ## Read( "makedocreldata.g" ); SetGapDocLaTeXOptions("nocolor", rec(Maintitlesize := "\\fontsize{36}{38}\\selectfont")); MakeGAPDocDoc( GAPInfo.ManualDataChanges.pathtodoc, GAPInfo.ManualDataChanges.main, GAPInfo.ManualDataChanges.files, GAPInfo.ManualDataChanges.bookname, GAPInfo.ManualDataChanges.pathtoroot, "MathJax" );; Exec ("mv -f manual.pdf manual-bw.pdf"); SetGapDocLaTeXOptions("color", rec(Maintitlesize := "\\fontsize{36}{38}\\selectfont")); MakeGAPDocDoc( GAPInfo.ManualDataChanges.pathtodoc, GAPInfo.ManualDataChanges.main, GAPInfo.ManualDataChanges.files, GAPInfo.ManualDataChanges.bookname, GAPInfo.ManualDataChanges.pathtoroot, "MathJax" );; GAPDocManualLabFromSixFile( "changes", "manual.six" );; CopyHTMLStyleFiles("."); QUIT; ############################################################################# ## #E gap-4r6p5/doc/changes/preface.xml0000644000175000017500000000162512172557252015451 0ustar billbill Preface This is one of the three main &GAP; books. It describes most essential changes from previous &GAP; releases.

In addition to this manual, there is the &GAP; Tutorial (see ) and the &GAP; Reference Manual (see ) containing detailed documentation of the mathematical functionality of &GAP;.

A lot of the functionality of the system and a number of contributed extensions are provided as &GAP; packages, and each of these has its own manual. New versions of packages are released independently of &GAP; releases, and changes between package versions may be described in their documentation.

gap-4r6p5/doc/manualbib.xml0000644000175000017500000057141512172557252014377 0ustar billbill# J. A.Abbott On the Factorization of Polynomials over Algebraic Fields School of Mathematical Sciences, University of Bath 1989 September

DeanAlvis GeorgeLusztig Correction to the paper: <C>T</C>he representations and generic degrees of the <C>H</C>ecke algebra of type <C><M>H_4</M></C> [<C>J</C>. <C>R</C>eine <C>A</C>ngew. <C>M</C>ath. <C><Alt Only="BibTeX,BibTeXhref">\bf </Alt>336</C> (1982), 201–212; <C>MR</C>0671329 (84a:20013)] 1994 449 217–218 Correction: ibid. \bf 449, 217–218 (1994) AL82 0075-4102 1268587 (95a:20005) 20C15 Bhama Srinivasan JRMAA8 Journal für die Reine und Angewandte Mathematik
DeanAlvis GeorgeLusztig The representations and generic degrees of the <C>H</C>ecke algebra of type <C><M>H_4</M></C> 1982 336 201–212 Correction: ibid. \bf 449, 217–218 (1994) AL94 0075-4102 671329 (84a:20013) 20C15 Bhama Srinivasan JRMAA8 Journal für die Reine und Angewandte Mathematik
DeanAlvis The left cells of the <C>C</C>oxeter group of type <C><M>H_4</M></C> 1987 107 1 160–168 0021-8693 883878 (88d:20014) 20C15 (20C30 20H15) Bhama Srinivasan JALGA4 Journal of Algebra
D. G.Arrell S.Manrai M. F.Worboys A procedure for obtaining simplified defining relations for a subgroup Groups–St Andrews 1981 (St Andrews, 1981) Cambridge Univ. Press 1982 Colin M.Campbell Edmund F.Robertson 71 London Math. Soc. Lecture Note Ser. 155–159
Cambridge
GrpsStAndrews81 0-521-28974-2 finitely presented groups; subgroup presentation, simplification; modified Todd Coxeter (mtc), tree decoding; algorithm description 679157 (84a:20041) 20F05 (20-04) D. G.Arrell E. F.Robertson A modified <C>T</C>odd-<C>C</C>oxeter algorithm Computational group theory (Durham, 1982) Academic Press 1984 Michael D.Atkinson 27–32
London
Durham1982 0-12-066270-1 finitely presented groups; subgroup presentation, simplification; modified Todd Coxeter (mtc), tree decoding; algorithm description 760644 (86g:20042) 20F05 (20-04) I. D. Macdonald E.Artin Galoissche <C>T</C>heorie Verlag Harri Deutsch 1973
Zurich
Übersetzung nach der zweiten englischen Auflage besorgt von Viktor Ziegler, Mit einem Anhang von N. A. Milgram, Zweite, unveränderte Auflage, Deutsch-Taschenbücher, No. 21 0392905 (52 #13718) 12-02 86 UlrichBaum Existenz und effiziente <C>K</C>onstruktion schneller <C>F</C>ouriertransformationen überauflösbarer <C>G</C>ruppen Rheinische Friedrich Wilhelm Universität Bonn 1991 Dissertation
Bonn, Germany
UlrichBaum MichaelClausen Computing irreducible representations of supersolvable groups 1994 63 207 351–359 0025-5718 1226811 (94i:20029) 20C40 (20C15 68Q40) Wolfgang Lempken MCMPAF Mathematics of Computation
LászlóBabai GeneCooperman LarryFinkelstein ÁkosSeress Nearly Linear Time Algorithms for Permutation Groups with a Small Base Proceedings of the International Symposium on Symbolic and Algebraic Computation (ISSAC'91), Bonn 1991 1991 200–209 ACM Press ISSAC91
M. J.Beetham C. M.Campbell A note on the <C>T</C>odd-<C>C</C>oxeter coset enumeration algorithm 1976 20 1 73–79 0013-0915 finitely presented groups; subgroup presentation; modified Todd Coxeter (mtc); algorithm description 0399265 (53 #3116) 20F05 D. L. Johnson Proceedings of the Edinburgh Mathematical Society. Series II
MarkBenard Schur indices and splitting fields of the unitary reflection groups 1976 38 2 318–342 0021-8693 0401901 (53 #5727) 20C30 Larry C. Grove Journal of Algebra
C. T.Benson C. W.Curtis On the degrees and rationality of certain characters of finite <C>C</C>hevalley groups 1972 165 251–273 0002-9947 0304473 (46 #3608) 20C30 A. Dress Transactions of the American Mathematical Society
T. R.Berger Characters and derived length in groups of odd order 1976 39 1 199–207 0021-8693 0396729 (53 #590) 20C15 I. M. Isaacs Journal of Algebra
Hans UlrichBesche Die <C>B</C>erechnung von <C>C</C>haraktergraden und <C>C</C>harakteren endlicher auflösbarer <C>G</C>ruppen im <C>C</C>omputeralgebrasystem <C>GAP</C> Lehrstuhl D für Mathematik, Rheinisch Westfälische Technische Hochschule 1992 Diplomarbeit
Aachen, Germany
Hans UlrichBesche BettinaEick Construction of finite groups 1999 27 4 387–404 0747-7171 1681346 (2000c:20001) 20-04 (20D05 20D10) Eamonn A. O'Brien Journal of Symbolic Computation
Hans UlrichBesche BettinaEick The groups of order at most 1000 except 512 and 768 1999 27 4 405–413 0747-7171 1681347 (2000c:20002) 20-04 (20D05 20D10) Eamonn A. O'Brien Journal of Symbolic Computation
Hans UlrichBesche BettinaEick The groups of order <C><M>q^n \cdot p</M></C> 2001 29 4 1759–1772 0092-7872 1853124 (2002f:20028) 20D60 COALDM Communications in Algebra
Hans UlrichBesche BettinaEick E. A.O'Brien The groups of order at most 2000 2001 7 1–4 (electronic) 1079-6762 1826989 20D60 Electronic Research Announcements of the American Mathematical Society
Hans UlrichBesche BettinaEick E. A.O'Brien A millennium project: constructing small groups 2002 12 5 623–644 0218-1967 1935567 (2003h:20042) 20D99 Robert M. Guralnick International Journal of Algebra and Computation
F. RudolfBeyl UlrichFelgner PeterSchmid On groups occurring as center factor groups 1979 61 1 161–177 0021-8693 554857 (81i:20034) 20E22 Richard E. Phillips JALGA4 Journal of Algebra
BettinaEick E. A.O'Brien Enumerating <C><M>p</M></C>-groups 1999 67 2 191–205 Group theory 0263-6115 1717413 (2000h:20033) 20D15 (20J05) Phạm Anh Minh JAMADS Australian Mathematical Society. Journal. Series A. Pure Mathematics and Statistics
BettinaEick E. A.O'Brien The groups of order <C><M>512</M></C> Algorithmic algebra and number theory (Heidelberg, 1997) Springer 1999 B. H.Matzat G.-M.Greuel G.Hiss 379–380
Berlin
Proceedings of Abschlusstagung des DFG Schwerpunktes Algorithmische Algebra und Zahlentheorie in Heidelberg 1672078 (99m:20034) 20D15
M. F.Newman E. A.O'Brien M. R.Vaughan-Lee Groups and nilpotent <C>L</C>ie rings whose order is the sixth power of a prime 2004 278 1 383–401 0021-8693 2068084 (2005c:20034) 20D15 (17B30) Jeffrey M. Riedl JALGA4 Journal of Algebra
E. A.O'Brien M. R.Vaughan-Lee The groups with order <M>p^7</M> for odd prime <M>p</M> 2005 292 1 243–258 0021-8693 2166803 (2006d:20038) 20D15 (17B30) JALGA4 Journal of Algebra
BorisGirnat <C>K</C>lassifikation der <C>G</C>ruppen bis zur <C>O</C>rdnung <C><M>p^5</M></C> TU Braunschweig 2003 Staatsexamensarbeit
Braunschweig, Germany
HeikoDietrich BettinaEick On the groups of cube-free order 2005 292 1 122–137 0021-8693 2166799 (2006g:20001) 20-04 (20D06 20D10) Eamonn A. O'Brien JALGA4 Journal of Algebra
ThomasBischops Collectoren im <C>P</C>rogrammsystem <C>GAP</C> Lehrstuhl D für Mathematik, Rheinisch Westfälische Technische Hochschule 1989 Diplomarbeit
Aachen, Germany
 WiebBosma John J.Cannon Handbook of <C>C</C>ayley Functions Department of Pure Mathematics, University of Sydney 1992
Sydney, Australia
system design; Cayley;; manual 282 pp. N.Bourbaki Éléments de mathématique. <C>F</C>asc. <C>XXXIV</C>. <C>G</C>roupes et algèbres de <C>L</C>ie. <C>C</C>hapitre <C>IV</C>: <C>G</C>roupes de <C>C</C>oxeter et systèmes de <C>T</C>its. <C>C</C>hapitre <C>V</C>: <C>G</C>roupes engendrés par des réflexions. <C>C</C>hapitre <C>VI</C>: systèmes de racines Hermann 1968 Actualités Scientifiques et Industrielles, No. 1337
Paris
0240238 (39 #1590) 22.50 (17.00) G. B. Seligman 288 pp. (loose errata)
Richard P.Brent Graeme L.Cohen A new lower bound for odd perfect numbers 1989 53 187 431–437, S7–S24 0025-5718 968150 (89m:11008) 11A25 (11Y05 11Y70) Samuel S. Wagstaff, Jr. MCMPAF Mathematics of Computation
ThomasBreuer Potenzabbildungen, <C>U</C>ntergruppenfusionen, <C>T</C>afel-<C>A</C>utomorphismen Lehrstuhl D für Mathematik, Rheinisch Westfälische Technische Hochschule 1991 Diplomarbeit
Aachen, Germany
T.Breuer K.Lux The multiplicity-free permutation characters of the sporadic simple groups and their automorphism groups 1996 24 7 2293–2316 0092-7872 1390375 (97c:20020) 20C34 (20D08) Peter Fleischmann COALDM Communications in Algebra
ThomasBreuer Integral bases for subfields of cyclotomic fields 1997 8 4 279–289 0938-1279 1464789 (99a:11120) 11R18 Wieb Bosma AAECEW Applicable Algebra in Engineering, Communication and Computing
ThomasBreuer GötzPfeiffer Finding possible permutation characters 1998 26 3 343–354 0747-7171 1633876 (99e:20005) 20B99 (20B40 20C15 20C40) Cheryl E. Praeger Journal of Symbolic Computation
ThomasBreuer SteveLinton The <C>GAP 4</C> Type System. Organizing Algebraic Algorithms ISSAC '98: Proceedings of the 1998 international symposium on Symbolic and algebraic computation 1998 38–45
New York, NY, USA
ACM Press Chairman: Volker Weispfenning and Barry Trager ISSAC98 1-58113-002-3 Rostock, Germany ACM Order No.: 505980, ACM member price $25
ThomasBreuer Computing possible class fusions from character tables 1999 27 6 2733–2748 0092-7872 1687309 (2000c:20015) 20C15 Jürgen Ritter COALDM Communications in Algebra
ThomasBreuer Simon P.Norton Improvements to the <C>A</C>tlas 297–327 The Clarendon Press Oxford University Press 1995 11 London Mathematical Society Monographs. New Series
New York
Appendix 2 by T. Breuer and S. Norton, Oxford Science Publications JLPW95 0-19-851481-6 1367961 (96k:20016) 20C20 (20-00 20D06 20D08) J. L. Alperin
E.Brieskorn Die <C>F</C>undamentalgruppe des <C>R</C>aumes der regulären <C>O</C>rbits einer endlichen komplexen <C>S</C>piegelungsgruppe 1971 12 57–61 0020-9910 0293615 (45 #2692) 55A05 L. Neuwirth Inventiones Mathematicae
EgbertBrieskorn KyojiSaito Artin-<C>G</C>ruppen und <C>C</C>oxeter-<C>G</C>ruppen 1972 17 245–271 0020-9910 0323910 (48 #2263) 20F05 D. E. Cohen Inventiones Mathematicae
MichelBroué GunterMalle Zyklotomische <C>H</C>eckealgebren Astérisque 1993 212 119–189 Représentations unipotentes génériques et blocs des groupes réductifs finis Asterisque212 0303-1179 1235834 (94m:20095) 20G40 (20C20 20H15) François Digne Paris Astérisque Société Mathématique de France
MichelBroué GunterMalle JeanMichel Generic blocks of finite reductive groups Astérisque 1993 212 7–92 Représentations unipotentes génériques et blocs des groupes réductifs finis Asterisque212 0303-1179 1235832 (95d:20072) 20G05 (20C20) Bhama Srinivasan Paris Astérisque Société Mathématique de France
MichelBroué GunterMalle JeanMichel Représentations unipotentes génériques et blocs des groupes réductifs finis Société Mathématique de France 1993
Paris
Astérisque No. 212 (1993) 0303-1179 1235830 (94c:20078) 20G05 1–203 AlanBaker A concise introduction to the theory of numbers Cambridge University Press 1984
Cambridge
0-521-24383-1; 0-521-28654-9 781734 (86f:11001) 11-01 Don Redmond xiii+95 A. E.Brouwer A. M.Cohen A.Neumaier Distance-regular graphs Springer-Verlag 1989 18 Ergebnisse der Mathematik und ihrer Grenzgebiete (3) [Results in Mathematics and Related Areas (3)]
Berlin
3-540-50619-5 1002568 (90e:05001) 05-02 (05C75) Joe Hemmeter xviii+495 HaroldBrown RolfBülow JoachimNeubüser HansWondratschek HansZassenhaus Crystallographic groups of four-dimensional space Wiley-Interscience [John Wiley & Sons] 1978
New York
Wiley Monographs in Crystallography 0-471-03095-3 0484179 (58 #4109) 82.20 (20F05) Daniel B. Litvin xiv+443
GilbertBaumslag Frank B.Cannonito Charles F.Miller III Some recognizable properties of solvable groups 1981 178 3 289–295 0025-5874 635200 (82k:20061) 20F16 (03D40 20F10) V. A. Romanʹkov MAZEAX Mathematische Zeitschrift
GilbertBaumslag Frank B.Cannonito Charles F.Miller III Computable algebra and group embeddings 1981 69 1 186–212 0021-8693 613868 (82e:20042) 20F10 (03D40 03D45 16A53) D. E. Cohen JALGA4 Journal of Algebra
N.Bourbaki Éléments de mathématique. <C>A</C>lgèbre. <C>C</C>hapitres 1 à 3 Hermann 1970
Paris
0274237 (43 #2) 00.00 (13.00) P. Samuel xiii+635 pp. (not consecutively paged)
R.Brown D. L.Johnson E. F.Robertson Some computations of nonabelian tensor products of groups 1987 111 1 177–202 0021-8693 913203 (88m:20071) 20F05 (20E22) Stephen J. Pride JALGA4 Journal of Algebra
FrancisBuekenhout DimitriLeemans On the list of finite primitive permutation groups of degree <C><M>\leq 50</M></C> 1996 22 2 215–225 0747-7171 1422147 (97g:20004) 20B15 Journal of Symbolic Computation
GregoryButler JohnMcKay The transitive groups of degree up to eleven 1983 11 8 863–911 0092-7872 695893 (84f:20005) 20B05 Michael Klemm COALDM Communications in Algebra
GregButler The transitive groups of degree fourteen and fifteen 1993 16 5 413–422 0747-7171 1271082 (95e:20006) 20B35 (20B40 68Q40) Gerhard Hiss Journal of Symbolic Computation
R. J.Bradford On the computation of integral bases and defects of integrity School of Mathematical Sciences, University of Bath 1989
Bath
BernardBeauzamy VilmarTrevisan Paul S.Wang Polynomial factorization: sharp bounds, efficient algorithms 1993 15 4 393–413 0747-7171 1227929 (94m:68091) 68Q40 Journal of Symbolic Computation
W.Burnside Theory of groups of finite order Dover Publications Inc. 1955
New York
Unabridged republication of the second edition, published in 1911 0069818 (16,1086c) 20.0X xxiv+512
GregoryButler Computing in permutation and matrix groups. <C>II</C>. <C>B</C>acktrack algorithm 1982 39 160 671–680 0025-5718 permutation groups, matrix groups;; backtrack through stabilizer chain 669659 (83k:20004b) 20-04 (20E25 20G40) J. D. Dixon MCMPAF Mathematics of Computation
GregoryButler JohnCannon Computing in permutation and matrix groups. <C>III</C>. <C>S</C>ylow subgroups 1989 8 3 241–252 0747-7171 1015649 (90i:20003) 20-04 (20D20) J. D. Dixon Journal of Symbolic Computation
GregoryButler Effective computation with group homomorphisms 1985 1 2 143–157 0747-7171 permutation groups; homomorphisms 818875 (87b:68057) 68Q40 (20-04 20B99) Journal of Symbolic Computation
Harvey A.Campbell An extension of coset enumeration McGill University 1971 M. Sc. thesis
Montreal, Canada
finitely presented groups; subgroup presentation; modified Todd Coxeter (mtc); program description
John J.Cannon Construction of defining relators for finite groups 1973 5 105–129 0012-365X 0318322 (47 #6869) 20F05 H. S. M. Coxeter Discrete Mathematics
R. W.Carter Conjugacy classes in the <C>W</C>eyl group 1972 25 1–59 0010-437X 0318337 (47 #6884) 20H15 (17B20) Juri A. Bahturin Compositio Mathematica
Roger W.Carter Finite groups of <C>L</C>ie type John Wiley & Sons Inc. 1985 Pure and Applied Mathematics (New York)
New York
Conjugacy classes and complex characters, A Wiley-Interscience Publication 0-471-90554-2 794307 (87d:20060) 20G40 (20-02 20C15) David B. Surowski xii+544 Roger W.Carter Finite groups of <C>L</C>ie type John Wiley & Sons Ltd. 1993 Wiley Classics Library
Chichester
Conjugacy classes and complex characters, Reprint of the 1985 original, A Wiley-Interscience Publication 0-471-94109-3 1266626 (94k:20020) 20C33 (20-02 20G40) xii+544
R. W.Carter Representation theory of the <C><M>0</M></C>-<C>H</C>ecke algebra 1986 104 1 89–103 0021-8693 865891 (88a:20014) 20C15 (16A65 20G05) David Benson JALGA4 Journal of Algebra
Roger W.Carter Simple groups of <C>L</C>ie type John Wiley & Sons, London-New York-Sydney 1972 Pure and Applied Mathematics, Vol. 28 0407163 (53 #10946) 20G15 (20D05 22E20) Louis Solomon viii+331 Roger W.Carter Simple groups of <C>L</C>ie type John Wiley & Sons Inc. 1989 Wiley Classics Library
New York
Reprint of the 1972 original, A Wiley-Interscience Publication 0-471-50683-4 1013112 (90g:20001) 20-02 (20D05 20E32 20G15 20G40 22-02) x+335 FrankCeller Kohomologie und <C>N</C>ormalisatoren in <C>GAP</C> Lehrstuhl D für Mathematik, Rheinisch Westfälische Technische Hochschule 1992 Diplomarbeit
Aachen, Germany
F.Celler J.Neubüser C. R. B.Wright Some remarks on the computation of complements and normalizers in soluble groups 1990 21 1-2 57–76 0167-8019 1085773 (91m:20026) 20D10 (20-04) Michael C. Slattery AAMADV Acta Applicandae Mathematicae. An International Survey Journal on Applying Mathematics and Mathematical Applications
RuthCharney Artin groups of finite type are biautomatic 1992 292 4 671–683 0025-5831 1157320 (93c:20067) 20F36 (20F10) D. F. Holt MAANA Mathematische Annalen
MichaelClausen A direct proof of <C>M</C>inkwitz's extension theorem 1997 8 4 305–306 0938-1279 1464791 20C15 AAECEW Applicable Algebra in Engineering, Communication and Computing
HenriCohen A course in computational algebraic number theory Springer-Verlag 1993 138 Graduate Texts in Mathematics
Berlin
3-540-55640-0 1228206 (94i:11105) 11Y40 (11Rxx 68Q40) Joe P. Buhler xii+534
S. B.Conlon Calculating characters of <C><M>p</M></C>-groups 1990 9 5-6 535–550 Computational group theory, Part 1 0747-7171 1075421 (91j:20033) 20C40 (20C15 20D15) Michael C. Slattery Journal of Symbolic Computation
S. B.Conlon Computing modular and projective character degrees of soluble groups 1990 9 5-6 551–570 Computational group theory, Part 1 0747-7171 1075422 (91j:20034) 20C40 (20C15 20C20) Michael C. Slattery Journal of Symbolic Computation
J. H.Conway R. T.Curtis S. P.Norton R. A.Parker R. A.Wilson Atlas of finite groups Oxford University Press 1985
Eynsham
Maximal subgroups and ordinary characters for simple groups, With computational assistance from J. G. Thackray 0-19-853199-0 827219 (88g:20025) 20D05 (20-02) R. L. Griess xxxiv+252
John H.Conway AlexanderHulpke JohnMcKay On transitive permutation groups LMS J. Comput. Math. 1998 1 1–8 (electronic) 1461-1570 1635715 (99g:20011) 20B05 (20B40) D. F. Holt LMS Journal of Computation and Mathematics
GeneCooperman LarryFinkelstein A random base change algorithm for permutation groups 1994 17 6 513–528 0747-7171 1300351 (96a:68048) 68Q40 (20B07) Journal of Symbolic Computation
T. H.Cormen C. E.Leiserson R. L.Rivest Introduction to algorithms MIT Press 1990 The MIT Electrical Engineering and Computer Science Series
Cambridge, MA
0-262-03141-8 1066870 (91i:68001) 68-01 (05-01 05C85 68Q25) Selim G. Akl xx+1028 DavidCox JohnLittle DonalO'Shea Ideals, varieties, and algorithms Springer-Verlag 1997 Undergraduate Texts in Mathematics
New York
Second An introduction to computational algebraic geometry and commutative algebra 0-387-94680-2 1417938 (97h:13024) 13P10 (13-01 14-01 14Qxx 68Q40) xiv+536 Charles W.Curtis IrvingReiner Methods of representation theory. <C>V</C>ol. <C>I</C> John Wiley & Sons Inc. 1981
New York
With applications to finite groups and orders, Pure and Applied Mathematics, A Wiley-Interscience Publication 0-471-18994-4 632548 (82i:20001) 20-02 (10C30 12A57 20Cxx) J. L. Alperin xxi+819 Charles W.Curtis IrvingReiner Methods of representation theory. <C>V</C>ol. <C>II</C> John Wiley & Sons Inc. 1987 Pure and Applied Mathematics (New York)
New York
With applications to finite groups and orders, A Wiley-Interscience Publication 0-471-88871-0 892316 (88f:20002) 20-02 (11Exx 18F25 19A31 19B28 19C99 20Cxx) J. L. Alperin xviii+951
PierreDeligne Les immeubles des groupes de tresses généralisés 1972 17 273–302 0020-9910 0422673 (54 #10659) 32C40 (55A25) Alan H. Durfee Inventiones Mathematicae
Vinay V.Deodhar A note on subgroups generated by reflections in <C>C</C>oxeter groups 1989 53 6 543–546 0003-889X 1023969 (91c:20063) 20H15 (20F55) François Digne ACVMAL Archiv der Mathematik
John D.Dixon High speed computation of group characters 1967 10 446–450 0029-599X 0224726 (37 #325) 20.80 (65.00) D. H. Lehmer Numerische Mathematik
John D.Dixon BrianMortimer The primitive permutation groups of degree less than <C><M>1000</M></C> 1988 103 2 213–238 0305-0041 923674 (89b:20014) 20B10 (20B15 20B20) Wolfgang Knapp MPCPCO Mathematical Proceedings of the Cambridge Philosophical Society
John D.Dixon Constructing representations of finite groups Groups and computation (New Brunswick, NJ, 1991) Amer. Math. Soc. 1993 LarryFinkelstein William M.Kantor 11 DIMACS Ser. Discrete Math. Theoret. Comput. Sci. 105–112
Providence, RI
DIMACS 0-8218-6599-4 1235797 (94h:20011) 20C15 (20C30) Peter Fleischmann
AndreasDress A characterisation of solvable groups 1969 110 213–217 0025-5874 0248239 (40 #1491) 20.80 R. Schmidt Mathematische Zeitschrift
F.DuCloux Coxeter Version 1.0 Université de Lyon
Lyon, France
1991
MatthewDyer Reflection subgroups of <C>C</C>oxeter systems 1990 135 1 57–73 0021-8693 1076077 (91j:20100) 20F55 (17B20 20H15) Robert Bédard JALGA4 Journal of Algebra
D. B. A.Epstein D. F.Holt S. E.Rees The use of <C>K</C>nuth-<C>B</C>endix methods to solve the word problem in automatic groups 1991 12 4-5 397–414 Computational group theory, Part 2 0747-7171 1146506 (92m:68052) 68Q40 (03D40 20F10) Klaus Madlener Journal of Symbolic Computation
BettinaEick Special presentations for finite soluble groups and computing (pre-)<C>F</C>rattini subgroups Groups and computation, II (New Brunswick, NJ, 1995) Amer. Math. Soc. 1997 LarryFinkelstein William M.Kantor 28 DIMACS Ser. Discrete Math. Theoret. Comput. Sci. 101–112
Providence, RI
DIMACS2 0-8218-0516-9 1444133 (99a:20014) 20D10 (20-04)
BettinaEick FranzGähler WernerNickel Computing maximal subgroups and <C>W</C>yckoff positions of space groups 1997 53 4 467–474 0108-7673 1461658 (98g:20080) 20H15 (82D25) Vojtěch Kopský ACACEQ Acta Crystallographica. Section A: Foundations of Crystallography
B.Eick B.Höfling The solvable primitive permutation groups of degree at most 6560 LMS J. Comput. Math. 2003 6 29–39 (electronic) 1461-1570 1971491 (2004a:20005) 20B15 Xianhua Li LMS Journal of Computation and Mathematics
BettinaEick AlexanderHulpke Computing the maximal subgroups of a permutation group <C>I</C> 155–168 DIMACS3
GrahamEllis On the capability of groups 1998 41 3 487–495 0013-0915 1697585 (2000e:20053) 20E22 (20F28 20J05) J. Wiegold PRMSA3 Proceedings of the Edinburgh Mathematical Society. Series II
David B. A.Epstein James W.Cannon Derek F.Holt Silvio V. F.Levy Michael S.Paterson William P.Thurston Word processing in groups Jones and Bartlett Publishers 1992
Boston, MA
0-86720-244-0 1161694 (93i:20036) 20F10 (03D40 20-02 68Q70) Richard M. Thomas xii+330 V.Felsch D. L.Johnson J.Neubüser S. V.Tsaranov The structure of certain <C>C</C>oxeter groups Groups '93 Galway/St Andrews, Vol. 1 (Galway, 1993) Cambridge Univ. Press 1995 211 London Math. Soc. Lecture Note Ser. 177–190
Cambridge
1342790 (96d:20028) 20F05 (20F55) Daan Krammer VolkmarFelsch GünterSandlöbes An interactive program for computing subgroups Computational group theory (Durham, 1982) Academic Press 1984 Michael D.Atkinson 137–143
London
Durham1982 0-12-066270-1 groups; subgroup lattice, table of marks; cyclic extensions; program description 760655 (85k:20003) 20-04 (20D10 68Q99) VolkmarFelsch JoachimNeubüser An algorithm for the computation of conjugacy classes and centralizers in <C><M>p</M></C>-groups Symbolic and algebraic computation (EUROSAM '79, Internat. Sympos., Marseille, 1979) Springer 1979 Edward W.Ng 72 Lecture Notes in Comput. Sci. 452–465
Berlin
EUROSAM '79, an International Symposium held in Marseille, June 1979 EUROSAM79 3-540-09519-5 575705 (82d:20003) 20-04 Colin M. Campbell
PaulFong Solvable groups and modular representation theory 1962 103 484–494 0002-9947 0139667 (25 #3098) 20.80 D. E. Littlewood Transactions of the American Mathematical Society
J. S.Frame Recursive computation of tensor power components 1982 10 153–159 0172-1062 667230 (84a:20001) 20-04 (20C15) J. McKay Bayreuther Mathematische Schriften
<C>GAP–Groups, Algorithms, and Programming, Version 4.4.9</C> The GAP Group 2006 GAP groups; *; gap; manual http://www.gap-system.org <C>GAP–Groups, Algorithms, and Programming, Version 4.4</C> The GAP Group 2004 http://www.gap-system.org GAP groups; *; gap; manual
F. A.Garside The braid group and other groups 1969 20 235–254 0248801 (40 #2051) 55.20 L. Neuwirth The Quarterly Journal of Mathematics. Oxford. Second Series
MeinolfGeck On the character values of <C>I</C>wahori-<C>H</C>ecke algebras of exceptional type 1994 68 1 51–76 0024-6115 1243835 (94i:20073) 20F55 (20C15) François Digne PLMTAL Proceedings of the London Mathematical Society. Third Series
M.Geck Beiträge zur <C>D</C>arstellungstheorie von <C>I</C>wahori-<C>H</C>ecke <C>A</C>lgebren Verlag der Augustinus Buchhandlung, Aachen 1995 11 Aachener Beiträge zur Mathematik
MeinolfGeck SungsoonKim Bases for the <C>B</C>ruhat-<C>C</C>hevalley order on all finite <C>C</C>oxeter groups 1997 197 1 278–310 0021-8693 1480786 (98k:20066) 20F55 (06A07) Andrew Mathas JALGA4 Journal of Algebra
MeinolfGeck JeanMichel ``<C>G</C>ood'' elements of finite <C>C</C>oxeter groups and representations of <C>I</C>wahori-<C>H</C>ecke algebras 1997 74 2 275–305 0024-6115 1425324 (97i:20050) 20F55 (20C20) Stephen P. Humphries PLMTAL Proceedings of the London Mathematical Society. Third Series
MeinolfGeck GötzPfeiffer On the irreducible characters of <C>H</C>ecke algebras 1993 102 1 79–94 0001-8708 1250466 (94m:20018) 20C15 Hiroshi Naruse ADMTA4 Advances in Mathematics
MeinolfGeck GerhardHiss FrankLübeck GunterMalle GötzPfeiffer C<C>HEVIE</C>–a system for computing and processing generic character tables 1996 7 3 175–210 Computational methods in Lie theory (Essen, 1994) 0938-1279 1486215 (99m:20017) 20C40 (20C33) AAECEW Applicable Algebra in Engineering, Communication and Computing
Stephan P.Glasby Computational Approaches to the Theory of Finite Soluble Groups Department of Pure Mathematics, University of Sydney 1987 Phd thesis
Sydney, Australia
S. P.Glasby Michael C.Slattery Computing intersections and normalizers in soluble groups 1990 9 5-6 637–651 Computational group theory, Part 1 0747-7171 1075428 (91j:20044) 20D10 Patrizia Longobardi Journal of Symbolic Computation
Ronald L.Graham Donald E.Knuth OrenPatashnik Concrete mathematics Addison-Wesley Publishing Company Advanced Book Program 1989
Reading, MA
A foundation for computer science 0-201-14236-8 1001562 (91f:00001) 00A05 (00-01 05-01 68-01 68Rxx) Volker Strehl xiv+625
TomHalverson ArunRam Murnaghan-<C>N</C>akayama rules for characters of <C>I</C>wahori-<C>H</C>ecke algebras of classical type 1996 348 10 3967–3995 0002-9947 1322951 (96m:20011) 20C15 François Digne TAMTAM Transactions of the American Mathematical Society
TheoHahn International tables for crystallography. <C>V</C>ol. <C>A</C> Published for International Union of Crystallography, Chester 1983 Space-group symmetry 90-277-1445-2 817988 (87i:82092) 82A60 (00A69 20C35 20H15 82-02) Vojtěch Kopský xv+854 TheoHahn International Tables for Crystallography, <C>V</C>ol. <C>A</C> Kluwer, Dordrecht 1995 4th Space-group symmetry International Tables for Crystallography, {V}ol. {A} MarshallHall Jr. The theory of groups The Macmillan Co. 1959
New York, N.Y.
0103215 (21 #1996) 20.00 R. H. Bruck xiii+434 MarshallHall Jr. James K.Senior The groups of order <C><M>2^{n} (n \leq 6)</M></C> The Macmillan Co. 1964
New York
0168631 (29 #5889) 20.00 Michael Rosen 225
PhilipHall The <C>E</C>ulerian functions of a group Quarterly J. Of Mathematics 1936 os-7 1 134–151
WilhelmHanrath Irreduzible <C>D</C>arstellungen von <C>R</C>aumgruppen Rheinisch Westfälische Technische Hochschule 1988 Dissertation
Aachen, Germany
 GeorgeHavas Symbolic and Algebraic Calculation Basser Department of Computer Science, University of Sydney 1969 Basser Computing Dept., Technical Report 89
Sydney, Australia
finitely presented groups; simplification; Tietze transformations GeorgeHavas A <C>R</C>eidemeister-<C>S</C>chreier program Proceedings of the Second International Conference on the Theory of Groups (Australian Nat. Univ., Canberra, 1973) 1974 Michael F.Newman 372 Lecture Notes in Math. 347–356. Lecture Notes in Math., Vol. 372
Berlin
Springer Held at the Australian National University, Canberra, August 13–24, 1973, With an introduction by B. H. Neumann, Lecture Notes in Mathematics, Vol. 372 Canberra73 finitely presented groups; subgroup presentation; Reidemeister Schreier (rs); program description 0376827 (51 #13002) 20-04 F. Levin MR 49#9054, Zbl 282.00012 GeorgeHavas Coset enumeration strategies Proceedings of the International Symposium on Symbolic and Algebraic Computation (ISSAC'91), Bonn 1991 1991 191–199 ACM Press ISSAC91
GeorgeHavas Bohdan S.Majewski Integer matrix diagonalization 1997 24 3-4 399–408 Computational algebra and number theory (London, 1993) 0747-7171 1484488 (98g:65039) 65F30 (65Y20) Journal of Symbolic Computation
GeorgeHavas M. F.Newman Application of computers to questions like those of <C>B</C>urnside Burnside groups (Proc. Workshop, Univ. Bielefeld, Bielefeld, 1977) Springer 1980 Jens L.Mennicke 806 Lecture Notes in Math. 211–230
Berlin
Bielefeld77 3-540-10006-7 finitely presentend groups; Burnside groups; nilpotent quotient 586047 (82d:20002) 20-04 (20F50) Colin M. Campbell MR 81j:20002, Zbl 424.00008 GeorgeHavas P. E.Kenne J. S.Richardson E. F.Robertson A <C>T</C>ietze transformation program Computational group theory (Durham, 1982) Academic Press 1984 Michael D.Atkinson 69–73
London
Durham1982 0-12-066270-1 finitely presented groups; simplification; Tietze 760651 (86b:20039) 20F05 (20-04)
T.Hawkes I. M.Isaacs M.Özaydin On the <C>M</C>öbius function of a finite group 1989 19 4 1003–1034 0035-7596 1039540 (90k:20046) 20D30 David Gluck RMJMAE The Rocky Mountain Journal of Mathematics
GerhardHiss ChristophJansen KlausLux Richard A.Parker Computational <C>M</C>odular <C>C</C>haracter <C>T</C>heory http://www.math.rwth-aachen.de/~MOC/CoMoChaT/ Derek F.Holt The <C>W</C>arwick automatic groups software Geometric and computational perspectives on infinite groups (Minneapolis, MN and New Brunswick, NJ, 1994) Amer. Math. Soc. 1996 25 DIMACS Ser. Discrete Math. Theoret. Comput. Sci. 69–82
Providence, RI
1364180 (96m:20052) 20F10 (03D40 20-04 68Q40) Sarah E. Rees
Derek F.Holt C. R.Leedham-Green E. A.O'Brien SarahRees Computing matrix group decompositions with respect to a normal subgroup 1996 184 3 818–838 0021-8693 1407872 (97m:20021) 20C40 (20B40) Wolfgang Lempken JALGA4 Journal of Algebra
Derek F.Holt C. R.Leedham-Green E. A.O'Brien SarahRees Testing matrix groups for primitivity 1996 184 3 795–817 0021-8693 1407871 (97m:20020) 20C40 (20B40) Wolfgang Lempken JALGA4 Journal of Algebra
Derek F.Holt W.Plesken Perfect groups The Clarendon Press Oxford University Press 1989 Oxford Mathematical Monographs
New York
With an appendix by W. Hanrath, Oxford Science Publications 0-19-853559-7 1025760 (91c:20029) 20D05 (20F05) M. Ram Murty xii+364
Derek F.Holt SarahRees Testing modules for irreducibility 1994 57 1 1–16 0263-6115 1279282 (95e:20023) 20C40 Herbert Pahlings JAMADS Australian Mathematical Society. Journal. Series A. Pure Mathematics and Statistics
GeorgeHavas ColinRamsay Experiments in coset enumeration Groups and computation, III (Columbus, OH, 1999) de Gruyter 2001 William M.Kantor ÁkosSeress 8 Ohio State Univ. Math. Res. Inst. Publ. 183–192
Berlin
DIMACS3 3-11-016721-2 1829479 (2002e:20064) 20F05 (20-04) Sarah E. Rees
GeorgeHavas ColinRamsay Proving a group trivial made easy: a case study in coset enumeration 2000 62 1 105–118 0004-9727 1775892 (2002j:20061) 20F05 E. F. Robertson ALNBAB Bulletin of the Australian Mathematical Society
J. M.Howie An introduction to semigroup theory Academic Press [Harcourt Brace Jovanovich Publishers] 1976
London
L.M.S. Monographs, No. 7 0466355 (57 #6235) 20MXX T. E. Hall x+272 AlexanderHulpke <C>Zur Berechnung von Charaktertafeln</C> Lehrstuhl D für Mathematik, Rheinisch Westfälische Technische Hochschule 1993 Diplomarbeit AlexanderHulpke Konstruktion transitiver <C>P</C>ermutationsgruppen Rheinisch Westfälische Technische Hochschule 1996 Dissertation
Aachen, Germany
Verlag der Augustinus Buchhandlung, Aachen AlexanderHulpke Computing normal subgroups Proceedings of the 1998 International Symposium on Symbolic and Algebraic Computation (Rostock) 1998 194–198 (electronic)
New York
ACM Chairman: Volker Weispfenning and Barry Trager ISSAC98 1-58113-002-3 Rostock, Germany 1805183 20-04 (68W30) ACM Order No.: 505980, ACM member price $25
AlexanderHulpke Computing subgroups invariant under a set of automorphisms 1999 27 4 415–427 0747-7171 1681348 (2000a:20001) 20-04 (20D30) D. F. Holt Journal of Symbolic Computation
AlexanderHulpke Conjugacy classes in finite permutation groups via homomorphic images 2000 69 232 1633–1651 0025-5718 1659847 (2001a:20006) 20B40 Alberto Delgado MCMPAF Mathematics of Computation
AlexanderHulpke Representing subgroups of finitely presented groups by quotient subgroups 2001 10 3 369–381 1058-6458 1917425 (2003i:20049) 20F05 (20C34 20C40 68W30) Dmitrii V. Pasechnik Experimental Mathematics
AlexanderHulpke Constructing transitive permutation groups 2005 39 1 1–30 0747-7171 2168238 (2006e:20004) 20B10 (20B35) J. Quistorff Journal of Symbolic Computation
James E.Humphreys Introduction to <C>L</C>ie algebras and representation theory Springer-Verlag 1972
New York
Graduate Texts in Mathematics, Vol. 9 0323842 (48 #2197) 17BXX F. W. Lemire xii+169 James E.Humphreys Introduction to <C>L</C>ie algebras and representation theory Springer-Verlag 1978 9 Graduate Texts in Mathematics
New York
Second printing, revised 0-387-90053-5 499562 (81b:17007) 17Bxx I. P. Shestakov xii+171 James E.Humphreys Reflection groups and <C>C</C>oxeter groups Cambridge University Press 1990 29 Cambridge Studies in Advanced Mathematics
Cambridge
0-521-37510-X 1066460 (92h:20002) 20-02 (20F32 20F55 20G15 20H15) Louis Solomon xii+204 James E.Humphreys Reflection groups and <C>C</C>oxeter groups Cambridge University Press 1990 29 Cambridge Studies in Advanced Mathematics
Cambridge
0-521-37510-X 1066460 (92h:20002) 20-02 (20F32 20F55 20G15 20H15) Louis Solomon xii+204 B.Huppert Endliche <C>G</C>ruppen. <C>I</C> Springer-Verlag 1967 Die Grundlehren der Mathematischen Wissenschaften, Band 134
Berlin
0224703 (37 #302) 20.25 J. H. Walter xii+793 BertramHuppert NormanBlackburn Finite groups. <C>II</C> Springer-Verlag 1982 242 Grundlehren Math. Wiss.
Berlin
3-540-10632-4 650245 (84i:20001a) 20-02 (20Dxx) xiii+531 BertramHuppert Character theory of finite groups Walter de Gruyter & Co. 1998 25 de Gruyter Expositions in Mathematics
Berlin
3-11-015421-8 1645304 (99j:20011) 20C15 (20C05 20C10) Gerhard Hiss vi+618 I. MartinIsaacs Character theory of finite groups Academic Press [Harcourt Brace Jovanovich Publishers] 1976
New York
Pure and Applied Mathematics, No. 69 0-12-374550-0 0460423 (57 #417) 20-02 Stephen D. Smith xii+303
HiroyukiIshibashi A. G.Earnest Two-element generation of orthogonal groups over finite fields 1994 165 1 164–171 0021-8693 1272584 (95b:20069) 20G40 (20F05) Jia-Chen Ye JALGA4 Journal of Algebra
HiroyukiIshibashi A. G.Earnest Addendum: ``<C>T</C>wo-element generation of orthogonal groups over finite fields'' [<C>J</C>. <C>A</C>lgebra <C><Alt Only="BibTeX,BibTeXhref">\bf </Alt>165</C> (1994), no. 1, 164–171; <C>MR</C>1272584 (95b:20069)] 1996 182 3 805 0021-8693 1398123 (97d:20061) 20G40 (20F05) JALGA4 Journal of Algebra
HiroyukiIshibashi A. G.Earnest Erratum: ``<C>T</C>wo-element generation of orthogonal groups over finite fields'' [<C>J</C>. <C>A</C>lgebra <C><Alt Only="BibTeX,BibTeXhref">\bf </Alt>165</C> (1994), no. 1, 164–171; <C>MR</C>1272584 (95b:20069)] 1994 170 3 1035 0021-8693 1305274 (95h:20062) 20G40 (20F05) JALGA4 Journal of Algebra
ChristophJansen KlausLux RichardParker RobertWilson An atlas of <C>B</C>rauer characters The Clarendon Press Oxford University Press 1995 11 London Mathematical Society Monographs. New Series
New York
Appendix 2 by T. Breuer and S. Norton, Oxford Science Publications 0-19-851481-6 1367961 (96k:20016) 20C20 (20-00 20D06 20D08) J. L. Alperin xviii+327 D. L.Johnson Presentations of groups Cambridge University Press 1997 15 London Mathematical Society Student Texts
Cambridge
Second 0-521-58542-2 1472735 (98e:20001) 20-01 (20F05) xii+216 AnsgarKaup Gitterbasen und <C>C</C>haraktere endlicher <C>G</C>ruppen Lehrstuhl D für Mathematik, Rheinisch Westfälische Technische Hochschule 1992 Diplomarbeit
Aachen, Germany
DavidKazhdan GeorgeLusztig Representations of <C>C</C>oxeter groups and <C>H</C>ecke algebras 1979 53 2 165–184 0020-9910 560412 (81j:20066) 20H15 (17B35 20G05 22E47) Vinay V. Deodhar INVMBH Inventiones Mathematicae
GregorKemper FrankLübeck KayMagaard Matrix generators for the <C>R</C>ee groups <C><M>{}^2G_2(q)</M></C> 2001 29 1 407–413 0092-7872 1842506 (2002e:20025) 20C33 (20D06) COALDM Communications in Algebra
AdalbertKerber Algebraic combinatorics via finite group actions Bibliographisches Institut 1991
Mannheim
3-411-14521-8 1115208 (92k:05130) 05E10 (20C30) A. O. Morris 436
WolfgangKimmerle RichardLyons RobertSandling David N.Teague Composition factors from the group ring and <C>A</C>rtin's theorem on orders of simple groups Proc. London Math. Soc. (3) 1990 60 1 89--122 0024-6115 1023806 (91c:20030) 20D06 (20C05 20D60) P. Fong PLMTAL Proceedings of the London Mathematical Society. Third Series
PeterKleidman MartinLiebeck The subgroup structure of the finite classical groups Cambridge University Press 1990 129 London Mathematical Society Lecture Note Series
Cambridge
0-521-35949-X 1057341 (91g:20001) 20-02 (20D06 20G40) R. W. Carter x+303
A. U.Klimyk Decomposition of the direct product of irreducible representations of semisimple <C>L</C>ie algebras into irreducible representations Ukrain. Mat. Ž. 1966 18 5 19–27 0041-6053 0206169 (34 #5991) 17.30 (22.60) Renzo Cirelli Akademiya Nauk Ukrainskoĭ SSR. Institut Matematiki. Ukrainskiĭ Matematicheskiĭ Zhurnal
A. U.Klimyk Decomposition of a direct product of irreducible representations of a semisimple <C>L</C>ie algebra into irreducible representations American Mathematical Society Translations. Series 2 American Mathematical Society 1968 76 63–73
Providence, R.I.
 Donald E.Knuth The Art of Computer Programming, Volume 2: <C>S</C>eminumerical Algorithms Addison-Wesley 1998 third Donald E.Knuth The art of computer programming. <C>V</C>ol. 2: <C>S</C>eminumerical algorithms Addison-Wesley Publishing Co., Reading, Mass.-London-Don Mills, Ont 1969 0286318 (44 #3531) 68.00 (65.00) M. Muller xi+624 ReinhardLaue Zur <C>K</C>onstruktion und <C>K</C>lassifikation endlicher auflösbarer <C>G</C>ruppen Universität Bayreuth 1982 9 0172-1062 polycyclic groups;;; classification 651224 (84e:20018) 20D10 (20-02) T. O. Hawkes Bayreuther Mathematische Schriften Bayreuth. Math. Schr. PAGES: ii + 304, 1 correction sheet, Earlier version: Habilitationsschrift, RWTH Aachen, 1980 ii+304 MR 84e:20018 (T. O. Hawkes), Zbl 479.20010 (H. Heineken) ReinhardLaue JoachimNeubüser UlrichSchoenwaelder Algorithms for finite soluble groups and the <C>SOGOS</C> system Computational group theory (Durham, 1982) 1984 Michael D.Atkinson 105–135
London
Academic Press Durham1982 0-12-066270-1 polycyclic groups;;; algorithm description 760654 (86h:20023) 20D10 (20-04 20D15 20F05 68Q40) Gerhard Pazderski MR 86h:20023 (Gerhard Pazderski), Zbl 547:20012 (E. Kommissartschik) PhilippeLeChenadec Canonical forms in finitely presented algebras Pitman Publishing Ltd. 1986 Research Notes in Theoretical Computer Science
London
0-273-08721-5 840218 (88b:68117) 68Q50 (03B35 03D03 08B05 20F05 68Q40) Friedrich Otto xii+201
Charles R.Leedham-Green Leonard H.Soicher Collection from the left and other strategies 1990 9 5-6 665–675 Computational group theory, Part 1 0747-7171 1075430 (92b:20021) 20D10 (68Q25) M. Greendlinger Journal of Symbolic Computation
A. K.Lenstra H. W.Lenstra Jr. L.Lovász Factoring polynomials with rational coefficients 1982 261 4 515–534 LLL82 0025-5831 682664 (84a:12002) 12-04 (12A20 68C20 68C25) Daniel Lazard MAANA3 Mathematische Annalen
Jeffrey S.Leon On an algorithm for finding a base and a strong generating set for a group given by generating permutations 1980 35 151 941–974 0025-5718 permutation groups; stabilizer chain, base and strong generating set of; Schreier Sims, Todd Coxeter (tc) 572868 (82i:20004) 20-04 (20F05) Colin M. Campbell MCMPAF Mathematics of Computation MR 82i:20004 (Colin M. Campbell), Zbl 444.20001 (J. Neubüser)
Jeffrey S.Leon Permutation group algorithms based on partitions. <C>I</C>. <C>T</C>heory and algorithms 1991 12 4-5 533–583 Computational group theory, Part 2 0747-7171 1146516 (93c:68043) 68Q40 (20B40) Jean Moulin Ollagnier Journal of Symbolic Computation
SteveLinton Vector Enumeration Programs, version 3 1993 E.Lo A Polycyclic Quotient Algorithm Rutgers University 1996 FrankLübeck Conway polynomials for finite fields http://www.math.rwth-aachen.de:8001/~Frank.Luebeck/data/ConwayPol 2003
Eugene M.Luks FerencRákóczi Charles R. B.Wright Some algorithms for nilpotent permutation groups 1997 23 4 335–354 0747-7171 1445430 (97m:68113) 68Q40 (20B05) Journal of Symbolic Computation
GeorgeLusztig On a theorem of <C>B</C>enson and <C>C</C>urtis 1981 71 2 490–498 0021-8693 630610 (83a:20053) 20G05 (14L30) S. I. Gelʹfand JALGA4 Journal of Algebra
GeorgeLusztig Characters of reductive groups over a finite field Princeton University Press 1984 107 Annals of Mathematics Studies
Princeton, NJ
0-691-08350-9; 0-691-08351-7 742472 (86j:20038) 20G05 (14L20 20C15) Bhama Srinivasan xxi+384 K.Lux H.Pahlings Computational aspects of representation theory of finite groups Representation theory of finite groups and finite-dimensional algebras (Bielefeld, 1991) 1991 G. O.Michler C. M.Ringel 95 Progr. Math. 37–64
Basel
Birkhäuser MR91 3-7643-2604-2 1112157 (92g:20025) 20C40 Wolfgang Knapp
I. G.Macdonald Numbers of conjugacy classes in some finite classical groups 1981 23 1 23–48 0004-9727 615131 (82j:20092) 20G40 Naohisa Shimomura ALNBAB Bulletin of the Australian Mathematical Society
MeenaMahajan V.Vinay Determinant: combinatorics, algorithms, and complexity 1997 Article 5, 26 pp. (electronic) 1073-0486 1484546 (98m:15016) 15A15 (05C50 68Q15 68Q22 68R05) H.-J. Hoehnke Chicago Journal of Theoretical Computer Science
GunterMalle Degrés relatifs des algèbres cyclotomiques associées aux groupes de réflexions complexes de dimension deux Finite reductive groups (Luminy, 1994) 1997 MarcCabanes 141 Progr. Math. 311–332
Boston, MA
Birkhäuser Boston Related structures and representations Luminy94 0-8176-3885-7 1429878 (98h:20019) 20C99 (20F55 20G40) François Digne
LeonardSoicher JohnMcKay Computing <C>G</C>alois groups over the rationals 1985 20 3 273–281 0022-314X 797178 (87a:12002) 12-04 (11R32 11Y40) Hale F. Trotter JNUTA9 Journal of Number Theory
D. H.McLain An algorithm for determining defining relations of a subgroup 1977 18 1 51–56 0017-0895 finitely presented groups; subgroup presentation; modified Todd Coxeter (mtc); algorithm description 0424950 (54 #12908) 20F05 N. S. Mendelsohn Glasgow Mathematical Journal MR 54 # 12908 (N. S. Mendelsohn), Zbl 348.20029 (Summary)
MatthiasMecky JoachimNeubüser Some remarks on the computation of conjugacy classes of soluble groups 1989 40 2 281–292 0004-9727 1012835 (91i:20001) 20-04 (20D10) ALNBAB Bulletin of the Australian Mathematical Society
ThomasMerkwitz <C>Markentafeln endlicher Gruppen</C> Lehrstuhl D für Mathematik, Rheinisch Westfälische Technische Hochschule 1998 Diplomarbeit
Aachen, Germany
 JürgenMnich Untergruppenverbände und auflösbare <C>G</C>ruppen in <C>GAP</C> Lehrstuhl D für Mathematik, Rheinisch Westfälische Technische Hochschule 1992 Diplomarbeit
Aachen, Germany
groups; subgroup lattice, table of marks; cyclic extensions; algorithm description
Peter L.Montgomery Modular multiplication without trial division 1985 44 170 519–521 0025-5718 777282 (86e:11121) 11Y16 MCMPAF Mathematics of Computation
Francis D.Murnaghan The orthogonal and symplectic groups Comm. Dublin Inst. Adv. Studies. Ser. A, no. 1958 13 146 0103933 (21 #2695) 20.00 J. S. Frame
JohnMcKay Kiang ChuenYoung The nonabelian simple groups <C><M>G</M></C>, <C><M>|G| < 10^{6}</M></C>–minimal generating pairs 1979 33 146 812–814 0025-5718 521296 (80d:20018) 20D05 (20F05) W. J. Wong MCMPAF Mathematics of Computation
B. D.McKay <C>nauty</C> user's guide (version 1.5), Technical report TR-CS-90-02 Australian National University
Computer Science Department, ANU
1990 GabrieleNebe Endliche rationale <C>M</C>atrixgruppen vom <C>G</C>rad 24 Rheinisch Westfälische Technische Hochschule 1995 Dissertation
Aachen, Germany
Aachener Beiträge zur Mathematik 12
GabrieleNebe Finite subgroups of <C><M>GL_n(Q)</M></C> for <C><M>25 \leq n \leq 31</M></C> 1996 24 7 2341–2397 0092-7872 1390378 (97e:20066) 20G15 Martin W. Liebeck COALDM Communications in Algebra
JoachimNeubüser Die <C>U</C>ntergruppenverbände der <C>Gruppen</C> der <C>Ordnungen</C> <M>\leq 100</M> mit <C>Ausnahme</C> der <C>Ordnungen</C> 64 und 96 Universität Kiel 1967 Habilitationsschrift
Kiel, Germany
PAGES: 370 JoachimNeubüser An elementary introduction to coset table methods in computational group theory Groups–St Andrews 1981 (St Andrews, 1981) 1982 Colin M.Campbell Edmund F.Robertson 71 London Math. Soc. Lecture Note Ser. 1–45
Cambridge
Cambridge Univ. Press GrpsStAndrews81 0-521-28974-2 finitely presented groups; subgroup presentation, permutation representation, low index subgroups; Todd Coxeter (tc), modified Todd Coxeter (mtc); algorithm description, survey 679153 (84f:20004) 20-04 (20-02) George Havas MR 84f:20004 (George Havas), Zbl 489.20003 (G. Butler) JürgenNeukirch Algebraische <C>Z</C>ahlentheorie Springer, Berlin, Heidelberg and New York 1992 GabrieleNebe WilhelmPlesken Finite rational matrix groups of degree 16 74–144 AMS 1995 556 vol. 116 NPbook95 0065-9266 1265024 (95k:20081) 20H20 (11E57) V. D. Mazurov MAMCAU Memoirs of the American Mathematical Society Mem. Amer. Math. Soc. G.Nebe W.Plesken Finite rational matrix groups AMS 1995 556 Mem. Amer. Math. Soc. vol. 116 0065-9266 1265024 (95k:20081) 20H20 (11E57) V. D. Mazurov MAMCAU Memoirs of the American Mathematical Society Mem. Amer. Math. Soc. viii+144 JoachimNeubüser HerbertPahlings WilhelmPlesken C<C>AS</C>; design and use of a system for the handling of characters of finite groups Computational group theory (Durham, 1982) 1984 Michael D.Atkinson 195–247
London
Academic Press Durham1982 0-12-066270-1 ordinary representations; characters 760658 (86i:20004) 20-04 (20C15 20C30 68Q40) D. Wales MR 86i:20004 (D. Hales), Zbl 546.20001 (G. Butler)
JoachimNeubüser WilhelmPlesken HansWondratschek An emendatory discursion on defining crystal systems 1981 10 77–96 0340-6253 620802 (82i:20059) 20H15 (51F15 82A60) Daniel B. Litvin Proceedings of the Conference on Kristallographische Gruppen (Univ. Bielefeld, Bielefeld, 1979), Part II MATCDV Match Zbl 551.20033 (Author)
M. F.Newman Determination of groups of prime-power order Group theory (Proc. Miniconf., Australian Nat. Univ., Canberra, 1975) 1977 R. A.Bryce J.Cossey Michael F.Newman 573 Lecture Notes in Math. 73–84. Lecture Notes in Math., Vol. 573
Berlin
Springer Lecture Notes in Mathematics, Vol. 573 Canberra75 finitely presented groups, p-groups;; nilpotent quotient; application 0453862 (56 #12115) 20D15 Bruce W. King MR 56 # 12115 (Bruce W. King), Zbl no ref
Michael F.Newman Proving a group infinite 1990 54 3 209–211 0003-889X 1037607 (90j:20068) 20F05 D. L. Johnson ACVMAL Archiv der Mathematik
Michael F.Newman Eamonn A.O'Brien A <C>CAYLEY</C> library for the groups of order dividing <C><M>128</M></C> Group theory (Singapore, 1987) 1989 Kai NahCheng Yu KiangLeong 437–442
Berlin
de Gruyter Singapore87 3-11-011366-X 981861 (90b:20002) 20-04 (20D15) J. McKay FelixNoeske <C>Zur Darstellungstheorie der Schurschen Erweiterungen symmetrischer Gruppen</C> Lehrstuhl D für Mathematik, Rheinisch Westfälische Technische Hochschule 2002 Diplomarbeit
Eamonn A.O'Brien The <C><M>p</M></C>-group generation algorithm 1990 9 5-6 677–698 Computational group theory, Part 1 0747-7171 1075431 (91j:20050) 20D15 È. M. Palʹchik Journal of Symbolic Computation
Eamonn A.O'Brien The groups of order <C><M>256</M></C> 1991 143 1 219–235 0021-8693 1128656 (93e:20029) 20D15 (20-04) JALGA4 Journal of Algebra
Eamonn A.O'Brien Isomorphism testing for <C><M>p</M></C>-groups 1994 17 2 131, 133–147 0747-7171 1283739 (95f:20040b) 20D15 (20D45 20F28) Richard Davitt Journal of Symbolic Computation
Eamonn A.O'Brien Computing automorphism groups of <C><M>p</M></C>-groups Computational algebra and number theory (Sydney, 1992) 1995 WiebBosma Alfvan der Poorten 325 83–90
Dordrecht
Kluwer Acad. Publ. 1344923 (96g:20024) 20D15 (20D45) Wolfgang Lempken
Michael F.Newman Eamonn A.O'Brien Application of computers to questions like those of <C>B</C>urnside. <C>II</C> 1996 6 5 593–605 0218-1967 1419133 (97k:20002) 20-04 (20D15 20F05) Colin M. Campbell International Journal of Algebra and Computation
ThomasOstermann Charaktertafeln von <C>S</C>ylownormalisatoren sporadischer einfacher <C>G</C>ruppen Universität Essen 1986
Essen
872094 (88g:20002) 20-04 (20C20 20D08) M. F. Newman x+187 Universität Essen Fachbereich Mathematik Vorlesungen aus dem Fachbereich Mathematik der Universität GH Essen [Lecture Notes in Mathematics at the University of Essen] 14
HerbertPahlings On the <C>M</C>öbius function of a finite group 1993 60 1 7–14 0003-889X 1193087 (94c:20039) 20D30 David Gluck ACVMAL Archiv der Mathematik
Richard A.Parker The computer calculation of modular characters (the meat-axe) Computational group theory (Durham, 1982) 1984 Michael D.Atkinson 267–274
London
Academic Press Durham1982 0-12-066270-1 760660 (85k:20041) 20C20 (20-04) Leo J. Alex G.Pfeiffer <C>Von Permutationscharakteren und Markentafeln</C> Lehrstuhl D für Mathematik, Rheinisch Westfälische Technische Hochschule 1991 Diplomarbeit
Aachen, Germany
GötzPfeiffer Character tables of <C>W</C>eyl groups in <C>GAP</C> 1994 47 165–222 0172-1062 1285208 (95d:20027) 20C40 (20C15 20D06 20F40) Stephen A. Linton Bayreuther Mathematische Schriften
GötzPfeiffer Young characters on <C>C</C>oxeter basis elements of <C>I</C>wahori-<C>H</C>ecke algebras and a <C>M</C>urnaghan-<C>N</C>akayama formula 1994 168 2 525–535 0021-8693 1292779 (95g:20012) 20C30 (20C15 20F55) Arun Ram JALGA4 Journal of Algebra
GötzPfeiffer Character values of <C>I</C>wahori-<C>H</C>ecke algebras of type <C><M>B</M></C> Finite reductive groups (Luminy, 1994) 1997 MarcCabanes 141 Progr. Math. 333–360
Boston, MA
Birkhäuser Boston Related structures and representations Luminy94 0-8176-3885-7 1429879 (98a:20008) 20C15 (20F55) Robert Bédard
GötzPfeiffer The subgroups of <C><M>M_{24}</M></C>, or how to compute the table of marks of a finite group 1997 6 3 247–270 1058-6458 1481593 (98h:20032) 20D30 (20D08) A. S. Kondratʹev Experimental Mathematics
GünterPilz Near-rings North-Holland Publishing Co. 1983 23 North-Holland Mathematics Studies
Amsterdam
Second The theory and its applications 0-7204-0566-1 721171 (85h:16046) 16A76 (16-02) J. R. Clay xv+470
WilhelmPlesken Finite unimodular groups of prime degree and circulants 1985 97 1 286–312 0021-8693 812182 (87c:20020) 20C10 (20G40) Wolfgang Knapp JALGA4 Journal of Algebra
WilhelmPlesken Solving <C><M>XX^{\rm tr} = A</M></C> over the integers 1995 226/228 331--344 0024-3795 1344572 (96h:15016) 15A24 M. C. Chaki LAAPAW Linear Algebra and its Applications
WilhelmPlesken GabrieleNebe Finite rational matrix groups 1–73 AMS 1995 556 vol. 116 NPbook95 0065-9266 1265024 (95k:20081) 20H20 (11E57) V. D. Mazurov MAMCAU Memoirs of the American Mathematical Society Mem. Amer. Math. Soc.
G.Nebe W.Plesken Finite rational matrix groups 1995 116 556 viii+144 0065-9266 1265024 (95k:20081) 20H20 (11E57) V. D. Mazurov MAMCAU Memoirs of the American Mathematical Society
WilhelmPlesken MichaelPohst On maximal finite irreducible Subgroups of <C>GL(n,Z)</C>. <C>I</C>. The five and seven dimensional cases, <C>II</C>. The six dimensional case 1977 31 536–576 MR 56 # 3137a, 3137b (Wolfgang Knapp), Zbl 359.20006, 359.20007 (authors)
WilhelmPlesken MichaelPohst On maximal finite irreducible subgroups of <C><M>GL(n, Z)</M></C>. <C>I</C>. <C>T</C>he five and seven dimensional cases 1977 31 138 536–551 0025-5718 0444789 (56 #3137a) 20G05 Wolfgang Knapp Mathematics of Computation
WilhelmPlesken MichaelPohst On maximal finite irreducible subgroups of <C><M>GL(n, Z)</M></C>. <C>II</C>. <C>T</C>he six dimensional case 1977 31 138 552–573 0025-5718 0444790 (56 #3137b) 20G05 Wolfgang Knapp Mathematics of Computation
WilhelmPlesken MichaelPohst On maximal finite irreducible Subgroups of <C>GL(n,Z)</C>. <C>III</C>. The nine dimensional case, <C>IV</C>. Remarks on even dimensions with application to n = 8, <C>V</C>. The eight dimensional case and a complete description of dimensions less than ten 1980 34 245–301 MR 81b:20012a, 81b:20012b, 81b:20012c (Wolfgang Knapp), Zbl 431.20039, 431.20040, 431.20041 (authors)
WilhelmPlesken MichaelPohst On maximal finite irreducible subgroups of <C><M>GL(n, Z)</M></C>. <C>III</C>. <C>T</C>he nine-dimensional case 1980 34 149 245–258 0025-5718 551303 (81b:20012a) 20C10 Wolfgang Knapp MCMPAF Mathematics of Computation
WilhelmPlesken MichaelPohst On maximal finite irreducible subgroups of <C><M>GL(n, Z)</M></C>. <C>IV</C>. <C>R</C>emarks on even dimensions with applications to <C><M>n = 8</M></C> 1980 34 149 259–275 0025-5718 551304 (81b:20012b) 20C10 Wolfgang Knapp MCMPAF Mathematics of Computation
WilhelmPlesken MichaelPohst On maximal finite irreducible subgroups of <C><M>GL(n, Z)</M></C>. <C>V</C>. <C>T</C>he eight-dimensional case and a complete description of dimensions less than ten 1980 34 149 277–301, loose microfiche suppl 0025-5718 551305 (81b:20012c) 20C10 Wolfgang Knapp MCMPAF Mathematics of Computation
M.Pohst A modification of the <C>LLL</C> reduction algorithm 1987 4 1 123–127 0747-7171 908420 (89c:11183) 11Y16 (11H06 11R27 11Y05 68Q20) Hans G. Kopetzky Journal of Symbolic Computation
ArunRam A <C>F</C>robenius formula for the characters of the <C>H</C>ecke algebras 1991 106 3 461–488 0020-9910 1134480 (93c:20029) 20C30 (05E05 16W30 17B37) Jie Du INVMBH Inventiones Mathematicae
ColinRamsay <C>ACE</C> for <C>Amateurs</C> Centre for Discrete Mathematics and Computing, The University of Queensland 1999 Draft C.Ramsay <C>ACE</C> User Manual
Department of Computer Science & Electrical Engineering and Department of Mathematics, The University of Queensland, QLD 4072, Australia
1999 Draft Centre for Discrete Mathematics and Computing MichaelRinge The <C>C</C> <C>M</C>eat<C>A</C>xe, Release 1.5 Lehrstuhl D für Mathematik, Rheinisch Westfälische Technische Hochschule
Aachen, Germany
1993 MichaelRinge The <C>C</C> <C>M</C>eat<C>A</C>xe, Release 2.3 Lehrstuhl D für Mathematik, Rheinisch Westfälische Technische Hochschule
Aachen, Germany
1998
Edmund F.Robertson Tietze transformations with weighted substring search 1988 6 1 59–64 0747-7171 finitely presented groups; simplification; Tietze transformations 961370 (89h:68076) 68Q40 (20F05) Journal of Symbolic Computation
Colva M.Roney-Dougal William R.Unger The affine primitive permutation groups of degree less than 1000 2003 35 4 421–439 0747-7171 1976576 (2004e:20002) 20B15 Xianhua Li Journal of Symbolic Computation
Colva M.Roney-Dougal The primitive permutation groups of degree less than 2500 2005 292 1 154–183 0021-8693 2166801 (2006e:20005) 20B15 Michael Giudici JALGA4 Journal of Algebra
Gordon F.Royle The transitive groups of degree twelve 1987 4 2 255–268 0747-7171 922391 (89b:20010) 20B05 Martin W. Liebeck Journal of Symbolic Computation
L. J.Rylands D. E.Taylor Matrix generators for the orthogonal groups 1998 25 3 351–360 0747-7171 1615330 (99d:20078) 20G40 A. G. Earnest Journal of Symbolic Computation
L. L.Scott Modular permutation representations 1973 175 101–121 0002-9947 0310051 (46 #9154) 20C20 H. K. Farahat Transactions of the American Mathematical Society
Gerhard J. A.Schneider Dixon's character table algorithm revisited 1990 9 5-6 601–606 Computational group theory, Part 1 0747-7171 1075426 (91j:20036) 20C40 (20-04 20C15 68Q40) Jamshid Moori Journal of Symbolic Computation
MichaelScherner Erweiterung einer <C>A</C>rithmetik von <C>K</C>reisteilungskörpern auf deren <C>T</C>eilkörper und deren <C>I</C>mplementation in <C>GAP</C> Lehrstuhl D für Mathematik, Rheinisch Westfälische Technische Hochschule 1992 Diplomarbeit
Aachen, Germany
 UteSchiffer Cliffordmatrizen Lehrstuhl D für Mathematik, Rheinisch Westfälische Technische Hochschule 1994 Diplomarbeit
Aachen, Germany
ÁkosSeress Nearly linear time algorithms for permutation groups: an interplay between theory and practice 1998 52 1-3 183–207 Algebra and combinatorics: interactions and applications (Königstein, 1994) 0167-8019 1649697 (2000e:20008) 20B40 (20-04 68W30) Miguel Á. Borges-Trenard AAMADV Acta Applicandae Mathematicae. An International Survey Journal on Applying Mathematics and Mathematical Applications
G. C.Shephard J. A.Todd Finite unitary reflection groups Canadian J. Math. 1954 6 274–304 0059914 (15,600b) 20.0X H. S. M. Coxeter
M. W.Short The primitive soluble permutation groups of degree less than <C><M>256</M></C> Springer-Verlag 1992 1519 Lecture Notes in Mathematics
Berlin
3-540-55501-3 1176516 (93g:20006) 20B15 (20B35 20B40 20F16) A. S. Kondratʹev x+145 Charles C.Sims Computational methods in the study of permutation groups Computational Problems in Abstract Algebra (Proc. Conf., Oxford, 1967) 1970 JohnLeech 29 Proceedings of a Conference held at Oxford under the auspices of the Science Research Council, Atlas Computer Laboratory 169–183
Oxford
Pergamon Oxford67 permutation groups; primitive groups, classification of, stabilizer chain; Schreier Sims 0257203 (41 #1856) 20.20 (65.00) H. Kimura RUSSIAN translation in: Computations in algebra and number theory (Russian), edited by B. B. Venkov and D. K. Faddeev, pp. 129–147, Matematika, Novoie v Zarubeznoi Naukie, vol. 2, Izdat. MIR, Moscow, 1976 MR 41 # 1856 (H. Kimura), Zbl 215, 100 (J. McKay), CR 11 # 19,829 (G. N. Raney)
Charles C.Sims Computing the order of a solvable permutation group 1990 9 5-6 699–705 Computational group theory, Part 1 0747-7171 1075432 (91m:20011) 20B40 Gerhard Hiss Journal of Symbolic Computation
Charles C.Sims Computation with finitely presented groups Cambridge University Press 1994 48 Encyclopedia of Mathematics and its Applications
Cambridge
0-521-43213-8 1267733 (95f:20053) 20F05 (20-02 68Q40 68Q42) Friedrich Otto xiii+604 Charles C.Sims Computing with subgroups of automorphism groups of finite groups Proceedings of the 1997 International Symposium on Symbolic and Algebraic Computation (Kihei, HI) 1997 WolfgangKüchlin 400–403 (electronic)
New York
The Association for Computing Machinery ACM Held in Kihei, HI, July 21–23, 1997 ACM ISSAC97 1810006 68W30 (20D45) <C>SOGOS</C> - A Program System for Handling Subgroups of Finite Soluble Groups, version 5.0, User's reference manual Lehrstuhl D für Mathematik, Rheinisch Westfälische Technische Hochschule
Aachen, Germany
1989 groups, finitely presented groups, polycyclic groups, nilpotent groups, p-groups; SOGOS, pc-presentation, ag-presentation, collection, elements, classes of conjugate elements, centralizer, normalizer, normal closure, intersection, sylow subgroups, derived subgroup, series, central series, p-central series, subgroup lattice, table of marks, complements, factor groups; nilpotent quotient (nq); manual Leonard H.Soicher G<C>RAPE</C>: a system for computing with graphs and groups Groups and computation (New Brunswick, NJ, 1991) 1993 LarryFinkelstein William M.Kantor 11 DIMACS Ser. Discrete Math. Theoret. Comput. Sci. 287–291
Providence, RI
Amer. Math. Soc. DIMACS 0-8218-6599-4 1235810 05C85 (20B40)
BerndSouvignier Irreducible finite integral matrix groups of degree <C><M>8</M></C> and <C><M>10</M></C> 1994 63 207 335–350 With microfiche supplement 0025-5718 1213836 (94i:20091) 20H15 (11E12 20C10 20C40) Alexander W. Mason MCMPAF Mathematics of Computation
<C>SPAS</C> - <C>S</C>ubgroup <C>P</C>resentation <C>A</C>lgorithms <C>S</C>ystem, version 2.5, User's reference manual Lehrstuhl D für Mathematik, Rheinisch Westfälische Technische Hochschule
Aachen, Germany
1989 SPAS finitely presented groups; SPAS, subgroup presentation, simplification, low index subgroups; Todd Coxeter (tc), modified Todd Coxeter (mtc), Reidemeister Schreier (rs), reduced Reidemeister Schreier (rrs), Tietze transformations, tree decoding; manual T. A.Springer Linear algebraic groups Birkhäuser Boston 1981 9 Progress in Mathematics
Mass.
3-7643-3029-5 632835 (84i:20002) 20-02 (20Gxx) x+304
John R.Stembridge On the eigenvalues of representations of reflection groups and wreath products 1989 140 2 353–396 0030-8730 1023791 (91a:20022) 20C30 (20C15) A. Kerber PJMAAI Pacific Journal of Mathematics
D. E.Taylor Pairs of Generators for Matrix Groups. <C>I</C> The Cayley Bulletin 1987 3
HeikoTheißen <C>Methoden zur Bestimmung der rationalen Konjugiertheit in endlichen Gruppen</C> Lehrstuhl D für Mathematik, Rheinisch Westfälische Technische Hochschule 1993 Diplomarbeit
Aachen, Germany
 HeikoTheißen <C>Eine Methode zur Normalisatorberechnung in Permutationsgruppen mit Anwendungen in der Konstruktion primitiver Gruppen</C> Rheinisch Westfälische Technische Hochschule 1997 Dissertation
Aachen, Germany
 PeterThiemann <C>SOGOS</C> <C>III</C> - <C>C</C>haraktere und <C>E</C>ffizienzuntersuchung Lehrstuhl D für Mathematik, Rheinisch Westfälische Technische Hochschule 1987 Diplomarbeit
Aachen, Germany
 Michael R.Vaughan-Lee An aspect of the nilpotent quotient algorithm Computational group theory (Durham, 1982) 1984 Michael D.Atkinson 75–83
London
Academic Press Durham1982 0-12-066270-1 760652 (86b:20040) 20F05 (20-04 20D15 68Q40) M. F. Newman
Michael R.Vaughan-Lee Collection from the left 1990 9 5-6 725–733 Computational group theory, Part 1 0747-7171 1075434 (92c:20065) 20F12 (20-04 20D15 20F18) M. Greendlinger Journal of Symbolic Computation Academic Press
MichaelVaughan-Lee The restricted <C>B</C>urnside problem The Clarendon Press Oxford University Press 1990 5 London Mathematical Society Monographs. New Series
New York
, Oxford Science Publications 0-19-853573-2 1057610 (92c:20001) 20-02 (20F12 20F40 20F45 20F50) Norman Blackburn xiv+209
Robert W.van der Waall On symplectic primitive modules and monomial groups Nederl. Akad. Wetensch. Proc. Ser. A 79, Indag. Math. 1976 38 4 362–375 0424931 (54 #12889) 20D10 T. R. Berger
StanWagon Editor's corner: the <C>E</C>uclidean algorithm strikes again 1990 97 2 125–129 0002-9890 1041889 (91b:11039) 11E25 (11Y50) K. S. Williams AMMYAE The American Mathematical Monthly
HelmutWielandt Permutation groups through invariant relations and invariant functions Department of Mathematics, The Ohio State University 1969 Lecture Notes Robert A.Wilson PeterWalsh JonathanTripp IbrahimSuleiman Richard A.Parker Simon P.Norton SimonNickerson SteveLinton JohnBray RachelAbbott <C>ATLAS of Finite Group Representations</C> http://brauer.maths.qmul.ac.uk/Atlas/ ATLAS
John N.Bray Ibrahim A. I.Suleiman Peter G.Walsh Robert A.Wilson Generating maximal subgroups of sporadic simple groups 2001 29 3 1325–1337 0092-7872 1842416 (2002e:20032) 20D08 Hiroyoshi Yamaki COALDM Communications in Algebra
Robert A.Wilson Standard generators for sporadic simple groups 1996 184 2 505–515 0021-8693 1409225 (98e:20025) 20D08 JALGA4 Journal of Algebra
HansWondratschek Introduction to space-group symmetry International Tables for Crystallography, Vol. A Kluwer, Dordrecht 1995 TheoHahn 711–735 4th Space-group symmetry Hah95 MartinWursthorn <C>SISYPHOS</C> Computing in modular group algebras, Version 0.5 Math. Inst. B, 3. Lehrstuhl
Universität Stuttgart
1993
D.Zagier A one-sentence proof that every prime <C><M>p \equiv 1 \pmod 4</M></C> is a sum of two squares 1990 97 2 144 0002-9890 1041893 (91b:11040) 11E25 K. S. Williams AMMYAE The American Mathematical Monthly
MatthiasZumbroich <C>Grundlagen</C> einer <C>Arithmetik</C> in <C>Kreisteilungskörpern</C> und ihre <C>Implementation</C> in <C>CAS</C> Lehrstuhl D für Mathematik, Rheinisch Westfälische Technische Hochschule 1989 Diplomarbeit
Aachen, Germany
 JohnLeech Computational problems in abstract algebra 1970 29 Proceedings of a Conference held at Oxford under the auspices of the Science Research Council, Atlas Computer Laboratory
Oxford
Pergamon Press 0252149 (40 #5374) 00.04 (10.00) Computational Problems in Abstract Algebra, Proc. Conf. Oxford, 1967 x+402 MR 40#5374, Zbl 186.299 Michael F.Newman Proceedings of the <C>S</C>econd <C>I</C>nternational <C>C</C>onference on the <C>T</C>heory of <C>G</C>roups 1974 372 Lecture Notes in Math.
Berlin
Springer-Verlag Held at the Australian National University, Canberra, August 13–24, 1973, With an introduction by B. H. Neumann, Lecture Notes in Mathematics, Vol. 372 0344315 (49 #9054) 20-06 Proceedings of the Second International Conference on the Theory of Groups, Canberra, 1973 vii+740 MR 49#9054, Zbl 282.00012 R. A.Bryce J.Cossey Michael F.Newman Group theory 1977 573 Lecture Notes in Math.
Berlin
Springer-Verlag Lecture Notes in Mathematics, Vol. 573 0430032 (55 #3040) 20-06 Group theory, Proc. Miniconf., Austral. Nat. Univ., Canberra, 1975 v+146 MR 55#3040, Zbl 342.00008 Jens L.Mennicke Burnside groups 1980 806 Lecture Notes in Mathematics
Berlin
Springer 3-540-10006-7 586041 (81j:20002) 20-06 Proceedings of a Workshop held at the University of Bielefeld, Bielefeld, June–July 1977 ii+274 MR 81j:20002, Zbl 424.00008 Edward W.Ng Symbolic and algebraic computation 1979 72 Lecture Notes in Computer Science
Berlin
Springer-Verlag EUROSAM '79, an International Symposium held in Marseille, June 1979 3-540-09519-5 575677 (81d:68005) 68-06 (68C20) xv+557 Michael D.Atkinson Computational group theory 1984
London
Academic Press Inc. [Harcourt Brace Jovanovich Publishers] 0-12-066270-1 760641 (85g:20001) 20-06 (68-06) Proceedings of the London Mathematical Society symposium held in Durham, July 30–August 9, 1982 xii+375 Colin M.Campbell Edmund F.Robertson Groups–<C>S</C>t. <C>A</C>ndrews 1981 1982 71 London Mathematical Society Lecture Note Series
Cambridge
Cambridge University Press 0-521-28974-2 679152 (83j:20005) 20-06 Proceedings of the International Conference on Groups held at the Mathematical Institute, University of St Andrews, St. Andrews, July 25–August 8, 1981 viii+360 Kai NahCheng Yu KiangLeong Group theory 1989
Berlin
Walter de Gruyter & Co. 3-11-011366-X 981831 (89j:20001) 20-06 Proceedings of the Singapore Group Theory Conference held at the National University of Singapore, Singapore, June 8–19, 1987 xviii + 586 G. O.Michler C. M.Ringel Representation theory of finite groups and finite-dimensional algebras 1991 95 Progress in Mathematics
Basel
Birkhäuser Verlag 3-7643-2604-2 1112154 (91m:20005) 20-06 (00B25 16-06 20Cxx) Proceedings of the conference held at the University of Bielefeld, Bielefeld, May 15–17, 1991 x+520 Proceedings of the 1991 International Symposium on Symbolic and Algebraic Computation (ISSAC'91), Bonn 1991 1991 ACM Press Proceedings of the International Symposium on Symbolic and Algebraic Computation (ISSAC'91), Bonn 1991 WolfgangKüchlin Proceedings of the 1997 <C>I</C>nternational <C>S</C>ymposium on <C>S</C>ymbolic and <C>A</C>lgebraic <C>C</C>omputation 1997
New York
The Association for Computing Machinery Association for Computing Machinery (ACM) Held in Kihei, HI, July 21–23, 1997 ACM 1809584 (2001i:68010) 68-06 (65-06 68W30) electronic OliverGloor Proceedings of the 1998 <C>I</C>nternational <C>S</C>ymposium on <C>S</C>ymbolic and <C>A</C>lgebraic <C>C</C>omputation 1998
New York
The Association for Computing Machinery Association for Computing Machinery (ACM) Held in Rostock, August 13–15, 1998 ACM 1805195 (2001m:68004) 68-06 (00B25 68W30) front matter+321 pp. (electronic) LarryFinkelstein William M.Kantor Groups and computation 1993 DIMACS Series in Discrete Mathematics and Theoretical Computer Science, 11
Providence, RI
American Mathematical Society 0-8218-6599-4 1235790 (94c:20003) 20-06 (20B40) Proceedings of the DIMACS Workshop held at Rutgers University, New Brunswick, New Jersey, October 7–10, 1991 xx+313 LarryFinkelstein William M.Kantor Groups and computation. <C>II</C> 1997 DIMACS Series in Discrete Mathematics and Theoretical Computer Science, 28
Providence, RI
American Mathematical Society 0-8218-0516-9 1444126 (97m:20003) 20-06 (68-06) Proceedings of the 2nd DIMACS Workshop held at Rutgers University, New Brunswick, NJ, June 7–10, 1995 xviii+382 William M.Kantor ÁkosSeress Groups and computation. <C>III</C> 2001 Ohio State University Mathematical Research Institute Publications, 8
Berlin
Walter de Gruyter & Co. 3-11-016721-2 1829467 (2002d:20003) 20-06 Proceedings of the 3rd International Conference held at The Ohio State University, Columbus, OH, June 15–19, 1999 viii+368 GilbertBaumslag DavidEpstein RobertGilman HamishShort CharlesSims Geometric and computational perspectives on infinite groups 1996 DIMACS Series in Discrete Mathematics and Theoretical Computer Science, 25
Providence, RI
American Mathematical Society 0-8218-0449-9 1364175 (96g:20055) 20F32 (20-06) Proceedings of the Joint DIMACS/Geometry Center Workshop held at the University of Minnesota, Minneapolis, Minnesota, January 3–14, 1994 and Rutgers University, New Brunswick, New Jersey, March 17–20, 1994 xvi+212 Colin M.Campbell Thaddeus C.Hurley Edmund F.Robertson Sean J.Tobin James J.Ward Groups '93 <C>G</C>alway/<C>S</C>t. <C>A</C>ndrews. <C>V</C>ol. 1 1995 211 London Mathematical Society Lecture Note Series
Cambridge
Cambridge University Press 0-521-47749-2 1342775 (96b:20001a) 20-06 Proceedings of the International Conference held at University College, Galway, August 1–14, 1993 xii+304 Colin M.Campbell Thaddeus C.Hurley Edmund F.Robertson Sean J.Tobin James J.Ward Groups '93 <C>G</C>alway/<C>S</C>t. <C>A</C>ndrews. <C>V</C>ol. 2 1995 212 London Mathematical Society Lecture Note Series
Cambridge
Cambridge University Press 0-521-47750-6 1337278 (96b:20001b) 20-06 Proceedings of the International Conference held at University College, Galway, August 1–14, 1993 i–xii and 305–609 MarcCabanes Finite reductive groups 1997 141 Progress in Mathematics
Boston, MA
Birkhäuser Boston Inc. Related structures and representations 0-8176-3885-7 1429866 (97i:20001) 20-06 (20G40) Proceedings of the International Conference held in Luminy, October 3–7, 1994 xii+452 ISSAC '98: Proceedings of the 1998 international symposium on Symbolic and algebraic computation 1998
New York, NY, USA
ACM ACM Press Chairman: Volker Weispfenning and Barry Trager 1-58113-002-3 Rostock, Germany ISSAC '98: Proceedings of the 1998 international symposium on Symbolic and algebraic computation ACM Order No.: 505980, ACM member price $25
J.Schur On the representation of the symmetric and alternating groups by fractional linear substitutions Internat. J. Theoret. Phys. 2001 40 1 413–458 Translated from the German [J. Reine Angew. Math. 139 (1911), 155–250] by Marc-Felix Otto 0020-7748 1820589 (2003a:20016) 20C25 (05E05 20C30) Tadeusz Józefiak http://dx.doi.org/10.1023/A:1003772419522 IJTPBM 10.1023/A:1003772419522 International Journal of Theoretical Physics
J.Schur Über die Darstellung der symmetrischen und der alternierenden Gruppe durch gebrochene lineare Substitutionen Journal für die reine und angewandte Mathematik 1911 139 155–250 http://www.digizeitschriften.de/resolveppn/GDZPPN002167298 42.0154.02
LukasMaas On a construction of the basic spin representations of symmetric groups Communications in Algebra 2010 38 4545–4552 http://dx.doi.org/10.1080/00927872.2010.490541 http://arxiv.org/abs/0911.3794 10.1080/00927872.2010.490541
JohnBrillhart D.H.Lehmer J.L.Selfridge New primality criteria and factorizations of <M>2^m \pm 1</M> Mathematics of Computation 1975 29 620–647 http://dx.doi.org/10.2307/2005583 10.2307/2005583
gap-4r6p5/doc/versiondata0000644000175000017500000000037312172557302014147 0ustar billbill gap-4r6p5/doc/test/0000755000175000017500000000000012174560027012661 5ustar billbillgap-4r6p5/doc/test/mktestx.sh0000755000175000017500000000131712172557252014725 0ustar billbill#!/bin/sh ############################################################################# ## ## The script to test all *.tst files in the current directory ## TESTGAP="../../../bin/gap.sh -L ../wsp.g -b -m 100m -o 500m -A -N -x 80 -r -T" ls *.tst > list.files ed - list.files << \% 1,$s/^.*\/// 1,$s/\..*$// w % if test -e diffs; then rm diffs; fi for i in `cat list.files` do echo $i echo $i >> diffs echo 'r:=ReadTest( "'$i'" );' | $TESTGAP >> diffs echo '============================================================' >> diffs echo '============================================================' done echo '' echo '############################################################' rm list.filesgap-4r6p5/doc/ref/0000755000175000017500000000000012174560027012456 5ustar billbillgap-4r6p5/doc/ref/grpfp.xml0000644000175000017500000005554612172557252014341 0ustar billbill Finitely Presented Groups A finitely presented group (in short: FpGroup) is a group generated by a finite set of abstract generators subject to a finite set of relations that these generators satisfy. Every finite group can be represented as a finitely presented group, though in almost all cases it is computationally much more efficient to work in another representation (even the regular permutation representation).

Finitely presented groups are obtained by factoring a free group by a set of relators. Their elements know about this presentation and compare accordingly.

So to create a finitely presented group you first have to generate a free group (see  for details). Then a list of relators is constructed as words in the generators of the free group and is factored out to obtain the finitely presented group. Its generators are the images of the free generators. So for example to create the group \langle a, b \mid a^2, b^3, (a b)^5 \rangle you can use the following commands: f := FreeGroup( "a", "b" );; gap> g := f / [ f.1^2, f.2^3, (f.1*f.2)^5 ]; ]]>

Note that you cannot call the generators by their names. These names are not variables, but just display figures. So, if you want to access the generators by their names, you first have to introduce the respective variables and to assign the generators to them.

Unbind(a); gap> GeneratorsOfGroup( g ); [ a, b ] gap> a; Error, Variable: 'a' must have a value gap> a := g.1;; b := g.2;; # assign variables gap> GeneratorsOfGroup( g ); [ a, b ] gap> a in f; false gap> a in g; true ]]>

To relieve you of the tedium of typing the above assignments, when working interactively, there is the function .

Note that the generators of the free group are different from the generators of the FpGroup (even though they are displayed by the same names). That means that words in the generators of the free group are not elements of the finitely presented group. Vice versa elements of the FpGroup are not words.

a*b = b*a; false gap> (b^2*a*b)^2 = a^0; true ]]>

Such calculations comparing elements of an FpGroup may run into problems: There exist finitely presented groups for which no algorithm exists (it is known that no such algorithm can exist) that will tell for two arbitrary words in the generators whether the corresponding elements in the FpGroup are equal.

Therefore the methods used by &GAP; to compute in finitely presented groups may run into warning errors, run out of memory or run forever. If the FpGroup is (by theory) known to be finite the algorithms are guaranteed to terminate (if there is sufficient memory available), but the time needed for the calculation cannot be bounded a priori. See and .

(b^2*a*b)^2; (b^2*a*b)^2 gap> a^0; ]]>

A consequence of our convention is that elements of finitely presented groups are not printed in a unique way. See also .

IsSubgroupFpGroup and IsFpGroup <#Include Label="IsSubgroupFpGroup"> <#Include Label="IsFpGroup"> <#Include Label="InfoFpGroup">
Creating Finitely Presented Groups quotient creates a finitely presented group given by the presentation \langle gens \mid rels \rangle where gens are the free generators of the free group F. Note that relations are entered as relators, i.e., as words in the generators of the free group. To enter an equation use the quotient operator, i.e., for the relation a^b = ab one has to enter a^b / (a b).

The same result is obtained with the infix operator /, i.e., as F / rels.

f := FreeGroup( 3 );; gap> f / [ f.1^4, f.2^3, f.3^5, f.1*f.2*f.3 ]; ]]> <#Include Label="FactorGroupFpGroupByRels"> <#Include Label="ParseRelators"> <#Include Label="StringFactorizationWord">

Comparison of Elements of Finitely Presented Groups equality Two elements of a finitely presented group are equal if they are equal in this group. Nevertheless they may be represented as different words in the generators. Because of the fundamental problems mentioned in the introduction to this chapter such a test may take very long and cannot be guaranteed to finish.

The method employed by &GAP; for such an equality test use the underlying finitely presented group. First (unless this group is known to be infinite) &GAP; tries to find a faithful permutation representation by a bounded Todd-Coxeter. If this fails, a Knuth-Bendix (see ) is attempted and the words are compared via their normal form.

If only elements in a subgroup are to be tested for equality it thus can be useful to translate the problem in a new finitely presented group by rewriting (see );

The equality test of elements underlies many basic calculations, such as the order of an element, and the same type of problems can arise there. In some cases, working with rewriting systems can still help to solve the problem. The kbmag package provides such functionality, see the package manual for further details. smaller Compared with equality testing, problems get even worse when trying to compute a total ordering on the elements of a finitely presented group. As any ordering that is guaranteed to be reproducible in different runs of &GAP; or even with different groups given by syntactically equal presentations would be prohibitively expensive to implement, the ordering of elements is depending on a method chosen by &GAP; and not guaranteed to stay the same when repeating the construction of an FpGroup. The only guarantee given for the < ordering for such elements is that it will stay the same for one family during its lifetime. The attribute is used to obtain a comparison function for a family of FpGroup elements. <#Include Label="FpElmComparisonMethod"> <#Include Label="SetReducedMultiplication">

Preimages in the Free Group <#Include Label="FreeGroupOfFpGroup"> <#Include Label="FreeGeneratorsOfFpGroup"> <#Include Label="RelatorsOfFpGroup"> Let elm be an element of a group whose elements are represented as words with further properties. Then returns the word from the free group that is used as a representative for elm.

w := g.1*g.2; a*b gap> IsWord( w ); false gap> ue := UnderlyingElement( w ); a*b gap> IsWord( ue ); true ]]> <#Include Label="ElementOfFpGroup">

Operations for Finitely Presented Groups Finitely presented groups are groups and so all operations for groups should be applicable to them (though not necessarily efficient methods are available). Most methods for finitely presented groups rely on coset enumeration. See  for details.

The command can be used to obtain a faithful permutation representation, if such a representation of small degree exists. (Otherwise it might run very long or fail.) f := FreeGroup( "a", "b" ); gap> g := f / [ f.1^2, f.2^3, (f.1*f.2)^5 ]; gap> h := IsomorphismPermGroup( g ); [ a, b ] -> [ (1,2)(4,5), (2,3,4) ] gap> u:=Subgroup(g,[g.1*g.2]);;rt:=RightTransversal(g,u); RightTransversal(,Group([ a*b ])) gap> Image(ActionHomomorphism(g,rt,OnRight)); Group([ (1,2)(3,4)(5,7)(6,8)(9,10)(11,12), (1,3,2)(4,5,6)(7,8,9)(10,11,12) ]) ]]> The default algorithm for makes little sense for finitely presented or free groups, as it produces words that are extremely long.

By specifying the option radius, instead elements are taken as words in the generators of F in the ball of radius l with equal distribution in the free group.

PseudoRandom(g:radius:=20); a^3*b^2*a^-2*b^-1*a*b^-4*a*b^-1*a*b^-4 ]]>

Coset Tables and Coset Enumeration Coset enumeration (see for an explanation) is one of the fundamental tools for the examination of finitely presented groups. This section describes &GAP; functions that can be used to invoke a coset enumeration.

Note that in addition to the built-in coset enumerator there is the &GAP; package ACE. Moreover, &GAP; provides an interactive Todd-Coxeter in the &GAP; package ITC which is based on the XGAP package. <#Include Label="CosetTable"> <#Include Label="TracedCosetFpGroup"> returns the action of G on the cosets of its subgroup H.

u := Subgroup( g, [ g.1, g.1^g.2 ] ); Group([ a, b^-1*a*b ]) gap> FactorCosetAction( g, u ); [ a, b ] -> [ (2,4)(5,6), (1,2,3)(4,5,6) ] ]]> <#Include Label="CosetTableBySubgroup"> <#Include Label="CosetTableFromGensAndRels"> <#Include Label="CosetTableDefaultMaxLimit"> <#Include Label="CosetTableDefaultLimit"> <#Include Label="MostFrequentGeneratorFpGroup"> <#Include Label="IndicesInvolutaryGenerators">

Standardization of coset tables For any two coset numbers i and j with i < j the first occurrence of i in a coset table precedes the first occurrence of j with respect to the usual row-wise ordering of the table entries. Following the notation of Charles Sims' book on computation with finitely presented groups we call such a table a standard coset table.

The table entries which contain the first occurrences of the coset numbers i > 1 recursively provide for each i a representative of the corresponding coset in form of a unique word w_i in the generators and inverse generators of G. The first coset (which is H itself) can be represented by the empty word w_1. A coset table is standard if and only if the words w_1, w_2, \ldots are length-plus-lexicographic ordered (as defined in ), for short: lenlex.

This standardization of coset tables is different from that used in &GAP; versions 4.2 and earlier. Before that, we ignored the columns that correspond to inverse generators and hence only considered words in the generators of G. We call this older ordering the semilenlex standard as it also applies to the case of semigroups where no inverses of the generators are known.

We changed our default from the semilenlex standard to the lenlex standard to be consistent with . However, the semilenlex standardisation remains available and the convention used for all implicit standardisations can be selected by setting the value of the global variable to either "lenlex" or "semilenlex". Independent of the current value of you can standardize (or restandardize) a coset table at any time using . <#Include Label="CosetTableStandard"> <#Include Label="StandardizeTable">

Coset tables for subgroups in the whole group <#Include Label="CosetTableInWholeGroup"> <#Include Label="SubgroupOfWholeGroupByCosetTable">
Augmented Coset Tables and Rewriting <#Include Label="AugmentedCosetTableInWholeGroup"> <#Include Label="AugmentedCosetTableMtc"> <#Include Label="AugmentedCosetTableRrs"> <#Include Label="RewriteWord">
Low Index Subgroups <#Include Label="LowIndexSubgroupsFpGroupIterator">
Converting Groups to Finitely Presented Groups <#Include Label="IsomorphismFpGroup"> <#Include Label="IsomorphismFpGroupByGenerators">
New Presentations and Presentations for Subgroups IsomorphismFpGroup is also used to compute a new finitely presented group that is isomorphic to the given subgroup of a finitely presented group. (This is typically the only method to compute with subgroups of a finitely presented group.)

f:=FreeGroup(2);; gap> g:=f/[f.1^2,f.2^3,(f.1*f.2)^5]; gap> u:=Subgroup(g,[g.1*g.2]); Group([ f1*f2 ]) gap> hom:=IsomorphismFpGroup(u); [ <[ [ 1, 1 ] ]|f2^-1*f1^-1> ] -> [ F1 ] gap> new:=Range(hom); gap> List(GeneratorsOfGroup(new),i->PreImagesRepresentative(hom,i)); [ <[ [ 1, 1 ] ]|f2^-1*f1^-1> ] ]]>

When working with such homomorphisms, some subgroup elements are expressed as extremely long words in the group generators. Therefore the underlying words of subgroup generators stored in the isomorphism (as obtained by and displayed when ing the homomorphism) as well as preimages under the homomorphism are stored in the form of straight line program elements (see ). These will behave like ordinary words and no extra treatment should be necessary.

r:=Range(hom).1^10; F1^10 gap> p:=PreImagesRepresentative(hom,r); <[ [ 1, 10 ] ]|(f2^-1*f1^-1)^10> ]]> If desired, it also is possible to convert these underlying words using : r:=EvalStraightLineProgElm(UnderlyingElement(p)); (f2^-1*f1^-1)^10 gap> p:=ElementOfFpGroup(FamilyObj(p),r); (f2^-1*f1^-1)^10 ]]>

(If you are only interested in a finitely presented group isomorphic to the given subgroup but not in the isomorphism, you may also use the functions and (see ).)

Homomorphisms can also be used to obtain an isomorphic finitely presented group with a (hopefully) simpler presentation.

<#Include Label="IsomorphismSimplifiedFpGroup">

Preimages under Homomorphisms from an FpGroup For some subgroups of a finitely presented group the number of subgroup generators increases with the index of the subgroup. However often these generators are not needed at all for further calculations, but what is needed is the action of the cosets of the subgroup. This gives the image of the subgroup in a finite quotient and this finite quotient can be used to calculate normalizers, closures, intersections and so forth .

The same applies for subgroups that are obtained as preimages under homomorphisms. <#Include Label="SubgroupOfWholeGroupByQuotientSubgroup"> <#Include Label="IsSubgroupOfWholeGroupByQuotientRep"> <#Include Label="AsSubgroupOfWholeGroupByQuotient"> <#Include Label="DefiningQuotientHomomorphism">

Quotient Methods An important class of algorithms for finitely presented groups are the quotient algorithms which compute quotient groups of a given finitely presented group. There are algorithms for epimorphisms onto abelian groups, p-groups and solvable groups. (The low index algorithm –– can be considered as well as an algorithm that produces permutation group quotients.)

, as defined for general groups, returns the largest abelian quotient of the given group. f:=FreeGroup(2);;fp:=f/[f.1^6,f.2^6,(f.1*f.2)^12]; gap> hom:=MaximalAbelianQuotient(fp); [ f1, f2 ] -> [ f1, f3 ] gap> Size(Image(hom)); 36 ]]> <#Include Label="PQuotient"> <#Include Label="EpimorphismQuotientSystem"> <#Include Label="EpimorphismPGroup"> <#Include Label="EpimorphismNilpotentQuotient"> <#Include Label="SolvableQuotient"> <#Include Label="EpimorphismSolvableQuotient"> <#Include Label="LargerQuotientBySubgroupAbelianization">

Abelian Invariants for Subgroups Using variations of coset enumeration it is possible to compute the abelian invariants of a subgroup of a finitely presented group without computing a complete presentation for the subgroup in the first place. Typically, the operation when called for subgroups should automatically take care of this, but in case you want to have further control about the methods used, the following operations might be of use. <#Include Label="AbelianInvariantsSubgroupFpGroup"> <#Include Label="AbelianInvariantsSubgroupFpGroupMtc"> <#Include Label="AbelianInvariantsSubgroupFpGroupRrs"> <#Include Label="AbelianInvariantsNormalClosureFpGroup"> <#Include Label="AbelianInvariantsNormalClosureFpGroupRrs">
Testing Finiteness of Finitely Presented Groups As a consequence of the algorithmic insolvabilities mentioned in the introduction to this chapter, there cannot be a general method that will test whether a given finitely presented group is actually finite.

Therefore testing the finiteness of a finitely presented group can be problematic. What &GAP; actually does upon a call of (or if it is –probably implicitly– asked for a faithful permutation representation) is to test whether it can find (via coset enumeration) a cyclic subgroup of finite index. If it can, it rewrites the presentation to this subgroup. Since the subgroup is cyclic, its size can be checked easily from the resulting presentation, the size of the whole group is the product of the index and the subgroup size. Since however no bound for the index of such a subgroup (if any exist) is known, such a test might continue unsuccessfully until memory is exhausted.

On the other hand, a couple of methods exist, that might prove that a group is infinite. Again, none is guaranteed to work in every case:

The first method is to find (for example via the low index algorithm, see ) a subgroup U such that [U:U'] is infinite. If U has finite index, this can be checked by .

Note that this test has been done traditionally by checking the (see section ) of U, does a similar calculation but stops as soon as it is known whether 0 is an invariant without computing the actual values. This can be notably faster.

Another method is based on p-group quotients, see . <#Include Label="IsInfiniteAbelianizationGroup:grp"> <#Include Label="NewmanInfinityCriterion">

gap-4r6p5/doc/ref/changes.xml0000644000175000017500000003604312172557252014622 0ustar billbill Changes from Earlier Versions
Changes between &GAP; 4.3 and &GAP; 4.4 The main changes between &GAP; 4.3 and &GAP; 4.4 are: Potentially Incompatible Changes The mechanism for the loading of Packages has changed to allow easier updates independent of main &GAP; releases. Packages require a file PackageInfo.g now. The new PackageInfo.g files are available for all packages with the new version of GAP (see ). returns false now for the trivial group. : The output format has changed. Division rings (see ) are now implemented as . : p-th power maps are compatible with the input now. The print order for polynomials has been changed. These changes are, in some respects, departures from our policy of maintaining upward compatibility of documented functions between releases. In the first case, we felt that the old behavior was sufficiently inconsistent, illogical, and impossible to document that we had no alternative but to change it. In the case of the package interface, the change was necessary to introduce new functionality. The planned and phased removal of a few unnecessary functions or synonyms is needed to avoid becoming buried in legacy interfaces, but we remain committed to our policy of maintaining upward compatibility whenever sensibly possible.

Groebner Bases:

Buchberger's algorithm to compute Groebner Bases has been implemented in GAP. (A. Hulpke) For large scale Groebner Basis computations there also is an interface to the Singular system available in the http://www.gap-system.org/Packages/singular.html Singular package. (M. Costantini and W. de Graaf) New methods for factorizing polynomials over algebraic extensions of the rationals have been implemented in GAP. (A. Hulpke) For more functionality to compute with algebraic number fields there is an interface to the Kant system available in the http://www.gap-system.org/Packages/alnuth.html Alnuth package. (B. Assmann and B. Eick) A new functionality to compute the minimal normal subgroups of a finite group, as well as its socle, has been installed. (B. Höfling) A fast method for recognizing whether a permutation group is symmetric or alternating is available now (A. Seress) A method for computing the Galois group of a rational polynomial is available again. (A. Hulpke) The algorithm for has been extended to the case where the splitting field is not supported in &GAP;. (T. Breuer) Brauer tables of direct products can now be constructed from the known Brauer tables of the direct factors. (T. Breuer) Basic support for vector spaces of rational functions and of uea elements is available now in &GAP;. (T. Breuer and W. de Graaf) Various new functions for computations with integer matrices are available, such as methods for computing normal forms of integer matrices as well as nullspaces or solutions systems of equations. (W. Nickel and F. Gähler) New Packages The following new Packages have been accepted.

http://www.gap-system.org/Packages/alnuth.html Alnuth: Algebraic Number Theory and an interface to the Kant system. By B. Assmann and B. Eick. http://www.gap-system.org/Packages/laguna.html LAGUNA: Computing with Lie Algebras and Units of Group Algebras. By V. Bovdi, A. Konovalov, R. Rossmanith, C. Schneider. http://www.gap-system.org/Packages/nq.html NQ: The ANU Nilpotent Quotient Algorithm. By W. Nickel. http://www.gap-system.org/Packages/kbmag.html KBMAG: Knuth-Bendix for Monoids and Groups. By D. Holt. http://www.gap-system.org/Packages/polycyclic.html Polycyclic: Computation with polycyclic groups. By B. Eick and W. Nickel. http://www.gap-system.org/Packages/quagroup.html QuaGroup: Computing with Quantized Enveloping Algebras. By W. de Graaf. Performance Enhancements The computation of irreducible representations and irreducible characters using the Baum-Clausen algorithm and the implementation of the Dixon-Schneider algorithm have been speeded up. The algorithm for has been changed: the efficiency is improved and a new criterion is used. The algorithm for has been speeded up. The method for has been improved following a suggestion of H. Pahlings. New improved methods for normalizer and subgroup conjugation in S_n have been installed and new improved methods for and have been implemented. These improve the available methods when groups of large degrees are given. The partition split method used in the permutation backtrack is now in the kernel. Transversal computations in large permutation groups are improved. Homomorphisms from free groups into permutation groups now give substantially shorter words for preimages. The membership test in and groups has been improved using the invariant forms underlying these groups. An improvement for the cyclic extension method for the computation of subgroup lattices has been implemented. A better method for for finite field matrices has been implemented. The display has changed and the arithmetic of multivariate polynomials has been improved. The function now uses Pollard's rho method combined with the Pohlig/Hellmann approach. Various functions for sets and lists have been improved following suggestions of L. Teirlinck. These include: , , , , . The methods for and have been improved in the case of a known (anti-) symmetry following a suggestion of M. Costantini.

The improvements listed in this Section have been implemented by T. Breuer and A. Hulpke. New Programming and User Features The 2GB limit for workspace size has been removed and version numbers for saved workspaces have been introduced. (S. Linton and B. Höfling) The limit on the total number of types created in a session has been removed. (S. Linton) There is a new mechanism for loading packages available. Packages need a file PackageInfo.g now. (T. Breuer and F. Lübeck; see ).

Finally, as always, a number of bugs have been fixed. This release thus incorporates the contents of all the bug fixes which were released for &GAP; 4.3. It also fixes a number of bugs discovered since the last bug fix.

Earlier Changes The most important changes between &GAP; 4.2 and &GAP; 4.3 were:

The performance of several routines has been substantially improved. The functionality in the areas of finitely presented groups, Schur covers and the calculation of representations has been extended. The data libraries of transitive groups, finite integral matrix groups, character tables and tables of marks have been extended. The Windows installation has been simplified for the case where you are installing &GAP; in its standard location. Many bugs have been fixed.

The most important changes between &GAP; 4.1 and &GAP; 4.2 were:

A much extended and improved library of small groups as well as associated routines. The primitive groups library has been made more independent of the rest of &GAP;, some errors were corrected. New (and often much faster) infrastructure for orbit computation, based on a general dictionary abstraction. New functionality for dealing with representations of algebras, and in particular for semisimple Lie algebras. New functionality for binary relations on arbitrary sets, magmas and semigroups. Bidirectional streams, allowing an external process to be started and then controlled interactively by &GAP; A prototype implementation of algorithms using general subgroup chains. Changes in the behavior of vectors over small finite fields. A fifth book New features for Developers has been added to the &GAP; manual. Numerous bug fixes and performance improvements

The changes between the final release of &GAP; 3 (version 3.4.4) and &GAP; 4 are wide-ranging. The general philosophy of the changes is two-fold. Firstly, many assumptions in the design of &GAP; 3 revealed its authors' primary interest in group theory, and indeed in finite group theory. Although much of the &GAP; 4 library is concerned with groups, the basic design now allows extension to other algebraic structures, as witnessed by the inclusion of substantial bodies of algorithms for computation with semigroups and Lie algebras. Secondly, as the scale of the system, and the number of people using and contributing to it has grown, some aspects of the underlying system have proved to be restricting, and these have been improved as part of comprehensive re-engineering of the system. This has included the new method selection system, which underpins the library, and a new, much more flexible, &GAP; package interface.

Details of these changes can be found in the document Migrating to GAP 4 available at the &GAP; website, see http://www.gap-system.org/Gap3/migratedoc.pdf.

It is perhaps worth mentioning a few points here.

Firstly, much remains unchanged, from the perspective of the mathematical user:

The syntax of that part of the &GAP; language that most users need for investigating mathematical problems.

The great majority of function names.

Data libraries and the access to them.

A number of visible aspects have changed:

Some function names that need finer specifications now that there are more structures available in &GAP;. The access to information already obtained about a mathematical structure. In &GAP; 3 such information about a group could be looked up by directly inspecting the group record, whereas in &GAP; 4 functions must be used to access such information.

Behind the scenes, much has changed:

A new kernel, with improvements in memory management and in the language interpreter, as well as new features such as saving of workspaces and the possibility of compilation of &GAP; code into C. A new structure to the library, based upon a new type and method selection system, which is able to support a broader range of algebraic computation and to make the structure of the library simpler and more modular. New and faster algorithms in many mathematical areas. Data structures and algorithms for new mathematical objects, such as algebras and semigroups. A new and more flexible structure for the &GAP; installation and documentation, which means, for example, that a &GAP; package and its documentation can be installed and be fully usable without any changes to the &GAP; system.

Very few features of &GAP; 3 are not yet available in &GAP; 4.

Not all of the &GAP; 3 packages have yet been converted for use with &GAP; 4. The library of crystallographic groups which was present in &GAP; 3 is now part of a &GAP; 4 package http://www.gap-system.org/Packages/crystcat.html CrystCat by V. Felsch and F. Gähler.

gap-4r6p5/doc/ref/debug.xml0000644000175000017500000007537712172557252014315 0ustar billbill Debugging and Profiling Facilities This chapter describes some functions that are useful mainly for debugging and profiling purposes.

Probably the most important debugging tool in &GAP; is the break loop (see Section ) which can be entered by putting an statement into your code or by hitting Control-C. In the break loop one can inspect variables, stack traces and issue commands as usual in an interactive &GAP; session. See also the , and functions.

Sections  and  show how to get information about the methods chosen by the method selection mechanism (see chapter ).

The final sections describe functions for collecting statistics about computations (see , ).

Recovery from NoMethodFound-Errors When the method selection fails because there is no applicable method, an error as in the following example occurs and a break loop is entered:

IsNormal(2,2); Error, no method found! For debugging hints type ?Recovery from NoMethodFound Error, no 1st choice method found for `IsNormal' on 2 arguments called from ( ) called from read-eval-loop Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can 'return;' to continue brk> ]]>

This only says, that the method selection tried to find a method for IsNormal on two arguments and failed. In this situation it is crucial to find out, why this happened. Therefore there are a few functions which can display further information. Note that you can leave the break loop by the quit command (see ) and that the information about the incident is no longer accessible afterwards.

<#Include Label="ShowArguments"> <#Include Label="ShowArgument"> <#Include Label="ShowDetails"> <#Include Label="ShowMethods"> <#Include Label="ShowOtherMethods">

Inspecting Applicable Methods <#Include Label="ApplicableMethod">
Tracing Methods <#Include Label="TraceMethods"> <#Include Label="UntraceMethods"> <#Include Label="TraceImmediateMethods">
Info Functions The mechanism permits operations to display intermediate results or information about the progress of the algorithms. Information is always given according to one or more info classes. Each of the info classes defined in the &GAP; library usually covers a certain range of algorithms, so for example InfoLattice covers all the cyclic extension algorithms for the computation of a subgroup lattice.

The amount of information to be displayed can be specified by the user for each info class separately by a level, the higher the level the more information will be displayed. Ab initio all info classes have level zero except which initially has level 1.

creates a new info class with name name.

creates a new info class with name name and binds it to the global variable name. The variable must previously be writable, and is made readonly by this function.

Sets the info level for infoclass to level.

returns the info level of infoclass.

If the info level of infoclass is at least level the remaining arguments, info and possibly moreinfo and so on, are evaluated. (Technically, is a keyword and not a function.)

By default, they are viewed, preceded by the string "#I " and followed by a newline. Otherwise the third and subsequent arguments are not evaluated. (The latter can save substantial time when displaying difficult results.)

The behaviour can be customized with .

InfoExample:=NewInfoClass("InfoExample");; gap> Info(InfoExample,1,"one");Info(InfoExample,2,"two"); gap> SetInfoLevel(InfoExample,1); gap> Info(InfoExample,1,"one");Info(InfoExample,2,"two"); #I one gap> SetInfoLevel(InfoExample,2); gap> Info(InfoExample,1,"one");Info(InfoExample,2,"two"); #I one #I two gap> InfoLevel(InfoExample); 2 gap> Info(InfoExample,3,Length(Combinations([1..9999]))); ]]>

Note that the last call is executed without problems, since the actual level 2 of InfoExample causes to ignore the last argument, which prevents Length(Combinations([1..9999])) from being evaluated; note that an evaluation would be impossible due to memory restrictions.

A set of info classes (called an info selector) may be passed to a single statement. As a shorthand, info classes and selectors may be combined with + rather than . In this case, the message is triggered if the level of any of the classes is high enough.

InfoExample:=NewInfoClass("InfoExample");; gap> SetInfoLevel(InfoExample,0); gap> Info(InfoExample + InfoWarning, 1, "hello"); #I hello gap> Info(InfoExample + InfoWarning, 2, "hello"); gap> SetInfoLevel(InfoExample,2); gap> Info(InfoExample + InfoWarning, 2, "hello"); #I hello gap> InfoLevel(InfoWarning); 1 ]]> Customizing statements nothing This allows to customize what happens in an Info(infoclass, level, ...) statement.

In the first function handler must be a function with three arguments infoclass, level, list. Here list is the list containing the third to last argument of the call.

The default handler is the function DefaultInfoHandler. DefaultInfoHandler It prints "#I ", then the third and further arguments of the info statement, and finally a "\n".

If the first argument of an statement is a sum of Info classes, the handler of the first summand is used.

The file or stream to which statements for individual classes print can be changed with . The initial default for all classes is the string "*Print*" which means the current output file. The default can be changed with . The argument out can be a filename or an open stream, the special names "*Print*", "*errout* and "*stdout* are also recognized.

For example, SetDefaultInfoOutput("*errout*"); would send output to standard error, which can be interesting if &GAP;s output is redirected. is an info class to which general warnings are sent at level 1, which is its default level. More specialised warnings are shown via calls of at level 2, e.g. information about the autoloading of &GAP; packages and the initial line matched when displaying an on-line help topic.

Assertions Assertions are used to find errors in algorithms. They test whether intermediate results conform to required conditions and issue an error if not.

assigns the global assertion level to lev. By default it is zero.

returns the current assertion level.

With two arguments, if the global assertion level is at least lev, condition cond is tested and if it does not return true an error is raised. Thus Assert(lev, cond) is equivalent to the code = lev and not then Error("Assertion failure"); fi; ]]>

With the message argument form of the statement, if the global assertion level is at least lev, condition cond is tested and if it does not return true then message is evaluated and printed.

Assertions are used at various places in the library. Thus turning assertions on can slow code execution significantly.

Timing returns a record with components bound to integers or fail. Each integer is the cpu time (processor time) in milliseconds spent by &GAP; in a certain status:

user_time cpu time spent with &GAP; functions (without child processes). system_time cpu time spent in system calls, e.g., file access (fail if not available). user_time_children cpu time spent in child processes (fail if not available). system_time_children cpu time spent in system calls by child processes (fail if not available).

Note that this function is not fully supported on all systems. Only the user_time component is (and may on some systems include the system time).

The following example demonstrates tasks which contribute to the different time components:

Runtimes(); # after startup rec( user_time := 3980, system_time := 60, user_time_children := 0, system_time_children := 0 ) gap> Exec("cat /usr/bin/*||wc"); # child process with a lot of file access 893799 7551659 200928302 gap> Runtimes(); rec( user_time := 3990, system_time := 60, user_time_children := 1590, system_time_children := 600 ) gap> a:=0;;for i in [1..100000000] do a:=a+1; od; # GAP user time gap> Runtimes(); rec( user_time := 12980, system_time := 70, user_time_children := 1590, system_time_children := 600 ) gap> ?blabla # first call of help, a lot of file access Help: no matching entry found gap> Runtimes(); rec( user_time := 13500, system_time := 440, user_time_children := 1590, system_time_children := 600 ) ]]> returns the time spent by &GAP; in milliseconds as an integer. It is the same as the value of the user_time component given by , as explained above.

See for a translation from milliseconds into hour/minute format. In the read-eval-print loop, stores the time the last command took.

Profiling Profiling of code can be used to determine in which parts of a program how much time has been spent and how much memory has been allocated during runtime. The idea is that first one switches on profiling for those &GAP; functions the performance of which one wants to check, then one runs some &GAP; computations, then one looks at the profile information collected during these computations, then one runs more computations (perhaps clearing all profile information before, see ), and finally one switches off profiling.

For switching on and off profiling, &GAP; supports entering a list of functions (see , ) or a list of operations whose methods shall be (un)profiled (, ), and can be used to show profile information about functions in a given list.

Besides these functions, , , and can be used for switching on or off profiling for all global functions, operations, and operations together with all their methods, respectively, and for showing profile information about these functions.

Note that &GAP; will perform more slowly when profiling than when not. <#Include Label="ProfileGlobalFunctions"> <#Include Label="ProfileOperations"> <#Include Label="ProfileOperationsAndMethods"> <#Include Label="ProfileFunctions"> <#Include Label="UnprofileFunctions"> <#Include Label="ProfileMethods"> <#Include Label="UnprofileMethods"> <#Include Label="DisplayProfile"> <#Include Label="ClearProfile"> An Example of Profiling Let us suppose we want to get information about the computation of the conjugacy classes of a certain permutation group. For that, first we create the group, then we start profiling for all global functions and for all operations and their methods, then we compute the conjugacy classes, and then we stop profiling.

g:= PrimitiveGroup( 24, 1 );; gap> ProfileGlobalFunctions( true ); gap> ProfileOperationsAndMethods( true ); gap> ConjugacyClasses( g );; gap> ProfileGlobalFunctions( false ); gap> ProfileOperationsAndMethods( false ); ]]>

Now the profile information is available. We can list the information for all profiled functions with .

DisplayProfile(); count self/ms chld/ms stor/kb chld/kb package function 17647 0 0 275 0 GAP BasePoint 10230 0 0 226 0 (oprt.) ShallowCopy 10139 0 0 0 0 PositionSortedOp: for* 10001 0 0 688 0 UniteSet: for two int* 10001 8 0 28 688 (oprt.) UniteSet 14751 12 0 0 0 =: for two families: * 10830 8 4 182 276 GAP Concatenation 2700 20 12 313 55 GAP AddRefinement 2444 28 4 3924 317 GAP ConjugateStabChain 4368 0 32 7 714 (oprt.) Size 2174 32 4 1030 116 GAP List 585 4 32 45 742 GAP RRefine 1532 32 8 194 56 GAP AddGeneratorsExtendSc* 1221 8 32 349 420 GAP Partition 185309 28 12 0 0 (oprt.) Length 336 4 40 95 817 GAP ExtendSeriesPermGroup 4 28 20 488 454 (oprt.) Sortex 2798 0 52 54 944 GAP StabChainForcePoint 560 4 48 83 628 GAP StabChainSwap 432 16 40 259 461 GAP SubmagmaWithInversesNC 185553 48 8 915 94 (oprt.) Add 26 0 64 0 2023 (oprt.) CentralizerOp 26 0 64 0 2023 GAP CentralizerOp: perm g* 26 0 64 0 2023 GAP Centralizer: try to e* 152 4 64 0 2024 (oprt.) Centralizer 1605 0 68 0 2032 (oprt.) StabilizerOfExternalS* 26 0 68 0 2024 GAP Meth(StabilizerOfExte* 382 0 96 69 1922 GAP TryPcgsPermGroup 5130 4 96 309 3165 GAP ForAll 7980 24 116 330 6434 GAP ChangeStabChain 12076 12 136 351 6478 GAP ProcessFixpoint 192 0 148 4 3029 GAP StabChainMutable: cal* 2208 4 148 3 3083 (oprt.) StabChainMutable 217 0 160 0 3177 (oprt.) StabChainOp 217 12 148 60 3117 GAP StabChainOp: group an* 216 36 464 334 12546 GAP PartitionBacktrack 1479 12 668 566 18474 GAP RepOpElmTuplesPermGro* 1453 12 684 56 18460 GAP in: perm class rep 126 0 728 13 19233 GAP ConjugacyClassesTry 1 0 736 0 19671 GAP ConjugacyClassesByRan* 2 0 736 2 19678 (oprt.) ConjugacyClasses 1 0 736 0 19675 GAP ConjugacyClasses: per* 13400 1164 0 0 0 (oprt.) Position 484 12052 OTHER 2048 23319 TOTAL ]]>

We can restrict the list to global functions with .

ProfileGlobalFunctions(); count self/ms chld/ms stor/kb chld/kb package function 17647 0 0 275 0 GAP BasePoint 10830 8 4 182 276 GAP Concatenation 2700 20 12 313 55 GAP AddRefinement 2444 28 4 3924 317 GAP ConjugateStabChain 2174 32 4 1030 116 GAP List 585 4 32 45 742 GAP RRefine 1532 32 8 194 56 GAP AddGeneratorsExtendSc* 1221 8 32 349 420 GAP Partition 336 4 40 95 817 GAP ExtendSeriesPermGroup 2798 0 52 54 944 GAP StabChainForcePoint 560 4 48 83 628 GAP StabChainSwap 432 16 40 259 461 GAP SubmagmaWithInversesNC 382 0 96 69 1922 GAP TryPcgsPermGroup 5130 4 96 309 3165 GAP ForAll 7980 24 116 330 6434 GAP ChangeStabChain 12076 12 136 351 6478 GAP ProcessFixpoint 216 36 464 334 12546 GAP PartitionBacktrack 1479 12 668 566 18474 GAP RepOpElmTuplesPermGro* 126 0 728 13 19233 GAP ConjugacyClassesTry 1 0 736 0 19671 GAP ConjugacyClassesByRan* 1804 14536 OTHER 2048 23319 TOTAL ]]>

We can restrict the list to operations with .

ProfileOperations(); count self/ms chld/ms stor/kb chld/kb package function 10230 0 0 226 0 (oprt.) ShallowCopy 10001 8 0 28 688 (oprt.) UniteSet 4368 0 32 7 714 (oprt.) Size 185309 28 12 0 0 (oprt.) Length 4 28 20 488 454 (oprt.) Sortex 185553 48 8 915 94 (oprt.) Add 26 0 64 0 2023 (oprt.) CentralizerOp 152 4 64 0 2024 (oprt.) Centralizer 1605 0 68 0 2032 (oprt.) StabilizerOfExternalS* 2208 4 148 3 3083 (oprt.) StabChainMutable 217 0 160 0 3177 (oprt.) StabChainOp 2 0 736 2 19678 (oprt.) ConjugacyClasses 13400 1164 0 0 0 (oprt.) Position 764 21646 OTHER 2048 23319 TOTAL ]]>

We can restrict the list to operations and their methods with .

ProfileOperationsAndMethods(); count self/ms chld/ms stor/kb chld/kb package function 10230 0 0 226 0 (oprt.) ShallowCopy 10139 0 0 0 0 PositionSortedOp: for* 10001 0 0 688 0 UniteSet: for two int* 10001 8 0 28 688 (oprt.) UniteSet 14751 12 0 0 0 =: for two families: * 4368 0 32 7 714 (oprt.) Size 185309 28 12 0 0 (oprt.) Length 4 28 20 488 454 (oprt.) Sortex 185553 48 8 915 94 (oprt.) Add 26 0 64 0 2023 (oprt.) CentralizerOp 26 0 64 0 2023 GAP CentralizerOp: perm g* 26 0 64 0 2023 GAP Centralizer: try to e* 152 4 64 0 2024 (oprt.) Centralizer 1605 0 68 0 2032 (oprt.) StabilizerOfExternalS* 26 0 68 0 2024 GAP Meth(StabilizerOfExte* 192 0 148 4 3029 GAP StabChainMutable: cal* 2208 4 148 3 3083 (oprt.) StabChainMutable 217 0 160 0 3177 (oprt.) StabChainOp 217 12 148 60 3117 GAP StabChainOp: group an* 1453 12 684 56 18460 GAP in: perm class rep 2 0 736 2 19678 (oprt.) ConjugacyClasses 1 0 736 0 19675 GAP ConjugacyClasses: per* 13400 1164 0 0 0 (oprt.) Position 728 20834 OTHER 2048 23319 TOTAL ]]>

Finally, we can restrict the list to explicitly given functions with , by entering the list of functions as an argument.

DisplayProfile( [ StabChainOp, Centralizer ] ); count self/ms chld/ms stor/kb chld/kb package function 152 4 64 0 2024 (oprt.) Centralizer 217 0 160 0 3177 (oprt.) StabChainOp 2044 23319 OTHER 2048 23319 TOTAL ]]> <#Include Label="DisplayCacheStats"> <#Include Label="ClearCacheStats">

Information about the version used GAPInfo.Version The global variable GAPInfo.Version (see ) contains the version number of the version of &GAP;. Its value can be checked other version number using .
Test Files Test files are used to check that &GAP; produces correct results in certain computations. A selection of test files for the library can be found in the tst directory of the &GAP; distribution. <#Include Label="ReadTest"> <#Include Label="StartStopTest"> <#Include Label="[1]{testinstall.g}"> <#Include Label="[1]{testall.g}">

<#Include Label="Test">

Debugging Recursion The &GAP; interpreter monitors the level of nesting of &GAP; functions during execution. By default, whenever this nesting reaches a multiple of 5000, &GAP; enters a break loop () allowing you to terminate the calculation, or enter Return; to continue it.

dive:= function(depth) if depth>1 then dive(depth-1); fi; return; end; function( depth ) ... end gap> dive(100); gap> OnBreak:= function() Where(1); end; # shorter traceback function( ) ... end gap> dive(6000); recursion depth trap (5000) at dive( depth - 1 ); called from dive( depth - 1 ); called from ... Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you may 'return;' to continue brk> return; gap> dive(11000); recursion depth trap (5000) at dive( depth - 1 ); called from dive( depth - 1 ); called from ... Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you may 'return;' to continue brk> return; recursion depth trap (10000) at dive( depth - 1 ); called from dive( depth - 1 ); called from ... Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you may 'return;' to continue brk> return; gap> ]]>

This behaviour can be controlled using the following procedure. interval must be a non-negative small integer (between 0 and 2^{28}). An interval of 0 suppresses the monitoring of recursion altogether. In this case excessive recursion may cause &GAP; to crash.

dive:= function(depth) if depth>1 then dive(depth-1); fi; return; end; function( depth ) ... end gap> SetRecursionTrapInterval(1000); gap> dive(2500); recursion depth trap (1000) at dive( depth - 1 ); called from dive( depth - 1 ); called from ... Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you may 'return;' to continue brk> return; recursion depth trap (2000) at dive( depth - 1 ); called from dive( depth - 1 ); called from ... Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you may 'return;' to continue brk> return; gap> SetRecursionTrapInterval(-1); SetRecursionTrapInterval( ): must be a non-negative smal\ l integer not in any function Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can replace via 'return ;' to continue brk> return (); SetRecursionTrapInterval( ): must be a non-negative smal\ l integer not in any function Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can replace via 'return ;' to continue brk> return 0; gap> dive(20000); gap> dive(2000000); Segmentation fault ]]>

Global Memory Information The &GAP; environment provides automatic memory management, so that the programmer does not need to concern themselves with allocating space for objects, or recovering space when objects are no longer needed. The component of the kernel which provides this is called GASMAN (&GAP; Storage MANager). Messages reporting garbage collections performed by GASMAN can be switched on by the -g command line option (see section ). There are also some facilities to access information from GASMAN from &GAP; programs. <#Include Label="GasmanStatistics"> <#Include Label="GasmanMessageStatus"> <#Include Label="GasmanLimits">
gap-4r6p5/doc/ref/fields.xml0000644000175000017500000000562012172557252014455 0ustar billbill Fields and Division Rings <#Include Label="[1]{field}">
Generating Fields <#Include Label="IsDivisionRing"> <#Include Label="IsField"> <#Include Label="Field"> <#Include Label="DefaultField"> <#Include Label="DefaultFieldByGenerators"> <#Include Label="GeneratorsOfDivisionRing"> <#Include Label="GeneratorsOfField"> <#Include Label="DivisionRingByGenerators"> <#Include Label="AsDivisionRing">
Subfields of Fields <#Include Label="Subfield"> <#Include Label="FieldOverItselfByGenerators"> <#Include Label="PrimitiveElement"> <#Include Label="PrimeField"> <#Include Label="IsPrimeField"> <#Include Label="DegreeOverPrimeField"> <#Include Label="DefiningPolynomial"> <#Include Label="RootOfDefiningPolynomial"> <#Include Label="FieldExtension"> <#Include Label="Subfields">
Galois Action <#Include Label="[2]{field}">

<#Include Label="[3]{field}"> IsFieldControlledByGaloisGroup <#Include Label="GaloisGroup:field"> returns the minimal polynomial of z over the field F. This is a generator of the ideal in F[x] of all polynomials which vanish on z. (This definition is consistent with the general definition of for rings.)

MinimalPolynomial( Rationals, E(8) ); x_1^4+1 gap> MinimalPolynomial( CF(4), E(8) ); x_1^2+(-E(4)) gap> MinimalPolynomial( CF(8), E(8) ); x_1+(-E(8)) ]]> <#Include Label="TracePolynomial"> <#Include Label="Norm"> <#Include Label="Trace"> <#Include Label="Conjugates"> <#Include Label="NormalBase">

gap-4r6p5/doc/ref/addmagma.xml0000644000175000017500000000772412172557252014751 0ustar billbill Additive Magmas This chapter deals with domains that are closed under addition +, which are called near-additive magmas in &GAP;. Together with the domains closed under multiplication * (see ), they are the basic algebraic structures. In many cases, the addition is commutative (see ), the domain is called an additive magma then. Every module (see ), vector space (see ), ring (see ), or field (see ) is an additive magma. In the cases of all (near-)additive magma-with-zero or (near-)additive magma-with-inverses, additional additive structure is present (see ).
(Near-)Additive Magma Categories <#Include Label="IsNearAdditiveMagma"> <#Include Label="IsNearAdditiveMagmaWithZero"> <#Include Label="IsNearAdditiveGroup"> <#Include Label="IsAdditiveMagma"> <#Include Label="IsAdditiveMagmaWithZero"> <#Include Label="IsAdditiveGroup">
(Near-)Additive Magma Generation This section describes functions that create additive magmas from generators (see , , ), the underlying operations for which methods can be installed (see , , ) and functions for forming additive submagmas (see , , ). <#Include Label="NearAdditiveMagma"> <#Include Label="NearAdditiveMagmaWithZero"> <#Include Label="NearAdditiveGroup"> <#Include Label="NearAdditiveMagmaByGenerators"> <#Include Label="NearAdditiveMagmaWithZeroByGenerators"> <#Include Label="NearAdditiveGroupByGenerators"> <#Include Label="SubnearAdditiveMagma"> <#Include Label="SubnearAdditiveMagmaWithZero"> <#Include Label="SubnearAdditiveGroup">
Attributes and Properties for (Near-)Additive Magmas <#Include Label="IsAdditivelyCommutative"> <#Include Label="GeneratorsOfNearAdditiveMagma"> <#Include Label="GeneratorsOfNearAdditiveMagmaWithZero"> <#Include Label="GeneratorsOfNearAdditiveGroup"> <#Include Label="AdditiveNeutralElement"> <#Include Label="TrivialSubnearAdditiveMagmaWithZero">
Operations for (Near-)Additive Magmas <#Include Label="ClosureNearAdditiveGroup"> <#Include Label="ShowAdditionTable">
gap-4r6p5/doc/ref/demo.tst0000644000175000017500000000030112172557252014134 0ustar billbill# this is a demo file for the 'Test' function # gap> g := Group((1,2), (1,2,3)); Group([ (1,2), (1,2,3) ]) # another comment following an empty line # the following fails: gap> a := 13+29; 41 gap-4r6p5/doc/ref/ctblmaps.xml0000644000175000017500000000776212172557252015025 0ustar billbill Maps Concerning Character Tables maps parametrized maps <#Include Label="[1]{ctblmaps}">

Several examples in this chapter require the &GAP; Character Table Library to be available. If it is not yet loaded then we load it now.

LoadPackage( "ctbllib" ); true ]]>

Power Maps <#Include Label="[2]{ctblmaps}"> <#Include Label="PowerMap"> <#Include Label="PossiblePowerMaps"> <#Include Label="ElementOrdersPowerMap"> <#Include Label="PowerMapByComposition">
Orbits on Sets of Possible Power Maps <#Include Label="[3]{ctblmaps}"> <#Include Label="OrbitPowerMaps"> <#Include Label="RepresentativesPowerMaps">
Class Fusions between Character Tables <#Include Label="[4]{ctblmaps}"> <#Include Label="FusionConjugacyClasses"> <#Include Label="ComputedClassFusions"> <#Include Label="GetFusionMap"> <#Include Label="StoreFusion"> <#Include Label="NamesOfFusionSources"> <#Include Label="PossibleClassFusions"> <#Include Label="ConsiderStructureConstants">
Orbits on Sets of Possible Class Fusions <#Include Label="[5]{ctblmaps}"> <#Include Label="OrbitFusions"> <#Include Label="RepresentativesFusions">
Parametrized Maps <#Include Label="[6]{ctblmaps}"> <#Include Label="CompositionMaps"> <#Include Label="InverseMap"> <#Include Label="ProjectionMap"> <#Include Label="Indirected"> <#Include Label="Parametrized"> <#Include Label="ContainedMaps"> <#Include Label="UpdateMap"> <#Include Label="MeetMaps"> <#Include Label="CommutativeDiagram"> <#Include Label="CheckFixedPoints"> <#Include Label="TransferDiagram"> <#Include Label="TestConsistencyMaps"> <#Include Label="Indeterminateness"> <#Include Label="PrintAmbiguity"> <#Include Label="ContainedSpecialVectors"> <#Include Label="CollapsedMat"> <#Include Label="ContainedDecomposables">
Subroutines for the Construction of Power Maps <#Include Label="[7]{ctblmaps}"> <#Include Label="InitPowerMap"> <#Include Label="Congruences"> <#Include Label="ConsiderKernels"> <#Include Label="ConsiderSmallerPowerMaps"> <#Include Label="MinusCharacter"> <#Include Label="PowerMapsAllowedBySymmetrizations">
Subroutines for the Construction of Class Fusions <#Include Label="InitFusion"> <#Include Label="CheckPermChar"> <#Include Label="ConsiderTableAutomorphisms"> <#Include Label="FusionsAllowedByRestrictions">
gap-4r6p5/doc/ref/mgmring.xml0000644000175000017500000000545412172557252014654 0ustar billbill Magma Rings <#Include Label="[1]{mgmring}">
Free Magma Rings <#Include Label="FreeMagmaRing"> <#Include Label="GroupRing"> <#Include Label="IsFreeMagmaRing"> <#Include Label="IsFreeMagmaRingWithOne"> <#Include Label="IsGroupRing"> <#Include Label="UnderlyingMagma"> <#Include Label="AugmentationIdeal">
Elements of Free Magma Rings <#Include Label="[2]{mgmring}"> <#Include Label="IsMagmaRingObjDefaultRep"> <#Include Label="IsElementOfFreeMagmaRing"> <#Include Label="IsElementOfFreeMagmaRingFamily"> <#Include Label="CoefficientsAndMagmaElements"> <#Include Label="ZeroCoefficient"> <#Include Label="ElementOfMagmaRing">
Natural Embeddings related to Magma Rings <#Include Label="[3]{mgmring}">
Magma Rings modulo Relations <#Include Label="[4]{mgmring}"> <#Include Label="IsElementOfMagmaRingModuloRelations"> <#Include Label="IsElementOfMagmaRingModuloRelationsFamily"> <#Include Label="NormalizedElementOfMagmaRingModuloRelations"> <#Include Label="IsMagmaRingModuloRelations">
Magma Rings modulo the Span of a Zero Element <#Include Label="IsElementOfMagmaRingModuloSpanOfZeroFamily"> <#Include Label="IsMagmaRingModuloSpanOfZero"> <#Include Label="MagmaRingModuloSpanOfZero">
Technical Details about the Implementation of Magma Rings <#Include Label="[5]{mgmring}">
gap-4r6p5/doc/ref/grpmat.xml0000644000175000017500000001125312172557252014500 0ustar billbill Matrix Groups Matrix groups are groups generated by invertible square matrices.

In the following example we temporarily increase the line length limit from its default value 80 to 83 in order to get a nicer output format.

m1 := [ [ Z(3)^0, Z(3)^0, Z(3) ], > [ Z(3), 0*Z(3), Z(3) ], > [ 0*Z(3), Z(3), 0*Z(3) ] ];; gap> m2 := [ [ Z(3), Z(3), Z(3)^0 ], > [ Z(3), 0*Z(3), Z(3) ], > [ Z(3)^0, 0*Z(3), Z(3) ] ];; gap> m := Group( m1, m2 ); Group( [ [ [ Z(3)^0, Z(3)^0, Z(3) ], [ Z(3), 0*Z(3), Z(3) ], [ 0*Z(3), Z(3), 0*Z(3) ] ], [ [ Z(3), Z(3), Z(3)^0 ], [ Z(3), 0*Z(3), Z(3) ], [ Z(3)^0, 0*Z(3), Z(3) ] ] ]) ]]>

IsMatrixGroup (Filter) For most operations, &GAP; only provides methods for finite matrix groups. Many calculations in finite matrix groups are done via so-called nice monomorphisms (see Section ) that represent a faithful action on vectors. <#Include Label="IsMatrixGroup">
Attributes and Properties for Matrix Groups <#Include Label="DimensionOfMatrixGroup"> <#Include Label="DefaultFieldOfMatrixGroup"> <#Include Label="FieldOfMatrixGroup"> <#Include Label="TransposedMatrixGroup"> <#Include Label="IsFFEMatrixGroup">
Actions of Matrix Groups <#Include Label="[1]{grpmat}"> <#Include Label="ProjectiveActionOnFullSpace"> <#Include Label="ProjectiveActionHomomorphismMatrixGroup"> <#Include Label="BlowUpIsomorphism">
GL and SL (See also section .) <#Include Label="IsGeneralLinearGroup"> <#Include Label="IsNaturalGL"> <#Include Label="IsSpecialLinearGroup"> <#Include Label="IsNaturalSL"> <#Include Label="IsSubgroupSL">
Invariant Forms <#Include Label="InvariantBilinearForm"> <#Include Label="IsFullSubgroupGLorSLRespectingBilinearForm"> <#Include Label="InvariantSesquilinearForm"> <#Include Label="IsFullSubgroupGLorSLRespectingSesquilinearForm"> <#Include Label="InvariantQuadraticForm"> <#Include Label="IsFullSubgroupGLorSLRespectingQuadraticForm">
Matrix Groups in Characteristic 0 Most of the functions described in this and the following section have implementations which use functions from the &GAP; package Carat. If Carat is not installed or not compiled, no suitable methods are available. <#Include Label="IsCyclotomicMatrixGroup"> <#Include Label="IsRationalMatrixGroup"> <#Include Label="IsIntegerMatrixGroup"> <#Include Label="IsNaturalGLnZ"> <#Include Label="IsNaturalSLnZ"> <#Include Label="InvariantLattice"> <#Include Label="NormalizerInGLnZ"> <#Include Label="CentralizerInGLnZ"> <#Include Label="ZClassRepsQClass"> <#Include Label="IsBravaisGroup"> <#Include Label="BravaisGroup"> <#Include Label="BravaisSubgroups"> <#Include Label="BravaisSupergroups"> <#Include Label="NormalizerInGLnZBravaisGroup">
Acting OnRight and OnLeft <#Include Label="[1]{grpramat}"> <#Include Label="CrystGroupDefaultAction"> <#Include Label="SetCrystGroupDefaultAction">
gap-4r6p5/doc/ref/vspc.xml0000644000175000017500000001343412172557252014164 0ustar billbill Vector Spaces
IsLeftVectorSpace (Filter) <#Include Label="IsLeftVectorSpace">
Constructing Vector Spaces <#Include Label="VectorSpace"> <#Include Label="Subspace"> <#Include Label="AsVectorSpace"> <#Include Label="AsSubspace">
Operations and Attributes for Vector Spaces <#Include Label="GeneratorsOfLeftVectorSpace"> <#Include Label="TrivialSubspace">
Domains of Subspaces of Vector Spaces <#Include Label="Subspaces"> <#Include Label="IsSubspacesVectorSpace">
Bases of Vector Spaces <#Include Label="[1]{basis}"> <#Include Label="IsBasis"> <#Include Label="Basis"> <#Include Label="CanonicalBasis"> <#Include Label="RelativeBasis">
Operations for Vector Space Bases <#Include Label="BasisVectors"> <#Include Label="UnderlyingLeftModule"> <#Include Label="Coefficients"> <#Include Label="LinearCombination"> <#Include Label="EnumeratorByBasis"> <#Include Label="IteratorByBasis">
Operations for Special Kinds of Bases <#Include Label="IsCanonicalBasis"> <#Include Label="IsIntegralBasis"> <#Include Label="IsNormalBasis">
Mutable Bases <#Include Label="[1]{basismut}"> <#Include Label="IsMutableBasis"> <#Include Label="MutableBasis"> <#Include Label="NrBasisVectors"> <#Include Label="ImmutableBasis"> <#Include Label="IsContainedInSpan"> <#Include Label="CloseMutableBasis">
Row and Matrix Spaces row spaces matrix spaces <#Include Label="IsRowSpace"> <#Include Label="IsMatrixSpace"> <#Include Label="IsGaussianSpace"> <#Include Label="FullRowSpace"> <#Include Label="FullMatrixSpace"> <#Include Label="DimensionOfVectors"> <#Include Label="IsSemiEchelonized"> <#Include Label="SemiEchelonBasis"> <#Include Label="IsCanonicalBasisFullRowModule"> <#Include Label="IsCanonicalBasisFullMatrixModule"> <#Include Label="NormedRowVectors"> <#Include Label="SiftedVector">
Vector Space Homomorphisms <#Include Label="[1]{vspchom}"> <#Include Label="LeftModuleGeneralMappingByImages"> <#Include Label="LeftModuleHomomorphismByImages"> <#Include Label="LeftModuleHomomorphismByMatrix"> <#Include Label="NaturalHomomorphismBySubspace"> <#Include Label="Hom"> <#Include Label="End"> <#Include Label="IsFullHomModule"> <#Include Label="IsPseudoCanonicalBasisFullHomModule"> <#Include Label="IsLinearMappingsModule">
Vector Spaces Handled By Nice Bases <#Include Label="[2]{basis}"> <#Include Label="NiceFreeLeftModule"> <#Include Label="NiceVector"> <#Include Label="NiceFreeLeftModuleInfo"> <#Include Label="NiceBasis"> <#Include Label="IsBasisByNiceBasis"> <#Include Label="IsHandledByNiceBasis">
How to Implement New Kinds of Vector Spaces <#Include Label="DeclareHandlingByNiceBasis"> <#Include Label="NiceBasisFiltersInfo"> <#Include Label="CheckForHandlingByNiceBasis">
gap-4r6p5/doc/ref/monoid.xml0000644000175000017500000000242312172557252014472 0ustar billbill Monoids This chapter describes functions for monoids. Currently there are only few of them. More general functions for magmas and semigroups can be found in Chapters  and .
Functions for Monoids <#Include Label="IsMonoid"> <#Include Label="Monoid"> <#Include Label="Submonoid"> <#Include Label="MonoidByGenerators"> <#Include Label="AsMonoid"> <#Include Label="AsSubmonoid"> <#Include Label="GeneratorsOfMonoid"> <#Include Label="TrivialSubmonoid"> <#Include Label="FreeMonoid"> <#Include Label="MonoidByMultiplicationTable">
gap-4r6p5/doc/ref/mloop.xml0000644000175000017500000013550512172557252014343 0ustar billbill Main Loop and Break Loop This chapter is a first of a series of chapters that describe the interactive environment in which you use &GAP;.
Main Loop read eval print loop loop prompt prompt syntax errors errors output last last2 last3 previous result The normal interaction with &GAP; happens in the so-called read-eval-print loop. This means that you type an input, &GAP; first reads it, evaluates it, and then shows the result. Note that the term print may be confusing since there is a &GAP; function called (see ) which is in fact not used in the read-eval-print loop, but traditions are hard to break. In the following, whenever we want to express that &GAP; places some characters on the standard output, we will say that &GAP; shows something.

The exact sequence in the read-eval-print loop is as follows.

To signal that it is ready to accept your input, &GAP; shows the prompt gap>. When you see this, you know that &GAP; is waiting for your input.

Note that every statement must be terminated by a semicolon. You must also enter Return (i.e., strike the Return key) before &GAP; starts to read and evaluate your input. (The Return key may actually be marked with the word Enter and a returning arrow on your terminal.) Because &GAP; does not do anything until you enter Return, you can edit your input to fix typos and only when everything is correct enter Return and have &GAP; take a look at it (see ). It is also possible to enter several statements as input on a single line. Of course each statement must be terminated by a semicolon.

It is absolutely acceptable to enter a single statement on several lines. When you have entered the beginning of a statement, but the statement is not yet complete, and you enter Return, &GAP; will show the partial prompt >. When you see this, you know that &GAP; is waiting for the rest of the statement. This happens also when you forget the semicolon ; that terminates every &GAP; statement. Note that when Return has been entered and the current statement is not yet complete, &GAP; will already evaluate those parts of the input that are complete, for example function calls that appear as arguments in another function call which needs several input lines. So it may happen that one has to wait some time for the partial prompt.

When you enter Return, &GAP; first checks your input to see if it is syntactically correct (see Chapter  for the definition of syntactically correct). If it is not, &GAP; prints an error message of the following form

1 * ; Syntax error: expression expected 1 * ; ^ ]]>

The first line tells you what is wrong about the input, in this case the * operator takes two expressions as operands, so obviously the right one is missing. If the input came from a file (see ), this line will also contain the filename and the line number. The second line is a copy of the input. And the third line contains a caret pointing to the place in the previous line where &GAP; realized that something is wrong. This need not be the exact place where the error is, but it is usually quite close.

Sometimes, you will also see a partial prompt after you have entered an input that is syntactically incorrect. This is because &GAP; is so confused by your input, that it thinks that there is still something to follow. In this case you should enter ;Return repeatedly, ignoring further error messages, until you see the full prompt again. When you see the full prompt, you know that &GAP; forgave you and is now ready to accept your next –hopefully correct– input.

If your input is syntactically correct, &GAP; evaluates or executes it, i.e., performs the required computations (see Chapter  for the definition of the evaluation).

If you do not see a prompt, you know that &GAP; is still working on your last input. Of course, you can type ahead, i.e., already start entering new input, but it will not be accepted by &GAP; until &GAP; has completed the ongoing computation.

When &GAP; is ready it will usually show the result of the computation, i.e., the value computed. Note that not all statements produce a value, for example, if you enter a for loop, nothing will be printed, because the for loop does not produce a value that could be shown.

Also sometimes you do not want to see the result. For example if you have computed a value and now want to assign the result to a variable, you probably do not want to see the value again. You can terminate statements by two semicolons to suppress showing the result.

If you have entered several statements on a single line &GAP; will first read, evaluate, and show the first one, then read, evaluate, and show the second one, and so on. This means that the second statement will not even be checked for syntactical correctness until &GAP; has completed the first computation.

After the result has been shown &GAP; will display another prompt, and wait for your next input. And the whole process starts all over again. Note that if you have entered several statements on a single line, a new prompt will only be printed after &GAP; has read, evaluated, and shown the last statement.

In each statement that you enter, the result of the previous statement that produced a value is available in the variable last. The next to previous result is available in last2 and the result produced before that is available in last3.

1;2;3; 1 2 3 gap> last3 + last2 * last; 7 ]]>

Also in each statement the time spent by the last statement, whether it produced a value or not, is available in the variable . This is an integer that holds the number of milliseconds.

Special Rules for Input Lines The input for some &GAP; objects may not fit on one line, in particular big integers, long strings or long identifiers. In these cases you can still type or paste them in long single lines. For nicer display you can also specify the input on several lines. This is achieved by ending a line by a backslash or by a backslash and a carriage return character, then continue the input on the beginning of the next line. When reading this &GAP; will ignore such continuation backslashes, carriage return characters and newline characters. &GAP; also prints long strings and integers this way.

n := 1234\ > 567890; 1234567890 gap> "This is a very long string that does not fit on a line \ > and is therefore continued on the next line."; "This is a very long string that does not fit on a line and is therefo\ re continued on the next line." gap> bla\ > bla := 5;; blabla; 5 ]]>

There is a special rule about &GAP; prompts in input lines: In line editing mode (usual user input and &GAP; started without -n) in lines starting with whitespace following gap> , > or brk> this beginning part is removed. This rule is very convenient because it allows to cut and paste input from other &GAP; sessions or manual examples easily into your current session.

View and Print &GAP; has three different operations to display or print objects: , and , and these three have different purposes as follows. The first, , should print the object to the standard output in a human-readable relatively complete and verbose form. The second, , should print the object to the standard output in a short and concise form, it is used in the main read-eval-print loop to display the resulting object of a computation. The third, , should print the object to the standard output in a complete form which is &GAP;-readable if at all possible, such that reading the output into &GAP; produces an object which is equal to the original one.

All three operations have corresponding operations which do not print anything to standard output but return the output as a string. These are , and (corresponding to ). Additionally, there is which is very similar to but does not insert control characters for line breaks.

For implementation convenience it is allowed that some of these operations have methods which delegate to some other of these operations. However, the rules for this are that a method may only delegate to another operation which appears further down in the following table:

This is to avoid circular delegations.

Note in particular that none of the methods of the string producing operations may delegate to the corresponding printing operations. Note also that the above mentioned purposes of the different operations suggest that delegations between different operations will be sub-optimal in most scenarios. Default delegations in the library The library contains the following low ranked default methods: A method for which returns the constant value of the global variable . A method for which returns the constant value of the global variable . A method for which first calls and prints the result, if it is a different object than . Otherwise the method delegates to . A method for which first calls and prints the result, if it is a different object than . Otherwise the method delegates to . A method for which prints the result of . A method for which returns the result of Recommendations for the implementation This subsection describes what methods for printing and viewing one should implement for new &GAP; objects.

One should at the very least install a method to allow printing. Using the standard delegations this enables a limited form of viewing, displaying and printing.

If, for larger objects, nicer line breaks are needed, one should install a separate method which puts in positions for good line breaks using the control characters \< (ASCII 1) and \> (ASCII 2).

If, for even larger objects, output performance and memory usage matters, one should install a separate method.

One should usually install a method, unless the above method is good enough for purposes. Performance and memory should never matter here, so it is usually unnecessary to install a separate method.

If the type of object calls for it one should install a method. This is the case if a human readable verbose form is required.

If the performance and memory usage for matters, one should install a separate method.

Note that if only a method is installed, then works and returns . Likewise, works and returns . If you want to avoid this then install methods for these operations as well. <#Include Label="View"> Also shows the objects obj1, obj2... etc. on the standard output. The difference compared to is in general that the shown form is not required to be short, and that in many cases the form shown by is &GAP; readable.

z:= Z(2); Z(2)^0 gap> v:= [ z, z, z, z, z, z, z ]; [ Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0 ] gap> ConvertToVectorRep(v);; v; gap> Print( v, "\n" ); [ Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0 ] ]]>

Another difference is that shows strings without the enclosing quotes, so can be used to produce formatted text on the standard output (see also chapter ). Some characters preceded by a backslash, such as \n, are processed specially (see chapter ). can be used to print to a file.

for i in [1..5] do > Print( i, " ", i^2, " ", i^3, "\n" ); > od; 1 1 1 2 4 8 3 9 27 4 16 64 5 25 125 gap> g:= SmallGroup(12,5); gap> Print( g, "\n" ); Group( [ f1, f2, f3 ] ) gap> View( g ); Print( "\n" ); ]]>

The functions and actually call the operations and , respectively, for each argument. By installing special methods for these operations, it is possible to achieve special printing behavior for certain objects (see chapter ). The only exceptions are strings (see Chapter ), for which the default and methods as well as the function print also the enclosing doublequotes, whereas strips the doublequotes.

The default method for is to call . So it is sufficient to have a method for an object in order to it. If one wants to supply a short form for , one can install additionally a method for . <#Include Label="Display"> When setting up examples, in particular if for beginning users, it sometimes can be convenient to hide the structure behind a printing name. For many objects, such as groups, this can be done using . If the objects however is represented internally, for example permutations representing group elements, this function is not applicable. Instead the function can be used to interface with the display routines on a lower level. <#Include Label="SetNameObject">

Break Loops When an error has occurred or when you interrupt &GAP; (usually by hitting Ctrl-C) &GAP; enters a break loop, that is in most respects like the main read eval print loop (see ). That is, you can enter statements, &GAP; reads them, evaluates them, and shows the result if any. However those evaluations happen within the context in which the error occurred. So you can look at the arguments and local variables of the functions that were active when the error happened and even change them. The prompt is changed from gap> to brk> to indicate that you are in a break loop.

1/0; Rational operations: must not be zero not in any function Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can replace via 'return ;' to continue ]]>

If errors occur within a break loop &GAP; enters another break loop at a deeper level. This is indicated by a number appended to brk:

1/0; Rational operations: must not be zero not in any function Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can replace via 'return ;' to continue brk_02> ]]>

There are two ways to leave a break loop, see and . quit from a break loop The first way to leave a break loop is to quit the break loop. To do this you enter quit; or type the eof (end of file) character, which is usually Ctrl-D except when using the -e option (see Section ). Note that &GAP; code between quit; and the end of the input line is ignored.

quit; brk> ]]>

In this case control returns to the break loop one level above or to the main loop, respectively. So iterated break loops must be left iteratively. Note also that if you type quit; from a gap> prompt, &GAP; will exit (see ).

Note: If you leave a break loop with quit without completing a command it is possible (though not very likely) that data structures will be corrupted or incomplete data have been stored in objects. Therefore no guarantee can be given that calculations afterwards will return correct results! If you have been using options quitting a break loop generally leaves the options stack with options you no longer want. The function removes all options on the options stack, and this is the sole intended purpose of this function. return from a break loop return return from break loop The other way to leave a break loop is to return from a break loop. To do this you type return; or return obj;. If the break loop was entered because you interrupted &GAP;, then you can continue by typing return;. If the break loop was entered due to an error, you may have to modify the value of a variable before typing return; (see the example for ) or you may have to return an object obj (by typing: return obj;) to continue the computation; in any case, the message printed on entering the break loop will tell you which of these alternatives is possible. For example, if the break loop was entered because a variable had no assigned value, the value to be returned is often a value that this variable should have to continue the computation.

return 9; # we had tried to enter the divisor 9 but typed 0 ... 1/9 gap> ]]> By default, when a break loop is entered, &GAP; prints a trace of the innermost 5 commands currently being executed. This behaviour can be configured by changing the value of the global variable . When a break loop is entered, the value of is checked. If it is a function, then it is called with no arguments. By default, the value of is .

OnBreak := function() Print("Hello\n"); end; function( ) ... end ]]>

Error("!\n"); Error, ! Hello Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can 'return;' to continue brk> quit; ]]>

In cases where a break loop is entered during a function that was called with options (see Chapter ), a quit; will also cause the options stack to be reset and an Info-ed warning stating this is emitted at level 1 (see Chapter ).

Note that for break loops entered by a call to , the lines after Entering break read-eval-print loop ... and before the brk> prompt can also be customised, namely by redefining .

ErrorNoTraceBack Also, note that one can achieve the effect of changing locally. As mentioned above, the default value of is . Thus, a call to generally gives a trace back up to five levels of calling functions. Conceivably, we might like to have a function like that does not trace back without globally changing . Such a function we might call ErrorNoTraceBack and here is how we might define it. (Note ErrorNoTraceBack is not a &GAP; function.)

ErrorNoTraceBack := function(arg) # arg is special variable that GAP > # knows to treat as list of arg's > local SavedOnBreak, ENTBOnBreak; > SavedOnBreak := OnBreak; # save current value of OnBreak > > ENTBOnBreak := function() # our `local' OnBreak > local s; > for s in arg do > Print(s); > od; > OnBreak := SavedOnBreak; # restore OnBreak afterwards > end; > > OnBreak := ENTBOnBreak; > Error(); > end; function( arg ) ... end ]]>

Here is a somewhat trivial demonstration of the use of ErrorNoTraceBack.

ErrorNoTraceBack("Gidday!", " How's", " it", " going?\n"); Error, Gidday! How's it going? Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can 'return;' to continue brk> quit; ]]>

Now we call with the same arguments to show the difference.

Error("Gidday!", " How's", " it", " going?\n"); Error, Gidday! How's it going? Hello Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can 'return;' to continue brk> quit; ]]>

Observe that the value of before the ErrorNoTraceBack call was restored. However, we had changed from its default value; to restore to its default value, we should do the following.

OnBreak := Where;; ]]> Break loop message When a break loop is entered by a call to the message after the Entering break read-eval-print loop ... line is produced by the function OnBreakMessage, which just like is a user-configurable global variable that is a function with no arguments.

OnBreakMessage(); # By default, OnBreakMessage prints the following you can 'quit;' to quit to outer loop, or you can 'return;' to continue ]]>

Perhaps you are familiar with what's possible in a break loop, and so don't need to be reminded. In this case, you might wish to do the following (the first line just makes it easy to restore the default value later).

NormalOnBreakMessage := OnBreakMessage;; # save the default value gap> OnBreakMessage := function() end; # do-nothing function function( ) ... end gap> OnBreakMessage(); gap> OnBreakMessage := NormalOnBreakMessage;; # reset ]]>

With still set away from its default value, calling as we did above, now produces:

Error("!\n"); Error, ! Hello Entering break read-eval-print loop ... brk> quit; # to get back to outer loop ]]>

However, suppose you are writing a function which detects an error condition and OnBreakMessage needs to be changed only locally, i.e., the instructions on how to recover from the break loop need to be specific to that function. The same idea used to define ErrorNoTraceBack (see ) can be adapted to achieve this. The function is an example in the &GAP; code where the idea is actually used.

Backtrace Stack trace shows the last nr commands on the execution stack during whose execution the error occurred. If not given, nr defaults to 5. (Assume, for the following example, that after the last example has been set back to its default value.)

StabChain(SymmetricGroup(100)); # After this we typed ^C user interrupt at bpt := S.orbit[1]; called from SiftedPermutation( S, (g * rep) ^ -1 ) called from StabChainStrong( S.stabilizer, [ sch ], options ); called from StabChainStrong( S.stabilizer, [ sch ], options ); called from StabChainStrong( S, GeneratorsOfGroup( G ), options ); called from StabChainOp( G, rec( ) ) called from ... Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can 'return;' to continue brk> Where(2); called from SiftedPermutation( S, (g * rep) ^ -1 ) called from StabChainStrong( S.stabilizer, [ sch ], options ); called from ... ]]>

Note that the variables displayed even in the first line of the list (after the called from line) may be already one environment level higher and may be necessary to access them.

At the moment this backtrace does not work from within compiled code (this includes the method selection which by default is compiled into the kernel). If this creates problems for debugging, call &GAP; with the -M option (see ) to avoid loading compiled code.

(Function calls to and methods installed for binary operations are handled in a special way. In rare circumstances it is possible therefore that they do not show up in a log but the log refers to the last proper function call that happened before.)

The command line option -T to &GAP; disables the break loop. This is mainly intended for testing purposes and for special applications. If this option is given then errors simply cause &GAP; to return to the main loop.

Variable Access in a Break Loop In a break loop access to variables of the current break level and higher levels is possible, but if the same variable name is used for different objects or if a function calls itself recursively, of course only the variable at the lowest level can be accessed. DownEnv and UpEnv moves down nr steps in the environment and allows one to inspect variables on this level; if nr is negative it steps up in the environment again; nr defaults to 1 if not given. acts similarly to but in the reverse direction (the mnemonic rule to remember the difference between and is the order in which commands on the execution stack are displayed by ).

OnBreak := function() Where(0); end;; # eliminate back-tracing on gap> # entry to break loop gap> test:= function( n ) > if n > 3 then Error( "!\n" ); fi; test( n+1 ); end;; gap> test( 1 ); Error, ! Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can 'return;' to continue brk> Where(); called from test( n + 1 ); called from test( n + 1 ); called from test( n + 1 ); called from ( ) called from read-eval-loop brk> n; 4 brk> DownEnv(); brk> n; 3 brk> Where(); called from test( n + 1 ); called from test( n + 1 ); called from ( ) called from read-eval-loop brk> DownEnv( 2 ); brk> n; 1 brk> Where(); called from ( ) called from read-eval-loop brk> DownEnv( -2 ); brk> n; 3 brk> quit; gap> OnBreak := Where;; # restore OnBreak to its default value ]]>

Note that the change of the environment caused by only affects variable access in the break loop. If you use return to continue a calculation &GAP; automatically jumps to the right environment level again.

Note also that search for variables looks first in the chain of outer functions which enclosed the definition of a currently executing function, before it looks at the chain of calling functions which led to the current invocation of the function.

foo := function() > local x; x := 1; > return function() local y; y := x*x; Error("!!\n"); end; > end; function( ) ... end gap> bar := foo(); function( ) ... end gap> fun := function() local x; x := 3; bar(); end; function( ) ... end gap> fun(); Error, !! called from bar( ); called from ( ) called from read-eval-loop Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can 'return;' to continue brk> x; 1 brk> DownEnv(1); brk> x; 3 ]]>

Here the x of foo which contained the definition of bar is found before that of fun which caused its execution. Using we can access the x from fun.

Error and ErrorCount signals an error from within a function. First the messages messages are printed, this is done exactly as if (see ) were called with these arguments. Then a break loop (see ) is entered, unless the standard error output is not connected to a terminal. You can leave this break loop with return; to continue execution with the statement following the call to . returns a count of the number of errors (including user interruptions) which have occurred in the &GAP; session so far. This count is reduced modulo 2^{28} on 32 bit systems, 2^{60} on 64 bit systems. The count is incremented by each error, even if &GAP; was started with the -T option to disable the break loop.
Leaving GAP quit exit at exit functions saving on exit The normal way to terminate a &GAP; session is to enter either quit; (note the semicolon) or an end-of-file character (usually Ctrl-D) at the gap> prompt in the main read eval print loop. An emergency way to leave &GAP; is to enter QUIT QUIT at any gap> or brk> or brk_nn> prompt. Before actually terminating, &GAP; will call (with no arguments) all of the functions that have been installed using InstallAtExit. These typically perform tasks such as cleaning up temporary files created during the session, and closing open files. If an error occurs during the execution of one of these functions, that function is simply abandoned, no break loop is entered.

InstallAtExit(function() Print("bye\n"); end); gap> quit; bye ]]>

During execution of these functions, the global variable QUITTING will be set to true if &GAP; is exiting because the user typed QUIT and false otherwise. Since QUIT is considered as an emergency measure, different action may be appropriate. If, when &GAP; is exiting due to a quit or end-of-file (i.e. not due to a QUIT) the variable is bound to a string value, then the system will try to save the workspace to that file.

Line Editing In most installations &GAP; will be compiled to use the Gnu readline library (see the line Libs used: on &GAP; startup). In that case skip to the next section . (The line editing commands described in the rest of this section were available in previous versions of &GAP;, they will work almost the same in the standard configuration of the Gnu readline library.)

&GAP; allows one you to edit the current input line with a number of editing commands. Those commands are accessible either as control keys or as escape keys. You enter a control key by pressing the Ctrl key, and, while still holding the Ctrl key down, hitting another key key. You enter an escape key by hitting Esc and then hitting another key key. Below we denote control keys by Ctrl-key and escape keys by Esc-key. The case of key does not matter, i.e., Ctrl-A and Ctrl-a are equivalent.

Normally, line editing will be enabled if the input is connected to a terminal. Line editing can be enabled or disabled using the command line options -f and -n respectively (see ), however this is a machine dependent feature of &GAP;.

Typing Ctrl-key or Esc-key for characters not mentioned below always inserts Ctrl-key resp. Esc-key at the current cursor position.

The first few commands allow you to move the cursor on the current line.

Ctrl-A move the cursor to the beginning of the line. Esc-B move the cursor to the beginning of the previous word. Ctrl-B move the cursor backward one character. Ctrl-F move the cursor forward one character. Esc-F move the cursor to the end of the next word. Ctrl-E move the cursor to the end of the line.

The next commands delete or kill text. The last killed text can be reinserted, possibly at a different position, with the yank command Ctrl-Y. Ctrl-H or del delete the character left of the cursor. Ctrl-D delete the character under the cursor. Ctrl-K kill up to the end of the line. Esc-D kill forward to the end of the next word. Esc-del kill backward to the beginning of the last word. Ctrl-X kill entire input line, and discard all pending input. Ctrl-Y insert (yank) a just killed text.

The next commands allow you to change the input.

Ctrl-T exchange (twiddle) current and previous character. Esc-U uppercase next word. Esc-L lowercase next word. Esc-C capitalize next word.

The Tab character, which is in fact the control key Ctrl-I, looks at the characters before the cursor, interprets them as the beginning of an identifier and tries to complete this identifier. If there is more than one possible completion, it completes to the longest common prefix of all those completions. If the characters to the left of the cursor are already the longest common prefix of all completions hitting Tab a second time will display all possible completions.

tab complete the identifier before the cursor.

The next commands allow you to fetch previous lines, e.g., to correct typos, etc.

Ctrl-L insert last input line before current character. Ctrl-P redisplay the last input line, another Ctrl-P will redisplay the line before that, etc. If the cursor is not in the first column only the lines starting with the string to the left of the cursor are taken. Ctrl-N Like Ctrl-P but goes the other way round through the history. Esc-< goes to the beginning of the history. Esc-> goes to the end of the history. Ctrl-O accepts this line and perform a Ctrl-N.

Finally there are a few miscellaneous commands.

Ctrl-V enter next character literally, i.e., enter it even if it is one of the control keys. Ctrl-U execute the next line editing command 4 times. Esc-num execute the next line editing command num times. Esc-Ctrl-L redisplay input line.

The four arrow keys (cursor keys) can be used instead of Ctrl-B, Ctrl-F, Ctrl-P, and Ctrl-N, respectively.

<#Include Label="readline">
Editing Files In most cases, it is preferable to create longer input (in particular &GAP; programs) separately in an editor, and to read in the result via . Note that by default reads from the directory in which &GAP; was started (respectively under Windows the directory containing the &GAP; binary), so you might have to give an absolute path to the file.

If you cannot create several windows, the command may be used to leave &GAP;, start an editor, and read in the edited file automatically. <#Include Label="Edit">

Editor Support utilities for editing GAP files vi vim emacs In the etc subdirectory of the &GAP; installation we provide some setup files for the editors vim and emacs/xemacs.

vim is a powerful editor that understands the basic vi commands but provides much more functionality. You can find more information about it (and download it) from http://www.vim.org.

To get support for &GAP; syntax in vim, create in your home directory a directory .vim with subdirectories .vim/syntax and .vim/indent (If you are not using Unix, refer to the vim documentation on where to place syntax files). Then copy the file etc/gap.vim to .vim/syntax/gap.vim and the file etc/gap_indent.vim to .vim/indent/gap.vim.

Then edit the .vimrc file in your home directory. Add lines as in the following example:

See the headers of the two mentioned files for additional comments and adjust details according to your personal taste. Send comments and suggestions to support@gap-system.org. Setup files for emacs/xemacs are contained in the etc/emacs subdirectory.

Changing the Screen Size Called with no arguments, returns the size of the screen as a list with two entries. The first is the length of each line, the second is the number of lines.

Called with one argument that is a list sz, sets the size of the screen; The first entry of sz, if bound, is the length of each line, and the second entry of sz, if bound, is the number of lines. The values for unbound entries of sz are left unaffected. The function returns the new values.

Note that those parameters can also be set with the command line options -x for the line length and -y for the number of lines (see Section ).

To check/change whether line breaking occurs for files and streams see  and .

The line length must be between 20 and 4096 characters (inclusive) and the number of lines must be at least 10. Values outside this range will be adjusted to the nearest endpoint of the range.

Teaching Mode When using &GAP; in the context of (undergraduate) teaching it is often desirable to simplify some of the system output and functionality defaults (potentially at the cost of making the printing of objects more expensive). This can be achieved by turning on a teaching mode: When called with a boolean argument switch, this function will turn teaching mode respectively on or off. a:=Z(11)^3; Z(11)^3 gap> TeachingMode(true); #I Teaching mode is turned ON gap> a; ZmodnZObj(8,11) gap> TeachingMode(false); #I Teaching mode is turned OFF gap> a; Z(11)^3 ]]> At the moment, teaching mode changes the following things

Prime Field Elements Elements of fields of prime order are printed as instead as power of a primitive root. Quadratic Irrationalities Elements of a quadratic extension of the rationals are printed using the square root instead of using roots of unity. Creation of some small groups The group creator functions , , , and create by default (if no other representation is specified) not a pc group, but a finitely presented group, which makes the generators easier to interpret.

gap-4r6p5/doc/ref/orders.xml0000644000175000017500000000472412172557252014511 0ustar billbill Orderings <#Include Label="[1]{orders}">
IsOrdering (Filter) <#Include Label="IsOrdering"> <#Include Label="OrderingsFamily">
Building new orderings <#Include Label="OrderingByLessThanFunctionNC"> <#Include Label="OrderingByLessThanOrEqualFunctionNC">
Properties and basic functionality <#Include Label="IsWellFoundedOrdering"> <#Include Label="IsTotalOrdering"> <#Include Label="IsIncomparableUnder"> <#Include Label="FamilyForOrdering"> <#Include Label="LessThanFunction"> <#Include Label="LessThanOrEqualFunction"> <#Include Label="IsLessThanUnder"> <#Include Label="IsLessThanOrEqualUnder">
Orderings on families of associative words <#Include Label="[2]{orders}"> <#Include Label="IsOrderingOnFamilyOfAssocWords"> <#Include Label="IsTranslationInvariantOrdering"> <#Include Label="IsReductionOrdering"> <#Include Label="OrderingOnGenerators"> <#Include Label="LexicographicOrdering"> <#Include Label="ShortLexOrdering"> <#Include Label="IsShortLexOrdering"> <#Include Label="WeightLexOrdering"> <#Include Label="IsWeightLexOrdering"> <#Include Label="WeightOfGenerators"> <#Include Label="BasicWreathProductOrdering"> <#Include Label="IsBasicWreathProductOrdering"> <#Include Label="WreathProductOrdering"> <#Include Label="IsWreathProductOrdering"> <#Include Label="LevelsOfGenerators">
gap-4r6p5/doc/ref/options.xml0000644000175000017500000000366312172557252014707 0ustar billbill Options Stack <#Include Label="[1]{options}">
Functions Dealing with the Options Stack <#Include Label="PushOptions"> <#Include Label="PopOptions"> <#Include Label="ResetOptionsStack"> <#Include Label="OnQuit"> <#Include Label="ValueOption"> <#Include Label="DisplayOptionsStack"> <#Include Label="InfoOptions">
Options Stack – an Example The example below shows simple manipulation of the Options Stack, first using and and then using the special function calling syntax.

foo := function() > Print("myopt1 = ", ValueOption("myopt1"), > " myopt2 = ",ValueOption("myopt2"),"\n"); > end; function( ) ... end gap> foo(); myopt1 = fail myopt2 = fail gap> PushOptions(rec(myopt1 := 17)); gap> foo(); myopt1 = 17 myopt2 = fail gap> DisplayOptionsStack(); [ rec( myopt1 := 17 ) ] gap> PopOptions(); gap> foo(); myopt1 = fail myopt2 = fail gap> foo( : myopt1, myopt2 := [Z(3),"aardvark"]); myopt1 = true myopt2 = [ Z(3), "aardvark" ] gap> DisplayOptionsStack(); [ ] gap> ]]>

gap-4r6p5/doc/ref/blist.xml0000644000175000017500000001113412172557252014321 0ustar billbill Boolean Lists This chapter describes boolean lists. A boolean list is a list that has no holes and contains only the boolean values true and false (see Chapter ). In function names we call boolean lists blists for brevity.
IsBlist (Filter) <#Include Label="IsBlist">
Boolean Lists Representing Subsets <#Include Label="BlistList"> <#Include Label="ListBlist"> <#Include Label="SizeBlist"> <#Include Label="IsSubsetBlist">
Set Operations via Boolean Lists <#Include Label="UnionBlist"> <#Include Label="IntersectionBlist"> <#Include Label="DifferenceBlist">
Function that Modify Boolean Lists <#Include Label="UniteBlist"> <#Include Label="UniteBlistList"> <#Include Label="IntersectBlist"> <#Include Label="SubtractBlist">
More about Boolean Lists We defined a boolean list as a list that has no holes and contains only true and false. There is a special internal representation for boolean lists that needs only 1 bit for each entry. This bit is set if the entry is true and reset if the entry is false. This representation is of course much more compact than the ordinary representation of lists, which needs 32 or 64 bits per entry.

Not every boolean list is represented in this compact representation. It would be too much work to test every time a list is changed, whether this list has become a boolean list. This section tells you under which circumstances a boolean list is represented in the compact representation, so you can write your functions in such a way that you make best use of the compact representation.

If a dense list containing only true and false is read, it is stored in the compact representation. Furthermore, the results of , , and are known to be boolean lists by construction, and thus are represented in the compact representation upon creation.

If an argument of , , , , , , and is a list represented in the ordinary representation, it is tested to see if it is in fact a boolean list. If it is not, an error is signalled. If it is, the representation of the list is changed to the compact representation.

If you change a boolean list that is represented in the compact representation by assignment (see ) or in such a way that the list remains a boolean list it will remain represented in the compact representation. Note that changing a list that is not represented in the compact representation, whether it is a boolean list or not, in such a way that the resulting list becomes a boolean list, will never change the representation of the list. <#Include Label="IsBlistRep">

gap-4r6p5/doc/ref/ratfun.xml0000644000175000017500000006576112172557252014522 0ustar billbill Polynomials and Rational Functions Let R be a commutative ring-with-one. We call a free associative algebra A over R a polynomial ring over R. The free generators of A are called indeterminates (to avoid naming conflicts with the word variables which will be used to denote &GAP; variables only) , they are usually denoted by x_1, x_2, \ldots. The number of indeterminates is called the rank of A. The elements of A are called polynomials. Products of indeterminates are called monomials, every polynomial can be expressed as a finite sum of products of monomials with ring elements in a form like r_{{1,0}} x_1 + r_{{1,1}} x_1 x_2 + r_{{0,1}} x_2 + \cdots with r_{{i,j}} \in R.

A polynomial ring of rank 1 is called an univariate polynomial ring, its elements are univariate polynomials.

Polynomial rings of smaller rank naturally embed in rings of higher rank; if S is a subring of R then a polynomial ring over S naturally embeds in a polynomial ring over R of the same rank. Note however that &GAP; does not consider R as a subset of a polynomial ring over R; for example the zero of R (0) and the zero of the polynomial ring (0x^0) are different objects.

Internally, indeterminates are represented by positive integers, but it is possible to give names to them to have them printed in a nicer way. Beware, however that there is not necessarily any relation between the way an indeterminate is called and the way it is printed. See section for details.

If R is an integral domain, the polynomial ring A over R is an integral domain as well and one can therefore form its quotient field Q. This field is called a field of rational functions. Again A embeds naturally into Q and &GAP; will perform this embedding implicitly. (In fact it implements the ring of rational functions over R.) To avoid problems with leading coefficients, however, R must be a unique factorization domain.

Indeterminates <#Include Label="[1]{ringpoly}">

<#Include Label="[2]{ringpoly}"> <#Include Label="Indeterminate"> <#Include Label="IndeterminateNumberOfUnivariateRationalFunction"> <#Include Label="IndeterminateOfUnivariateRationalFunction"> <#Include Label="IndeterminateName"> <#Include Label="CIUnivPols">

Operations for Rational Functions The rational functions form a field, therefore all arithmetic operations are applicable to rational functions.

addition subtraction product quotient f + g

f - g

f * g

f / g

x:=Indeterminate(Rationals,1);;y:=Indeterminate(Rationals,2);; gap> f:=3+x*y+x^5;;g:=5+x^2*y+x*y^2;; gap> a:=g/f; (x_1^2*x_2+x_1*x_2^2+5)/(x_1^5+x_1*x_2+3) ]]>

Note that the quotient f/g of two polynomials might be represented as a rational function again. If g is known to divide f the call Quotient(f,g) (see ) should be used instead.

mod f mod g

For two Laurent polynomials f and g, f mod g is the Euclidean remainder (see ) of f modulo g.

As calculating a multivariate Gcd can be expensive, it is not guaranteed that rational functions will always be represented as a quotient of coprime polynomials. In certain unfortunate situations this might lead to a degree explosion. To ensure cancellation you can use on the and values of a given rational function.

All polynomials as well as all the univariate polynomials in the same indeterminate form subrings of this field. If two rational functions are known to be in the same subring, the result will be expressed as element in this subring.

Comparison of Rational Functions comparison f = g

Two rational functions f and g are equal if the product Numerator(f) * Denominator(g) equals Numerator(g) * Denominator(f).

x:=Indeterminate(Rationals,"x");;y:=Indeterminate(Rationals,"y");; gap> f:=3+x*y+x^5;;g:=5+x^2*y+x*y^2;; gap> a:=g/f; (x^2*y+x*y^2+5)/(x^5+x*y+3) gap> b:=(g*f)/(f^2); (x^7*y+x^6*y^2+5*x^5+x^3*y^2+x^2*y^3+3*x^2*y+3*x*y^2+5*x*y+15)/(x^10+2\ *x^6*y+6*x^5+x^2*y^2+6*x*y+9) gap> a=b; true ]]>

smaller f < g

The ordering of rational functions is defined in several steps. Monomials (products of indeterminates) are sorted first by degree, then lexicographically (with x_1>x_2) (see ). Products of monomials with ring elements (terms) are compared first by their monomials and then by their coefficients.

x>y; true gap> x^2*y x*y x^2*y < 5* y*x^2; true ]]> Polynomials are compared by comparing the largest terms in turn until they differ. x+y x Rational functions are compared by comparing the polynomial Numerator(f) * Denominator(g) with the polynomial Numerator(g) * Denominator(f). (As the ordering of monomials used by &GAP; is invariant under multiplication this is independent of common factors in numerator and denominator.) f/g f/g<(g*g)/(f*g); false ]]>

For univariate polynomials this reduces to an ordering first by total degree and then lexicographically on the coefficients.

Properties and Attributes of Rational Functions All these tests are applicable to every rational function. Depending on the internal representation of the rational function, however some of these tests (in particular, univariateness) might be expensive in some cases.

For reasons of performance within algorithms it can be useful to use other attributes, which give a slightly more technical representation. See section  for details. <#Include Label="IsPolynomialFunction"> <#Include Label="NumeratorOfRationalFunction"> <#Include Label="DenominatorOfRationalFunction"> <#Include Label="IsPolynomial"> <#Include Label="AsPolynomial"> <#Include Label="IsUnivariateRationalFunction"> <#Include Label="CoefficientsOfUnivariateRationalFunction"> <#Include Label="IsUnivariatePolynomial"> <#Include Label="CoefficientsOfUnivariatePolynomial"> <#Include Label="IsLaurentPolynomial"> <#Include Label="IsConstantRationalFunction"> <#Include Label="IsPrimitivePolynomial"> <#Include Label="SplittingField">

Univariate Polynomials Some of the operations are actually defined on the larger domain of Laurent polynomials (see ). For this section you can simply ignore the word Laurent if it occurs in a description.

<#Include Label="UnivariatePolynomial"> <#Include Label="UnivariatePolynomialByCoefficients"> <#Include Label="DegreeOfLaurentPolynomial"> <#Include Label="RootsOfPolynomial"> <#Include Label="RootsOfUPol"> <#Include Label="QuotRemLaurpols"> <#Include Label="UnivariatenessTestRationalFunction"> <#Include Label="InfoPoly"> We remark that some functions for multivariate polynomials (which will be defined in the following sections) permit a different syntax for univariate polynomials which drops the requirement to specify the indeterminate. Examples are , , , and : p:=UnivariatePolynomial(Rationals,[1,2,3,4],1); 4*x^3+3*x^2+2*x+1 gap> Value(p,Z(5)); Z(5)^2 gap> LeadingCoefficient(p); 4 gap> Derivative(p); 12*x^2+6*x+2 ]]>

Polynomials as Univariate Polynomials in one Indeterminate <#Include Label="DegreeIndeterminate"> <#Include Label="PolynomialCoefficientsOfPolynomial"> <#Include Label="LeadingCoefficient"> <#Include Label="LeadingMonomial"> <#Include Label="Derivative"> <#Include Label="Discriminant"> <#Include Label="Resultant">
Multivariate Polynomials <#Include Label="Value">
Minimal Polynomials MinimalPolynomial <#Include Label="MinimalPolynomial">
Cyclotomic Polynomials <#Include Label="CyclotomicPolynomial">
Polynomial Factorization At the moment &GAP; provides only methods to factorize polynomials over finite fields (see Chapter ), over subfields of cyclotomic fields (see Chapter ), and over algebraic extensions of these (see Chapter ).

returns a list of the irreducible factors of the polynomial poly in the polynomial ring R. (That is factors over the value of R.)

For univariate factorizations, it is possible to pass a record opt as a third argument. This record can contain the following components: onlydegs is a set of positive integers. The factorization assumes that all irreducible factors have a degree in this set. stopdegs is a set of positive integers. The factorization will stop once a factor of degree in stopdegs has been found and will return the factorization found so far.

f:= CyclotomicPolynomial( GF(2), 7 ); x_1^6+x_1^5+x_1^4+x_1^3+x_1^2+x_1+Z(2)^0 gap> Factors( f ); [ x_1^3+x_1+Z(2)^0, x_1^3+x_1^2+Z(2)^0 ] gap> Factors( PolynomialRing( GF(8) ), f ); [ x_1+Z(2^3), x_1+Z(2^3)^2, x_1+Z(2^3)^3, x_1+Z(2^3)^4, x_1+Z(2^3)^5, x_1+Z(2^3)^6 ] gap> f:= MinimalPolynomial( Rationals, E(4) ); x^2+1 gap> Factors( f ); [ x^2+1 ] gap> Factors( PolynomialRing( Rationals ), f ); [ x^2+1 ] gap> Factors( PolynomialRing( CF(4) ), f ); [ x+(-E(4)), x+E(4) ] ]]> <#Include Label="FactorsSquarefree">

Polynomials over the Rationals The following functions are only available to polynomials with rational coefficients: <#Include Label="PrimitivePolynomial"> <#Include Label="PolynomialModP"> <#Include Label="GaloisType"> <#Include Label="ProbabilityShapes">
Factorization of Polynomials over the Rationals The following operations are used by &GAP; inside the factorization algorithm but might be of interest also in other contexts. <#Include Label="BombieriNorm"> <#Include Label="MinimizedBombieriNorm"> <#Include Label="HenselBound"> <#Include Label="OneFactorBound">
Laurent Polynomials A univariate polynomial can be written in the form r_0 + r_1 x + \cdots + r_n x^n, with r_i \in R. Formally, there is no reason to start with 0, if m is an integer, we can consider objects of the form r_m x^m + r_{{m+1}} x^{{m+1}} + \cdots + r_n x^n. We call these Laurent polynomials. Laurent polynomials also can be considered as quotients of a univariate polynomial by a power of the indeterminate. The addition and multiplication of univariate polynomials extends to Laurent polynomials (though it might be impossible to interpret a Laurent polynomial as a function) and many functions for univariate polynomials extend to Laurent polynomials (or extended versions for Laurent polynomials exist). <#Include Label="LaurentPolynomialByCoefficients"> <#Include Label="CoefficientsOfLaurentPolynomial"> <#Include Label="IndeterminateNumberOfLaurentPolynomial">
Univariate Rational Functions <#Include Label="UnivariateRationalFunctionByCoefficients">
Polynomial Rings and Function Fields While polynomials depend only on the family of the coefficients, polynomial rings A are defined over a base ring R. A polynomial is an element of A if and only if all its coefficients are contained in R. Besides providing domains and an easy way to create polynomials, polynomial rings can affect the behavior of operations like factorization into irreducibles.

If you need to work with a polynomial ring and its indeterminates the following two approaches will produce a ring that contains given variables (see section  for details about the internal numbering): Either, first create the ring and then get the indeterminates with .

r := PolynomialRing(Rationals,["a","b"]);; gap> indets := IndeterminatesOfPolynomialRing(r);; gap> a := indets[1]; a := indets[2]; a b ]]>

Alternatively, first create the indeterminates and then create the ring including these indeterminates.

a:=Indeterminate(Rationals,"a":old);; gap> b:=Indeterminate(Rationals,"b":old);; gap> PolynomialRing(Rationals,[a,b]);; ]]>

As a convenient shortcut, intended mainly for interactive working, the i-th indeterminate of a polynomial ring R can be accessed as R.i, which corresponds exactly to IndeterminatesOfPolynomialRing( R )[i] or, if it has the name nam, as R.nam. Note that the number i is in general not the indeterminate number, but simply an index into the indeterminates list of R.

r := PolynomialRing(Rationals, ["a", "b"]:old );; gap> r.1; r.2; r.a; r.b; a b a b gap> IndeterminateNumberOfLaurentPolynomial(r.1); 3 ]]>

Polynomials as &GAP; objects can exist without a polynomial ring being defined and polynomials cannot be associated to a particular polynomial ring. (For example dividing a polynomial which is in a polynomial ring over the integers by another integer will result in a polynomial over the rationals, not in a rational function over the integers.)

<#Include Label="PolynomialRing"> <#Include Label="IndeterminatesOfPolynomialRing"> <#Include Label="CoefficientsRing"> <#Include Label="IsPolynomialRing"> <#Include Label="IsFiniteFieldPolynomialRing"> <#Include Label="IsAbelianNumberFieldPolynomialRing"> <#Include Label="IsRationalsPolynomialRing"> <#Include Label="FunctionField"> <#Include Label="IsFunctionField">

Univariate Polynomial Rings <#Include Label="UnivariatePolynomialRing"> <#Include Label="IsUnivariatePolynomialRing">
Monomial Orderings It is often desirable to consider the monomials within a polynomial to be arranged with respect to a certain ordering. Such an ordering is called a monomial ordering if it is total, invariant under multiplication with other monomials and admits no infinite descending chains. For details on monomial orderings see .

In &GAP;, monomial orderings are represented by objects that provide a way to compare monomials (as polynomials as well as –for efficiency purposes within algorithms– in the internal representation as lists).

Normally the ordering chosen should be admissible, i.e. it must be compatible with products: If a < b then ca < cb for all monomials a, b and c.

Each monomial ordering provides the two functions and to compare monomials. These functions work as is less than, i.e. they return true if and only if the left argument is smaller.

<#Include Label="IsMonomialOrdering"> <#Include Label="LeadingMonomialOfPolynomial"> <#Include Label="LeadingTermOfPolynomial"> <#Include Label="LeadingCoefficientOfPolynomial"> <#Include Label="MonomialComparisonFunction"> <#Include Label="MonomialExtrepComparisonFun"> <#Include Label="MonomialLexOrdering"> <#Include Label="MonomialGrlexOrdering"> <#Include Label="MonomialGrevlexOrdering"> <#Include Label="EliminationOrdering"> <#Include Label="PolynomialReduction"> <#Include Label="PolynomialReducedRemainder"> <#Include Label="PolynomialDivisionAlgorithm"> <#Include Label="MonomialExtGrlexLess">

Groebner Bases A Groebner Basis of an ideal Ii, in a polynomial ring R, with respect to a monomial ordering, is a set of ideal generators G such that the ideal generated by the leading monomials of all polynomials in G is equal to the ideal generated by the leading monomials of all polynomials in I.

For more details on Groebner bases see . <#Include Label="GroebnerBasis"> <#Include Label="ReducedGroebnerBasis"> <#Include Label="StoredGroebnerBasis"> <#Include Label="InfoGroebner">

Rational Function Families All rational functions defined over a ring lie in the same family, the rational functions family over this ring.

In &GAP; therefore the family of a polynomial depends only on the family of the coefficients, all polynomials whose coefficients lie in the same family are compatible. <#Include Label="RationalFunctionsFamily"> <#Include Label="IsPolynomialFunctionsFamily"> <#Include Label="CoefficientsFamily">

The Representations of Rational Functions &GAP; uses four representations of rational functions: Rational functions given by numerator and denominator, polynomials, univariate rational functions (given by coefficient lists for numerator and denominator and valuation) and Laurent polynomials (given by coefficient list and valuation).

These representations do not necessarily reflect mathematical properties: While an object in the Laurent polynomials representation must be a Laurent polynomial it might turn out that a rational function given by numerator and denominator is actually a Laurent polynomial and the property tests in section  will find this out.

Each representation is associated one or several defining attributes that give an external representation (see ) of the representation in the form of lists and are the defining information that tells a rational function what it is.

&GAP; also implements methods to compute these attributes for rational functions in other representations, provided it would be possible to express an mathematically equal rational function in the representation associated with the attribute. (That is one can always get a numerator/denominator representation of a polynomial while an arbitrary function of course can compute a polynomial representation only if it is a polynomial.)

Therefore these attributes can be thought of as conceptual representations that allow us –as far as possible– to consider an object as a rational function, a polynomial or a Laurent polynomial, regardless of the way it is represented in the computer.

Functions thus usually do not need to care about the representation of a rational function. Depending on its (known in the context or determined) properties, they can access the attribute representing the rational function in the desired way.

Consequentially, methods for rational functions are installed for properties and not for representations.

When creating new rational functions however they must be created in one of the three representations. In most cases this will be the representation for which the conceptual representation in which the calculation was done is the defining attribute.

Iterated operations (like forming the product over a list) therefore will tend to stay in the most suitable representation and the calculation of another conceptual representation (which may be comparatively expensive in certain circumstances) is not necessary.

The Defining Attributes of Rational Functions In general, rational functions are given in terms of monomials. They are represented by lists, using numbers (see ) for the indeterminates.

<#Include Label="[4]{ratfun}"> <#Include Label="[1]{ratfun}">

The attributes that give a representation of a a rational function as a Laurent polynomial are and .

<#Include Label="[2]{ratfun}"> <#Include Label="IsRationalFunctionDefaultRep"> <#Include Label="ExtRepNumeratorRatFun"> <#Include Label="ExtRepDenominatorRatFun"> <#Include Label="ZeroCoefficientRatFun"> <#Include Label="IsPolynomialDefaultRep"> <#Include Label="ExtRepPolynomialRatFun"> <#Include Label="IsLaurentPolynomialDefaultRep">

Creation of Rational Functions <#Include Label="[3]{ratfun}"> <#Include Label="RationalFunctionByExtRep"> <#Include Label="PolynomialByExtRep"> <#Include Label="LaurentPolynomialByExtRep">
Arithmetic for External Representations of Polynomials The following operations are used internally to perform the arithmetic for polynomials in their external representation (see ) as lists.

Functions to perform arithmetic with the coefficient lists of Laurent polynomials are described in Section . <#Include Label="ZippedSum"> <#Include Label="ZippedProduct"> <#Include Label="QuotientPolynomialsExtRep">

Cancellation Tests for Rational Functions The operation can be used to test for common factors of two polynomials. This however would be too expensive to be done in the arithmetic, thus uses the following operations internally to try to keep the denominators as small as possible <#Include Label="RationalFunctionByExtRepWithCancellation"> <#Include Label="TryGcdCancelExtRepPolynomials"> <#Include Label="HeuristicCancelPolynomials">
gap-4r6p5/doc/ref/gappkg.xml0000644000175000017500000001563412172557252014466 0ustar billbill GAP Packages package The functionality of &GAP; can be extended by loading &GAP; packages. &GAP; distribution already contains all currently redistributed with &GAP; packages in the &GAPDIRNAME;/pkg directory.

&GAP; packages are written by (groups of) &GAP; users which may not be members of the &GAP; developer team. The responsibility and copyright of a &GAP; package remains with the original author(s).

&GAP; packages have their own documentation which is smoothly integrated into the &GAP; help system.

All &GAP; users who develop new code are invited to share the results of their efforts with other &GAP; users by making the code and its documentation available in form of a package. Information how to do this is available from the &GAP; Web pages (http://www.gap-system.org) and in the &GAP; package Example (see http://www.gap-system.org/Packages/example.html). There are possibilities to get a package distributed together with &GAP; and it is possible to submit a package to a formal refereeing process.

In this chapter we describe how to use existing packages.

Installing a GAP Package Before a package can be used it must be installed. With a standard installation of &GAP; there should be all currently redistributed with &GAP; packages already available. But since &GAP; packages are released independently of the main &GAP; system it may be sensible to upgrade or install new packages between upgrades of your &GAP; installation.

A package consists of a collection of files within a single directory that must be a subdirectory of the pkg directory in one of the &GAP; root directories, see . (If you don't have access to the pkg directory in your main &GAP; installation you can add private root directories as explained in that section.)

Whenever you get from somewhere an archive of a &GAP; package it should be accompanied with a README file that explains its installation. Some packages just consist of &GAP; code and the installation is done by unpacking the archive in one of the places described above. There are also packages that need further installation steps, there may be for example some external programs which have to be compiled (this is often done by just saying ./configure; make inside the unpacked package directory, but check the individual README files). Note that if you use Windows you may not be able to use some or all external binaries.

Loading a GAP Package automatic loading of GAP packages disable automatic loading Some &GAP; packages are prepared for automatic loading, that is they will be loaded automatically with &GAP;, others must in each case be separately loaded by a call to . <#Include Label="LoadPackage"> <#Include Label="SetPackagePath"> <#Include Label="ExtendRootDirectories"> <#Include Label="DisplayPackageLoadingLog">
Functions for GAP Packages The following functions are mainly used in files contained in a package and not by users of a package. <#Include Label="ReadPackage"> <#Include Label="TestPackageAvailability"> <#Include Label="InstalledPackageVersion"> <#Include Label="DirectoriesPackageLibrary"> <#Include Label="DirectoriesPackagePrograms"> <#Include Label="CompareVersionNumbers"> <#Include Label="IsPackageMarkedForLoading"> <#Include Label="DeclareAutoreadableVariables"> Kernel modules in &GAP; packages gac If the package has a kernel module, then it can be compiled using the gac script. A kernel module is implemented in C and follows certain conventions to comply with the &GAP; kernel interface, which we plan to document later. In the meantime, we advice to get in touch with &GAP; developers if you plan to develop such a package.

To use the gac script to produce dynamically loadable modules, call it with the -d option, for example:

This will produce a file test.so, which then can be loaded into &GAP; with . To load a compiled file, the command is used. This command loads filename as module. If given, the CRC checksum crc must match the value of the module (see ).

LoadDynamicModule("./test.so"); gap> CrcFile("test.so"); 2906458206 gap> LoadDynamicModule("./test.so",1); Error, mismatch (or no support for dynamic loading) called from ( ) called from read-eval-loop Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can 'return;' to continue brk> quit; gap> LoadDynamicModule("./test.so",2906458206); ]]>

On some operating systems, once you have loaded a dynamic module with a certain filename, loading another with the same filename will have no effect, even if the file on disk has changed. The PackageInfo.g File Each package has the file PackageInfo.g which contains meta-information about the package (package name, version, author(s), relations to other packages, homepage, download archives, banner, etc.). This file is used by the package loading mechanism and also for the distribution of a package to other users. <#Include Label="ValidatePackageInfo"> <#Include Label="ShowPackageVariables"> <#Include Label="BibEntry">

gap-4r6p5/doc/ref/string.xml0000644000175000017500000005201412172557252014514 0ustar billbill Strings and Characters
IsChar and IsString type doublequotes singlequotes <#Include Label="IsChar"> <#Include Label="IsString"> Strings As Lists Note that a string is just a special case of a list. So everything that is possible for lists (see ) is also possible for strings. Thus you can access the characters in such a string (see ), test for membership (see ), ask for the length, concatenate strings (see ), form substrings etc. You can even assign to a mutable string (see ). Of course unless you assign a character in such a way that the list stays dense, the resulting list will no longer be a string.

Length( s2 ); 12 gap> s2[2]; 'e' gap> 'a' in s2; false gap> s2[2] := 'a';; s2; "Hallo world." gap> s1{ [1..4] }; "Hell" gap> Concatenation( s1{ [ 1 .. 6 ] }, s1{ [ 1 .. 4 ] } ); "Hello Hell" ]]> Printing Strings If a string is displayed by , for example as result of an evaluation (see ), or by and , it is displayed with enclosing doublequotes. (But note that there is an ambiguity for the empty string which is also an empty list of arbitrary &GAP; objects; it is only printed like a string if it was input as empty string or converted to a string with .) The output of can be read back into &GAP;.

Strings behave differently from other &GAP; objects with respect to , , or . These commands interpret a string in the sense that they essentially send the characters of the string directly to the output stream/file. (But depending on the type of the stream and the presence of some special characters used as hints for line breaks there may be sent some additional newline (or backslash and newline) characters.

s4:= "abc\"def\nghi";; gap> View( s4 ); Print( "\n" ); "abc\"def\nghi" gap> ViewObj( s4 ); Print( "\n" ); "abc\"def\nghi" gap> PrintObj( s4 ); Print( "\n" ); "abc\"def\nghi" gap> Print( s4 ); Print( "\n" ); abc"def ghi gap> s := "German uses strange characters: äöüß\n"; "German uses strange characters: äöüß\n" gap> Print(s); German uses strange characters: äöüß gap> PrintObj(s); Print( "\n" ); "German uses strange characters: \303\244\303\266\303\274\303\237\n" ]]>

s := "\007"; "\007" gap> Print(s); # rings bell in many terminals ]]>

Note that only those line breaks are printed by that are contained in the string (\n characters, see ), as is shown in the example below.

s1; "Hello world." gap> Print( s1 ); Hello world.gap> Print( s1, "\n" ); Hello world. gap> Print( s1, "\nnext line\n" ); Hello world. next line ]]>

Special Characters escaped characters special character sequences There are a number of special character sequences that can be used between the singlequotes of a character literal or between the doublequotes of a string literal to specify characters. They consist of two characters. The first is a backslash \. The second may be any character. If it is an octal digit (from 0 to 7) there must be two more such digits. The meaning is given in the following list

\n newline character. This is the character that, at least on UNIX systems, separates lines in a text file. Printing of this character in a string has the effect of moving the cursor down one line and back to the beginning of the line. \" doublequote character \" doublequote character. Inside a string a doublequote must be escaped by the backslash, because it is otherwise interpreted as end of the string. \' singlequote character \' singlequote character. Inside a character a singlequote must escaped by the backslash, because it is otherwise interpreted as end of the character. \\ backslash character \\ backslash character. Inside a string a backslash must be escaped by another backslash, because it is otherwise interpreted as first character of an escape sequence. \b backspace character \b backspace character. Printing this character should have the effect of moving the cursor back one character. Whether it works or not is system dependent and should not be relied upon. \r carriage return character \r carriage return character. Printing this character should have the effect of moving the cursor back to the beginning of the same line. Whether this works or not is again system dependent. \c flush character \c flush character. This character is not printed. Its purpose is to flush the output queue. Usually &GAP; waits until it sees a newline before it prints a string. If you want to display a string that does not include this character use \c. \XYZ octal character codes \XYZ with X, Y, Z three octal digits. This is translated to the character corresponding to the number X * 64 + Y * 8 + Z modulo 256. This can be used to specify and store arbitrary binary data as a string in &GAP;. escaping non-special characters other For any other character the backslash is simply ignored.

Again, if the line is displayed as result of an evaluation, those escape sequences are displayed in the same way that they are input.

Only , , or send the characters directly to the output stream.

"This is one line.\nThis is another line.\n"; "This is one line.\nThis is another line.\n" gap> Print( last ); This is one line. This is another line. ]]>

Note in particular that it is not allowed to enclose a newline inside the string. You can use the special character sequence \n to write strings that include newline characters. If, however, an input string is too long to fit on a single line it is possible to continue it over several lines. In this case the last character of each input line, except the last line must be a backslash. Both backslash and newline are thrown away by &GAP; while reading the string. Note that the same continuation mechanism is available for identifiers and integers, see .

Internally Represented Strings convert <#Include Label="IsStringRep"> <#Include Label="ConvertToStringRep"> <#Include Label="IsEmptyString"> a string nothing The function returns an empty string in internal representation which has enough memory allocated for len characters. This can be useful for creating and filling a string with a known number of entries.

The function gives back to &GAP;s memory manager the physical memory which is allocated for the string str in internal representation but not needed by its current number of characters.

These functions are intended for saving some of &GAP;s memory in certain situations, see the explanations and the example for the analogeous functions and for plain lists. <#Include Label="CharsFamily">

Recognizing Characters <#Include Label="IsDigitChar"> <#Include Label="IsLowerAlphaChar"> <#Include Label="IsUpperAlphaChar"> <#Include Label="IsAlphaChar">
Comparisons of Strings strings strings The equality operator = returns true if the two strings string1 and string2 are equal and false otherwise. The inequality operator <> returns true if the two strings string1 and string2 are not equal and false otherwise.

"Hello world.\n" = "Hello world.\n"; true gap> "Hello World.\n" = "Hello world.\n"; # comparison is case sensitive false gap> "Hello world." = "Hello world.\n"; # first string has no false gap> "Goodbye world.\n" = "Hello world.\n"; false gap> [ 'a', 'b' ] = "ab"; true ]]> strings The ordering of strings is lexicographically according to the order implied by the underlying, system dependent, character set.

"Hello world.\n" < "Hello world.\n"; # the strings are equal false gap> # in ASCII capitals range before small letters: gap> "Hello World." < "Hello world."; true gap> "Hello world." < "Hello world.\n"; # prefixes are always smaller true gap> # G comes before H, in ASCII at least: gap> "Goodbye world.\n" < "Hello world.\n"; true ]]>

Strings can be compared via < with certain &GAP; objects that are not strings, see  for the details.

Operations to Produce or Manipulate Strings For the possibility to print &GAP; objects to strings, see . <#Include Label="DisplayString"> This is the default value for . <#Include Label="ViewString"> This is the default value for . <#Include Label="PrintString"> <#Include Label="String"> <#Include Label="StripLineBreakCharacters"> returns a string which represents the integer int with hexa-decimal digits (using A to F as digits 10 to 15). The inverse translation can be achieved with . <#Include Label="StringPP"> <#Include Label="WordAlp"> <#Include Label="LowercaseString"> <#Include Label="SplitString"> <#Include Label="ReplacedString"> This function changes the string string in place. The characters (space), \n, \r and \t are considered as white space. Leading and trailing white space characters in string are removed. Sequences of white space characters between other characters are replaced by a single space character.

See for a non-destructive version. s := " x y \n\n\t\r z\n \n"; " x y \n\n\t\r z\n \n" gap> NormalizeWhitespace(s); gap> s; "x y z" ]]> <#Include Label="NormalizedWhitespace"> Both arguments must be strings. This function efficiently removes all characters given in chars from string. gap> s := "ab c\ndef\n\ng h i .\n"; "ab c\ndef\n\ng h i .\n" gap> RemoveCharacters(s, " \n\t\r"); # remove all whitespace characters gap> s; "abcdefghi." <#Include Label="JoinStringsWithSeparator"> <#Include Label="Chomp"> The following two functions convert basic strings to lists of numbers and vice versa. They are useful for examples of text encryption. <#Include Label="NumbersString"> <#Include Label="StringNumbers">

Character Conversion The following functions convert characters in their internal integer values and vice versa. Note that the number corresponding to a particular character might depend on the system used. While most systems use an extension of ASCII, in particular character values outside the range [ 32 .. 126 ] might differ between architectures.

returns an integer value in the range [ 0 .. 255 ] that corresponds to char. returns a character that corresponds to the integer value int, which must be in the range [ 0 .. 255 ].

c:=CharInt(65); 'A' gap> IntChar(c); 65 ]]> returns a signed integer value in the range [ -128 .. 127 ] that corresponds to char. returns a character which corresponds to the signed integer value int, which must be in the range [ -128 .. 127 ].

The signed and unsigned integer functions behave the same for values in the range [ 0 .. 127 ].

SIntChar(c); 65 gap> c:=CharSInt(-20);; gap> SIntChar(c); -20 gap> IntChar(c); 236 gap> SIntChar(CharInt(255)); -1 ]]>

Operations to Evaluate Strings evaluation return either an integer ( and ), or a rational () as represented by the string str. returns fail if non-digit characters occur in str. For , the argument string may start with the sign character -, followed by either a sequence of digits or by two sequences of digits that are separated by one of the characters / or ., where the latter stands for a decimal dot. (The methods only evaluate numbers but do not perform arithmetic!)

evaluates an integer written with hexa-decimal digits. Here the letters a-f or A-F are used as digits 10 to 15. An error occurs when a wrong character is found in the string. This function can be used (together with ) for efficiently storing and reading large integers from respectively into &GAP;. Note that the translation between integers and their hexa-decimal representation costs linear computation time in terms of the number of digits, while translation from and into decimal representation needs substantial computations. If str is not in compact string representation then is applied to it as side effect.

Int("12345")+1; 12346 gap> Int("123/45"); fail gap> Int("1+2"); fail gap> Int("-12"); -12 gap> Rat("123/45"); 41/15 gap> Rat( "123.45" ); 2469/20 gap> IntHexString("-abcdef0123456789"); -12379813738877118345 gap> HexStringInt(last); "-ABCDEF0123456789" ]]> <#Include Label="Ordinal"> <#Include Label="EvalString"> <#Include Label="CrcString">

Calendar Arithmetic <#Include Label="[2]{string}"> <#Include Label="DaysInYear"> <#Include Label="DaysInMonth"> <#Include Label="DMYDay"> <#Include Label="DayDMY"> <#Include Label="WeekDay"> <#Include Label="StringDate"> <#Include Label="HMSMSec"> <#Include Label="SecHMSM"> <#Include Label="StringTime"> <#Include Label="SecondsDMYhms"> <#Include Label="DMYhmsSeconds">
Obtaining LaTeX Representations of Objects LaTeX For the purpose of generating &LaTeX; source code with &GAP; it is recommended to add new functions which will print the &LaTeX; source or return &LaTeX; strings for further processing.

An alternative approach could be based on methods for the default &LaTeX; representation for each appropriate type of objects. However, there is no clear notion of a default &LaTeX; code for any non-trivial mathematical object; moreover, different output may be required in different contexts.

While customisation of such an operation may require changes in a variety of methods that may be distributed all over the library, the user will have a clean overview of the whole process of &LaTeX; code generation if it is contained in a single function. Furthermore, there may be kinds of objects which are not detected by the method selection, or there may be a need in additional parameters specifying requirements for the output.

This is why having a special purpose function for each particular case is more suitable. &GAP; provides several functions that produce &LaTeX; strings for those situations where this is nontrivial and reasonable. A useful example is from the &GAP; library, others can be found entering ?LaTeX at the &GAP; prompt. Package authors are encouraged to add an index entry LaTeX to the documentation of all &LaTeX; string producing functions. This way, entering ?LaTeX will give an overview of all documented functionality in this direction.

gap-4r6p5/doc/ref/coll.xml0000644000175000017500000001050112172557252014132 0ustar billbill Collections <#Include Label="[1]{coll}">
IsCollection (Filter) <#Include Label="IsCollection">
Collection Families <#Include Label="CollectionsFamily"> <#Include Label="IsCollectionFamily"> <#Include Label="ElementsFamily"> <#Include Label="CategoryCollections">
Lists and Collections Sorted Lists as Collections The following functions take a list or collection as argument, and return a corresponding list. They differ in whether or not the result is mutable or immutable (see ), guaranteed to be sorted, or guaranteed to admit list access in constant time (see ). <#Include Label="IsListOrCollection"> <#Include Label="Enumerator"> <#Include Label="EnumeratorSorted"> <#Include Label="EnumeratorByFunctions"> <#Include Label="List:coll"> <#Include Label="SortedList"> <#Include Label="SSortedList"> <#Include Label="AsList"> <#Include Label="AsSortedList"> <#Include Label="AsSSortedList"> <#Include Label="Elements">
Attributes and Properties for Collections <#Include Label="IsEmpty"> <#Include Label="IsFinite"> <#Include Label="IsTrivial"> <#Include Label="IsNonTrivial"> <#Include Label="IsWholeFamily"> <#Include Label="Size"> <#Include Label="Representative"> <#Include Label="RepresentativeSmallest">
Operations for Collections <#Include Label="IsSubset"> <#Include Label="Intersection"> <#Include Label="Union"> <#Include Label="Difference">
Membership Test for Collections \in in returns true if the object obj lies in the collection C, and false otherwise.

The infix version of the command

obj in C

calls the operation , for which methods can be installed.

13 in Integers; [ 1, 2 ] in Integers; true false gap> g:= Group( (1,2) );; (1,2) in g; (1,2,3) in g; true false ]]>

Random Elements <#Include Label="[2]{coll}"> <#Include Label="Random:coll"> <#Include Label="PseudoRandom"> <#Include Label="RandomList">
Iterators <#Include Label="Iterator"> <#Include Label="IteratorSorted"> <#Include Label="IsIterator"> <#Include Label="IsDoneIterator"> <#Include Label="NextIterator"> <#Include Label="IteratorList"> <#Include Label="TrivialIterator"> <#Include Label="IteratorByFunctions">
gap-4r6p5/doc/ref/files.xml0000644000175000017500000004340312172557252014312 0ustar billbill Files and Filenames Files are identified by filenames, which are represented in &GAP; as strings. Filenames can be created directly by the user or a program, but of course this is operating system dependent.

Filenames for some files can be constructed in a system independent way using the following functions. This is done by first getting a directory object for the directory the file shall reside in, and then constructing the filename. However, it is sometimes necessary to construct filenames of files in subdirectories relative to a given directory object. In this case the directory separator is always / even under DOS or MacOS.

Section describes how to construct directory objects for the common &GAP; and system directories. Using the command it is possible to construct a filename pointing to a file in these directories. There are also functions to test for accessibility of files, see .

Portability For portability filenames and directory names should be restricted to at most 8 alphanumerical characters optionally followed by a dot . and between 1 and 3 alphanumerical characters. Upper case letters should be avoided because some operating systems do not make any distinction between case, so that NaMe, Name and name all refer to the same file whereas some operating systems are case sensitive. To avoid problems only lower case characters should be used.

Another function which is system-dependent is . returns a record describing the last system error that has occurred. This record contains at least the component message which is a string. This message is, however, highly operating system dependent and should only be used as an informational message for the user.

GAP Root Directories GAPInfo.RootPaths GAPInfo.UserGapRoot When &GAP; is started it determines a list of directories which we call the &GAP; root directories. In a running &GAP; session this list can be found in GAPInfo.RootPaths.

The core part of &GAP; knows which files to read relative to its root directories. For example when &GAP; wants to read its library file lib/group.gd, it appends this path to each path in GAPInfo.RootPaths until it finds the path of an existing file. The first file found this way is read.

Furthermore, &GAP; looks for available packages by examining the subdirectories pkg/ in each of the directories in GAPInfo.RootPaths.

The root directories are specified via one or several of the -l paths command line options, see . Furthermore, by default &GAP; automatically prepends a user specific &GAP; root directory to the list; this can be avoided by calling &GAP; with the -r option. The name of this user specific directory depends on your operating system, it can be found in GAPInfo.UserGapRoot. This directory can be used to tell &GAP; about personal preferences, to always load some additional code, to install additional packages, or to overwrite some &GAP; files. See for more information how to do this.

Directories <#Include Label="IsDirectory"> <#Include Label="Directory"> <#Include Label="DirectoryTemporary"> <#Include Label="DirectoryCurrent"> <#Include Label="DirectoriesLibrary"> <#Include Label="DirectoriesSystemPrograms"> <#Include Label="DirectoryContents"> <#Include Label="DirectoryDesktop"> <#Include Label="DirectoryHome">
File Names <#Include Label="Filename">
Special Filenames The special filename "*stdin*" denotes the standard input, i.e., the stream through which the user enters commands to &GAP;. The exact behaviour of reading from "*stdin*" is operating system dependent, but usually the following happens. If &GAP; was started with no input redirection, statements are read from the terminal stream until the user enters the end of file character, which is usually Ctrl-D. Note that terminal streams are special, in that they may yield ordinary input after an end of file. Thus when control returns to the main read-eval-print loop the user can continue with &GAP;. If &GAP; was started with an input redirection, statements are read from the current position in the input file up to the end of the file. When control returns to the main read eval view loop the input stream will still return end of file, and &GAP; will terminate.

The special filename "*errin*" denotes the stream connected to the UNIX stderr output. This stream is usually connected to the terminal, even if the standard input was redirected, unless the standard error stream was also redirected, in which case opening of "*errin*" fails.

The special filename "*stdout*" can be used to print to the standard output.

The special filename "*errout*" can be used to print to the standard error output file, which is usually connected to the terminal, even if the standard output was redirected.

File Access When the following functions return false one can use to find out the reason (as provided by the operating system), see the examples. returns true if a file with the filename name-file exists and can be seen by the &GAP; process. Otherwise false is returned.

IsExistingFile( "/bin/date" ); # file `/bin/date' exists true gap> IsExistingFile( "/bin/date.new" ); # non existing `/bin/date.new' false gap> IsExistingFile( "/bin/date/new" ); # `/bin/date' is not a directory false gap> LastSystemError().message; "Not a directory" ]]> returns true if a file with the filename name-file exists and the &GAP; process has read permissions for the file, or false if this is not the case.

IsReadableFile( "/bin/date" ); # file `/bin/date' is readable true gap> IsReadableFile( "/bin/date.new" ); # non-existing `/bin/date.new' false gap> LastSystemError().message; "No such file or directory" ]]> returns true if a file with the filename name-file exists and the &GAP; process has write permissions for the file, or false if this is not the case.

IsWritableFile( "/bin/date" ); # file `/bin/date' is not writable false ]]>

returns true if a file with the filename name-file exists and the &GAP; process has execute permissions for the file, or false if this is not the case. Note that execute permissions do not imply that it is possible to execute the file, e.g., it may only be executable on a different machine.

IsExecutableFile( "/bin/date" ); # ... but executable true ]]> returns true if the file with the filename name-file exists and is a directory, and false otherwise. Note that this function does not check if the &GAP; process actually has write or execute permissions for the directory. You can use , resp. to check such permissions.

File Operations <#Include Label="Read"> <#Include Label="ReadAsFunction"> PrintTo and AppendTo works like , except that the arguments obj1, \ldots (if present) are printed to the file with the name name-file instead of the standard output. This file must of course be writable by &GAP;. Otherwise an error is signalled. Note that will overwrite the previous contents of this file if it already existed; in particular, with just the name-file argument empties that file.

works like , except that the output does not overwrite the previous contents of the file, but is appended to the file.

There is an upper limit of 15 on the number of output files that may be open simultaneously.

Note that one should be careful not to write to a logfile (see ) with or . LogTo Calling with a string name-file causes the subsequent interaction to be logged to the file with the name name-file, i.e., everything you see on your terminal will also appear in this file. ( may also be used to log to a stream.) This file must of course be writable by &GAP;, otherwise an error is signalled. Note that will overwrite the previous contents of this file if it already existed.

Called without arguments, stops logging to a file or stream. InputLogTo Calling with a string name-file causes the subsequent input to be logged to the file with the name name-file, i.e., everything you type on your terminal will also appear in this file. Note that and cannot be used at the same time while and can. Note that will overwrite the previous contents of this file if it already existed.

Called without arguments, stops logging to a file or stream. OutputLogTo Calling with a string name-file causes the subsequent output to be logged to the file with the name name-file, i.e., everything &GAP; prints on your terminal will also appear in this file. Note that and cannot be used at the same time while and can. Note that will overwrite the previous contents of this file if it already existed.

Called without arguments, stops logging to a file or stream. <#Include Label="CrcFile"> will remove the file with filename name-file and returns true in case of success. The function returns fail if a system error occurred, for example, if your permissions do not allow the removal of name-file. In this case the function can be used to get information about the error. <#Include Label="Reread">

gap-4r6p5/doc/ref/groups.xml0000644000175000017500000004747412172557252014543 0ustar billbill Groups This chapter explains how to create groups and defines operations for groups, that is operations whose definition does not depend on the representation used. However methods for these operations in most cases will make use of the representation.

If not otherwise specified, in all examples in this chapter the group g will be the symmetric group S_4 acting on the letters \{ 1, \ldots, 4 \}.

Group Elements Groups in &GAP; are written multiplicatively. The elements from which a group can be generated must permit multiplication and multiplicative inversion (see ).

a:=(1,2,3);;b:=(2,3,4);; gap> One(a); () gap> Inverse(b); (2,4,3) gap> a*b; (1,3)(2,4) gap> Order(a*b); 2 gap> Order( [ [ 1, 1 ], [ 0, 1 ] ] ); infinity ]]>

The next example may run into an infinite loop because the given matrix in fact has infinite order.

Order( [ [ 1, 1 ], [ 0, 1 ] ] * Indeterminate( Rationals ) ); #I Order: warning, order of might be infinite ]]>

order Since groups are domains, the recommended command to compute the order of a group is . For convenience, group orders can also be computed with .

The operation can be used to compute the commutator of two elements, the operation computes the product x^{{-1}} y.

Creating Groups When groups are created from generators, this means that the generators must be elements that can be multiplied and inverted (see also ). For creating a free group on a set of symbols, see . <#Include Label="Group"> <#Include Label="GroupByGenerators"> <#Include Label="GroupWithGenerators"> <#Include Label="GeneratorsOfGroup"> <#Include Label="AsGroup"> <#Include Label="ConjugateGroup"> <#Include Label="IsGroup"> <#Include Label="InfoGroup">
Subgroups For the general concept of parents and subdomains, see  and . More functions that construct certain subgroups can be found in the sections , , , and .

<#Include Label="[2]{grp}"> <#Include Label="Subgroup"> <#Include Label="Index"> <#Include Label="IndexInWholeGroup"> freegp:=FreeGroup(1);; gap> freesub:=Subgroup(freegp,[freegp.1^5]);; gap> IndexInWholeGroup(freesub); 5 ]]> <#Include Label="AsSubgroup"> <#Include Label="IsSubgroup"> <#Include Label="IsNormal"> <#Include Label="IsCharacteristicSubgroup"> <#Include Label="ConjugateSubgroup"> <#Include Label="ConjugateSubgroups"> <#Include Label="IsSubnormal"> <#Include Label="SubgroupByProperty"> <#Include Label="SubgroupShell">

Closures of (Sub)groups <#Include Label="ClosureGroup"> <#Include Label="ClosureGroupAddElm"> <#Include Label="ClosureGroupDefault"> <#Include Label="ClosureSubgroup">
Expressing Group Elements as Words in Generators factorization words Using homomorphisms (see chapter ) is is possible to express group elements as words in given generators: Create a free group (see ) on the correct number of generators and create a homomorphism from this free group onto the group G in whose generators you want to factorize. Then the preimage of an element of G is a word in the free generators, that will map on this element again.

<#Include Label="EpimorphismFromFreeGroup"> <#Include Label="Factorization">

Structure Descriptions <#Include Label="StructureDescription">
Cosets right cosets coset <#Include Label="RightCoset"> <#Include Label="RightCosets"> <#Include Label="CanonicalRightCosetElement"> <#Include Label="IsRightCoset"> <#Include Label="CosetDecomposition">
Transversals <#Include Label="RightTransversal">
Double Cosets <#Include Label="DoubleCoset"> <#Include Label="RepresentativesContainedRightCosets"> <#Include Label="DoubleCosets"> <#Include Label="IsDoubleCoset"> <#Include Label="DoubleCosetRepsAndSizes"> <#Include Label="InfoCoset">
Conjugacy Classes <#Include Label="ConjugacyClass"> <#Include Label="ConjugacyClasses:grp"> <#Include Label="ConjugacyClassesByRandomSearch"> <#Include Label="ConjugacyClassesByOrbits"> <#Include Label="NrConjugacyClasses"> <#Include Label="RationalClass"> <#Include Label="RationalClasses"> <#Include Label="GaloisGroup:clas"> <#Include Label="IsConjugate"> <#Include Label="NthRootsInGroup">
Normal Structure For the operations and , see Chapter . normalizer <#Include Label="Normalizer"> <#Include Label="Core"> <#Include Label="PCore"> <#Include Label="NormalClosure"> <#Include Label="NormalIntersection"> <#Include Label="ComplementClassesRepresentatives"> <#Include Label="InfoComplement">
Specific and Parametrized Subgroups The centre of a group (the subgroup of those elements that commute with all other elements of the group) can be computed by the operation . <#Include Label="TrivialSubgroup"> <#Include Label="CommutatorSubgroup"> <#Include Label="DerivedSubgroup"> <#Include Label="CommutatorLength"> <#Include Label="FittingSubgroup"> <#Include Label="FrattiniSubgroup"> <#Include Label="PrefrattiniSubgroup"> <#Include Label="PerfectResiduum"> <#Include Label="RadicalGroup"> <#Include Label="Socle"> <#Include Label="SupersolvableResiduum"> <#Include Label="PRump">
Sylow Subgroups and Hall Subgroups With respect to the following &GAP; functions, please note that by theorems of P. Hall, a group G is solvable if and only if one of the following conditions holds. For each prime p dividing the order of G, there exists a p-complement (see ). For each set P of primes dividing the order of G, there exists a P-Hall subgroup (see ). G has a Sylow system (see ). G has a complement system (see ). <#Include Label="SylowSubgroup"> <#Include Label="SylowComplement"> <#Include Label="HallSubgroup"> <#Include Label="SylowSystem"> <#Include Label="ComplementSystem"> <#Include Label="HallSystem">
Subgroups characterized by prime powers <#Include Label="Omega"> <#Include Label="Agemo">
Group Properties Some properties of groups can be defined not only for groups but also for other structures. For example, nilpotency and solvability make sense also for algebras. Note that these names refer to different definitions for groups and algebras, contrary to the situation with finiteness or commutativity. In such cases, the name of the function for groups got a suffix Group to distinguish different meanings for different structures.

Some functions, such as and , although they are mathematical properties, are not properties in the sense of &GAP; (see  and ), as they depend on a parameter. <#Include Label="IsCyclic"> <#Include Label="IsElementaryAbelian"> <#Include Label="IsNilpotentGroup"> <#Include Label="NilpotencyClassOfGroup"> <#Include Label="IsPerfectGroup"> <#Include Label="IsSolvableGroup"> <#Include Label="IsPolycyclicGroup"> <#Include Label="IsSupersolvableGroup"> <#Include Label="IsMonomialGroup"> <#Include Label="IsSimpleGroup"> <#Include Label="IsAlmostSimpleGroup"> <#Include Label="IsomorphismTypeInfoFiniteSimpleGroup"> <#Include Label="SimpleGroup"> <#Include Label="SimpleGroupsIterator"> <#Include Label="SmallSimpleGroup"> <#Include Label="AllSmallNonabelianSimpleGroups"> <#Include Label="IsFinitelyGeneratedGroup"> <#Include Label="IsSubsetLocallyFiniteGroup"> <#Include Label="IsPGroup"> <#Include Label="PrimePGroup"> <#Include Label="PClassPGroup"> <#Include Label="RankPGroup"> <#Include Label="IsPSolvable"> <#Include Label="IsPNilpotent">

Numerical Group Attributes This section gives only some examples of numerical group attributes, so it should not serve as a collection of all numerical group attributes. The manual contains more such attributes documented in this manual, for example, , and others.

Note also that some functions, such as , are mathematical attributes, but not &GAP; attributes (see ) as they are depending on a parameter. <#Include Label="AbelianInvariants:grp"> <#Include Label="Exponent"> <#Include Label="EulerianFunction">

Subgroup Series In group theory many subgroup series are considered, and &GAP; provides commands to compute them. In the following sections, there is always a series G = U_1 > U_2 > \cdots > U_m = \langle 1 \rangle of subgroups considered. A series also may stop without reaching G or \langle 1 \rangle.

A series is called subnormal if every U_{{i+1}} is normal in U_i.

A series is called normal if every U_i is normal in G.

A series of normal subgroups is called central if U_i/U_{{i+1}} is central in G / U_{{i+1}}.

We call a series refinable if intermediate subgroups can be added to the series without destroying the properties of the series.

<#Include Label="[1]{grp}"> <#Include Label="ChiefSeries"> <#Include Label="ChiefSeriesThrough"> <#Include Label="ChiefSeriesUnderAction"> <#Include Label="SubnormalSeries"> <#Include Label="CompositionSeries"> <#Include Label="DisplayCompositionSeries"> <#Include Label="DerivedSeriesOfGroup"> <#Include Label="DerivedLength"> <#Include Label="ElementaryAbelianSeries"> <#Include Label="InvariantElementaryAbelianSeries"> <#Include Label="LowerCentralSeriesOfGroup"> <#Include Label="UpperCentralSeriesOfGroup"> <#Include Label="PCentralSeries"> <#Include Label="JenningsSeries"> <#Include Label="DimensionsLoewyFactors"> <#Include Label="AscendingChain"> <#Include Label="IntermediateGroup"> <#Include Label="IntermediateSubgroups">

Factor Groups <#Include Label="NaturalHomomorphismByNormalSubgroup"> <#Include Label="FactorGroup"> <#Include Label="CommutatorFactorGroup"> <#Include Label="MaximalAbelianQuotient"> <#Include Label="HasAbelianFactorGroup"> <#Include Label="HasElementaryAbelianFactorGroup"> <#Include Label="CentralizerModulo">
Sets of Subgroups <#Include Label="ConjugacyClassSubgroups"> <#Include Label="IsConjugacyClassSubgroupsRep"> <#Include Label="ConjugacyClassesSubgroups"> <#Include Label="ConjugacyClassesMaximalSubgroups"> <#Include Label="AllSubgroups"> <#Include Label="MaximalSubgroupClassReps"> <#Include Label="MaximalSubgroups"> <#Include Label="NormalSubgroups"> <#Include Label="MaximalNormalSubgroups"> <#Include Label="MinimalNormalSubgroups">
Subgroup Lattice <#Include Label="LatticeSubgroups"> <#Include Label="ClassElementLattice"> <#Include Label="DotFileLatticeSubgroups"> <#Include Label="MaximalSubgroupsLattice"> <#Include Label="MinimalSupergroupsLattice"> <#Include Label="RepresentativesPerfectSubgroups"> <#Include Label="ConjugacyClassesPerfectSubgroups"> <#Include Label="Zuppos"> <#Include Label="InfoLattice">
Specific Methods for Subgroup Lattice Computations <#Include Label="LatticeByCyclicExtension"> <#Include Label="InvariantSubgroupsElementaryAbelianGroup"> <#Include Label="SubgroupsSolvableGroup"> <#Include Label="SizeConsiderFunction"> <#Include Label="ExactSizeConsiderFunction"> <#Include Label="InfoPcSubgroup">
Special Generating Sets <#Include Label="GeneratorsSmallest"> <#Include Label="LargestElementGroup"> <#Include Label="MinimalGeneratingSet"> <#Include Label="SmallGeneratingSet"> <#Include Label="IndependentGeneratorsOfAbelianGroup"> <#Include Label="IndependentGeneratorExponents">
1-Cohomology one cohomology cohomology cocycles Let G be a finite group and M an elementary abelian normal p-subgroup of G. Then the group of 1-cocycles Z^1( G/M, M ) is defined as Z^1(G/M, M) = \{ \gamma: G/M \rightarrow M \mid \forall g_1, g_2 \in G : \gamma(g_1 M \cdot g_2 M ) = \gamma(g_1 M)^{{g_2}} \cdot \gamma(g_2 M) \} and is a GF(p)-vector space.

The group of 1-coboundaries B^1( G/M, M ) is defined as B^1(G/M, M) = \{ \gamma : G/M \rightarrow M \mid \exists m \in M \forall g \in G : \gamma(gM) = (m^{{-1}})^g \cdot m \} It also is a GF(p)-vector space.

Let \alpha be the isomorphism of M into a row vector space {\cal W} and (g_1, \ldots, g_l) representatives for a generating set of G/M. Then there exists a monomorphism \beta of Z^1( G/M, M ) in the l-fold direct sum of {\cal W}, such that \beta( \gamma ) = ( \alpha( \gamma(g_1 M) ),\ldots, \alpha( \gamma(g_l M) ) ) for every \gamma \in Z^1( G/M, M ). <#Include Label="OneCocycles"> <#Include Label="OneCoboundaries"> <#Include Label="OCOneCocycles"> <#Include Label="ComplementClassesRepresentativesEA"> <#Include Label="InfoCoh">

Schur Covers and Multipliers Additional attributes and properties of a group can be derived from computing its Schur cover. For example, if G is a finitely presented group, the derived subgroup of a Schur cover of G is invariant and isomorphic to the value of G, see . Darstellungsgruppe <#Include Label="EpimorphismSchurCover"> <#Include Label="SchurCover"> <#Include Label="AbelianInvariantsMultiplier"> <#Include Label="Epicentre"> <#Include Label="NonabelianExteriorSquare"> <#Include Label="EpimorphismNonabelianExteriorSquare"> <#Include Label="IsCentralFactor"> <#Include Label="{SchurCoversOfSymmetricGroup}">
Tests for the Availability of Methods <#Include Label="[3]{grp}"> <#Include Label="CanEasilyTestMembership"> <#Include Label="CanEasilyComputeWithIndependentGensAbelianGroup"> <#Include Label="CanComputeSize"> <#Include Label="CanComputeSizeAnySubgroup"> <#Include Label="CanComputeIndex"> <#Include Label="CanComputeIsSubset"> <#Include Label="KnowsHowToDecompose">
gap-4r6p5/doc/ref/integers.xml0000644000175000017500000001340212172557252015024 0ustar billbill Integers One of the most fundamental datatypes in every programming language is the integer type. &GAP; is no exception.

&GAP; integers are entered as a sequence of decimal digits optionally preceded by a + sign for positive integers or a - sign for negative integers. The size of integers in &GAP; is only limited by the amount of available memory, so you can compute with integers having thousands of digits.

-1234; -1234 gap> 123456789012345678901234567890123456789012345678901234567890; 123456789012345678901234567890123456789012345678901234567890 ]]>

Many more functions that are mainly related to the prime residue group of integers modulo an integer are described in chapter , and functions dealing with combinatorics can be found in chapter .

Integers: Global Variables <#Include Label="IntegersGlobalVars"> <#Include Label="IsIntegers">
Elementary Operations for Integers <#Include Label="IsInt"> <#Include Label="IsPosInt"> <#Include Label="Int"> <#Include Label="IsEvenInt"> <#Include Label="IsOddInt"> <#Include Label="AbsInt"> <#Include Label="SignInt"> <#Include Label="LogInt"> <#Include Label="RootInt"> <#Include Label="SmallestRootInt"> <#Include Label="ListOfDigits"> for integers returns pseudo random integers between -10 and 10 distributed according to a binomial distribution. To generate uniformly distributed integers from a range, use the construction Random( [ low .. high ] )  (see ).
Quotients and Remainders <#Include Label="QuoInt"> <#Include Label="BestQuoInt"> <#Include Label="RemInt"> <#Include Label="GcdInt"> <#Include Label="Gcdex"> <#Include Label="LcmInt"> <#Include Label="CoefficientsQadic"> <#Include Label="CoefficientsMultiadic"> <#Include Label="ChineseRem"> <#Include Label="PowerModInt">
Prime Integers and Factorization <#Include Label="Primes"> <#Include Label="IsPrimeInt"> <#Include Label="PrimalityProof"> <#Include Label="IsPrimePowerInt"> <#Include Label="NextPrimeInt"> <#Include Label="PrevPrimeInt"> <#Include Label="FactorsInt"> <#Include Label="PrimeDivisors"> <#Include Label="PartialFactorization"> <#Include Label="PrintFactorsInt"> <#Include Label="PrimePowersInt"> <#Include Label="DivisorsInt">
Residue Class Rings mod modulo returns a residue class ring of modulo an ideal. These residue class rings are rings, thus all operations for rings (see Chapter ) apply. See also Chapters  and . If r, s and n are integers, r / s as a reduced fraction is p/q, where q and n are coprime, then r / s mod n is defined to be the product of p and the inverse of q modulo n. See Section  for more details and definitions.

With the above definition, 4 / 6 mod 32 equals 2 / 3 mod 32 and hence exists (and is equal to 22), despite the fact that 6 has no inverse modulo 32. <#Include Label="ZmodnZ"> <#Include Label="ZmodnZObj"> <#Include Label="IsZmodnZObj">

Check Digits <#Include Label="CheckDigitISBN"> <#Include Label="CheckDigitTestFunction">
Random Sources &GAP; provides methods for many collections of objects. On a lower level these methods use random sources which provide random integers and random choices from lists. <#Include Label="IsRandomSource"> <#Include Label="Random"> <#Include Label="State"> <#Include Label="IsGlobalRandomSource"> <#Include Label="RandomSource">
gap-4r6p5/doc/ref/numtheor.xml0000644000175000017500000000517512172557252015055 0ustar billbill Number Theory prime residue group <#Include Label="[1]{numtheor}">
InfoNumtheor (Info Class) <#Include Label="InfoNumtheor">
Prime Residues prime residue group <#Include Label="PrimeResidues"> <#Include Label="Phi"> <#Include Label="Lambda"> <#Include Label="GeneratorsPrimeResidues">
Primitive Roots and Discrete Logarithms <#Include Label="OrderMod"> <#Include Label="LogMod"> <#Include Label="PrimitiveRootMod"> <#Include Label="IsPrimitiveRootMod">
Roots Modulo Integers <#Include Label="Jacobi"> <#Include Label="Legendre"> <#Include Label="RootMod"> <#Include Label="RootsMod"> <#Include Label="RootsUnityMod">
Multiplicative Arithmetic Functions <#Include Label="Sigma"> <#Include Label="Tau"> <#Include Label="MoebiusMu">
Continued Fractions <#Include Label="ContinuedFractionExpansionOfRoot"> <#Include Label="ContinuedFractionApproximationOfRoot">
Miscellaneous <#Include Label="TwoSquares">
gap-4r6p5/doc/ref/help.xml0000644000175000017500000003141612172557252014141 0ustar billbill The Help System This chapter describes the &GAP; help system. The help system lets you read the documentation interactively.
Invoking the Help The basic command to read &GAP;'s documentation from within a &GAP; session is as follows.

getting help ?[book:][?]topic

For an explanation and some examples see .

Note that the first question mark must appear in the first position after the gap> prompt. The search strings book and topic are normalized in a certain way (see the end of this section for details) before the search starts. This makes the search case insensitive and there can be arbitrary white space after the first question mark.

When there are several manual sections that match the query a numbered list of topics is displayed. These matches can be accessed with ?number.

There are some further specially handled commands which start with a question mark. They are explained in Section .

By default &GAP; shows the help sections as text in the terminal (window), page by page if the shown text does not fit on the screen. But there are several other choices to read (other formats of) the documents: via a viewer for pdf files or via a web browser. This is explained below in Section .

Details of the string normalization process

Here is a precise description how the search strings book and topic are normalized before a search starts: backslashes and double or single quotes are removed, parentheses and braces are substituted by blanks, non-ASCII characters are considered as ISO-latin1 characters and the accented letters are substituted by their non-accented counterpart. Finally white space is normalized.

Browsing through the Sections Help books for &GAP; are organized in chapters, sections, and subsections. There are a few special commands starting with a question mark (in the first position after the gap> prompt) which allow browsing a book section or chapter wise.

browsing forward ?>

browsing backwards ?<

The two help commands ?< and ?> allow one to browse through a whole help book. ?< displays the section or subsection preceding the previously shown (sub)section, and ?> takes you to the section or subsection following the previously shown one.

browsing forward one chapter ?>>

browsing backwards one chapter ?<<

?<< takes you back to the beginning of the current chapter. If you are already at the start of a chapter ?<< takes you to the beginning of the previous chapter. ?>> takes you to the beginning of the next chapter.

browsing the previous section browsed ?-

browsing the next section browsed ?+

&GAP; remembers the last few sections that you have read. ?- takes you to the one that you have read before the current one, and displays it again. Further applications of ?- take you further back in this history. ?+ reverses this process, i.e., it takes you back to the section that you have read after the current one. It is important to note that ?- and ?+ do not alter the history like the other help commands.

list of available books ?books

This command shows a list of the books which are currently known to the help system. For each book there is a short name which is used with the book part of the basic help query and there is a long name which hopefully tells you what this book is about.

A short name which ends in (not loaded) refers to a &GAP; package whose documentation is loaded but which needs a call of before you can use the described functions.

table of sections for help books ?[book:]sections

table of chapters for help books ?[book:][chapters]

These commands show tables of contents for all available, respectively the matching books. For some books these commands show the same, namely the whole table of contents.

redisplay a help section ?

redisplay with next help viewer ?&

These commands redisplay the last shown help section. In the form ?& the next preferred help viewer is used for the display (provided one has chosen several viewers), see  below.

Changing the Help Viewer document formats (text, dvi, ps, pdf, HTML) Books of the &GAP; help system or package manuals can be available in several formats. Currently the following formats occur (not all of them may be available for all books):

text This is used for display in the terminal window in which &GAP; is running. Complicated mathematical expressions may not be easy to read in this format. pdf Adobe's pdf format. Can be used for printing and onscreen reading on most current systems (with freely available software). Some manual books contain hyperlinks in this format. HTML The format of web pages. Can be used with any web browser. There may be hyperlink information available which allows a convenient browsing through the book via cross-references. This format has the problem that complicated formulae may be not be easy to read since there is no syntax for formulae in HTML. (Some older manual books use special symbol fonts for formulae and need a particular configuration of the web browser for correct display. Some manuals may use technology for quite sophisticated formula display.)

Depending on your operating system and available additional software you can use several of these formats with &GAP;'s help system. This is configured with the following command. This command takes an arbitrary number of arguments which must be strings describing a viewer. The recognized viewers are explained below. A call with no arguments shows the current setting.

The first given arguments are those with higher priority. So, if a help section is available in the format needed by viewer1, this viewer is used. If not, availability of the format for viewer2 is checked and so on. Recall that the command ?& displays the last seen section again but with the next possible viewer in your list, see .

The viewer "screen" (see below) is always silently appended since we assume that each help book is available in text format.

If you want to change the default setting you can use a call of SetUserPreference( "HelpViewers", [ ... ] ); (the list in the second argument containing the viewers you want) in your gap.ini file (see ).

"screen" This is the default setting. The help is shown in text format using the command. Hint: Text versions of manuals are formatted assuming that your terminal displays at least 80 characters per line, if this is not the case some sections may look very bad. We suggest to use a terminal in UTF-8 encoding with a fixed width font (this is the default on most modern Linux/Windows/Mac systems anyway). Terminals in ISO-8859-X encoding will also work reasonably well (so far, since we do not yet use many special characters which such terminals could not display). "firefox", chrome, "mozilla", "netscape", "konqueror" If a book is available in HTML format this is shown using the corresponding web browser. How well this works, for example by using a running instance of this browser, depends on your particular start script of this browser. (Note, that for some old books the browser must be configured to use symbol fonts.) "browser" (for MS Windows) If a book is available in HTML format, it will be opened using the Windows default application (typically, a web browser). "links2", "w3m", "lynx" If a book is available in HTML format this is shown using the text based "links2" (in graphics mode), w3m or lynx web browser, respectively, inside the terminal running &GAP;. (Formulae in some older books which use symbol fonts may be unreadable.) "mac default browser", "browser", "safari", "firefox" (for Mac OS X) If a book is available in HTML format this is shown in a web browser. The options "safari" and "firefox" use the corresponding browsers. The other two options use the program default browser (which can be set in Safari's preferences, in the "General" tab). "xpdf" (on X-windows systems) If a book is available in pdf format it is shown with the onscreen viewer program xpdf (which must be installed on your system). This is a nice program, once it is running it is reused by &GAP; for the next displays of help sections. "acroread" If a book is available in pdf format it is shown with the onscreen viewer program acroread (which must be available on your system). This program does not allow remote commands or startup with a given page. Therefore the page numbers you have to visit are just printed on the screen. When you are looking at several sections of the same book, this viewer assumes that the acroread window still exists. When you go to another book a new acroread window is launched. "pdf viewer", "skim", "preview", "adobe reader" (for Mac OS X) If a book is available in pdf format this is shown in a pdf viewer. The options "skim", "preview" and "adobe reader" use the corresponding viewers. The other two options use the pdf viewer which you have chosen to open pdf files from the Finder. Note that only "Skim" seems to be capable to open a pdf file on a given page. For the other help viewers, the page numbers where the information can be found will just be printed on the screen. None of the help viewers seems to be capable of opening a pdf at a given named destination (i. e., jump to precisely the place where the information can be found). The pdf viewer "Skim" is open source software, it can be downloaded from http://skim-app.sourceforge.net/. "less" or "more" This is the same as "screen" but additionally the user preferences "Pager" and ""PagerOptions" are set, see the section  for more details.

Please, send ideas for further viewer commands to support@gap-system.org.

The Pager Command &GAP; contains a builtin pager which shows a text string which does not fit on the screen page by page. Its functionality is very rudimentary and self-explaining. This is because (at least under UNIX) there are powerful external standard programs which do this job. <#Include Label="Pager">
gap-4r6p5/doc/ref/stbchain.xml0000644000175000017500000013573612172557252015016 0ustar billbill More about Stabilizer Chains This chapter contains some rather technical complements to the material handled in the chapters  and .
Generalized Conjugation Technique The command ConjugateGroup( G, p ) (see ) for a permutation group G with stabilizer chain equips its result also with a stabilizer chain, namely with the chain of G conjugate by p. Conjugating a stabilizer chain by a permutation p means replacing all the points which appear in the orbit components by their images under p and replacing every permutation g which appears in a labels or transversal component by its conjugate g^p. The conjugate g^p acts on the mapped points exactly as g did on the original points, i.e., (pnt.p). g^p = (pnt.g).p. Since the entries in the translabels components are integers pointing to positions of the labels list, the translabels lists just have to be permuted by p for the conjugated stabilizer. Then generators is reconstructed as labels{ genlabels } and transversal{ orbit } as labels{ translabels{ orbit } }.

generalized conjugation technique This conjugation technique can be generalized. Instead of mapping points and permutations under the same permutation p, it is sometimes desirable (e.g., in the context of permutation group homomorphisms) to map the points with an arbitrary mapping map and the permutations with a homomorphism hom such that the compatibility of the actions is still valid: map(pnt).hom(g) = map(pnt.g). (Of course the ordinary conjugation is a special case of this, with map(pnt) = pnt.p and hom(g) = g^p.)

In the generalized case, the conjugated chain need not be a stabilizer chain for the image of hom, since the preimage of the stabilizer of map(b) (where b is a base point) need not fix b, but only fixes the preimage map^{{-1}}( map(b) ) setwise. Therefore the method can be applied only to one level and the next stabilizer must be computed explicitly. But if map is injective, we have map(b).hom(g) = map(b) if and only if b.g = b, and if this holds, then g = w(g_1, \ldots, g_n) is a word in the generators g_1, \ldots, g_n of the stabilizer of b and hom(g) =^* w( hom(g_1), \ldots, hom(g_n) ) is in the conjugated stabilizer. If, more generally, hom is a right inverse to a homomorphism \varphi (i.e., \varphi(hom(g)) = g for all g), equality * holds modulo the kernel of \varphi; in this case the conjugated chain can be made into a real stabilizer chain by extending each level with the generators of the kernel and appending a proper stabilizer chain of the kernel at the end. These special cases will occur in the algorithms for permutation group homomorphisms (see ).

To conjugate the points (i.e., orbit) and permutations (i.e., labels) of the Schreier tree, a loop is set up over the orbit list constructed during the orbit algorithm, and for each vertex b with unique edge a(l)b ending at b, the label l is mapped with hom and b with map. We assume that the orbit list was built w.r.t. a certain ordering < of the labels, where l' < l means that every point in the orbit was mapped with l' before it was mapped with l. This shape of the orbit list is guaranteed if the Schreier tree is extended only by , and it is then also guaranteed for the conjugated Schreier tree. (The ordering of the labels cannot be read from the Schreier tree, however.)

In the generalized case, it can happen that the edge a(l)b bears a label l whose image is old, i.e., equal to the image of an earlier label l' < l. Because of the compatibility of the actions we then have map(b) = map(a).hom(l)^{{-1}} = map(a).hom(l')^{{-1}} = map(a{{l'}}^{{-1}}), so map(b) is already equal to the image of the vertex a{{l'}}^{{-1}}. This vertex must have been encountered before b = al^{{-1}} because l' < l. We conclude that the image of a label can be old only if the vertex at the end of the corresponding edge has an old image, too, but then it need not be conjugated at all. A similar remark applies to labels which map under hom to the identity.

The General Backtrack Algorithm with Ordered Partitions Section describes the basic functions for a backtrack search. The purpose of this section is to document how the general backtrack algorithm is implemented in &GAP; and which parts you have to modify if you want to write your own backtrack routines. Internal representation of ordered partitions ordered partitions &GAP; represents an ordered partition as a record with the following components. points a list of all points contained in the partition, such that the points of each cell from lie consecutively, cellno a list whose ith entry is the number of the cell which contains the point i, firsts a list such that points[firsts[j]] is the first point in points which is in cell j, lengths a list of the cell lengths. Some of the information is redundant, e.g., the lengths could also be read off the firsts list, but since this need not be increasing, it would require some searching. Similar for cellno, which could be replaced by a systematic search of points, keeping track of what cell is currently being traversed. With the above components, the mth cell of a partition P is expressed as P.points{ [ P.firsts[m] .. P.firsts[m] + P.lengths[m] - 1 ] }. The most important operations, however, to be performed upon P are the splitting of a cell and the reuniting of the two parts. Following the strategy of J. Leon, this is done as follows:

(1) The points which make up the cell that is to be split are sorted so that the ones that remain inside occupy positions [ P.firsts[m] .. last ] in the list P.points (for a suitable value of last). (2) The points at positions [ last + 1 .. P.firsts[m] + P.lengths[m] - 1 ] will form the additional cell. For this new cell requires additional entries are added to the lists P.firsts (namely, last+1) and P.lengths (namely, P.firsts[m] + P.lengths[m] - last - 1). (3) The entries of the sublist P.cellno{ [ last+1 .. P.firsts[m] + P.lengths[m]-1 ] } must be set to the number of the new cell. (4) The entry P.lengths[m] must be reduced to last - P.firsts[m] + 1.

Then reuniting the two cells requires only the reversal of steps 2 to 4 above. The list P.points need not be rearranged. Functions for setting up an R-base This subsection explains some &GAP; functions which are local to the library file lib/stbcbckt.gi which contains the code for backtracking in permutation groups. They are mentioned here because you might find them helpful when you want to implement you own backtracking function based on the partition concept. An important argument to most of the functions is the R-base R, which you should regard as a black box. We will tell you how to set it up, how to maintain it and where to pass it as argument, but it is not necessary for you to know its internal representation. However, if you insist to learn the whole story: Here are the record components from which an R-base is made up:

domain the set \Omega on which the group G operates base the sequence (a_1, \ldots, a_r) of base points partition an ordered partition, initially \Pi_0, this will be refined to \Pi_1, \ldots, \Pi_r during the backtrack algorithm where a list such that a_i lies in cell number where[i] of \Pi_i rfm a list whose ith entry is a list of refinements which take \Sigma_i to \Sigma_{{i+1}}; the structure of a refinement is described below chain a (copy of a) stabilizer chain for G (not if G is a symmetric group) fix only if G is a symmetric group: a list whose i entry contains Fixcells( \Pi_i ) level initially equal to chain, this will be changed to chains for the stabilizers G_{{a_1 \ldots a_i}} for i = 1, \ldots, r during the backtrack algorithm; if G is a symmetric group, only the number of moved points is stored for each stabilizer lev a list whose ith entry remembers the level entry for G_{{a_1 \ldots a_{{i-1}}}} level2, lev2 a similar construction for a second group (used in intersection calculations), false otherwise. This second group H activated if the R-base is constructed as EmptyRBase( [ G, H ], \Omega, \Pi_0 ) (if G = H, &GAP; sets level2 = true instead). nextLevel this is described below

As our guiding example, we present code for the function which calculates the centralizer of an element g in the group G. (The real code is more general and has a few more subtleties.)

false then Add( fix, q ); ProcessFixpoint( R, q ); AddRefinement( R, "Centralizer", [ Pi.cellno[ p ], q, where ] ); if Pi.lengths[ where ] = 1 then p := FixpointCellNo( Pi, where ); ProcessFixpoint( R, p ); AddRefinement( R, "ProcessFixpoint", [ p, where ] ); fi; fi; od; end; return PartitionBacktrack( G, c -> g ^ c = g, false, R, [ Pi_0, g ], L, R ); ]]>

The list numbers below refer to the line numbers of the code above.

1. omega is the set on which G acts and Pi_0 is the first member of the decreasing sequence of partitions mentioned in . We set Pi_0 = omega, which is constructed as TrivialPartition( omega ), but we could have started with a finer partition, e.g., into unions of g-cycles of the same length. 2. This statement sets up the R-base in the variable R. 3.-21. These lines define a function R.nextLevel which is called whenever an additional member in the sequence Pi_0 \geq \Pi_1 \geq \ldots of partitions is needed. If \Pi_i does not yet contain enough base points in one-point cells, &GAP; will call R.nextLevel( \Pi_i, R ), and this function will choose a new base point a_{{i+1}}, refine \Pi_i to \Pi_{{i+1}} (thereby changing the first argument) and store all necessary information in R. 5. This statement selects a new base point a_{{i+1}}, which is not yet in a one-point cell of \Pi and still moved by the stabilizer G_{{a_1 \ldots a_i}} of the earlier base points. If certain points of omega should be preferred as base point (e.g., because they belong to long cycles of g), a list of points starting with the most wanted ones, can be given as an optional third argument to NextRBasePoint (actually, this is done in the real code for ). 6. Fixcells( \Pi ) returns the list of points in one-point cells of \Pi (ordered as the cells are ordered in \Pi). 7. For every point p \in fix, if we know the image p^g under c \in C_G(e), we also know ( p^g )^c = ( p^c )^g. We therefore want to isolate these extra points in \Pi. 9. This statement puts point q in a cell of its own, returning in where the number of the cell of \Pi from which q was taken. If q was already the only point in its cell, where = false instead. 12. This command does the necessary bookkeeping for the extra base point q: It prescribes q as next base in the stabilizer chain for G (needed, e.g., in line 5) and returns false if q was already fixed the stabilizer of the earlier base points (and true otherwise; this is not used here). Another call to ProcessFixpoint like this was implicitly made by the function NextRBasePoint to register the chosen base point. By contrast, the point q was not chosen this way, so ProcessFixpoint must be called explicitly for q. 13. This statement registers the function which will be used during the backtrack search to perform the corresponding refinements on the image partition \Sigma_i (to yield the refined \Sigma_{{i+1}}). After choosing an image b_{{i+1}} for the base point a_{{i+1}}, &GAP; will compute \Sigma_i \wedge (\{ b_{{i+1}} \}, \Omega \setminus \{ b_{{i+1}} \}) and store this partition in I.partition, where I is a black box similar to R, but corresponding to the current image partition (hence it is an R-image in analogy to the R-base). Then &GAP; will call the function Refinements.Centralizer( R, I, Pi.cellno[ p ], p, where ), with the then current values of R and I, but where \Pi.cellno[ p ], p, where still have the values they have at the time of this AddRefinement command. This function call will further refine I.partition to yield \Sigma_{{i+1}} as it is programmed in the function Refinements.Centralizer, which is described below. (The global variable Refinements is a record which contains all refinement functions for all backtracking procedures.) 14.-19. If the cell from which q was taken out had only two points, we now have an additional one-point cell. This condition is checked in line 13 and if it is true, this extra fixpoint p is taken (line 15), processed like q before (line 16) and is then (line 17) passed to another refinement function Refinements.ProcessFixpoint( R, I, p, where ), which is also described below. 23.-29. This command starts the backtrack search. Its result will be the centralizer as a subgroup of G. Its arguments are 24. the group we want to run through, 25. the property we want to test, as a &GAP; function, 26. false if we are looking for a subgroup, true in the case of a representative search (when the result would be one representative), 27. the R-base, 28. a list of data, to be stored in I.data, which has in position 1 the first member \Sigma_0 of the decreasing sequence of image partitions mentioned in . In the centralizer example, position 2 contains the element that is to be centralized. In the case of a representative search, i.e., a conjugacy test g^c ?= h, we would have h instead of g here, and possibly a \Sigma_0 different from \Pi_0 (e.g., a partition into unions of h-cycles of same length). 29. two subgroups L \leq C_G(g) and R \leq C_G(h) known in advance (we have L = R in the centralizer case). Refinement functions for the backtrack search The last subsection showed how the refinement process leading from \Pi_i to \Pi_{{i+1}} is coded in the function R.nextLevel, this has to be executed once the base point a_{{i+1}}. The analogous refinement step from \Sigma_i to \Sigma_{{i+1}} must be performed for each choice of an image b_{{i+1}} for a_{{i+1}}, and it will depend on the corresponding value of \Sigma_i \wedge (\{b_{{i+1}}\}, \Omega \setminus \{b_{{i+1}}\}). But before we can continue our centralizer example, we must, for the interested reader, document the record components of the other black box I, as we did above for the R-base black box R. Most of the components change as &GAP; walks up and down the levels of the search tree. data this will be mentioned below depth the level i in the search tree of the current node \Sigma_i bimg a list of images of the points in R.base partition the partition \Sigma_i of the current node level the stabilizer chain R.lev[i] at the current level perm a permutation mapping Fixcells( \Pi_i ) to Fixcells( \Sigma_i ); this implies mapping (a_1, \ldots, a_i) to (b_1, \ldots, b_i) level2, perm2 a similar construction for the second stabilizer chain, false otherwise (and true if R.level2 = true)

As declared in the above code for , the refinement is performed by the function Refinement.Centralizer( R, I, \Pi.cellno[p], p, where ). The functions in the record Refinement always take two additional arguments before the ones specified in the AddRefinement call (in line 13 above), namely the R-base R and the current value I of the R-image. In our example, p is a fixpoint of \Pi = \Pi_i \wedge (\{ a_{{i+1}} \}, \Omega \setminus \{ a_{{i+1}} \}) such that where = \Pi.cellno[ p^g ]. The Refinement functions must return false if the refinement is unsuccessful (e.g., because it leads to \Sigma_{{i+1}} having different cell sizes from \Pi_{{i+1}}) and true otherwise. Our particular function looks like this.

The list numbers below refer to the line numbers of the code immediately above.

3. The current value of \Sigma_i \wedge (\{ b_{{i+1}} \}, \Omega \setminus \{ b_{{i+1}} \}) is always found in I.partition. 4. The image of the only point in cell number cellno = \Pi_i.cellno[ p ] in \Sigma under g = I.data[ 2 ] is calculated. 5. The function returns true only if the image q has the same cell number in \Sigma as p had in \Pi (i.e., where) and if q can be prescribed as an image for p under the coset of the stabilizer G_{{a_1 \ldots a_{{i+1}}}}.c where c \in G is an (already constructed) element mapping the earlier base points a_1, \ldots, a_{{i+1}} to the already chosen images b_1, \ldots, b_{{i+1}}. This latter condition is tested by ProcessFixpoint( I, p, q ) which, if successful, also does the necessary bookkeeping in I. In analogy to the remark about line 12 in the program above, the chosen image b_{{i+1}} for the base point a_{{i+1}} has already been processed implicitly by the function PartitionBacktrack, and this processing includes the construction of an element c \in G which maps Fixcells( \Pi_i ) to Fixcells( \Sigma_i ) and a_{{i+1}} to b_{{i+1}}. By contrast, the extra fixpoints p and q in \Pi_{{i+1}} and \Sigma_{{i+1}} were not chosen automatically, so they require an explicit call of ProcessFixpoint, which replaces the element c by some c'.c (with c' \in G_{{a_1 \ldots a_{{i+1}}}}) which in addition maps p to q, or returns false if this is impossible.

You should now be able to guess what Refinements.ProcessFixpoint( R, I, p, where ) does: it simply returns ProcessFixpoint( I, p, FixpointCellNo( I.partition, where ) ).

Summary.

When you write your own backtrack functions using the partition technique, you have to supply an R-base, including a component nextLevel, and the functions in the Refinements record which you need. Then you can start the backtrack by passing the R-base and the additional data (for the data component of the R-image) to PartitionBacktrack. Functions for meeting ordered partitions A kind of refinement that occurs in particular in the normalizer calculation involves computing the meet of \Pi (cf. lines 6ff. above) with an arbitrary other partition \Lambda, not just with one point. To do this efficiently, &GAP; uses the following two functions.

StratMeetPartition( R, \Pi, \Lambda [, g ] )

MeetPartitionStrat( R, I{, \Lambda'}[, {g'}], strat )

meet strategy Such a StratMeetPartition command would typically appear in the function call R.nextLevel( \Pi, R ) (during the refinement of \Pi_i to \Pi_{{i+1}}). This command replaces \Pi by \Pi \wedge \Lambda (thereby changing the second argument) and returns a meet strategy strat. This is (for us) a black box which serves two purposes: First, it allows &GAP; to calculate faster the corresponding meet \Sigma \wedge \Lambda', which must then appear in a Refinements function (during the refinement of \Sigma_i to \Sigma_{{i+1}}). It is faster to compute \Sigma \wedge \Lambda' with the meet strategy of \Pi \wedge \Lambda because if the refinement of \Sigma is successful at all, the intersection of a cell from the left hand side of the \wedge sign with a cell from the right hand side must have the same size in both cases (and strat records these sizes, so that only non-empty intersections must be calculated for \Sigma \wedge \Lambda'). Second, if there is a discrepancy between the behaviour prescribed by strat and the behaviour observed when refining \Sigma, the refinement can immediately be abandoned.

On the other hand, if you only want to meet a partition \Pi with \Lambda for a one-time use, without recording a strategy, you can simply type StratMeetPartition( \Pi, \Lambda ) as in the following example, which also demonstrates some other partition-related commands.

P := Partition( [[1,2],[3,4,5],[6]] );; Cells( P ); [ [ 1, 2 ], [ 3, 4, 5 ], [ 6 ] ] gap> Q := Partition( OnTuplesTuples( last, (1,3,6) ) );; Cells( Q ); [ [ 3, 2 ], [ 6, 4, 5 ], [ 1 ] ] gap> StratMeetPartition( P, Q ); [ ] gap> # The ``meet strategy'' was not recorded, ignore this result. gap> Cells( P ); [ [ 1 ], [ 5, 4 ], [ 6 ], [ 2 ], [ 3 ] ] ]]>

You can even say StratMeetPartition( \Pi, \Delta ) where \Delta is simply a subset of \Omega, it will then be interpreted as the partition (\Delta, \Omega \setminus \Delta).

&GAP; makes use of the advantages of a meet strategy if the refinement function in Refinements contains a MeetPartitionStrat command where strat is the meet strategy calculated by StratMeetPartition before. Such a command replaces I.partition by its meet with \Lambda', again changing the argument I. The necessary reversal of these changes when backtracking from a node (and prescribing the next possible image for a base point) is automatically done by the function PartitionBacktrack.

In all cases, an additional argument g means that the meet is to be taken not with \Lambda, but instead with \Lambda.{{g^{{-1}}}}, where operation on ordered partitions is meant cellwise (and setwise on each cell). (Analogously for the primed arguments.)

P := Partition( [[1,2],[3,4,5],[6]] );; gap> StratMeetPartition( P, P, (1,6,3) );; Cells( P ); [ [ 1 ], [ 5, 4 ], [ 6 ], [ 2 ], [ 3 ] ] ]]> Note that P.(1,3,6) = Q. Avoiding multiplication of permutations In the description of the last subsections, the backtrack algorithm constructs an element c \in G mapping the base points to the prescribed images and finally tests the property in question for that element. During the construction, c is obtained as a product of transversal elements from the stabilizer chain for G, and so multiplications of permutations are required for every c submitted to the test, even if the test fails (i.e., in our centralizer example, if g^c<>g). Even if the construction of c stops before images for all base points have been chosen, because a refinement was unsuccessful, several multiplications will already have been performed by (explicit or implicit) calls of ProcessFixpoint, and, actually, the general backtrack procedure implemented in &GAP; avoids this.

For this purpose, &GAP; does not actually multiply the permutations but rather stores all the factors of the product in a list. Specifically, instead of carrying out the multiplication in c \mapsto c'.c mentioned in the comment to line 5 of the above program — where c' \in G_{{a_1 \ldots a_{{i+1}}}} is a product of factorized inverse transversal elements, see — &GAP; appends the list of these factorized inverse transversal elements (giving c') to the list of factors already collected for c. Here c' is multiplied from the left and is itself a product of inverses of strong generators of G, but &GAP; simply spares itself all the work of inverting permutations and stores only a list of inverses, whose product is then (c'.c)^{{-1}} (which is the new value of c^{{-1}}). The list of inverses is extended this way whenever ProcessFixpoint is called to improve c.

The product has to be multiplied out only when the property is finally tested for the element c. But it is often possible to delay the multiplication even further, namely until after the test, so that no multiplication is required in the case of an unsuccessful test. Then the test itself must be carried out with the factorized version of the element c. For this purpose, PartitionBacktrack can be passed its second argument (the property in question) in a different way, not as a single &GAP; function, but as a list like in lines 2–4 of the following alternative excerpt from the code for .

c!.lftObj = c!.rgtObj ], false, R, [ Pi_0, g ], L, R ); ]]>

The test for c to have the property in question is of the form opr( left, c ) = right where opr is an operation function as explained in . In other words, c passes the test if and only if it maps a left object to a right object under a certain operation. In the centralizer example, we have opr = OnPoints and left = right = g, but in a conjugacy test, we would have right = h.

2. Two first two entries (here g and g) are the values of left and right. 3. The third entry (here ) is the operation opr. 4. The fourth entry is the test to be performed upon the mapped left object left and preimage of the right object opr( right, c^-1 ). Here &GAP; operates with the inverse of c because this is the product of the permutations stored in the list of inverses. The preimage of right under c is then calculated by mapping right with the factors of c^{{-1}} one by one, without the need to multiply these factors. This mapping of right is automatically done by the ProcessFixpoint function whenever c is extended, the current value of right is always stored in c!.rgtObj. When the test given by the fourth entry is finally performed, the element c has two components c!.lftObj = left and c!.rgtObj = opr( right, c^-1 ), which must be used to express the desired relation as a function of c. In our centralizer example, we simply have to test whether they are equal.

Stabilizer Chains for Automorphisms Acting on Enumerators This section describes a way of representing the automorphism group of a group as permutation group, following . The code however is not yet included in the &GAP; library.

In this section we present an example in which objects we already know (namely, automorphisms of solvable groups) are equipped with the permutation-like operations ^ and / for action on positive integers. To achieve this, we must define a new type of objects which behave like permutations but are represented as automorphisms acting on an enumerator. Our goal is to generalize the Schreier-Sims algorithm for construction of a stabilizer chain to groups of such new automorphisms. An operation domain for automorphisms The idea we describe here is due to C. Sims. We consider a group A of automorphisms of a group G, given by generators, and we would like to know its order. Of course we could follow the strategy of the Schreier-Sims algorithm (described in ) for A acting on G. This would involve a call of StabChainStrong( EmptyStabChain( [], One( A ) ), GroupGenerators( A ) ) where StabChainStrong is a function as the one described in the pseudo-code below:

The membership test sch \notin S.stabilizer can be performed because the stabilizer chain of S.stabilizer is already correct at that moment. We even know a base in advance, namely any generating set for G. Fix such a generating set (g_1, \ldots, g_d) and observe that this base is generally very short compared to the degree |G| of the operation. The problem with the Schreier-Sims algorithm, however, is then that the length of the first basic orbit g_1.A would already have the magnitude of |G|, and the basic orbits at deeper levels would not be much shorter. For the advantage of a short base we pay the high price of long basic orbits, since the product of the (few) basic orbit lengths must equal |A|. Such long orbits make the Schreier-Sims algorithm infeasible, so we have to look for a longer base with shorter basic orbits.

Assume that G is solvable and choose a characteristic series with elementary abelian factors. For the sake of simplicity we assume that N < G is an elementary abelian characteristic subgroup with elementary abelian factor group G/N. Since N is characteristic, A also acts as a group of automorphisms on the factor group G/N, but of course not necessarily faithfully. To retain a faithful action, we let A act on the disjoint union G/N with G, and choose as base (g_1 N, \ldots, g_d N, g_1, \ldots, g_d). Now the first d basic orbits lie inside G/N and can have length at most [G:N]. Since the base points g_1 N, \ldots, g_d N form a generating set for G/N, their iterated stabilizer A^{(d+1)} acts trivially on the factor group G/N, i.e., it leaves the cosets g_i N invariant. Accordingly, the next d basic orbits lie inside g_i N (for i = 1, \ldots, d) and can have length at most |N|.

Generalizing this method to a characteristic series G = N_0 > N_1 > \ldots > N_l = \{ 1 \} of length l > 2, we can always find a base of length l.d such that each basic orbit is contained in a coset of a characteristic factor, i.e. in a set of the form g_i N_{{j-1}} / N_j (where g_i is one of the generators of G and 1 \leq j \leq l). In particular, the length of the basic orbits is bounded by the size of the corresponding characteristic factors. To implement a Schreier-Sims algorithm for such a base, we must be able to let automorphisms act on cosets of characteristic factors g_i N_{{j-1}} / N_j, for varying i and j. We would like to translate each such action into an action on \{ 1, \ldots, [ N_{{j-1}}:N_j] \}, because then we need not enumerate the operation domain, which is the disjoint union of G / N_1, G / N_2 \ldots G / N_l, as a whole. Enumerating it as a whole would result in basic orbits like orbit \subseteq \{ 1001, \ldots, 1100 \} with a transversal list whose first 1000 entries would be unbound, but still require 4 bytes of memory each (see ).

Identifying each coset g_i N_{{j-1}} / N_j into \{ 1, \ldots, [N_{{j-1}}:N_j] \} of course means that we have to change the action of the automorphisms on every level of the stabilizer chain. Such flexibility is not possible with permutations because their effect on positive integers is hardwired into them, but we can install new operations for automorphisms. Enumerators for cosets of characteristic factors So far we have not used the fact that the characteristic factors are elementary abelian, but we will do so from here on. Our first task is to implement an enumerator (see and ) for a coset of a characteristic factor in a solvable group G. We assume that such a coset g N/M is given by

(1) a pcgs for the group G (see ), let n = Length( pcgs ); (2) a range range = [ start .. stop ] indicating that N = \langle pcgs\{ [ start .. n ] \} \rangle and M = \langle pcgs\{ [ stop + 1 .. n ] \} \rangle, i.e., the cosets of pcgs\{ range \} form a base for the vector space N/M; (3) the representative g.

We first define a new representation for such enumerators and then construct them by simply putting these three pieces of data into a record object. The enumerator should behave as a list of group elements (representing cosets modulo M), consequently, its family will be the family of the pcgs itself.

The definition of the operations , and is now straightforward. The code has sometimes been abbreviated and is meant cum grano salis, e.g., the declaration of the local variables has been left out.

Product( RelativeOrdersPcgs( enum!.pcgs ){ enum!.range } ) ); InstallMethod( \[\], [ IsCosetSolvableFactorEnumeratorRep, IsPosRat and IsInt ], function( enum, pos ) elm := (); pos := pos - 1; for i in Reversed( enum!.range ) do p := RelativeOrderOfPcElement( enum!.pcgs, i ); elm := enum!.pcgs[ i ] ^ ( pos mod p ) * elm; pos := QuoInt( pos, p ); od; return enum!.representative * elm; end ); InstallMethod( Position, [ IsCosetSolvableFactorEnumeratorRep, IsObject, IsZeroCyc ], function( enum, elm, zero ) exp := ExponentsOfPcElement( enum!.pcgs, LeftQuotient( enum!.representative, elm ) ); pos := 0; for i in enum!.range do pos := pos * RelativeOrderOfPcElement( pcgs, i ) + exp[ i ]; od; return pos + 1; end ); ]]> Making automorphisms act on such enumerators Our next task is to make automorphisms of the solvable group pcgs!.group act on [ 1 .. Length( enum ) ] for such an enumerator enum. We achieve this by introducing a new representation of automorphisms on enumerators and by putting the enumerator together with the automorphism into an object which behaves like a permutation. Turning an ordinary automorphism into such a special automorphism requires then the construction of a new object which has the new type. We provide an operation PermOnEnumerator( model, aut ) which constructs such a new object having the same type as model, but representing the automorphism aut. So aut can be either an ordinary automorphism or one which already has an enumerator in its type, but perhaps different from the one we want (i.e. from the one in model).

Next we have to install new methods for the operations which calculate the product of two automorphisms, because this product must again have the right type. We also have to write a function which uses the enumerators to apply such an automorphism to positive integers.

How the corresponding methods for p / aut and aut ^ n look like is obvious.

Now we can formulate the recursive procedure StabChainStrong which extends the stabilizer chain by adding in new generators newgens. We content ourselves again with pseudo-code, emphasizing only the lines which set the EnumeratorDomainPermutation. We assume that initially S is a stabilizer chain for the trivial subgroup with a level for each pair (range,g) characterizing an enumerator (as described above). We also assume that the identity element at each level already has the type corresponding to that level.

gap-4r6p5/doc/ref/weakptr.xml0000644000175000017500000002245212172557252014666 0ustar billbill Weak Pointers This chapter describes the use of the kernel feature of weak pointers. This feature is primarily intended for use only in &GAP; internals, and should be used extremely carefully otherwise.

The GASMAN garbage collector is the part of the kernel that manages memory in the users workspace. It will normally only reclaim the storage used by an object when the object cannot be reached as a subobject of any &GAP; variable, or from any reference in the kernel. We say that any link to object a from object b keeps object a alive, as long as b is alive. It is occasionally convenient, however, to have a link to an object which does not keep it alive, and this is a weak pointer. The most common use is in caches, and similar structures, where it is only necessary to remember how to solve problem x as long as some other link to x exists.

The following section describes the semantics of the objects that contain weak pointers. Following sections describe the functions available to manipulate them.

Weak Pointer Objects A weak pointer object is similar to a mutable plain list, except that it does not keep its subobjects alive during a garbage collection. From the &GAP; viewpoint this means that its entries may become unbound, apparently spontaneously, at any time. Considerable care is therefore needed in programming with such an object. returns a weak pointer object which contains the same subobjects as the list list, that is it returns a shallow weak copy of list.

w := WeakPointerObj( [ 1, , [2,3], fail, rec( a := 1) ] ); WeakPointerObj( [ 1, , [ 2, 3 ], fail, rec( a := 1 ) ] ) ]]>

After some computations involving garbage collections (but not necessarily in the first garbage collection after the above assignment), &GAP; will notice that the list and the record stored in w are not referenced by other objects than w, and that therefore these entries may disappear.

GASMAN("collect"); ... (perhaps more computations and garbage collections) ... gap> GASMAN("collect"); gap> w; WeakPointerObj( [ 1, , , fail ] ) ]]>

Note that w has failed to keep its list and record subobjects alive during the garbage collections. Certain subobjects, such as small integers and elements of small finite fields, are not stored in the workspace, and so are not subject to garbage collection, while certain other objects, such as the Boolean values, are always reachable from global variables or the kernel and so are never garbage collected.

Subobjects reachable without going through a weak pointer object do not evaporate, as in:

w := WeakPointerObj( [ 1, , , fail ] ); WeakPointerObj( [ 1, , , fail ] ) gap> l := [1,2,3];; gap> w[1] := l;; gap> w; WeakPointerObj( [ [ 1, 2, 3 ], , , fail ] ) gap> GASMAN("collect"); gap> w; WeakPointerObj( [ [ 1, 2, 3 ], , , fail ] ) ]]>

Note also that the global variables last, last2 and last3 will keep things alive –this can be confusing when debugging.

Low Level Access Functions for Weak Pointer Objects ElmWPObj The functions and set and unbind entries in a weak pointer object.

The function returns the element at position pos of the weak pointer object wp, if there is one, and fail otherwise. A return value of fail can thus arise either because (a) the value fail is stored at position pos, or (b) no value is stored at position pos. Since fail cannot vanish in a garbage collection, these two cases can safely be distinguished by a subsequent call to , which returns true if there is currently a value bound at position pos of wp and false otherwise.

Note that it is not safe to write:

if IsBoundElmWPObj(w,i) then x:= ElmWPObj(w,i); fi;

and treat x as reliably containing a value taken from w, as a badly timed garbage collection could leave x containing fail. Instead use

x := ElmWPObj(w,i); if x <> fail or IsBoundElmWPObj(w,i) then . . ..

Here is an example.

w := WeakPointerObj( [ 1, , [2,3], fail, rec() ] ); WeakPointerObj( [ 1, , [ 2, 3 ], fail, rec( ) ] ) gap> SetElmWPObj(w,5,[]); gap> w; WeakPointerObj( [ 1, , [ 2, 3 ], fail, [ ] ] ) gap> UnbindElmWPObj(w,1); gap> w; WeakPointerObj( [ , , [ 2, 3 ], fail, [ ] ] ) gap> ElmWPObj(w,3); [ 2, 3 ] gap> ElmWPObj(w,1); fail ]]>

Now after some computations and garbage collections \ldots

2;;3;;4;;GASMAN("collect"); # clear last, last2, last3 ]]>

\ldots we get the following.

ElmWPObj(w,3); fail gap> w; WeakPointerObj( [ , , , fail ] ) gap> ElmWPObj(w,4); fail gap> IsBoundElmWPObj(w,3); false gap> IsBoundElmWPObj(w,4); true ]]>

Accessing Weak Pointer Objects as Lists Weak pointer objects are members of ListsFamily and the categories and . Methods based on the low-level functions in the previous section, are installed for the list access operations, enabling them to be used as lists. However, it is not recommended that these be used in programming. They are supplied mainly as a convenience for interactive working, and may not be safe, since functions and methods for lists may assume that after IsBound(w[i]) returns true, access to w[i] is safe.
Copying Weak Pointer Objects A method is installed, which makes a new weak pointer object containing the same objects as the original.

It is possible to apply to a weak pointer object, obtaining a new weak pointer object containing copies of the objects in the original. This may not be safe if a badly timed garbage collection occurs during copying.

Applying to a weak pointer object produces an immutable plain list containing immutable copies of the objects contained in the weak pointer object. An immutable weak pointer object is a contradiction in terms.

The GASMAN Interface for Weak Pointer Objects The key support for weak pointers is in the files src/gasman.c and src/gasman.h. This document assumes familiarity with the rest of the operation of GASMAN. A kernel type (tnum) of bags which are intended to act as weak pointers to their subobjects must meet three conditions. Firstly, the marking function installed for that tnum must use MarkBagWeakly for those subbags, rather than MARK_BAG. Secondly, before any access to such a subbag, it must be checked with IS_WEAK_DEAD_BAG. If that returns true, then the subbag has evaporated in a recent garbage collection and must not be accessed. Typically the reference to it should be removed. Thirdly, a sweeping function must be installed for that tnum which copies the bag, removing all references to dead weakly held subbags.

The files src/weakptr.c and src/weakptr.h use this interface to support weak pointer objects. Other objects with weak behaviour could be implemented in a similar way.

gap-4r6p5/doc/ref/grpchain.xml0000644000175000017500000000574212172557252015007 0ustar billbill Chains of subgroups (preliminary) The functions and operations described in this chapter have been added very recently and are still undergoing development. It is conceivable that names of variants of the functionality might change in future versions. If you plan to use these functions in your own code, please contact us.

<#Include Label="[1]{grpchain}">

<#Include Label="IsChainTypeGroup">

<#Include Label="ChainSubgroup"> <#Include Label="Transversal"> <#Include Label="IsInChain"> <#Include Label="GeneratingSetIsComplete">

<#Include Label="SiftOneLevel">[grpchain]!{for chains of subgroups} <#Include Label="Sift">[grpchain]!{for chains of subgroups} <#Include Label="SizeOfChainOfGroup"> <#Include Label="TransversalOfChainSubgroup"> <#Include Label="ChainStatistics"> <#Include Label="HasChainHomomorphicImage"> <#Include Label="ChainHomomorphicImage">

Stabiliser chain subgroups <#Include Label="BaseOfGroup"> <#Include Label="ExtendedGroup"> <#Include Label="StrongGens"> <#Include Label="ChainSubgroupByStabiliser"> <#Include Label="OrbitGeneratorsOfGroup">

<#Include Label="RandomSchreierSims"> <#Include Label="ChangedBaseGroup">

Hom coset chain subgroups <#Include Label="ChainSubgroupByHomomorphism"> <#Include Label="ChainSubgroupByProjectionFunction"> <#Include Label="QuotientGroupByChainHomomorphicImage"> <#Include Label="ChainSubgroupQuotient">

<#Include Label="MakeHomChain">

Direct product chain subgroups <#Include Label="ChainSubgroupByDirectProduct"> <#Include Label="ChainSubgroupByPSubgroupOfAbelian">

Trivial chain subgroups and sift function chain subgroups <#Include Label="ChainSubgroupByTrivialSubgroup"> <#Include Label="ChainSubgroupBySiftFunction">

gap-4r6p5/doc/ref/libform.xml0000644000175000017500000001654512172557252014651 0ustar billbill Library Files This chapter describes some of the conventions used in the &GAP; library files. These conventions are intended as a help on how to read library files and how to find information in them. So everybody is recommended to follow these conventions, although they do not prescribe a compulsory programming style –&GAP; itself will not bother with the formatting of files.

Filenames have traditionally &GAP; adhered to the 8+3 convention (to make it possible to use the same filenames even on a MS-DOS file system) and been in lower case (systems that do not recognize lower case in file names will convert them automatically to upper case). It is no longer so important to adhere to these conventions, but at the very least filenames should adhere to a 16+5 convention, and be distinct even after identifying upper and lower case. Directory names of packages, however, must be in lower case (the command assumes this).

File Types The &GAP; library consists of the following types of files, distinguished by their suffixes:

.g Files which contain parts of the inner workings of &GAP;. These files usually do not contain mathematical functionality, except for providing links to kernel functions. .gd Declaration files. These files contain declarations of all categories, attributes, operations, and global functions. These files also contain the operation definitions in comments. .gi Implementation files. These files contain all installations of methods and global functions. Usually declarations of representations are also considered to be part of the implementation and are therefore found in the .gi files.

As a rule of thumb, all .gd files are read in before the .gi files are read. Therefore a .gi file usually may use any operation or global function (it has been declared before), and no care has to be taken towards the order in which the .gi files are read.

Finding Implementations in the Library For a concretely given function, you can use and for finding the file where this function is defined, and the line in this file where the definition of this function starts. This does not work for arbitrary functions, see Section for the restrictions.

If you are interested in getting the function which implements a method for specific arguments, you can use . If does not work for this method then setting the print level of higher will give you the installation string for this method, which can be used for searching in library files.

To find the occurrence of functions, methods, function names, and installation strings in the library, one can use the grep tool under UNIX. To find a function, search for the function name in the .gd files; as global variables are usually declared only once, only few files will show up. The function installation is likely to occur in the corresponding .gi file.

To find a method from the known operation name and the installation string, search for the string Method( (this catches both and ) and the installation string or the operation name.

The following tools from the &GAP; package Browse can be used for accessing the code of functions.

shows an overview of &GAP;'s operations and methods, and allows one to navigate through the files that contain the implementations of the methods, using a pager. shows profiling results (similar to ) and allows one to navigate through the files that contain the implementations of the functions that were actually used, using a pager.

Undocumented Variables For several global variables in &GAP;, no information is available via the help system (see Section , for a quick overview of the help system, or Chapter , for details). There are various reasons for hiding a variable from the user; namely, the variable may be regarded as of minor importance (for example, it may be a function called by documented &GAP; functions that first compute many input parameters for the undocumented function), or it belongs to a part of &GAP; that is still experimental in the sense that the meaning of the variable has not yet been fixed or even that it is not clear whether the variable will vanish in a more developed version.

As a consequence, it is dangerous to use undocumented variables because they are not guaranteed to exist or to behave the same in future versions of &GAP;.

Conversely, for documented variables, the definitions in the &GAP; manual can be relied on for future &GAP; versions (unless they turn out to be erroneous); if the &GAP; developers find that some piece of minor, but documented functionality is an insurmountable obstacle to important developments, they may make the smallest possible incompatible change to the functionality at the time of a major release. However, in any such case it will be announced clearly in the &GAP; Forum what has been changed and why.

So on the one hand, the developers of &GAP; want to keep the freedom of changing undocumented &GAP; code. On the other hand, users may be interested in using undocumented variables.

In this case, whenever you write &GAP; code involving undocumented variables, and want to make sure that this code will work in future versions of &GAP;, you may ask at support@gap-system.org for documentation about the variables in question. The &GAP; developers then decide whether these variables shall be documented or not, and if yes, what the definitions shall be.

In the former case, the new documentation is added to the &GAP; manual, this means that from then on, this definition is protected against changes.

In the latter case (which may occur for example if the variables in question are still experimental), you may add the current values of these variables to your private code if you want to be sure that nothing will be broken later due to changes in &GAP;.

gap-4r6p5/doc/ref/trans.xml0000644000175000017500000000301012172557252014325 0ustar billbill Transformations This chapter describes functions for transformations.

<#Include Label="[1]{trans}">

Functions for Transformations <#Include Label="IsTransformation"> <#Include Label="TransformationFamily"> <#Include Label="Transformation"> <#Include Label="IdentityTransformation"> <#Include Label="RandomTransformation"> <#Include Label="DegreeOfTransformation"> <#Include Label="ImageListOfTransformation"> <#Include Label="ImageSetOfTransformation"> <#Include Label="RankOfTransformation"> <#Include Label="KernelOfTransformation"> <#Include Label="PreimagesOfTransformation"> <#Include Label="RestrictedTransformation"> <#Include Label="AsTransformation"> <#Include Label="PermLeftQuoTransformation"> <#Include Label="BinaryRelationTransformation"> <#Include Label="TransformationRelation">
gap-4r6p5/doc/ref/helpintf.xml0000644000175000017500000003072412172557252015023 0ustar billbill Interface to the GAP Help System In this chapter we describe which information the help system needs about a manual book and how to tell it this information. The code which implements this interface can be found in lib/helpbase.gi.

If you are intending to use a documentation format that is already used by some other help book you probably don't need to know anything from this chapter. However, if you want to create a new format and make it available to &GAP; then hopefully you will find the necessary information here.

The basic idea of the help system is as follows: One tells &GAP; a directory which contains a file manual.six, see . When the &GAP; help is asked something about this book it reads in some basic information from the file manual.six: strings like section headers, function names, and index entries to be searched by the online help; information about the available formats of this book like text, html, dvi, and pdf; the actual files containing the documentation, corresponding section numbers, and page numbers: and so on. See  for a description of the format of the manual.six file.

It turns out that there is almost no restriction on the format of the manual.six file, except that it must provide a string, say "myownformat" which identifies the format of the help book. Then the basic actions on a help book are delegated by the help system to handler functions stored in a record HELP_BOOK_HANDLER.myownformat. See  for information which functions must be provided by the handler and what they are supposed to do. The main work to teach &GAP; to use a new document format is to write these handler functions and to produce an appropriate manual.six file.

Installing and Removing a Help Book This command tells &GAP; that in directory dir (given as either a string describing the path relative to the &GAP; root directory GAPInfo.RootPaths[1] or as directory object) contains the basic information about a help book. The string short is used as an identifying name for that book by the online help. The string long should be a short explanation of the content of the book. Both strings together should easily fit on a line, since they are displayed with ?books.

It is possible to reinstall a book with different strings short, long; (for example, documentation of a not-loaded &GAP; package indicates this in the string short and if you later load the package, &GAP; quietly changes the string short as it reinstalls its documentation).

The only condition necessary to make the installation of a book valid is that the directory dir must contain a file manual.six. The next section explains how this file must look. This command tells &GAP; not to use the help book with identifying name short any more. The book can be re-installed using .

The manual.six File If a manual.six file for a help book is not in the format of the gapmacro.tex macros, explained in the document The gapmacro.tex Manual Format (see the file gap4r5/doc/gapmacrodoc.pdf from the tools archive etc/tools.tar.gz which should be unpacked using the script etc/install-tools.sh), the first non-empty line of manual.six must be of the form

#SIXFORMAT myownformat

where myownformat is an identifying string for this format. The reading of the (remainder of the) file is then delegated to the function HELP_BOOK_HANDLER.myownformat.ReadSix which must exist. Thus there are no further regulations for the format of the manual.six file, other that what you yourself impose. If such a line is missing then it is assumed that the manual.six file complies with the gapmacro.tex documentation format which is the default format.

Section explains how the return value of HELP_BOOK_HANDLER.myownformat.ReadSix should look like and which further function should be contained in HELP_BOOK_HANDLER.myownformat.

The Help Book Handler document formats!for help books For each document format myownformat there must be a record HELP_BOOK_HANDLER.myownformat of functions with the following names and functionality.

An implementation example of such a set of handler functions is the default format, which is the format name used for the gapmacro.tex documentation format, and this is contained in the file lib/helpdef.gi.

The package &GAPDoc; (see Chapter ) also defines a format (as it should) which is called: GapDocGAP (the case is significant).

As you can see by the above two examples, the name for a document format can be anything, but it should be in some way meaningful.

ReadSix( stream ) For an input text stream stream to a manual.six file, this must return a record info which has at least the following two components: bookname which is the short identifying name of the help book, and entries. Here info.entries must be a list with one entry per search string (which can be a section header, function name, index entry, or whatever seems sensible to be searched for matching a help query). A match for the &GAP; help is a pair (info, i) where i refers to an index for the list info.entries and this corresponds to a certain position in the document. There is one further regulation for the format of the entries of info.entries. They must be lists and the first element of such a list must be a string which is printed by &GAP; for example when several matches are found for a query (so it should essentially be the string which is searched for the match, except that it may contain upper and lower case letters or some markup). There may be other components in info which are needed by the functions below, but their names and formats are not prescribed. The stream argument is typically generated using , e.g.

dirs := DirectoriesLibrary( "doc/ref" );; gap> file := Filename( dirs, "manual.six" );; gap> stream := InputTextFile( file );; ]]> ShowChapters( info ) This must return a text string or list of text lines which contains the chapter headers of the book info.bookname. ShowSection( info ) This must return a text string or list of text lines which contains the section (and chapter) headers of the book info.bookname. SearchMatches( info, topic, frombegin ) This function must return a list of indices of info.entries for entries which match the search string topic. If frombegin is true then those parts of topic which are separated by spaces should be considered as the beginnings of words to decide the matching. It frombegin is false, a substring search should be performed. The string topic can be assumed to be already normalized (transformed to lower case, and whitespace normalized). The function must return a list with two entries [exact, match] where exact is the list of indices for exact matches and match a list of indices of the remaining matches. MatchPrevChap( info, i ) This should return the match [info, j] which points to the beginning of the chapter containing match [info, i], respectively to the beginning of the previous chapter if [info, i] is already the beginning of a chapter. (Corresponds to ?<<.) MatchNextChap( info, i ) Like the previous function except that it should return the match for the beginning of the next chapter. (Corresponds to ?>>.) MatchPrev( info, i ) This should return the previous section (or appropriate portion of the document). (Corresponds to ?<.) MatchNext( info, i ) Like the previous function except that it should return the next section (or appropriate portion of the document). (Corresponds to ?>.) HelpData( info, i, type ) This returns for match [info, i] some data whose format depends on the string type, or fail if these data are not available. The values of type which currently must be handled and the corresponding result format are described in the list below.

The HELP_BOOK_HANDLER.myownformat.HelpData function must recognize the following values of the type argument.

"text" This must return a corresponding text string in a format which can be fed into the Pager, see . "url" If the help book is available in HTML format this must return an URL as a string (Probably a file:// URL containing a label for the exact start position in that file). Otherwise it returns fail. "dvi" If the help book is available in dvi-format this must return a record of form rec( file := filename, page := pagenumber ). Otherwise it returns fail. "pdf" Same as case "dvi", but for the corresponding pdf-file. "secnr" This must return a pair like [[3,3,1], "3.3.1"] which gives the section number as chapter number, section number, subsection number triple and a corresponding string (a chapter itself is encoded like [[4,0,0], "4."]). Useful for cross-referencing between help books.

Introducing new Viewer for the Online Help To introduce a new viewer for the online help, one should extend the global record , the structure of which is explained below. <#Include Label="HELP_VIEWER_INFO">
gap-4r6p5/doc/ref/algfld.xml0000644000175000017500000000677012172557252014447 0ustar billbill Algebraic extensions of fields If we adjoin a root \alpha of an irreducible polynomial f \in K[x] to the field K we get an algebraic extension K(\alpha), which is again a field. We call K the base field of K(\alpha).

By Kronecker's construction, we may identify K(\alpha) with the factor ring K[x]/(f), an identification that also provides a method for computing in these extension fields.

It is important to note that different extensions of the same field are entirely different (and its elements lie in different families), even if mathematically one could be embedded in the other one.

Currently &GAP; only allows extension fields of fields K, when K itself is not an extension field.

Creation of Algebraic Extensions <#Include Label="AlgebraicExtension"> <#Include Label="IsAlgebraicExtension">
Elements in Algebraic Extensions Operations for algebraic elements According to Kronecker's construction, the elements of an algebraic extension are considered to be polynomials in the primitive element. The elements of the base field are represented as polynomials of degree zero. &GAP; therefore displays elements of an algebraic extension as polynomials in an indeterminate a, which is a root of the defining polynomial of the extension. Polynomials of degree zero are displayed with a leading exclamation mark to indicate that they are different from elements of the base field.

The usual field operations are applicable to algebraic elements.

a^3/(a^2+a+1); -1/2*a^3+1/2*a^2-1/2*a gap> a*(1/a); !1 ]]>

The external representation of algebraic extension elements are the polynomial coefficients in the primitive element a, the operations and can be used for conversion.

ExtRepOfObj(One(a)); [ 1, 0, 0, 0 ] gap> ExtRepOfObj(a^3+2*a-9); [ -9, 2, 0, 1 ] gap> ObjByExtRep(FamilyObj(a),[3,19,-27,433]); 433*a^3-27*a^2+19*a+3 ]]>

&GAP; does not embed the base field in its algebraic extensions and therefore lists which contain elements of the base field and of the extension are not homogeneous and thus cannot be used as polynomial coefficients or to form matrices. The remedy is to multiply the list(s) with the value of the attribute of the extension which will embed all entries in the extension.

m:=[[1,a],[0,1]]; [ [ 1, a ], [ 0, 1 ] ] gap> IsMatrix(m); false gap> m:=m*One(e); [ [ !1, a ], [ !0, !1 ] ] gap> IsMatrix(m); true gap> m^2; [ [ !1, 2*a ], [ !0, !1 ] ] ]]> <#Include Label="IsAlgebraicElement">

gap-4r6p5/doc/ref/ctblmono.xml0000644000175000017500000000524112172557252015023 0ustar billbill Monomiality Questions This chapter describes functions dealing with the monomiality of finite (solvable) groups and their characters.

<#Include Label="[1]{ctblmono}">

Several examples in this chapter use the symmetric group S_4 and the special linear group SL(2,3). For running the examples, you must first define the groups, for example as follows.

S4:= SymmetricGroup( 4 );; SetName( S4, "S4" ); gap> Sl23:= SL( 2, 3 );; ]]>

InfoMonomial (Info Class) <#Include Label="InfoMonomial">
Character Degrees and Derived Length <#Include Label="Alpha"> <#Include Label="Delta"> <#Include Label="IsBergerCondition">
Primitivity of Characters <#Include Label="TestHomogeneous"> <#Include Label="IsPrimitiveCharacter"> <#Include Label="TestQuasiPrimitive"> <#Include Label="TestInducedFromNormalSubgroup">
Testing Monomiality <#Include Label="[2]{ctblmono}"> <#Include Label="TestMonomial"> <#Include Label="TestMonomialUseLattice"> <#Include Label="IsMonomialNumber"> <#Include Label="TestMonomialQuick"> <#Include Label="TestSubnormallyMonomial"> <#Include Label="TestRelativelySM">
Minimal Nonmonomial Groups <#Include Label="IsMinimalNonmonomial"> <#Include Label="MinimalNonmonomialGroup">
gap-4r6p5/doc/ref/run.xml0000644000175000017500000006774612172557252014034 0ustar billbill Running GAP options This chapter informs about command line options for &GAP; (see ), some files in user specific &GAP; root directory (see ) and saving and loading a &GAP; workspace (see ).
Command Line Options features UNIX options UNIX GAPInfo.CommandLineOptions When you start &GAP; from a command line or from a script you may specify a number of options on the command-line to change the default behaviour of &GAP;. All these options start with a hyphen -, followed by a single letter. Options must not be grouped, e.g., gap -gq is invalid, use gap -g -q instead. Some options require an argument, this must follow the option and must be separated by whitespace, e.g., gap -m 256m, it is not correct to say gap -m256m instead. Certain Boolean options (-b, -q, -e, -r, -A, -D, -M, -T, -X, -Y) toggle the current value so that gap -b -b is equivalent to gap and to gap -b -q -b -q etc.

&GAP; for UNIX will distinguish between upper and lower case options.

As described in the &GAP; installation instructions (see the INSTALL file in the &GAP; root directory, or at http://www.gap-system.org/Download/INSTALL), usually you will not execute &GAP; directly. Instead you will call a (shell) script, with the name gap, which in turn executes &GAP;. This script sets some options which are necessary to make &GAP; work on your system. This means that the default settings mentioned below may not be what you experience when you execute &GAP; on your system.

During a &GAP; session, one can find the current values of command line options in the record GAPInfo.CommandLineOptions (see ), whose component names are the command line options (without the leading -).

-A -A By default, some needed and suggested &GAP; packages (see ) are loaded, if present, into the &GAP; session when it starts. This option disables (actually toggles) the loading of suggested packages, which can be useful for debugging or testing. The needed packages (and their needed packages, and so on) are loaded in any case. -a -a memory GASMAN, the storage manager of &GAP; uses sbrk to get blocks of memory from (certain) operating systems and it is required that subsequent calls to sbrk produce adjacent blocks of memory in this case because &GAP; only wants to deal with one large block of memory. If the C function malloc is called for whatever reason, it is likely that sbrk will no longer produce adjacent blocks, therefore &GAP; does not use malloc itself.

However some operating systems insist on calling malloc to create a buffer when a file is opened, or for some other reason. In order to catch these cases &GAP; preallocates a block of memory with malloc which is immediately freed. The amount preallocated can be controlled with the -a option. (Most users do not need this option.)

The option argument memory is specified as with the -m option. -B -B architecture Executable binary files that form part of &GAP; or of a &GAP; package are kept in a subdirectory of the bin directory within the &GAP; or package root directory. The subdirectory name is determined from the operating system, processor and compiler details when &GAP; (resp. the package) is installed. Under rare circumstances, it may be necessary to override this name, and this can be done using the -B option. -b -b tells &GAP; to suppress the banner. That means that &GAP; immediately prints the prompt. This is useful when, after a while, you get tired of the banner. This option can be repeated to enable the banner; each -b toggles the state of banner display. -D -D The -D option tells &GAP; to print short messages when it is reading files or loading modules. This option may be repeated to toggle this behavior on and off. The message,

tells you that &GAP; has started to read the library file lib/kernel.g.

tells you that &GAP; has used the compiled version of the library file lib/kernel.g. This compiled module was statically linked to the &GAP; kernel at the time the kernel was created.

tells you that &GAP; has loaded the compiled version of the library file lib/kernel.g. This compiled module was dynamically loaded to the &GAP; kernel at runtime from a corresponding .so file.

Obviously, this is a debugging option and most users will not need it. -E -E If your &GAP; installation uses the readline library for command line editing (see ), this may be disabled by using -E option. This option may be repeated to toggle this behavior on and off. If your &GAP; installation does not use the readline library (you can check by IsBound(GAPInfo.UseReadline); if this is the case), this option will have no effect at all. -e -e tells &GAP; not to quit when receiving a Ctrl-D on an empty input line (see ). This option should not be used when the input is a file or pipe. This option may be repeated to toggle this behavior on and off. -f -f tells &GAP; to enable the line editing and history (see ).

In general line editing will be enabled if the input is connected to a terminal. There are rare circumstances, for example when using a remote session with a corrupted telnet implementation, when this detection fails. Try using -f in this case to enable line editing. This option does not toggle; you must use -n to disable line editing. -g -g tells &GAP; to print a message every time a full garbage collection is performed.

For example, this tells you that there are 44580 live objects that survived a full garbage collection, that 57304 unused objects were reclaimed by it, and that 734 kilobytes from a total allocated memory of 4096 kilobytes are available afterwards. -g -g -g -g If you give the option -g twice, &GAP; prints a information message every time a partial or full garbage collection is performed. The message,

for example, tells you that 9405 objects survived the partial garbage collection and 7525 objects were reclaimed, and that 2541 kilobytes from a total allocated memory of 4096 kilobytes are available afterwards. -h -h tells &GAP; to print a summary of all available options (-h is mnemonic for help). &GAP; exits after printing the summary, all other options are ignored. -i -i filename changes the name of the init file from the default init.g to filename. (Usually not needed.) -K -K memory is like the -o option. But while the latter actually allocates more memory if the system allows it and then prints a warning inside a break loop the -K options tells &GAP; not even to try to allocate more memory. Instead &GAP; just exits with an appropriate message. The default is that this feature is switched off. You have to set it explicitly when you want to enable it. -L -L filename The option -L tells &GAP; to load a saved workspace. See section . -l -l path_list can be used to set or modify &GAP;'s list of root directories (see ). The default if no -l option is given is the current directory ./. This option can be used several times. Depending on the -r option a further user specific path is prepended to the list of root directories (the path in GAPInfo.UserGapRoot).

path_list should be a list of directories separated by semicolons. No whitespace is permitted before or after a semicolon. If path_list does not start or end with a semicolon, then path_list replaces the existing list of root directories. If path_list starts with a semicolon, then path_list is appended to the existing list of root directories. If path_list ends with a semicolon and does not start with one, then the new list of root directories is the concatenation of path_list and the existing list of root directories. After &GAP; has completed its startup procedure and displays the prompt, the list of root directories can be seen in the variable GAPInfo.RootPaths, see .

Usually this option is used inside a startup script to specify where &GAP; is installed on the system. The -l option can also be used by individual users to tell &GAP; about privately installed modifications of the library, additional &GAP; packages and so on. Section explains how several root paths can be used to do this.

&GAP; will attempt to read the file root_dir/lib/init.g during startup where root_dir is one of the directories in its list of root directories. If &GAP; cannot find its init.g file it will print the following warning.

'? ]]>

It is not possible to use &GAP; without the library files, so you must not ignore this warning. You should leave &GAP; and start it again, specifying the correct root path using the -l option. -M -M tells &GAP; not to check for, nor to use, compiled versions of library files. This option may be repeated to toggle this behavior on and off. -m -m memory tells &GAP; to allocate memory bytes at startup time. If the last character of memory is k or K it is taken as kilobytes, if the last character is m or M memory is taken as megabytes and if it is g or G it is taken as gigabytes.

This amount of memory should be large enough so that computations do not require too many garbage collections. On the other hand, if &GAP; allocates more memory than is physically available, it will spend most of the time paging. -n -n tells &GAP; to disable the line editing and history (see ).

You may want to do this if the command line editing is incompatible with another program that is used to run &GAP;. For example if &GAP; is run from inside a GNU Emacs shell window, -n should be used since otherwise every input line will be echoed twice, once by Emacs and once by &GAP;. This option does not toggle; you must use -f to enable line editing. -O -O disables loading obsolete variables (see Chapter ). This option is used mainly for testing purposes, for example in order to make sure that a &GAP; package or one's own &GAP; code does not rely on the obsolete variables. -o -o memory tells &GAP; to allocate at most memory bytes without asking. The option argument memory is specified as with the -m option.

If more than this amount is required during the &GAP; session, &GAP; prints an error message and enters a break loop. In that case you can enter return; which implicitly doubles the amount given with this option. -q -q tells &GAP; to be quiet. This means that &GAP; displays neither the banner nor the prompt gap>. This is useful if you want to run &GAP; as a filter with input and output redirection and want to avoid the banner and the prompts appearing in the output file. This option may be repeated to disable quiet mode; each -q toggles quiet mode. -R -R The option -R tells &GAP; not to load a saved workspace previously specified via the -L option. This option does not toggle. -r -r The option -r tells &GAP; to ignore any user specific configuration files. In particular, the user specific root directory GAPInfo.UserGapRoot is not added to the &GAP; root directories and so gap.ini and gaprc files that may be contained in that directory are not read, see . Multiple -r options toggle this behaviour. -s -s memory With this option &GAP; does not use sbrk to get memory from the operating system. Instead it uses mmap, malloc or some other command for the amount given with this option to allocate space for the GASMAN memory manager. Usually &GAP; does not really use all of this memory, the options -m, -o, -K still work as documented. This feature assumes that the operating system only assigns physical memory to the &GAP; process when it is accessed, so that specifying a large amount of memory with -s should not cause any performance problem. The advantage of using this option is that &GAP; can work together with kernel modules which allocate a lot of memory with malloc.

The option argument memory is specified as with the -m option. -T -T suppresses the usual break loop behaviour of &GAP;. With this option &GAP; behaves as if the user quit immediately from every break loop. This is intended for automated testing of &GAP;. This option may be repeated to toggle this behavior on and off. -X -X tells &GAP; to do a consistency check of the library file and the corresponding compiled module when loading the compiled module. This option may be repeated to toggle this behavior on and off. -x -x length With this option you can tell &GAP; how long lines are. &GAP; uses this value to decide when to split long lines. After starting &GAP; you may use to alter the line length.

The default value is 80, unless another value can be obtained from the Operating System, which is the right value if you have a standard terminal application. If you have a larger monitor, or use a smaller font, or redirect the output to a printer, you may want to increase this value. -y -y length With this option you can tell &GAP; how many lines your screen has. &GAP; uses this value to decide after how many lines of on-line help it should wait. After starting &GAP; you may use to alter the number of lines.

The default value is 24, unless another value can be obtained from the Operating System, which is the right value if you have a standard terminal application. If you have a larger monitor, or use a smaller font, or redirect the output to a printer, you may want to increase this value. options filename ... Further arguments are taken as filenames of files that are read by &GAP; during startup, after the system and private init files are read, but before the first prompt is printed. The files are read in the order in which they appear on the command line. &GAP; only accepts up to 14 filenames on the command line. If a file cannot be opened &GAP; will print an error message and will abort.

options -C-U -P-W -z-p Additional options, -C, -U, -P, -W, -p and -z are used internally by the gac script (see ) and/or on specific operating systems.

The gap.ini and gaprc files When you start &GAP;, it looks for files with the names gap.ini and gaprc in its root directories (see ), and reads the first gap.ini and the first gaprc file it finds. These files are used for certain initializations, as follows.

The file gap.ini is read early in the startup process. Therefore, the parameters set in this file can influence the startup process, such as which packages are automatically loaded (see ) and whether library files containing obsolete variables are read (see Chapter ). On the other hand, only calls to a restricted set of &GAP; functions are allowed in a gap.ini file. Usually, it should only contain calls of . This file can be generated (or updated when new releases introduce further user preferences) with the command . This file is read whenever &GAP; is started, with or without a workspace.

The file gaprc is read after the startup process, before the first input file given on the command line (see ). So the contents of this file cannot influence the startup process, but all &GAP; library functions can be called in this file. When &GAP; is started with a workspace then the file is read only if no gaprc file had been read before the workspace was created. (With this setup, it is on the one hand possible that administrators provide a &GAP; workspace for several users such that the user's gaprc file is read when &GAP; is started with the workspace, and on the other hand one can start &GAP;, read one's gaprc file, save a workspace, and then start from this workspace without reading one's gaprc file again.)

Note that by default, the user specific &GAP; root directory GAPInfo.UserGapRoot is the first &GAP; root directory. So you can put your gap.ini and gaprc files into this directory.

This mechanism substitutes the much less flexible reading of a users .gaprc file in versions of &GAP; up to 4.4. For compatibility this .gaprc file is still read if the directory GAPInfo.UserGapRoot does not exist, see how to migrate your old setup. The gap.ini file gap.ini The file gap.ini is read after the declaration part of the &GAP; library is read, before the declaration parts of the packages needed and suggested by &GAP; are read, and before the implementation parts of &GAP; and of the packages are read.

The file gap.ini is expected to consist of calls to the function , see Section .

Since the file gap.ini is read before the implementation part of &GAP; is read, not all &GAP; functions may be called in the file. Assignments of numbers, lists, and records are admissible as well as calls to basic functions such as and .

Note that the file gap.ini is read also when &GAP; is started with a workspace. The gaprc file If a file gaprc is found it is read after &GAP;'s init.g, but before any of the files mentioned on the command line are read. You can use this file for your private customizations. (Many users may be happy with using just user preferences in the gap.ini file (see above) for private customization.) For example, if you have a file containing functions or data that you always need, you could read this from gaprc. Or if you find some of the names in the library too long, you could define abbreviations for those names in gaprc. The following sample gaprc file does both.

Note that only one gaprc file is read when &GAP; is started. When a workspace is created in a &GAP; session after a gaprc file has been read then no more gaprc file will be read when &GAP; is started with this workspace.

Also note that the file must be called gaprc. If you use a Windows text editor, in particular if your default is not to show file suffixes, you might accidentally create a file gaprc.txt or gaprc.doc which GAP will not recognize. <#Include Label="UserPreferences">

Saving and Loading a Workspace &GAP; workspace files are binary files that contain the data of a &GAP; session. One can produce a workspace file with , and load it into a new &GAP; session using the -L command line option, see Section .

One purpose of workspace files is of course the possibility to save a snapshot image of the current &GAP; workspace in a file.

The recommended way to start &GAP; is to load an existing workspace file, because this reduces the startup time of &GAP; drastically. So if you have installed &GAP; yourself then you should think about creating a workspace file immediately after you have started &GAP;, and then using this workspace file later on, whenever you start &GAP;. If your &GAP; installation is shared between several users, the system administrator should think about providing such a workspace file. save will save a snapshot image of the current &GAP; workspace in the file filename. This image then can be loaded by another copy of &GAP; which then will behave as at the point when was called.

a:=1; gap> SaveWorkspace("savefile"); true gap> quit; ]]>

can only be used at the main gap> prompt. It cannot be included in the body of a loop or function, or called from a break loop.

Testing for the System Architecture <#Include Label="ARCH_IS_UNIX"> <#Include Label="ARCH_IS_MAC_OS_X"> <#Include Label="ARCH_IS_WINDOWS">
Global Values that Control the &GAP; Session Several global values control the &GAP; session, such as the command line, the architecture, or the information about available and loaded packages. Many of these values are accessible as components of the global record . Typically, these components are set and read in low level &GAP; functions, so changing the values of existing components of by hand is not recommended.

Important components are documented via index entries, try the input ??GAPInfo for getting an overview of these components.

Coloring the Prompt and Input &GAP; provides hooks for functions which are called when the prompt is to be printed and when an input line is finished.

An example of using this feature is the following function. <#Include Label="ColorPrompt">

gap-4r6p5/doc/ref/process.xml0000644000175000017500000000200112172557252014653 0ustar billbill Processes <#Include Label="[1]{process}">
Process and Exec <#Include Label="Process"> <#Include Label="Exec">
gap-4r6p5/doc/ref/runexamples.g0000644000175000017500000000234212172557252015176 0ustar billbill# This runs the examples from the ref manual chapter-wise and indicates # differences in files EXAMPLEDIFFSnr where nr is the number of the chapter. SaveWorkspace("wsp"); for i in [1..Length(exsref)] do Print("Checking ref, Chapter ",i,"\n"); resfile := Concatenation( "EXAMPLEDIFFS", ListWithIdenticalEntries(2-Length(String(i)),'0'), String(i) ); RemoveFile(resfile); Exec(Concatenation("echo 'RunExamples(exsref{[", String(i), "]}", # By default compare up to whitespace, so some editing wrt. line breaks # or other whitespace in example output is accepted. # Comment the "WS" for comparison with \=. # Uncomment the "WSRS" or "RS" to change the source code to the # current output. ", WS", ## ", RS", ## ", WSRS", ");' | ../../bin/gap.sh -b -r -A -q -L wsp > ", resfile )); str := StringFile(resfile); if str{[Length(str)-22..Length(str)]} = "# Running list 1 . . .\n" then RemoveFile(resfile); else pos := PositionSublist(str, "# Running list 1 . . .\n"); FileString(resfile, str{[pos+23..Length(str)]}); Print(" found differences in ref, see file ", resfile, "\n"); fi; od; RemoveFile("wsp"); QUIT; gap-4r6p5/doc/ref/makedocreldata.g0000644000175000017500000001313212172557252015572 0ustar billbill############################################################################# ## ## values for the `MakeGAPDocDoc' call that builds the Reference Manual ## GAPInfo.ManualDataRef:= rec( pathtodoc:= ".", main:= "main.xml", bookname:= "ref", pathtoroot:= "../..", files:= [ "../../src/sysfiles.c", "../../grp/basic.gd", "../../grp/classic.gd", "../../grp/perf.gd", "../../grp/ree.gd", "../../grp/suzuki.gd", "../../lib/addmagma.gd", "../../lib/algebra.gd", "../../lib/algfld.gd", "../../lib/algfp.gd", "../../lib/alghom.gd", "../../lib/alghom.gi", "../../lib/alglie.gd", "../../lib/algrep.gd", "../../lib/arith.gd", "../../lib/attr.gd", "../../lib/basis.gd", "../../lib/basismut.gd", "../../lib/boolean.g", "../../lib/clas.gd", "../../lib/cmdledit.g", "../../lib/coll.gd", "../../lib/colorprompt.g", "../../lib/combinat.gd", "../../lib/contfrac.gd", "../../lib/csetgrp.gd", "../../lib/ctbl.gd", "../../lib/ctbl.gi", "../../lib/ctblauto.gd", "../../lib/ctblfuns.gd", "../../lib/ctblgrp.gd", "../../lib/ctbllatt.gd", "../../lib/ctblmaps.gd", "../../lib/ctblmoli.gd", "../../lib/ctblmono.gd", "../../lib/ctblpope.gd", "../../lib/ctblsolv.gd", "../../lib/ctblsymm.gd", "../../lib/cyclotom.g", "../../lib/cyclotom.gd", "../../lib/cyclotom.gi", "../../lib/dict.gd", "../../lib/domain.gd", "../../lib/extlset.gd", "../../lib/factgrp.gd", "../../lib/ffe.gd", "../../lib/field.gd", "../../lib/files.gd", "../../lib/filter.g", "../../lib/fldabnum.gd", "../../lib/float.gd", "../../lib/fpmon.gd", "../../lib/fpsemi.gd", "../../lib/function.g", "../../lib/galois.gd", "../../lib/gasman.gd", "../../lib/ghom.gd", "../../lib/ghomfp.gd", "../../lib/ghompcgs.gd", "../../lib/ghomperm.gd", "../../lib/global.gd", "../../lib/gpprmsya.gd", "../../lib/gprd.gd", "../../lib/groebner.gd", "../../lib/grp.gd", "../../lib/grpffmat.gd", "../../lib/grpfp.gd", "../../lib/grpfree.gd", "../../lib/grplatt.gd", "../../lib/grpmat.gd", "../../lib/grpnames.gd", "../../lib/grpnice.gd", "../../lib/grppc.gd", "../../lib/grppccom.gd", "../../lib/grppcext.gd", "../../lib/grppcfp.gd", "../../lib/grppclat.gd", "../../lib/grpperm.gd", "../../lib/grpramat.gd", "../../lib/grpreps.gd", "../../lib/grptbl.gd", "../../lib/helpview.gd", "../../lib/ideal.gd", "../../lib/integer.gd", "../../lib/kbsemi.gd", "../../lib/kernel.g", "../../lib/liefam.gd", "../../lib/lierep.gd", "../../lib/list.g", "../../lib/list.gd", "../../lib/listcoef.gd", "../../lib/magma.gd", "../../lib/mapphomo.gd", "../../lib/mapping.gd", "../../lib/matblock.gd", "../../lib/matint.gd", "../../lib/matrix.gd", "../../lib/matobj1.gd", "../../lib/matobj2.gd", "../../lib/methsel2.g", "../../lib/methwhy.g", "../../lib/mgmadj.gd", "../../lib/mgmhom.gd", "../../lib/mgmring.gd", "../../lib/mgmring.gi", "../../lib/module.gd", "../../lib/monoid.gd", "../../lib/morpheus.gd", "../../lib/numtheor.gd", "../../lib/object.gd", "../../lib/object.gi", "../../lib/obsolete.gd", "../../lib/onecohom.gd", "../../lib/oper.g", "../../lib/oper1.g", "../../lib/oprt.gd", "../../lib/options.gd", "../../lib/orders.gd", "../../lib/package.gd", "../../lib/padics.gd", "../../lib/pager.gd", "../../lib/pcgs.gd", "../../lib/pcgsind.gd", "../../lib/pcgsmodu.gd", "../../lib/pcgspcg.gd", "../../lib/pcgsspec.gd", "../../lib/permutat.g", "../../lib/polyconw.gd", "../../lib/polyrat.gd", "../../lib/pquot.gd", "../../lib/primality.gd", "../../lib/process.gd", "../../lib/profile.g", "../../lib/proto.gd", "../../lib/randiso.gd", "../../lib/random.gd", "../../lib/ratfun.gd", "../../lib/record.g", "../../lib/reesmat.gd", "../../lib/relation.gd", "../../lib/reread.g", "../../lib/ring.gd", "../../lib/ringhom.gd", "../../lib/ringpoly.gd", "../../lib/rws.gd", "../../lib/rwsgrp.gd", "../../lib/rwspcclt.gd", "../../lib/rwspcgrp.gd", "../../lib/rwssmg.gd", "../../lib/schur.gd", "../../lib/schursym.gd", "../../lib/semicong.gd", "../../lib/semigrp.gd", "../../lib/semiquo.gd", "../../lib/semirel.gd", "../../lib/semiring.gd", "../../lib/semitran.gd", "../../lib/set.gd", "../../lib/sgpres.gd", "../../lib/smgideal.gd", "../../lib/stbc.gd", "../../lib/stbcbckt.gd", "../../lib/straight.gd", "../../lib/streams.gd", "../../lib/string.g", "../../lib/string.gd", "../../lib/system.g", "../../lib/teaching.g", "../../lib/tcsemi.gd", "../../lib/test.gi", "../../lib/tietze.gd", "../../lib/tom.gd", "../../lib/trans.gd", "../../lib/tuples.gd", "../../lib/twocohom.gd", "../../lib/type.g", "../../lib/type1.g", "../../lib/unknown.gd", "../../lib/upoly.gd", "../../lib/userpref.g", "../../lib/variable.g", "../../lib/vecmat.gd", "../../lib/vspc.gd", "../../lib/vspchom.gd", "../../lib/word.gd", "../../lib/wordass.gd", "../../lib/zlattice.gd", "../../lib/zmodnz.gd", "../../prim/irredsol.gd", "../../prim/primitiv.gd", "../../grp/simple.gd", "../../small/small.gd", "../../trans/trans.gd", "../../tst/testall.g", "../../tst/testinstall.g", ], );; ############################################################################# ## #E gap-4r6p5/doc/ref/obsolete.xml0000644000175000017500000001723012172557252015023 0ustar billbill Replaced and Removed Command Names <#Include Label="obsolete_intro">
Group Actions – Name Changes group operations The concept of a group action is sometimes referred to as a group operation. In &GAP; 3 as well as in older versions of &GAP; 4 the term Operation was used instead of Action. We decided to change the names to avoid confusion with the term operation as in and operations for Xyz.

Here are some examples of such name changes.

Operation RepresentativeOperation OperationHomomorphism FunctionOperation OLD NOW USE Operation RepresentativeOperation OperationHomomorphism FunctionOperation

Package Interface – Obsolete Functions and Name Changes With &GAP; 4.4 the package interface was changed. Thereby some functions became obsolete and the names of some others were made more consistent.

DeclarePackage DeclareAutoPackage DeclarePackageDocumentation DeclarePackageAutoDocumentation The following functions are no longer needed: DeclarePackage, DeclareAutoPackage, DeclarePackageDocumentation and DeclarePackageAutoDocumentation. They are substituted by entries in the packages' PackageInfo.g files, see .

Furthermore, the global variable PACKAGES_VERSIONS is no longer needed, since this information is now contained in the GAPInfo.PackagesInfo record (see ). The global variable Revisions is also no longer needed, since the function DisplayRevision was made obsolete in &GAP; 4.5.

The following function names were changed.

RequirePackage ReadPkg RereadPkg OLD NOW USE RequirePackage ReadPkg RereadPkg

Normal Forms of Integer Matrices – Name Changes Smith normal form Hermite normal form Former versions of &GAP; 4 documented several functions for computing the Smith or Hermite normal form of integer matrices. Some of them were never implemented and it was unclear which commands to use. The functionality of all of these commands is now available with and a few interface functions.
Miscellaneous Name Changes or Removed Names QUIET BANNER In former releases of &GAP; 4 there were some global variable names bound to general information about the running &GAP;, such as path names or command line options. Although they were not officially documented they were used by several users and in some packages. We mention here BANNER and QUIET. This type of information is now collected in the global record .

Here are some further name changes.

MonomialTotalDegreeLess NormedVectors MutableIdentityMat MutableNullMat OLD NOW USE MonomialTotalDegreeLess NormedVectors MutableIdentityMat MutableNullMat

The former .gaprc file Up to &GAP; 4.4, a file .gaprc in the user's home directory (if available, and &GAP; was started without -r option) was read automatically during startup, early enough for influencing the autoloading of packages and late enough for being allowed to execute any &GAP; code. On Windows machines this file was called gap.rc.

In &GAP; 4.5 the startup mechanism has changed, see for details. These new configuration files are now contained in a directory GAPInfo.UserGapRoot.

For the sake of partial backwards compatibility, also the former file ~/.gaprc is still supported for such initializations, but this file is read only if the directory GAPInfo.UserGapRoot does not exist. In that case the ~/.gaprc is read at the same time as gaprc would be read, i. e., too late for influencing the startup of &GAP;.

As before, the command line option -r disables reading ~/.gaprc, see .

To migrate from the old setup to the new one introduced with &GAP; 4.5, first have a look at the function . Many users will find that all or most of what was set in the old ~/.gaprc file can now be done via the user preferences in a gap.ini file. If you had code for new functions or abbreviations in your old ~/.gaprc file or you were reading additional files, then move this into the file gaprc (without the leading dot, same name for all operating systems) in the directory GAPInfo.UserGapRoot.

gap-4r6p5/doc/ref/lists.xml0000644000175000017500000020675712172557252014363 0ustar billbill Lists Lists are the most important way to treat objects together. A list arranges objects in a definite order. So each list implies a partial mapping from the integers to the elements of the list. I.e., there is a first element of a list, a second, a third, and so on. Lists can occur in mutable or immutable form, see  for the concept of mutability, and  for the case of lists.

This chapter deals mainly with the aspect of lists in &GAP; as data structures. Chapter  tells more about the collection aspect of certain lists, and more about lists as arithmetic objects can be found in the chapters and .

Lists are used to implement ranges (see ), sets (see ),Sets strings (see ), row vectors (see ), and matrices (see ); Boolean lists (see ) are a further special kind of lists.

Several operations for lists, such as and , will be described in Chapter , in particular see .

List Categories A list can be written by writing down the elements in order between square brackets [, ], and separating them with commas ,. An empty list, i.e., a list with no elements, is written as [].

[ 1, 2, 3 ]; # a list with three elements [ 1, 2, 3 ] gap> [ [], [ 1 ], [ 1, 2 ] ]; # a list may contain other lists [ [ ], [ 1 ], [ 1, 2 ] ] ]]>

Each list constructed this way is mutable (see ). <#Include Label="IsList"> <#Include Label="IsDenseList"> <#Include Label="IsHomogeneousList"> <#Include Label="IsTable"> <#Include Label="IsRectangularTable"> <#Include Label="IsConstantTimeAccessList">

Basic Operations for Lists The basic operations for lists are element access (see ), assignment of elements to a list (see ), fetching the length of a list (see ), the test for a hole at a given position, and unbinding an element at a given position (see ).

The term basic operation means that each other list operation can be formulated in terms of the basic operations. (But note that usually a more efficient method than this one is implemented.)

Any &GAP; object list in the category is regarded as a list, and if methods for the basic list operations are installed for list then list can be used also for the other list operations.

For internally represented lists, kernel methods are provided for the basic list operations. For other lists, it is possible to install appropriate methods for these operations. This permits the implementation of lists that do not need to store all list elements (see also ); for example, the elements might be described by an algorithm, such as the elements list of a group. For this reduction of space requirements, however, a price in access time may have to be paid (see ).

list element list boundedness test list assignment list unbind These operations implement element access, test for element boundedness, list element assignment, and removal of the element at position pos. In all cases, the index pos must be a positive integer.

Note that the special characters [, ], :, and = must be escaped with a backslash \ (see ); so denotes the operation for element access in a list, whereas [] denotes an empty list. (Maybe the variable names involving special characters look strange, but nevertheless they are quite suggestive.)

\[\]( list, pos ) is equivalent to list[ pos ], which clearly will usually be preferred; the former is useful mainly if one wants to access the operation itself, for example if one wants to install a method for element access in a special kind of lists.

Similarly, is used explicitly mainly in method installations. In other situations, one can simply call , which then delegates to if the first argument is a list, and to if the first argument is a record.

Analogous statements hold for and .

List Elements accessing list element list[ pos ]

The above construct evaluates to the pos-th element of the list list, where pos must be a positive integer. List indexing is done with origin 1, i.e., the first element of the list is the element at position 1. l := [ 2, 3, 5, 7, 11, 13 ];; l[1]; l[2]; l[6]; 2 3 13 ]]> If list is not a list, or pos does not evaluate to a positive integer, or list[pos] is unbound an error is signalled.

sublist sublist list{ poss }

The above construct evaluates to a new list new whose first element is list[poss[1]], whose second element is list[poss[2]], and so on. poss must be a dense list of positive integers. However, it does not need to be sorted and may contain duplicate elements. If for any i, list[ poss[i] ] is unbound, an error is signalled.

l := [ 2, 3, 5, 7, 11, 13, 17, 19 ];; gap> l{[4..6]}; l{[1,7,1,8]}; [ 7, 11, 13 ] [ 2, 17, 2, 19 ] ]]>

The result is a new list, that is not identical to any other list. The elements of that list, however, are identical to the corresponding elements of the left operand (see ).

It is possible to nest such sublist extractions, as can be seen in the example below.

m := [ [1,2,3], [4,5,6], [7,8,9], [10,11,12] ];; m{[1,2,3]}{[3,2]}; [ [ 3, 2 ], [ 6, 5 ], [ 9, 8 ] ] gap> l := m{[1,2,3]};; l{[3,2]}; [ [ 7, 8, 9 ], [ 4, 5, 6 ] ] ]]>

Note the difference between the two examples. The latter extracts elements 1, 2, and 3 from m and then extracts the elements 3 and 2 from this list. The former extracts elements 1, 2, and 3 from m and then extracts the elements 3 and 2 from each of those element lists.

To be precise: With each selector [pos] or {poss} we associate a level that is defined as the number of selectors of the form {poss} to its left in the same expression. For example

Then a selector list[pos] of level level is computed as ListElement(list,pos,level), where ListElement is defined as follows. (Note that ListElement is not a &GAP; function.)

ListElement(elm,pos,level-1) ); fi; end; ]]>

and a selector list{poss} of level level is computed as ListElements(list,poss,level), where ListElements is defined as follows. (Note that ListElements is not a &GAP; function.)

ListElements(elm,poss,level-1) ); fi; end; ]]>

sublist This operation implements sublist access. For any list, the default method is to loop over the entries in the list poss, and to delegate to the element access operation. (For the somewhat strange variable name, cf. .)

List Assignment assignment list element list[ pos ] := object;

The list element assignment assigns the object object, which can be of any type, to the list entry at the position pos, which must be a positive integer, in the mutable (see ) list list. That means that accessing the pos-th element of the list list will return object after this assignment.

l := [ 1, 2, 3 ];; gap> l[1] := 3;; l; # assign a new object [ 3, 2, 3 ] gap> l[2] := [ 4, 5, 6 ];; l; # may be of any type [ 3, [ 4, 5, 6 ], 3 ] gap> l[ l[1] ] := 10;; l; # may be an expression [ 3, [ 4, 5, 6 ], 10 ] ]]>

If the index pos is larger than the length of the list list (see ), the list is automatically enlarged to make room for the new element. Note that it is possible to generate lists with holes that way.

l[4] := "another entry";; l; # is enlarged [ 3, [ 4, 5, 6 ], 10, "another entry" ] gap> l[ 10 ] := 1;; l; # now has a hole [ 3, [ 4, 5, 6 ], 10, "another entry",,,,,, 1 ] ]]>

The function should be used if you want to add an element to the end of the list.

Note that assigning to a list changes the list, thus this list must be mutable (see ). See  for subtleties of changing lists.

If list does not evaluate to a list, pos does not evaluate to a positive integer or object is a call to a function which does not return a value (for example Print) an error is signalled.

sublist list{ poss } := objects;

The sublist assignment assigns the object objects[1], which can be of any type, to the list list at the position poss[1], the object objects[2] to list[poss[2]], and so on. poss must be a dense list of positive integers, it need, however, not be sorted and may contain duplicate elements. objects must be a dense list and must have the same length as poss.

l := [ 2, 3, 5, 7, 11, 13, 17, 19 ];; gap> l{[1..4]} := [10..13];; l; [ 10, 11, 12, 13, 11, 13, 17, 19 ] gap> l{[1,7,1,10]} := [ 1, 2, 3, 4 ];; l; [ 3, 11, 12, 13, 11, 13, 2, 19,, 4 ] ]]>

The next example shows that it is possible to nest such sublist assignments.

m := [ [1,2,3], [4,5,6], [7,8,9], [10,11,12] ];; gap> m{[1,2,3]}{[3,2]} := [ [11,12], [13,14], [15,16] ];; m; [ [ 1, 12, 11 ], [ 4, 14, 13 ], [ 7, 16, 15 ], [ 10, 11, 12 ] ] ]]>

The exact behaviour is defined in the same way as for list extractions (see ). Namely, with each selector [pos] or {poss} we associate a level that is defined as the number of selectors of the form {poss} to its left in the same expression. For example

Then a list assignment list[pos] := vals; of level level is computed as ListAssignment( list, pos, vals, level ), where ListAssignment is defined as follows. (Note that ListAssignment is not a &GAP; function.)

and a list assignment list{poss} := vals of level level is computed as ListAssignments( list, poss, vals, level ), where ListAssignments is defined as follows. (Note that ListAssignments is not a &GAP; function.)

sublist assignment This operation implements sublist assignment. For any list, the default method is to loop over the entries in the list poss, and to delegate to the element assignment operation. (For the somewhat strange variable name, cf. .) <#Include Label="Add"> <#Include Label="Remove"> This function copies n elements from fromlst, starting at position fromind and incrementing the position by fromstep each time, into tolst starting at position toind and incrementing the position by tostep each time. fromlst and tolst must be plain lists. fromstep and/or tostep can be negative. Unbound positions of fromlst are simply copied to tolst.

is used in methods for the operations and . <#Include Label="Append">

IsBound and Unbind for Lists <#Include Label="IsBound_list"> <#Include Label="Unbind_list">
Identical Lists With the list assignment (see ) it is possible to change a mutable list. This section describes the semantic consequences of this fact. (See also .)

First we define what it means when we say that an object is changed. You may think that in the following example the second assignment changes the integer.

But in this example it is not the integer 3 which is changed, by adding one to it. Instead the variable i is changed by assigning the value of i+1, which happens to be 4, to i. The same thing happens in the example below.

The second assignment does not change the first list, instead it assigns a new list to the variable l. On the other hand, in the following example the list is changed by the second assignment.

To understand the difference, think of a variable as a name for an object. The important point is that a list can have several names at the same time. An assignment var:= list; means in this interpretation that var is a name for the object list. At the end of the following example l2 still has the value [ 1, 2 ] as this list has not been changed and nothing else has been assigned to it.

But after the following example the list for which l2 is a name has been changed and thus the value of l2 is now [ 1, 2, 3 ].

We say that two lists are identical if changing one of them by a list assignment also changes the other one. This is slightly incorrect, because if two lists are identical, there are actually only two names for one list. However, the correct usage would be very awkward and would only add to the confusion. Note that two identical lists must be equal, because there is only one list with two different names. Thus identity is an equivalence relation that is a refinement of equality. Identity of objects can be detected using .

Let us now consider under which circumstances two lists are identical.

If you enter a list literal then the list denoted by this literal is a new list that is not identical to any other list. Thus in the following example l1 and l2 are not identical, though they are equal of course.

Also in the following example, no lists in the list l are identical.

If you assign a list to a variable no new list is created. Thus the list value of the variable on the left hand side and the list on the right hand side of the assignment are identical. So in the following example l1 and l2 are identical lists.

If you pass a list as an argument, the old list and the argument of the function are identical. Also if you return a list from a function, the old list and the value of the function call are identical. So in the following example l1 and l2 are identical lists:

If you change a list it keeps its identity. Thus if two lists are identical and you change one of them, you also change the other, and they are still identical afterwards. On the other hand, two lists that are not identical will never become identical if you change one of them. So in the following example both l1 and l2 are changed, and are still identical.

Duplication of Lists Here we describe the meaning of and for lists. For the general definition of these functions, see .

ShallowCopy The subobjects (see ) of a list are exactly its elements.

This means that for any list list, returns a mutable new list new that is not identical to any other list (see ), and whose elements are identical to the elements of list.

StructuralCopy Analogously, for a mutable list list, returns a mutable new list scp that is not identical to any other list, and whose elements are structural copies (defined recursively) of the elements of list; an element of scp is mutable (and then a new list) if and only if the corresponding element of list is mutable.

In both cases, modifying the copy new resp. scp by assignments (see ) does not modify the original object list.

basically executes the following code for lists.

list1 := [ [ 1, 2 ], [ 3, 4 ] ];; list2 := ShallowCopy( list1 );; gap> IsIdenticalObj( list1, list2 ); false gap> IsIdenticalObj( list1[1], list2[1] ); true gap> list2[1] := 0;; list1; list2; [ [ 1, 2 ], [ 3, 4 ] ] [ 0, [ 3, 4 ] ] ]]>

basically executes the following code for lists.

list1 := [ [ 1, 2 ], [ 3, 4 ] ];; list2 := StructuralCopy( list1 );; gap> IsIdenticalObj( list1, list2 ); false gap> IsIdenticalObj( list1[1], list2[1] ); false gap> list2[1][1] := 0;; list1; list2; [ [ 1, 2 ], [ 3, 4 ] ] [ [ 0, 2 ], [ 3, 4 ] ] ]]>

The above code is not entirely correct. If the object list contains a mutable object twice this object is not copied twice, as would happen with the above definition, but only once. This means that the copy new and the object list have exactly the same structure when viewed as a general graph.

sub := [ 1, 2 ];; list1 := [ sub, sub ];; gap> list2 := StructuralCopy( list1 ); [ [ 1, 2 ], [ 1, 2 ] ] gap> list2[1][1] := 0;; list2; [ [ 0, 2 ], [ 0, 2 ] ] gap> list1; [ [ 1, 2 ], [ 1, 2 ] ] ]]>

Membership Test for Lists in element test This function call or the infix variant obj in list tests whether there is a positive integer i such that list[i] = obj holds.

If the list list knows that it is strictly sorted (see ), the membership test is much quicker, because a binary search can be used instead of the linear search used for arbitrary lists, see .

1 in [ 2, 2, 1, 3 ]; 1 in [ 4, -1, 0, 3 ]; true false gap> s := SSortedList( [2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32] );; gap> 17 in s; # uses binary search and only 4 comparisons false ]]>

For finding the position of an element in a list, see .

Enlarging Internally Represented Lists Section  told you (among other things) that it is possible to assign beyond the logical end of a mutable list, automatically enlarging the list. This section tells you how this is done for internally represented lists.

It would be extremely wasteful to make all lists large enough so that there is room for all assignments, because some lists may have more than 100000 elements, while most lists have less than 10 elements.

On the other hand suppose every assignment beyond the end of a list would be done by allocating new space for the list and copying all entries to the new space. Then creating a list of 1000 elements by assigning them in order, would take half a million copy operations and also create a lot of garbage that the garbage collector would have to reclaim.

So the following strategy is used. If a list is created it is created with exactly the correct size. If a list is enlarged, because of an assignment beyond the end of the list, it is enlarged by at least length/8 + 4 entries. Therefore the next assignments beyond the end of the list do not need to enlarge the list. For example creating a list of 1000 elements by assigning them in order, would now take only 32 enlargements.

The result of this is of course that the physical length of a list may be larger than the logical length, which is usually called simply the length of the list. Aside from the implications for the performance you need not be aware of the physical length. In fact all you can ever observe, for example by calling , is the logical length.

Suppose that would have to take the physical length and then test how many entries at the end of a list are unassigned, to compute the logical length of the list. That would take too much time. In order to make , and other functions that need to know the logical length, more efficient, the length of a list is stored along with the list.

For fine tuning code dealing with plain lists we provide the following two functions.

a plain list nothing The function returns an empty plain list which has enough memory allocated for len entries. This can be useful for creating and filling a plain list with a known number of entries.

The function gives back to &GAP;'s memory manager the physical memory which is allocated for the plain list l but not needed by the current number of entries.

Note that there are similar functions and for strings instead of plain lists. gap> l:=[]; for i in [1..160] do Add(l, i^2); od; [ ] gap> m:=EmptyPlist(160); for i in [1..160] do Add(m, i^2); od; [ ] gap> # now l uses about 25% more memory than the equal list m gap> ShrinkAllocationPlist(l); gap> # now l and m use the same amount of memory

Comparisons of Lists comparisons list equal list1 = list2

list1 <> list2

Two lists list1 and list2 are equal if and only if for every index i, either both entries list1[i] and list2[i] are unbound, or both are bound and are equal, i.e., list1[i] = list2[i] is true.

[ 1, 2, 3 ] = [ 1, 2, 3 ]; true gap> [ , 2, 3 ] = [ 1, 2, ]; false gap> [ 1, 2, 3 ] = [ 3, 2, 1 ]; false ]]>

This definition will cause problems with lists which are their own entries. Comparing two such lists for equality may lead to an infinite recursion in the kernel if the list comparison has to compare the list entries which are in fact the lists themselves, and then &GAP; crashes.

list smaller list1 < list2

list1 <= list2

Lists are ordered lexicographically. Unbound entries are smaller than any bound entry. That implies the following behaviour. Let i be the smallest positive integer i such that list1 and list2 at position i differ, i.e., either exactly one of list1[i], list2[i] is bound or both entries are bound and differ. Then list1 is less than list2 if either list1[i] is unbound (and list2[i] is not) or both are bound and list1[i] < list2[i] is true.

[ 1, 2, 3, 4 ] < [ 1, 2, 4, 8 ]; # [3] < [3] true gap> [ 1, 2, 3 ] < [ 1, 2, 3, 5 ]; # [4] is unbound and thus < 5 true gap> [ 1, , 3, 4 ] < [ 1, -1, 3 ]; # [2] is unbound and thus < -1 true ]]>

Note that for comparing two lists with < or <=, the (relevant) list elements must be comparable with <, which is usually not the case for objects in different families, see . Also for the possibility to compare lists with other objects, see .

Arithmetic for Lists operators It is convenient to have arithmetic operations for lists, in particular because in &GAP; row vectors and matrices are special kinds of lists. However, it is the wide variety of list objects because of which we prescribe arithmetic operations not for all of them. (Keep in mind that list means just an object in the category .)

(Due to the intended generality and flexibility, the definitions given in the following sections are quite technical. But for not too complicated cases such as matrices (see ) and row vectors (see ) whose entries aren't lists, the resulting behaviour should be intuitive.)

For example, we want to deal with matrices which can be added and multiplied in the usual way, via the infix operators + and *; and we want also Lie matrices, with the same additive behaviour but with the multiplication defined by the Lie bracket. Both kinds of matrices shall be lists, with the usual access to their rows, with returning the number of rows etc.

For the categories and attributes that control the arithmetic behaviour of lists, see .

For the definition of return values of additive and multiplicative operations whose arguments are lists in these filters, see  and , respectively. It should be emphasized that these sections describe only what the return values are, and not how they are computed.

For the mutability status of the return values, see . (Note that this is not dealt with in the sections about the result values.)

Further details about the special cases of row vectors and matrices can be found in  and in , the compression status is dealt with in  and .

Filters Controlling the Arithmetic Behaviour of Lists <#Include Label="[1]{arith}"> <#Include Label="IsGeneralizedRowVector"> <#Include Label="IsMultiplicativeGeneralizedRowVector"> <#Include Label="IsListDefault"> <#Include Label="NestingDepthA"> <#Include Label="NestingDepthM">
Additive Arithmetic for Lists In this general context, we define the results of additive operations only in the following situations. For unary operations (zero and additive inverse), the unique argument must be in ; for binary operations (addition and subtraction), at least one argument must be in , and the other either is not a list or also in .

(For non-list &GAP; objects, defining the results of unary operations is not an issue here, and if at least one argument is a list not in , it shall be left to this argument whether the result in question is defined and what it is.) Zero for lists The zero (see ) of a list x in is defined as the list whose entry at position i is the zero of x[i] if this entry is bound, and is unbound otherwise.

Zero( [ 1, 2, 3 ] ); Zero( [ [ 1, 2 ], 3 ] ); Zero( liemat ); [ 0, 0, 0 ] [ [ 0, 0 ], 0 ] LieObject( [ [ 0, 0 ], [ 0, 0 ] ] ) ]]> AdditiveInverse for lists The additive inverse (see ) of a list x in is defined as the list whose entry at position i is the additive inverse of x[i] if this entry is bound, and is unbound otherwise.

AdditiveInverse( [ 1, 2, 3 ] ); AdditiveInverse( [ [ 1, 2 ], 3 ] ); [ -1, -2, -3 ] [ [ -1, -2 ], -3 ] ]]> Addition of lists addition If x and y are in and have the same additive nesting depth (see ), the sum x + y is defined pointwise, in the sense that the result is a list whose entry at position i is x[i] + y[i] if these entries are bound, is a shallow copy (see ) of x[i] or y[i] if the other argument is not bound at position i, and is unbound if both x and y are unbound at position i.

If x is in and y is in and has lower additive nesting depth, or is neither a list nor a domain, the sum x + y is defined as a list whose entry at position i is x[i] + y if x is bound at position i, and is unbound if not. The equivalent holds in the reversed case, where the order of the summands is kept, as addition is not always commutative.

1 + [ 1, 2, 3 ]; [ 1, 2, 3 ] + [ 0, 2, 4 ]; [ 1, 2 ] + [ Z(2) ]; [ 2, 3, 4 ] [ 1, 4, 7 ] [ 0*Z(2), 2 ] gap> l1:= [ 1, , 3, 4 ];; l2:= [ , 2, 3, 4, 5 ];; gap> l3:= [ [ 1, 2 ], , [ 5, 6 ] ];; l4:= [ , [ 3, 4 ], [ 5, 6 ] ];; gap> NestingDepthA( l1 ); NestingDepthA( l2 ); 1 1 gap> NestingDepthA( l3 ); NestingDepthA( l4 ); 2 2 gap> l1 + l2; [ 1, 2, 6, 8, 5 ] gap> l1 + l3; [ [ 2, 2, 3, 4 ],, [ 6, 6, 3, 4 ] ] gap> l2 + l4; [ , [ 3, 6, 3, 4, 5 ], [ 5, 8, 3, 4, 5 ] ] gap> l3 + l4; [ [ 1, 2 ], [ 3, 4 ], [ 10, 12 ] ] gap> l1 + []; [ 1,, 3, 4 ] ]]> Subtraction of lists list and non-list For two &GAP; objects x and y of which one is in and the other is also in or is neither a list nor a domain, x - y is defined as x + (-y).

l1 - l2; [ 1, -2, 0, 0, -5 ] gap> l1 - l3; [ [ 0, -2, 3, 4 ],, [ -4, -6, 3, 4 ] ] gap> l2 - l4; [ , [ -3, -2, 3, 4, 5 ], [ -5, -4, 3, 4, 5 ] ] gap> l3 - l4; [ [ 1, 2 ], [ -3, -4 ], [ 0, 0 ] ] gap> l1 - []; [ 1,, 3, 4 ] ]]>

Multiplicative Arithmetic for Lists In this general context, we define the results of multiplicative operations only in the following situations. For unary operations (one and inverse), the unique argument must be in ; for binary operations (multiplication and division), at least one argument must be in , and the other either not a list or also in .

(For non-list &GAP; objects, defining the results of unary operations is not an issue here, and if at least one argument is a list not in , it shall be left to this argument whether the result in question is defined and what it is.) One for lists The one (see ) of a dense list x in such that x has even multiplicative nesting depth and has the same length as each of its rows is defined as the usual identity matrix on the outer two levels, that is, an identity matrix of the same dimensions, with diagonal entries One( x[1][1] ) and off-diagonal entries Zero( x[1][1] ).

One( [ [ 1, 2 ], [ 3, 4 ] ] ); [ [ 1, 0 ], [ 0, 1 ] ] gap> One( [ [ [ [ 1 ] ], [ [ 2 ] ] ], [ [ [ 3 ] ], [ [ 4 ] ] ] ] ); [ [ [ [ 1 ] ], [ [ 0 ] ] ], [ [ [ 0 ] ], [ [ 1 ] ] ] ] ]]> Inverse for lists The inverse (see ) of an invertible square table x in whose entries lie in a common field is defined as the usual inverse y, i.e., a square matrix over the same field such that x y and y x is equal to One( x ).

Inverse( [ [ 1, 2 ], [ 3, 4 ] ] ); [ [ -2, 1 ], [ 3/2, -1/2 ] ] ]]> Multiplication of lists list and non-list There are three possible computations that might be triggered by a multiplication involving a list in . Namely, x * y might be (I) the inner product x[1] * y[1] + x[2] * y[2] + \cdots + x[n] * y[n], where summands are omitted for which the entry in x or y is unbound (if this leaves no summand then the multiplication is an error), or (L) the left scalar multiple, i.e., a list whose entry at position i is x * y[i] if y is bound at position i, and is unbound if not, or (R) the right scalar multiple, i.e., a list whose entry at position i is x[i] * y if x is bound at position i, and is unbound if not.

Our aim is to generalize the basic arithmetic of simple row vectors and matrices, so we first summarize the situations that shall be covered.

scl vec mat scl (L) (L) vec (R) (I) (I) mat (R) (R) (R)

This means for example that the product of a scalar (scl) with a vector (vec) or a matrix (mat) is computed according to (L). Note that this is asymmetric.

Now we can state the general multiplication rules.

If exactly one argument is in then we regard the other argument (which is then neither a list nor a domain) as a scalar, and specify result (L) or (R), depending on ordering.

In the remaining cases, both x and y are in , and we distinguish the possibilities by their multiplicative nesting depths. An argument with odd multiplicative nesting depth is regarded as a vector, and an argument with even multiplicative nesting depth is regarded as a scalar or a matrix.

So if both arguments have odd multiplicative nesting depth, we specify result (I).

If exactly one argument has odd nesting depth, the other is treated as a scalar if it has lower multiplicative nesting depth, and as a matrix otherwise. In the former case, we specify result (L) or (R), depending on ordering; in the latter case, we specify result (L) or (I), depending on ordering.

We are left with the case that each argument has even multiplicative nesting depth. If the two depths are equal, we treat the computation as a matrix product, and specify result (R). Otherwise, we treat the less deeply nested argument as a scalar and the other as a matrix, and specify result (L) or (R), depending on ordering.

[ (), (2,3), (1,2), (1,2,3), (1,3,2), (1,3) ] * (1,4); [ (1,4), (1,4)(2,3), (1,2,4), (1,2,3,4), (1,3,2,4), (1,3,4) ] gap> [ 1, 2, , 4 ] * 2; [ 2, 4,, 8 ] gap> [ 1, 2, 3 ] * [ 1, 3, 5, 7 ]; 22 gap> m:= [ [ 1, 2 ], 3 ];; m * m; [ [ 7, 8 ], [ [ 3, 6 ], 9 ] ] gap> m * m = [ m[1] * m, m[2] * m ]; true gap> n:= [ 1, [ 2, 3 ] ];; n * n; 14 gap> n * n = n[1] * n[1] + n[2] * n[2]; true ]]> Division of lists list and non-list For two &GAP; objects x and y of which one is in and the other is also in or is neither a list nor a domain, x / y is defined as x * y^{{-1}}.

[ 1, 2, 3 ] / 2; [ 1, 2 ] / [ [ 1, 2 ], [ 3, 4 ] ]; [ 1/2, 1, 3/2 ] [ 1, 0 ] ]]> mod for lists list and non-list mod If x and y are in and have the same multiplicative nesting depth (see ), x mod y is defined pointwise, in the sense that the result is a list whose entry at position i is x[i] mod y[i] if these entries are bound, is a shallow copy (see ) of x[i] or y[i] if the other argument is not bound at position i, and is unbound if both x and y are unbound at position i.

If x is in and y is in and has lower multiplicative nesting depth or is neither a list nor a domain, x mod y is defined as a list whose entry at position i is x[i] mod y if x is bound at position i, and is unbound if not. The equivalent holds in the reversed case, where the order of the arguments is kept.

4711 mod [ 2, 3,, 5, 7 ]; [ 1, 1,, 1, 0 ] gap> [ 2, 3, 4, 5, 6 ] mod 3; [ 2, 0, 1, 2, 0 ] gap> [ 10, 12, 14, 16 ] mod [ 3, 5, 7 ]; [ 1, 2, 0, 16 ] ]]> Left quotients of lists list and non-list For two &GAP; objects x and y of which one is in and the other is also in or is neither a list nor a domain, LeftQuotient( x, y ) is defined as x^{{-1}} * y.

LeftQuotient( [ [ 1, 2 ], [ 3, 4 ] ], [ 1, 2 ] ); [ 0, 1/2 ] ]]>

Mutability Status and List Arithmetic Many results of arithmetic operations, when applied to lists, are again lists, and it is of interest whether their entries are mutable or not (if applicable). Note that the mutability status of the result itself is already defined by the general rule for any result of an arithmetic operation, not only for lists (see ).

However, we do not define exactly the mutability status for each element on each level of a nested list returned by an arithmetic operation. (Of course it would be possible to define this recursively, but since the methods used are in general not recursive, in particular for efficient multiplication of compressed matrices, such a general definition would be a burden in these cases.) Instead we consider, for a list x in , the sequence x = x_1, x_2, \ldots x_n where x_{{i+1}} is the first bound entry in x_i if exists (that is, if x_i is a nonempty list), and n is the largest i such that x_i lies in . The immutability level of x is defined as infinity if x is immutable, and otherwise the number of x_i which are immutable. (So the immutability level of a mutable empty list is 0.)

Thus a fully mutable matrix has immutability level 0, and a mutable matrix with immutable first row has immutability level 1 (independent of the mutability of other rows).

The immutability level of the result of any of the binary operations discussed here is the minimum of the immutability levels of the arguments, provided that objects of the required mutability status exist in &GAP;.

Moreover, the results have a homogeneous mutability status, that is, if the first bound entry at nesting depth i is immutable (mutable) then all entries at nesting depth i are immutable (mutable, provided that a mutable version of this entry exists in &GAP;).

Thus the sum of two mutable matrices whose first rows are mutable is a matrix all of whose rows are mutable, and the product of two matrices whose first rows are immutable is a matrix all of whose rows are immutable, independent of the mutability status of the other rows of the arguments.

For example, the sum of a matrix (mutable or immutable, i.e., of immutability level one of 0, 1, or 2) and a mutable row vector (i.e., immutability level 0) is a fully mutable matrix. The product of two mutable row vectors of integers is an integer, and since &GAP; does not support mutable integers, the result is immutable.

For unary arithmetic operations, there are three operations available, an attribute that returns an immutable result (, , , ), an operation that returns a result that is mutable (, , , ), and an operation whose result has the same immutability level as the argument (, , , ). The last kind of operations is equivalent to the corresponding infix operations 0 * list, - list, list^0, and list^-1. (This holds not only for lists, see .)

IsMutable( l1 ); IsMutable( 2 * Immutable( [ 1, 2, 3 ] ) ); true false gap> IsMutable( l2 ); IsMutable( l3 ); true true ]]>

An example motivating the mutability rule is the use of syntactic constructs such as obj * list and - list as an elegant and efficient way to create mutable lists needed for further manipulations from mutable lists. In particular one can construct a mutable zero vector of length n by 0 * [ 1 .. n ]. The latter can be done also using . <#Include Label="ListWithIdenticalEntries">

Finding Positions in Lists <#Include Label="Position"> <#Include Label="Positions"> <#Include Label="PositionCanonical"> <#Include Label="PositionNthOccurrence"> <#Include Label="PositionSorted"> <#Include Label="PositionSet"> <#Include Label="PositionProperty"> <#Include Label="PositionsProperty"> <#Include Label="PositionBound"> <#Include Label="PositionNot"> <#Include Label="PositionNonZero"> <#Include Label="PositionSublist"> <#Include Label="PositionFirstComponent">
Properties and Attributes for Lists A list that contains mutable objects (like lists or records) cannot store attribute values that depend on the values of its entries, such as whether it is homogeneous, sorted, or strictly sorted, as changes in any of its entries could change such property values, like the following example shows.

l:=[[1],[2]]; [ [ 1 ], [ 2 ] ] gap> IsSSortedList(l); true gap> l[1][1]:=3; 3 gap> IsSSortedList(l); false ]]>

For such lists these property values must be computed anew each time the property is asked for. For example, if list is a list of mutable row vectors then the call of with list as first argument cannot take advantage of the fact that list is in fact sorted. One solution is to call explicitly in such a situation, another solution is to replace list by an immutable copy using . <#Include Label="IsMatchingSublist"> <#Include Label="IsDuplicateFree"> <#Include Label="IsSortedList"> <#Include Label="IsSSortedList"> <#Include Label="Length"> <#Include Label="ConstantTimeAccessList">

Sorting Lists <#Include Label="Sort"> <#Include Label="SortParallel"> <#Include Label="Sortex"> <#Include Label="SortingPerm"> The default methods for all of these sorting operations currently use Shell sort as it has a comparable performance to Quicksort for lists of length at most a few thousands, and has better worst-case behaviour.
Sorted Lists and Sets sets multisets Searching objects in a list works much quicker if the list is known to be sorted. Currently &GAP; exploits the sortedness of a list automatically only if the list is strictly sorted, which is indicated by the property .

Remember that a list of mutable objects cannot store that it is strictly sorted but has to test it anew whenever it is asked whether it is sorted, see the remark in . Therefore &GAP; cannot take advantage of the sortedness of a list if this list has mutable entries. Moreover, if a sorted list list with mutable elements is used as an argument of a function that expects this argument to be sorted, for example or , then it is checked whether list is in fact sorted; this check can have the effect actually to slow down the computations, compared to computations with sorted lists of immutable elements or computations that do not involve functions that do automatically check sortedness.

Strictly sorted lists are used to represent sets in &GAP;. More precisely, a strictly sorted list is called a proper set in the following, in order to avoid confusion with domains (see ) which also represent sets.

In short proper sets are represented by sorted lists without holes and duplicates in &GAP;. Note that we guarantee this representation, so you may make use of the fact that a set is represented by a sorted list in your functions.

In some contexts (for example see ), we also want to talk about multisets. A multiset is like a set, except that an element may appear several times in a multiset. Such multisets are represented by sorted lists without holes that may have duplicates.

This section lists only those functions that are defined exclusively for proper sets. Set theoretic functions for general collections, such as and , are described in Chapter . In particular, for the construction of proper sets, see  and . For finding positions in sorted lists, see .

There are nondestructive counterparts of the functions , , and available for proper sets. These are UnionSet, IntersectionSet, and . The former two are methods for the more general operations and , the latter is itself an operation (see ).

The result of IntersectionSet and UnionSet is always a new list, that is not identical to any other list. The elements of that list however are identical to the corresponding elements of the first argument set. If set is not a proper set it is not specified to which of a number of equal elements in set the element in the result is identical (see ). <#Include Label="[1]{set}"> For a list list that stores that it is strictly sorted, the test with whether the object obj is an entry of list uses binary search. This test can be entered also with the infix notation obj in list. <#Include Label="IsEqualSet"> <#Include Label="IsSubsetSet"> <#Include Label="AddSet"> <#Include Label="RemoveSet"> <#Include Label="UniteSet"> <#Include Label="IntersectSet"> <#Include Label="SubtractSet">

Operations for Lists Several of the following functions expect the first argument to be either a list or a collection (see ), with possibly slightly different meaning for lists and non-list collections. concatenation <#Include Label="Concatenation"> <#Include Label="Compacted"> <#Include Label="Collected"> <#Include Label="DuplicateFreeList"> <#Include Label="AsDuplicateFreeList"> <#Include Label="Flat"> <#Include Label="Reversed"> <#Include Label="Shuffle"> <#Include Label="IsLexicographicallyLess"> <#Include Label="Apply"> <#Include Label="Perform"> <#Include Label="PermListList"> <#Include Label="Maximum"> <#Include Label="Minimum"> <#Include Label="MaximumList"> <#Include Label="Cartesian"> <#Include Label="IteratorOfCartesianProduct"> <#Include Label="Permuted"> <#Include Label="List:list"> <#Include Label="Filtered"> <#Include Label="Number"> <#Include Label="First"> <#Include Label="ForAll"> <#Include Label="ForAny"> <#Include Label="Product"> <#Include Label="Sum"> <#Include Label="Iterated"> <#Include Label="ListN">
Advanced List Manipulations The following functions are generalizations of , , , and . <#Include Label="ListX"> <#Include Label="SetX"> <#Include Label="SumX"> <#Include Label="ProductX">
Ranges range A range is a dense list of integers in arithmetic progression (or degression). This is a list of integers such that the difference between consecutive elements is a nonzero constant. Ranges can be abbreviated with the syntactic construct

[ first, second .. last ]

or, if the difference between consecutive elements is 1, as

[ first .. last ].

If first > last, [ first .. last ] is the empty list, which by definition is also a range; also, if second > first > last or second < first < last, then [ first, second .. last ] is the empty list. If first = last, [ first, second .. last ] is a singleton list, which is a range, too. Note that last - first must be divisible by the increment second - first, otherwise an error is signalled.

Currently, the integers first, second and last and the length of a range must be small integers, that is at least -2^d and at most 2^d - 1 with d = 28 on 32-bit architectures and d = 60 on 64-bit architectures.

Note also that a range is just a special case of a list. Thus you can access elements in a range (see ), test for membership etc. You can even assign to such a range if it is mutable (see ). Of course, unless you assign last + second - first to the entry range[ Length( range ) + 1 ], the resulting list will no longer be a range.

r := [10..20]; [ 10 .. 20 ] gap> Length( r ); 11 gap> r[3]; 12 gap> 17 in r; true gap> r[12] := 25;; r; # r is no longer a range [ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 25 ] gap> r := [1,3..17]; [ 1, 3 .. 17 ] gap> Length( r ); 9 gap> r[4]; 7 gap> r := [0,-1..-9]; [ 0, -1 .. -9 ] gap> r[5]; -4 gap> r := [ 1, 4 .. 32 ]; Error, Range: - (31) must be divisible by (3) ]]>

Most often ranges are used in connection with the for-loop see ). Here the construct

for var in [ first .. last ] do statements od

replaces the

for var from first to last do statements od

which is more usual in other programming languages.

s := [];; for i in [10..20] do Add( s, i^2 ); od; s; [ 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400 ] ]]>

Note that a range with last >= first is at the same time also a proper set (see ), because it contains no holes or duplicates and is sorted, and also a row vector (see ), because it contains no holes and all elements are integers.

<#Include Label="IsRange"> <#Include Label="ConvertToRangeRep">

Enumerators An enumerator is an immutable list that need not store its elements explicitly but knows, from a set of basic data, how to determine the i-th element and the position of a given object. A typical example of this is a vector space over a finite field with q elements, say, for which it is very easy to enumerate all elements using q-adic expansions of integers.

Using this enumeration can be even quicker than a binary search in a sorted list of vectors, see .

On the one hand, element access to an enumerator may take more time than element access to an internally represented list containing the same elements. On the other hand, an enumerator may save a vast amount of memory. Take for example a permutation group of size a few millions. Even for moderate degree it is unlikely that a list of all its elements will fit into memory whereas it is no problem to construct an enumerator from a stabilizer chain (see ).

There are situations where one only wants to loop over the elements of a domain, without using the special facilities of an enumerator, namely the particular order of elements and the possibility to find the position of elements. For such cases, &GAP; provides iterators (see ).

The functions and return enumerators of domains. Most of the special implementations of enumerators in the &GAP; library are based on the general interface that is provided by ; one generic example is , which can be used to get an enumerator of a finite dimensional free module.

Also enumerators for non-domains can be implemented via ; for a discussion, see . <#Include Label="IsQuickPositionList">

gap-4r6p5/doc/ref/ctblfuns.xml0000644000175000017500000001606712172557252015036 0ustar billbill Class Functions characters group characters virtual characters generalized characters This chapter describes operations for class functions of finite groups. For operations concerning character tables, see Chapter .

Several examples in this chapter require the &GAP; Character Table Library to be available. If it is not yet loaded then we load it now.

LoadPackage( "ctbllib" ); true ]]>

Why Class Functions? <#Include Label="[1]{ctblfuns}"> <#Include Label="IsClassFunction">
Basic Operations for Class Functions <#Include Label="[2]{ctblfuns}"> <#Include Label="UnderlyingCharacterTable"> <#Include Label="ValuesOfClassFunction">
Comparison of Class Functions <#Include Label="[3]{ctblfuns}">
Arithmetic Operations for Class Functions <#Include Label="[4]{ctblfuns}">
Printing Class Functions <#Include Label="[5]{ctblfuns}">
Creating Class Functions from Values Lists <#Include Label="ClassFunction"> <#Include Label="VirtualCharacter"> <#Include Label="Character"> <#Include Label="ClassFunctionSameType">
Creating Class Functions using Groups <#Include Label="TrivialCharacter"> <#Include Label="NaturalCharacter"> <#Include Label="PermutationCharacter">
Operations for Class Functions <#Include Label="[6]{ctblfuns}"> <#Include Label="IsCharacter"> <#Include Label="IsVirtualCharacter"> <#Include Label="IsIrreducibleCharacter"> <#Include Label="DegreeOfCharacter"> <#Include Label="ScalarProduct:ctblfuns"> <#Include Label="MatScalarProducts"> <#Include Label="Norm:ctblfuns"> <#Include Label="ConstituentsOfCharacter"> <#Include Label="KernelOfCharacter"> <#Include Label="ClassPositionsOfKernel"> <#Include Label="CentreOfCharacter"> <#Include Label="ClassPositionsOfCentre:ctblfuns"> <#Include Label="InertiaSubgroup"> <#Include Label="CycleStructureClass"> <#Include Label="IsTransitive:ctblfuns"> <#Include Label="Transitivity:ctblfuns"> <#Include Label="CentralCharacter"> <#Include Label="DeterminantOfCharacter"> <#Include Label="EigenvaluesChar"> <#Include Label="Tensored">
Restricted and Induced Class Functions <#Include Label="[7]{ctblfuns}"> <#Include Label="RestrictedClassFunction"> <#Include Label="RestrictedClassFunctions"> <#Include Label="InducedClassFunction"> <#Include Label="InducedClassFunctions"> <#Include Label="InducedClassFunctionsByFusionMap"> <#Include Label="InducedCyclic">
Reducing Virtual Characters <#Include Label="[8]{ctblfuns}"> <#Include Label="ReducedClassFunctions"> <#Include Label="ReducedCharacters"> <#Include Label="IrreducibleDifferences"> <#Include Label="LLL"> <#Include Label="Extract"> <#Include Label="OrthogonalEmbeddingsSpecialDimension"> <#Include Label="Decreased"> <#Include Label="DnLattice"> <#Include Label="DnLatticeIterative">
Symmetrizations of Class Functions <#Include Label="Symmetrizations"> <#Include Label="SymmetricParts"> <#Include Label="AntiSymmetricParts"> <#Include Label="OrthogonalComponents"> <#Include Label="SymplecticComponents">
Molien Series <#Include Label="MolienSeries"> <#Include Label="MolienSeriesInfo"> <#Include Label="ValueMolienSeries"> <#Include Label="MolienSeriesWithGivenDenominator">
Possible Permutation Characters <#Include Label="[1]{ctblpope}"> <#Include Label="PermCharInfo"> <#Include Label="PermCharInfoRelative">
Computing Possible Permutation Characters <#Include Label="PermChars"> <#Include Label="TestPerm1"> <#Include Label="PermBounds"> <#Include Label="PermComb"> <#Include Label="Inequalities">
Operations for Brauer Characters <#Include Label="FrobeniusCharacterValue"> <#Include Label="BrauerCharacterValue"> <#Include Label="SizeOfFieldOfDefinition"> <#Include Label="RealizableBrauerCharacters">
Domains Generated by Class Functions <#Include Label="[9]{ctblfuns}">
gap-4r6p5/doc/ref/domain.xml0000644000175000017500000007374212172557252014470 0ustar billbill Domains and their Elements <#Include Label="[1]{domain}">

An introduction to the most important facts about domains is given in Chapter .

There are only few operations especially for domains (see ), operations such as and are defined for the more general situation of collections (see Chapter ).

Operational Structure of Domains Domains have an operational structure, that is, a collection of operations under which the domain is closed. For example, a group is closed under multiplication, taking the zeroth power of elements, and taking inverses of elements. The operational structure may be empty, examples of domains without additional structure are the underlying relations of general mappings (see ).

The operations under which a domain is closed are a subset of the operations that the elements of a domain admit. It is possible that the elements admit more operations. For example, matrices can be multiplied and added. But addition plays no role in a group of matrices, and multiplication plays no role in a vector space of matrices. In particular, a matrix group is not closed under addition.

Note that the elements of a domain exist independently of this domain, usually they existed already before the domain was created. So it makes sense to say that a domain is generated by some elements with respect to certain operations.

Of course, different sets of operations yield different notions of generation. For example, the group generated by some matrices is different from the ring generated by these matrices, and these two will in general be different from the vector space generated by the same matrices, over a suitable field.

The other way round, the same set of elements may be obtained by generation w.r.t. different notions of generation. For example, one can get the group generated by two elements g and h also as the monoid generated by the elements g, g^{{-1}}, h, h^{{-1}}; if both g and h have finite order then of course the group generated by g and h coincides with the monoid generated by g and h.

Additionally to the operational structure, a domain can have properties. For example, the multiplication of a group is associative, and the multiplication in a field is commutative.

Note that associativity and commutativity depend on the set of elements for which one considers the multiplication, i.e., it depends on the domain. For example, the multiplication in a full matrix ring over a field is not commutative, whereas its restriction to the set of diagonal matrices is commutative.

One important difference between the operational structure and the properties of a domain is that the operational structure is fixed when the domain is constructed, whereas properties can be discovered later. For example, take a domain whose operational structure is given by closure under multiplication. If it is discovered that the inverses of all its elements also do (by chance) lie in this domain, being closed under taking inverses is not added to the operational structure. But a domain with operational structure of multiplication, taking the identity, and taking inverses will be treated as a group as soon as the multiplication is found out to be associative for this domain.

The operational structures available in &GAP; form a hierarchy, which is explicitly formulated in terms of domain categories, see .

Equality and Comparison of Domains <#Include Label="[2]{domain}">
Constructing Domains For several operational structures (see ), &GAP; provides functions to construct domains with this structure (note that such functions do not exist for all operational structures). For example, returns groups, returns vector spaces etc.:

Struct Struct( arg1, arg2, ... )

The syntax of these functions may vary, dependent on the structure in question. Usually a domain is constructed as the closure of some elements under the given operations, that is, the domain is given by its generators. For example, a group can be constructed from a list of generating permutations or matrices or whatever is admissible as group elements, and a vector space over a given field F can be constructed from F and a list of appropriate vectors.

The idea of generation and generators in &GAP; is that the domain returned by a function such as Group, Algebra, or FreeLeftModule contains the given generators. This implies that the generators of a group must know how they are multiplied and inverted, the generators of a module must know how they are added and how scalar multiplication works, and so on. Thus one cannot use for example permutations as generators of a vector space.

The function Struct first checks whether the arguments admit the construction of a domain with the desired structure. This is done by calling the operation

IsGeneratorsOfStruct( [info, ]gens )

IsGeneratorsOfStruct

where arglist is the list of given generators and info an argument of Struct, for example the field of scalars in the case that a vector space shall be constructed. If the check failed then Struct returns fail, otherwise it returns the result of StructByGenerators (see below). (So if one wants to omit the check then one should call StructByGenerators directly.)

GeneratorsOfStruct GeneratorsOfStruct( D)

For a domain D with operational structure corresponding to Struct, the attribute GeneratorsOfStruct returns a list of corresponding generators of D. If these generators were not yet stored in D then D must know some generators if GeneratorsOfStruct shall have a chance to compute the desired result; for example, monoid generators of a group can be computed from known group generators (and vice versa). Note that several notions of generation may be meaningful for a given domain, so it makes no sense to ask for the generators of a domain. Further note that the generators may depend on other information about D. For example the generators of a vector space depend on the underlying field of scalars; the vector space generators of a vector space over the field with four elements need not generate the same vector space when this is viewed as a space over the field with two elements.

StructByGenerators StructByGenerators( [info, ]gens )

Domain construction from generators gens is implemented by operations StructByGenerators, which are called by the simple functions Struct; methods can be installed only for the operations. Note that additional information info may be necessary to construct the domain; for example, a vector space needs the underlying field of scalars in addition to the list of vector space generators. The GeneratorsOfStruct value of the returned domain need not be equal to gens. But if a domain D is printed as Struct([a, b, ...]) and if there is an attribute GeneratorsOfStruct then the list GeneratorsOfStruct( D ) is guaranteed to be equal to [ a, b, ... ].

StructWithGenerators StructWithGenerators( [info, ]gens )

The only difference between StructByGenerators and StructWithGenerators is that the latter guarantees that the GeneratorsOfStruct value of the result is equal to the given generators gens.

ClosureStruct ClosureStruct( D, obj )

For constructing a domain as the closure of a given domain with an element or another domain, one can use the operation ClosureStruct. It returns the smallest domain with operational structure corresponding to Struct that contains D as a subset and obj as an element.

Changing the Structure The same set of elements can have different operational structures. For example, it may happen that a monoid M does in fact contain the inverses of all of its elements; if M has not been constructed as a group (see ) then it is reasonable to ask for the group that is equal to M.

AsStruct AsStruct( [info, ]D )

If D is a domain that is closed under the operational structure given by Struct then AsStruct returns a domain E that consists of the same elements (that is, D = E) and that has this operational structure (that is, IsStruct( E ) is true); if D is not closed under the structure given by Struct then AsStruct returns fail.

If additional information besides generators are necessary to define D then the argument info describes the value of this information for the desired domain. For example, if we want to view D as a vector space over the field with two elements then we may call AsVectorSpace( GF(2), D ); this allows us to change the underlying field of scalars, for example if D is a vector space over the field with four elements. Again, if D is not equal to a domain with the desired structure and additional information then fail is returned.

In the case that no additional information info is related to the structure given by Struct, the operation AsStruct is in fact an attribute (see ).

See the index of the &GAP; Reference Manual for an overview of the available AsStruct functions.

Changing the Representation Often it is useful to answer questions about a domain via computations in a different but isomorphic domain. In the sense that this approach keeps the structure and changes the underlying set of elements, it can be viewed as a counterpart of keeping the set of elements and changing its structure (see ).

One reason for doing so can be that computations with the elements in the given domain are not very efficient. For example, if one is given a solvable matrix group (see Chapter ) then one can compute an isomorphism to a polycyclicly presented group G, say (see Chapter ); the multiplication of two matrices –which is essentially determined by the dimension of the matrices– is much more expensive than the multiplication of two elements in G –which is essentially determined by the composition length of G.

IsomorphismRepStruct IsomorphismRepStruct( D )

If D is a domain that is closed under the operational structure given by Struct then IsomorphismRepStruct returns a mapping hom from D to a domain E having structure given by Struct, such that hom respects the structure Struct and Rep describes the representation of the elements in E. If no domain E with the required properties exists then fail is returned.

For example, takes a group as its argument and returns a group homomorphism (see ) onto an isomorphic permutation group (see Chapter ) provided the original group is finite; for infinite groups, returns fail. Similarly, returns a group homomorphism from its argument to a polycyclicly presented group (see ) if the argument is polycyclic, and fail otherwise.

See the index of the &GAP; Reference Manual for an overview of the available IsomorphismRepStruct functions.

Domain Categories As mentioned in , the operational structure of a domain is fixed when the domain is constructed. For example, if D was constructed by then D is in general not regarded as a group in &GAP;, even if D is in fact closed under taking inverses. In this case, returns false for D. The operational structure determines which operations are applicable for a domain, so for example is not defined for D and therefore will signal an error.

IsStruct IsStruct( D )

The functions IsStruct implement the tests whether a domain D has the respective operational structure (upon construction). IsStruct is a filter (see ) that involves certain categories (see ) and usually also certain properties (see ). For example, is equivalent to IsMagmaWithInverses and IsAssociative, the first being a category and the second being a property.

Implications between domain categories describe the hierarchy of operational structures available in &GAP;. Here are some typical examples.

is implied by each domain category, is implied by each category that describes the closure under multiplication *, is implied by each category that describes the closure under addition +, implies ; a magma-with-one is a magma such that each element (and thus also the magma itself) can be asked for its zeroth power, implies ; a magma-with-inverses is a magma such that each element can be asked for its inverse; important special cases are groups, which in addition are associative, a ring is a magma that is also an additive group, a ring-with-one is a ring that is also a magma-with-one, a division ring is a ring-with-one that is also closed under taking inverses of nonzero elements, a field is a commutative division ring.

Each operational structure Struct has associated with it a domain category IsStruct, and operations StructByGenerators for constructing a domain from generators, GeneratorsOfStruct for storing and accessing generators w.r.t. this structure, ClosureStruct for forming the closure, and AsStruct for getting a domain with the desired structure from one with weaker operational structure and for testing whether a given domain can be regarded as a domain with Struct.

The functions applicable to domains with the various structures are described in the corresponding chapters of the Reference Manual. For example, functions for rings, fields, groups, and vector spaces are described in Chapters , , , and , respectively. More general functions for arbitrary collections can be found in Chapter .

Parents <#Include Label="Parent">
Constructing Subdomains Subdomains For many domains D, there are functions that construct certain subsets S of D as domains with parent (see ) already set to D. For example, if G is a group that contains the elements in the list gens then Subgroup( G, gens ) returns a group S that is generated by the elements in gens and with Parent( S ) = G.

Substruct Substruct( D, gens )

More general, if D is a domain whose algebraic structure is given by the function Struct (for example Group, Algebra, Field) then the function Substruct (for example Subgroup, Subalgebra, Subfield) returns domains with structure Struct and parent set to the first argument.

SubstructNC SubstructNC( D, gens )

Each function Substruct checks that the Struct generated by gens is in fact a subset of D. If one wants to omit this check then one can call SubstructNC instead; the suffix NC stands for no check.

AsSubstruct AsSubstruct( D, S )

first constructs AsStruct( [info, ]S ), where info depends on D and S, and then sets the parent (see ) of this new domain to D.

IsSubstruct IsSubstruct( D, S )

There is no real need for functions that check whether a domain S is a Substruct of a domain D, since this is equivalent to the checks whether S is a Struct and S is a subset of D. Note that in many cases, only the subset relation is what one really wants to check, and that appropriate methods for the operation are available for many special situations, such as the test whether a group is contained in another group, where only generators need to be checked.

If a function IsSubstruct is available in &GAP; then it is implemented as first a call to IsStruct for the second argument and then a call to for the two arguments.

Operations for Domains For the meaning of the attributes , , in the case of a domain argument, see . <#Include Label="IsGeneralizedDomain"> <#Include Label="GeneratorsOfDomain"> <#Include Label="Domain">
Attributes and Properties of Elements The following attributes and properties for elements and domains correspond to the operational structure. <#Include Label="Characteristic"> <#Include Label="OneImmutable"> <#Include Label="ZeroImmutable"> <#Include Label="MultiplicativeZeroOp"> <#Include Label="IsOne"> <#Include Label="IsZero"> <#Include Label="IsIdempotent"> <#Include Label="InverseImmutable"> <#Include Label="AdditiveInverseImmutable"> <#Include Label="Order">
Comparison Operations for Elements Binary comparison operations have been introduced already in . The underlying operations for which methods can be installed are the following. \= and \< equality comparison Note that the comparisons via <>, <=, >, and >= are delegated to the operations and .

In general, objects in different families cannot be compared with . For the reason and for exceptions from this rule, see . <#Include Label="CanEasilyCompareElements">

Arithmetic Operations for Elements Binary arithmetic operations have been introduced already in . The underlying operations for which methods can be installed are the following. \+, \*, \/, \^, \mod addition multiplication division exponentiation remainder For details about special methods for , , and , consult the appropriate index entries for them. <#Include Label="LeftQuotient"> <#Include Label="Comm"> <#Include Label="LieBracket"> <#Include Label="Sqrt">
Relations Between Domains Domains are often constructed relative to other domains. The probably most usual case is to form a subset of a domain, for example the intersection (see ) of two domains, or a Sylow subgroup of a given group (see ).

In such a situation, the new domain can gain knowledge by exploiting that several attributes are maintained under taking subsets. For example, the intersection of an arbitrary domain with a finite domain is clearly finite, a Sylow subgroup of an abelian group is abelian, too, and so on.

Since usually the new domain has access to the knowledge of the old domain(s) only when it is created (see  for the exception), this is the right moment to take advantage of the subset relation, using .

Analogous relations occur when a factor structure is created from a domain and a subset (see ), and when a domain isomorphic to a given one is created (see ).

The functions , , and are used to tell &GAP; under what conditions an attribute is maintained under taking subsets, or forming factor structures or isomorphic domains. This is used only when a new attribute is created, see . For the attributes already available, such as and , the maintenances are already notified. <#Include Label="UseSubsetRelation"> <#Include Label="UseFactorRelation"> <#Include Label="UseIsomorphismRelation"> <#Include Label="InstallSubsetMaintenance"> <#Include Label="InstallFactorMaintenance"> <#Include Label="InstallIsomorphismMaintenance">

Useful Categories of Elements This section and the following one are rather technical, and may be interesting only for those &GAP; users who want to implement new kinds of elements.

It deals with certain categories of elements that are useful mainly for the design of elements, from the viewpoint that one wants to form certain domains of these elements. For example, a domain closed under multiplication * (a so-called magma, see Chapter ) makes sense only if its elements can be multiplied, and the latter is indicated by the category for each element. Again note that the underlying idea is that a domain is regarded as generated by given elements, and that these elements carry information about the desired domain. For general information on categories and their hierarchies, see .

More special categories of this kind are described in the contexts where they arise, they are , , , and .

<#Include Label="IsExtAElement"> <#Include Label="IsNearAdditiveElement"> <#Include Label="IsAdditiveElement"> <#Include Label="IsNearAdditiveElementWithZero"> <#Include Label="IsAdditiveElementWithZero"> <#Include Label="IsNearAdditiveElementWithInverse"> <#Include Label="IsAdditiveElementWithInverse"> <#Include Label="IsExtLElement"> <#Include Label="IsExtRElement"> <#Include Label="IsMultiplicativeElement"> <#Include Label="IsMultiplicativeElementWithOne"> <#Include Label="IsMultiplicativeElementWithZero"> <#Include Label="IsMultiplicativeElementWithInverse"> <#Include Label="IsVector"> <#Include Label="IsNearRingElement"> <#Include Label="IsRingElement"> <#Include Label="IsNearRingElementWithOne"> <#Include Label="IsRingElementWithOne"> <#Include Label="IsNearRingElementWithInverse"> <#Include Label="IsRingElementWithInverse">

Useful Categories for all Elements of a Family The following categories of elements are to be understood mainly as categories for all objects in a family, they are usually used as third argument of NewFamily (see ). The purpose of each of the following categories is then to guarantee that each collection of its elements automatically lies in its collections category (see ).

For example, the multiplication of permutations is associative, and it is stored in the family of permutations that each permutation lies in . As a consequence, each magma consisting of permutations (more precisely: each collection that lies in the family CollectionsFamily( PermutationsFamily ), see ) automatically lies in CategoryCollections( IsAssociativeElement ). A magma in this category is always known to be associative, via a logical implication (see ).

Similarly, if a family knows that all its elements are in the categories and , then each algebra of these elements is automatically known to be a Lie algebra (see Chapter ). <#Include Label="IsAssociativeElement"> <#Include Label="IsAdditivelyCommutativeElement"> <#Include Label="IsCommutativeElement"> <#Include Label="IsFiniteOrderElement"> <#Include Label="IsJacobianElement"> <#Include Label="IsZeroSquaredElement">

gap-4r6p5/doc/ref/floats.xml0000644000175000017500000002035112172557252014475 0ustar billbill Floats Starting with version 4.5, &GAP; has built-in support for floating-point numbers in machine format, and allows package to implement arbitrary-precision floating-point arithmetic in a uniform manner. For now, one such package, Float exists, and is based on the arbitrary-precision routines in mpfr.

A word of caution: &GAP; deals primarily with algebraic objects, which can be represented exactly in a computer. Numerical imprecision means that floating-point numbers do not form a ring in the strict &GAP; sense, because addition is in general not associative ((1.0e-100+1.0)-1.0 is not the same as 1.0e-100+(1.0-1.0), in the default precision setting).

Most algorithms in &GAP; which require ring elements will therefore not be applicable to floating-point elements. In some cases, such a notion would not even make any sense (what is the greatest common divisor of two floating-point numbers?)

A sample run Floating-point numbers can be input into &GAP; in the standard floating-point notation:

3.14; 3.14 gap> last^2/6; 1.64327 gap> h := 6.62606896e-34; 6.62607e-34 gap> pi := 4*Atan(1.0); 3.14159 gap> hbar := h/(2*pi); 1.05457e-34 ]]>

Floating-point numbers can also be created using Float, from strings or rational numbers; and can be converted back using String,Rat,Int.

&GAP; allows rational and floating-point numbers to be mixed in the elementary operations +,-,*,/. However, floating-point numbers and rational numbers may not be compared. Conversions are performed using the creator Float:

Float("3.1416"); 3.1416 gap> Float(355/113); 3.14159 gap> Rat(last); 355/113 gap> Rat(0.33333); 1/3 gap> Int(1.e10); 10000000000 gap> Int(1.e20); 100000000000000000000 gap> Int(1.e30); 1000000000000000019884624838656 ]]>

Methods Floating-point numbers may be directly input, as in any usual mathematical software or language; with the exception that every floating-point number must contain a decimal digit. Therefore .1, .1e1, -.999 etc. are all valid &GAP; inputs.

Floating-point numbers so entered in &GAP; are stored as strings. They are converted to floating-point when they are first used. This means that, if the floating-point precision is increased, the constants are reevaluated to fit the new format.

Floating-point numbers may be followed by an underscore, as in 1._. This means that they are to be immediately converted to the current floating-point format. The underscore may be followed by a single letter, which specifies which format/precision to use. By default, &GAP; has a single floating-point handler, with fixed (53 bits) precision, and its format specifier is 'l' as in 1._l. Higher-precision floating-point computations is available via external packages; float for example.

A record, , contains all relevant constants for the current floating-point format; see its documentation for details. Typical fields are FLOAT.MANT_DIG=53, the constant FLOAT.VIEW_DIG=6 specifying the number of digits to view, and FLOAT.PI for the constant \pi. The constants have the same name as their C counterparts, except for the missing initial DBL_ or M_.

Floating-point numbers may be created using the single function , which accepts as arguments rational, string, or floating-point numbers. Floating-point numbers may also be created, in any floating-point representation, using as in NewFloat(IsIEEE754FloatRep,355/113), by supplying the category filter of the desired new floating-point number; or using as in NewFloat(1.0,355/113), by supplying a sample floating-point number.

Floating-point numbers may also be converted to other &GAP; formats using the usual commands , , .

Exact conversion to and from floating-point format may be done using external representations. The "external representation" of a floating-point number x is a pair [m,e] of integers, such that x=m*2^(1+e-LogInt(m,2)). Conversion to and from external representation is performed as usual using and : ExtRepOfObj(3.14); [ 7070651414971679, 2 ] gap> ObjByExtRep(IEEE754FloatsFamily,last); 3.14 ]]>

Computations with floating-point numbers never raise any error. Division by zero is allowed, and produces a signed infinity. Illegal operations, such as 0./0., produce NaN's (not-a-number); this is the only floating-point number x such that not EqFloat(x+0.0,x).

The IEEE754 standard requires NaN to be non-equal to itself. On the other hand, &GAP; requires every object to be equal to itself. To respect the IEEE754 standard, the function should be used instead of =.

The category a floating-point belongs to can be checked using the filters , , , , .

Comparisons between floating-point numbers and rationals are explicitly forbidden. The rationale is that objects belonging to different families should in general not be comparable in &GAP;. Floating-point numbers are also approximations of real numbers, and don't follow the same rules; consider for example, using the default &GAP; implementation of floating-point numbers, 1.0/3.0 = Float(1/3); true gap> (1.0/3.0)^5 = Float((1/3)^5); false ]]>

<#Include Label="FLOAT_UNARY"> <#Include Label="Float">

High-precision-specific methods &GAP; provides a mechanism for packages to implement new floating-point numerical interfaces. The following describes that mechanism, actual examples of packages are documented separately.

A package must create a record with fields (all optional) creator a function converting strings to floating-point; eager a character allowing immediate conversion to floating-point; objbyextrep a function creating a floating-point number out of a list [mantissa,exponent]; filter a filter for the new floating-point objects; constants a record containing numerical constants, such as MANT_DIG, MAX, MIN, NAN.

The package must install methods Int, Rat, String for its objects, and creators NewFloat(filter,IsRat), NewFloat(IsString).

It must then install methods for all arithmetic and numerical operations: PLUS, Exp, ...

The user chooses that implementation by calling with the record as argument, and with an optional second argument requesting a precision in binary digits.

Complex arithmetic Complex arithmetic may be implemented in packages, and is present in float. Complex numbers are treated as usual numbers; they may be input with an extra "i" as in -0.5+0.866i.

Methods should then be implemented for Norm, RealPart, ImaginaryPart, ComplexConjugate, ...

Interval-specific methods Interval arithmetic may also be implemented in packages. Intervals are in fact efficient implementations of sets of real numbers. The only non-trivial issue is how they should be compared. The standard EQ tests if the intervals are equal; however, it is usually more useful to know if intervals overlap, or are disjoint, or are contained in each other. The methods provided by the package should include Sup,Inf,Mid,DiameterOfInterval,Overlaps,IsSubset,IsDisjoint.

Note the usual convention that intervals are compared as in [a,b]\le[c,d] if and only if a\le c and b\le d.

gap-4r6p5/doc/ref/hash2.xml0000644000175000017500000002170312172557252014214 0ustar billbill Dictionaries and General Hash Tables People and computers spend a large amount of time with searching. Dictionaries are an abstract data structure which facilitates searching for objects. Depending on the kind of objects the implementation will use a variety of possible internal storage methods that will aim to provide the fastest possible access to objects. These internal methods include

Hash Tables for objects for which a hash function has been defined. Direct Indexing if the domain is small and cheaply enumerable Sorted Lists if a total order can be computed easily Plain lists for objects for which nothing but an equality test is available.

Using Dictionaries The standard way to use dictionaries is to first create a dictionary (using , and then to store objects (and associated information) in it and look them up.

For the creation of objects the user has to make a few choices: Is the dictionary only to be used to check whether objects are known already, or whether associated information is to be stored with the objects. This second case is called a lookup dictionary and is selected by the second parameter of .

The second choice is to indicate which kind of objects are to be stored. This choice will decide the internal storage used. This kind of objects is specified by the first parameter to , which is a sample object.

In some cases however such a sample object is not specific enough. For example when storing vectors over a finite field, it would not be clear whether all vectors will be over a prime field or over a field extension. Such an issue can be resolved by indicating in an (optional) third parameter to a domain which has to be a collection that will contain all objects to be used with this dictionary. (Such a domain may also be used internally to decide that direct indexing can be used).

The reason for this choice of giving two parameters is that in some cases no suitable collection of objects has been defined in &GAP; - for example for permutations there is no object representing the symmetric group on infinitely many points.

Once a dictionary has been created, it is possible to use to check which representation is used by &GAP;.

In the following example, we create a dictionary to store permutations with associated information. d:=NewDictionary((1,2,3),true);; gap> AddDictionary(d,(1,2),1); gap> AddDictionary(d,(5,6),9); gap> AddDictionary(d,(4,7),2); gap> LookupDictionary(d,(5,6)); 9 gap> LookupDictionary(d,(5,7)); fail ]]> A typical example of this use would be in an orbit algorithm. The dictionary would be used to store the elements known in the orbit together with their respective orbit positions.

We observe that this dictionary is stored internally by a sorted list. On the other hand, if we have an explicit, sorted element list, direct indexing is to be used. RepresentationsOfObject(d); [ "IsComponentObjectRep", "IsDictionaryDefaultRep", "IsListDictionary", "IsListLookupDictionary", "IsSortDictionary", "IsSortLookupDictionary" ] gap> d:=NewDictionary((1,2,3),true,Elements(SymmetricGroup(5)));; gap> RepresentationsOfObject(d); [ "IsComponentObjectRep", "IsDictionaryDefaultRep", "IsPositionDictionary", "IsPositionDictionary" ] ]]> (Just indicating SymmetricGroup(5) as a third parameter would still keep the first storage method, as indexing would be too expensive if no explicit element list is known.)

The same effect happens in the following example, in which we work with vectors: Indicating only a vector only enables sorted index, as it cannot be known whether all vectors will be defined over the prime field. On the other hand, providing the vector space (and thus limiting the domain) enables the use of hashing (which will be faster). v:=GF(2)^7;; gap> d:=NewDictionary(Zero(v),true);; gap> RepresentationsOfObject(d); [ "IsComponentObjectRep", "IsDictionaryDefaultRep", "IsListDictionary", "IsListLookupDictionary", "IsSortDictionary", "IsSortLookupDictionary" ] gap> d:=NewDictionary(Zero(v),true,v);; gap> RepresentationsOfObject(d); [ "IsComponentObjectRep", "IsDictionaryDefaultRep", "IsPositionDictionary", "IsPositionDictionary" ] ]]>

Dictionaries This section contains the formal declarations for dictionaries. For information on how to use them, please refer to the previous section . <#Include Label="[1]{dict}"> <#Include Label="[2]{dict}"> <#Include Label="NewDictionary">
Dictionaries via Binary Lists As there are situations where the approach via binary lists is explicitly desired, such dictionaries can be created deliberately. <#Include Label="DictionaryByPosition"> <#Include Label="IsDictionary"> <#Include Label="IsLookupDictionary"> <#Include Label="AddDictionary"> <#Include Label="KnowsDictionary"> <#Include Label="LookupDictionary">
General Hash Tables These sections describe some particularities for hash tables. These are intended mainly for extending the implementation - programs requiring hash functionality ought to use the dictionary interface described above.

We hash by keys and also store a value. Keys cannot be removed from the table, but the corresponding value can be changed. Fast access to last hash index allows you to efficiently store more than one array of values –this facility should be used with care.

This code works for any kind of object, provided you have a method to convert the key into a positive integer. This method should ideally be implemented efficiently in the core.

Note that, for efficiency, it is currently impossible to create a hash table with non-positive integers.

Hash keys The crucial step of hashing is to transform key objects into integers such that equal objects produce the same integer.

The actual function used will vary very much on the type of objects. However &GAP; provides already key functions for some commonly encountered objects. <#Include Label="DenseIntKey"> <#Include Label="SparseIntKey">

Dense hash tables Dense hash tables are used for hashing dense sets without collisions, in particular integers. Keys are stored as an unordered list and values as an array with holes. The position of a value is given by the function returned by , and so KeyIntDense must be one-to-one. <#Include Label="DenseHashTable">
Sparse hash tables Sparse hash tables are used for hashing sparse sets. Stores keys as an array with fail denoting an empty position, stores values as an array with holes. Uses the result of calling ) of the key. DefaultHashLength is the default starting hash table length; the table is doubled when it becomes half full.

In sparse hash tables, the integer obtained from the hash key is then transformed to an index position by taking it modulo the length of the hash array. <#Include Label="SparseHashTable"> <#Include Label="DoubleHashArraySize">

gap-4r6p5/doc/ref/intrfc.xml0000644000175000017500000007701012172557252014476 0ustar billbill Examples of Extending the System This chapter gives a few examples of how one can extend the functionality of &GAP;.

They are arranged in ascending difficulty. We show how to install new methods, add new operations and attributes and how to implement new features using categories and representations. (As we do not introduce completely new kinds of objects in these example it will not be necessary to declare any families.) Finally we show a simple way how to create new objects with an own arithmetic.

The examples given are all very rudimentary –no particular error checks are performed and the user interface sometimes is quite clumsy.

Even more complex examples that create whole classes of objects anew will be given in the following two chapters and .

Addition of a Method The easiest case is the addition of a new algorithm as a method for an existing operation for the existing structures.

For example, assume we wanted to implement a better method for computing the exponent of a nilpotent group (it is the product of the exponents of the Sylow subgroups).

The first task is to find which operation is used by &GAP; (it is ) and how it is declared. We can find this in the Reference Manual (in our particular case in section ) and the declaration in the library file lib/grp.gd. The easiest way to find the place of the declaration is usually to grep over all .gd and .g files, see section .

In our example the declaration in the library is:

Similarly we find that the filter represents the concept of being nilpotent.

We then write a function that implements the new algorithm which takes the right set of arguments and install it as a method. In our example this installation would be:

We have left out the optional rank argument of , which normally is a wise choice –&GAP; automatically uses an internal ranking based on the filters that is only offset by the given rank. So our method will certainly be regarded as better than a method that has been installed for mere groups or for solvable groups but will be ranked lower than the library method for abelian groups.

That's all. Using we can check for a nilpotent group that indeed our new method will be used.

When testing, remember that the method selection will not check for properties that are not known. (This is done internally by checking the property tester first.) Therefore the method would not be applicable for the group g in the following definition but only for the –mathematically identical but endowed with more knowledge by &GAP;– group h. (Section  shows a way around this.)

g:=Group((1,2),(1,3)(2,4));; gap> h:=Group((1,2),(1,3)(2,4));; gap> IsNilpotentGroup(h); # enforce test true gap> HasIsNilpotentGroup(g); false gap> HasIsNilpotentGroup(h); true ]]>

Let's now look at a slightly more complicated example: We want to implement a better method for computing normalizers in a nilpotent permutation group. (Such an algorithm can be found for example in .)

We already know , the filter represents the concept of being a group of permutations.

&GAP; uses to compute normalizers, however the declaration is a bit more complicated. In the library we find

The full mechanism of is described in chapter , however for our purposes it is sufficient to know that for such a function the actual work is done by an operation NormalizerOp, an underlying operation for (and all the complications are just there to be able to remember certain results) and that the declaration of this operation is given by the first arguments, it would be:

This time we decide to enter a non-default family predicate in the call to . We could just leave it out as in the previous call; this would yield the default value, the function of arbitrary many arguments which always returns true. However, then the method might be called in some cases of inconsistent input (for example matrix groups in different characteristics) that ought to fall through the method selection to raise an error.

In our situation, we want the second group to be a subgroup of the first, so necessarily both must have the same family and we can use as family predicate.

Now we can install the method. Again this manual is lazy and does not show you the actual code:

Extending the Range of Definition of an Existing Operation It might be that the operation has been defined so far only for a set of objects that is too restrictive for our purposes (or we want to install a method that takes another number of arguments). If this is the case, the call to causes an error message. We can avoid this by using instead. It is also possible to re-declare an operation with another number of arguments and/or different filters for its arguments.
Enforcing Property Tests As mentioned above, &GAP; does not check unknown properties to test whether a method might be applicable. In some cases one wants to enforce this, however, because the gain from knowing the property outweighs the cost of its determination.

In this situation one has to install a method without the additional property (so it can be tried even if the property is not yet known) and at high rank (so it will be used before other methods). The first thing to do in the actual function then is to test the property and to bail out with if it turns out to be false.

The above example thus would become:

The value 50 used in this example is quite arbitrary. A better way is to use values that are given by the system inherently: We want this method still to be ranked as high, as if it had the requirement. So we have &GAP; compute the extra rank of this: the slightly complicated construction of addition and subtraction is necessary because and might imply the same elementary filters which we otherwise would count twice.

A somehow similar situation occurs with matrix groups. Most methods for matrix groups are only applicable if the group is known to be finite.

However we should not enforce a finiteness test early (someone else later might install good methods for infinite groups while the finiteness test would be too expensive) but just before &GAP; would give a no method found error. This is done by redispatching, see . For example to enforce such a final finiteness test for normalizer calculations could be done by:

Adding a new Operation Next, we will consider how to add own operations. As an example we take the Sylow normalizer in a group of a given prime. This operation gets two arguments, the first has to be a group, the second a prime number.

There is a function , but no property for being prime (which would be pointless as integers cannot store property values anyhow). So the second argument gets specified only as positive integer: (Note that we are using instead of as used in the library. The only difference other than that saves some typing, is that it also protects the variables against overwriting. When testing code (when one probably wants to change things) this might be restricting. If this does not bother you, you can use

as well.)

The filters and given are only used to test that installs methods with suitable arguments and will be completely ignored when using . Technically one could therefore simply use for all arguments in the declaration. The main point of using more specific filters here is to help documenting with which arguments the function is to be used (so for example a call SylowNormalizer(5,G) would be invalid).

Of course initially there are no useful methods for newly declared operations; you will have to write and install them yourself.

If the operation only takes one argument and has reproducible results without side effects, it might be worth declaring it as an attribute instead; see Section .

Adding a new Attribute NewAttribute DeclareAttribute Now we look at an example of how to add a new attribute. As example we consider the set of all primes that divide the size of a group.

First we have to declare the attribute:

(See ). This implicitly declares attribute tester and setter, it is convenient however to assign these to variables as well:

Alternatively, there is a declaration command that executes all three assignments simultaneously and protects the variables against overwriting:

Next we have to install method(s) for the attribute that compute its value. (This is not strictly necessary. We could use the attribute also without methods only for storing and retrieving information, but calling it for objects for which the value is not known would produce a no method found error.) For this purpose we can imagine the attribute simply as an one-argument operation:

IsAttributeStoringRep The function installed must always return a value (or call ). If the object is in the representation IsAttributeStoringRep this return value once computed will be automatically stored and retrieved if the attribute is called a second time. We don't have to call setter or tester ourselves. (This storage happens by &GAP; internally calling the attribute setter with the return value of the function. Retrieval is by a high-ranking method which is installed under the condition HasPrimesDividingSize. This method was installed automatically when the attribute was declared.)

Adding a new Representation NewRepresentation DeclareRepresentation IsComponentObjectRep IsAttributeStoringRep Next, we look at the implementation of a new representation of existing objects. In most cases we want to implement this representation only for efficiency reasons while keeping all the existing functionality.

For example, assume we wanted (following ) to implement permutation groups defined by relations.

Next, we have to decide a few basics about the representation. All existing permutation groups in the library are attribute storing and we probably want to keep this for our new objects. Thus the representation must be a subrepresentation of IsComponentObjectRep and IsAttributeStoringRep. Furthermore we want each object to be a permutation group and we can imply this directly in the representation.

We also decide that we store the degree (the largest point that might be moved) in a component degree and the defining relations in a component relations (we do not specify the format of relations here. In an actual implementation one would have to design this as well, but it does not affect the declarations this chapter is about).

(If we wanted to implement sparse matrices we might for example rather settle for a positional object in which we store a list of the nonzero entries.)

We can make the new representation a subrepresentation of an existing one. In such a case of course we have to provide all structure of this parent representation as well.

Next we need to check in which family our new objects will be. This will be the same family as of every other permutation group, namely the CollectionsFamily(PermutationsFamily) (where the family PermutationsFamily = FamilyObj((1,2,3)) has been defined already in the library).

Now we can write a function to create our new objects. Usually it is helpful to look at functions from the library that are used in similar situations (for example in our case) to make sure we have not forgotten any further requirements in the declaration we might have to add here. However in most cases the function is straightforward:

It also is a good idea to install a and possibly also a method –otherwise testing becomes quite hard:

Next we have to write enough methods for the new representation so that the existing algorithms can be used. In particular we will have to implement methods for all operations for which library or kernel provides methods for the existing (alternative) representations. In our particular case there are no such methods. (If we would have implemented sparse matrices we would have had to implement methods for the list access and assignment functions, see .) However the existing way permutation groups are represented is by generators. To be able to use the existing machinery we want to be able to obtain a generating set also for groups in our new representation. This can be done (albeit not very effectively) by a stabilizer calculation in the symmetric group given by the degree component. The operation function to use is probably a bit complicated and will depend on the format of the relations (we have not specified in this example). In the following method we use operationfunction as a placeholder;

This is all we must do. Of course for performance reasons one might want to install methods for further operations as well.

Components versus Attributes In the last section we introduced two new components, G!.degree and G!.relations. Technically, we could have used attributes instead. There is no clear distinction which variant is to be preferred: An attribute expresses part of the functionality available to certain objects (and thus could be computed later and probably even for a wider class of objects), a component is just part of the internal definition of an object.

So if the data is of general interest, if we want the user to have access to it, attributes are preferable. Moreover, attributes can be used by the method selection (by specifying the filter HasAttr for an attribute Attr). They provide a clean interface and their immutability makes it safe to hand the data to a user who potentially could corrupt a components entries.

On the other hand more technical data (say the encoding of a sparse matrix) is better hidden from the user in a component, as declaring it as an attribute would not give any advantage.

Resource-wise, attributes need more memory (the attribute setter and tester are implicitly declared, and one filter bit is required), the attribute access is one further function call in the kernel, thus components might be an immeasurable bit faster.

Adding new Concepts Now we look how to implement a new concept for existing objects and fit this in the method selection. Three examples that will be made more explicit below would be groups for which a length of elements (as a word in certain generators) is defined, groups that can be decomposed as a semidirect product and M-groups.

In each case we have two possibilities for the declaration. We can either declare it as a property or as a category. Both are eventually filter(s) and in this way indistinguishable for the method selection. However, the value of a property for a particular object can be unknown at first and later in the session be computed (to be true or false). This is implemented by reserving two filters for each property, one indicating whether the property value is known, and one, provided the value is known, to indicate the actual boolean value. Contrary to this, the decision whether or not an object lies in a category is taken at creation time and this is implemented using a single filter.

Property: Properties also are attributes: If a property value is not known for an object, &GAP; tries to find a method to compute the property value. If no suitable method is found, an error is raised. Category: An object is in a category if it has been created in it. Testing the category for an object simply returns this value. Existing objects cannot enter a new category later in life. This means that in most cases one has to write own code to create objects in a new category.

If we want to implement a completely new concept so that new operations are defined only for the new objects –for example bialgebras for which a second scalar multiplication is defined– usually a category is chosen.

Technically, the behaviour of the category IsXYZ, declared as subcategory of IsABC is therefore exactly the same as if we would declare IsXYZ to be a property for IsABC and install the following method:

(The word category also has a well-defined mathematical meaning, but this does not need to concern us at this point. The set of objects which is defined to be a (&GAP;) category does not need to be a category in the mathematical sense, vice versa not every mathematical category is declared as a (&GAP;) category.) Eventually the choice between category and property often becomes a matter of taste or style.

Sometimes there is even a third possibility (if you have &GAP; 3 experience this might reflect most closely an object whose operations record is XYOps): We might want to indicate this new concept simply by the fact that certain attributes are set. In this case we could simply use the respective attribute tester(s).

The examples given below each give a short argument why the respective solution was chosen, but one could argue as well for other choices. Example: M-groups M-groups are finite groups for which all irreducible complex representations are induced from linear representations of subgroups, it turns out that they are all solvable and that every supersolvable group is an M-group. See for further details.

Solvability and supersolvability both are testable properties. We therefore declare IsMGroup as a property for solvable groups: The filter in this declaration only means that methods for IsMGroup by default can only be installed for groups that are (and know to be) solvable (though they could be installed for more general situations using ). It does not yet imply that M-groups are solvable. We must do this deliberately via an implication and we use the same technique to imply that every supersolvable group is an M-group.

Now we might install a method that tests for solvable groups whether they are M-groups: Example: Groups with a word length Our second example is that of groups for whose elements a word length is defined. (We assume that the word length is only defined in the context of the group with respect to a preselected generating set but not for single elements alone. However we will not delve into any details of how this length is defined and how it could be computed.)

Having a word length is a feature which enables other operations (for example a word length function). This is exactly what categories are intended for and therefore we use one.

First, we declare the category. All objects in this category are groups and so we inherit the supercategory :

We also define the operation which is enabled by this category, the word length of a group element, which is defined for a group and an element (remember that group elements are described by the category ):

We then would proceed by installing methods to compute the word length in concrete cases and might for example add further operations to get shortest words in cosets. Example: Groups with a decomposition as semidirect product

DeclareAttribute!example The third example is groups which have a (nontrivial) decomposition as a semidirect product. If this information has been found out, we want to be able to use it in algorithms. (Thus we do not only need the fact that there is a decomposition, but also the decomposition itself.)

We also want this to be applicable to every group and not only for groups which have been explicitly constructed via .

Instead we simply declare an attribute SemidirectProductDecomposition for groups. (Again, in this manual we don't go in the details of how such an decomposition would look like).

If a decomposition has been found, it can be stored in a group using SetSemidirectProductDecomposition. (At the moment all groups in &GAP; are attribute storing.)

Methods that rely on the existence of such a decomposition then get installed for the tester filter HasSemidirectProductDecomposition.

Creating Own Arithmetic Objects Finally let's look at a way to create new objects with a user-defined arithmetic such that one can form for example groups, rings or vector spaces of these elements. This topic is discussed in much more detail in chapter , in this section we present a simple approach that may be useful to get started but does not permit you to exploit all potential features.

The basic design is that the user designs some way to represent her objects in terms of &GAP;s built-in types, for example as a list or a record. We call this the defining data of the new objects. Also provided are functions that perform arithmetic on this defining data, that is they take objects of this form and return objects that represent the result of the operation. The function then is called to provide a wrapping such that proper new &GAP;-objects are created which can be multiplied etc. with the default infix operations such as *.

<#Include Label="ArithmeticElementCreator"> Example: ArithmeticElementCreator As the first example we look at subsets of \{ 1, \ldots, 4 \} and define an addition as union and multiplication as intersection. These operations are both commutative and we want the resulting elements to know this.

We therefore use the following specification:

# the whole set gap> w := [1,2,3,4]; [ 1, 2, 3, 4 ] gap> PosetElementSpec :=rec( > # name of the new elements > ElementName := "PosetOn4", > # arithmetic operations > One := a -> w, > Zero := a -> [], > Multiplication := function(a, b) return Intersection(a, b); end, > Addition := function(a, b) return Union(a, b); end, > # Mathematical properties of the elements > MathInfo := IsCommutativeElement and IsAdditivelyCommutativeElement > );; gap> mkposet := ArithmeticElementCreator(PosetElementSpec); function( x ) ... end ]]>

Now we can create new elements, perform arithmetic on them and form domains:

a := mkposet([1,2,3]); [ 1, 2, 3 ] gap> CategoriesOfObject(a); [ "IsExtAElement", "IsNearAdditiveElement", "IsNearAdditiveElementWithZero", "IsAdditiveElement", "IsExtLElement", "IsExtRElement", "IsMultiplicativeElement", "IsMultiplicativeElementWithOne", "IsAdditivelyCommutativeElement", "IsCommutativeElement", "IsPosetOn4" ] gap> a=[1,2,3]; false gap> UnderlyingElement(a)=[1,2,3]; true gap> b:=mkposet([2,3,4]); [ 2, 3, 4 ] gap> a+b; [ 1, 2, 3, 4 ] gap> a*b; [ 2, 3 ] gap> s:=Semigroup(a,b); gap> Size(s); 3 ]]>

The categories IsPosetOn4 and IsPosetOn4Collection can be used to install methods specific to the new objects. IsPosetOn4Collection(s); true ]]>

gap-4r6p5/doc/ref/boolean.xml0000644000175000017500000002145012172557252014625 0ustar billbill Booleans type logical The two main boolean values are true and false. They stand for the logical values of the same name. They appear as values of the conditions in if-statements and while-loops. Booleans are also important as return values of filters (see ) such as and . Note that it is a convention that the name of a function that returns true or false according to the outcome, starts with Is.

For technical reasons, also the value fail (see ) is regarded as a boolean.

IsBool (Filter) <#Include Label="IsBool">
Fail (Variable) The value fail is used to indicate situations when an operation could not be performed for the given arguments, either because of shortcomings of the arguments or because of restrictions in the implementation or computability. So for example will return fail if the point searched for is not in the list.

fail is simply an object that is different from every other object than itself.

For technical reasons, fail is a boolean value. But note that fail cannot be used to form boolean expressions with and, or, and not (see  below), and fail cannot appear in boolean lists (see Chapter ).

Comparisons of Booleans comparisons Equality and inequality of Booleans equality inequality bool1 = bool2

\noindent bool1 <> bool2

The equality operator = evaluates to true if the two boolean values bool1 and bool2 are equal, i.e., both are true or both are false or both fail, and false otherwise. The inequality operator <> evaluates to true if the two boolean values bool1, bool2 are different, and false otherwise. This operation is also called the exclusive or, because its value is true if exactly one of bool1 or bool2 is true.

You can compare boolean values with objects of other types. Of course they are never equal.

true = false; false gap> false = (true = fail); true gap> true <> 17; true ]]> Ordering of Booleans ordering bool1 < bool2

The ordering of boolean values is defined by true < false < fail. For the comparison of booleans with other &GAP; objects, see Section .

true < false; fail >= false; true true ]]>

Operations for Booleans operations logical operations The following boolean operations are only applicable to true and false.

Logical disjunction Logical disjunction or bool1 or bool2

The logical operator or evaluates to true if at least one of the two boolean operands bool1 and bool2 is true, and to false otherwise.

or first evaluates bool1. If the value is neither true nor false an error is signalled. If the value is true, then or returns true without evaluating bool2. If the value is false, then or evaluates bool2. Again, if the value is neither true nor false an error is signalled. Otherwise or returns the value of bool2. This short-circuited evaluation is important if the value of bool1 is true and evaluation of bool2 would take much time or cause an error.

or is associative, i.e., it is allowed to write b1 or b2 or b3, which is interpreted as (b1 or b2) or b3. or has the lowest precedence of the logical operators. All logical operators have lower precedence than the comparison operators =, <, in, etc.

true or false; true gap> false or false; false gap> i := -1;; l := [1,2,3];; gap> if i <= 0 or l[i] = false then # this does not cause an error, > Print("aha\n"); fi; # because `l[i]' is not evaluated aha ]]> Logical conjunction Logical conjunction and bool1 and bool2

and \noindent fil1 and fil2

The logical operator and evaluates to true if both boolean operands bool1, bool2 are true, and to false otherwise.

and first evaluates bool1. If the value is neither true nor false an error is signalled. If the value is false, then and returns false without evaluating bool2. If the value is true, then and evaluates bool2. Again, if the value is neither true nor false an error is signalled. Otherwise and returns the value of bool2. This short-circuited evaluation is important if the value of bool1 is false and evaluation of bool2 would take much time or cause an error.

and is associative, i.e., it is allowed to write b1 and b2 and b3, which is interpreted as (b1 and b2) and b3. and has higher precedence than the logical or operator, but lower than the unary logical not operator. All logical operators have lower precedence than the comparison operators =, <, in, etc.

true and false; false gap> true and true; true gap> false and 17; # does not cause error, because 17 is never looked at false ]]>

and can also be applied to filters. It returns a filter that when applied to some argument x, tests fil1(x) and fil2(x).

andfilt:= IsPosRat and IsInt;; gap> andfilt( 17 ); andfilt( 1/2 ); true false ]]> Logical negation Logical negation not not bool

The logical operator not returns true if the boolean value bool is false, and true otherwise. An error is signalled if bool does not evaluate to true or false.

not has higher precedence than the other logical operators, or and and. All logical operators have lower precedence than the comparison operators =, <, in, etc.

true and false; false gap> not true; false gap> not false; true ]]>

gap-4r6p5/doc/ref/combinat.xml0000644000175000017500000000565512172557252015013 0ustar billbill Combinatorics This chapter describes functions that deal with combinatorics. We mainly concentrate on two areas. One is about selections, that is the ways one can select elements from a set. The other is about partitions, that is the ways one can partition a set into the union of pairwise disjoint subsets.
Combinatorial Numbers <#Include Label="Factorial"> <#Include Label="Binomial"> <#Include Label="Bell"> <#Include Label="Bernoulli"> <#Include Label="Stirling1"> <#Include Label="Stirling2">
Combinations, Arrangements and Tuples <#Include Label="Combinations"> <#Include Label="IteratorOfCombinations"> <#Include Label="NrCombinations"> <#Include Label="Arrangements"> <#Include Label="NrArrangements"> <#Include Label="UnorderedTuples"> <#Include Label="NrUnorderedTuples"> <#Include Label="Tuples"> <#Include Label="EnumeratorOfTuples"> <#Include Label="IteratorOfTuples"> <#Include Label="NrTuples"> <#Include Label="PermutationsList"> <#Include Label="NrPermutationsList"> <#Include Label="Derangements"> <#Include Label="NrDerangements"> <#Include Label="PartitionsSet"> <#Include Label="NrPartitionsSet"> <#Include Label="Partitions"> <#Include Label="IteratorOfPartitions"> <#Include Label="NrPartitions"> <#Include Label="OrderedPartitions"> <#Include Label="NrOrderedPartitions"> <#Include Label="PartitionsGreatestLE"> <#Include Label="PartitionsGreatestEQ"> <#Include Label="RestrictedPartitions"> <#Include Label="NrRestrictedPartitions"> <#Include Label="SignPartition"> <#Include Label="AssociatedPartition"> <#Include Label="PowerPartition"> <#Include Label="PartitionTuples"> <#Include Label="NrPartitionTuples">
Fibonacci and Lucas Sequences <#Include Label="Fibonacci"> <#Include Label="Lucas">
Permanent of a Matrix <#Include Label="Permanent">
gap-4r6p5/doc/ref/moreinfo.xml0000644000175000017500000000521512172557252015025 0ustar billbill Information about &GAP; is best obtained from the &GAP; website

http://www.gap-system.org

There you will find, amongst other things directions to the sites from which you can download the current &GAP; distribution, all accepted and deposited &GAP; packages, and a selection of other contributions. the &GAP; manual and an archive of the gap-forum mailing list, formatted for reading with a Web browser, and indexed for searching. information about &GAP; developers, and about the email addresses available for comment, discussion and support.

We would particularly ask you to note the following things: The &GAP; Forum – an email discussion forum for comments, discussions or questions about &GAP;. You must subscribe to the list before you can post to it, see the website for details. In particular we will announce new releases in this mailing list. The email address support@gap-system.org to which you are asked to send any questions or bug reports which do not seem likely to be of interest to the whole &GAP; Forum. Please give a (short, if possible) self-contained excerpt of a &GAP; session containing both input and output that illustrates your problem (including comments of why you think it is a bug) and state the type of the machine, operating system, (compiler used, if UNIX/Linux) and the version of &GAP; you are using (the first line after the &GAP; 4 banner starting GAP, Version 4...). We also ask you to send a brief message to support@gap-system.org when you install &GAP;. The correct form of citation of &GAP;, which we ask you use whenever you publish scientific results obtained using &GAP;.

It finally remains for us to wish you all pleasure and success in using &GAP;, and to invite your constructive comment and criticism.

The GAP Group,

&RELEASEDAY; gap-4r6p5/doc/ref/module.xml0000644000175000017500000000362112172557252014473 0ustar billbill Modules

Generating modules <#Include Label="IsLeftOperatorAdditiveGroup"> <#Include Label="IsLeftModule"> <#Include Label="GeneratorsOfLeftOperatorAdditiveGroup"> <#Include Label="GeneratorsOfLeftModule"> <#Include Label="AsLeftModule"> <#Include Label="IsRightOperatorAdditiveGroup"> <#Include Label="IsRightModule"> <#Include Label="GeneratorsOfRightOperatorAdditiveGroup"> <#Include Label="GeneratorsOfRightModule"> <#Include Label="LeftModuleByGenerators"> <#Include Label="LeftActingDomain">
Submodules <#Include Label="Submodule"> <#Include Label="SubmoduleNC"> <#Include Label="ClosureLeftModule"> <#Include Label="TrivialSubmodule">
Free Modules <#Include Label="IsFreeLeftModule"> <#Include Label="FreeLeftModule"> <#Include Label="Dimension"> <#Include Label="IsFiniteDimensional"> <#Include Label="UseBasis"> <#Include Label="IsRowModule"> <#Include Label="IsMatrixModule"> <#Include Label="IsFullRowModule"> <#Include Label="FullRowModule"> <#Include Label="IsFullMatrixModule"> <#Include Label="FullMatrixModule">
gap-4r6p5/doc/ref/semigrp.xml0000644000175000017500000001253012172557252014653 0ustar billbill Semigroups This chapter describes functions for creating semigroups and determining information about them.
IsSemigroup (Filter) <#Include Label="IsSemigroup"> <#Include Label="Semigroup"> <#Include Label="Subsemigroup"> <#Include Label="SemigroupByGenerators"> <#Include Label="AsSemigroup"> <#Include Label="AsSubsemigroup"> <#Include Label="GeneratorsOfSemigroup"> <#Include Label="FreeSemigroup"> <#Include Label="SemigroupByMultiplicationTable">
Properties of Semigroups The following functions determine information about semigroups. <#Include Label="IsRegularSemigroup"> <#Include Label="IsRegularSemigroupElement"> <#Include Label="IsSimpleSemigroup"> <#Include Label="IsZeroSimpleSemigroup"> <#Include Label="IsZeroGroup"> <#Include Label="IsReesCongruenceSemigroup">
Making transformation semigroups Cayley's Theorem gives special status to semigroups of transformations, and accordingly there are special functions to deal with them, and to create them from other finite semigroups. <#Include Label="IsTransformationSemigroup"> <#Include Label="DegreeOfTransformationSemigroup"> <#Include Label="IsomorphismTransformationSemigroup"> <#Include Label="IsFullTransformationSemigroup"> <#Include Label="FullTransformationSemigroup">
Ideals of semigroups Ideals of semigroups are the same as ideals of the semigroup when considered as a magma. For documentation on ideals for magmas, see . <#Include Label="SemigroupIdealByGenerators"> <#Include Label="ReesCongruenceOfSemigroupIdeal"> <#Include Label="IsLeftSemigroupIdeal">
Congruences for semigroups An equivalence or a congruence on a semigroup is the equivalence or congruence on the semigroup considered as a magma. So, to deal with equivalences and congruences on semigroups, magma functions are used. For documentation on equivalences and congruences for magmas, see . <#Include Label="IsSemigroupCongruence"> <#Include Label="IsReesCongruence">
Quotients Given a semigroup and a congruence on the semigroup, one can construct a new semigroup: the quotient semigroup. The following functions deal with quotient semigroups in &GAP;. <#Include Label="[1]{semiquo}"> <#Include Label="IsQuotientSemigroup"> <#Include Label="HomomorphismQuotientSemigroup"> <#Include Label="QuotientSemigroupPreimage">
Green's Relations <#Include Label="[1]{semirel}"> <#Include Label="GreensRRelation"> <#Include Label="IsGreensRelation"> <#Include Label="IsGreensClass"> <#Include Label="IsGreensLessThanOrEqual"> <#Include Label="RClassOfHClass"> <#Include Label="EggBoxOfDClass"> <#Include Label="DisplayEggBoxOfDClass"> <#Include Label="GreensRClassOfElement"> <#Include Label="GreensRClasses"> <#Include Label="GroupHClassOfGreensDClass"> <#Include Label="IsGroupHClass"> <#Include Label="IsRegularDClass">
Rees Matrix Semigroups <#Include Label="[1]{reesmat}"> <#Include Label="ReesMatrixSemigroup"> <#Include Label="ReesZeroMatrixSemigroup"> <#Include Label="IsReesMatrixSemigroup"> <#Include Label="IsReesZeroMatrixSemigroup"> <#Include Label="ReesMatrixSemigroupElement"> <#Include Label="IsReesMatrixSemigroupElement"> <#Include Label="SandwichMatrixOfReesMatrixSemigroup"> <#Include Label="RowIndexOfReesMatrixSemigroupElement"> <#Include Label="ReesZeroMatrixSemigroupElementIsZero"> <#Include Label="AssociatedReesMatrixSemigroupOfDClass"> <#Include Label="IsomorphismReesMatrixSemigroup">
gap-4r6p5/doc/ref/extractexamples.g0000644000175000017500000000153312172557252016045 0ustar billbill# This code extracts the examples from the ref manual chapter-wise and # stores this in a workspace. Read("makedocreldata.g"); exsref := ExtractExamples(GAPInfo.ManualDataRef.pathtodoc, GAPInfo.ManualDataRef.main, GAPInfo.ManualDataRef.files, "Chapter"); RS := rec(changeSources := true); WS := rec(compareFunction := "uptowhitespace"); WSRS := rec(changeSources := true, compareFunction := "uptowhitespace"); WriteRefExamplesTst := function(fnam) local ch, i, a; PrintTo(fnam,"gap> save:=SizeScreen();; SizeScreen([72,save[2]]);;\n"); for i in [1..Length(exsref)] do ch := exsref[i]; AppendTo(fnam, "\n#### Reference manual, Chapter ",i," ####\n", "gap> START_TEST(\"", i, "\");\n"); for a in ch do AppendTo(fnam, "\n# ",a[2], a[1]); od; od; AppendTo(fnam, "gap> SizeScreen(save);;\n"); end; gap-4r6p5/doc/ref/copyrigh.xml0000644000175000017500000001060012172557252015025 0ustar billbill Copyright ©right; (1987-&RELEASEYEAR;) by the &GAP; Group,

incorporating the Copyright ©right; 1999, 2000 by School of Mathematical and Computational Sciences, University of St Andrews, North Haugh, St Andrews, Fife KY16 9SS, Scotland

being the Copyright ©right; 1992 by Lehrstuhl D für Mathematik, RWTH, 52056 Aachen, Germany, transferred to St Andrews on July 21st, 1997.

except for files in the distribution, which have an explicit different copyright statement. In particular, the copyright of packages distributed with &GAP; is usually with the package authors or their institutions.

&GAP; is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. For details, see the file GPL in the etc directory of the &GAP; distribution or see http://www.gnu.org/licenses/gpl.html.

If you obtain &GAP; please send us a short notice to that effect, e.g., an e-mail message to the address support@gap-system.org. This helps us to keep track of the number of &GAP; users.

If you publish a mathematical result that was partly obtained using &GAP;, please cite &GAP;, just as you would cite another paper that you used (see below for sample citation). Also we would appreciate if you could inform us about such a paper, which we will add to the &GAP; http://www.gap-system.org/Doc/Bib/bib.html.

Specifically, please refer to

[GAP] The GAP Group, GAP - Groups, Algorithms, and Programming, Version &VERSIONNUMBER;; &RELEASEYEAR; (http://www.gap-system.org)

You are permitted to modify and redistribute &GAP;, but you are not allowed to restrict further redistribution. That is to say proprietary modifications will not be allowed. We want all versions of &GAP; to remain free.

If you modify any part of &GAP; and redistribute it, you must supply a README document. This should specify what modifications you made in which files. We do not want to take credit or be blamed for your modifications.

Of course we are interested in all of your modifications. In particular we would like to see bug-fixes, improvements and new functions. So again we would appreciate it if you would inform us about all modifications you make.

In addition to the general copyright for &GAP; set forth above, the following terms apply to the versions of &GAP; for Windows.

The executable of &GAP; for Windows that we distribute was compiled with the gcc compiler supplied with Cygwin installation (http://cygwin.com/).

The GNU C compiler is

Copyright ©right; 2010 Free Software Foundation, Inc.

under the terms of the GNU General Public License (GPL).

The Cygwin API library is also covered by the GNU GPL. The executable we provide is linked against this library (and in the process includes GPL'd Cygwin glue code). This means that the executable falls under the GPL too, which it does anyhow.

The cyggcc_s-1.dll, cygncurses-10.dll, cygncursesw-10.dll, cygpanel-10.dll, cygpopt-0.dll, cygreadline7.dll, cygstart.exe, cygwin1.dll, libW11.dll, mintty.exe, rxvt.exe and regtool.exe are taken unmodified from the Cygwin distribution. They are copyright by RedHat Software and released under the GPL. For more information on Cygwin, see http://www.cygwin.com.

Please contact support@gap-system.org if you need further information. gap-4r6p5/doc/ref/function.xml0000644000175000017500000001516012172557252015034 0ustar billbill Functions functions The section  describes how to define a function. In this chapter we describe functions that give information about functions, and various utility functions used either when defining functions or calling functions.

Information about a function <#Include Label="NameFunction"> <#Include Label="NumberArgumentsFunction"> <#Include Label="NamesLocalVariablesFunction"> <#Include Label="FilenameFunc"> <#Include Label="StartlineFunc"> <#Include Label="PageSource">
Calling a function with a list argument that is interpreted as several arguments <#Include Label="CallFuncList">
Functions that do nothing The following functions return fixed results (or just their own argument). They can be useful in places when the syntax requires a function, but actually no functionality is required. So is often used as family predicate in . <#Include Label="ReturnTrue"> <#Include Label="ReturnFalse"> <#Include Label="ReturnFail"> <#Include Label="IdFunc">
Function Types Functions are &GAP; objects and thus have categories and a family. <#Include Label="IsFunction"> <#Include Label="IsOperation"> <#Include Label="FunctionsFamily">
Naming Conventions The way functions are named in &GAP; might help to memorize or even guess names of library functions.

If a variable name consists of several words then the first letter of each word is capitalized.

If the first part of the name of a function is a verb then the function may modify its argument(s) but does not return anything, for example appends the list given as second argument to the list given as first argument. Otherwise the function returns an object without changing the arguments, for example returns the concatenation of the lists given as arguments.

If the name of a function contains the word Of then the return value is thought of as information deduced from the arguments. Usually such functions are attributes (see ). Examples are , which returns a list of generators for the group entered as argument, or .

For the setter and tester functions of an attribute Attr the names SetAttr resp. HasAttr are available (see ).

If the name of a function contains the word By then the return value is thought of as built in a certain way from the parts given as arguments. For example, creating a group as a factor group of a given group by a normal subgroup can be done by taking the image of . Other examples of By functions are and .

Often such functions construct an algebraic structure given by its generators (for example, ). In some cases, By may be replaced by With (like e.g. ) or even both versions of the name may be used. The difference between StructByGenerators and StructWithGenerators is that the latter guarantees that the GeneratorsOfStruct value of the result is equal to the given set of generators (see ).

If the name of a function has the form AsSomething then the return value is an object (usually a collection which has the same family of elements), which may, for example: know more about its own structure (and so support more operations) than its input (e.g. if the elements of the collection form a group, then this group can be constructed using ); discard its additional structure (e.g. applied to a group will return a list of its elements); contain all elements of the original object without duplicates (like e.g. does if its argument is a list of elements from the same family); remain unchanged (like e.g. does if its argument is a group). If Something and the argument of AsSomething are domains, some further rules apply as explained in .

If the name of a function fun1 ends with NC then there is another function fun2 with the same name except that the NC is missing. NC stands for no check. When fun2 is called then it checks whether its arguments are valid, and if so then it calls fun1. The functions and are a typical example.

The idea is that the possibly time consuming check of the arguments can be omitted if one is sure that they are unnecessary. For example, if an algorithm produces generators of the derived subgroup of a group then it is guaranteed that they lie in the original group; would check this, and omits the check.

Needless to say, all these rules are not followed slavishly, for example there is one operation instead of two operations ZeroOfElement and ZeroOfAdditiveGroup.

gap-4r6p5/doc/ref/foa.xml0000644000175000017500000002132212172557252013751 0ustar billbill Function-Operation-Attribute Triples &GAP; is eager to maintain information that it has gathered about an object, possibly by lengthy calculations. The most important mechanism for information maintenance is the automatic storage and look-up that takes place for attributes; and this was already mentioned in section . In this chapter we will describe further mechanisms that allow storage of results that are not values of attributes.

FOA triples The idea which is common to all sections is that certain operations, which are not themselves attributes, have an attribute associated with them. To automatically delegate tasks to the attribute, &GAP; knows, in addition to the operation and the attributes also a function, which is wrapped around the other two. This wrapper function is called by the user and decides whether to call the operation or the attribute or possibly both. The whole function-operation-attribute triple (or FOA triple) is set up by a single &GAP; command which writes the wrapper function and already installs some methods, e.g., for the attribute to fall back on the operation. The idea is then that subsequent methods, which perform the actual computation, are installed only for the operation, whereas the wrapper function remains unaltered, and in general no additional methods for the attribute are required either.

Key Dependent Operations <#Include Label="KeyDependentOperation">
In Parent Attributes <#Include Label="InParentFOA">
Operation Functions ExternalSet G-sets Orbits Chapter  and, in particular, the Section  explain that certain operations such as ), besides their usual usage with arguments G, D, and opr, can also be applied to an external set (G-set), in which case they can be interpreted as attributes. Moreover, they can also be interpreted as attributes for permutation groups, meaning the natural action on the set of its moved points.

The definition of says that a method should be a function with arguments G, D, gens, oprs, and opr, as in the case of the operation when specified via gens and oprs (see ). All other syntax variants allowed for (e.g., leaving out gens and oprs) are handled by default methods.

The default methods for support the following behaviour. If the only argument is an external set xset and the attribute tester HasOrbits( xset ) returns true, the stored value of that attribute is returned. If the only argument is an external set xset and the attribute value is not known, the default arguments are obtained from the data of xset. If gens and oprs are not specified, gens is set to Pcgs( G ) if CanEasilyComputePcgs( G ) is true, and to GeneratorsOfGroup( G ) otherwise; oprs is set to gens. The default value of opr is . In the case of an operation of a permutation group G on MovedPoints( G ) via , if the attribute tester HasOrbits( G ) returns true, the stored attribute value is returned. The operation is called as result:= Orbits( G, D, gens, oprs, opr ). In the case of an external set xset or a permutation group G in its natural action, the attribute setter is called to store result. result is returned.

The declaration of operations that match the above pattern is done as follows. <#Include Label="OrbitsishOperation"> <#Include Label="OrbitishFO"> Example: Orbit and OrbitOp For example, to setup the function and its operation OrbitOp, the declaration file lib/oprt.gd contains the following line of code: The variable OrbitishReq contains the standard requirements which are usually entered in calls to .

The relation test via famrel is used to provide a uniform construction of the wrapper functions created by , in spite of the different syntax of the specific functions. For example, admits the calls Orbit( G, D, pnt, opr ) and Orbit( G, pnt, opr ), i.e., the second argument D may be omitted; admits the calls Blocks( G, D, seed, opr ) and Blocks( G, D, opr ), i.e., the third argument may be omitted. The translation to the appropriate call of OrbitOp or BlocksOp, for either operation with five or six arguments, is handled via famrel.

As a consequence, there must not only be methods for OrbitOp with the six arguments corresponding to OrbitishReq, but also methods for only five arguments (i.e., without D). Plenty of examples are contained in the implementation file lib/oprt.gi.

In order to handle a few special cases (currently and ), also the following form of is supported.

OrbitishFO( name, reqs, famrel, attr )

The functions in question depend upon an argument seed, so they cannot be regarded as attributes. However, they are most often called without giving seed, meaning choose any minimal resp. maximal block system. In this case, the result can be stored as the value of the attribute attr that was entered as fourth argument of . This attribute is considered by a call Blocks( G, D, opr ) (i.e., without seed) in the same way as considers OrbitsAttr.

To set this up, the declaration file lib/oprt.gd contains the following lines: And this extraordinary FOA triple works as follows: s4 := Group((1,2,3,4),(1,2));; gap> Blocks( s4, MovedPoints(s4), [1,2] ); [ [ 1, 2, 3, 4 ] ] gap> Tester( BlocksAttr )( s4 ); false gap> Blocks( s4, MovedPoints(s4) ); [ [ 1, 2, 3, 4 ] ] gap> Tester( BlocksAttr )( s4 ); BlocksAttr( s4 ); true [ [ 1, 2, 3, 4 ] ] ]]>

gap-4r6p5/doc/ref/quogphom.xml0000644000175000017500000000510512172557252015044 0ustar billbill Quotient groups by homomorphisms (preliminary) <#Include Label="[1]{quogphom}">

The functions and operations described in this chapter have been added very recently and are still undergoing development. It is conceivable that names of variants of the functionality might change in future versions. If you plan to use these functions in your own code, please contact us.

<#Include Label="IsHomCoset"> <#Include Label="IsHomCosetToPerm"> <#Include Label="IsHomCosetToPermRep"> <#Include Label="IsHomCosetToMatrix"> <#Include Label="IsHomCosetToMatrixRep"> <#Include Label="IsHomCosetToFp"> <#Include Label="IsHomCosetToFpRep"> <#Include Label="IsHomCosetToTuple"> <#Include Label="IsHomCosetToTupleRep"> <#Include Label="IsHomCosetToAdditiveElt"> <#Include Label="IsHomCosetToAdditiveEltRep"> <#Include Label="IsHomCosetToObjectRep">

It also has one property for each kind of source. <#Include Label="IsHomCosetOfPerm"> <#Include Label="IsHomCosetOfMatrix"> <#Include Label="IsHomCosetOfFp"> <#Include Label="IsHomCosetOfTuple"> <#Include Label="IsHomCosetOfAdditiveElt">

Creating hom cosets and quotient groups <#Include Label="HomCoset"> <#Include Label="HomCosetWithImage"> <#Include Label="QuotientGroupHom"> <#Include Label="QuotientGroupByHomomorphism"> <#Include Label="QuotientGroupByImages"> <#Include Label="QuotientGroupByImagesNC">

Operations on hom cosets <#Include Label="Homomorphism">[quogphom]!{for quotient groups by homomorphisms} <#Include Label="SourceElt"> <#Include Label="ImageElt"> <#Include Label="CanonicalElt"> <#Include Label="Source"> <#Include Label="Range"> <#Include Label="ImagesSource">

gap-4r6p5/doc/ref/pcgs.xml0000644000175000017500000006156112172557252014151 0ustar billbill Polycyclic Groups A group G is polycyclic if there exists a subnormal series G = C_1 > C_2 > \ldots > C_n > C_{{n+1}} = \{ 1 \} with cyclic factors. Such a series is called pc series of G.

Every polycyclic group is solvable and every finite solvable group is polycyclic. However, there are infinite solvable groups which are not polycyclic.

In &GAP; there exists a large number of methods for polycyclic groups which are based upon the polycyclic structure of these groups. These methods are usually very efficient, especially for groups which are given by a pc-presentation (see chapter ), and can be applied to many types of groups. Hence &GAP; tries to use them whenever possible, for example, for permutation groups and matrix groups over finite fields that are known to be polycyclic (the only exception is the representation as finitely presented group for which the polycyclic methods cannot be used in general).

At the current state of implementations the &GAP; library contains methods to compute with finite polycyclic groups, while the &GAP; package Polycyclic by Bettina Eick and Werner Nickel allows also computations with infinite polycyclic groups which are given by a pc-presentation.

Polycyclic Generating Systems Let G be a polycyclic group with a pc series as above. A polycyclic generating sequence (pcgs for short) of G is a sequence P := (g_1, \ldots, g_n) of elements of G such that C_i = \langle C_{{i+1}}, g_i \rangle for 1 \leq i \leq n. Note that each polycyclic group has a pcgs, but except for very small groups, a pcgs is not unique.

For each index i the subsequence of elements (g_i, \ldots, g_n) forms a pcgs of the subgroup C_i. In particular, these tails generate the subgroups of the pc series and hence we say that the pc series is determined by P.

Let r_i be the index of C_{{i+1}} in C_i which is either a finite positive number or infinity. Then r_i is the order of g_i C_{{i+1}} and we call the resulting list of indices the relative orders of the pcgs P.

Moreover, with respect to a given pcgs (g_1, \ldots, g_n) each element g of G can be represented in a unique way as a product g = g_1^{{e_1}} \cdot g_2^{{e_2}} \cdots g_n^{{e_n}} with exponents e_i \in \{0, \ldots, r_i-1\}, if r_i is finite, and e_i \in &ZZ; otherwise. Words of this form are called normal words or words in normal form. Then the integer vector [ e_1, \ldots, e_n ] is called the exponent vector of the element g. Furthermore, the smallest index k such that e_k \neq 0 is called the depth of g and e_k is the leading exponent of g.

For many applications we have to assume that each of the relative orders r_i is either a prime or infinity. This is equivalent to saying that there are no trivial factors in the pc series and the finite factors of the pc series are maximal refined. Then we obtain that r_i is the order of g C_{{i+1}} for all elements g in C_i \setminus C_{{i+1}} and we call r_i the relative order of the element g.

Computing a Pcgs Suppose a group G is given; for example, let G be a permutation or matrix group. Then we can ask &GAP; to compute a pcgs of this group. If G is not polycyclic, the result will be fail.

Note that these methods can only be applied if G is not given as finitely presented group. For finitely presented groups one can try to compute a pcgs via the polycyclic quotient methods, see .

Note also that a pcgs behaves like a list. <#Include Label="Pcgs"> <#Include Label="IsPcgs"> <#Include Label="CanEasilyComputePcgs">

Defining a Pcgs Yourself In a number of situations it might be useful to supply a pcgs to a group.

Note that the elementary operations for such a pcgs might be rather inefficient, since &GAP; has to use generic methods in this case. It might be helpful to supply the relative orders of the self-defined pcgs as well by SetRelativeOrder. See also . <#Include Label="PcgsByPcSequence">

Elementary Operations for a Pcgs <#Include Label="RelativeOrders:pcgs"> <#Include Label="IsFiniteOrdersPcgs"> <#Include Label="IsPrimeOrdersPcgs"> <#Include Label="PcSeries"> <#Include Label="GroupOfPcgs"> <#Include Label="OneOfPcgs">
Elementary Operations for a Pcgs and an Element <#Include Label="RelativeOrderOfPcElement"> <#Include Label="ExponentOfPcElement"> <#Include Label="ExponentsOfPcElement"> <#Include Label="DepthOfPcElement"> <#Include Label="LeadingExponentOfPcElement"> <#Include Label="PcElementByExponents"> <#Include Label="LinearCombinationPcgs"> <#Include Label="SiftedPcElement"> <#Include Label="CanonicalPcElement"> <#Include Label="ReducedPcElement"> <#Include Label="CleanedTailPcElement"> <#Include Label="HeadPcElementByNumber">
Exponents of Special Products There are certain products of elements whose exponents are used often within algorithms, and which might be obtained more easily than by computing the product first and to obtain its exponents afterwards. The operations in this section provide a way to obtain such exponent vectors directly.

(The circumstances under which these operations give a speedup depend very much on the pcgs and the representation of elements that is used. So the following operations are not guaranteed to give a speedup in every case, however the default methods are not slower than to compute the exponents of a product and thus these operations should always be used if applicable.)

The second class are exponents of products of the generators which make up the pcgs. If the pcgs used is a family pcgs (see ) then these exponents can be looked up and do not need to be computed. <#Include Label="ExponentsConjugateLayer"> <#Include Label="ExponentsOfRelativePower"> <#Include Label="ExponentsOfConjugate"> <#Include Label="ExponentsOfCommutator">

Subgroups of Polycyclic Groups - Induced Pcgs Let U be a subgroup of G and let P be a pcgs of G as above such that P determines the subnormal series G = C_1 > \ldots > C_{{n+1}} = \{ 1 \}. Then the series of subgroups U \cap C_i is a subnormal series of U with cyclic or trivial factors. Hence, if we choose an element u_{{i_j}} \in (U \cap C_{{i_j}}) \setminus (U \cap C_{{i_j+1}}) whenever this factor is non-trivial, then we obtain a pcgs Q = (u_{{i_1}}, \ldots, u_{{i_m}}) of U. We say that Q is an induced pcgs with respect to P. The pcgs P is the parent pcgs to the induced pcgs Q.

Note that the pcgs Q is induced with respect to P if and only if the matrix of exponent vectors of the elements u_{{i_j}} with respect to P is in upper triangular form. Thus Q is not unique in general.

In particular, the elements of an induced pcgs do not necessarily have leading coefficient 1 relative to the inducing pcgs. The attribute holds the leading coefficients in case they have to be renormed in an algorithm.

Each induced pcgs is a pcgs and hence allows all elementary operations for pcgs. On the other hand each pcgs could be transformed into an induced pcgs for the group defined by the pcgs, but note that an arbitrary pcgs is in general not an induced pcgs for technical reasons.

An induced pcgs is compatible with its parent, see .

In a non-commutative Gauss algorithm is described to compute an induced pcgs of a subgroup U from a generating set of U. For calling this in &GAP;, see to .

To create a subgroup generated by an induced pcgs such that the induced pcgs gets stored automatically, use . <#Include Label="IsInducedPcgs"> <#Include Label="InducedPcgsByPcSequence"> <#Include Label="ParentPcgs"> <#Include Label="InducedPcgs"> <#Include Label="InducedPcgsByGenerators"> <#Include Label="InducedPcgsByPcSequenceAndGenerators"> <#Include Label="LeadCoeffsIGS"> <#Include Label="ExtendedPcgs"> <#Include Label="SubgroupByPcgs">

Subgroups of Polycyclic Groups – Canonical Pcgs The induced pcgs Q of U is called canonical if the matrix of exponent vectors contains normed vectors only and above each leading entry in the matrix there are 0's only. The canonical pcgs of U with respect to P is unique and hence such pcgs can be used to compare subgroups. <#Include Label="IsCanonicalPcgs"> <#Include Label="CanonicalPcgs">
Factor Groups of Polycyclic Groups – Modulo Pcgs Let N be a normal subgroup of G such that G/N is polycyclic with pcgs (h_1 N, \ldots, h_r N). Then we call the sequence of preimages (h_1, \ldots h_r) a modulo pcgs of G/N. G is called the numerator of the modulo pcgs and N is the denominator of the modulo pcgs.

Modulo pcgs are often used to facilitate efficient computations with factor groups, since they allow computations with factor groups without formally defining the factor group at all.

All elementary operations of pcgs, see Sections and , apply to modulo pcgs as well. However, it is in general not possible to compute induced pcgs with respect to a modulo pcgs.

Two more elementary operations for modulo pcgs are and . <#Include Label="ModuloPcgs"> <#Include Label="IsModuloPcgs"> <#Include Label="NumeratorOfModuloPcgs"> <#Include Label="DenominatorOfModuloPcgs"> Modulo Pcgs can also be built from compatible induced pcgs. Let G be a group with pcgs P and let I be an induced pcgs of a normal subgroup N of G. (Respectively: P and I are both induced with respect to the same Pcgs.) Then we can compute a modulo pcgs of G mod N by

P mod I

Note that in this case we obtain the advantage that the values of and are just P and I, respectively, and hence are unique.

The resulting modulo pcgs will consist of a subset of P and will be compatible with P (or its parent).

G := Group((1,2,3,4));; gap> P := Pcgs(G); Pcgs([ (1,2,3,4), (1,3)(2,4) ]) gap> I := InducedPcgsByGenerators(P, [(1,3)(2,4)]); Pcgs([ (1,3)(2,4) ]) gap> M := P mod I; [ (1,2,3,4) ] gap> NumeratorOfModuloPcgs(M); Pcgs([ (1,2,3,4), (1,3)(2,4) ]) gap> DenominatorOfModuloPcgs(M); Pcgs([ (1,3)(2,4) ]) ]]> <#Include Label="CorrespondingGeneratorsByModuloPcgs"> <#Include Label="CanonicalPcgsByGeneratorsWithImages">

Factor Groups of Polycyclic Groups in their Own Representation If substantial calculations are done in a factor it might be worth still to construct the factor group in its own representation (for example by calling on a modulo pcgs.

<#Include Label="[1]{pcgs}"> <#Include Label="ProjectedPcElement"> <#Include Label="ProjectedInducedPcgs"> <#Include Label="LiftedPcElement"> <#Include Label="LiftedInducedPcgs">

Pcgs and Normal Series By definition, a pcgs determines a pc series of its underlying group. However, in many applications it will be necessary that this pc series refines a normal series with certain properties; for example, a normal series with abelian factors.

There are functions in &GAP; to compute a pcgs through a normal series with elementary abelian factors, a central series or the lower p-central series. See also Section for a more explicit possibility. <#Include Label="IsPcgsElementaryAbelianSeries"> <#Include Label="PcgsElementaryAbelianSeries"> <#Include Label="IndicesEANormalSteps"> <#Include Label="EANormalSeriesByPcgs"> <#Include Label="IsPcgsCentralSeries"> <#Include Label="PcgsCentralSeries"> <#Include Label="IndicesCentralNormalSteps"> <#Include Label="CentralNormalSeriesByPcgs"> <#Include Label="IsPcgsPCentralSeriesPGroup"> <#Include Label="PcgsPCentralSeriesPGroup"> <#Include Label="IndicesPCentralNormalStepsPGroup"> <#Include Label="PCentralNormalSeriesByPcgsPGroup"> <#Include Label="IsPcgsChiefSeries"> <#Include Label="PcgsChiefSeries"> <#Include Label="IndicesChiefNormalSteps"> <#Include Label="ChiefNormalSeriesByPcgs"> <#Include Label="IndicesNormalSteps"> <#Include Label="NormalSeriesByPcgs">

Sum and Intersection of Pcgs <#Include Label="SumFactorizationFunctionPcgs">
Special Pcgs In short, a special pcgs is a pcgs which has particularly nice properties, for example it always refines an elementary abelian series, for p-groups it even refines a central series. These nice properties permit particularly efficient algorithms.

Let G be a finite polycyclic group. A special pcgs of G is a pcgs which is closely related to a Hall system and the maximal subgroups of G. These pcgs have been introduced by C. R. Leedham-Green who also gave an algorithm to compute them. Improvements to this algorithm are due to Bettina Eick. For a more detailed account of their definition the reader is referred to

To introduce the definition of special pcgs we first need to define the LG-series and head complements of a finite polycyclic group G. Let G = G_1 > G_2 > \ldots G_m > G_{{m+1}} = \{ 1 \} be the lower nilpotent series of G; that is, G_i is the smallest normal subgroup of G_{{i-1}} with nilpotent factor. To obtain the LG-series of G we need to refine this series. Thus consider a factor F_i := G_i / G_{{i+1}}. Since F_i is finite nilpotent, it is a direct product of its Sylow subgroups, say F_i = P_{{i,1}} \cdots P_{{i,r_i}}. For each Sylow p_j-subgroup P_{{i,j}} we can consider its lower p_j-central series. To obtain a characteristic central series with elementary abelian factors of F_i we loop over its Sylow subgroups. Each time we consider P_{{i,j}} in this process we take the next step of its lower p_j-central series into the series of F_i. If there is no next step, then we just skip the consideration of P_{{i,j}}. Note that the second term of the lower p-central series of a p-group is in fact its Frattini subgroup. Thus the Frattini subgroup of F_i is contained in the computed series of this group. We denote the Frattini subgroup of F_i = G_i / G_{{i+1}} by G_i^* / G_{{i+1}}.

The factors G_i / G_i^* are called the heads of G, while the (possibly trivial) factors G_i^* / G_{{i+1}} are the tails of G. A head complement of G is a subgroup U of G such that U / G_i^* is a complement to the head G_i / G_i^* in G / G_i^* for some i.

Now we are able to define a special pcgs of G. It is a pcgs of G with three additional properties. First, the pc series determined by the pcgs refines the LG-series of G. Second, a special pcgs exhibits a Hall system of the group G; that is, for each set of primes \pi the elements of the pcgs with relative order in \pi form a pcgs of a Hall \pi-subgroup in a Hall system of G. Third, a special pcgs exhibits a head complement for each head of G.

To record information about the LG-series with the special pcgs we define the LGWeights of the special pcgs. These weights are a list which contains a weight w for each elements g of the special pcgs. Such a weight w represents the smallest subgroup of the LG-series containing g.

Since the LG-series is defined in terms of the lower nilpotent series, Sylow subgroups of the factors and lower p-central series of the Sylow subgroup, the weight w is a triple. More precisely, g is contained in the w[1]th term U of the lower nilpotent series of G, but not in the next smaller one V. Then w[3] is a prime such that g V is contained in the Sylow w[3]-subgroup P/V of U/V. Moreover, gV is contained in the w[2]th term of the lower p-central series of P/V.

There are two more attributes of a special pcgs containing information about the LG-series: the list LGLayers and the list LGFirst. The list of layers corresponds to the elements of the special pcgs and denotes the layer of the LG-series in which an element lies. The list LGFirst corresponds to the LG-series and gives the number of the first element in the special pcgs of the corresponding subgroup. <#Include Label="IsSpecialPcgs"> <#Include Label="SpecialPcgs"> <#Include Label="LGWeights"> <#Include Label="LGLayers"> <#Include Label="LGFirst"> <#Include Label="LGLength"> <#Include Label="IsInducedPcgsWrtSpecialPcgs"> <#Include Label="InducedPcgsWrtSpecialPcgs">

Action on Subfactors Defined by a Pcgs When working with a polycyclic group, one often needs to compute matrix operations of the group on a factor of the group. For this purpose there are the functions described in to .

In certain situations, for example within the computation of conjugacy classes of finite soluble groups as described in , affine actions of groups are required. For this purpose we introduce the functions and . <#Include Label="VectorSpaceByPcgsOfElementaryAbelianGroup"> <#Include Label="LinearAction"> <#Include Label="LinearActionLayer"> <#Include Label="AffineAction"> <#Include Label="AffineActionLayer">

Orbit Stabilizer Methods for Polycyclic Groups If a pcgs pcgs is known for a group G, then orbits and stabilizers can be computed by a special method which is particularly efficient. Note that within this function only the elements in pcgs and the relative orders of pcgs are needed. Hence this function works effectively even if the elementary operations for pcgs are slow. <#Include Label="StabilizerPcgs"> <#Include Label="Pcgs_OrbitStabilizer:pcgs">
Operations which have Special Methods for Groups with Pcgs IsNilpotent IsSupersolvable Size CompositionSeries ConjugacyClasses Centralizer FrattiniSubgroup PrefrattiniSubgroup MaximalSubgroups HallSystem MinimalGeneratingSet Centre Intersection AutomorphismGroup IrreducibleModules For the following operations there are special methods for groups with pcgs installed:

, , , , , , , , and related operations, and related operations, , , , , .

Conjugacy Classes in Solvable Groups There are a variety of algorithms to compute conjugacy classes and centralizers in solvable groups via epimorphic images (, , ). Usually these are only invoked as methods, but it is possible to access the algorithm directly.

<#Include Label="ClassesSolvableGroup"> <#Include Label="CentralizerSizeLimitConsiderFunction">

gap-4r6p5/doc/ref/unknown.xml0000644000175000017500000000172712172557252014712 0ustar billbill Unknowns data type <#Include Label="[1]{unknown}">
More about Unknowns <#Include Label="Unknown"> <#Include Label="LargestUnknown"> <#Include Label="IsUnknown"> <#Include Label="[2]{unknown}"> <#Include Label="[3]{unknown}">
gap-4r6p5/doc/ref/magma.xml0000644000175000017500000001111012172557252014260 0ustar billbill Magmas This chapter deals with domains (see ) that are closed under multiplication *. Following , we call them magmas in &GAP;. Together with the domains closed under addition + (see ), they are the basic algebraic structures; every semigroup (see ), monoid (see ), group (see ), ring (see ), or field (see ) is a magma. In the cases of a magma-with-one or magma-with-inverses, additional multiplicative structure is present, see . For functions to create free magmas, see .
Magma Categories <#Include Label="IsMagma"> <#Include Label="IsMagmaWithOne"> <#Include Label="IsMagmaWithInversesIfNonzero"> <#Include Label="IsMagmaWithInverses">
Magma Generation This section describes functions that create magmas from generators (see , , ), the underlying operations for which methods can be installed (see , , ), functions for forming submagmas (see , , ), and functions that form a magma equal to a given collection (see , ).

creates a new magma which is the original magma with a zero adjoined. <#Include Label="Magma"> <#Include Label="MagmaWithOne"> <#Include Label="MagmaWithInverses"> <#Include Label="MagmaByGenerators"> <#Include Label="MagmaWithOneByGenerators"> <#Include Label="MagmaWithInversesByGenerators"> <#Include Label="Submagma"> <#Include Label="SubmagmaWithOne"> <#Include Label="SubmagmaWithInverses"> <#Include Label="AsMagma"> <#Include Label="AsSubmagma"> <#Include Label="InjectionZeroMagma">

Magmas Defined by Multiplication Tables The most elementary (but of course usually not recommended) way to implement a magma with only few elements is via a multiplication table. <#Include Label="MagmaByMultiplicationTable"> <#Include Label="MagmaWithOneByMultiplicationTable"> <#Include Label="MagmaWithInversesByMultiplicationTable"> <#Include Label="MagmaElement"> <#Include Label="MultiplicationTable">
Attributes and Properties for Magmas Note that and always refer to the multiplication of a domain. If a magma M has also an additive structure, e.g., if M is a ring (see ), then the addition + is always assumed to be associative and commutative, see . <#Include Label="GeneratorsOfMagma"> <#Include Label="GeneratorsOfMagmaWithOne"> <#Include Label="GeneratorsOfMagmaWithInverses"> <#Include Label="Centralizer"> <#Include Label="Centre"> <#Include Label="Idempotents"> <#Include Label="IsAssociative"> <#Include Label="IsCentral"> <#Include Label="IsCommutative"> <#Include Label="MultiplicativeNeutralElement"> <#Include Label="MultiplicativeZero"> <#Include Label="IsMultiplicativeZero"> <#Include Label="SquareRoots"> <#Include Label="TrivialSubmagmaWithOne">
gap-4r6p5/doc/ref/matrix.xml0000644000175000017500000005641412172557252014522 0ustar billbill Matrices Matrices are represented in &GAP; by lists of row vectors (see ) (for future changes to this policy see Chapter ). The vectors must all have the same length, and their elements must lie in a common ring. However, since checking rectangularness can be expensive functions and methods of operations for matrices often will not give an error message for non-rectangular lists of lists –in such cases the result is undefined.

Because matrices are just a special case of lists, all operations and functions for lists are applicable to matrices also (see chapter ). This especially includes accessing elements of a matrix (see ), changing elements of a matrix (see ), and comparing matrices (see ).

Note that, since a matrix is a list of lists, the behaviour of for matrices is just a special case of for lists (see ); called with an immutable matrix mat, returns a mutable matrix whose rows are identical to the rows of mat. In particular the rows are still immutable. To get a matrix whose rows are mutable, one can use List( mat, ShallowCopy ).

InfoMatrix (Info Class) <#Include Label="InfoMatrix">
Categories of Matrices <#Include Label="IsMatrix"> <#Include Label="IsOrdinaryMatrix"> <#Include Label="IsLieMatrix">
Operators for Matrices The rules for arithmetic operations involving matrices are in fact special cases of those for the arithmetic of lists, given in Section  and the following sections, here we reiterate that definition, in the language of vectors and matrices.

Note that the additive behaviour sketched below is defined only for lists in the category , and the multiplicative behaviour is defined only for lists in the category (see ).

addition mat1 + mat2

returns the sum of the two matrices mat1 and mat2, Probably the most usual situation is that mat1 and mat2 have the same dimensions and are defined over a common field; in this case the sum is a new matrix over the same field where each entry is the sum of the corresponding entries of the matrices.

In more general situations, the sum of two matrices need not be a matrix, for example adding an integer matrix mat1 and a matrix mat2 over a finite field yields the table of pointwise sums, which will be a mixture of finite field elements and integers if mat1 has bigger dimensions than mat2.

addition scalar + mat

addition mat + scalar

returns the sum of the scalar scalar and the matrix mat. Probably the most usual situation is that the entries of mat lie in a common field with scalar; in this case the sum is a new matrix over the same field where each entry is the sum of the scalar and the corresponding entry of the matrix.

More general situations are for example the sum of an integer scalar and a matrix over a finite field, or the sum of a finite field element and an integer matrix.

subtraction mat1 - mat2

subtraction scalar - mat

subtraction mat - scalar

Subtracting a matrix or scalar is defined as adding its additive inverse, so the statements for the addition hold likewise.

multiplication scalar * mat

multiplication mat * scalar

returns the product of the scalar scalar and the matrix mat. Probably the most usual situation is that the elements of mat lie in a common field with scalar; in this case the product is a new matrix over the same field where each entry is the product of the scalar and the corresponding entry of the matrix.

More general situations are for example the product of an integer scalar and a matrix over a finite field, or the product of a finite field element and an integer matrix.

multiplication vec * mat

returns the product of the row vector vec and the matrix mat. Probably the most usual situation is that vec and mat have the same lengths and are defined over a common field, and that all rows of mat have the same length m, say; in this case the product is a new row vector of length m over the same field which is the sum of the scalar multiples of the rows of mat with the corresponding entries of vec.

More general situations are for example the product of an integer vector and a matrix over a finite field, or the product of a vector over a finite field and an integer matrix.

multiplication mat * vec

returns the product of the matrix mat and the row vector vec. (This is the standard product of a matrix with a column vector.) Probably the most usual situation is that the length of vec and of all rows of mat are equal, and that the elements of mat and vec lie in a common field; in this case the product is a new row vector of the same length as mat and over the same field which is the sum of the scalar multiples of the columns of mat with the corresponding entries of vec.

More general situations are for example the product of an integer matrix and a vector over a finite field, or the product of a matrix over a finite field and an integer vector.

multiplication mat1 * mat2

This form evaluates to the (Cauchy) product of the two matrices mat1 and mat2. Probably the most usual situation is that the number of columns of mat1 equals the number of rows of mat2, and that the elements of mat and vec lie in a common field; if mat1 is a matrix with m rows and n columns, say, and mat2 is a matrix with n rows and o columns, the result is a new matrix with m rows and o columns. The element in row i at position j of the product is the sum of mat1[i][l] * mat2[l][j], with l running from 1 to n.

inverse Inverse( mat )

returns the inverse of the matrix mat, which must be an invertible square matrix. If mat is not invertible then fail is returned.

quotient mat1 / mat2

quotient scalar / mat

quotient mat / scalar

quotient vec / mat

In general, left / right is defined as left * right^-1. Thus in the above forms the right operand must always be invertible.

power mat ^ int

conjugate mat1 ^ mat2

image vec ^ mat

Powering a square matrix mat by an integer int yields the int-th power of mat; if int is negative then mat must be invertible, if int is 0 then the result is the identity matrix One( mat ), even if mat is not invertible.

Powering a square matrix mat1 by an invertible square matrix mat2 of the same dimensions yields the conjugate of mat1 by mat2, i.e., the matrix mat2^-1 * mat1 * mat2.

Powering a row vector vec by a matrix mat is in every respect equivalent to vec * mat. This operations reflects the fact that matrices act naturally on row vectors by multiplication from the right, and that the powering operator is &GAP;'s standard for group actions.

matrices Comm( mat1, mat2 )

returns the commutator of the square invertible matrices mat1 and mat2 of the same dimensions and over a common field, which is the matrix mat1^-1 * mat2^-1 * mat1 * mat2.

The following cases are still special cases of the general list arithmetic defined in .

addition scalar + matlist

addition matlist + scalar

subtraction scalar - matlist

subtraction matlist - scalar

multiplication scalar * matlist

multiplication matlist * scalar

quotient matlist / scalar

A scalar scalar may also be added, subtracted, multiplied with, or divided into a list matlist of matrices. The result is a new list of matrices where each matrix is the result of performing the operation with the corresponding matrix in matlist.

multiplication mat * matlist

multiplication matlist * mat

A matrix mat may also be multiplied with a list matlist of matrices. The result is a new list of matrices, where each entry is the product of mat and the corresponding entry in matlist.

quotient matlist / mat

Dividing a list matlist of matrices by an invertible matrix mat evaluates to matlist * mat^-1.

multiplication vec * matlist

returns the product of the vector vec and the list of matrices mat. The lengths l of vec and matlist must be equal. All matrices in matlist must have the same dimensions. The elements of vec and the elements of the matrices in matlist must lie in a common ring. The product is the sum over vec[i] * matlist[i] with i running from 1 to l.

For the mutability of results of arithmetic operations, see .

Properties and Attributes of Matrices <#Include Label="DimensionsMat"> <#Include Label="DefaultFieldOfMatrix"> <#Include Label="TraceMat"> <#Include Label="DeterminantMat"> <#Include Label="DeterminantMatDestructive"> <#Include Label="DeterminantMatDivFree"> <#Include Label="IsMonomialMatrix"> <#Include Label="IsDiagonalMat"> <#Include Label="IsUpperTriangularMat"> <#Include Label="IsLowerTriangularMat">
Matrix Constructions <#Include Label="IdentityMat"> <#Include Label="NullMat"> <#Include Label="EmptyMatrix"> <#Include Label="DiagonalMat"> <#Include Label="PermutationMat"> <#Include Label="TransposedMatImmutable"> <#Include Label="TransposedMatDestructive"> <#Include Label="KroneckerProduct"> <#Include Label="ReflectionMat"> <#Include Label="PrintArray">
Random Matrices <#Include Label="RandomMat"> <#Include Label="RandomInvertibleMat"> <#Include Label="RandomUnimodularMat">
Matrices Representing Linear Equations and the Gaussian Algorithm Gaussian algorithm <#Include Label="RankMat"> <#Include Label="TriangulizedMat"> <#Include Label="TriangulizeMat"> <#Include Label="NullspaceMat"> <#Include Label="NullspaceMatDestructive"> <#Include Label="SolutionMat"> <#Include Label="SolutionMatDestructive"> <#Include Label="BaseFixedSpace">
Eigenvectors and eigenvalues <#Include Label="GeneralisedEigenvalues"> <#Include Label="GeneralisedEigenspaces"> <#Include Label="Eigenvalues"> <#Include Label="Eigenspaces"> <#Include Label="Eigenvectors">
Elementary Divisors See also chapter . <#Include Label="ElementaryDivisorsMat"> <#Include Label="ElementaryDivisorsTransformationsMat"> <#Include Label="DiagonalizeMat">
Echelonized Matrices <#Include Label="SemiEchelonMat"> <#Include Label="SemiEchelonMatDestructive"> <#Include Label="SemiEchelonMatTransformation"> <#Include Label="SemiEchelonMats"> <#Include Label="SemiEchelonMatsDestructive">
Matrices as Basis of a Row Space See also chapter <#Include Label="BaseMat"> <#Include Label="BaseMatDestructive"> <#Include Label="BaseOrthogonalSpaceMat"> <#Include Label="SumIntersectionMat"> <#Include Label="BaseSteinitzVectors">
Triangular Matrices <#Include Label="DiagonalOfMat"> <#Include Label="UpperSubdiagonal"> <#Include Label="DepthOfUpperTriangularMatrix">
Matrices as Linear Mappings <#Include Label="CharacteristicPolynomial"> <#Include Label="JordanDecomposition"> <#Include Label="BlownUpMat"> <#Include Label="BlownUpVector"> <#Include Label="CompanionMat">
Matrices over Finite Fields Just as for row vectors, (see section ), &GAP; has a special representation for matrices over small finite fields.

To be eligible to be represented in this way, each row of a matrix must be able to be represented as a compact row vector of the same length over the same finite field.

v := Z(2)*[1,0,0,1,1]; [ Z(2)^0, 0*Z(2), 0*Z(2), Z(2)^0, Z(2)^0 ] gap> ConvertToVectorRep(v,2); 2 gap> v; gap> m := [v];; ConvertToMatrixRep(m,GF(2));; m; gap> m := [v,v];; ConvertToMatrixRep(m,GF(2));; m; gap> m := [v,v,v];; ConvertToMatrixRep(m,GF(2));; m; gap> v := Z(3)*[1..8]; [ Z(3), Z(3)^0, 0*Z(3), Z(3), Z(3)^0, 0*Z(3), Z(3), Z(3)^0 ] gap> ConvertToVectorRep(v); 3 gap> m := [v];; ConvertToMatrixRep(m,GF(3));; m; [ [ Z(3), Z(3)^0, 0*Z(3), Z(3), Z(3)^0, 0*Z(3), Z(3), Z(3)^0 ] ] gap> RepresentationsOfObject(m); [ "IsPositionalObjectRep", "Is8BitMatrixRep" ] gap> m := [v,v,v,v];; ConvertToMatrixRep(m,GF(3));; m; < mutable compressed matrix 4x8 over GF(3) > ]]>

All compressed matrices over GF(2) are viewed as <a nxm matrix over GF2>, while over fields GF(q) for q between 3 and 256, matrices with 25 or more entries are viewed in this way, and smaller ones as lists of lists.

Matrices can be converted to this special representation via the following functions.

Note that the main advantage of this special representation of matrices is in low dimensions, where various overheads can be reduced. In higher dimensions, a list of compressed vectors will be almost as fast. Note also that list access and assignment will be somewhat slower for compressed matrices than for plain lists.

In order to form a row of a compressed matrix a vector must accept certain restrictions. Specifically, it cannot change its length or change the field over which it is compressed. The main consequences of this are: that only elements of the appropriate field can be assigned to entries of the vector, and only to positions between 1 and the original length; that the vector cannot be shared between two matrices compressed over different fields.

This is enforced by the filter IsLockedRepresentationVector. When a vector becomes part of a compressed matrix, this filter is set for it. Assignment, , and are all prevented from altering a vector with this filter.

v := [Z(2),Z(2)];; ConvertToVectorRep(v,GF(2));; v; gap> m := [v,v]; [ , ] gap> ConvertToMatrixRep(m,GF(2)); 2 gap> m2 := [m[1], [Z(4),Z(4)]]; # now try and mix in some GF(4) [ , [ Z(2^2), Z(2^2) ] ] gap> ConvertToMatrixRep(m2); # but m2[1] is locked #I ConvertToVectorRep: locked vector not converted to different field fail gap> m2 := [ShallowCopy(m[1]), [Z(4),Z(4)]]; # a fresh copy of row 1 [ , [ Z(2^2), Z(2^2) ] ] gap> ConvertToMatrixRep(m2); # now it works 4 gap> m2; [ [ Z(2)^0, Z(2)^0 ], [ Z(2^2), Z(2^2) ] ] gap> RepresentationsOfObject(m2); [ "IsPositionalObjectRep", "Is8BitMatrixRep" ] ]]>

Arithmetic operations (see  and the following sections) preserve the compression status of matrices in the sense that if all arguments are compressed matrices written over the same field and the result is a matrix then also the result is a compressed matrix written over this field.

There are also two operations that are only available for matrices written over finite fields. <#Include Label="ImmutableMatrix"> <#Include Label="ConvertToMatrixRep"> <#Include Label="ProjectiveOrder"> <#Include Label="SimultaneousEigenvalues">

Inverse and Nullspace of an Integer Matrix Modulo an Ideal The following two operations deal with matrices over a ring, but only care about the residues of their entries modulo some ring element. In the case of the integers and a prime number p, say, this is effectively computation in a matrix over the prime field in characteristic p. <#Include Label="InverseMatMod"> <#Include Label="NullspaceModQ">
Special Multiplication Algorithms for Matrices over GF(2) When multiplying two compressed matrices M and N over GF(2) of dimensions a \times b and b \times c, say, where a, b and c are all greater than or equal to 128, &GAP; by default uses a more sophisticated matrix multiplication algorithm, in which linear combinations of groups of 8 rows of M are remembered and re-used in constructing various rows of the product. This is called level 8 grease. To optimise memory access patterns, these combinations are stored for (b+255)/256 sets of 8 rows at once. This number is called the blocking level.

These levels of grease and blocking are found experimentally to give good performance across a range of processors and matrix sizes, but other levels may do even better in some cases. You can control the levels exactly using the functions below.

We plan to include greased blocked matrix multiplication for other finite fields, and greased blocked algorithms for inversion and other matrix operations in a future release.

This function performs the standard unblocked and ungreased matrix multiplication for matrices of any size.

This function computes the product of m1 and m2, which must be compressed matrices over GF(2) of compatible dimensions, using level g grease and level b blocking.

Block Matrices <#Include Label="[1]{matblock}"> <#Include Label="AsBlockMatrix"> <#Include Label="BlockMatrix"> <#Include Label="MatrixByBlockMatrix">
gap-4r6p5/doc/ref/grppc.xml0000644000175000017500000005074712172557252014334 0ustar billbill Pc Groups Pc groups are polycyclic groups that use the polycyclic presentation for element arithmetic. This presentation gives them a natural pcgs, the with respect to which pcgs operations as described in chapter  are particularly efficient.

Let G be a polycyclic group with pcgs P = (g_1, \ldots, g_n) and corresponding relative orders (r_1, \ldots, r_n). Recall that the r_i are positive integers or infinity and let I be the set of indices i with r_i a positive integer. Then G has a finite presentation on the generators g_1, \ldots, g_n with relations of the following form. g_i^{{r_i}} = g_{{i+1}}^{a(i,i,i+1)} \cdots g_n^{a(i,i,n)} for 1 \leq i \leq n and i \in I g_i^{{-1}} g_j g_i = g_{{i+1}}^{a(i,j,i+1)} \cdots g_n^{a(i,j,n)} for 1 \leq i < j \leq n
For infinite groups we need additionally g_i^{{-1}} g_j^{{-1}} g_i = g_{{i+1}}^{b(i,j,i+1)} \cdots g_n^{b(i,j,n)} for 1 \leq i < j \leq n and j \not \in I g_i g_j g_i^{{-1}} = g_{{i+1}}^{c(i,j,i+1)} \cdots g_n^{c(i,j,n)} for 1 \leq i < j \leq n and i \not \in I g_i g_j^{{-1}} g_i^{{-1}} = g_{{i+1}}^{d(i,j,i+1)} \cdots g_n^{d(i,j,n)} for 1 \leq i < j \leq n and i, j, \not \in I
Here the right hand sides are assumed to be words in normal form; that is, for k \in I we have for all exponents 0 \leq a(i,j,k), b(i,j,k), c(i,j,k), d(i,j,k) < r_k.

A finite presentation of this type is called a power-conjugate presentation and a pc group is a polycyclic group defined by a power-conjugate presentation. Instead of conjugates we could just as well work with commutators and then the presentation would be called a power-commutator presentation. Both types of presentation are abbreviated as pc presentation. Note that a pc presentation is a rewriting system.

Clearly, whenever a group G with pcgs P is given, then we can write down the corresponding pc presentation. On the other hand, one may just write down a presentation on n abstract generators g_1, \ldots, g_n with relations of the above form and define a group H by this. Then the subgroups C_i = \langle g_i, \ldots, g_n \rangle of H form a subnormal series whose factors are cyclic or trivial. In the case that all factors are non-trivial, we say that the pc presentation of H is confluent. Note that &GAP; 4 can only work correctly with pc groups defined by a confluent pc presentation.

At the current state of implementations the &GAP; library contains methods to compute with finite polycyclic groups, while the &GAP; package Polycyclic by Bettina Eick and Werner Nickel allows also computations with infinite polycyclic groups which are given by a pc-presentation.

Algorithms for pc groups use the methods for polycyclic groups described in chapter .

The family pcgs Clearly, the generators of a power-conjugate presentation of a pc group G form a pcgs of the pc group. This pcgs is called the family pcgs. <#Include Label="FamilyPcgs"> <#Include Label="IsFamilyPcgs"> <#Include Label="InducedPcgsWrtFamilyPcgs"> <#Include Label="IsParentPcgsFamilyPcgs">
Elements of pc groups Comparison of elements of pc groups equality smaller The elements of a pc group G are always represented as words in normal form with respect to the family pcgs of G. Thus it is straightforward to compare elements of a pc group, since this boils down to a mere comparison of exponent vectors with respect to the family pcgs. In particular, the word problem is efficiently solvable in pc groups. Arithmetic operations for elements of pc groups However, multiplication and inversion of elements in pc groups is not as straightforward as in arbitrary finitely presented groups where a simple concatenation or reversion of the corresponding words is sufficient (but one cannot solve the word problem).

To multiply two elements in a pc group, we first concatenate the corresponding words and then use an algorithm called collection to transform the new word into a word in normal form.

g := FamilyPcgs( SmallGroup( 24, 12 ) ); Pcgs([ f1, f2, f3, f4 ]) gap> g[4] * g[1]; f1*f3 gap> (g[2] * g[3])^-1; f2^2*f3*f4 ]]>

Pc groups versus fp groups In theory pc groups are finitely presented groups. In practice the arithmetic in pc groups is different from the arithmetic in fp groups. Thus for technical reasons the pc groups in &GAP; do not form a subcategory of the fp groups and hence the methods for fp groups cannot be applied to pc groups in general. <#Include Label="IsPcGroup"> It is possible to convert a pc group to a fp group in &GAP;. The function computes the power-commutator presentation defined by pcgs. The string str can be used to give a name to the generators of the fp group.

p := FamilyPcgs( SmallGroup( 24, 12 ) ); Pcgs([ f1, f2, f3, f4 ]) gap> iso := IsomorphismFpGroupByPcgs( p, "g" ); [ f1, f2, f3, f4 ] -> [ g1, g2, g3, g4 ] gap> F := Image( iso ); gap> RelatorsOfFpGroup( F ); [ g1^2, g2^-1*g1^-1*g2*g1*g2^-1, g3^-1*g1^-1*g3*g1*g4^-1*g3^-1, g4^-1*g1^-1*g4*g1*g4^-1*g3^-1, g2^3, g3^-1*g2^-1*g3*g2*g4^-1*g3^-1, g4^-1*g2^-1*g4*g2*g3^-1, g3^2, g4^-1*g3^-1*g4*g3, g4^2 ] ]]>

Constructing Pc Groups If necessary, you can supply &GAP; with a pc presentation by hand. (Although this is the most tedious way to input a pc group.) Note that the pc presentation has to be confluent in order to work with the pc group in &GAP;.

(If you have already a suitable pcgs in another representation, use , see below.)

One way is to define a finitely presented group with a pc presentation in &GAP; and then convert this presentation into a pc group, see . Note that this does not work for arbitrary presentations of polycyclic groups, see Chapter for further information.

Another way is to create and manipulate a collector of a pc group by hand and to use it to define a pc group. &GAP; provides different collectors for different collecting strategies; at the moment, there are two collectors to choose from: the single collector for finite pc groups (see ) and the combinatorial collector for finite p-groups. See for further information on collecting strategies.

A collector is initialized with an underlying free group and the relative orders of the pc series. Then one adds the right hand sides of the power and the commutator or conjugate relations one by one. Note that omitted relators are assumed to be trivial.

For performance reasons it is beneficial to enforce a syllable representation in the free group (see ).

Note that in the end, the collector has to be converted to a group, see .

With these methods a pc group with arbitrary defining pcgs can be constructed. However, for almost all applications within &GAP; we need to have a pc group whose defining pcgs is a prime order pcgs, see and . <#Include Label="PcGroupFpGroup"> initializes a single collector or a combinatorial collector, where fgrp must be a free group and relorders must be a list of the relative orders of the pc series.

A combinatorial collector can only be set up for a finite p-group. Here, the relative orders relorders must all be equal and a prime. Let f_1, \ldots, f_n be the generators of the underlying free group of the collector coll.

For i < j, sets the conjugate f_j^{{f_i}} to equal w, which is assumed to be a word in f_{{i+1}}, \ldots, f_n. Let f_1, \ldots, f_n be the generators of the underlying free group of the collector coll.

For i < j, sets the commutator of f_j and f_i to equal w, which is assumed to be a word in f_{{i+1}}, \ldots, f_n. Let f_1, \ldots, f_n be the generators of the underlying free group of the collector coll, and let r_i be the corresponding relative orders.

sets the power f_i^{{r_i}} to equal w, which is assumed to be a word in f_{{i+1}}, \ldots, f_n. creates a group from a rewriting system. In the first version it is checked whether the rewriting system is confluent, in the second version this is assumed to be true. checks whether the pc group G has been built from a collector with a confluent power-commutator presentation.

F := FreeGroup(IsSyllableWordsFamily, 2 );; gap> coll1 := SingleCollector( F, [2,3] ); <> gap> SetConjugate( coll1, 2, 1, F.2 ); gap> SetPower( coll1, 1, F.2 ); gap> G1 := GroupByRws( coll1 ); gap> IsConfluent(G1); true gap> IsAbelian(G1); true gap> coll2 := SingleCollector( F, [2,3] ); <> gap> SetConjugate( coll2, 2, 1, F.2^2 ); gap> G2 := GroupByRws( coll2 ); gap> IsAbelian(G2); false ]]> <#Include Label="IsomorphismRefinedPcGroup"> <#Include Label="RefinedPcGroup">

Computing Pc Groups Another possibility to get a pc group in &GAP; is to convert a polycyclic group given by some other representation to a pc group. For finitely presented groups there are various quotient methods available. For all other types of groups one can use the following functions. <#Include Label="PcGroupWithPcgs"> <#Include Label="IsomorphismPcGroup"> <#Include Label="IsomorphismSpecialPcGroup">
Saving a Pc Group As printing a polycyclic group does not display the presentation, one cannot simply print a pc group to a file to save it. For this purpose we need the following function. <#Include Label="GapInputPcGroup">
Operations for Pc Groups All the operations described in Chapters and apply to a pc group. Nearly all methods for pc groups are methods for groups with pcgs as described in Chapter . The only method with is special for pc groups is a method to compute intersections of subgroups, since here a pcgs of a parent group is needed and this can only by guaranteed within pc groups.
2-Cohomology and Extensions One of the most interesting applications of pc groups is the possibility to compute with extensions of these groups by elementary abelian groups; that is, H is an extension of G by M, if there exists a normal subgroup N in H which is isomorphic to M such that H/N is isomorphic to G.

Pc groups are particularly suited for such applications, since the 2-cohomology can be computed efficiently for such groups and, moreover, extensions of pc groups by elementary abelian groups can be represented as pc groups again.

To define the elementary abelian group M together with an action of G on M we consider M as a MeatAxe module for G over a finite field (section  describes functions that can be used to obtain certain modules). For further information on meataxe modules see Chapter . Note that the matrices defining the module must correspond to the pcgs of the group G.

There exists an action of the subgroup of compatible pairs in Aut(G) \times Aut(M) which acts on the second cohomology group, see . 2-cocycles which lie in the same orbit under this action define isomorphic extensions of G. However, there may be isomorphic extensions of G corresponding to cocycles in different orbits.

See also the &GAP; package GrpConst by Hans Ulrich Besche and Bettina Eick that contains methods to construct up to isomorphism the groups of a given order.

Finally we note that for the computation of split extensions it is not necessary that M must correspond to an elementary abelian group. Here it is possible to construct split extensions of arbitrary pc groups, see . <#Include Label="TwoCoboundaries"> <#Include Label="TwoCocycles"> <#Include Label="TwoCohomology"> <#Include Label="Extensions"> <#Include Label="Extension"> returns the split extension of G by the G-module M. returns the module of an extension E of G by M. This is the normal subgroup of E which corresponds to M.

G := SmallGroup( 4, 2 );; gap> mats := List( Pcgs( G ), x -> IdentityMat( 1, GF(2) ) );; gap> M := GModuleByMats( mats, GF(2) );; gap> co := TwoCocycles( G, M );; gap> Extension( G, M, co[2] ); gap> SplitExtension( G, M ); gap> Extensions( G, M ); [ , , , , , , , ] gap> List(last, IdSmallGroup); [ [ 8, 5 ], [ 8, 2 ], [ 8, 3 ], [ 8, 3 ], [ 8, 2 ], [ 8, 2 ], [ 8, 3 ], [ 8, 4 ] ] ]]>

Note that the extensions returned by are computed up to equivalence, but not up to isomorphism. <#Include Label="CompatiblePairs"> <#Include Label="ExtensionRepresentatives"> returns the split extensions of the pc group G by the pc group N. aut should be a homomorphism from G into Aut(N).

In the following example we construct the holomorph of Q_8 as split extension of Q_8 by S_4.

N := SmallGroup( 8, 4 ); gap> IsAbelian( N ); false gap> A := AutomorphismGroup( N ); gap> iso := IsomorphismPcGroup( A ); CompositionMapping( Pcgs([ (2,6,5,3), (1,3,5)(2,4,6), (2,5)(3,6), (1,4)(3,6) ]) -> [ f1, f2, f3, f4 ], ) gap> H := Image( iso ); Group([ f1, f2, f3, f4 ]) gap> G := Subgroup( H, Pcgs(H){[1,2]} ); Group([ f1, f2 ]) gap> inv := InverseGeneralMapping( iso ); [ f1*f2, f2^2*f3, f4, f3 ] -> [ Pcgs([ f1, f2, f3 ]) -> [ f1*f2, f2, f3 ], Pcgs([ f1, f2, f3 ]) -> [ f2, f1*f2, f3 ], Pcgs([ f1, f2, f3 ]) -> [ f1*f3, f2, f3 ], Pcgs([ f1, f2, f3 ]) -> [ f1, f2*f3, f3 ] ] gap> K := SplitExtension( G, inv, N ); ]]>

Coding a Pc Presentation If one wants to store a large number of pc groups, then it can be useful to store them in a compressed format, since pc presentations can be space consuming. Here we introduce a method to code and decode pc presentations by integers. To decode a given code the size of the underlying pc group is needed as well. For the full definition and the coding and decoding procedures see . This method is used with the small groups library, see Section . <#Include Label="CodePcgs"> <#Include Label="CodePcGroup"> <#Include Label="PcGroupCode">
Random Isomorphism Testing The generic isomorphism test for groups may be applied to pc groups as well. However, this test is often quite time consuming. Here we describe another method to test isomorphism by a probabilistic approach. <#Include Label="RandomIsomorphismTest">
gap-4r6p5/doc/ref/overview.xml0000644000175000017500000001627512172557252015065 0ustar billbill &GAP; is a free, open and extensible software package for computation in discrete abstract algebra. The terms free and open describe the conditions under which the system is distributed -- in brief, it is free of charge (except possibly for the immediate costs of delivering it to you), you are free to pass it on within certain limits, and all of the workings of the system are open for you to examine and change. Details of these conditions can be found in Section .

The system is extensible in that you can write your own programs in the &GAP; language, and use them in just the same way as the programs which form part of the system (the library). Indeed, we actively support the contribution, refereeing and distribution of extensions to the system, in the form of &GAP; packages. Further details of this can be found in chapter , and on our website.

Development of &GAP; began at Lehrstuhl D für Mathematik, RWTH-Aachen, under the leadership of Joachim Neubüser in 1985. Version 2.4 was released in 1988 and version 3.1 in 1992. In 1997 coordination of &GAP; development, now very much an international effort, was transferred to St Andrews. A complete internal redesign and almost complete rewrite of the system was completed over the following years and version 4.1 was released in July 1999. A sign of the further internationalization of the project was the &GAP; 4.4 release in 2004, which has been coordinated from Colorado State University, Fort Collins.

More information on the motivation and development of &GAP; to date, can be found on our Web pages in a section entitled Release history and Prefaces.

For those readers who have used an earlier version of &GAP;, an overview of the changes from &GAP; 4.4 and a brief summary of changes from earlier versions is given in a separate manual .

The system that you are getting now consists of a core system and a number of packages. The core system consists of four main parts. A kernel, written in C, which provides the user with automatic dynamic storage management, which the user needn't bother about in his programming; a set of time-critical basic functions, e.g. arithmetic, operations for integers, finite fields, permutations and words, as well as natural operations for lists and records; an interpreter for the &GAP; language, an untyped imperative programming language with functions as first class objects and some extra built-in data types such as permutations and finite field elements. The language supports a form of object-oriented programming, similar to that supported by languages like C++ and Java but with some important differences. a small set of system functions allowing the &GAP; programmer to handle files and execute external programs in a uniform way, regardless of the particular operating system in use. a set of programming tools for testing, debugging, and timing algorithms. a read-eval-view style user interface. A much larger library of &GAP; functions that implement algebraic and other algorithms. Since this is written entirely in the &GAP; language, the &GAP; language is both the main implementation language and the user language of the system. Therefore the user can as easily as the original programmers investigate and vary algorithms of the library and add new ones to it, first for own use and eventually for the benefit of all &GAP; users. A library of group theoretical data which contains various libraries of groups, including the library of small groups (containing all groups of order at most 2000, except those of order 1024) and others. Large libraries of ordinary and Brauer character tables and Tables of Marks are included as packages. The documentation. This is available as on-line help, as printable files in PDF format and as HTML for viewing with a Web browser.

Also included with the core system are some test files and a few small utilities which we hope you will find useful.

&GAP; packages are self-contained extensions to the core system. A package contains &GAP; code and its own documentation and may also contain data files or external programs to which the &GAP; code provides an interface. These packages may be loaded into &GAP; using the command, and both the package and its documentation are then available just as if they were parts of the core system. Some packages may be loaded automatically, when &GAP; is started, if they are present. Some packages, because they depend on external programs, may only be available on the operating systems where those programs are available (usually UNIX). You should note that, while the packages included with this release are the most recent versions ready for release at this time, new packages and new versions may be released at any time and can be easily installed in your copy of &GAP;.

With &GAP; there are two packages (the library of ordinary and Brauer character tables, and the library of tables of marks) which contain functionality developed from parts of the &GAP; core system. These have been moved into packages for ease of maintenance and to allow new versions to be released independently of new releases of the core system. The library of small groups should also be regarded as a package, although it does not currently use the standard package mechanism. Other packages contain functionality which has never been part of the core system, and may extend it substantially, implementing specific algorithms to enhance its capabilities, providing data libraries, interfaces to other computer algebra systems and data sources such as the electronic version of the Atlas of Finite Group Representations; therefore, installation and usage of packages is recommended.

Further details about &GAP; packages can be found in chapter , and on the &GAP; website here: http://www.gap-system.org/Packages/packages.html. gap-4r6p5/doc/ref/fieldfin.xml0000644000175000017500000001517612172557252014776 0ustar billbill Finite Fields This chapter describes the special functionality which exists in &GAP; for finite fields and their elements. Of course the general functionality for fields (see Chapter ) also applies to finite fields.

In the following, the term finite field element is used to denote &GAP; objects in the category , and finite field means a field consisting of such elements. Note that in principle we must distinguish these fields from (abstract) finite fields. For example, the image of the embedding of a finite field into a field of rational functions in the same characteristic is of course a finite field but its elements are not in , and in fact &GAP; does currently not support such fields.

Special representations exist for row vectors and matrices over small finite fields (see sections  and ).

Finite Field Elements <#Include Label="IsFFE"> <#Include Label="Z"> <#Include Label="IsLexOrderedFFE">
Operations for Finite Field Elements <#Include Label="[2]{ffe}"> <#Include Label="DegreeFFE"> <#Include Label="LogFFE"> <#Include Label="IntFFE"> <#Include Label="IntFFESymm"> <#Include Label="IntVecFFE"> <#Include Label="AsInternalFFE">
Creating Finite Fields <#Include Label="DefaultField:ffe"> <#Include Label="GaloisField"> <#Include Label="PrimitiveRoot">
Frobenius Automorphisms <#Include Label="FrobeniusAutomorphism">
Conway Polynomials <#Include Label="ConwayPolynomial"> <#Include Label="IsCheapConwayPolynomial"> <#Include Label="RandomPrimitivePolynomial">
Printing, Viewing and Displaying Finite Field Elements Internal finite field elements are viewed, printed and displayed (see section for the distinctions between these operations) as powers of the primitive root (except for the zero element, which is displayed as 0 times the primitive root). Thus:

Z(2); Z(2)^0 gap> Z(5)+Z(5); Z(5)^2 gap> Z(256); Z(2^8) gap> Zero(Z(125)); 0*Z(5) ]]>

Note also that each element is displayed as an element of the field it generates, and that the size of the field is printed as a power of the characteristic.

Elements of larger fields are printed as &GAP; expressions which represent them as sums of low powers of the primitive root:

Print( Z(3,20)^100, "\n" ); 2*Z(3,20)^2+Z(3,20)^4+Z(3,20)^6+Z(3,20)^7+2*Z(3,20)^9+2*Z(3,20)^10+2*Z\ (3,20)^12+2*Z(3,20)^15+2*Z(3,20)^17+Z(3,20)^18+Z(3,20)^19 gap> Print( Z(3,20)^((3^20-1)/(3^10-1)), "\n" ); Z(3,20)^3+2*Z(3,20)^4+2*Z(3,20)^7+Z(3,20)^8+2*Z(3,20)^10+Z(3,20)^11+2*\ Z(3,20)^12+Z(3,20)^13+Z(3,20)^14+Z(3,20)^15+Z(3,20)^17+Z(3,20)^18+2*Z(\ 3,20)^19 gap> Z(3,20)^((3^20-1)/(3^10-1)) = Z(3,10); true ]]>

Note from the second example above, that these elements are not always written over the smallest possible field before being output.

The and methods for these large finite field elements use a slightly more compact, but mathematically equivalent representation. The primitive root is represented by z; its i-th power by zi and k times this power by kzi.

Z(5,20)^100; z2+z4+4z5+2z6+z8+3z9+4z10+3z12+z13+2z14+4z16+3z17+2z18+2z19 ]]>

This output format is always used for . For it is used only if its length would not exceed ViewLength() lines. Longer output is replaced by <<an element of GF(p, d)>>.

Z(2,409)^100000; <> gap> Display(Z(2,409)^100000); z2+z3+z4+z5+z6+z7+z8+z10+z11+z13+z17+z19+z20+z29+z32+z34+z35+z37+z40+z\ 45+z46+z48+z50+z52+z54+z55+z58+z59+z60+z66+z67+z68+z70+z74+z79+z80+z81\ +z82+z83+z86+z91+z93+z94+z95+z96+z98+z99+z100+z101+z102+z104+z106+z109\ +z110+z112+z114+z115+z118+z119+z123+z126+z127+z135+z138+z140+z142+z143\ +z146+z147+z154+z159+z161+z162+z168+z170+z171+z173+z174+z181+z182+z183\ +z186+z188+z189+z192+z193+z194+z195+z196+z199+z202+z204+z205+z207+z208\ +z209+z211+z212+z213+z214+z215+z216+z218+z219+z220+z222+z223+z229+z232\ +z235+z236+z237+z238+z240+z243+z244+z248+z250+z251+z256+z258+z262+z263\ +z268+z270+z271+z272+z274+z276+z282+z286+z288+z289+z294+z295+z299+z300\ +z301+z302+z303+z304+z305+z306+z307+z308+z309+z310+z312+z314+z315+z316\ +z320+z321+z322+z324+z325+z326+z327+z330+z332+z335+z337+z338+z341+z344\ +z348+z350+z352+z353+z356+z357+z358+z360+z362+z364+z366+z368+z372+z373\ +z374+z375+z378+z379+z380+z381+z383+z384+z386+z387+z390+z395+z401+z402\ +z406+z408 ]]>

Finally note that elements of large prime fields are stored and displayed as residue class objects. So

Z(65537); ZmodpZObj( 3, 65537 ) ]]>

gap-4r6p5/doc/ref/rings.xml0000644000175000017500000001367512172557252014342 0ustar billbill Rings This chapter deals with domains that are additive groups (see closed under multiplication *. Such a domain, if * and + are distributive, is called a ring in &GAP;. Each division ring, field (see ), or algebra (see ) is a ring. Important examples of rings are the integers (see ) and matrix rings.

In the case of a ring-with-one, additional multiplicative structure is present, see . There is a little support in &GAP; for rings that have no additional structure: it is possible to perform some computations for small finite rings; infinite rings are handled by &GAP; in an acceptable way in the case that they are algebras.

Also, the SONATA package provides support for near-rings, and a related functionality for multiplicative semigroups of near-rings is available in the Smallsemi package.

Several functions for ring elements, such as and , are defined only relative to a ring R, which can be entered as an optional argument; if R is omitted then a default ring is formed from the ring elements given as arguments, see .

Generating Rings <#Include Label="IsRing"> <#Include Label="Ring"> <#Include Label="DefaultRing"> <#Include Label="RingByGenerators"> <#Include Label="DefaultRingByGenerators"> <#Include Label="GeneratorsOfRing"> <#Include Label="Subring"> <#Include Label="ClosureRing"> <#Include Label="Quotient">
Ideals in Rings <#Include Label="[1]{ideal}"> <#Include Label="TwoSidedIdeal"> <#Include Label="TwoSidedIdealNC"> <#Include Label="IsTwoSidedIdeal"> <#Include Label="TwoSidedIdealByGenerators"> <#Include Label="LeftIdealByGenerators"> <#Include Label="RightIdealByGenerators"> <#Include Label="GeneratorsOfTwoSidedIdeal"> <#Include Label="GeneratorsOfLeftIdeal"> <#Include Label="GeneratorsOfRightIdeal"> <#Include Label="LeftActingRingOfIdeal"> <#Include Label="AsLeftIdeal">
Rings With One <#Include Label="IsRingWithOne"> <#Include Label="RingWithOne"> <#Include Label="RingWithOneByGenerators"> <#Include Label="GeneratorsOfRingWithOne"> <#Include Label="SubringWithOne">
Properties of Rings <#Include Label="IsIntegralRing"> <#Include Label="IsUniqueFactorizationRing"> <#Include Label="IsLDistributive"> <#Include Label="IsRDistributive"> <#Include Label="IsDistributive"> <#Include Label="IsAnticommutative"> <#Include Label="IsZeroSquaredRing"> <#Include Label="IsJacobianRing">
Units and Factorizations <#Include Label="IsUnit"> <#Include Label="Units"> <#Include Label="IsAssociated"> <#Include Label="Associates"> <#Include Label="StandardAssociate"> <#Include Label="StandardAssociateUnit"> <#Include Label="IsIrreducibleRingElement"> <#Include Label="IsPrime"> <#Include Label="Factors"> <#Include Label="PadicValuation">
Euclidean Rings <#Include Label="IsEuclideanRing"> <#Include Label="EuclideanDegree"> <#Include Label="EuclideanQuotient"> <#Include Label="EuclideanRemainder"> <#Include Label="QuotientRemainder">
Gcd and Lcm <#Include Label="Gcd"> <#Include Label="GcdOp"> <#Include Label="GcdRepresentation"> <#Include Label="GcdRepresentationOp"> <#Include Label="ShowGcd"> <#Include Label="Lcm"> <#Include Label="LcmOp"> <#Include Label="QuotientMod"> <#Include Label="PowerMod"> <#Include Label="InterpolatedPolynomial">
Homomorphisms of Rings A ring homomorphism is a mapping between two rings that respects addition and multiplication.

Currently &GAP; supports ring homomorphisms between finite rings (using straightforward methods) and ring homomorphisms with additional structures, where source and range are in fact algebras and where also the linear structure is respected, see . <#Include Label="RingGeneralMappingByImages"> <#Include Label="RingHomomorphismByImages"> <#Include Label="RingHomomorphismByImagesNC"> <#Include Label="NaturalHomomorphismByIdeal">

gap-4r6p5/doc/ref/methsel.xml0000644000175000017500000003113512172557252014650 0ustar billbill Method Selection operationmethod This chapter explains how &GAP; decides which function to call for which types of objects. It assumes that you have read the chapters about objects (Chapter ) and types (Chapter ).

An operation is a special &GAP; function that bundles a set of functions, its methods.

All methods of an operation compute the same result. But each method is installed for specific types of arguments.

If an operation is called with a tuple of arguments, one of the applicable methods is selected and called.

Special cases of methods are partial methods, immediate methods, and logical implications.

Operations and Methods

Operations are functions in the category .

So on the one hand, operations are &GAP; functions, that is, they can be applied to arguments and return a result or cause a side-effect.

On the other hand, operations are more. Namely, an operation corresponds to a set of &GAP; functions, called the methods of the operation.

Each call of an operation causes a suitable method to be selected and then called. The choice of which method to select is made according to the types of the arguments, the underlying mechanism is described in the following sections.

Examples of operations are the binary infix operators =, + etc., and is the operation that is called for each argument of .

Also all attributes and properties are operations. Each attribute has a special method which is called if the attribute value is already stored; this method of course simply returns this value.

The setter of an attribute is called automatically if an attribute value has been computed. Attribute setters are operations, too. They have a default method that ignores the request to store the value. Depending on the type of the object, there may be another method to store the value in a suitable way, and then set the attribute tester for the object to true.

Method Installation In order to describe what it means to select a method of an operation, we must describe how the methods are connected to their operations.

For attributes and properties there is .

For declaring that a filter is implied by other filters there is . <#Include Label="InstallMethod"> <#Include Label="InstallOtherMethod">

Applicable Methods and Method Selection A method installed as above is applicable for an arguments tuple if the following conditions are satisfied.

The number of arguments equals the length of the list args-filts, the i-th argument lies in the filter args-filts[i], and famp returns true when applied to the families of the arguments. The maximal number of arguments supported for methods is six, one gets an error message if one tries to install a method with at least seven arguments.

So args-filt describes conditions for each argument, and famp describes a relation between the arguments.

For unary operations such as attributes and properties, there is no such relation to postulate, famp is for these operations, a function that always returns true. For binary operations, the usual value of famp is , which means that both arguments must lie in the same family.

Note that any properties which occur among the filters in the filter list will not be tested by the method selection if they are not yet known. (More exact: if prop is a property then the filter implicitly uses not prop but Hasprop and prop.) If this is desired you must explicitly enforce a test (see section ) below.

If no method is applicable, the error message no method found is signaled.

Otherwise, the applicable method with highest rank is selected and then called. This rank is given by the sum of the ranks of the filters in the list args-filt, including involved filters, plus the number val used in the call of . So the argument val can be used to raise the priority of a method relative to other methods for opr.

Note that from the applicable methods, an efficient one shall be selected. This is a method that needs only little time and storage for the computations.

It seems to be impossible for &GAP; to select an optimal method in all cases. The present ranking of methods is based on the assumption that a method installed for a special situation shall be preferred to a method installed for a more general situation.

For example, a method for computing a Sylow subgroup of a nilpotent group is expected to be more efficient than a method for arbitrary groups. So the more specific method will be selected if &GAP; knows that the group given as argument is nilpotent.

Of course there is no obvious way to decide between the efficiency of incommensurable methods. For example, take an operation with one method for permutation groups, another method for nilpotent groups, but no method for nilpotent permutation groups, and call this operation with a permutation group known to be nilpotent.

Partial Methods After a method has been selected and called, the method may recognize that it cannot compute the desired result, and give up by calling TryNextMethod().

In effect, the execution of the method is terminated, and the method selection calls the next method that is applicable w.r.t. the original arguments. In other words, the applicable method is called that is subsequent to the one that called , according to decreasing rank of the methods.

For example, since every finite group of odd order is solvable, one may install a method for the property that checks whether the size of the argument is an odd integer, returns true if so, and gives up otherwise.

Care is needed if a partial method might modify the type of one of its arguments, for example by computing an attribute or property. If this happens, and the type has really changed, then the method should not exit using TryNextMethod() but should call the operation again, as the new information in the type may cause some methods previously judged inapplicable to be applicable. For example, if the above method for actually computes the size, (rather than just examining a stored size), then it must take care to check whether the type of the group has changed.

Redispatching As mentioned above the method selection will not test unknown properties. In situations, in which algorithms are only known (or implemented) under certain conditions, however such a test might be actually desired.

One way to achieve this would be to install the method under weaker conditions and explicitly test the properties first, exiting via if some of them are not fulfilled. A problem of this approach however is that such methods then automatically are ranked lower and that the code does not look nice.

A much better way is to use redispatching: Before deciding that no method has been found one tests these properties and if they turn out to be true the method selection is started anew (and will then find a method).

This can be achieved via the following function: <#Include Label="RedispatchOnCondition">

Immediate Methods Usually a method is called only if its operation has been called and if this method has been selected, see .

For attributes and properties, one can install also immediate methods. <#Include Label="InstallImmediateMethod">

Logical Implications <#Include Label="InstallTrueMethod">
Operations and Mathematical Terms overload Usually an operation stands for a mathematical concept, and the name of the operation describes this uniquely. Examples are the property and the attribute . But there are cases where the same mathematical term is used to denote different concepts, for example Degree is defined for polynomials, group characters, and permutation actions, and Rank is defined for matrices, free modules, p-groups, and transitive permutation actions.

It is in principle possible to install methods for the operation Rank that are applicable to the different types of arguments, corresponding to the different contexts. But this is not the approach taken in the &GAP; library. Instead there are operations such as for matrices and (in fact these are attributes) which are installed as methods of the ambiguous operations Rank and Degree.

The idea is to distinguish between on the one hand different ways to compute the same thing (e.g. different methods for , , etc.), and on the other hand genuinely different things (such as the degree of a polynomial and a permutation action).

The former is the basic purpose of operations and attributes. The latter is provided as a user convenience where mathematical usage forces it on us and where no conflicts arise. In programming the library, we use the underlying mathematically precise operations or attributes, such as and RankOperation. These should be attributes if appropriate, and the only role of the operation Rank is to decide which attribute the user meant. That way, stored information is stored with full mathematical precision and is less likely to be retrieved for a wrong purpose later.

One word about possible conflicts. A typical example is the mathematical term centre, which is defined as \{ x \in M | a * x = x * a \forall a \in M \} for a magma M, and as \{ x \in L | l * x = 0 \forall l \in L \} for a Lie algebra L. Here it is not possible to introduce an operation that delegates to attributes CentreOfMagma and CentreOfLieAlgebra, depending on the type of the argument. This is because any Lie algebra in &GAP; is also a magma, so both CentreOfMagma and CentreOfLieAlgebra would be defined for a Lie algebra, with different meaning if the characteristic is two. So we cannot achieve that one operation in &GAP; corresponds to the mathematical term centre.

Ambiguous operations such as Rank are declared in the library file lib/overload.g.

gap-4r6p5/doc/ref/rational.xml0000644000175000017500000000516612172557252015025 0ustar billbill Rational Numbers The rationals form a very important field. On the one hand it is the quotient field of the integers (see chapter ). On the other hand it is the prime field of the fields of characteristic zero (see chapter ).

The former comment suggests the representation actually used. A rational is represented as a pair of integers, called numerator and denominator. Numerator and denominator are reduced, i.e., their greatest common divisor is 1. If the denominator is 1, the rational is in fact an integer and is represented as such. The numerator holds the sign of the rational, thus the denominator is always positive.

Because the underlying integer arithmetic can compute with arbitrary size integers, the rational arithmetic is always exact, even for rationals whose numerators and denominators have thousands of digits.

2/3; 2/3 gap> 66/123; # numerator and denominator are made relatively prime 22/41 gap> 17/-13; # the numerator carries the sign; -17/13 gap> 121/11; # rationals with denominator 1 (when canceled) are integers 11 ]]>

Rationals: Global Variables <#Include Label="Rationals">
Elementary Operations for Rationals <#Include Label="IsRat"> <#Include Label="IsPosRat"> <#Include Label="IsNegRat"> <#Include Label="NumeratorRat"> <#Include Label="DenominatorRat"> <#Include Label="Rat"> for rationals returns pseudo random rationals which are the quotient of two random integers. See the description of for details. (Also see .)
gap-4r6p5/doc/ref/arith.xml0000644000175000017500000004621512172557252014323 0ustar billbill An Example – Designing Arithmetic Operations In this chapter, we give a –hopefully typical– example of extending &GAP; by new objects with prescribed arithmetic operations (for a simple approach that may be useful to get started though does not permit to exploit all potential features, see also ).
New Arithmetic Operations vs. New Objects A usual procedure in mathematics is the definition of new operations for given objects; here are a few typical examples. The Lie bracket defines an interesting new multiplicative structure on a given (associative) algebra. Forming a group ring can be viewed as defining a new addition for the elements of the given group, and extending the multiplication to sums of group elements in a natural way. Forming the exterior algebra of a given vector space can be viewed as defining a new multiplication for the vectors in a natural way.

&GAP; does not support such a procedure. The main reason for this is that in &GAP;, the multiplication in a group, a ring etc. is always written as *, and the addition in a vector space, a ring etc.  is always written as +. Therefore it is not possible to define the Lie bracket as a second multiplication for the elements of a given algebra; in fact, the multiplication in Lie algebras in &GAP; is denoted by *. Analogously, constructing the group ring as sketched above is impossible if an addition is already defined for the elements; note the difference between the usual addition of matrices and the addition in the group ring of a matrix group! (See Chapter  for an example.) Similarly, there is already a multiplication defined for row vectors (yielding the standard scalar product), hence these vectors cannot be regarded as elements of the exterior algebra of the space.

In situations such as the ones mentioned above, &GAP;'s way to deal with the structures in question is the following. Instead of defining new operations for the given objects, new objects are created to which the given arithmetic operations * and + are then made applicable.

With this construction, matrix Lie algebras consist of matrices that are different from the matrices with associative multiplication; technically, the type of a matrix determines how it is multiplied with other matrices (see ). A matrix with the Lie bracket as its multiplication can be created with the function from a matrix with the usual associative multiplication.

Group rings (more general: magma rings, see Chapter ) can be constructed with from a coefficient ring and a group. The elements of the group are not contained in such a group ring, one has to use an embedding map for creating a group ring element that corresponds to a given group element.

It should be noted that the &GAP; approach to the construction of Lie algebras from associative algebras is generic in the sense that all objects in the filter use the same methods for their addition, multiplication etc., by delegating to the underlying objects of the associative algebra, no matter what these objects actually are. Analogously, also the construction of group rings is generic.

Designing new Multiplicative Objects The goal of this section is to implement objects with a prescribed multiplication. Let us assume that we are given a field F, and that we want to define a new multiplication * on F that is given by a * b = a b - a - b + 2; here a b denotes the ordinary product in F.

By the discussion in Section , we know that we cannot define a new multiplication on F itself but have to create new objects.

We want to distinguish these new objects from all other &GAP; objects, in order to describe for example the situation that two of our objects shall be multiplied. This distinction is made via the type of the objects. More precisely, we declare a new filter, a function that will return true for our new objects, and false for all other &GAP; objects. This can be done by calling , but since our objects will know about the value already when they are constructed, the filter can be created with or .

The idea is that the new multiplication will be installed only for objects that lie in the category IsMyObject.

The next question is what internal data our new objects store, and how they are accessed. The easiest solution is to store the underlying object from the field F. &GAP; provides two general possibilities how to store this, namely record-like and list-like structures (for examples, see  and ). We decide to store the data in a list-like structure, at position 1. This representation is declared as follows.

Of course we can argue that this declaration is superfluous because all objects in the category IsMyObject will be represented this way; it is possible to proceed like that, but often (in more complicated situations) it turns out to be useful that several representations are available for the same element.

For creating the type of our objects, we need to specify to which family (see ) the objects shall belong. For the moment, we need not say anything about relations to other &GAP; objects, thus the only requirement is that all new objects lie in the same family; therefore we create a new family. Also we are not interested in properties that some of our objects have and others do not have, thus we need only one type, and store it in a global variable.

The next step is to write a function that creates a new object. It may look as follows. Objectify( MyType, [ Immutable( val ) ] ); ]]> Note that we store an immutable copy of the argument in the returned object; without doing so, for example if the argument would be a mutable matrix then the corresponding new object would be changed whenever the matrix is changed (see  for more details about mutability).

Having entered the above &GAP; code, we can create some of our objects. a:= MyObject( 3 ); b:= MyObject( 5 ); gap> a![1]; b![1]; 3 5 ]]> But clearly a lot is missing. Besides the fact that the desired multiplication is not yet installed, we see that also the way how the objects are printed is not satisfactory.

Let us improve the latter first. There are two &GAP; functions and for showing objects on the screen. is thought to show a short and human readable form of the object, and is thought to show a not necessarily short form that is &GAP; readable whenever this makes sense. We decide to show a as 3 by , and to show the construction MyObject( 3 ) by ; the methods are installed for the underlying operations and . " ); end ); InstallMethod( PrintObj, "for object in `IsMyObject'", [ IsMyObject and IsMyObjectListRep ], function( obj ) Print( "MyObject( ", obj![1], " )" ); end ); ]]>

This is the result of the above installations. a; Print( a, "\n" ); <3> MyObject( 3 ) ]]>

And now we try to install the multiplication.

When we enter the above code, &GAP; runs into an error. This is due to the fact that the operation is declared for two arguments that lie in the category . One could circumvent the check whether the method matches the declaration of the operation, by calling instead of . But it would make sense if our objects would lie in , for example because some generic methods for objects with multiplication would be available then, such as powering by positive integers via repeated squaring. So we want that IsMyObject implies . The easiest way to achieve such implications is to use the implied filter as second argument of the call; but since we do not want to start anew, we can also install the implication afterwards.

Afterwards, installing the multiplication works without problems. Note that MyType and therefore also a and b are not affected by this implication, so we construct them anew.

MyType:= NewType( NewFamily( "MyFamily" ), > IsMyObject and IsMyObjectListRep );; gap> a:= MyObject( 3 );; b:= MyObject( 5 );; gap> a*b; a^27; <9> <134217729> ]]>

Powering the new objects by negative integers is not possible yet, because &GAP; does not know how to compute the inverse of an element a, say, which is defined as the unique element a' such that both a a' and a' a are the unique multiplicative neutral element that belongs to a.

And also this neutral element, if it exists, cannot be computed by &GAP; in our current situation. It does, however, make sense to ask for the multiplicative neutral element of a given magma, and for inverses of elements in the magma.

But before we can form domains of our objects, we must define when two objects are regarded as equal; note that this is necessary in order to decide about the uniqueness of neutral and inverse elements. In our situation, equality is defined in the obvious way. For being able to form sets of our objects, also an ordering via is defined for them.

Let us look at an example. We start with finite field elements because then the domains are finite, hence the generic methods for such domains will have a chance to succeed.

a:= MyObject( Z(7) ); gap> m:= Magma( a ); gap> e:= MultiplicativeNeutralElement( m ); gap> elms:= AsList( m ); [ , , ] gap> ForAll( elms, x -> ForAny( elms, y -> x*y = e and y*x = e ) ); true gap> List( elms, x -> First( elms, y -> x*y = e and y*x = e ) ); [ , , ] ]]>

So a multiplicative neutral element exists, in fact all elements in the magma m are invertible. But what about the following.

b:= MyObject( Z(7)^0 ); m:= Magma( a, b ); gap> elms:= AsList( m ); [ , , , ] gap> e:= MultiplicativeNeutralElement( m ); gap> ForAll( elms, x -> ForAny( elms, y -> x*y = e and y*x = e ) ); false gap> List( elms, x -> b * x ); [ , , , ] ]]>

Here we found a multiplicative neutral element, but the element b does not have an inverse. If an addition would be defined for our elements then we would say that b behaves like a zero element.

When we started to implement the new objects, we said that we wanted to define the new multiplication for elements of a given field F. In principle, the current implementation would admit also something like MyObject( 2 ) * MyObject( Z(7) ). But if we decide that our initial assumption holds, we may define the identity and the inverse of the object <a> as <2*e> and <a/(a-e)>, respectively, where e is the identity element in F and / denotes the division in F; note that the element <e> is not invertible, and that the above definitions are determined by the multiplication defined for our objects. Further note that after the installations shown below, also One( MyObject( 1 ) ) is defined.

(For technical reasons, we do not install the intended methods for the attributes and but for the operations and . This is because for certain kinds of objects –mainly matrices– one wants to support a method to compute a mutable identity or inverse, and the attribute needs only a method that takes this object, makes it immutable, and then returns this object. As stated above, we only want to deal with immutable objects, so this distinction is not really interesting for us.)

A more interesting point to note is that we should mark our objects as likely to be invertible, since we add the possibility to invert them. Again, this could have been part of the declaration of IsMyObject, but we may also formulate an implication for the existing category.

MyObject( 2 * One( a![1] ) ) ); InstallMethod( InverseOp, "for an object in `IsMyObject'", [ IsMyObject and IsMyObjectListRep ], a -> MyObject( a![1] / ( a![1] - One( a![1] ) ) ) ); ]]> Now we can form groups of our (nonzero) elements. MyType:= NewType( NewFamily( "MyFamily" ), > IsMyObject and IsMyObjectListRep );; gap> gap> a:= MyObject( Z(7) ); gap> b:= MyObject( 0*Z(7) ); g:= Group( a, b ); <0*Z(7)> gap> Size( g ); 6 ]]>

We are completely free to define an addition for our elements, a natural one is given by <a> + <b> = <a+b-1>. As we did for the multiplication, we first change IsMyObject such that the additive structure is also known. Next we install the methods for the addition, and those to compute the additive neutral element and the additive inverse.

MyObject( One( a![1] ) ) ); InstallMethod( AdditiveInverseOp, "for an object in `IsMyObject'", [ IsMyObject and IsMyObjectListRep ], a -> MyObject( a![1] / ( a![1] - One( a![1] ) ) ) ); ]]>

Let us try whether the addition works.

MyType:= NewType( NewFamily( "MyFamily" ), > IsMyObject and IsMyObjectListRep );; gap> a:= MyObject( Z(7) );; b:= MyObject( 0*Z(7) );; gap> m:= AdditiveMagma( a, b ); gap> Size( m ); 7 ]]>

Similar as installing a multiplication automatically makes powering by integers available, multiplication with integers becomes available with the addition.

2 * a; gap> a+a; gap> MyObject( 2*Z(7)^0 ) * a; ]]>

In particular we see that this multiplication does not coincide with the multiplication of two of our objects, that is, an integer cannot be used as a shorthand for one of the new objects in a multiplication.

(It should be possible to create a field with the new multiplication and addition. Currently this fails, due to missing methods for computing several kinds of generators from field generators, for computing the characteristic in the case that the family does not know this in advance, for checking with whether a domain is in fact a field, for computing the closure as a field.)

It should be emphasized that the mechanism described above may be not suitable for the situation that one wants to consider many different multiplications on the same set of objects, since the installation of a new multiplication requires the declaration of at least one new filter and the installation of several methods. But the design of &GAP; is not suitable for such dynamic method installations.

Turning this argument the other way round, the implementation of the new arithmetics defined by the above multiplication and addition is available for any field F, one need not repeat it for each field one is interested in.

Similar to the above situation, the construction of a magma ring RM from a coefficient ring R and a magma M is implemented only once, since the definition of the arithmetic operations depends only on the given multiplication of M and not on M itself. So the addition is not implemented for the elements in M or –more precisely– for an isomorphic copy. In some sense, the addition is installed for the multiplication, and as mentioned in Section , there is only one multiplication in &GAP;. gap-4r6p5/doc/ref/padics.xml0000644000175000017500000001063712172557252014456 0ustar billbill p-adic Numbers (preliminary) In this chapter p is always a (fixed) prime integer.

The p-adic numbers Q_p are the completion of the rational numbers with respect to the valuation \nu_p( p^v \cdot a / b) = v if p divides neither a nor b. They form a field of characteristic 0 which nevertheless shows some behaviour of the finite field with p elements.

A p-adic numbers can be represented by a p-adic expansion which is similar to the decimal expansion used for the reals (but written from left to right). So for example if p = 2, the numbers 1, 2, 3, 4, 1/2, and 4/5 are represented as 1(2), 0.1(2), 1.1(2), 0.01(2), 10(2), and the infinite periodic expansion 0.010110011001100...(2). p-adic numbers can be approximated by ignoring higher powers of p, so for example with only 2 digits accuracy 4/5 would be approximated as 0.01(2). This is different from the decimal approximation of real numbers in that p-adic approximation is a ring homomorphism on the subrings of p-adic numbers whose valuation is bounded from below so that rounding errors do not increase with repeated calculations.

In &GAP;, p-adic numbers are always represented by such approximations. A family of approximated p-adic numbers consists of p-adic numbers with a fixed prime p and a certain precision, and arithmetic with these numbers is done with this precision.

Pure p-adic Numbers Pure p-adic numbers are the p-adic numbers described so far. <#Include Label="PurePadicNumberFamily"> returns the element of the p-adic number family fam that approximates the rational number rat.

p-adic numbers allow the usual operations for fields.

fam:=PurePadicNumberFamily(2,20);; gap> a:=PadicNumber(fam,4/5); 0.010110011001100110011(2) gap> fam:=PurePadicNumberFamily(2,3);; gap> a:=PadicNumber(fam,4/5); 0.0101(2) gap> 3*a; 0.0111(2) gap> a/2; 0.101(2) gap> a*10; 0.001(2) ]]> See for other methods for . <#Include Label="Valuation"> <#Include Label="ShiftedPadicNumber"> <#Include Label="IsPurePadicNumber"> <#Include Label="IsPurePadicNumberFamily">

Extensions of the p-adic Numbers The usual Kronecker construction with an irreducible polynomial can be used to construct extensions of the p-adic numbers. Let L be such an extension. Then there is a subfield K < L such that K is an unramified extension of the p-adic numbers and L/K is purely ramified.

(For an explanation of ramification see for example , or another book on algebraic number theory. Essentially, an extension L of the p-adic numbers generated by a rational polynomial f is unramified if f remains squarefree modulo p and is completely ramified if modulo p the polynomial f is a power of a linear factor while remaining irreducible over the p-adic numbers.)

The representation of extensions of p-adic numbers in &GAP; uses the subfield K. <#Include Label="PadicExtensionNumberFamily"> <#Include Label="PadicNumber"> <#Include Label="IsPadicExtensionNumber"> <#Include Label="IsPadicExtensionNumberFamily">

gap-4r6p5/doc/ref/record.xml0000644000175000017500000004010412172557252014461 0ustar billbill Records type Records are next to lists the most important way to collect objects together. A record is a collection of components. Each component has a unique name, which is an identifier that distinguishes this component, and a value, which is an object of arbitrary type. We often abbreviate value of a component to element. We also say that a record contains its elements. You can access and change the elements of a record using its name.

Record literals are written by writing down the components in order between rec( and ), and separating them by commas ,. Each component consists of the name, the assignment operator :=, and the value. The empty record, i.e., the record with no components, is written as rec().

rec( a := 1, b := "2" ); # a record with two components rec( a := 1, b := "2" ) gap> rec( a := 1, b := rec( c := 2 ) ); # record may contain records rec( a := 1, b := rec( c := 2 ) ) ]]>

We may use the function to illustrate the hierarchy of the record components.

Display( last ); rec( a := 1, b := rec( c := 2 ) ) ]]>

Records usually contain elements of various types, i.e., they are usually not homogeneous like lists.

IsRecord and RecNames <#Include Label="IsRecord"> <#Include Label="RecNames">
Accessing Record Elements accessing record r.name

The above construct evaluates to the value of the record component with the name name in the record r. Note that the name is not evaluated, i.e. it is taken literal.

r := rec( a := 1, b := 2 );; gap> r.a; 1 gap> r.b; 2 ]]>

record r.(name)

This construct is similar to the above construct. The difference is that the second operand name is evaluated. It must evaluate to a string or an integer otherwise an error is signalled. The construct then evaluates to the element of the record r whose name is, as a string, equal to name.

old := rec( a := 1, b := 2 );; gap> new := rec(); rec( ) gap> for i in RecNames( old ) do > new.(i) := old.(i); > od; gap> Display( new ); rec( a := 1, b := 2 ) ]]>

Record Assignment assignment record r.name := obj

The record assignment assigns the object obj, which may be an object of arbitrary type, to the record component with the name name, which must be an identifier, of the record r. That means that accessing the element with name name of the record r will return obj after this assignment. If the record r has no component with the name name, the record is automatically extended to make room for the new component.

r := rec( a := 1, b := 2 );; gap> r.a := 10;; gap> Display( r ); rec( a := 10, b := 2 ) gap> r.c := 3;; gap> Display( r ); rec( a := 10, b := 2, c := 3 ) ]]>

Note that assigning to a record changes the record.

The function can be used to test if a record has a component with a certain name, the function can be used to remove a component with a certain name again.

IsBound(r.a); true gap> IsBound(r.d); false gap> Unbind(r.b); gap> Display( r ); rec( a := 10, c := 3 ) ]]>

record r.(name) := obj

This construct is similar to the above construct. The difference is that the second operand name is evaluated. It must evaluate to a string or an integer otherwise an error is signalled. The construct then assigns obj to the record component of the record r whose name is, as a string, equal to name.

Identical Records With the record assignment (see ) it is possible to change a record. This section describes the semantic consequences of this fact which are essentially the same as for lists (see ).

The second assignment does not change the first record, instead it assigns a new record to the variable r. On the other hand, in the following example the record is changed by the second assignment.

To understand the difference first think of a variable as a name for an object. The important point is that a record can have several names at the same time. An assignment var := r means in this interpretation that var is a name for the object r. At the end of the following example r2 still has the value rec( a := 1 ) as this record has not been changed and nothing else has been assigned to r2.

But after the following example the record for which r2 is a name has been changed and thus the value of r2 is now rec( a := 1, b := 2 ).

We shall say that two records are identical if changing one of them by a record assignment also changes the other one. This is slightly incorrect, because if two records are identical, there are actually only two names for one record. However, the correct usage would be very awkward and would only add to the confusion. Note that two identical records must be equal, because there is only one records with two different names. Thus identity is an equivalence relation that is a refinement of equality.

Let us now consider under which circumstances two records are identical.

If you enter a record literal then the record denoted by this literal is a new record that is not identical to any other record. Thus in the following example r1 and r2 are not identical, though they are equal of course.

Also in the following example, no records in the list l are identical.

If you assign a record to a variable no new record is created. Thus the record value of the variable on the left hand side and the record on the right hand side of the assignment are identical. So in the following example r1 and r2 are identical records.

If you pass a record as argument, the old record and the argument of the function are identical. Also if you return a record from a function, the old record and the value of the function call are identical. So in the following example r1 and r2 are identical records.

The functions and accept a record and return a new record that is equal to the old record but that is not identical to the old record. The difference between and is that in the case of the corresponding components of the new and the old records will be identical, whereas in the case of they will only be equal. So in the following example r1 and r2 are not identical records.

If you change a record it keeps its identity. Thus if two records are identical and you change one of them, you also change the other, and they are still identical afterwards. On the other hand, two records that are not identical will never become identical if you change one of them. So in the following example both r1 and r2 are changed, and are still identical.

Comparisons of Records equality inequality rec1 = rec2

rec1 <> rec2

Two records are considered equal, if for each component of one record the other record has a component of the same name with an equal value and vice versa.

rec( a := 1, b := 2 ) = rec( b := 2, a := 1 ); true gap> rec( a := 1, b := 2 ) = rec( a := 2, b := 1 ); false gap> rec( a := 1 ) = rec( a := 1, b := 2 ); false gap> rec( a := 1 ) = 1; false ]]>

ordering rec1 < rec2

rec1 <= rec2

To compare records we imagine that the components of both records are sorted according to their names (the sorting depends on the &GAP; session, more precisely the order in which component names were first used). Then the records are compared lexicographically with unbound elements considered smaller than anything else. Precisely one record rec1 is considered less than another record rec2 if rec2 has a component with name name2 and either rec1 has no component with this name or rec1.name2 < rec2.name2 and for each component of rec1 with name name1 < name2 rec2 has a component with this name and rec1.name1 = rec2.name1.

rec( axy := 1, bxy := 2 ) < rec( bxy := 2, axy := 1 ); # are equal false gap> rec( axy := 1 ) < rec( axy := 1, bxy := 2 ); # unbound is < 2 true gap> # in new session the .axy components are compared first gap> rec( axy := 1, bxy := 2 ) < rec( axy := 2, bxy := 0 ); # 1 < 2 true gap> rec( axy := 1 ) < rec( axy := 0, bxy := 2 ); # 0 < 1 false gap> rec( bxy := 1 ) < rec( bxy := 0, axy := 2 ); # unbound is < 2 true ]]>

IsBound and Unbind for Records returns true if the record r has a component with the name name (which must be an identifier) and false otherwise. r must evaluate to a record, otherwise an error is signalled.

r := rec( a := 1, b := 2 );; gap> IsBound( r.a ); true gap> IsBound( r.c ); false ]]> deletes the component with the name name in the record r. That is, after execution of , r no longer has a record component with this name. Note that it is not an error to unbind a nonexisting record component. r must evaluate to a record, otherwise an error is signalled.

r := rec( a := 1, b := 2 );; gap> Unbind( r.a ); r; rec( b := 2 ) gap> Unbind( r.c ); r; rec( b := 2 ) ]]>

Note that and are special in that they do not evaluate their argument, otherwise would always signal an error when it is supposed to return false and there would be no way to tell which component to remove.

Record Access Operations Internally, record accesses are done using the operations listed in this section. For the records implemented in the kernel, kernel methods are provided for all these operations but otherwise it is possible to install methods for these operations for any object. This permits objects to simulate record behavior.

To save memory, records do not store a list of all component names, but only numbers identifying the components. There numbers are called RNams. &GAP; keeps a global list of all RNams that are used and provides functions to translate RNams to strings that give the component names and vice versa. returns a string representing the component name corresponding to the RNam nr. returns a number (the RNam) corresponding to the string str. It is also possible to pass a positive integer int in which case the decimal expansion of int is used as a string.

NameRNam(798); "BravaisSupergroups" gap> RNamObj("blubberflutsch"); 2075 gap> NameRNam(last); "blubberflutsch" ]]>

The correspondence between strings and RNams is not predetermined ab initio, but RNams are assigned to component names dynamically on a first come, first serve basis. Therefore, depending on the version of the library you are using and on the assignments done so far, the same component name may be represented by different RNams in different &GAP; sessions. record component record boundness test record assignment record unbind These operations are called for record accesses to arbitrary objects. If applicable methods are installed, they are called when the object is accessed as a record.

For records, the operations implement component access, test for element boundness, component assignment and removal of the component represented by the RNam rnam.

The component identifier rnam is always required to be in .

gap-4r6p5/doc/ref/grphomom.xml0000644000175000017500000004622112172557252015041 0ustar billbill Group Homomorphisms A group homomorphism is a mapping from one group to another that respects multiplication and inverses. They are implemented as a special class of mappings, so in particular all operations for mappings, such as , , , , , , and (see chapter , in particular section ) are applicable to them.

Homomorphisms can be used to transfer calculations into isomorphic groups in another representation, for which better algorithms are available. Section  explains a technique how to enforce this automatically.

Homomorphisms are also used to represent group automorphisms, and section explains explains &GAP;'s facilities to work with automorphism groups.

Section explains how to make &GAP; to search for all homomorphisms between two groups which fulfill certain specifications.

Creating Group Homomorphisms The most important way of creating group homomorphisms is to give images for a set of group generators and to extend it to the group generated by them by the homomorphism property.

A second way to create homomorphisms is to give functions that compute image and preimage. (A similar case are homomorphisms that are induced by conjugation. Special constructors for such mappings are described in section ).

The third class are epimorphisms from a group onto its factor group. Such homomorphisms can be constructed by .

The fourth class is homomorphisms in a permutation group that are induced by an action on a set. Such homomorphisms are described in the context of group actions, see chapter  and in particular . <#Include Label="GroupHomomorphismByImages"> <#Include Label="GroupHomomorphismByImagesNC"> <#Include Label="GroupGeneralMappingByImages"> <#Include Label="GroupHomomorphismByFunction"> <#Include Label="AsGroupGeneralMappingByImages">

Operations for Group Homomorphisms kernel Group homomorphisms are mappings, so all the operations and properties for mappings described in chapter  are applicable to them. (However often much better methods, than for general mappings are available.)

Group homomorphisms will map groups to groups by just mapping the set of generators.

can be used to compute the kernel of a group homomorphism.

hom:=GroupHomomorphismByImages(g,h,gens,[(1,2),(1,3)]);; gap> Kernel(hom); Group([ (1,4)(2,3), (1,2)(3,4) ]) ]]>

Homomorphisms can map between groups in different representations and are also used to get isomorphic groups in a different representation.

m1:=[[0,-1],[1,0]];;m2:=[[0,-1],[1,1]];; gap> sl2z:=Group(m1,m2);; # SL(2,Integers) as matrix group gap> F:=FreeGroup(2);; gap> psl2z:=F/[F.1^2,F.2^3]; #PSL(2,Z) as FP group gap> phom:=GroupHomomorphismByImagesNC(sl2z,psl2z,[m1,m2], > GeneratorsOfGroup(psl2z)); # the non NC-version would be expensive [ [ [ 0, -1 ], [ 1, 0 ] ], [ [ 0, -1 ], [ 1, 1 ] ] ] -> [ f1, f2 ] gap> Kernel(phom); # the diagonal matrices Group([ [ [ -1, 0 ], [ 0, -1 ] ], [ [ -1, 0 ], [ 0, -1 ] ] ]) gap> p1:=(1,2)(3,4);;p2:=(2,4,5);;a5:=Group(p1,p2);; gap> ahom:=GroupHomomorphismByImages(psl2z,a5, > GeneratorsOfGroup(psl2z),[p1,p2]); # here homomorphism test is cheap. [ f1, f2 ] -> [ (1,2)(3,4), (2,4,5) ] gap> u:=PreImage(ahom,Group((1,2,3),(1,2)(4,5))); Group() gap> Index(psl2z,u); 10 gap> isofp:=IsomorphismFpGroup(u);; Image(isofp); gap> RelatorsOfFpGroup(Image(isofp)); [ F1^2, F4^2, F3^3 ] gap> up:=PreImage(phom,u);; gap> List(GeneratorsOfGroup(up),TraceMat); [ -2, -2, 0, -4, 1, 0 ] ]]>

For an automorphism aut, Inverse returns the inverse automorphism aut^{{-1}}. However if hom is a bijective homomorphism between different groups, or if hom is injective and considered to be a bijection to its image, the operation should be used instead. (See  for a further discussion of this problem.)

iso:=IsomorphismPcGroup(g); Pcgs([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ]) -> [ f1, f2, f3, f4 ] gap> Inverse(iso); #I The mapping must be bijective and have source=range #I You might want to use `InverseGeneralMapping' fail gap> InverseGeneralMapping(iso); [ f1, f2, f3, f4 ] -> Pcgs([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ]) ]]>

Efficiency of Homomorphisms &GAP; permits to create homomorphisms between arbitrary groups. This section considers the efficiency of the implementation and shows ways how to choose suitable representations. For permutation groups (see ) or Pc groups (see ) this is normally nothing to worry about, unless the groups get extremely large. For other groups however certain calculations might be expensive and some precaution might be needed to avoid unnecessarily expensive calculations.

In short, it is always worth to tell a mapping that it is a homomorphism (this can be done by calling SetIsMapping) (or to create it directly with ).

The basic operations required are to compute image and preimage of elements and to test whether a mapping is a homomorphism. Their cost will differ depending on the type of the mapping. Mappings given on generators See and .

Computing images requires to express an element of the source as word in the generators. If it cannot be done effectively (this is determined by which returns true for example for arbitrary permutation groups, for Pc groups or for finitely presented groups with the images of the free generators) the span of the generators has to be computed elementwise which can be very expensive and memory consuming.

Computing preimages adheres to the same rules with swapped rôles of generators and their images.

The test whether a mapping is a homomorphism requires the computation of a presentation for the source and evaluation of its relators in the images of its generators. For larger groups this can be expensive and should be used if the mapping is known to be a homomorphism. Action homomorphisms See .

The calculation of images is determined by the acting function used and –for large domains– is often dominated by the search for the position of an image in a list of the domain elements. This can be improved by sorting this list if an efficient method for to compare elements of the domain is available.

Once the images of a generating set are computed, computing preimages (which is done via ) and computing the kernel behaves the same as for a homomorphism created with from a permutation group.

&GAP; will always assume that the acting function provided implements a proper group action and thus that the mapping is indeed a homomorphism. Mappings given by functions See .

Computing images is wholly determined by the function that performs the image calculation. If no function to compute preimages is given, computing preimages requires mapping every element of the source to find an element that maps to the requested image. This is time and memory consuming.

Other operations To compute the kernel of a homomorphism (unless the mapping is known to be injective) requires the capability to compute a presentation of the image and to evaluate the relators of this presentation in preimages of the presentations generators.

The calculation of the (respectively ) value requires to map a generating set of the source, testing surjectivity is a comparison for equality with the range.

Testing injectivity is a test for triviality of the kernel.

The comparison of mappings is based on a lexicographic comparison of a sorted element list of the source. For group homomorphisms, this can be simplified, using <#Include Label="ImagesSmallestGenerators">

Homomorphism for very large groups Some homomorphisms (notably particular actions) transfer known information about the source group (such as a stabilizer chain) to the image group if this is substantially cheaper than to compute the information in the image group anew. In most cases this is no problem and in fact speeds up further calculations notably.

For a huge source group, however this can be time consuming or take a large amount of extra memory for storage. In this case it can be helpful to avoid as much automatism as possible.

The following list of tricks might be useful in such a case. (However you will lose much automatic deduction. So please restrict the use of these to cases where the standard approach does not work.) Compute only images (or the ) of group elements. Do not compute the images of (sub)groups or the full preimage of a subgroup. Create action homomorphisms as surjective (see ), otherwise the range is set to be the full symmetric group. However do not compute or values, but only the images of a generator set. If you suspect an action homomorphism to do too much internally, replace the action function with a function that does the same; i.e. replace by function( p, g ) return p^g; end;. The action will be the same, but as the action function is not , the extra processing for special cases is not triggered.

Nice Monomorphisms &GAP; contains very efficient algorithms for some special representations of groups (for example pc groups or permutation groups) while for other representations only slow generic methods are available. In this case it can be worthwhile to do all calculations rather in an isomorphic image of the group, which is in a better representation. The way to achieve this in &GAP; is via nice monomorphisms.

For this mechanism to work, of course there must be effective methods to evaluate the value on elements and to take preimages under it. As by definition no good algorithms exist for the source group, normally this can only be achieved by using the the result of a call to or (see also section ). <#Include Label="IsHandledByNiceMonomorphism"> <#Include Label="NiceMonomorphism"> <#Include Label="NiceObject"> <#Include Label="IsCanonicalNiceMonomorphism">

Group Automorphisms Group automorphisms are bijective homomorphism from a group onto itself. An important subclass are automorphisms which are induced by conjugation of the group itself or a supergroup. <#Include Label="ConjugatorIsomorphism"> <#Include Label="ConjugatorAutomorphism"> <#Include Label="InnerAutomorphism"> <#Include Label="IsConjugatorIsomorphism"> <#Include Label="ConjugatorOfConjugatorIsomorphism">
Groups of Automorphisms Group automorphism can be multiplied and inverted and thus it is possible to form groups of automorphisms. <#Include Label="AutomorphismGroup"> <#Include Label="IsGroupOfAutomorphisms"> <#Include Label="AutomorphismDomain"> <#Include Label="IsAutomorphismGroup"> <#Include Label="InnerAutomorphismsAutomorphismGroup"> <#Include Label="InducedAutomorphism">
Calculating with Group Automorphisms Usually the best way to calculate in a group of automorphisms is to translate all calculations to an isomorphic group in a representation, for which better algorithms are available, say a permutation group. This translation can be done automatically using .

Once a group knows to be a group of automorphisms (this can be achieved by testing or setting the property ), &GAP; will try itself to find such a nice monomorphism once calculations in the automorphism group are done.

Note that nice homomorphisms inherit down to subgroups, but cannot necessarily be extended from a subgroup to the whole group. Thus when working with a group of automorphisms, it can be beneficial to enforce calculation of the nice monomorphism for the whole group (for example by explicitly calling and ignoring the result –it will be stored internally) at the start of the calculation. Otherwise &GAP; might first calculate a nice monomorphism for the subgroup, only to be forced to calculate a new nice monomorphism for the whole group later on.

If a good domain for a faithful permutation action is known already, a homomorphism for the action on it can be created using . It might be stored by SetNiceMonomorphism (see ).

Another nice way of representing automorphisms as permutations has been described in . It is not yet available in &GAP;, a description however can be found in section  . <#Include Label="AssignNiceMonomorphismAutomorphismGroup"> <#Include Label="NiceMonomorphismAutomGroup">

Searching for Homomorphisms homomorphisms <#Include Label="IsomorphismGroups"> <#Include Label="AllHomomorphismClasses"> <#Include Label="AllHomomorphisms"> <#Include Label="GQuotients"> <#Include Label="IsomorphicSubgroups"> <#Include Label="MorClassLoop">
Representations for Group Homomorphisms The different representations of group homomorphisms are used to indicate from what type of group to what type of group they map and thus determine which methods are used to compute images and preimages.

The information in this section is mainly relevant for implementing new methods and not for using homomorphisms. <#Include Label="IsGroupGeneralMappingByImages"> <#Include Label="MappingGeneratorsImages"> <#Include Label="IsGroupGeneralMappingByAsGroupGeneralMappingByImages"> <#Include Label="IsPreimagesByAsGroupGeneralMappingByImages"> <#Include Label="IsPermGroupGeneralMapping"> <#Include Label="IsToPermGroupGeneralMappingByImages"> <#Include Label="IsGroupGeneralMappingByPcgs"> <#Include Label="IsPcGroupGeneralMappingByImages"> <#Include Label="IsToPcGroupGeneralMappingByImages"> <#Include Label="IsFromFpGroupGeneralMappingByImages"> <#Include Label="IsFromFpGroupStdGensGeneralMappingByImages">

gap-4r6p5/doc/ref/makedocrel-new.g0000644000175000017500000000212012172557252015522 0ustar billbill## this creates the documentation, needs: ## GAPDoc package, latex, pdflatex, mkindex ## LoadPackage( "GAPDoc" ); Reread ("../conv/MakeLaTeX.gi"); Reread ("../conv/MakeHTML.gi"); Reread ("../conv/MakeText.gi"); Reread ("../conv/MakeBWText.gi"); Read ("../conv/BuildManual.g"); LoadPackage( "ctbllib" ); LoadPackage( "Browse" ); Read( "makedocreldata.g" ); Exec( "ln -s -f ../conv/manual.css manual.css" ); Exec( "ln -s -f ../conv/java.css java.css" ); Exec( "ln -s -f ../conv/toggle.js toggle.js" ); Exec( "ln -s -f ../conv/open.png open.png" ); Exec( "ln -s -f ../conv/closed.png closed.png" ); Exec( "ln -s -f ../conv/empty.png empty.png" ); if not IsDirectoryPath ("textmarkup") then Exec ("mkdir textmarkup"); fi; BuildManuals (rec( bookname := GAPInfo.ManualDataRef.bookname, pathtodoc := GAPInfo.ManualDataRef.pathtodoc, main := GAPInfo.ManualDataRef.main, pathtoroot := GAPInfo.ManualDataRef.pathtoroot, files := GAPInfo.ManualDataRef.files, htmlspecial := ["MathJax"])); ############################################################################# ## #E gap-4r6p5/doc/ref/xtndxmpl.xml0000644000175000017500000015735712172557252015104 0ustar billbill An Example – Residue Class Rings In this chapter, we give an example how &GAP; can be extended by new data structures and new functionality. In order to focus on the issues of the implementation, the mathematics in the example chosen is trivial. Namely, we will discuss computations with elements of residue class rings &ZZ; / n&ZZ;.

The first attempt is straightforward (see Section ), it deals with the implementation of the necessary arithmetic operations. Section  deals with the question why it might be useful to use an approach that involves creating a new data structure and integrating the algorithms dealing with these new &GAP; objects into the system. Section  shows how this can be done in our example, and Section , the question of further compatibility of the new objects with known &GAP; objects is discussed. Finally, Section  gives some hints how to improve the implementation presented before.

A First Attempt to Implement Elements of Residue Class Rings Suppose we want to do computations with elements of a ring &ZZ; / n&ZZ;, where n is a positive integer.

First we have to decide how to represent the element k + n&ZZ; in &GAP;. If the modulus n is fixed then we can use the integer k. More precisely, we can use any integer k' such that k - k' is a multiple of n. If different moduli are likely to occur then using a list of the form [ k, n ], or a record of the form rec( residue := k, modulus := n ) is more appropriate. In the following, let us assume the list representation [ k, n ] is chosen. Moreover, we decide that the residue k in all such lists satisfies 0 \leq k < n, i.e., the result of adding two residue classes represented by [ k_1, n ] and [ k_2, n ] (of course with same modulus n) will be [ k, n ] with k_1 + k_2 congruent to k modulo n and 0 \leq k < n.

Now we can implement the arithmetic operations for residue classes. Note that the result of the mod operator is normalized as required. The division by a noninvertible residue class results in fail.

resclass_sum := function( c1, c2 ) > if c1[2] <> c2[2] then Error( "different moduli" ); fi; > return [ ( c1[1] + c2[1] ) mod c1[2], c1[2] ]; > end;; gap> gap> resclass_diff := function( c1, c2 ) > if c1[2] <> c2[2] then Error( "different moduli" ); fi; > return [ ( c1[1] - c2[1] ) mod c1[2], c1[2] ]; > end;; gap> gap> resclass_prod := function( c1, c2 ) > if c1[2] <> c2[2] then Error( "different moduli" ); fi; > return [ ( c1[1] * c2[1] ) mod c1[2], c1[2] ]; > end;; gap> gap> resclass_quo := function( c1, c2 ) > local quo; > if c1[2] <> c2[2] then Error( "different moduli" ); fi; > quo:= QuotientMod( c1[1], c2[1], c1[2] ); > if quo <> fail then > quo:= [ quo, c1[2] ]; > fi; > return quo; > end;; ]]>

With these functions, we can in principle compute with residue classes.

list:= List( [ 0 .. 3 ], k -> [ k, 4 ] ); [ [ 0, 4 ], [ 1, 4 ], [ 2, 4 ], [ 3, 4 ] ] gap> resclass_sum( list[2], list[4] ); [ 0, 4 ] gap> resclass_diff( list[1], list[2] ); [ 3, 4 ] gap> resclass_prod( list[2], list[4] ); [ 3, 4 ] gap> resclass_prod( list[3], list[4] ); [ 2, 4 ] gap> List( list, x -> resclass_quo( list[2], x ) ); [ fail, [ 1, 4 ], fail, [ 3, 4 ] ] ]]>

Why Proceed in a Different Way? It depends on the computations we intended to do with residue classes whether or not the implementation described in the previous section is satisfactory for us.

Probably we are mainly interested in more complex data structures than the residue classes themselves, for example in matrix algebras or matrix groups over a ring such as &ZZ; / 4&ZZ;. For this, we need functions to add, multiply, invert etc. matrices of residue classes. Of course this is not a difficult task, but it requires to write additional &GAP; code.

And when we have implemented the arithmetic operations for matrices of residue classes, we might be interested in domain operations such as computing the order of a matrix group over &ZZ; / 4&ZZ;, a Sylow 2 subgroup, and so on. The problem is that a residue class represented as a pair [ k, n ] is not regarded as a group element by &GAP;. We have not yet discussed how a matrix of residue classes shall be represented, but if we choose the obvious representation of a list of lists of our residue classes then also this is not a valid group element in &GAP;. Hence we cannot apply the function to create a group of residue classes or a group of matrices of residue classes. This is because &GAP; assumes that group elements can be multiplied via the infix operator * (equivalently, via the operation ). Note that in fact the multiplication of two lists [ k_1, n ], [ k_2, n ] is defined, but we have [ k_1, n ] * [ k_2, n ] = k_1 * k_2 + n * n, the standard scalar product of two row vectors of same length. That is, the multiplication with * is not compatible with the function resclass_prod introduced in the previous section. Similarly, ring elements are assumed to be added via the infix operator +; the addition of residue classes is not compatible with the available addition of row vectors.

What we have done in the previous section can be described as implementation of a standalone arithmetic for residue classes. In order to use the machinery of the &GAP; library for creating higher level objects such as matrices, polynomials, or domains over residue class rings, we have to integrate this implementation into the &GAP; library. The key step will be to create a new kind of &GAP; objects. This will be done in the following sections; there we assume that residue classes and residue class rings are not yet available in &GAP;; in fact they are available, and their implementation is very close to what is described here.

A Second Attempt to Implement Elements of Residue Class Rings Faced with the problem to implement elements of the rings &ZZ; / n&ZZ;, we must define the types of these elements as far as is necessary to distinguish them from other &GAP; objects.

As is described in Chapter , the type of an object comprises several aspects of information about this object; the family determines the relation of the object to other objects, the categories determine what operations the object admits, the representation determines how an object is actually represented, and the attributes describe knowledge about the object.

First of all, we must decide about the family of each residue class. A natural way to do this is to put the elements of each ring &ZZ; / n&ZZ; into a family of their own. This means that for example elements of &ZZ; / 3&ZZ; and &ZZ; / 9&ZZ; lie in different families. So the only interesting relation between the families of two residue classes is equality; binary arithmetic operations with two residue classes will be admissible only if their families are equal. Note that in the naive approach in Section , we had to take care of different moduli by a check in each function; these checks may disappear in the new approach because of our choice of families.

Note that we do not need to tell &GAP; anything about the above decision concerning the families of the objects that we are going to implement, that is, the declaration part (see ) of the little &GAP; package we are writing contains nothing about the distribution of the new objects into families. (The actual construction of a family happens in the function MyZmodnZ shown below.)

Second, we want to describe methods to add or multiply two elements in &ZZ; / n&ZZ;, and these methods shall be not applicable to other &GAP; objects. The natural way to do this is to create a new category in which all elements of all rings &ZZ; / n&ZZ; lie. This is done as follows.

DeclareCategory( "IsMyZmodnZObj", IsScalar ); gap> cat:= CategoryCollections( IsMyZmodnZObj );; gap> cat:= CategoryCollections( cat );; gap> cat:= CategoryCollections( cat );; ]]>

So all elements in the rings &ZZ; / n&ZZ; will lie in the category IsMyZmodnZObj, which is a subcategory of . The latter means that one can add, subtract, multiply and divide two such elements that lie in the same family, with the obvious restriction that the second operand of a division must be invertible. (The name IsMyZmodnZObj is chosen because is already defined in &GAP;, for an implementation of residue classes that is very similar to the one developed in this manual chapter. Using this different name, one can simply enter the &GAP; code of this chapter into a &GAP; session, either interactively or by reading a file with this code, and experiment after each step whether the expected behaviour has been achieved, and what is still missing.)

The next lines of &GAP; code above create the categories CategoryCollections( IsMyZmodnZObj ) and two higher levels of collections categories of this, which will be needed later; it is important to create these categories before collections of the objects in IsMyZmodnZObj actually arise.

Note that the only difference between and is that in a call to , a variable corresponding to the first argument is set to the new category, and this variable is read-only (see ). The same holds for and etc.

There is no analogue of categories in the implementation in Section , since there it was not necessary to distinguish residue classes from other &GAP; objects. Note that the functions there assumed that their arguments were residue classes, and the user was responsible not to call them with other arguments. Thus an important aspect of types is to describe arguments of functions explicitly.

Third, we must decide about the representation of our objects. This is something we know already from Section , where we chose a list of length two. Here we may choose between two essentially different representations for the new &GAP; objects, namely as component object (record-like) or positional object (list-like). We decide to store the modulus of each residue class in its family, and to encode the element k + n&ZZ; by the unique residue in the range [ 0 .. n-1 ] that is congruent to k modulo n, and the object itself is chosen to be a positional object with this residue at the first and only position (see ).

DeclareRepresentation("IsMyModulusRep", IsPositionalObjectRep, [1]); ]]>

The fourth ingredients of a type, attributes, are usually of minor importance for element objects. In particular, we do not need to introduce special attributes for residue classes.

Having defined what the new objects shall look like, we now declare a global function (see ), to create an element when family and residue are given.

DeclareGlobalFunction( "MyZmodnZObj" ); ]]>

Now we have declared what we need, and we can start to implement the missing methods resp. functions; so the following command belongs to the implementation part of our package (see ).

The probably most interesting function is the one to construct a residue class.

InstallGlobalFunction( MyZmodnZObj, function( Fam, residue ) > return Objectify( NewType( Fam, IsMyZmodnZObj and IsMyModulusRep ), > [ residue mod Fam!.modulus ] ); > end ); ]]>

Note that we normalize residue explicitly using mod; we assumed that the modulus is stored in Fam, so we must take care of this below. If Fam is a family of residue classes, and residue is an integer, MyZmodnZObj returns the corresponding object in the family Fam, which lies in the category IsMyZmodnZObj and in the representation IsMyModulusRep.

MyZmodnZObj needs an appropriate family as first argument, so let us see how to get our hands on this. Of course we could write a handy function to create such a family for given modulus, but we choose another way. In fact we do not really want to call MyZmodnZObj explicitly when we want to create residue classes. For example, if we want to enter a matrix of residues then usually we start with a matrix of corresponding integers, and it is more elegant to do the conversion via multiplying the matrix with the identity of the required ring &ZZ; / n&ZZ;; this is also done for the conversion of integral matrices to finite field matrices. (Note that we will have to install a method for this.) So it is often sufficient to access this identity, for example via One( MyZmodnZ( n ) ), where MyZmodnZ returns a domain representing the ring &ZZ; / n&ZZ; when called with the argument n. We decide that constructing this ring is a natural place where the creation of the family can be hidden, and implement the function. (Note that the declaration belongs to the declaration part, and the installation belongs to the implementation part, see ).

DeclareGlobalFunction( "MyZmodnZ" ); gap> gap> InstallGlobalFunction( MyZmodnZ, function( n ) > local F, R; > > if not IsPosInt( n ) then > Error( " must be a positive integer" ); > fi; > > # Construct the family of element objects of our ring. > F:= NewFamily( Concatenation( "MyZmod", String( n ), "Z" ), > IsMyZmodnZObj ); > > # Install the data. > F!.modulus:= n; > > # Make the domain. > R:= RingWithOneByGenerators( [ MyZmodnZObj( F, 1 ) ] ); > SetIsWholeFamily( R, true ); > SetName( R, Concatenation( "(Integers mod ", String(n), ")" ) ); > > # Return the ring. > return R; > end ); ]]>

Note that the modulus n is stored in the component modulus of the family, as is assumed by MyZmodnZ. Thus it is not necessary to store the modulus in each element. When storing n with the !. operator as value of the component modulus, we used that all families are in fact represented as component objects (see ).

We see that we can use to construct a ring with one if we have the appropriate generators. The construction via makes sure that (and ) is true for each output of MyZmodnZ. So the main problem is to create the identity element of the ring, which in our case suffices to generate the ring. In order to create this element via MyZmodnZObj, we have to construct its family first, at each call of MyZmodnZ.

Also note that we may enter known information about the ring. Here we store that it contains the whole family of elements; this is useful for example when we want to check the membership of an element in the ring, which can be decided from the type of the element if the ring contains its whole elements family. Giving a name to the ring causes that it will be printed via printing the name. (By the way: This name (Integers mod n) looks like a call to with the arguments and n; a construction of the ring via this call seems to be more natural than by calling MyZmodnZ; later we shall install a method in order to admit this construction.)

Now we can read the above code into &GAP;, and the following works already.

R:= MyZmodnZ( 4 ); (Integers mod 4) gap> IsRing( R ); true gap> gens:= GeneratorsOfRingWithOne( R ); [ ] ]]>

But of course this means just to ask for the information we have explicitly stored in the ring. Already the questions whether the ring is finite and how many elements it has, cannot be answered by &GAP;. Clearly we know the answers, and we could store them in the ring, by setting the value of the property to true and the value of the attribute to n (the argument of the call to MyZmodnZ). If we do not want to do so then &GAP; could only try to find out the number of elements of the ring via forming the closure of the generators under addition and multiplication, but up to now, &GAP; does not know how to add or multiply two elements of our ring.

So we must install some methods for arithmetic and other operations if the elements are to behave as we want.

We start with a method for showing elements nicely on the screen. There are different operations for this purpose. One of them is , which is called for each argument in an explicit call to . Another one is , which is called in the read-eval-print loop for each object. shall produce short and human readable information about the object in question, whereas shall produce information that may be longer and is (if reasonable) readable by &GAP;. We cannot satisfy the latter requirement for a method because there is no way to make a family &GAP; readable. So we decide to display the expression ( k mod n ) for an object that is given by the residue k and the modulus n, which would be fine as a method. Since the default for is to call , and since no other method is applicable to our elements, we need only a method.

InstallMethod( PrintObj, > "for element in Z/nZ (ModulusRep)", > [ IsMyZmodnZObj and IsMyModulusRep ], > function( x ) > Print( "( ", x![1], " mod ", FamilyObj(x)!.modulus, " )" ); > end ); ]]>

So we installed a method for the operation (first argument), and we gave it a suitable information message (second argument), see  and  for applications of this information string. The third argument tells &GAP; that the method is applicable for objects that lie in the category IsMyZmodnZObj and in the representation IsMyModulusRep. and the fourth argument is the method itself. More details about can be found in .

Note that the requirement IsMyModulusRep for the argument x allows us to access the residue as x![1]. Since the family of x has the component modulus bound if it is constructed by MyZmodnZ, we may access this component. We check whether the method installation has some effect.

gens; [ ( 1 mod 4 ) ] ]]>

Next we install methods for the comparison operations. Note that we can assume that the residues in the representation chosen are normalized.

InstallMethod( \=, > "for two elements in Z/nZ (ModulusRep)", > IsIdenticalObj, > [IsMyZmodnZObj and IsMyModulusRep, IsMyZmodnZObj and IsMyModulusRep], > function( x, y ) return x![1] = y![1]; end ); gap> gap> InstallMethod( \<, > "for two elements in Z/nZ (ModulusRep)", > IsIdenticalObj, > [IsMyZmodnZObj and IsMyModulusRep, IsMyZmodnZObj and IsMyModulusRep], > function( x, y ) return x![1] < y![1]; end ); ]]>

The third argument used in these installations specifies the required relation between the families of the arguments (see ). This argument of a method installation, if present, is a function that shall be applied to the families of the arguments. means that the methods are applicable only if both arguments lie in the same family. (In installations for unary methods, obviously no relation is required, so this argument is left out there.)

Up to now, we see no advantage of the new approach over the one in Section . For a residue class represented as [ k, n ], the way it is printed on the screen is sufficient, and equality and comparison of lists are good enough to define equality and comparison of residue classes if needed. But this is not the case in other situations. For example, if we would have decided that the residue k need not be normalized then we would have needed functions in Section  that compute whether two residue classes are equal, and which of two residue classes is regarded as larger than another. Note that we are free to define what larger means for objects that are newly introduced.

Next we install methods for the arithmetic operations, first for the additive structure.

InstallMethod( \+, > "for two elements in Z/nZ (ModulusRep)", > IsIdenticalObj, > [IsMyZmodnZObj and IsMyModulusRep, IsMyZmodnZObj and IsMyModulusRep], > function( x, y ) > return MyZmodnZObj( FamilyObj( x ), x![1] + y![1] ); > end ); gap> gap> InstallMethod( ZeroOp, > "for element in Z/nZ (ModulusRep)", > [ IsMyZmodnZObj ], > x -> MyZmodnZObj( FamilyObj( x ), 0 ) ); gap> gap> InstallMethod( AdditiveInverseOp, > "for element in Z/nZ (ModulusRep)", > [ IsMyZmodnZObj and IsMyModulusRep ], > x -> MyZmodnZObj( FamilyObj( x ), AdditiveInverse( x![1] ) ) ); ]]>

Here the new approach starts to pay off. The method for the operation allows us to use the infix operator + for residue classes. The method for is used when we call this operation or the attribute explicitly, and it is also used when we ask for 0 * rescl, where rescl is a residue class.

(Note that and are distinguished because 0 * obj is guaranteed to return a mutable result whenever a mutable version of this result exists in &GAP; –for example if obj is a matrix– whereas is an attribute and therefore returns immutable results; for our example there is no difference since the residue classes are always immutable, nevertheless we have to install the method for . The same holds for , , and .)

Similarly, can be either called directly or via the unary - operator; so we can compute the additive inverse of the residue class rescl as -rescl.

It is not necessary to install methods for subtraction, since this is handled via addition of the additive inverse of the second argument if no other method is installed.

Let us try what we can do with the methods that are available now.

x:= gens[1]; y:= x + x; ( 1 mod 4 ) ( 2 mod 4 ) gap> 0 * x; -x; ( 0 mod 4 ) ( 3 mod 4 ) gap> y = -y; x = y; x < y; -x < y; true false true false ]]>

We might want to admit the addition of integers and elements in rings &ZZ; / n&ZZ;, where an integer is implicitly identified with its residue modulo n. To achieve this, we install methods to add an integer to an object in IsMyZmodnZObj from the left and from the right.

InstallMethod( \+, > "for element in Z/nZ (ModulusRep) and integer", > [ IsMyZmodnZObj and IsMyModulusRep, IsInt ], > function( x, y ) > return MyZmodnZObj( FamilyObj( x ), x![1] + y ); > end ); gap> gap> InstallMethod( \+, > "for integer and element in Z/nZ (ModulusRep)", > [ IsInt, IsMyZmodnZObj and IsMyModulusRep ], > function( x, y ) > return MyZmodnZObj( FamilyObj( y ), x + y![1] ); > end ); ]]>

Now we can do also the following.

2 + x; 7 - x; y - 2; ( 3 mod 4 ) ( 2 mod 4 ) ( 0 mod 4 ) ]]>

Similarly we install the methods dealing with the multiplicative structure. We need methods to multiply two of our objects, and to compute identity and inverse. The operation is called when we ask for rescl^0, and is called when we ask for rescl^-1. Note that the method for returns fail if the argument is not invertible.

InstallMethod( \*, > "for two elements in Z/nZ (ModulusRep)", > IsIdenticalObj, > [IsMyZmodnZObj and IsMyModulusRep, IsMyZmodnZObj and IsMyModulusRep], > function( x, y ) > return MyZmodnZObj( FamilyObj( x ), x![1] * y![1] ); > end ); gap> gap> InstallMethod( OneOp, > "for element in Z/nZ (ModulusRep)", > [ IsMyZmodnZObj ], > elm -> MyZmodnZObj( FamilyObj( elm ), 1 ) ); gap> gap> InstallMethod( InverseOp, > "for element in Z/nZ (ModulusRep)", > [ IsMyZmodnZObj and IsMyModulusRep ], > function( elm ) > local residue; > residue:= QuotientMod( 1, elm![1], FamilyObj( elm )!.modulus ); > if residue <> fail then > residue:= MyZmodnZObj( FamilyObj( elm ), residue ); > fi; > return residue; > end ); ]]>

To be able to multiply our objects with integers, we need not (but we may, and we should if we are going for efficiency) install special methods. This is because in general, &GAP; interprets the multiplication of an integer and an additive object as abbreviation of successive additions, and there is one generic method for such a multiplication that uses only additions and –in the case of a negative integer– taking the additive inverse. Analogously, there is a generic method for powering by integers that uses only multiplications and taking the multiplicative inverse.

Note that we could also interpret the multiplication with an integer as a shorthand for the multiplication with the corresponding residue class. We are lucky that this interpretation is compatible with the one that is already available. If this would not be the case then of course we would get into trouble by installing a concurrent multiplication that computes something different from the multiplication that is already defined, since &GAP; does not guarantee which of the applicable methods is actually chosen (see ).

Now we have implemented methods for the arithmetic operations for our elements, and the following calculations work.

y:= 2 * x; z:= (-5) * x; ( 2 mod 4 ) ( 3 mod 4 ) gap> y * z; y * y; ( 2 mod 4 ) ( 0 mod 4 ) gap> y^-1; y^0; fail ( 1 mod 4 ) gap> z^-1; ( 3 mod 4 ) ]]>

There are some other operations in &GAP; that we may want to accept our elements as arguments. An example is the operation that returns, e.g., the integral part of a rational number or the integer corresponding to an element in a finite prime field. For our objects, we may define that returns the normalized residue.

Note that we define this behaviour for elements but we implement it for objects in the representation IsMyModulusRep. This means that if someone implements another representation of residue classes then this person must be careful to implement methods for objects in this new representation compatibly with our definition, i.e., such that the result is independent of the representation.

InstallMethod( Int, > "for element in Z/nZ (ModulusRep)", > [ IsMyZmodnZObj and IsMyModulusRep ], > z -> z![1] ); ]]>

Another example of an operation for which we might want to install a method is . We make the ring print itself as mod the modulus, and then it is reasonable to allow a construction this way, which makes the output of the ring &GAP; readable.

InstallMethod( PrintObj, > "for full collection Z/nZ", > [ CategoryCollections( IsMyZmodnZObj ) and IsWholeFamily ], > function( R ) > Print( "(Integers mod ", > ElementsFamily( FamilyObj(R) )!.modulus, ")" ); > end ); gap> gap> InstallMethod( \mod, > "for `Integers', and a positive integer", > [ IsIntegers, IsPosRat and IsInt ], > function( Integers, n ) return MyZmodnZ( n ); end ); ]]>

Let us try this.

Int( y ); 2 gap> Integers mod 1789; (Integers mod 1789) ]]>

Probably it is not necessary to emphasize that with the approach of Section , installing methods for existing operations is usually not possible or at least not recommended. For example, installing the function resclass_sum defined in Section  as a method for adding two lists of length two (with integer entries) would not be compatible with the general definition of the addition of two lists of same length. Installing a method for the operation that takes a list [ k, n ] and returns k would in principle be possible, since there is no method for lists yet, but it is not sensible to do so because one can think of other interpretations of such a list where different methods could be installed with the same right.

As mentioned in Section , one advantage of the new approach is that with the implementation we have up to now, automatically also matrices of residue classes can be treated.

r:= Integers mod 16; (Integers mod 16) gap> x:= One( r ); ( 1 mod 16 ) gap> mat:= IdentityMat( 2 ) * x; [ [ ( 1 mod 16 ), ( 0 mod 16 ) ], [ ( 0 mod 16 ), ( 1 mod 16 ) ] ] gap> mat[1][2]:= x;; gap> mat; [ [ ( 1 mod 16 ), ( 1 mod 16 ) ], [ ( 0 mod 16 ), ( 1 mod 16 ) ] ] gap> Order( mat ); 16 gap> mat + mat; [ [ ( 2 mod 16 ), ( 2 mod 16 ) ], [ ( 0 mod 16 ), ( 2 mod 16 ) ] ] gap> last^4; [ [ ( 0 mod 16 ), ( 0 mod 16 ) ], [ ( 0 mod 16 ), ( 0 mod 16 ) ] ] ]]>

Such matrices, if they are invertible, are valid as group elements. One technical problem is that the default algorithm for inverting matrices may give up since Gaussian elimination need not be successful over rings containing zero divisors. Therefore we install a simpleminded inversion method that inverts an integer matrix.

InstallMethod( InverseOp, > "for an ordinary matrix over a ring Z/nZ", > [ IsMatrix and IsOrdinaryMatrix > and CategoryCollections( CategoryCollections( IsMyZmodnZObj ) ) ], > function( mat ) > local one, modulus; > > one:= One( mat[1][1] ); > modulus:= FamilyObj( one )!.modulus; > mat:= InverseOp( List( mat, row -> List( row, Int ) ) ); > if mat <> fail then > mat:= ( mat mod modulus ) * one; > fi; > if not IsMatrix( mat ) then > mat:= fail; > fi; > return mat; > end ); ]]>

Additionally we install a method for finding a domain that contains the matrix entries; this is used by some &GAP; library functions.

InstallMethod( DefaultFieldOfMatrixGroup, > "for a matrix group over a ring Z/nZ", > [ IsMatrixGroup and CategoryCollections( CategoryCollections( > CategoryCollections( IsMyZmodnZObj ) ) ) ], > G -> RingWithOneByGenerators([ One( Representative( G )[1][1] ) ])); ]]>

Now we can deal with matrix groups over residue class rings.

mat2:= IdentityMat( 2 ) * x;; gap> mat2[2][1]:= x;; gap> g:= Group( mat, mat2 );; gap> Size( g ); 3072 gap> Factors( last ); [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3 ] gap> syl3:= SylowSubgroup( g, 3 );; gap> gens:= GeneratorsOfGroup( syl3 ); [ [ [ ( 1 mod 16 ), ( 7 mod 16 ) ], [ ( 11 mod 16 ), ( 14 mod 16 ) ] ] ] gap> Order( gens[1] ); 3 ]]>

It should be noted that this way more involved methods for matrix groups may not be available. For example, many questions about a finite matrix group can be delegated to an isomorphic permutation group via a so-called nice monomorphism; this can be controlled by the filter .

By the way, also groups of (invertible) residue classes can be formed, but this may be of minor interest. g:= Group( x );; Size( g ); #I default `IsGeneratorsOfMagmaWithInverses' method returns `true' for [ ( 1 mod 16 ) ] 1 gap> g:= Group( 3*x );; Size( g ); #I default `IsGeneratorsOfMagmaWithInverses' method returns `true' for [ ( 3 mod 16 ) ] 4 ]]>

(The messages above tell that &GAP; does not know a method for deciding whether the given elements are valid group elements. We could add an appropriate IsGeneratorsOfMagmaWithInverses method if we would want.)

Having done enough for the elements, we may install some more methods for the rings if we want to use them as arguments. These rings are finite, and there are many generic methods that will work if they are able to compute the list of elements of the ring, so we install a method for this.

InstallMethod( Enumerator, > "for full collection Z/nZ", > [ CategoryCollections( IsMyZmodnZObj ) and IsWholeFamily ], > function( R ) > local F; > F:= ElementsFamily( FamilyObj(R) ); > return List( [ 0 .. Size( R ) - 1 ], x -> MyZmodnZObj( F, x ) ); > end ); ]]>

Note that this method is applicable only to full rings &ZZ; / n&ZZ;, for proper subrings it would return a wrong result. Furthermore, it is not required that the argument is a ring; in fact this method is applicable also to the additive group formed by all elements in the family, provided that it knows to contain the whole family.

Analogously, we install methods to compute the size, a random element, and the units of full rings &ZZ; / n&ZZ;.

InstallMethod( Random, > "for full collection Z/nZ", > [ CategoryCollections( IsMyZmodnZObj ) and IsWholeFamily ], > R -> MyZmodnZObj( ElementsFamily( FamilyObj(R) ), > Random( [ 0 .. Size( R ) - 1 ] ) ) ); gap> gap> InstallMethod( Size, > "for full ring Z/nZ", > [ CategoryCollections( IsMyZmodnZObj ) and IsWholeFamily ], > R -> ElementsFamily( FamilyObj(R) )!.modulus ); gap> gap> InstallMethod( Units, > "for full ring Z/nZ", > [ CategoryCollections( IsMyZmodnZObj ) > and IsWholeFamily and IsRing ], > function( R ) > local F; > F:= ElementsFamily( FamilyObj( R ) ); > return List( PrimeResidues( Size(R) ), x -> MyZmodnZObj( F, x ) ); > end ); ]]>

The method has the disadvantage that the result is returned as a list (in fact this list is also strictly sorted). We could improve the implementation by returning the units as a group; if we do not want to take the full list of elements as generators, we can use the function .

InstallMethod( Units, > "for full ring Z/nZ", > [ CategoryCollections( IsMyZmodnZObj ) > and IsWholeFamily and IsRing ], > function( R ) > local G, gens; > > gens:= GeneratorsPrimeResidues( Size( R ) ).generators; > if not IsEmpty( gens ) and gens[ 1 ] = 1 then > gens:= gens{ [ 2 .. Length( gens ) ] }; > fi; > gens:= Flat( gens ) * One( R ); > return GroupByGenerators( gens, One( R ) ); > end ); ]]>

Each ring &ZZ; / n&ZZ; is finite, and we could install a method that returns true when is called with &ZZ; / n&ZZ; as argument. But we can do this more elegantly via installing a logical implication.

InstallTrueMethod( IsFinite, > CategoryCollections( IsMyZmodnZObj ) and IsDomain ); ]]>

In effect, every domain that consists of elements in IsMyZmodnZObj will automatically store that it is finite, even if is not called for it.

Compatibility of Residue Class Rings with Prime Fields The above implementation of residue classes and residue class rings has at least two disadvantages. First, if p is a prime then the ring &ZZ; / p&ZZ; is in fact a field, but the return values of MyZmodnZ are never regarded as fields because they are not in the category . Second, and this makes the example really interesting, there are already elements of finite prime fields implemented in &GAP;, and we may want to identify them with elements in &ZZ; / p&ZZ;.

To be more precise, elements of finite fields in &GAP; lie in the category , and there is already a representation, IsInternalRep, of these elements via discrete logarithms. The aim of this section is to make IsMyModulusRep an alternative representation of elements in finite prime fields.

Note that this is only one step towards the desired compatibility. Namely, after having a second representation of elements in finite prime fields, we may wish that the function (which is the usual function to create finite fields in &GAP;) is able to return MyZmodnZ( p ) when GF( p ) is called for a prime p. Moreover, then we have to decide about a default representation of elements in GF( p ) for primes p for which both representations are available. Of course we can force the new representation by explicitly calling MyZmodnZ and MyZmodnZObj whenever we want, but it is not a priori clear in which situation which representation is preferable.

The same questions will occur when we want to implement a new representation for non-prime fields. The steps of this implementation will be the same as described in this chapter, and we will have to achieve compatibility with both the internal representation of elements in small finite fields and the representation IsMyModulusRep of elements in arbitrary prime fields.

But let us now turn back to the task of this section. We first adjust the setup of the declaration part of the previous section, and then repeat the installations with suitable modifications.

(We should start a new &GAP; session for that, otherwise &GAP; will complain that the objects to be declared are already bound; additionally, the methods installed above may be not compatible with the ones we want.)

DeclareCategory( "IsMyZmodnZObj", IsScalar ); gap> gap> DeclareCategory( "IsMyZmodnZObjNonprime", IsMyZmodnZObj ); gap> gap> DeclareSynonym( "IsMyZmodpZObj", IsMyZmodnZObj and IsFFE ); gap> gap> DeclareRepresentation( "IsMyModulusRep", IsPositionalObjectRep, [ 1 ] ); gap> gap> DeclareGlobalFunction( "MyZmodnZObj" ); gap> gap> DeclareGlobalFunction( "MyZmodnZ" ); ]]>

As in the previous section, all (newly introduced) elements of rings &ZZ; / n&ZZ; lie in the category IsMyZmodnZObj. But now we introduce two subcategories, namely IsMyZmodnZObjNonprime for all elements in rings &ZZ; / n&ZZ; where n is not a prime, and IsMyZmodpZObj for elements in finite prime fields. All objects in the latter are automatically known to lie in the category of finite field elements.

It would be reasonable if also those internally represented elements in the category that do in fact lie in a prime field would also lie in the category IsMyZmodnZObj (and thus in fact in IsMyZmodpZObj). But this cannot be achieved because internally represented finite field elements do in general not store whether they lie in a prime field.

As for the implementation part, again let us start with the definitions of MyZmodnZObj and MyZmodnZ.

InstallGlobalFunction( MyZmodnZObj, function( Fam, residue ) > if IsFFEFamily( Fam ) then > return Objectify( NewType( Fam, IsMyZmodpZObj > and IsMyModulusRep ), > [ residue mod Characteristic( Fam ) ] ); > else > return Objectify( NewType( Fam, IsMyZmodnZObjNonprime > and IsMyModulusRep ), > [ residue mod Fam!.modulus ] ); > fi; > end ); gap> InstallGlobalFunction( MyZmodnZ, function( n ) > local F, R; > > if not ( IsInt( n ) and IsPosRat( n ) ) then > Error( " must be a positive integer" ); > elif IsPrimeInt( n ) then > # Construct the family of element objects of our field. > F:= FFEFamily( n ); > # Make the domain. > R:= FieldOverItselfByGenerators( [ MyZmodnZObj( F, 1 ) ] ); > SetIsPrimeField( R, true ); > else > # Construct the family of element objects of our ring. > F:= NewFamily( Concatenation( "MyZmod", String( n ), "Z" ), > IsMyZmodnZObjNonprime ); > # Install the data. > F!.modulus:= n; > # Make the domain. > R:= RingWithOneByGenerators( [ MyZmodnZObj( F, 1 ) ] ); > SetIsWholeFamily( R, true ); > SetName( R, Concatenation( "(Integers mod ",String(n),")" ) ); > fi; > > # Return the ring resp. field. > return R; > end ); ]]>

Note that the result of MyZmodnZ with a prime as argument is a field that does not contain the whole family of its elements, since all finite field elements of a fixed characteristic lie in the same family. Further note that we cannot expect a family of finite field elements to have a component modulus, so we use to get the modulus. Requiring that Fam!.modulus works also if Fam is a family of finite field elements would violate the rule that an extension of &GAP; should not force changes in existing code, in this case code dealing with families of finite field elements.

InstallMethod( PrintObj, > "for element in Z/nZ (ModulusRep)", > [ IsMyZmodnZObjNonprime and IsMyModulusRep ], > function( x ) > Print( "( ", x![1], " mod ", FamilyObj(x)!.modulus, " )" ); > end ); gap> gap> InstallMethod( PrintObj, > "for element in Z/pZ (ModulusRep)", > [ IsMyZmodpZObj and IsMyModulusRep ], > function( x ) > Print( "( ", x![1], " mod ", Characteristic(x), " )" ); > end ); gap> gap> InstallMethod( \=, > "for two elements in Z/nZ (ModulusRep)", > IsIdenticalObj, > [ IsMyZmodnZObj and IsMyModulusRep, > IsMyZmodnZObj and IsMyModulusRep ], > function( x, y ) return x![1] = y![1]; end ); ]]>

The above method to check equality is independent of whether the arguments have a prime or nonprime modulus, so we installed it for arguments in IsMyZmodnZObj. Now we install also methods to compare objects in IsMyZmodpZObj with the old finite field elements.

InstallMethod( \=, > "for element in Z/pZ (ModulusRep) and internal FFE", > IsIdenticalObj, > [ IsMyZmodpZObj and IsMyModulusRep, IsFFE and IsInternalRep ], > function( x, y ) > return DegreeFFE( y ) = 1 and x![1] = IntFFE( y ); > end ); gap> gap> InstallMethod( \=, > "for internal FFE and element in Z/pZ (ModulusRep)", > IsIdenticalObj, > [ IsFFE and IsInternalRep, IsMyZmodpZObj and IsMyModulusRep ], > function( x, y ) > return DegreeFFE( x ) = 1 and IntFFE( x ) = y![1]; > end ); ]]>

The situation with the operation < is more difficult. Of course we are free to define the comparison of objects in IsMyZmodnZObjNonprime, but for the finite field elements, the comparison must be compatible with the predefined comparison of the old finite field elements. The definition of the < comparison of internally represented finite field elements can be found in Chapter . In situations where the documentation does not provide the required information, one has to look it up in the &GAP; code; for example, the comparison in our case can be found in the appropriate source code file of the &GAP; kernel.

InstallMethod( \<, > "for two elements in Z/nZ (ModulusRep, nonprime)", > IsIdenticalObj, > [ IsMyZmodnZObjNonprime and IsMyModulusRep, > IsMyZmodnZObjNonprime and IsMyModulusRep ], > function( x, y ) return x![1] < y![1]; end ); gap> gap> InstallMethod( \<, > "for two elements in Z/pZ (ModulusRep)", > IsIdenticalObj, > [ IsMyZmodpZObj and IsMyModulusRep, > IsMyZmodpZObj and IsMyModulusRep ], > function( x, y ) > local p, r; # characteristic and primitive root > if x![1] = 0 then > return y![1] <> 0; > elif y![1] = 0 then > return false; > else > p:= Characteristic( x ); > r:= PrimitiveRootMod( p ); > return LogMod( x![1], r, p ) < LogMod( y![1], r, p ); > fi; > end ); gap> gap> InstallMethod( \<, > "for element in Z/pZ (ModulusRep) and internal FFE", > IsIdenticalObj, > [ IsMyZmodpZObj and IsMyModulusRep, IsFFE and IsInternalRep ], > function( x, y ) > return x![1] * One( y ) < y; > end ); gap> gap> InstallMethod( \<, > "for internal FFE and element in Z/pZ (ModulusRep)", > IsIdenticalObj, > [ IsFFE and IsInternalRep, IsMyZmodpZObj and IsMyModulusRep ], > function( x, y ) > return x < y![1] * One( x ); > end ); ]]>

Now we install the same methods for the arithmetic operations , , , \-, , and as in the previous section, without listing them below. Also the same method is installed for objects in IsMyZmodnZObj. Note that it is compatible with the definition of for finite field elements. And of course the same method for is installed.

We have to be careful, however, with the methods for , , and . These methods and the missing methods for arithmetic operations with one argument in IsMyModulusRep and the other in IsInternalRep are given below.

InstallMethod( \+, > "for element in Z/pZ (ModulusRep) and internal FFE", > IsIdenticalObj, > [ IsMyZmodpZObj and IsMyModulusRep, IsFFE and IsInternalRep ], > function( x, y ) return x![1] + y; end ); gap> gap> InstallMethod( \+, > "for internal FFE and element in Z/pZ (ModulusRep)", > IsIdenticalObj, > [ IsFFE and IsInternalRep, IsMyZmodpZObj and IsMyModulusRep ], > function( x, y ) return x + y![1]; end ); gap> gap> InstallMethod( \*, > "for element in Z/pZ (ModulusRep) and internal FFE", > IsIdenticalObj, > [ IsMyZmodpZObj and IsMyModulusRep, IsFFE and IsInternalRep ], > function( x, y ) return x![1] * y; end ); gap> gap> InstallMethod( \*, > "for internal FFE and element in Z/pZ (ModulusRep)", > IsIdenticalObj, > [ IsFFE and IsInternalRep, IsMyZmodpZObj and IsMyModulusRep ], > function( x, y ) return x * y![1]; end ); gap> gap> InstallMethod( InverseOp, > "for element in Z/nZ (ModulusRep, nonprime)", > [ IsMyZmodnZObjNonprime and IsMyModulusRep ], > function( x ) > local residue; > residue:= QuotientMod( 1, x![1], FamilyObj(x)!.modulus ); > if residue <> fail then > residue:= MyZmodnZObj( FamilyObj(x), residue ); > fi; > return residue; > end ); gap> gap> InstallMethod( InverseOp, > "for element in Z/pZ (ModulusRep)", > [ IsMyZmodpZObj and IsMyModulusRep ], > function( x ) > local residue; > residue:= QuotientMod( 1, x![1], Characteristic( FamilyObj(x) ) ); > if residue <> fail then > residue:= MyZmodnZObj( FamilyObj(x), residue ); > fi; > return residue; > end ); ]]>

The operation is defined for finite field elements, we need a method for objects in IsMyZmodpZObj. Note that we need not require IsMyModulusRep since no access to representation dependent data occurs.

InstallMethod( DegreeFFE, > "for element in Z/pZ", > [ IsMyZmodpZObj ], > z -> 1 ); ]]>

The methods for , , , and , that we had installed in the previous section had all assumed that their argument contains the whole family of its elements. So these methods make sense only for the nonprime case. For the prime case, there are already methods for these operations with argument a field.

InstallMethod( Enumerator, > "for full ring Z/nZ", > [ CategoryCollections( IsMyZmodnZObjNonprime ) and IsWholeFamily ], > function( R ) > local F; > F:= ElementsFamily( FamilyObj( R ) ); > return List( [ 0 .. Size( R ) - 1 ], x -> MyZmodnZObj( F, x ) ); > end ); gap> gap> InstallMethod( Random, > "for full ring Z/nZ", > [ CategoryCollections( IsMyZmodnZObjNonprime ) and IsWholeFamily ], > R -> MyZmodnZObj( ElementsFamily( FamilyObj( R ) ), > Random( [ 0 .. Size( R ) - 1 ] ) ) ); gap> gap> InstallMethod( Size, > "for full ring Z/nZ", > [ CategoryCollections( IsMyZmodnZObjNonprime ) and IsWholeFamily ], > R -> ElementsFamily( FamilyObj( R ) )!.modulus ); gap> gap> InstallMethod( Units, > "for full ring Z/nZ", > [ CategoryCollections( IsMyZmodnZObjNonprime ) > and IsWholeFamily and IsRing ], > function( R ) > local G, gens; > > gens:= GeneratorsPrimeResidues( Size( R ) ).generators; > if not IsEmpty( gens ) and gens[ 1 ] = 1 then > gens:= gens{ [ 2 .. Length( gens ) ] }; > fi; > gens:= Flat( gens ) * One( R ); > return GroupByGenerators( gens, One( R ) ); > end ); gap> gap> InstallTrueMethod( IsFinite, > CategoryCollections( IsMyZmodnZObjNonprime ) and IsDomain ); ]]>

Further Improvements in Implementing Residue Class Rings There are of course many possibilities to improve the implementation.

With the setup as described above, subsequent calls MyZmodnZ( n ) with the same n yield incompatible rings in the sense that elements of one ring cannot be added to elements of an other one. The solution for this problem is to keep a global list of all results of MyZmodnZ in the current &GAP; session, and to return the stored values whenever possible. Note that this approach would admit methods that produce &GAP; readable output.

One can improve the method for the full ring in such a way that a group is returned and not only a list of its elements; then the result of can be used, e. g., as input for the operation .

To make computations more efficient, one can install methods for \-, , and ; one reason for doing so may be that this avoids the unnecessary construction of the additive or multiplicative inverse, or of intermediate powers.

The call to in MyZmodnZObj can be avoided by storing the required type, e.g., in the family. But note that it is not admissible to take the type of an existing object as first argument of . For example, suppose two objects in IsMyZmodnZObj shall be added. Then we must not use the type of one of the arguments in a call of , because the argument may have knowledge that is not correct for the result of the addition. One may think of the property that may hold for both arguments but certainly not for their sum.

For comparing two objects in IsMyZmodpZObj via <, we had to install a quite expensive method because of the compatibility with the comparison of finite field elements that did already exist. In fact &GAP; supports finite fields with elements represented via discrete logarithms only up to a given size. So in principle we have the freedom to define a cheaper comparison via < for objects in IsMyZmodpZObj if the modulus is large enough. This is possible by introducing two categories IsMyZmodpZObjSmall and IsMyZmodpZObjLarge, which are subcategories of IsMyZmodpZObj, and to install different methods for pairs of objects in these categories.

gap-4r6p5/doc/ref/tom.xml0000644000175000017500000001527612172557252014016 0ustar billbill Tables of Marks <#Include Label="[1]{tom}">
More about Tables of Marks <#Include Label="[2]{tom}">
Table of Marks Objects in GAP <#Include Label="[3]{tom}">

Several examples in this chapter require the &GAP; package TomLib (the &GAP; Library of Tables of Marks) to be available. If it is not yet loaded then we load it now.

LoadPackage( "tomlib" ); true ]]>

Constructing Tables of Marks <#Include Label="TableOfMarks"> <#Include Label="TableOfMarksByLattice"> <#Include Label="LatticeSubgroupsByTom">
Printing Tables of Marks <#Include Label="[5]{tom}">
Sorting Tables of Marks <#Include Label="SortedTom"> <#Include Label="PermutationTom">
Technical Details about Tables of Marks <#Include Label="InfoTom"> <#Include Label="IsTableOfMarks"> <#Include Label="TableOfMarksFamily"> <#Include Label="TableOfMarksComponents"> <#Include Label="ConvertToTableOfMarks">
Attributes of Tables of Marks <#Include Label="MarksTom"> <#Include Label="NrSubsTom"> <#Include Label="LengthsTom"> <#Include Label="ClassTypesTom"> <#Include Label="ClassNamesTom"> <#Include Label="FusionsTom"> <#Include Label="UnderlyingGroup:tom"> <#Include Label="IdempotentsTom"> <#Include Label="Identifier:tom"> <#Include Label="MatTom"> <#Include Label="MoebiusTom"> <#Include Label="WeightsTom">
Properties of Tables of Marks <#Include Label="[6]{tom}">
Other Operations for Tables of Marks <#Include Label="[7]{tom}"> <#Include Label="DerivedSubgroupTom"> <#Include Label="DerivedSubgroupsTomPossible"> <#Include Label="NormalizerTom"> <#Include Label="ContainedTom"> <#Include Label="ContainingTom"> <#Include Label="CyclicExtensionsTom"> <#Include Label="DecomposedFixedPointVector"> <#Include Label="EulerianFunctionByTom"> <#Include Label="IntersectionsTom"> <#Include Label="FactorGroupTom"> <#Include Label="MaximalSubgroupsTom"> <#Include Label="MinimalSupergroupsTom">
Accessing Subgroups via Tables of Marks <#Include Label="[8]{tom}"> <#Include Label="GeneratorsSubgroupsTom"> <#Include Label="StraightLineProgramsTom"> <#Include Label="IsTableOfMarksWithGens"> <#Include Label="RepresentativeTom">
The Interface between Tables of Marks and Character Tables The following examples require the &GAP; Character Table Library to be available. If it is not yet loaded then we load it now.

LoadPackage( "ctbllib" ); true ]]>

<#Include Label="FusionCharTableTom"> <#Include Label="PermCharsTom">

Generic Construction of Tables of Marks <#Include Label="[9]{tom}"> <#Include Label="TableOfMarksCyclic"> <#Include Label="TableOfMarksDihedral"> <#Include Label="TableOfMarksFrobenius">
The Library of Tables of Marks The &GAP; package TomLib provides access to several hundred tables of marks of almost simple groups and their maximal subgroups. If this package is installed then the tables from this database can be accessed via with argument a string. If also the &GAP; Character Table Library is installed and contains the ordinary character table of the group for which one wants to fetch the table of marks then one can also call with argument the character table.

A list of all names of tables of marks that are provided by the TomLib package can be obtained via .

names:= AllLibTomNames();; gap> "A5" in names; true ]]>

gap-4r6p5/doc/ref/objects.xml0000644000175000017500000003716512172557252014651 0ustar billbill Objects and Elements An object is anything in &GAP; that can be assigned to a variable, so nearly everything in &GAP; is an object.

Different objects can be regarded as equal with respect to the equivalence relation =, in this case we say that the objects describe the same element.

Objects Nearly all things one deals with in &GAP; are objects. For example, an integer is an object, as is a list of integers, a matrix, a permutation, a function, a list of functions, a record, a group, a coset or a conjugacy class in a group.

Examples of things that are not objects are comments which are only lexical constructs, while loops which are only syntactical constructs, and expressions, such as 1 + 1; but note that the value of an expression, in this case the integer 2, is an object.

Objects can be assigned to variables, and everything that can be assigned to a variable is an object. Analogously, objects can be used as arguments of functions, and can be returned by functions. <#Include Label="IsObject">

Elements as equivalence classes elements The equality operation = defines an equivalence relation on all &GAP; objects. The equivalence classes are called elements.

There are basically three reasons to regard different objects as equal. Firstly the same information may be stored in different places. Secondly the same information may be stored in different ways; for example, a polynomial can be stored sparsely or densely. Thirdly different information may be equal modulo a mathematical equivalence relation. For example, in a finitely presented group with the relation a^2 = 1 the different objects a and a^3 describe the same element.

As an example of all three reasons, consider the possibility of storing an integer in several places of the memory, of representing it as a fraction with denominator 1, or of representing it as a fraction with any denominator, and numerator a suitable multiple of the denominator.

Sets In &GAP; there is no category whose definition corresponds to the mathematical property of being a set, however in the manual we will often refer to an object as a set in order to convey the fact that mathematically, we are thinking of it as a set. In particular, two sets A and B are equal if and only if, x \in A \iff x \in B.

There are two types of object in &GAP; which exhibit this kind of behaviour with respect to equality, namely domains (see Section ) and lists whose elements are strictly sorted see . In general, set in this manual will mean an object of one of these types.

More precisely: two domains can be compared with {=}, the answer being true if and only if the sets of elements are equal (regardless of any additional structure) and; a domain and a list can be compared with =, the answer being true if and only if the list is equal to the strictly sorted list of elements of the domain.

A discussion about sorted lists and sets can be found in Section .

Domains An especially important class of objects in &GAP; are those whose underlying mathematical abstraction is that of a structured set, for example a group, a conjugacy class, or a vector space. Such objects are called domains. The equality relation between domains is always equality as sets, so that two domains are equal if and only if they contain the same elements.

Domains play a central role in &GAP;. In a sense, the only reason that &GAP; supports objects such as integers and permutations is the wish to form domains of them and compute the properties of those domains.

Domains are described in Chapter .

Identical Objects Two objects that are equal as objects (that is they actually refer to the same area of computer memory) and not only w.r.t. the equality relation = are called identical. Identical objects do of course describe the same element. <#Include Label="IsIdenticalObj"> <#Include Label="IsNotIdenticalObj">
Mutability and Copyability An object in &GAP; is said to be immutable if its mathematical value (as defined by =) does not change under any operation. More explicitly, suppose a is immutable and O is some operation on a, then if a = b evaluates to true before executing O(a), a = b also evaluates to true afterwards. (Examples for operations O that change mutable objects are and which are used to change list objects, see Chapter .) An immutable object may change, for example to store new information, or to adopt a more efficient representation, but this does not affect its behaviour under =.

There are two points here to note. Firstly, operation above refers to the functions and methods which can legitimately be applied to the object, and not the !. operation whereby virtually any aspect of any &GAP; level object may be changed. The second point which follows from this, is that when implementing new types of objects, it is the programmer's responsibility to ensure that the functions and methods they write never change immutable objects mathematically.

In fact, most objects with which one deals in &GAP; are immutable. For instance, the permutation (1,2) will never become a different permutation or a non-permutation (although a variable which previously had (1,2) stored in it may subsequently have some other value).

For many purposes, however, mutable objects are useful. These objects may be changed to represent different mathematical objects during their life. For example, mutable lists can be changed by assigning values to positions or by unbinding values at certain positions. Similarly, one can assign values to components of a mutable record, or unbind them. <#Include Label="IsCopyable"> <#Include Label="IsMutable"> <#Include Label="Immutable"> One can turn the (mutable or immutable) object obj into an immutable one with ; note that this also makes all subobjects of obj immutable, so one should call only if obj and its mutable subobjects are newly created. If one is not sure about this, should be used.

Note that it is not possible to turn an immutable object into a mutable one; only mutable copies can be made (see ).

Using , it is possible to store an immutable identity matrix or an immutable list of generators, and to pass around references to this immutable object safely. Only when a mutable copy is really needed does the actual object have to be duplicated. Compared to the situation without immutable objects, much unnecessary copying is avoided this way. Another advantage of immutability is that lists of immutable objects may remember whether they are sorted (see ), which is not possible for lists of mutable objects.

Since the operation must work for any object in &GAP;, it follows that an immutable form of every object must be possible, even if it is not sensible, and user-defined objects must allow for the possibility of becoming immutable without notice. Mutability of Iterators An interesting example of mutable (and thus copyable) objects is provided by iterators, see . (Of course an immutable form of an iterator is not very useful, but clearly will yield such an object.) Every call of changes a mutable iterator until it is exhausted, and this is the only way to change an iterator. for an iterator iter is defined so as to return a mutable iterator that has no mutable data in common with iter, and that behaves equally to iter w.r.t.  and (if iter is mutable) . Note that this meaning of the shallow copy of an iterator that is returned by is not as obvious as for lists and records, and must be explicitly defined. Mutability of Results of Arithmetic Operations Many operations return immutable results, among those in particular attributes (see ). Examples of attributes are , , , , and . Arithmetic operations, such as the binary infix operations +, -, *, /, ^, mod, the unary -, and operations such as and , return mutable results, except if all arguments are immutable. So the product of two matrices or of a vector and a matrix is immutable if and only if the two matrices or both the vector and the matrix are immutable (see also ). There is one exception to this rule, which arises where the result is less deeply nested than at least one of the argument, where mutable arguments may sometimes lead to an immutable result. For instance, a mutable matrix with immutable rows, multiplied by an immutable vector gives an immutable vector result. The exact rules are given in .

It should be noted that 0 * obj is equivalent to ZeroSM( obj ), -obj is equivalent to AdditiveInverseSM( obj ), obj^0 is equivalent to OneSM( obj), and obj^-1 is equivalent to InverseSM( obj ). The SM stands for same mutability, and indicates that the result is mutable if and only if the argument is mutable.

The operations , , , and return mutable results whenever a mutable version of the result exists, contrary to the attributes , , , and .

If one introduces new arithmetic objects then one need not install methods for the attributes , , etc. The methods for the associated operations and will be called, and then the results made immutable.

All methods installed for the arithmetic operations must obey the rule about the mutability of the result. This means that one may try to avoid the perhaps expensive creation of a new object if both operands are immutable, and of course no problems of this kind arise at all in the (usual) case that the objects in question do not admit a mutable form, i.e., that these objects are not copyable.

In a few, relatively low-level algorithms, one wishes to treat a matrix partly as a data structure, and manipulate and change its entries. For this, the matrix needs to be mutable, and the rule that attribute values are immutable is an obstacle. For these situations, a number of additional operations are provided, for example constructs a mutable matrix (contrary to the attribute ), while modifies a mutable matrix (in place) into upper triangular form.

Note that being immutable does not forbid an object to store knowledge. For example, if it is found out that an immutable list is strictly sorted then the list may store this information. More precisely, an immutable object may change in any way, provided that it continues to represent the same mathematical object.

Duplication of Objects Copy copy clone <#Include Label="ShallowCopy"> <#Include Label="StructuralCopy">
Other Operations Applicable to any Object There are a number of general operations which can be applied, in principle, to any object in &GAP;. Some of these are documented elsewhere –see , and . Others are mainly somewhat technical. for a suitable object obj sets that object to have name name (a string). <#Include Label="Name"> <#Include Label="IsInternallyConsistent"> returns the amount of memory in bytes used by the object obj and its subobjects. Note that in general, objects can reference each other in very difficult ways such that determining the memory usage is a recursive procedure. In particular, computing the memory usage of a complicated structure itself uses some additional memory, which is however no longer used after completion of this operation. This procedure descends into lists and records, positional and component objects, however it does not take into account the type and family objects! For functions, it only takes the memory usage of the function body, not of the local context the function was created in, although the function keeps a reference to that as well!
gap-4r6p5/doc/ref/wordass.xml0000644000175000017500000001321312172557252014666 0ustar billbill Associative Words
Categories of Associative Words <#Include Label="[1]{wordass}"> <#Include Label="IsAssocWord">
Free Groups, Monoids and Semigroups Usually a family of associative words will be generated by constructing the free object generated by them. See , for details. <#Include Label="FreeGroup"> <#Include Label="IsFreeGroup"> <#Include Label="AssignGeneratorVariables">
Comparison of Associative Words <#Include Label="[2]{wordass}"> <#Include Label="IsShortLexLessThanOrEqual"> <#Include Label="IsBasicWreathLessThanOrEqual">
Operations for Associative Words <#Include Label="[3]{wordass}">

<#Include Label="Length:wordass"> <#Include Label="ExponentSumWord"> <#Include Label="Subword"> <#Include Label="PositionWord"> <#Include Label="SubstitutedWord"> <#Include Label="EliminatedWord">

Operations for Associative Words by their Syllables <#Include Label="[5]{wordass}"> <#Include Label="NumberSyllables"> <#Include Label="ExponentSyllable"> <#Include Label="GeneratorSyllable"> <#Include Label="SubSyllables">
Representations for Associative Words &GAP; provides two different internal kinds of representations of associative words. The first one are syllable representations in which words are stored in syllable (i.e. generator,exponent) form. (Older versions of &GAP; only used this representation.) The second kind are letter representations in which each letter in a word is represented by its index number. Negative numbers are used for inverses. Unless the syllable representation is specified explicitly when creating the free group/monoid or semigroup, a letter representation is used by default.

Depending on the task in mind, either of these two representations will perform better in time or in memory use and algorithms that are syllable or letter based (for example and ) perform substantially better in the corresponding representation. For example when creating pc groups (see ), it is advantageous to use a syllable representation while calculations in free groups usually benefit from using a letter representation. <#Include Label="IsLetterAssocWordRep"> <#Include Label="IsLetterWordsFamily"> <#Include Label="IsBLetterAssocWordRep"> <#Include Label="IsBLetterWordsFamily"> <#Include Label="IsSyllableAssocWordRep"> <#Include Label="IsSyllableWordsFamily"> <#Include Label="Is8BitsFamily"> <#Include Label="LetterRepAssocWord"> <#Include Label="AssocWordByLetterRep">

The External Representation for Associative Words <#Include Label="[6]{wordass}">
Straight Line Programs <#Include Label="[1]{straight}"> <#Include Label="IsStraightLineProgram"> <#Include Label="StraightLineProgram"> <#Include Label="LinesOfStraightLineProgram"> <#Include Label="NrInputsOfStraightLineProgram"> <#Include Label="ResultOfStraightLineProgram"> <#Include Label="StringOfResultOfStraightLineProgram"> <#Include Label="CompositionOfStraightLinePrograms"> <#Include Label="IntegratedStraightLineProgram"> <#Include Label="RestrictOutputsOfSLP"> <#Include Label="IntermediateResultOfSLP"> <#Include Label="IntermediateResultOfSLPWithoutOverwrite"> <#Include Label="IntermediateResultsOfSLPWithoutOverwrite"> <#Include Label="ProductOfStraightLinePrograms"> <#Include Label="SlotUsagePattern">
Straight Line Program Elements <#Include Label="[2]{straight}"> <#Include Label="IsStraightLineProgElm"> <#Include Label="StraightLineProgElm"> <#Include Label="StraightLineProgGens"> <#Include Label="EvalStraightLineProgElm"> <#Include Label="StretchImportantSLPElement">
gap-4r6p5/doc/ref/relation.xml0000644000175000017500000001130712172557252015023 0ustar billbill Relations <#Include Label="[1]{relation}">
General Binary Relations This section lists general constructors of relations. <#Include Label="IsBinaryRelation"> <#Include Label="BinaryRelationByElements"> <#Include Label="IdentityBinaryRelation"> <#Include Label="EmptyBinaryRelation">
Properties and Attributes of Binary Relations <#Include Label="IsReflexiveBinaryRelation"> <#Include Label="IsSymmetricBinaryRelation"> <#Include Label="IsTransitiveBinaryRelation"> <#Include Label="IsAntisymmetricBinaryRelation"> <#Include Label="IsPreOrderBinaryRelation"> <#Include Label="IsPartialOrderBinaryRelation"> <#Include Label="IsHasseDiagram"> <#Include Label="IsEquivalenceRelation"> <#Include Label="Successors"> <#Include Label="DegreeOfBinaryRelation"> <#Include Label="PartialOrderOfHasseDiagram">
Binary Relations on Points We have special construction methods when the underlying X of our relation is the set of integers \{ 1, \ldots, n \}. <#Include Label="BinaryRelationOnPoints"> <#Include Label="RandomBinaryRelationOnPoints"> <#Include Label="AsBinaryRelationOnPoints">
Closure Operations and Other Constructors <#Include Label="ReflexiveClosureBinaryRelation"> <#Include Label="SymmetricClosureBinaryRelation"> <#Include Label="TransitiveClosureBinaryRelation"> <#Include Label="HasseDiagramBinaryRelation"> <#Include Label="StronglyConnectedComponents"> <#Include Label="PartialOrderByOrderingFunction">
Equivalence Relations equivalence relation An equivalence relation E over the set X is a relation on X which is reflexive, symmetric, and transitive. A partition P is a set of subsets of X such that for all R, S \in P, R \cap S is the empty set and \cup P = X. An equivalence relation induces a partition such that if (x,y) \in E then x, y are in the same element of P.

Like all binary relations in &GAP; equivalence relations are regarded as general endomorphic mappings (and the operations, properties and attributes of general mappings are available). However, partitions provide an efficient way of representing equivalence relations. Moreover, only the non-singleton classes or blocks are listed allowing for small equivalence relations to be represented on infinite sets. Hence the main attribute of equivalence relations is which provides the partition induced by the given equivalence. <#Include Label="EquivalenceRelationByPartition"> <#Include Label="EquivalenceRelationByRelation"> <#Include Label="EquivalenceRelationByPairs"> <#Include Label="EquivalenceRelationByProperty">

Attributes of and Operations on Equivalence Relations <#Include Label="EquivalenceRelationPartition"> <#Include Label="GeneratorsOfEquivalenceRelationPartition"> <#Include Label="JoinEquivalenceRelations">
Equivalence Classes <#Include Label="IsEquivalenceClass"> <#Include Label="EquivalenceClassRelation"> <#Include Label="EquivalenceClasses"> <#Include Label="EquivalenceClassOfElement">
gap-4r6p5/doc/ref/pres.xml0000644000175000017500000002337212172557252014164 0ustar billbill Presentations and Tietze Transformations A finite presentation describes a group, but usually there is a multitude of presentations that describe isomorphic groups. Therefore a presentation in &GAP; is different from a finitely presented group though there are ways to translate between both.

An important feature of presentations is that they can be modified (see sections to ).

If you only want to get new presentations for subgroups of a finitely presented group (and do not want to manipulate presentations yourself), chances are that the operation already does what you want (see ).

Creating Presentations Most of the functions creating presentations and all functions performing Tietze transformations on them sort the relators by increasing lengths. The function is an exception because it is intended to reflect the relators that were used to define the involved f. p. group. You may use the command to sort the presentation. <#Include Label="PresentationFpGroup"> <#Include Label="TzSort"> <#Include Label="GeneratorsOfPresentation"> <#Include Label="FpGroupPresentation"> <#Include Label="PresentationViaCosetTable"> <#Include Label="SimplifiedFpGroup">
Subgroup Presentations Schreier <#Include Label="PresentationSubgroup"> <#Include Label="PresentationSubgroupRrs"> <#Include Label="PrimaryGeneratorWords"> <#Include Label="PresentationSubgroupMtc"> <#Include Label="PresentationNormalClosureRrs"> <#Include Label="PresentationNormalClosure">
Relators in a Presentation In order to speed up the Tietze transformation routines, each relator in a presentation is internally represented by a list of positive or negative generator numbers, i.e., each factor of the proper &GAP; word is represented by the position number of the corresponding generator with respect to the current list of generators, or by the respective negative number, if the factor is the inverse of a generator. Note that the numbering of the generators in Tietze words is always relative to a generator list and bears no relation to the internal numbering of generators in a family of associative words. <#Include Label="TietzeWordAbstractWord"> <#Include Label="AbstractWordTietzeWord">
Printing Presentations Whenever you create a presentation P, say, or assign it to a variable, &GAP; will respond by printing P. However, as P may contain a lot of generators and many relators of large length, it would be annoying if the standard print facilities displayed all this information in detail. So they restrict the printout to just one line of text containing the number of generators, the number of relators, and the total length of all relators of P. As compensation, &GAP; offers some special print commands which display various details of a presentation. Note that there is also a function . It is described in Section . <#Include Label="TzPrintGenerators"> <#Include Label="TzPrintRelators"> <#Include Label="TzPrintLengths"> <#Include Label="TzPrintStatus"> <#Include Label="TzPrintPresentation"> <#Include Label="TzPrint"> <#Include Label="TzPrintPairs">
Changing Presentations The functions described in this section may be used to change a presentation. Note, however, that in general they do not perform Tietze transformations because they change or may change the isomorphism type of the group defined by the presentation. <#Include Label="AddGenerator"> <#Include Label="TzNewGenerator"> <#Include Label="AddRelator"> <#Include Label="RemoveRelator">
Tietze Transformations The commands in this section can be used to modify a presentation by Tietze transformations.

In general, the aim of such modifications will be to simplify the given presentation, i.e., to reduce the number of generators and the number of relators without increasing too much the sum of all relator lengths which we will call the total length of the presentation. Depending on the concrete presentation under investigation one may end up with a nice, short presentation or with a very huge one.

Unfortunately there is no algorithm which could be applied to find the shortest presentation which can be obtained by Tietze transformations from a given one. Therefore, what &GAP; offers are some lower-level Tietze transformation commands and, in addition, some higher-level commands which apply the lower-level ones in a kind of default strategy which of course cannot be the optimal choice for all presentations.

The design of these commands follows closely the concept of the ANU Tietze transformation program and its later revisions (see , ). <#Include Label="TzGo"> <#Include Label="SimplifyPresentation"> <#Include Label="TzGoGo">

Elementary Tietze Transformations <#Include Label="TzEliminate"> <#Include Label="TzSearch"> <#Include Label="TzSearchEqual"> <#Include Label="TzFindCyclicJoins">
Tietze Transformations that introduce new Generators Some of the Tietze transformation commands listed so far may eliminate generators and hence change the given presentation to a presentation on a subset of the given set of generators, but they all do not introduce new generators. However, sometimes there will be the need to substitute certain words as new generators in order to improve a presentation. Therefore &GAP; offers the two commands and which introduce new generators. <#Include Label="TzSubstitute"> <#Include Label="TzSubstituteCyclicJoins">
Tracing generator images through Tietze transformations Any sequence of Tietze transformations applied to a presentation, starting from some presentation P_1 and ending up with some presentation P_2, defines an isomorphism, \varphi say, between the groups defined by P_1 and P_2, respectively. Sometimes it is desirable to know the images of the (old) generators of P_1 or the preimages of the (new) generators of P_2 under \varphi. The &GAP; Tietze transformation functions are able to trace these images. This is not automatically done because the involved words may grow to tremendous length, but it will be done if you explicitly request for it by calling the function . <#Include Label="TzInitGeneratorImages"> <#Include Label="OldGeneratorsOfPresentation"> <#Include Label="TzImagesOldGens"> <#Include Label="TzPreImagesNewGens"> <#Include Label="TzPrintGeneratorImages">
The Decoding Tree Procedure <#Include Label="DecodeTree">
Tietze Options Several of the Tietze transformation commands described above are controlled by certain parameters, the Tietze options, which often have a tremendous influence on their performance and results. However, in each application of the commands, an appropriate choice of these option parameters will depend on the concrete presentation under investigation. Therefore we have implemented the Tietze options in such a way that they are associated to the presentation: Each presentation keeps its own set of Tietze option parameters as an attribute. <#Include Label="TzOptions"> <#Include Label="TzPrintOptions">
gap-4r6p5/doc/ref/rws.xml0000644000175000017500000002077112172557252014026 0ustar billbill Rewriting Systems Rewriting systems in &GAP; are a framework for dealing with the very general task of rewriting elements of a free (or term) algebra in some normal form. Although most rewriting systems currently in use are string rewriting systems (where the algebra has only one binary operation which is associative) the framework in &GAP; is general enough to encompass the task of rewriting algebras of any signature from groups to semirings.

Rewriting systems are already implemented in &GAP; for finitely presented semigroups and for pc groups. The use of these particular rewriting systems is described in the corresponding chapters. We describe here only the general framework of rewriting systems with a particular emphasis on material which would be helpful for a developer implementing a rewriting system.

We fix some definitions and terminology for the rest of this chapter. Let T be a term algebra in some signature. A term rewriting system for T is a set of ordered pairs of elements of T of the form (l, r). Viewed as a set of relations, the rewriting system determines a presentation for a quotient algebra A of T.

When we take into account the fact that the relations are expressed as ordered pairs, we have a way of reducing the elements of T. Suppose an element u of T has a subword l and (l, r) is a rule of the rewriting system, then we can replace the subterm l of u by the term r and obtain a new word v. We say that we have rewritten u as v. Note that u and v represent the same element of A. If u can not be rewritten using any rule of the rewriting system we sat that u is reduced.

Operations on rewriting systems <#Include Label="IsRewritingSystem"> <#Include Label="Rules"> <#Include Label="OrderOfRewritingSystem"> <#Include Label="ReducedForm"> <#Include Label="IsConfluent"> <#Include Label="ConfluentRws"> <#Include Label="IsReduced"> <#Include Label="ReduceRules"> <#Include Label="AddRule"> <#Include Label="AddRuleReduced"> <#Include Label="MakeConfluent"> <#Include Label="GeneratorsOfRws">
Operations on elements of the algebra In this section let u denote an element of the term algebra T representing [u] in the quotient algebra A. The result of is w where [w] equals [u][v] in A and w is in reduced form.

The remaining operations are defined similarly when they are defined (as determined by the signature of the term algebra).

Properties of rewriting systems These properties may be used to identify the type of term algebra over which the rewriting system is defined.
Rewriting in Groups and Monoids One application of rewriting is to reduce words in finitely presented groups and monoids. The rewriting system still has to be built for a finitely presented monoid (using IsomorphismFpMonoid for conversion). Rewriting then can take place for words in the underlying free monoid. (These can be obtained from monoid elements with the command UnderlyingElement.)

f:=FreeGroup(3);; gap> rels:=[f.1*f.2^2/f.3,f.2*f.3^2/f.1,f.3*f.1^2/f.2];; gap> g:=f/rels; gap> mhom:=IsomorphismFpMonoid(g); MappingByFunction( , , function( x ) ... end, function( x ) ... end ) gap> mon:=Image(mhom); gap> k:=KnuthBendixRewritingSystem(mon); Knuth Bendix Rewriting System for Monoid( [ f1, f1^-1, f2, f2^-1, f3, f3^-1 ], ... ) with rules [ [ f1*f1^-1, ], [ f1^-1*f1, ], [ f2*f2^-1, ], [ f2^-1*f2, ], [ f3*f3^-1, ], [ f3^-1*f3, ], [ f1*f2^2*f3^-1, ], [ f2*f3^2*f1^-1, ] , [ f3*f1^2*f2^-1, ] ] gap> MakeConfluent(k); gap> a:=Product(GeneratorsOfMonoid(mon)); f1*f1^-1*f2*f2^-1*f3*f3^-1 gap> ReducedForm(k,UnderlyingElement(a)); ]]>

To rewrite a word in the finitely presented group, one has to convert it to a word in the monoid first, rewrite in the underlying free monoid and convert back (by forming first again an element of the fp monoid) to the finitely presented group.

r:=PseudoRandom(g);; gap> Length(r); 3704 gap> melm:=Image(mhom,r);; gap> red:=ReducedForm(k,UnderlyingElement(melm)); f1^-1^3*f2^-1*f1^2 gap> melm:=ElementOfFpMonoid(FamilyObj(One(mon)),red); f1^-1^3*f2^-1*f1^2 gap> gpelm:=PreImagesRepresentative(mhom,melm); f1^-3*f2^-1*f1^2 gap> r=gpelm; true gap> CategoriesOfObject(red); [ "IsExtLElement", "IsExtRElement", "IsMultiplicativeElement", "IsMultiplicativeElementWithOne", "IsAssociativeElement", "IsWord" ] gap> CategoriesOfObject(melm); [ "IsExtLElement", "IsExtRElement", "IsMultiplicativeElement", "IsMultiplicativeElementWithOne", "IsAssociativeElement", "IsElementOfFpMonoid" ] gap> CategoriesOfObject(gpelm); [ "IsExtLElement", "IsExtRElement", "IsMultiplicativeElement", "IsMultiplicativeElementWithOne", "IsMultiplicativeElementWithInverse", "IsAssociativeElement", "IsElementOfFpGroup" ] ]]>

Note, that the elements red (free monoid) melm (fp monoid) and gpelm (group) differ, though they are displayed identically.

Under Unix, it is possible to use the kbmag package to replace the built-in rewriting by this packages efficient C implementation. You can do this (after loading the kbmag package) by assigning the variable to KBMAG_REW. Assignment to GAPKB_REW reverts to the built-in implementation. LoadPackage("kbmag"); true gap> KB_REW:=KBMAG_REW;; ]]>

Developing rewriting systems <#Include Label="[2]{rws}">
gap-4r6p5/doc/ref/main.xml0000644000175000017500000001134012172557252014127 0ustar billbill Atlas"> —---"> <#Include SYSTEM "../versiondata"> ]> GAP - Reference Manual Release &VERSIONNUMBER;, &RELEASEDAY; The GAP Group support@gap-system.org http://www.gap-system.org Copyright ©right; (1987-&RELEASEYEAR;) for the core part of the &GAP; system by the &GAP; Group.

Most parts of this distribution, including the core part of the &GAP; system are distributed under the terms of the GNU General Public License, see http://www.gnu.org/licenses/gpl.html or the file GPL in the etc directory of the &GAP; installation.

More detailed information about copyright and licenses of parts of this distribution can be found in Section of this manual.

&GAP; is developed over a long time and has many authors and contributors. More detailed information can be found in Section of this manual. <#Include SYSTEM "preface.xml"> <#Include SYSTEM "help.xml"> <#Include SYSTEM "run.xml"> <#Include SYSTEM "language.xml"> <#Include SYSTEM "function.xml"> <#Include SYSTEM "mloop.xml"> <#Include SYSTEM "debug.xml"> <#Include SYSTEM "options.xml"> <#Include SYSTEM "files.xml"> <#Include SYSTEM "streams.xml"> <#Include SYSTEM "process.xml"> <#Include SYSTEM "objects.xml"> <#Include SYSTEM "types.xml"> <#Include SYSTEM "integers.xml"> <#Include SYSTEM "numtheor.xml"> <#Include SYSTEM "combinat.xml"> <#Include SYSTEM "rational.xml"> <#Include SYSTEM "cyclotom.xml"> <#Include SYSTEM "floats.xml"> <#Include SYSTEM "boolean.xml"> <#Include SYSTEM "lists.xml"> <#Include SYSTEM "blist.xml"> <#Include SYSTEM "vector.xml"> <#Include SYSTEM "matrix.xml"> <#Include SYSTEM "matint.xml"> <#Include SYSTEM "matobj.xml"> <#Include SYSTEM "string.xml"> <#Include SYSTEM "hash2.xml"> <#Include SYSTEM "record.xml"> <#Include SYSTEM "coll.xml"> <#Include SYSTEM "domain.xml"> <#Include SYSTEM "mapping.xml"> <#Include SYSTEM "relation.xml"> <#Include SYSTEM "orders.xml"> <#Include SYSTEM "magma.xml"> <#Include SYSTEM "word.xml"> <#Include SYSTEM "wordass.xml"> <#Include SYSTEM "rws.xml"> <#Include SYSTEM "groups.xml"> <#Include SYSTEM "grphomom.xml"> <#Include SYSTEM "grpoper.xml"> <#Include SYSTEM "permutat.xml"> <#Include SYSTEM "grpperm.xml"> <#Include SYSTEM "grpmat.xml"> <#Include SYSTEM "pcgs.xml"> <#Include SYSTEM "grppc.xml"> <#Include SYSTEM "grpfp.xml"> <#Include SYSTEM "pres.xml"> <#Include SYSTEM "grpprod.xml"> <#Include SYSTEM "grplib.xml"> <#Include SYSTEM "semigrp.xml"> <#Include SYSTEM "monoid.xml"> <#Include SYSTEM "fpsemi.xml"> <#Include SYSTEM "trans.xml"> <#Include SYSTEM "addmagma.xml"> <#Include SYSTEM "rings.xml"> <#Include SYSTEM "module.xml"> <#Include SYSTEM "fields.xml"> <#Include SYSTEM "fieldfin.xml"> <#Include SYSTEM "fldabnum.xml"> <#Include SYSTEM "vspc.xml"> <#Include SYSTEM "algebra.xml"> <#Include SYSTEM "algfp.xml"> <#Include SYSTEM "alglie.xml"> <#Include SYSTEM "mgmring.xml"> <#Include SYSTEM "ratfun.xml"> <#Include SYSTEM "algfld.xml"> <#Include SYSTEM "padics.xml"> <#Include SYSTEM "meataxe.xml"> <#Include SYSTEM "tom.xml"> <#Include SYSTEM "ctbl.xml"> <#Include SYSTEM "ctblfuns.xml"> <#Include SYSTEM "ctblmaps.xml"> <#Include SYSTEM "unknown.xml"> <#Include SYSTEM "ctblmono.xml"> <#Include SYSTEM "gappkg.xml"> <#Include SYSTEM "obsolete.xml"> <#Include SYSTEM "methsel.xml"> <#Include SYSTEM "create.xml"> <#Include SYSTEM "intrfc.xml"> <#Include SYSTEM "xtndxmpl.xml"> <#Include SYSTEM "arith.xml"> <#Include SYSTEM "libform.xml"> <#Include SYSTEM "helpintf.xml"> <#Include SYSTEM "foa.xml"> <#Include SYSTEM "weakptr.xml"> <#Include SYSTEM "stbchain.xml"> gap-4r6p5/doc/ref/meataxe.xml0000644000175000017500000005630712172557252014643 0ustar billbill The MeatAxe The MeatAxe is a tool for the examination of submodules of a group algebra. It is a basic tool for the examination of group actions on finite-dimensional modules.

&GAP; uses the improved MeatAxe of Derek Holt and Sarah Rees, and also incorporates further improvements of Ivanyos and Lux.

MeatAxe Modules GModuleByMats creates a MeatAxe module over field from a list of invertible matrices gens which reflect a group's action. If the list of generators is empty, the dimension must be given as second argument.

MeatAxe routines are on a level with Gaussian elimination. Therefore they do not deal with &GAP; modules but essentially with lists of matrices. For the MeatAxe, a module is a record with components

generators A list of matrices which represent a group operation on a finite dimensional row vector space. dimension The dimension of the vector space (this is the common length of the row vectors (see )). field The field over which the vector space is defined.

Once a module has been created its entries may not be changed. A MeatAxe may create a new component NameOfMeatAxe in which it can store private information. By a MeatAxe submodule or factor module we denote actually the induced action on the submodule, respectively factor module. Therefore the submodules or factor modules are again MeatAxe modules. The arrangement of generators is guaranteed to be the same for the induced modules, but to obtain the complete relation to the original module, the bases used are needed as well.

Module Constructions Called with a permutation group G and a finite field F, returns the natural permutation module M over F for the group of permutation matrices that acts on the canonical basis of M in the same way as G acts on the points up to its largest moved point (see ). calculates the tensor product of the modules m1 and m2. They are assumed to be modules over the same algebra so, in particular, they should have the same number of generators. calculates the wedge product of a G-module. That is the action on antisymmetric tensors.
Selecting a Different MeatAxe All MeatAxe routines are accessed via the global variable , which is a record whose components hold the various functions. It is possible to have several implementations of a MeatAxe available. Each MeatAxe represents its routines in an own global variable and assigning to this variable selects the corresponding MeatAxe.
Accessing a Module Even though a MeatAxe module is a record, its components should never be accessed outside of MeatAxe functions. Instead the following operations should be used: returns a list of matrix generators of module. returns the dimension in which the matrices act. returns the field over which module is defined.
Irreducibility Tests tests whether the module module is irreducible (i.e. contains no proper submodules.) A module is absolutely irreducible if it remains irreducible over the algebraic closure of the field. (Formally: If the tensor product L \otimes_K M is irreducible where M is the module defined over K and L is the algebraic closure of K.) returns the degree of the splitting field as extension of the prime field.
Decomposition of modules A module is decomposable if it can be written as the direct sum of two proper submodules (and indecomposable if not). Obviously every finite dimensional module is a direct sum of its indecomposable parts. The homogeneous components of a module are the direct sums of isomorphic indecomposable components. They are uniquely determined.

returns whether module is indecomposable.

returns a decomposition of module as a direct sum of indecomposable modules. It returns a list, each entry is a list of form [B,ind] where B is a list of basis vectors for the indecomposable component and ind the induced module action on this component. (Such a decomposition is not unique.)

computes the homogeneous components of module given as sums of indecomposable components. The function returns a list, each entry of which is a record corresponding to one isomorphism type of indecomposable components. The record has the following components.

indices the index numbers of the indecomposable components, as given by , that are in the homogeneous component, component one of the indecomposable components, images a list of the remaining indecomposable components, each given as a record with the components component (the component itself) and isomorphism (an isomorphism from the defining component to this one).

Finding Submodules subspace should be a subspace of (or a vector in) the underlying vector space of module i.e. the full row space of the same dimension and over the same field as module. A normalized basis of the submodule of module generated by subspace is returned. returns the basis of a proper submodule of module and fail if no proper submodule exists. returns a list containing a basis for every submodule. returns a list of bases of all minimal submodules. returns a list of bases of all maximal submodules. returns a basis of the radical of module. returns a basis of the socle of module. returns a list of bases of all minimal supermodules of the submodule given by the basis sub. returns a list of bases of submodules in a composition series in ascending order. returns a list of composition factors of module in ascending order. returns a list giving all irreducible composition factors with their frequencies.
Induced Actions returns a list [bas, change ] where bas is a normed basis (i.e. in echelon form with pivots normed to 1) for sub and change is the base change from bas to sub (the basis vectors of bas expressed in coefficients for sub). creates a new module corresponding to the action of module on sub. In the NB version the basis sub must be normed. (That is it must be in echelon form with pivots normed to 1, see .) creates a new module corresponding to the action of module on the factor of sub. If compl is given, it has to be a basis of a (vector space-)complement of sub. The action then will correspond to compl.

The basis sub has to be given in normed form. (That is it must be in echelon form with pivots normed to 1, see ) work the same way as the above functions for modules, but take as input only a single matrix. Computes induced actions on submodules or factor modules and also returns the corresponding bases. The action taken is binary encoded in type: 1 stands for subspace action, 2 for factor action, and 4 for action of the full module on a subspace adapted basis. The routine returns the computed results in a list in sequence (sub,quot,both,basis) where basis is a basis for the whole space, extending sub. (Actions which are not computed are omitted, so the returned list may be shorter.) If no type is given, it is assumed to be 7. The basis given in sub must be normed!

All these routines return fail if sub is not a proper subspace.

Module Homomorphisms returns a basis of all module homomorphisms from module1 to module2. Homomorphisms are by matrices, whose rows give the images of the standard basis vectors of module1 in the standard basis of module2. returns a basis of all module homomorphisms from module to module. If module1 and module2 are isomorphic modules, this function returns an isomorphism from module1 to module2 in form of a matrix. It returns fail if the modules are not isomorphic. returns the module automorphisms of module (the set of all isomorphisms from module to itself) as a matrix group.
Module Homomorphisms for irreducible modules The following are lower-level functions that provide homomorphism functionality for irreducible modules. Generic code should use the functions in Section instead. tests two irreducible modules for equivalence. returns an isomorphism from module1 to module2 (if one exists), and fail otherwise. It requires that one of the modules is known to be irreducible. It implicitly assumes that the same group is acting, otherwise the results are unpredictable. The isomorphism is given by a matrix M, whose rows give the images of the standard basis vectors of module1 in the standard basis of module2. That is, conjugation of the generators of module2 with M yields the generators of module1. mat should be a dim1 \times dim2 matrix defining a homomorphism from module1 to module2. This function verifies that mat really does define a module homomorphism, and then returns the corresponding homomorphism between the underlying row spaces of the modules. This can be used for computing kernels, images and pre-images. returns a basis of the space of all homomorphisms from the irreducible module module1 to module2. Let cf be the output of . This routine tries to find a group algebra element that has nullity zero on all composition factors except number nr.
MeatAxe Functionality for Invariant Forms The functions in this section can only be applied to an absolutely irreducible MeatAxe module. returns an invariant bilinear form, which may be symmetric or anti-symmetric, of module, or fail if no such form exists. returns an invariant hermitian (= self-adjoint) sesquilinear form of module, which must be defined over a finite field whose order is a square, or fail if no such form exists. returns an invariant quadratic form of module, or fail if no such form exists. If the characteristic of the field over which module is defined is not 2, then the invariant bilinear form (if any) divided by two will be returned. In characteristic 2, the form returned will be lower triangular. returns a basis of the underlying vector space of module which is contained in an orbit of the action of the generators of module on that space. This is used by in characteristic 2. for an even dimensional module, returns 1 or -1, according as MTX.InvariantQuadraticForm(module) is of + or - type. For an odd dimensional module, returns 0. For a module with no invariant quadratic form, returns fail. This calculation uses an algorithm due to Jon Thackray.
The Smash MeatAxe The standard MeatAxe provided in the &GAP; library is based on the MeatAxe in the &GAP; 3 package Smash, originally written by Derek Holt and Sarah Rees . It is accessible via the variable SMTX to which is assigned by default. For the sake of completeness the remaining sections document more technical functions of this MeatAxe. returns the module action on a random irreducible submodule. finds an element with minimal possible nullspace dimension if module is known to be irreducible. Function to sort the output of Homomorphisms. returns (at most max) bases of submodules of module2 which are isomorphic to the irreducible module module1. returns a setter function for the component smashMeataxe.(string). returns a getter function for the component smashMeataxe.(string). Tests for irreducibility and sets a subbasis if reducible. It neither sets an irreducibility flag, nor tests it. Thus the routine also can simply be called to obtain a random submodule. Tests for absolute irreducibility and sets splitting field degree. It neither sets an absolute irreducibility flag, nor tests it. returns the basis of a minimal submodule of module containing the indicated composition factor. It assumes Distinguish has been called already. creates the direct sum of two matrix lists. extends the partial basis pbasis to a basis of the full space by action of module. It returns whether it succeeded.
Smash MeatAxe Flags The following getter routines access internal flags. For each routine, the appropriate setter's name is prefixed with Set. Basis of a submodule. list [newgens,coefflist] giving an algebra element used for chopping. matrix of . minimal polynomial of . uses factor of . nullspace of the matrix evaluated under this factor. dimension of the nullspace. matrix centralising all generators which is computed as a byproduct of . minimal polynomial of .
gap-4r6p5/doc/ref/mapping.xml0000644000175000017500000001762112172557252014646 0ustar billbill Mappings functions relations A mapping in &GAP; is what is called a function in mathematics. &GAP; also implements generalized mappings in which one element might have several images, these can be imagined as subsets of the cartesian product and are often called relations.

Most operations are declared for general mappings and therefore this manual often refers to (general) mappings, unless you deliberately need the generalization you can ignore the general bit and just read it as mappings.

<#Include Label="[1]{mapping}">

For mappings which preserve an algebraic structure a kernel is defined. Depending on the structure preserved the operation to compute this kernel is called differently, see Section .

Some technical details of general mappings are described in section .

IsDirectProductElement (Filter) <#Include Label="IsDirectProductElement">
Creating Mappings <#Include Label="GeneralMappingByElements"> <#Include Label="MappingByFunction"> <#Include Label="InverseGeneralMapping"> <#Include Label="CompositionMapping"> <#Include Label="CompositionMapping2"> <#Include Label="IsCompositionMappingRep"> <#Include Label="ConstituentsCompositionMapping"> <#Include Label="ZeroMapping"> <#Include Label="IdentityMapping"> <#Include Label="Embedding"> <#Include Label="Projection"> <#Include Label="RestrictedMapping">
Properties and Attributes of (General) Mappings <#Include Label="IsTotal"> <#Include Label="IsSingleValued"> <#Include Label="IsMapping"> <#Include Label="IsInjective"> <#Include Label="IsSurjective"> <#Include Label="IsBijective"> <#Include Label="Range"> <#Include Label="Source"> <#Include Label="UnderlyingRelation"> <#Include Label="UnderlyingGeneralMapping">
Images under Mappings <#Include Label="ImagesSource"> <#Include Label="ImagesRepresentative"> <#Include Label="ImagesElm"> <#Include Label="ImagesSet"> <#Include Label="ImageElm"> <#Include Label="Image"> <#Include Label="Images">
Preimages under Mappings <#Include Label="PreImagesRange"> <#Include Label="PreImagesElm"> <#Include Label="PreImageElm"> <#Include Label="PreImagesRepresentative"> <#Include Label="PreImagesSet"> <#Include Label="PreImage"> <#Include Label="PreImages">
Arithmetic Operations for General Mappings <#Include Label="[3]{mapping}">
Mappings which are Compatible with Algebraic Structures From an algebraical point of view, the most important mappings are those which are compatible with a structure. For Magmas, Groups and Rings, &GAP; supports the following four types of such mappings:

General mappings that respect multiplication General mappings that respect addition General mappings that respect scalar mult. General mappings that respect multiplicative and additive structure

(Very technical note: &GAP; defines categories IsSPGeneralMapping and IsNonSPGeneralMapping. The distinction between these is orthogonal to the structure compatibility described here and should not be confused.)

Magma Homomorphisms <#Include Label="IsMagmaHomomorphism"> <#Include Label="MagmaHomomorphismByFunctionNC"> <#Include Label="NaturalHomomorphismByGenerators">
Mappings that Respect Multiplication <#Include Label="RespectsMultiplication"> <#Include Label="RespectsOne"> <#Include Label="RespectsInverses"> <#Include Label="IsGroupGeneralMapping"> <#Include Label="KernelOfMultiplicativeGeneralMapping"> <#Include Label="CoKernelOfMultiplicativeGeneralMapping">
Mappings that Respect Addition <#Include Label="RespectsAddition"> <#Include Label="RespectsAdditiveInverses"> <#Include Label="RespectsZero"> <#Include Label="IsAdditiveGroupGeneralMapping"> <#Include Label="KernelOfAdditiveGeneralMapping"> <#Include Label="CoKernelOfAdditiveGeneralMapping">
Linear Mappings Also see Sections , , and , . <#Include Label="RespectsScalarMultiplication"> <#Include Label="IsLeftModuleGeneralMapping"> <#Include Label="IsLinearMapping">
Ring Homomorphisms <#Include Label="IsRingGeneralMapping"> <#Include Label="IsRingWithOneGeneralMapping"> <#Include Label="IsAlgebraGeneralMapping"> <#Include Label="IsAlgebraWithOneGeneralMapping"> <#Include Label="IsFieldHomomorphism">
General Mappings <#Include Label="IsGeneralMapping"> <#Include Label="IsConstantTimeAccessGeneralMapping"> <#Include Label="IsEndoGeneralMapping">
Technical Matters Concerning General Mappings <#Include Label="[2]{mapping}">

<#Include Label="[4]{mapping}"> <#Include Label="IsSPGeneralMapping"> <#Include Label="IsGeneralMappingFamily"> <#Include Label="FamilyRange"> <#Include Label="FamilySource"> <#Include Label="FamiliesOfGeneralMappingsAndRanges"> <#Include Label="GeneralMappingsFamily"> <#Include Label="TypeOfDefaultGeneralMapping">

gap-4r6p5/doc/ref/alglie.xml0000644000175000017500000003224112172557252014443 0ustar billbill Lie Algebras <#Include Label="[1]{alglie}">
Lie Objects <#Include Label="[1]{liefam}"> <#Include Label="LieObject"> <#Include Label="IsLieObject"> <#Include Label="LieFamily"> <#Include Label="UnderlyingFamily"> <#Include Label="UnderlyingRingElement">
Constructing Lie algebras In this section we describe functions that create Lie algebras. Creating and working with subalgebras goes exactly in the same way as for general algebras; so for that we refer to Chapter . <#Include Label="LieAlgebraByStructureConstants"> <#Include Label="RestrictedLieAlgebraByStructureConstants"> <#Include Label="LieAlgebra"> <#Include Label="FreeLieAlgebra"> <#Include Label="FullMatrixLieAlgebra"> <#Include Label="RightDerivations"> <#Include Label="SimpleLieAlgebra">
Distinguished Subalgebras Here we describe functions that calculate well-known subalgebras and ideals of a Lie algebra (such as the centre, the centralizer of a subalgebra, etc.). <#Include Label="LieCentre"> <#Include Label="LieCentralizer"> <#Include Label="LieNormalizer"> <#Include Label="LieDerivedSubalgebra"> <#Include Label="LieNilRadical"> <#Include Label="LieSolvableRadical"> <#Include Label="CartanSubalgebra">
Series of Ideals <#Include Label="LieDerivedSeries"> <#Include Label="LieLowerCentralSeries"> <#Include Label="LieUpperCentralSeries">
Properties of a Lie Algebra <#Include Label="IsLieAbelian"> <#Include Label="IsLieNilpotent"> <#Include Label="IsLieSolvable">
Semisimple Lie Algebras and Root Systems This section contains some functions for dealing with semisimple Lie algebras and their root systems. <#Include Label="SemiSimpleType"> <#Include Label="ChevalleyBasis"> <#Include Label="IsRootSystem"> <#Include Label="IsRootSystemFromLieAlgebra"> <#Include Label="RootSystem"> <#Include Label="UnderlyingLieAlgebra"> <#Include Label="PositiveRoots"> <#Include Label="NegativeRoots"> <#Include Label="PositiveRootVectors"> <#Include Label="NegativeRootVectors"> <#Include Label="SimpleSystem"> <#Include Label="CartanMatrix"> <#Include Label="BilinearFormMat"> <#Include Label="CanonicalGenerators">
Semisimple Lie Algebras and Weyl Groups of Root Systems This section deals with the Weyl group of a root system. A Weyl group is represented by its action on the weight lattice. A weight is by definition a linear function \lambda: H \rightarrow F (where F is the ground field), such that the values \lambda(h_i) are all integers (where the h_i are the Cartan elements of the ). On the other hand each weight is determined by these values. Therefore we represent a weight by a vector of integers; the i-th entry of this vector is the value \lambda(h_i). Now the elements of the Weyl group are represented by matrices, and if g is an element of a Weyl group and w a weight, then w*g gives the result of applying g to w. Another way of applying the i-th simple reflection to a weight is by using the function .

A Weyl group is generated by the simple reflections. So for a Weyl group W gives a list of matrices and the i-th entry of this list is the simple reflection corresponding to the i-th simple root of the corresponding root system. <#Include Label="IsWeylGroup"> <#Include Label="SparseCartanMatrix"> <#Include Label="WeylGroup"> <#Include Label="ApplySimpleReflection"> <#Include Label="LongestWeylWordPerm"> <#Include Label="ConjugateDominantWeight"> <#Include Label="WeylOrbitIterator">

Restricted Lie algebras A Lie algebra L over a field of characteristic p>0 is called restricted if there is a map x \mapsto x^p from L into L (called a p-map) such that ad x^p = (ad x)^p, (\alpha x)^p = \alpha^p x^p and (x+y)^p = x^p + y^p + \sum_{{i=1}}^{{p-1}} s_i(x,y), where s_i: L \times L \rightarrow L are certain Lie polynomials in two variables. Using these relations we can calculate y^p for all y \in L, once we know x^p for x in a basis of L. Therefore a p-map is represented in &GAP;  by a list containing the images of the basis vectors of a basis B of L. For this reason this list is an attribute of the basis B.

<#Include Label="IsRestrictedLieAlgebra"> <#Include Label="PthPowerImages"> <#Include Label="PthPowerImage"> <#Include Label="JenningsLieAlgebra"> <#Include Label="PCentralLieAlgebra"> <#Include Label="NaturalHomomorphismOfLieAlgebraFromNilpotentGroup">

The Adjoint Representation In this section we show functions for calculating with the adjoint representation of a Lie algebra (and the corresponding trace form, called the Killing form) (see also and ).

<#Include Label="AdjointMatrix"> <#Include Label="AdjointAssociativeAlgebra"> <#Include Label="KillingMatrix"> <#Include Label="KappaPerp"> <#Include Label="IsNilpotentElement"> <#Include Label="NonNilpotentElement"> <#Include Label="FindSl2">

Universal Enveloping Algebras <#Include Label="UniversalEnvelopingAlgebra">
Finitely Presented Lie Algebras Finitely presented Lie algebras can be constructed from free Lie algebras by using the / constructor, i.e., FL/[r1, ..., rk] is the quotient of the free Lie algebra FL by the ideal generated by the elements r1, ..., rk of FL. If the finitely presented Lie algebra K happens to be finite dimensional then an isomorphic structure constants Lie algebra can be constructed by NiceAlgebraMonomorphism(K) (see ), which returns a surjective homomorphism. The structure constants Lie algebra can then be accessed by calling for this map. Also limited computations with elements of the finitely presented Lie algebra are possible.

L:= FreeLieAlgebra( Rationals, "s", "t" ); gap> gL:= GeneratorsOfAlgebra( L );; s:= gL[1];; t:= gL[2];; gap> K:= L/[ s*(s*t), t*(t*(s*t)), s*(t*(s*t))-t*(s*t) ]; gap> h:= NiceAlgebraMonomorphism( K ); [ [(1)*s], [(1)*t] ] -> [ v.1, v.2 ] gap> U:= Range( h ); gap> IsLieNilpotent( U ); true gap> gK:= GeneratorsOfAlgebra( K ); [ [(1)*s], [(1)*t] ] gap> gK[1]*(gK[2]*gK[1]) = Zero( K ); true ]]>

<#Include Label="FpLieAlgebraByCartanMatrix"> <#Include Label="NilpotentQuotientOfFpLieAlgebra">

Modules over Lie Algebras and Their Cohomology Representations of Lie algebras are dealt with in the same way as representations of ordinary algebras (see ). In this section we mainly deal with modules over general Lie algebras and their cohomology. The next section is devoted to modules over semisimple Lie algebras. <#Include Label="[1]{lierep}"> <#Include Label="IsCochain"> <#Include Label="Cochain"> <#Include Label="CochainSpace"> <#Include Label="ValueCochain"> <#Include Label="LieCoboundaryOperator"> <#Include Label="Cocycles"> <#Include Label="Coboundaries">
Modules over Semisimple Lie Algebras This section contains functions for calculating information on representations of semisimple Lie algebras. First we have some functions for calculating some combinatorial data (set of dominant weights, the dominant character, the decomposition of a tensor product, the dimension of a highest-weight module). Then there is a function for creating an admissible lattice in the universal enveloping algebra of a semisimple Lie algebra. Finally we have a function for constructing a highest-weight module over a semisimple Lie algebra.

<#Include Label="DominantWeights"> <#Include Label="DominantCharacter"> <#Include Label="DecomposeTensorProduct"> <#Include Label="DimensionOfHighestWeightModule">

Admissible Lattices in UEA <#Include Label="[2]{lierep}"> <#Include Label="IsUEALatticeElement"> <#Include Label="LatticeGeneratorsInUEA"> An UEALattice element is represented by a list of the form [ m1, c1, m2, c2, ... ], where the c1, c2 etc. are coefficients, and the m1, m2 etc. are monomials. A monomial is a list of the form [ ind1, e1, ind2, e2, ... ] where ind1, ind2 are indices, and e1, e2 etc. are exponents. Let N be the number of positive roots of the underlying Lie algebra L. The indices lie between 1 and dim(L). If an index lies between 1 and N, then it represents a negative root vector (corresponding to the root NegativeRoots( R )[ind], where R is the root system of L; see ). This leads to a factor yind1^(e1) in the printed form of the monomial (which equals z^e1/e1!, where z is a basis element of L). If an index lies between N+1 and 2N, then it represents a positive root vector. Finally, if ind lies between 2N+1 and 2N+rank, then it represents an element of the Cartan subalgebra. This is printed as ( h_1/ e_1 ), meaning {h_1 \choose e_1}, where h_1, \ldots, h_{rank} are the canonical Cartan generators.

The zero element is represented by the empty list, the identity element by the list [ [], 1 ].

L:= SimpleLieAlgebra( "G", 2, Rationals );; gap> g:=LatticeGeneratorsInUEA( L ); [ y1, y2, y3, y4, y5, y6, x1, x2, x3, x4, x5, x6, ( h13/1 ), ( h14/1 ) ] gap> IsUEALatticeElement( g[1] ); true gap> g[1]^3; 6*y1^(3) gap> q:= g[7]*g[1]^2; -2*y1+2*y1*( h13/1 )+2*y1^(2)*x1 gap> ExtRepOfObj( q ); [ [ 1, 1 ], -2, [ 1, 1, 13, 1 ], 2, [ 1, 2, 7, 1 ], 2 ] ]]> <#Include Label="IsWeightRepElement"> <#Include Label="HighestWeightModule">

Tensor Products and Exterior and Symmetric Powers <#Include Label="TensorProductOfAlgebraModules"> <#Include Label="ExteriorPowerOfAlgebraModule"> <#Include Label="SymmetricPowerOfAlgebraModule">
gap-4r6p5/doc/ref/ctbl.xml0000644000175000017500000005475312172557252014146 0ustar billbill Character Tables tables This chapter describes operations for character tables of finite groups.

Operations for characters (or, more general, class functions) are described in Chapter .

For a description of the &GAP; Library of Character Tables, see the separate manual for the &GAP; package CTblLib.

Several examples in this chapter require the &GAP; Character Table Library to be available. If it is not yet loaded then we load it now.

LoadPackage( "ctbllib" ); true ]]>

Some Remarks about Character Theory in &GAP; <#Include Label="[1]{ctbl}">
History of Character Theory Stuff in GAP &GAP; provides functions for dealing with group characters since the version &GAP; 3.1, which was released in March 1992. The reason for adding this branch of mathematics to the topics of &GAP; was (apart from the usefulness of character theoretic computations in general) the insight that &GAP; provides an ideal environment for developing the algorithms needed. In particular, it had been decided at Lehrstuhl D für Mathematik that the CAS system (a standalone Fortran program together with a database of character tables, see ) should not be developed further and the functionality of CAS should be made available in &GAP;. The background was that extending CAS (by new Fortran code) had turned out to be much less flexible than writing analogous &GAP; library code.

For integrating the existing character theory algorithms, &GAP;'s memory management and long integer arithmetic were useful as well as the list handling –it is an important feature of character theoretic methods that questions about groups are translated into manipulations of lists; on the other hand, the datatype of cyclotomics (see Chapter ) was added to the &GAP; kernel because of the character theory algorithms. For developing further code, also other areas of &GAP;'s library became interesting, such as permutation groups, finite fields, and polynomials.

The development of character theory code for &GAP; has been supported by several DFG grants, in particular the project Representation Theory of Finite Groups and Finite Dimensional Algebras (until 1991), and the Schwerpunkt Algorithmische Zahlentheorie und Algebra (from 1991 until 1997). Besides that, several Diploma theses at Lehrstuhl D were concerned with the development and/or implementation of algorithms dealing with characters in &GAP;.

The major contributions can be listed as follows. The arithmetic for the cyclotomics data type, following , was first implemented by Marco van Meegen; an alternative approach was studied in the diploma thesis of Michael Scherner (see ) but was not efficient enough; later Martin Schönert replaced the implementation by a better one. The basic routines for characters and character tables were written by Thomas Breuer and Götz Pfeiffer. The lattice related functions, such as , , and , were implemented by Ansgar Kaup (see ). Functions for computing possible class fusions, possible power maps, and table automorphisms were written by Thomas Breuer (see ). Functions for computing possible permutation characters were written by Thomas Breuer (see ) and Götz Pfeiffer (see ). Functions for computing character tables from groups were written by Alexander Hulpke (Dixon-Schneider algorithm, see ) and Hans Ulrich Besche (Baum algorithm and Conlon algorithm, see ). Functions for dealing with Clifford matrices were written by Ute Schiffer (see ). Functions for monomiality questions were written by Thomas Breuer and Erzsébet Horváth.

Since then, the code has been maintained and extended further by Alexander Hulpke (code related to his implementation of the Dixon-Schneider algorithm) and Thomas Breuer.

Currently &GAP; does not provide special functionality for computing Brauer character tables, but there is an interface to the MOC system (see ), and the &GAP; Character Table Library contains many known Brauer character tables.

Creating Character Tables <#Include Label="[10]{ctbl}"> <#Include Label="CharacterTable"> <#Include Label="BrauerTable"> <#Include Label="CharacterTableRegular"> <#Include Label="SupportedCharacterTableInfo"> <#Include Label="ConvertToCharacterTable">
Character Table Categories <#Include Label="IsNearlyCharacterTable"> <#Include Label="InfoCharacterTable"> <#Include Label="NearlyCharacterTablesFamily">
Conventions for Character Tables The following few conventions should be noted. The class of the identity element is expected to be the first one; thus the degree of a character is the character value at position 1. The trivial character of a character table need not be the first in the list of irreducibles. Most functions that take a character table as an argument and work with characters expect these characters as an argument, too. For some functions, the list of irreducible characters serves as the default, i.e, the value of the attribute ; in these cases, the value is automatically computed if it was not yet known. For a stored class fusion, the image table is denoted by its value; each library table has a unique identifier by which it can be accessed (see  in the manual for the &GAP; Character Table Library), tables constructed from groups get an identifier that is unique in the current &GAP; session.
The Interface between Character Tables and Groups <#Include Label="[2]{ctbl}"> <#Include Label="UnderlyingGroup:ctbl"> <#Include Label="ConjugacyClasses:ctbl"> <#Include Label="IdentificationOfConjugacyClasses"> <#Include Label="CharacterTableWithStoredGroup"> <#Include Label="CompatibleConjugacyClasses">
Operators for Character Tables <#Include Label="[3]{ctbl}">
Attributes and Properties for Groups and Character Tables <#Include Label="[4]{ctbl}"> <#Include Label="CharacterDegrees"> <#Include Label="Irr"> <#Include Label="LinearCharacters"> <#Include Label="OrdinaryCharacterTable"> <#Include Label="[5]{ctbl}">
Attributes and Properties only for Character Tables <#Include Label="[6]{ctbl}"> <#Include Label="OrdersClassRepresentatives"> <#Include Label="SizesCentralizers"> <#Include Label="SizesConjugacyClasses"> <#Include Label="AutomorphismsOfTable"> <#Include Label="UnderlyingCharacteristic"> <#Include Label="ClassNames"> <#Include Label="ClassParameters"> <#Include Label="Identifier:ctbl"> <#Include Label="InfoText"> <#Include Label="InverseClasses"> <#Include Label="RealClasses"> <#Include Label="ClassOrbit"> <#Include Label="ClassRoots">
Normal Subgroups Represented by Lists of Class Positions <#Include Label="[8]{ctbl}"> <#Include Label="ClassPositionsOfNormalSubgroups"> <#Include Label="ClassPositionsOfAgemo"> <#Include Label="ClassPositionsOfCentre:ctbl"> <#Include Label="ClassPositionsOfDirectProductDecompositions"> <#Include Label="ClassPositionsOfDerivedSubgroup"> <#Include Label="ClassPositionsOfElementaryAbelianSeries"> <#Include Label="ClassPositionsOfFittingSubgroup"> <#Include Label="ClassPositionsOfLowerCentralSeries"> <#Include Label="ClassPositionsOfUpperCentralSeries"> <#Include Label="ClassPositionsOfSupersolvableResiduum"> <#Include Label="ClassPositionsOfPCore"> <#Include Label="ClassPositionsOfNormalClosure">
Operations Concerning Blocks <#Include Label="PrimeBlocks"> <#Include Label="SameBlock"> <#Include Label="BlocksInfo"> <#Include Label="DecompositionMatrix"> <#Include Label="LaTeXStringDecompositionMatrix">
Other Operations for Character Tables <#Include Label="[9]{ctbl}">

<#Include Label="Index!for_character_tables"> <#Include Label="IsInternallyConsistent!for_character_tables"> <#Include Label="IsPSolvableCharacterTable"> <#Include Label="IsClassFusionOfNormalSubgroup"> <#Include Label="Indicator"> <#Include Label="NrPolyhedralSubgroups"> <#Include Label="ClassMultiplicationCoefficient:ctbl"> <#Include Label="ClassStructureCharTable"> <#Include Label="MatClassMultCoeffsCharTable">

Printing Character Tables <#Include Label="[11]{ctbl}"> <#Include Label="DisplayOptions"> <#Include Label="PrintCharacterTable">
Computing the Irreducible Characters of a Group Several algorithms are available for computing the irreducible characters of a finite group G. The default method for arbitrary finite groups is to use the Dixon-Schneider algorithm (see ). For supersolvable groups, Conlon's algorithm can be used (see ). For abelian-by-supersolvable groups, the Baum-Clausen algorithm for computing the irreducible representations (see ) can be used to compute the irreducible characters (see ).

These functions are installed in methods for , but explicitly calling one of them will not set the value of G. <#Include Label="IrrDixonSchneider"> <#Include Label="IrrConlon"> <#Include Label="IrrBaumClausen"> <#Include Label="IrreducibleRepresentations"> <#Include Label="IrreducibleRepresentationsDixon">

Representations Given by Modules This section describes functions that return certain modules of a given group. (Extensions by modules can be formed by the command .) <#Include Label="IrreducibleModules"> <#Include Label="AbsoluteIrreducibleModules"> <#Include Label="RegularModule">
The Dixon-Schneider Algorithm <#Include Label="[1]{ctblgrp}">
Advanced Methods for Dixon-Schneider Calculations irreducible characters The computation of irreducible characters of very large groups may take quite some time. On the other hand, for the expert only a few irreducible characters may be needed, since the other ones can be computed using character theoretic methods such as tensoring, induction, and restriction. Thus &GAP; provides also step-by-step routines for doing the calculations. These routines allow one to compute some characters and to stop before all are calculated. Note that there is no safety net: The routines (being somehow internal) do no error checking, and assume the information given is correct.

When the info level of if positive, information about the progress of splitting is printed. (The default value is zero.) <#Include Label="DixonRecord"> <#Include Label="DixonInit"> <#Include Label="DixontinI"> <#Include Label="DixonSplit"> <#Include Label="BestSplittingMatrix"> <#Include Label="DxIncludeIrreducibles"> <#Include Label="SplitCharacters"> <#Include Label="IsDxLargeGroup">

Components of a Dixon Record The Dixon record D returned by stores all the information that is used by the Dixon-Schneider routines while computing the irreducible characters of a group. Some entries, however, may be useful to know about when using the algorithm interactively, see . group the group G of which the character table is to be computed, conjugacyClasses classes of G (all characters stored in the Dixon record correspond to this arrangement of classes), irreducibles the already known irreducible characters (given as lists of their values on the conjugacy classes), characterTable the value of G (whose irreducible characters are not yet known), ClassElement( D, el ) a function that returns the number of the class of G that contains the element el.
An Example of Advanced Dixon-Schneider Calculations First, we set the appropriate info level higher.

SetInfoLevel( InfoCharacterTable, 1 ); ]]>

for printout of some internal results. We now define our group, which is isomorphic to PSL_4(3).

g:= PrimitiveGroup(40,5); PSL(4, 3) gap> Size(g); 6065280 gap> d:= DixonInit( g );; #I 29 classes #I choosing prime 65521 gap> c:= d.characterTable;; ]]>

After the initialisation, one structure matrix is evaluated, yielding smaller spaces and several irreducible characters.

DixonSplit( d ); #I Matrix 9,Representative of Order 3,Centralizer: 5832 #I Dimensions: [ 1, 2, 1, 4, 12, 1, 1, 2, 1, 2, 1 ] #I Two-dim space split #I Two-dim space split #I Two-dim space split 9 ]]>

In this case spaces of the listed dimensions are a result of the splitting process. The three two dimensional spaces are split successfully by combinatoric means.

We obtain several irreducible characters by tensor products and notify them to the Dixon record.

asp:= AntiSymmetricParts( c, d.irreducibles, 2 );; gap> ro:= ReducedCharacters( c, d.irreducibles, asp );; gap> Length( ro.irreducibles ); 3 gap> DxIncludeIrreducibles( d, ro.irreducibles ); ]]>

The tensor products of the nonlinear characters among each other are reduced with the irreducible characters. The result is split according to the spaces found, which yields characters of smaller norms, but no new irreducibles.

nlc:= Filtered( d.irreducibles, i -> i[1] > 1 );; gap> t:= Tensored( nlc, nlc );; gap> ro:= ReducedCharacters( c, d.irreducibles, t );; ro.irreducibles; [ ] gap> List( ro.remainders, i -> ScalarProduct( c, i, i) ); [ 2, 2, 4, 4, 4, 4, 13, 13, 18, 18, 19, 21, 21, 36, 36, 29, 34, 34, 42, 34, 48, 54, 62, 68, 68, 78, 84, 84, 88, 90, 159, 169, 169, 172, 172, 266, 271, 271, 268, 274, 274, 280, 328, 373, 373, 456, 532, 576, 679, 683, 683, 754, 768, 768, 890, 912, 962, 1453, 1453, 1601, 1601, 1728, 1739, 1739, 1802, 2058, 2379, 2414, 2543, 2744, 2744, 2920, 3078, 3078, 4275, 4275, 4494, 4760, 5112, 5115, 5115, 5414, 6080, 6318, 7100, 7369, 7369, 7798, 8644, 10392, 12373, 12922, 14122, 14122, 18948, 21886, 24641, 24641, 25056, 38942, 44950, 78778 ] gap> t:= SplitCharacters( d, ro.remainders );; gap> List( t, i -> ScalarProduct( c, i, i ) ); [ 2, 2, 4, 2, 2, 4, 4, 3, 6, 5, 5, 9, 9, 4, 12, 13, 18, 18, 20, 18, 20, 24, 26, 32, 32, 16, 42, 59, 69, 69, 72, 72, 36, 72, 78, 78, 84, 122, 117, 127, 117, 127, 64, 132, 100, 144, 196, 256, 456, 532, 576, 679, 683, 683, 754, 768, 768, 890, 912, 962, 1453, 1453, 1601, 1601, 1728, 1739, 1739, 1802, 2058, 2379, 2414, 2543, 2744, 2744, 2920, 3078, 3078, 4275, 4275, 4494, 4760, 5112, 5115, 5115, 5414, 6080, 6318, 7100, 7369, 7369, 7798, 8644, 10392, 12373, 12922, 14122, 14122, 18948, 21886, 24641, 24641, 25056, 38942, 44950, 78778 ] ]]>

Finally we calculate the characters induced from all cyclic subgroups and obtain the missing irreducibles by applying the LLL-algorithm to them.

ic:= InducedCyclic( c, "all" );; gap> ro:= ReducedCharacters( c, d.irreducibles, ic );; gap> Length( ro.irreducibles ); 0 gap> l:= LLL( c, ro.remainders );; gap> Length( l.irreducibles ); 13 ]]>

The LLL returns class function objects (see Chapter ), and the Dixon record works with character values lists. So we convert them to a list of values before feeding them in the machinery of the Dixon-algorithm.

l.irreducibles[1]; Character( CharacterTable( PSL(4, 3) ), [ 640, E(13)^7+E(13)^8+E(13)^11, E(13)^4+E(13)^10+E(13)^12, E(13)^2+E(13)^5+E(13)^6, E(13)+E(13)^3+E(13)^9, 0, -8, 0, -8, 0, 0, 0, 0, 0, -8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1 ] ) gap> l:=List(l.irreducibles,ValuesOfClassFunction);; gap> DxIncludeIrreducibles( d, l ); gap> Length( d.irreducibles ); 29 gap> Length( d.classes ); 29 ]]>

It turns out we have found all irreducible characters. As the last step, we obtain the irreducible characters and tell them to the group. This makes them available also to the character table.

irrs:= DixontinI( d );; #I Total:1 matrices,[ 9 ] gap> SetIrr(g,irrs); gap> Length(Irr(c)); 29 gap> SetInfoLevel( InfoCharacterTable, 0 ); ]]>

Constructing Character Tables from Others <#Include Label="[12]{ctbl}"> <#Include Label="CharacterTableDirectProduct"> <#Include Label="FactorsOfDirectProduct"> <#Include Label="CharacterTableFactorGroup"> <#Include Label="CharacterTableIsoclinic"> <#Include Label="CharacterTableWreathSymmetric">
Sorted Character Tables <#Include Label="CharacterTableWithSortedCharacters"> <#Include Label="SortedCharacters"> <#Include Label="CharacterTableWithSortedClasses"> <#Include Label="SortedCharacterTable"> <#Include Label="ClassPermutation">
Automorphisms and Equivalence of Character Tables <#Include Label="MatrixAutomorphisms"> <#Include Label="TableAutomorphisms"> <#Include Label="TransformingPermutations"> <#Include Label="TransformingPermutationsCharacterTables"> <#Include Label="FamiliesOfRows">
Storing Normal Subgroup Information <#Include Label="NormalSubgroupClassesInfo"> <#Include Label="ClassPositionsOfNormalSubgroup"> <#Include Label="NormalSubgroupClasses"> <#Include Label="FactorGroupNormalSubgroupClasses">
gap-4r6p5/doc/ref/fpsemi.xml0000644000175000017500000002662712172557252014504 0ustar billbill Finitely Presented Semigroups and Monoids A finitely presented semigroup (resp. finitely presented monoid) is a quotient of a free semigroup (resp. free monoid) on a finite number of generators over a finitely generated congruence on the free semigroup (resp. free monoid).

Finitely presented semigroups are obtained by factoring a free semigroup by a set of relations (a generating set for the congruence), i.e., a set of pairs of words in the free semigroup.

f:=FreeSemigroup("a","b");; gap> x:=GeneratorsOfSemigroup(f);; gap> s:=f/[ [x[1]*x[2],x[2]*x[1]] ]; gap> GeneratorsOfSemigroup(s); [ a, b ] gap> RelationsOfFpSemigroup(s); [ [ a*b, b*a ] ] ]]>

Finitely presented monoids are obtained by factoring a free monoid by a set of relations, i.e. a set of pairs of words in the free monoid.

f:=FreeMonoid("a","b");; gap> x:=GeneratorsOfMonoid(f); [ a, b ] gap> e:=Identity(f); gap> m:=f/[ [x[1]*x[2],e] ]; gap> RelationsOfFpMonoid(m); [ [ a*b, ] ] ]]>

Notice that for &GAP; a finitely presented monoid is not a finitely presented semigroup.

IsFpSemigroup(m); false ]]>

However, one can build a finitely presented semigroup isomorphic to that finitely presented monoid (see ).

Also note that is not possible to refer to the generators by their names. These names are not variables, but just display figures. So, if one wants to access the generators by their names, one first has to introduce the respective variables and to assign the generators to them. Unbind(a); gap> f:=FreeSemigroup("a","b");; gap> x:=GeneratorsOfSemigroup(f);; gap> s:=f/[ [x[1]*x[2],x[2]*x[1]] ];; gap> a; Error, Variable: 'a' must have a value gap> a:=GeneratorsOfSemigroup(s)[1]; a gap> b:=GeneratorsOfSemigroup(s)[2]; b gap> a in f; false gap> a in s; true ]]>

The generators of the free semigroup (resp. free monoid) are different from the generators of the finitely presented semigroup (resp. finitely presented monoid) (even though they are displayed by the same names). This means that words in the generators of the free semigroup (resp. free monoid) are not elements of the finitely presented semigroup (resp. finitely presented monoid). Conversely elements of the finitely presented semigroup (resp. finitely presented monoid) are not words of the free semigroup (resp. free monoid).

Calculations comparing elements of an finitely presented semigroup may run into problems: there are finitely presented semigroups for which no algorithm exists (it is known that no such algorithm can exist) that will tell for two arbitrary words in the generators whether the corresponding elements in the finitely presented semigroup are equal. Therefore the methods used by &GAP; to compute in finitely presented semigroups may run into warning errors, run out of memory or run forever. If the finitely presented semigroup is (by theory) known to be finite the algorithms are guaranteed to terminate (if there is sufficient memory available), but the time needed for the calculation cannot be bounded a priori. The same can be said for monoids. (See .)

a*b=a^5; false gap> a^5*b^2*a=a^6*b^2; true ]]>

Note that elements of a finitely presented semigroup (or monoid) are not printed in a unique way:

a^5*b^2*a; a^5*b^2*a gap> a^6*b^2; a^6*b^2 ]]>

IsSubsemigroupFpSemigroup (Filter) <#Include Label="IsSubsemigroupFpSemigroup"> <#Include Label="IsSubmonoidFpMonoid"> <#Include Label="IsFpSemigroup"> <#Include Label="IsFpMonoid"> <#Include Label="IsElementOfFpSemigroup"> <#Include Label="IsElementOfFpMonoid"> <#Include Label="FpGrpMonSmgOfFpGrpMonSmgElement">
Creating Finitely Presented Semigroups quotient creates a finitely presented semigroup given by the presentation \langle gens \mid rels \rangle where gens are the generators of the free semigroup F, and the relations rels are entered as pairs of words in the generators of the free semigroup.

The same result is obtained with the infix operator /, i.e., as F / rels.

f:=FreeSemigroup(3);; gap> s:=GeneratorsOfSemigroup(f);; gap> f/[ [s[1]*s[2]*s[1],s[1]] , [s[2]^4,s[1]] ]; ]]> <#Include Label="FactorFreeSemigroupByRelations"> <#Include Label="IsomorphismFpSemigroup">

Comparison of Elements of Finitely Presented Semigroups comparison Two elements a, b of a finitely presented semigroup are equal if they are equal in the semigroup. Nevertheless they may be represented as different words in the generators. Because of the fundamental problems mentioned in the introduction to this chapter such a test may take a very long time and cannot be guaranteed to finish (see ).
Preimages in the Free Semigroup Elements of a finitely presented semigroup are not words, but are represented using a word from the free semigroup as representative.

for an element elm of a finitely presented semigroup, it returns the word from the free semigroup that is used as a representative for elm.

f := FreeSemigroup( "a" , "b" );; gap> a := GeneratorsOfSemigroup( f )[ 1 ];; gap> b := GeneratorsOfSemigroup( f )[ 2 ];; gap> s := f / [ [ a^3 , a ] , [ b^3 , b ] , [ a*b , b*a ] ]; gap> w := GeneratorsOfSemigroup(s)[1] * GeneratorsOfSemigroup(s)[2]; a*b gap> IsWord (w ); false gap> ue := UnderlyingElement( w ); a*b gap> IsWord( ue ); true ]]> <#Include Label="ElementOfFpSemigroup"> <#Include Label="FreeSemigroupOfFpSemigroup"> <#Include Label="FreeGeneratorsOfFpSemigroup"> <#Include Label="RelationsOfFpSemigroup">

Finitely presented monoids The functionality available for finitely presented monoids is essentially the same as that available for finitely presented semigroups, and thus the previous sections apply (with the obvious changes) to finitely presented monoids. quotient creates a finitely presented monoid given by the monoid presentation \langle gens \mid rels \rangle where gens are the generators of the free monoid F, and the relations rels are entered as pairs of words in both the identity and the generators of the free monoid.

The same result is obtained with the infix operator /, i.e., as F/rels.

f := FreeMonoid( 3 ); gap> x := GeneratorsOfMonoid( f ); [ m1, m2, m3 ] gap> e:= Identity ( f ); gap> m := f/[ [x[1]^3,e] , [x[1]*x[2],x[2] ]]; ]]>

Rewriting Systems and the Knuth-Bendix Procedure If a finitely presented semigroup has a confluent rewriting system then it has a solvable word problem, that is, there is an algorithm to decide when two words in the free underlying semigroup represent the same element of the finitely presented semigroup. Indeed, once we have a confluent rewriting system, it is possible to successfully test that two words represent the same element in the semigroup, by reducing both words using the rewriting system rules. This is, at the moment, the method that &GAP; uses to check equality in finitely presented semigroups and monoids.

<#Include Label="ReducedConfluentRewritingSystem"> <#Include Label="KB_REW"> KnuthBendixRewritingSystem in the first form, for a semigroup s and a reduction ordering for the underlying free semigroup, it returns the Knuth-Bendix rewriting system of the finitely presented semigroup s using the reduction ordering wordord. In the second form, for a monoid m and a reduction ordering for the underlying free monoid, it returns the Knuth-Bendix rewriting system of the finitely presented monoid m using the reduction ordering wordord. <#Include Label="SemigroupOfRewritingSystem"> <#Include Label="MonoidOfRewritingSystem"> <#Include Label="FreeSemigroupOfRewritingSystem"> <#Include Label="FreeMonoidOfRewritingSystem">

Todd-Coxeter Procedure This procedure gives a standard way of finding a transformation representation of a finitely presented semigroup. Usually one does not explicitly call this procedure but uses or . <#Include Label="CosetTableOfFpSemigroup">
gap-4r6p5/doc/ref/create.xml0000644000175000017500000014336012172557252014456 0ustar billbill Creating New Objects This chapter is divided into three parts.

In the first part, it is explained how to create filters (see , , , ), operations (see ), families (see ), types (see ), and objects with given type (see ).

In the second part, first a few small examples are given, for dealing with the usual cases of component objects (see ) and positional objects (see ), and for the implementation of new kinds of lists (see  and ). Finally, the external representation of objects is introduced (see ), as a tool for representation independent access to an object.

The third part deals with some rules concerning the organization of the &GAP; library; namely, some commands for creating global variables are explained (see ) that correspond to the ones discussed in the first part of the chapter, and the idea of distinguishing declaration and implementation part of &GAP; packages is outlined (see ).

See also Chapter  for examples how the functions from the first part are used, and why it is useful to have a declaration part and an implementation part.

Creating Categories <#Include Label="NewCategory"> <#Include Label="CategoryFamily">

See also .

Creating Representations <#Include Label="NewRepresentation">
Creating Attributes and Properties Each method that is installed for an attribute or a property via must require exactly one argument, and this must lie in the filter filter that was entered as second argument of resp. .

As for any operation (see ), for attributes and properties one can install a method taking an argument that does not lie in filt via , or a method for more than one argument; in the latter case, clearly the result value is not stored in any of the arguments. <#Include Label="NewAttribute"> <#Include Label="NewProperty">

Creating Other Filters In order to change the value of filt for an object obj, one can use logical implications (see ) or , . <#Include Label="NewFilter"> <#Include Label="SetFilterObj"> <#Include Label="ResetFilterObj">
Creating Operations <#Include Label="NewOperation">
Creating Families Families are probably the least obvious part of the &GAP; type system, so some remarks about the role of families are necessary. When one uses &GAP; as it is, one will (better: should) not meet families at all. The two situations where families come into play are the following.

First, since families are used to describe relations between arguments of operations in the method selection mechanism (see Chapter , and also Chapter ), one has to prescribe such a relation in each method installation (see ); usual relations are (which means that any relation of the actual arguments is admissible), (which means that there are two arguments that lie in the same family), and IsCollsElms (which means that there are two arguments, the first being a collection of elements that lie in the same family as the second argument).

Second –and this is the more complicated situation– whenever one creates a new kind of objects, one has to decide what its family shall be. If the new object shall be equal to existing objects, for example if it is just represented in a different way, there is no choice: The new object must lie in the same family as all objects that shall be equal to it. So only if the new object is different (w.r.t. the equality =) from all other &GAP; objects, we are likely to create a new family for it. Note that enlarging an existing family by such new objects may be problematic because of implications that have been installed for all objects of the family in question. The choice of families depends on the applications one has in mind. For example, if the new objects in question are not likely to be arguments of operations for which family relations are relevant (for example binary arithmetic operations), one could create one family for all such objects, and regard it as the family of all those &GAP; objects that would in fact not need a family. On the other extreme, if one wants to create domains of the new objects then one has to choose the family in such a way that all intended elements of a domain do in fact lie in the same family. (Remember that a domain is a collection, see Chapter , and that a collection consists of elements in the same family, see Chapter  and Section .)

Let us look at an example. Suppose that no permutations are available in &GAP;, and that we want to implement permutations. Clearly we want to support permutation groups, but it is not a priori clear how to distribute the new permutations into families. We can put all permutations into one family; this is how in fact permutations are implemented in &GAP;. But it would also be possible to put all permutations of a given degree into a family of their own; this would for example mean that for each degree, there would be distinguished trivial permutations, and that the stabilizer of the point 5 in the symmetric group on the points 1, 2, \ldots, 5 is not regarded as equal to the symmetric group on 1, 2, 3, 4. Note that the latter approach would have the advantage that it is no problem to construct permutations and permutation groups acting on arbitrary (finite) sets, for example by constructing first the symmetric group on the set and then generating any desired permutation group as a subgroup of this symmetric group.

So one aspect concerning a reasonable choice of families is to make the families large enough for being able to form interesting domains of elements in the family. But on the other hand, it is useful to choose the families small enough for admitting meaningful relations between objects. For example, the elements of different free groups in &GAP; lie in different families; the multiplication of free group elements is installed only for the case that the two operands lie in the same family, with the effect that one cannot erroneously form the product of elements from different free groups. In this case, families appear as a tool for providing useful restrictions.

As another example, note that an element and a collection containing this element never lie in the same family, by the general implementation of collections; namely, the family of a collection of elements in the family Fam is the collections family of Fam (see ). This means that for a collection, we need not (because we cannot) decide about its family.

A few functions in &GAP; return families, see and . <#Include Label="NewFamily">

Creating Types <#Include Label="NewType">
Creating Objects New objects are created by . data is a list or a record, and type is the type that the desired object shall have. turns data into an object with type type. That is, data is changed, and afterwards it will not be a list or a record unless type is of type list resp. record.

If data is a list then turns it into a positional object, if data is a record then turns it into a component object (for examples, see  and ).

does also return the object that it made out of data.

For examples where is used, see , , and the example in Chapter . <#Include Label="ObjectifyWithAttributes">

Component Objects A component object is an object in the representation IsComponentObjectRep or a subrepresentation of it. Such an object cobj is built from subobjects that can be accessed via cobj!.name, similar to components of a record. Also analogously to records, values can be assigned to components of cobj via cobj!.name:= val. For the creation of component objects, see . One must be very careful when using the !. operator, in order to interpret the component in the right way, and even more careful when using the assignment to components using !., in order to keep the information stored in cobj consistent.

First of all, in the access or assignment to a component as shown above, name must be among the admissible component names for the representation of cobj, see . Second, preferably only few low level functions should use !., whereas this operator should not occur in user interactions.

Note that even if cobj claims that it is immutable, i.e., if cobj is not in the category , access and assignment via !. and !.:= work. This is necessary for being able to store newly discovered information in immutable objects.

The following example shows the implementation of an iterator (see ) for the domain of integers, which is represented as component object. See  for an implementation using positional objects. (In practice, such an iterator can be implemented more elegantly using , see .)

The used succession of integers is 0, 1, -1, 2, -2, 3, -3, \ldots, that is, a_n = n/2 if n is even, and a_n = (1-n)/2 otherwise.

The above command creates a new representation (see ) IsIntegersIteratorCompRep, as a subrepresentation of IsComponentObjectRep, and with one admissible component counter. So no other components than counter will be needed.

After the above method installation, one can already ask for Iterator( Integers ). Note that exactly the domain of integers is described by the filter .

By the call to , the returned object lies in the family containing all iterators, which is IteratorsFamily, it lies in the category and in the representation IsIntegersIteratorCompRep; furthermore, it has the component counter with value 0.

What is missing now are methods for the two basic operations of iterators, namely and . The former must always return false, since there are infinitely many integers. The latter must return the next integer in the iteration, and update the information stored in the iterator, that is, increase the value of the component counter.

<#Include Label="NamesOfComponents">

Positional Objects A positional object is an object in the representation IsPositionalObjectRep or a subrepresentation of it. Such an object pobj is built from subobjects that can be accessed via pobj![pos], similar to positions in a list. Also analogously to lists, values can be assigned to positions of pobj via pobj![pos]:= val. For the creation of positional objects, see .

One must be very careful when using the ![] operator, in order to interpret the position in the right way, and even more careful when using the assignment to positions using ![], in order to keep the information stored in pobj consistent.

First of all, in the access or assignment to a position as shown above, pos must be among the admissible positions for the representation of pobj, see . Second, preferably only few low level functions should use ![], whereas this operator should not occur in user interactions.

Note that even if pobj claims that it is immutable, i.e., if pobj is not in the category , access and assignment via ![] work. This is necessary for being able to store newly discovered information in immutable objects.

The following example shows the implementation of an iterator (see ) for the domain of integers, which is represented as positional object. See  for an implementation using component objects, and more details.

The above command creates a new representation (see ) IsIntegersIteratorPosRep, as a subrepresentation of IsComponentObjectRep, and with only the first position being admissible for storing data.

After the above method installation, one can already ask for Iterator( Integers ). Note that exactly the domain of integers is described by the filter .

By the call to , the returned object lies in the family containing all iterators, which is IteratorsFamily, it lies in the category and in the representation IsIntegersIteratorPosRep; furthermore, the first position has value 0.

What is missing now are methods for the two basic operations of iterators, namely and . The former must always return false, since there are infinitely many integers. The latter must return the next integer in the iteration, and update the information stored in the iterator, that is, increase the value stored in the first position.

It should be noted that one can of course install both the methods shown in Section  and . The call Iterator( Integers ) will cause one of the methods to be selected, and for the returned iterator, which will have one of the representations we constructed, the right method will be chosen.

Implementing New List Objects This section gives some hints for the quite usual situation that one wants to implement new objects that are lists. More precisely, one either wants to deal with lists that have additional features, or one wants that some objects also behave as lists. An example can be found in .

A list in &GAP; is an object in the category . Basic operations for lists are , , and (see ).

Note that the access to the position pos in the list list via list[pos] is handled by the call \[\]( list, pos ) to the operation . To explain the somewhat strange name \[\] of this operation, note that non-alphanumeric characters like [ and ] may occur in &GAP; variable names only if they are escaped by a \ character.

Analogously, the check IsBound( list[pos] ) whether the position pos of the list list is bound is handled by the call IsBound\[\]( list, pos ) to the operation .

For mutable lists, also assignment to positions and unbinding of positions via the operations and are basic operations. The assignment list[pos]:= val is handled by the call \[\]\:\=( list, pos, val ), and Unbind( list[pos] ) is handled by the call Unbind\[\]( list, pos ).

All other operations for lists, e.g., , , , are based on these operations. This means that it is sufficient to install methods for the new list objects only for the basic operations.

So if one wants to implement new list objects then one creates them as objects in the category , and installs methods for , , and . If the new lists shall be mutable, one needs to install also methods for and .

One application for this is the implementation of enumerators for domains. An enumerator for the domain D is a dense list whose entries are in bijection with the elements of D. If D is large then it is not useful to write down all elements. Instead one can implement such a bijection implicitly. This works also for infinite domains.

In this situation, one implements a new representation of the lists that are already available in &GAP;, in particular the family of such a list is the same as the family of the domain D.

But it is also possible to implement new kinds of lists that lie in new families, and thus are not equal to lists that were available in &GAP; before. An example for this is the implementation of matrices whose multiplication via * is the Lie product of matrices.

In this situation, it makes no sense to put the new matrices into the same family as the original matrices. Note that the product of two Lie matrices shall be defined but not the product of an ordinary matrix and a Lie matrix. So it is possible to have two lists that have the same entries but that are not equal w.r.t. = because they lie in different families.

Example – Constructing Enumerators When dealing with countable sets, a usual task is to define enumerations, i.e., bijections to the positive integers. In &GAP;, this can be implemented via enumerators (see ). These are lists containing the elements in a specified ordering, and the operations and list access via define the desired bijection. For implementing such an enumerator, one mainly needs to install the appropriate functions for these operations.

A general setup for creating such lists is given by .

If the set in question is a domain D for which a method is available then all one has to do is to write down the functions for computing the n-th element of the list and for computing the position of a given &GAP; object in the list, to put them into the components ElementNumber and NumberElement of a record, and to call with the domain D and this record as arguments. For example, the following lines of code install an method for the case that D is the domain of rational integers. (Note that is a filter that describes exactly the domain of rational integers.)

EnumeratorByFunctions( Integers, rec( ElementNumber := function( e, n ) ... end, NumberElement := function( e, x ) ... end ) ) ); ]]>

The bodies of the functions have been omitted above; here is the code that is actually used in &GAP;. (The ordering coincides with that for the iterators for the domain of rational integers that have been discussed in  and .)

enum:= Enumerator( Integers ); gap> Print( enum!.NumberElement, "\n" ); function ( e, x ) local pos; if not IsInt( x ) then return fail; elif 0 < x then pos := 2 * x; else pos := -2 * x + 1; fi; return pos; end gap> Print( enum!.ElementNumber, "\n" ); function ( e, n ) if n mod 2 = 0 then return n / 2; else return (1 - n) / 2; fi; return; end ]]>

The situation becomes slightly more complicated if the set S in question is not a domain. This is because one must provide also at least a method for computing the length of the list, and because one has to determine the family in which it lies (see ). The latter should usually not be a problem since either S is nonempty and all its elements lie in the same family –in this case one takes the collections family of any element in S– or the family of the enumerator must be ListsFamily.

An example in the &GAP; library is an enumerator for the set of k-tuples over a finite set; the function is called .

Print( EnumeratorOfTuples, "\n" ); function ( set, k ) local enum; if k = 0 then return Immutable( [ [ ] ] ); elif IsEmpty( set ) then return Immutable( [ ] ); fi; enum := EnumeratorByFunctions( CollectionsFamily( FamilyObj( set ) ), rec( ElementNumber := function ( enum, n ) local nn, t, i; nn := n - 1; t := [ ]; for i in [ 1 .. enum!.k ] do t[i] := RemInt( nn, Length( enum!.set ) ) + 1; nn := QuoInt( nn, Length( enum!.set ) ); od; if nn <> 0 then Error( "[", n, "] must have an assigned value" ); fi; nn := enum!.set{Reversed( t )}; MakeImmutable( nn ); return nn; end, NumberElement := function ( enum, elm ) local n, i; if not IsList( elm ) then return fail; fi; elm := List( elm, function ( x ) return Position( enum!.set, x ); end ); if fail in elm or Length( elm ) <> enum!.k then return fail; fi; n := 0; for i in [ 1 .. enum!.k ] do n := Length( enum!.set ) * n + elm[i] - 1; od; return n + 1; end, Length := function ( enum ) return Length( enum!.set ) ^ enum!.k; end, PrintObj := function ( enum ) Print( "EnumeratorOfTuples( ", enum!.set, ", ", enum!.k, " )" ); return; end, set := Set( set ), k := k ) ); SetIsSSortedList( enum, true ); return enum; end ]]>

We see that the enumerator is a homogeneous list that stores individual functions ElementNumber, NumberElement, Length, and PrintObj; besides that, the data components S and k are contained.

Example – Constructing Iterators Iterators are a kind of objects that is implemented for several collections in the &GAP; library and which might be interesting also in other cases, see . A general setup for implementing new iterators is provided by .

All one has to do is to write down the functions for , , and , and to call with this record as argument. For example, the following lines of code install an method for the case that the argument is the domain of rational integers.

(Note that is a filter that describes exactly the domain of rational integers.)

IteratorByFunctions( rec( NextIterator:= function( iter ) ... end, IsDoneIterator := ReturnFalse, ShallowCopy := function( iter ) ... end ) ) ); ]]>

The bodies of two of the functions have been omitted above; here is the code that is actually used in &GAP;. (The ordering coincides with that for the iterators for the domain of rational integers that have been discussed in  and .)

iter:= Iterator( Integers ); gap> Print( iter!.NextIterator, "\n" ); function ( iter ) iter!.counter := iter!.counter + 1; if iter!.counter mod 2 = 0 then return iter!.counter / 2; else return (1 - iter!.counter) / 2; fi; return; end gap> Print( iter!.ShallowCopy, "\n" ); function ( iter ) return rec( counter := iter!.counter ); end ]]>

Note that the ShallowCopy component of the record must be a function that does not return an iterator but a record that can be used as the argument of in order to create the desired shallow copy.

Arithmetic Issues in the Implementation of New Kinds of Lists When designing a new kind of list objects in &GAP;, defining the arithmetic behaviour of these objects is an issue.

There are situations where arithmetic operations of list objects are unimportant in the sense that adding two such lists need not be represented in a special way. In such cases it might be useful either to support no arithmetics at all for the new lists, or to enable the default arithmetic methods. The former can be achieved by not setting the filters and in the types of the lists, the latter can be achieved by setting the filter . (for details, see ). An example for wrapped lists with default behaviour are vector space bases; they are lists with additional properties concerning the computation of coefficients, but arithmetic properties are not important. So it is no loss to enable the default methods for these lists.

However, often the arithmetic behaviour of new list objects is important, and one wants to keep these lists away from default methods for addition, multiplication etc. For example, the sum and the product of (compatible) block matrices shall be represented as a block matrix, so the default methods for sum and product of matrices shall not be applicable, although the results will be equal to those of the default methods in the sense that their entries at corresponding positions are equal.

So one does not set the filter in such cases, and thus one can implement one's own methods for arithmetic operations. (Of course can means on the other hand that one must implement such methods if one is interested in arithmetics of the new lists.)

The specific binary arithmetic methods for the new lists will usually cover the case that both arguments are of the new kind, and perhaps also the interaction between a list of the new kind and certain other kinds of lists may be handled if this appears to be useful.

For the last situation, interaction between a new kind of lists and other kinds of lists, &GAP; provides already a setup. Namely, there are the categories and , which are concerned with the additive and the multiplicative behaviour, respectively, of lists. For lists in these filters, the structure of the results of arithmetic operations is prescribed (see  and ).

For example, if one implements block matrices in then automatically the product of such a block matrix and a (plain) list of such block matrices will be defined as the obvious list of matrix products, and a default method for plain lists will handle this multiplication. (Note that this method will rely on a method for computing the product of the block matrices, and of course no default method is available for that.) Conversely, if the block matrices are not in then the product of a block matrix and a (plain) list of block matrices is not defined. (There is no default method for it, and one can define the result and provide a method for computing it.)

Thus if one decides to set the filters and for the new lists, on the one hand one loses freedom in defining arithmetic behaviour, but on the other hand one gains several default methods for a more or less natural behaviour.

If a list in the filter () lies in IsAttributeStoringRep, the values of additive (multiplicative) nesting depth is stored in the list and need not be calculated for each arithmetic operation. One can then store the value(s) already upon creation of the lists, with the effect that the default arithmetic operations will access elements of these lists only if this is unavoidable. For example, the sum of two plain lists of wrapped matrices with stored nesting depths are computed via the method for adding two such wrapped lists, and without accessing any of their rows (which might be expensive). In this sense, the wrapped lists are treated as black boxes.

External Representation An operation is defined for elements rather than for objects in the sense that if the arguments are replaced by objects that are equal to the old arguments w.r.t. the equivalence relation = then the result must be equal to the old result w.r.t. =.

But the implementation of many methods is representation dependent in the sense that certain representation dependent subobjects are accessed.

For example, a method that implements the addition of univariate polynomials may access coefficients lists of its arguments only if they are really stored, while in the case of sparsely represented polynomials a different approach is needed.

In spite of this, for many operations one does not want to write an own method for each possible representations of each argument, for example because none of the methods could in fact take advantage of the actually given representations of the objects. Another reason could be that one wants to install first a representation independent method, and then add specific methods as they are needed to gain more efficiency, by really exploiting the fact that the arguments have certain representations.

For the purpose of admitting representation independent code, one can define an external representation of objects in a given family, install methods to compute this external representation for each representation of the objects, and then use this external representation of the objects whenever they occur.

We cannot provide conversion functions that allow us to first convert any object in question to one particular standard representation, and then access the data in the way defined for this representation, simply because it may be impossible to choose such a standard representation uniformly for all objects in the given family.

So the aim of an external representation of an object obj is a different one, namely to describe the data from which obj is composed. In particular, the external representation of obj is not one possible (standard) representation of obj, in fact the external representation of obj is in general different from obj w.r.t. =, first of all because the external representation of obj does in general not lie in the same family as obj.

For example the external representation of a rational function is a list of length two or three, the first entry being the zero coefficient, the second being a list describing the coefficients and monomials of the numerator, and the third, if bound, being a list describing the coefficients and monomials of the denominator. In particular, the external representation of a polynomial is a list and not a polynomial.

The other way round, the external representation of obj encodes obj in such a way that from this data and the family of obj, one can create an object that is equal to obj. Usually the external representation of an object is a list or a record.

Although the external representation of obj is by definition independent of the actually available representations for obj, it is usual that a representation of obj exists for which the computation of the external representation is obtained by just unpacking obj, in the sense that the desired data is stored in a component or a position of obj, if obj is a component object (see ) or a positional object (see ).

To implement an external representation means to install methods for the following two operations. returns the external representation of its argument, and returns an object in the family fam that has external representation data.

Of course, ObjByExtRep( FamilyObj( obj ), ExtRepOfObj( obj ) ) must be equal to obj w.r.t. the operation . But it is not required that equal objects have equal external representations.

Note that if one defines a new representation of objects for which an external representation does already exist then one must install a method to compute this external representation for the objects in the new representation.

Mutability and Copying Any &GAP; object is either mutable or immutable. This can be tested with the function . The intended meaning of (im)mutability is a mathematical one: an immutable object should never change in such a way that it represents a different Element. Objects may change in other ways, for instance to store more information, or represent an element in a different way.

Immutability is enforced in different ways for built-in objects (like records, or lists) and for external objects (made using ).

For built-in objects which are immutable, the kernel will prevent you from changing them. Thus

l := [1,2,4]; [ 1, 2, 4 ] gap> MakeImmutable(l); [ 1, 2, 4 ] gap> l[3] := 5; Error, Lists Assignment: must be a mutable list ]]>

For external objects, the situation is different. An external object which claims to be immutable (i.e. its type does not contain ) should not admit any methods which change the element it represents. The kernel does not prevent the use of !. and ![ to change the underlying data structure. This is used for instance by the code that stores attribute values for reuse. In general, these ! operations should only be used in methods which depend on the representation of the object. Furthermore, we would not recommend users to install methods which depend on the representations of objects created by the library or by &GAP; packages, as there is certainly no guarantee of the representations being the same in future versions of &GAP;.

Here we see an immutable object (the group S_4), in which we improperly install a new component.

g := SymmetricGroup(IsPermGroup,4); Sym( [ 1 .. 4 ] ) gap> IsMutable(g); false gap> NamesOfComponents(g); [ "Size", "NrMovedPoints", "MovedPoints", "GeneratorsOfMagmaWithInverses" ] gap> g!.silly := "rubbish"; "rubbish" gap> NamesOfComponents(g); [ "Size", "NrMovedPoints", "MovedPoints", "GeneratorsOfMagmaWithInverses", "silly" ] gap> g!.silly; "rubbish" ]]>

On the other hand, if we form an immutable externally represented list, we find that &GAP; will not let us change the object.

e := Enumerator(g); gap> IsMutable(e); false gap> IsList(e); true gap> e[3]; (1,2,4) gap> e[3] := false; Error, The list you are trying to assign to is immutable ]]>

When we consider copying objects, another filter , enters the game and we find that and behave quite differently. Objects can be divided for this purpose into three: mutable objects, immutable but copyable objects, and non-copyable objects (called constants).

A mutable or copyable object should have a method for the operation , which should make a new mutable object, sharing its top-level subobjects with the original. The exact definition of top-level subobject may be defined by the implementor for new kinds of object.

applied to a constant simply returns the constant.

is expected to be much less used than . Applied to a mutable object, it returns a new mutable object which shares no mutable sub-objects with the input. Applied to an immutable object (even a copyable one), it just returns the object. It is not an operation (indeed, it's a rather special kernel function).

e1 := StructuralCopy(e); gap> IsMutable(e1); false gap> e2 := ShallowCopy(e); [ (), (1,4), (1,2,4), (1,3,4), (2,4), (1,4,2), (1,2), (1,3,4,2), (2,3,4), (1,4,2,3), (1,2,3), (1,3)(2,4), (3,4), (1,4,3), (1,2,4,3), (1,3), (2,4,3), (1,4,3,2), (1,2)(3,4), (1,3,2), (2,3), (1,4)(2,3), (1,2,3,4), (1,3,2,4) ] gap> ]]>

There are two other related functions: , which makes a new immutable object which shares no mutable subobjects with its input and which changes an object and its mutable subobjects in place to be immutable. It should only be used on new objects that you have just created, and which cannot share mutable subobjects with anything else.

Both and work on external objects by just resetting the filter in the object's type. This should make ineligible any methods that might change the object. As a consequence, you must allow for the possibility of immutable versions of any objects you create.

So, if you are implementing your own external objects. The rules amount to the following:

You decide if your objects should be mutable or copyable or constants, by fixing whether their type includes or . You install methods for your objects respecting that decision: for constants: no methods change the underlying elements; for copyables: you provide a method for ; for mutables: you may have methods that change the underlying elements and these should explicitly require .

Global Variables in the Library Global variables in the &GAP; library are usually read-only in order to avoid their being overwritten accidentally. See also Section . <#Include Label="DeclareCategory"> <#Include Label="DeclareRepresentation"> <#Include Label="DeclareAttribute"> <#Include Label="DeclareProperty"> <#Include Label="DeclareFilter"> <#Include Label="DeclareOperation"> <#Include Label="DeclareGlobalFunction"> <#Include Label="DeclareGlobalVariable"> <#Include Label="InstallValue"> <#Include Label="DeclareSynonym"> <#Include Label="FlushCaches">
Declaration and Implementation Part Each package of &GAP; code consists of two parts, the declaration part that defines the new categories and operations for the objects the package deals with, and the implementation part where the corresponding methods are installed. The declaration part should be representation independent, representation dependent information should be dealt with in the implementation part.

&GAP; functions that are not operations and that are intended to be called by users should be notified to &GAP; in the declaration part via . Values for these functions can be installed in the implementation part via .

Calls to the following functions belong to the declaration part.

,

,

,

,

,

,

,

,

.

Calls to the following functions belong to the implementation part.

,

,

,

,

,

,

,

.

DeclareRepresentation Whenever both a NewSomething and a DeclareSomething variant of a function exist (see ), the use of DeclareSomething is recommended because this protects the variables in question from being overwritten. Note that there are no functions DeclareFamily and DeclareType since families and types are created dynamically, hence usually no global variables are associated to them. Further note that is regarded as belonging to the implementation part, because usually representations of objects are accessed only in very few places, and all code that involves a particular representation is contained in one file; additionally, representations of objects are often not interesting for the user, so there is no need to provide a user interface or documentation about representations.

It should be emphasized that declaration means only an explicit notification of mathematical or technical terms or of concepts to &GAP;. For example, declaring a category or property with name IsInteresting does of course not tell &GAP; what this shall mean, and it is necessary to implement possibilities to create objects that know already that they lie in IsInteresting in the case that it is a category, or to install implications or methods in order to compute for a given object whether IsInteresting is true or false for it in the case that IsInteresting is a property.

gap-4r6p5/doc/ref/manual.mst0000644000175000017500000000046412172557252014470 0ustar billbillpreamble "" postamble "\n" group_skip "\n" headings_flag 1 heading_prefix "\\letter " numhead_positive "{}" symhead_positive "{}" item_0 "\n " item_1 "\n \\sub " item_01 "\n \\sub " item_x1 ", " item_2 "\n \\subsub " item_12 "\n \\subsub " item_x2 ", " page_compositor "--" line_max 1000 gap-4r6p5/doc/ref/algebra.xml0000644000175000017500000002151512172557252014605 0ustar billbill Algebras <#Include Label="[1]{algebra}">
InfoAlgebra (Info Class) <#Include Label="InfoAlgebra">
Constructing Algebras by Generators <#Include Label="Algebra"> <#Include Label="AlgebraWithOne">
Constructing Algebras as Free Algebras <#Include Label="FreeAlgebra"> <#Include Label="FreeAlgebraWithOne"> <#Include Label="FreeAssociativeAlgebra"> <#Include Label="FreeAssociativeAlgebraWithOne">
Constructing Algebras by Structure Constants <#Include Label="[2]{algebra}"> <#Include Label="AlgebraByStructureConstants"> <#Include Label="StructureConstantsTable"> <#Include Label="EmptySCTable"> <#Include Label="SetEntrySCTable"> <#Include Label="GapInputSCTable"> <#Include Label="TestJacobi"> <#Include Label="IdentityFromSCTable"> <#Include Label="QuotientFromSCTable">
Some Special Algebras <#Include Label="QuaternionAlgebra"> <#Include Label="ComplexificationQuat"> <#Include Label="OctaveAlgebra"> <#Include Label="FullMatrixAlgebra"> <#Include Label="NullAlgebra">
Subalgebras <#Include Label="Subalgebra"> <#Include Label="SubalgebraNC"> <#Include Label="SubalgebraWithOne"> <#Include Label="SubalgebraWithOneNC"> <#Include Label="TrivialSubalgebra">
Ideals For constructing and working with ideals in algebras the same functions are available as for ideals in rings. So for the precise description of these functions we refer to Chapter . Here we give examples demonstrating the use of ideals in algebras. For an introduction into the construction of quotient algebras we refer to Chapter of the user's tutorial.

m:= [ [ 0, 2, 3 ], [ 0, 0, 4 ], [ 0, 0, 0] ];; gap> A:= AlgebraWithOne( Rationals, [ m ] );; gap> I:= Ideal( A, [ m ] ); # the two-sided ideal of `A' generated by `m' , (1 generators)> gap> Dimension( I ); 2 gap> GeneratorsOfIdeal( I ); [ [ [ 0, 2, 3 ], [ 0, 0, 4 ], [ 0, 0, 0 ] ] ] gap> BasisVectors( Basis( I ) ); [ [ [ 0, 1, 3/2 ], [ 0, 0, 2 ], [ 0, 0, 0 ] ], [ [ 0, 0, 1 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ] ] gap> A:= FullMatrixAlgebra( Rationals, 4 );; gap> m:= NullMat( 4, 4 );; m[1][4]:=1;; gap> I:= LeftIdeal( A, [ m ] ); gap> Dimension( I ); 4 gap> GeneratorsOfLeftIdeal( I ); [ [ [ 0, 0, 0, 1 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ], [ 0, 0, 0, 0 ] ] ] gap> mats:= [ [[1,0],[0,0]], [[0,1],[0,0]], [[0,0],[0,1]] ];; gap> A:= Algebra( Rationals, mats );; gap> # Form the two-sided ideal for which `mats[2]' is known to be gap> # the unique basis element. gap> I:= Ideal( A, [ mats[2] ], "basis" ); , (dimension 1)> ]]>

Categories and Properties of Algebras <#Include Label="IsFLMLOR"> <#Include Label="IsFLMLORWithOne"> <#Include Label="IsAlgebra"> <#Include Label="IsAlgebraWithOne"> <#Include Label="IsLieAlgebra"> <#Include Label="IsSimpleAlgebra"> returns true (always) for a matrix algebra matalg, since matrix algebras are always finite dimensional.

A:= MatAlgebra( Rationals, 3 );; gap> IsFiniteDimensional( A ); true ]]> <#Include Label="IsQuaternion">

Attributes and Operations for Algebras <#Include Label="GeneratorsOfAlgebra"> <#Include Label="GeneratorsOfAlgebraWithOne"> <#Include Label="ProductSpace"> <#Include Label="PowerSubalgebraSeries"> <#Include Label="AdjointBasis"> <#Include Label="IndicesOfAdjointBasis"> <#Include Label="AsAlgebra"> <#Include Label="AsAlgebraWithOne"> <#Include Label="AsSubalgebra"> <#Include Label="AsSubalgebraWithOne"> <#Include Label="MutableBasisOfClosureUnderAction"> <#Include Label="MutableBasisOfNonassociativeAlgebra"> <#Include Label="MutableBasisOfIdealInNonassociativeAlgebra"> <#Include Label="DirectSumOfAlgebras"> <#Include Label="FullMatrixAlgebraCentralizer"> <#Include Label="RadicalOfAlgebra"> <#Include Label="CentralIdempotentsOfAlgebra"> <#Include Label="DirectSumDecomposition"> <#Include Label="LeviMalcevDecomposition"> <#Include Label="Grading">
Homomorphisms of Algebras <#Include Label="[1]{alghom}"> <#Include Label="AlgebraGeneralMappingByImages"> <#Include Label="AlgebraHomomorphismByImages"> <#Include Label="AlgebraHomomorphismByImagesNC"> <#Include Label="AlgebraWithOneGeneralMappingByImages"> <#Include Label="AlgebraWithOneHomomorphismByImages"> <#Include Label="AlgebraWithOneHomomorphismByImagesNC"> <#Include Label="NaturalHomomorphismByIdeal_algebras"> <#Include Label="OperationAlgebraHomomorphism"> <#Include Label="NiceAlgebraMonomorphism"> <#Include Label="IsomorphismFpAlgebra"> <#Include Label="IsomorphismMatrixAlgebra"> <#Include Label="IsomorphismSCAlgebra"> <#Include Label="RepresentativeLinearOperation">
Representations of Algebras <#Include Label="[1]{algrep}"> <#Include Label="LeftAlgebraModuleByGenerators"> <#Include Label="RightAlgebraModuleByGenerators"> <#Include Label="BiAlgebraModuleByGenerators"> <#Include Label="LeftAlgebraModule"> <#Include Label="RightAlgebraModule"> <#Include Label="BiAlgebraModule"> <#Include Label="GeneratorsOfAlgebraModule"> <#Include Label="IsAlgebraModuleElement"> <#Include Label="IsLeftAlgebraModuleElement"> <#Include Label="IsRightAlgebraModuleElement"> <#Include Label="LeftActingAlgebra"> <#Include Label="RightActingAlgebra"> <#Include Label="ActingAlgebra"> <#Include Label="IsBasisOfAlgebraModuleElementSpace"> <#Include Label="MatrixOfAction"> <#Include Label="SubAlgebraModule"> <#Include Label="LeftModuleByHomomorphismToMatAlg"> <#Include Label="RightModuleByHomomorphismToMatAlg"> <#Include Label="AdjointModule"> <#Include Label="FaithfulModule"> <#Include Label="ModuleByRestriction"> <#Include Label="NaturalHomomorphismBySubAlgebraModule"> <#Include Label="DirectSumOfAlgebraModules"> <#Include Label="TranslatorSubalgebra">
gap-4r6p5/doc/ref/checkdocument.g0000644000175000017500000002047212172557252015453 0ustar billbill## Frank Lübeck ## Validating the manual and checking for text between ## chapters/sections/subsections. ## LoadPackage( "GAPDoc" ); LoadPackage( "ctbllib" ); Read( "makedocreldata.g" ); if not IsBound( GAPInfo.ManualDataRef ) then Error( "read the data from makedocrel.g first" ); fi; pathtodoc:= GAPInfo.ManualDataRef.pathtodoc;; main:= GAPInfo.ManualDataRef.main;; bookname:= GAPInfo.ManualDataRef.bookname;; pathtoroot:= GAPInfo.ManualDataRef.pathtoroot;; files:= GAPInfo.ManualDataRef.files;; # MakeGAPDocDoc( pathtodoc, main, files, bookname, pathtoroot );; Print("Collecting document for ref manual . . .\n"); doc := ComposedDocument( "GAPDoc", pathtodoc, main, files, true ); gapdocdtd := Filename(DirectoriesPackageLibrary("gapdoc"), "../gapdoc.dtd"); Print("Loading gaprxp . . ."); if LoadPackage("gaprxp") = true then Print(" ok\nParsing with rxp (with validation) . . .\n"); resrxp := XMLParseWithRxp(doc[1], [ "-V", "-D", "Book", gapdocdtd]); Print("ERRORS:\n"); for a in resrxp.err do Print(a,"\n"); od; Print("Creating parse tree . . .\n"); tree := XMLMakeTree(resrxp.out); else Print(" not found!\nParsing with GAPDoc parser (without validation) . . ."); tree := ParseTreeXMLString( doc[1], doc[2] ); Print("Calling CheckAndCleanGapDocTree . . .\n"); CheckAndCleanGapDocTree( tree ); fi; AddParagraphNumbersGapDocTree(tree); # Utility, substitutes content of chapters, section, subsections respectively # by strings like ___Chapter[4,0,0,0]. FoldSectioning := function(tree, sectype) local fun, elnams; if sectype = "Chapter" then elnams := ["Chapter","TitlePage","Appendix","Bibliography"]; elif sectype = "Section" then elnams := ["Section"]; elif sectype = "Subsection" then elnams := ["Subsection", "ManSection"]; else elnams := [sectype]; fi; fun := function(r) if r.name in ["XMLPI", "XMLDOCTYPE", "XMLCOMMENT", "COMMENT"] then if not IsBound(r.origcontent) then r.origcontent := r.content; fi; r.content := ""; elif r.name in elnams then if not IsBound(r.origcontent) then r.origcontent := r.content; fi; r.content := Concatenation("___", r.name, SubstitutionSublist(String(r.count), " ",""), "\n"); fi; end; ApplyToNodesParseTree(tree, fun); end; # remove the folding MoveBackOrigContent := function(tree) ApplyToNodesParseTree(tree, function(r) if IsBound(r.origcontent) then r.content := r.origcontent; Unbind(r.origcontent); fi;end); end; # Show the structure of a folded (sub)tree. Text between sections is # truncated after 3/4 of a line. Warnings are printed if there is text # between sections. (Text before any section is fine.) StringStructure := function(tree) local str, sp, new, pos, r, i, iss; str := GetTextXMLTree(tree); NormalizeWhitespace(str); str := SubstitutionSublist(str, " ___", "\n___"); sp := SplitString(str,"","\n"); new := []; for r in sp do if Length(r) > 2 and r{[1..3]} = "___" then pos := Position(r,']'); if pos = Length(r) then Add(new, r); else Add(new, r{[1..pos]}); Add(new, r{[pos+1 .. Minimum(pos+60, Length(r))]}); fi; else Add(new, r{[1..Minimum(60, Length(r))]}); fi; od; # print warnings iss := new[1]{[1..Minimum(Length(new[1]),3)]} = "___"; for i in [2..Length(new)] do if new[i]{[1..Minimum(Length(new[i]),3)]} = "___" then iss := true; else if iss then Print("Warning: text after ",new[i-1],"\n",new[i]," . . .\n"); fi; iss := false; fi; od; return JoinStringsWithSeparator(new, "\n"); end; # And an example how to use above utilities: SectionStructuresWithWarnings := function(tree) local chstr, chaps, chapstr, secs, secstr, ch, s; MoveBackOrigContent(tree); Print("###### Checking chapter structure . . .\n"); FoldSectioning(tree, "Chapter"); chstr := StringStructure(tree); MoveBackOrigContent(tree); Print("###### Checking section structures of chapters . . .\n"); chaps := XMLElements(tree,["Chapter","Appendix"]); chapstr := []; for ch in chaps do Print("Chapter ", ch.count, "\n"); FoldSectioning(ch,"Section"); Add(chapstr, StringStructure(ch)); od; MoveBackOrigContent(tree); Print("###### Checking subsection structures of sections . . .\n"); secs := XMLElements(tree,["Section"]); secstr := []; for s in secs do #Print("Section ", s.count, "\n"); FoldSectioning(s,"Subsection"); Add(secstr, StringStructure(s)); od; MoveBackOrigContent(tree); return [chstr, chapstr, secstr]; end; # a variant of 'WordsString' Words := function(str) local res; res := SplitString(str, "", " \n\t\r\240\302\"\\:;,.'/?[]{}\|=+-_()<>*&^%$#@!~`"); return res; end; # a fragment of what one could do with a word list, would like to find # a list of words for the spell checker CheckWords := function(wlist) local bnd, fu, gapv; # numbers wlist := Filtered(wlist, a-> not ForAll(a, IsDigitChar)); # documented GAP variables wlist := Filtered(wlist, a-> not IsDocumentedWord(a)); # further bound GAP variables bnd := Filtered(wlist, a-> IsBoundGlobal(a)); wlist := Filtered(wlist, a-> not IsBoundGlobal(a)); # further words which may refer to GAP variables fu := function(s) s := Filtered(s, x-> IsDigitChar(x) or IsUpperAlphaChar(x)); return Length(s) > 1; end; gapv := Filtered(wlist, fu); wlist := Filtered(wlist, a-> not fu(a)); return [wlist, gapv, bnd]; end; # a general utility, could maybe made more general to cover FoldSectioning # as well HideElementsXMLTree := function(tree, elts) local fu; if IsString(elts) then elts := [elts]; fi; fu := function(r) if r.name in elts then if not IsBound(r.origcontent) then r.origcontent := r.content; fi; r.content := ""; fi; end; ApplyToNodesParseTree(tree, fu); end; # remove the folding or hiding MoveBackOrigContent := function(tree) ApplyToNodesParseTree(tree, function(r) if IsBound(r.origcontent) then r.content := r.origcontent; Unbind(r.origcontent); fi;end); end; # as the name says SomeTests := function(tree) local txt, wds, chk; # after hiding these there shouldn't be any GAP variable names any more HideElementsXMLTree(tree, ["C","M","Math","Display","A","Arg", "Example", "XMLPI", "XMLDOCTYPE", "XMLCOMMENT", "COMMENT"]); txt := GetTextXMLTree(tree); txt := SubstitutionSublist(txt, "\342\200\223", "-"); wds := Set(Words(txt)); chk := CheckWords(wds); return chk; end; # f is called before recursion, g afterwards # Will generalize ApplyToNodesParseTree to a 3-arg version . . . ApplyToNodes2 := function ( r, f, g ) local ff; ff := function ( rr ) local a; if IsList( rr.content ) and not IsString( rr.content ) then for a in rr.content do f( a ); ff( a ); g( a ); od; fi; return; end; f( r ); ff( r ); g( r ); return; end; # This finds elements in outside ManSections (should not happen) and # strings in elements which are not given in Arg attributes of the # current ManSection. CheckAContent := function(tree) local c1, c2, fu, g; c1 := 0; c2 := 0; fu := function(r) local w; if r.name = "ManSection" then GAPInfo.ARGLIST := []; elif r.name in ["Func","Oper","Meth","Filt","Prop", "Attr","Var","Fam","InfoClass"] then if IsBound(r.attributes.Arg) then Append(GAPInfo.ARGLIST, WordsString(r.attributes.Arg)); fi; elif r.name in ["A", "Arg"] then if not IsBound(GAPInfo.ARGLIST) then Print(" outside ManSection: ", GetTextXMLTree(r),"\n"); c1 := c1+1; else w := WordsString(GetTextXMLTree(r)); w := Filtered(w, a-> not a in GAPInfo.ARGLIST); if Length(w) > 0 then Print("Wrong : ",w,"/",GAPInfo.ARGLIST,"\n"); c2 := c2+1; fi; fi; fi; end; g := function(r) if r.name = "ManSection" then Unbind(GAPInfo.ARGLIST); fi; end; ApplyToNodes2(tree, fu, g); Print(c1," outside ManSection, ",c2," wrong usages.\n"); end; # one call that shows text between subsections strs := SectionStructuresWithWarnings(tree); gap-4r6p5/doc/ref/permutat.xml0000644000175000017500000001053712172557252015053 0ustar billbill Permutations &GAP; offers a data type permutation to describe the elements of permutation groups.

The points on which permutations in &GAP; act are the positive integers up to a certain architecture dependent limit, and the image of a point i under a permutation p is written i^p, which is expressed as i^p in &GAP;. (This action is also implemented by the function .) If i^p is different from i, we say that i is moved by p, otherwise it is fixed. Permutations in &GAP; are entered and displayed in cycle notation, such as (1,2,3)(4,5).

The preimage of the point i under the permutation p can be computed as i/p, without constructing the inverse of p.

For arithmetic operations for permutations and their precedence, see .

In the names of the &GAP; functions that deal with permutations, the word Permutation is usually abbreviated to Perm, to save typing. For example, the category test function for permutations is .

IsPerm (Filter) <#Include Label="[1]{permutat}"> <#Include Label="IsPerm"> <#Include Label="IsPermCollection"> <#Include Label="PermutationsFamily">
Comparison of Permutations equality test precedence test Two permutations are equal if they move the same points and all these points have the same images under both permutations.

The permutation p1 is smaller than p2 if p1 \neq p2 and i^{{p1}} < i^{{p2}}, where i is the smallest point with i^{{p1}} \neq i^{{p2}}. Therefore the identity permutation is the smallest permutation, see also Section .

Permutations can be compared with certain other &GAP; objects, see  for the details.

(1,2,3) = (2,3,1); true gap> (1,2,3) * (2,3,4) = (1,3)(2,4); true gap> (1,2,3) < (1,3,2); # 1^(1,2,3) = 2 < 3 = 1^(1,3,2) true gap> (1,3,2,4) < (1,3,4,2); # 2^(1,3,2,4) = 4 > 1 = 2^(1,3,4,2) false ]]> <#Include Label="DistancePerms"> <#Include Label="SmallestGeneratorPerm">

Moved Points of Permutations <#Include Label="SmallestMovedPoint"> <#Include Label="LargestMovedPoint"> <#Include Label="MovedPoints"> <#Include Label="NrMovedPoints">
Sign and Cycle Structure <#Include Label="SignPerm"> <#Include Label="CycleStructurePerm">
Creating Permutations <#Include Label="ListPerm"> <#Include Label="PermList"> <#Include Label="MappingPermListList"> <#Include Label="RestrictedPerm">
gap-4r6p5/doc/ref/matint.xml0000644000175000017500000000752412172557252014510 0ustar billbill Integral matrices and lattices
Linear equations over the integers and Integral Matrices <#Include Label="NullspaceIntMat"> <#Include Label="SolutionIntMat"> <#Include Label="SolutionNullspaceIntMat"> <#Include Label="BaseIntMat"> <#Include Label="BaseIntersectionIntMats"> <#Include Label="ComplementIntMat">
Normal Forms over the Integers This section describes the computation of the Hermite and Smith normal form of integer matrices.

The Hermite Normal Form (HNF) H of an integer matrix A is a row equivalent upper triangular form such that all off-diagonal entries are reduced modulo the diagonal entry of the column they are in. There exists a unique unimodular matrix Q such that Q A = H.

The Smith Normal Form S of an integer matrix A is the unique equivalent diagonal form with S_i dividing S_j for i < j. There exist unimodular integer matrices P, Q such that P A Q = S.

All routines described in this section build on the workhorse routine . <#Include Label="TriangulizedIntegerMat"> <#Include Label="TriangulizedIntegerMatTransform"> <#Include Label="TriangulizeIntegerMat"> <#Include Label="HermiteNormalFormIntegerMat"> <#Include Label="HermiteNormalFormIntegerMatTransform"> <#Include Label="SmithNormalFormIntegerMat"> <#Include Label="SmithNormalFormIntegerMatTransforms"> <#Include Label="DiagonalizeIntMat"> <#Include Label="NormalFormIntMat"> <#Include Label="AbelianInvariantsOfList">

Determinant of an integer matrix <#Include Label="DeterminantIntMat">
Decompositions <#Include Label="[1]{zlattice}"> <#Include Label="Decomposition"> <#Include Label="LinearIndependentColumns"> <#Include Label="PadicCoefficients"> <#Include Label="IntegralizedMat"> <#Include Label="DecompositionInt">
Lattice Reduction <#Include Label="LLLReducedBasis"> <#Include Label="LLLReducedGramMat">
Orthogonal Embeddings <#Include Label="OrthogonalEmbeddings"> <#Include Label="ShortestVectors">
gap-4r6p5/doc/ref/vector.xml0000644000175000017500000002255112172557252014513 0ustar billbill Row Vectors Just as in mathematics, a vector in &GAP; is any object which supports appropriate addition and scalar multiplication operations (see Chapter ). As in mathematics, an especially important class of vectors are those represented by a list of coefficients with respect to some basis. These correspond roughly to the &GAP; concept of row vectors.
IsRowVector (Filter) <#Include Label="IsRowVector">
Operators for Row Vectors The rules for arithmetic operations involving row vectors are in fact special cases of those for the arithmetic of lists, as given in Section  and the following sections, here we reiterate that definition, in the language of vectors.

Note that the additive behaviour sketched below is defined only for lists in the category , and the multiplicative behaviour is defined only for lists in the category .

addition vec1 + vec2

returns the sum of the two row vectors vec1 and vec2. Probably the most usual situation is that vec1 and vec2 have the same length and are defined over a common field; in this case the sum is a new row vector over the same field where each entry is the sum of the corresponding entries of the vectors.

In more general situations, the sum of two row vectors need not be a row vector, for example adding an integer vector vec1 and a vector vec2 over a finite field yields the list of pointwise sums, which will be a mixture of finite field elements and integers if vec1 is longer than vec2.

addition scalar + vec

vec + scalar

returns the sum of the scalar scalar and the row vector vec. Probably the most usual situation is that the elements of vec lie in a common field with scalar; in this case the sum is a new row vector over the same field where each entry is the sum of the scalar and the corresponding entry of the vector.

More general situations are for example the sum of an integer scalar and a vector over a finite field, or the sum of a finite field element and an integer vector.

[ 1, 2, 3 ] + [ 1/2, 1/3, 1/4 ]; [ 3/2, 7/3, 13/4 ] gap> [ 1/2, 3/2, 1/2 ] + 1/2; [ 1, 2, 1 ] ]]>

subtraction subtraction subtraction vec1 - vec2

scalar - vec

vec - scalar

Subtracting a vector or scalar is defined as adding its additive inverse, so the statements for the addition hold likewise.

[ 1, 2, 3 ] - [ 1/2, 1/3, 1/4 ]; [ 1/2, 5/3, 11/4 ] gap> [ 1/2, 3/2, 1/2 ] - 1/2; [ 0, 1, 0 ] ]]>

multiplication multiplication scalar * vec

vec * scalar

returns the product of the scalar scalar and the row vector vec. Probably the most usual situation is that the elements of vec lie in a common field with scalar; in this case the product is a new row vector over the same field where each entry is the product of the scalar and the corresponding entry of the vector.

More general situations are for example the product of an integer scalar and a vector over a finite field, or the product of a finite field element and an integer vector.

[ 1/2, 3/2, 1/2 ] * 2; [ 1, 3, 1 ] ]]>

multiplication vec1 * vec2

returns the standard scalar product of vec1 and vec2, i.e., the sum of the products of the corresponding entries of the vectors. Probably the most usual situation is that vec1 and vec2 have the same length and are defined over a common field; in this case the sum is an element of this field.

More general situations are for example the inner product of an integer vector and a vector over a finite field, or the inner product of two row vectors of different lengths.

[ 1, 2, 3 ] * [ 1/2, 1/3, 1/4 ]; 23/12 ]]>

For the mutability of results of arithmetic operations, see .

Further operations with vectors as operands are defined by the matrix operations, see . <#Include Label="NormedRowVector">

Row Vectors over Finite Fields &GAP; can use compact formats to store row vectors over fields of order at most 256, based on those used by the Meat-Axe . This format also permits extremely efficient vector arithmetic. On the other hand element access and assignment is significantly slower than for plain lists.

The function is used to convert a list into a compressed vector, or to rewrite a compressed vector over another field. Note that this function is much faster when it is given a field (or field size) as an argument, rather than having to scan the vector and try to decide the field. Supplying the field can also avoid errors and/or loss of performance, when one vector from some collection happens to have all of its entries over a smaller field than the natural field of the problem. <#Include Label="ConvertToVectorRep"> <#Include Label="NumberFFVector">

Coefficient List Arithmetic <#Include Label="[1]{listcoef}"> <#Include Label="AddRowVector"> <#Include Label="AddCoeffs"> <#Include Label="MultRowVector"> <#Include Label="CoeffsMod">
Shifting and Trimming Coefficient Lists <#Include Label="[3]{listcoef}"> <#Include Label="LeftShiftRowVector"> <#Include Label="RightShiftRowVector"> <#Include Label="ShrinkRowVector"> <#Include Label="RemoveOuterCoeffs">
Functions for Coding Theory <#Include Label="[4]{listcoef}"> <#Include Label="WeightVecFFE"> <#Include Label="DistanceVecFFE"> <#Include Label="DistancesDistributionVecFFEsVecFFE"> <#Include Label="DistancesDistributionMatFFEVecFFE"> <#Include Label="AClosestVectorCombinationsMatFFEVecFFE"> <#Include Label="CosetLeadersMatFFE">
Vectors as coefficients of polynomials A list of ring elements can be interpreted as a row vector or the list of coefficients of a polynomial. There are a couple of functions that implement arithmetic operations based on these interpretations. &GAP; contains proper support for polynomials (see ), the operations described in this section are on a lower level.

<#Include Label="[2]{listcoef}"> <#Include Label="ValuePol"> <#Include Label="ProductCoeffs"> <#Include Label="ReduceCoeffs"> <#Include Label="ReduceCoeffsMod"> <#Include Label="PowerModCoeffs"> <#Include Label="ShiftedCoeffs">

gap-4r6p5/doc/ref/cyclotom.xml0000644000175000017500000002250312172557252015037 0ustar billbill Cyclotomic Numbers type irrationalities cyclotomic field elements &GAP; admits computations in abelian extension fields of the rational number field &QQ;, that is fields with abelian Galois group over &QQ;. These fields are subfields of cyclotomic fields &QQ;(e_n) where e_n = \exp(2 \pi i/n) is a primitive complex n-th root of unity. The elements of these fields are called cyclotomics.

Information concerning operations for domains of cyclotomics, for example certain integral bases of fields of cyclotomics, can be found in Chapter . For more general operations that take a field extension as a –possibly optional– argument, e.g., or , see Chapter .

Operations for Cyclotomics <#Include Label="E"> <#Include Label="Cyclotomics"> <#Include Label="IsCyclotomic"> <#Include Label="IsIntegralCyclotomic"> <#Include Label="Int:cyclotomics"> <#Include Label="String:cyclotomics"> <#Include Label="Conductor"> <#Include Label="AbsoluteValue"> <#Include Label="RoundCyc"> <#Include Label="CoeffsCyc"> <#Include Label="DenominatorCyc"> <#Include Label="ExtRepOfObj:cyclotomics"> <#Include Label="DescriptionOfRootOfUnity"> <#Include Label="IsGaussInt"> <#Include Label="IsGaussRat"> <#Include Label="DefaultField:cyclotomics">
Infinity <#Include Label="IsInfinity">
Comparisons of Cyclotomics operators To compare cyclotomics, the operators <, <=, =, >=, >, and <> can be used, the result will be true if the first operand is smaller, smaller or equal, equal, larger or equal, larger, or unequal, respectively, and false otherwise.

Cyclotomics are ordered as follows: The relation between rationals is the natural one, rationals are smaller than irrational cyclotomics, and is the largest cyclotomic. For two irrational cyclotomics with different conductors (see ), the one with smaller conductor is regarded as smaller. Two irrational cyclotomics with same conductor are compared via their external representation (see ).

For comparisons of cyclotomics and other &GAP; objects, see Section .

E(5) < E(6); # the latter value has conductor 3 false gap> E(3) < E(3)^2; # both have conductor 3, compare the ext. repr. false gap> 3 < E(3); E(5) < E(7); true true ]]>

ATLAS Irrationalities atomic irrationalities <#Include Label="EB"> <#Include Label="EI"> <#Include Label="EY"> <#Include Label="EM"> <#Include Label="NK"> <#Include Label="AtlasIrrationality">
Galois Conjugacy of Cyclotomics <#Include Label="GaloisCyc"> <#Include Label="ComplexConjugate"> <#Include Label="StarCyc"> <#Include Label="Quadratic"> <#Include Label="GaloisMat"> <#Include Label="RationalizedMat">
Internally Represented Cyclotomics The implementation of an internally represented cyclotomic is based on a list of length equal to its conductor. This means that the internal representation of a cyclotomic does not refer to the smallest number field but the smallest cyclotomic field containing it. The reason for this is the wish to reflect the natural embedding of two cyclotomic fields into a larger one that contains both. With such embeddings, it is easy to construct the sum or the product of two arbitrary cyclotomics (in possibly different fields) as an element of a cyclotomic field.

The disadvantage of this approach is that the arithmetical operations are quite expensive, so the use of internally represented cyclotomics is not recommended for doing arithmetics over number fields, such as calculations with matrices of cyclotomics. But internally represented cyclotomics are good enough for dealing with irrationalities in character tables (see chapter ).

For the representation of cyclotomics one has to recall that the n-th cyclotomic field &QQ;(e_n) is a vector space of dimension \varphi(n) over the rationals where \varphi denotes Euler's phi-function (see ).

A special integral basis of cyclotomic fields is chosen that allows one to easily convert arbitrary sums of roots of unity into the basis, as well as to convert a cyclotomic represented w.r.t. the basis into the smallest possible cyclotomic field. This basis is accessible in &GAP;, see  for more information and references.

Note that the set of all n-th roots of unity is linearly dependent for n > 1, so multiplication is not the multiplication of the group ring &QQ;\langle e_n \rangle; given a &QQ;-basis of &QQ;(e_n) the result of the multiplication (computed as multiplication of polynomials in e_n, using (e_n)^n = 1) will be converted to the basis.

E(5) * E(5)^2; ( E(5) + E(5)^4 ) * E(5)^2; E(5)^3 E(5)+E(5)^3 gap> ( E(5) + E(5)^4 ) * E(5); -E(5)-E(5)^3-E(5)^4 ]]>

An internally represented cyclotomic is always represented in the smallest cyclotomic field it is contained in. The internal coefficients list coincides with the external representation returned by .

To avoid calculations becoming unintentionally very long, or consuming very large amounts of memory, there is a limit on the conductor of internally represented cyclotomics, by default set to one million. This can be raised (although not lowered) using and accessed using . The maximum value of the limit is 2^{28}-1 on 32 bit systems, and 2^{32} on 64 bit systems. So the maximal cyclotomic field implemented in &GAP; is not really the field &QQ;^{ab}.

It should be emphasized that one disadvantage of representing a cyclotomic in the smallest cyclotomic field (and not in the smallest field) is that arithmetic operations in a fixed small extension field of the rational number field are comparatively expensive. For example, take a prime integer p and suppose that we want to work with a matrix group over the field &QQ;(\sqrt{{p}}). Then each matrix entry could be described by two rational coefficients, whereas the representation in the smallest cyclotomic field requires p-1 rational coefficients for each entry. So it is worth thinking about using elements in a field constructed with when natural embeddings of cyclotomic fields are not needed. returns the current limit on conductors of internally represented cyclotomic numbers

can be called to increase the limit on conductors of internally represented cyclotomic numbers. Note that computing in large cyclotomic fields using this representation can be both slow and memory-consuming, and that other approaches may be better for some problems. See .

gap-4r6p5/doc/ref/grpprod.xml0000644000175000017500000001364112172557252014666 0ustar billbill Group Products This chapter describes the various group product constructions that are possible in &GAP;.

At the moment for some of the products methods are available only if both factors are given in the same representation or only for certain types of groups such as permutation groups and pc groups when the product can be naturally represented as a group of the same kind.

&GAP; does not guarantee that a product of two groups will be in a particular representation. (Exceptions are and which are construction that makes sense only for permutation groups, see ).

&GAP; however will try to choose an efficient representation, so products of permutation groups or pc groups often will be represented as a group of the same kind again.

Therefore the only guaranteed way to relate a product to its factors is via the embedding and projection homomorphisms, see .

Direct Products The direct product of groups is the cartesian product of the groups (considered as element sets) with component-wise multiplication.

<#Include Label="DirectProduct">

Semidirect Products The semidirect product of a group N with a group G acting on N via a homomorphism \alpha from G into the automorphism group of N is the cartesian product G \times N with the multiplication (g, n) \cdot (h, m) = (gh, n^{{h^\alpha}}m). <#Include Label="SemidirectProduct">
Subdirect Products The subdirect product of the groups G and H with respect to the epimorphisms \varphi\colon G \rightarrow A and \psi\colon H \rightarrow A (for a common group A) is the subgroup of the direct product G \times H consisting of the elements (g,h) for which g^{\varphi} = h^{\psi}. It is the pull-back of the following diagram.

G | phi psi V H ---> A <#Include Label="SubdirectProduct"> <#Include Label="SubdirectProducts">

Wreath Products The wreath product of a group G with a permutation group P acting on n points is the semidirect product of the normal subgroup G^n with the group P which acts on G^n by permuting the components.

Note that &GAP; always considers the domain of a permutation group to be the points moved by elements of the group as returned by , i.e. it is not possible to have a domain to include fixed points, I.e. P = \langle (1,2,3) \rangle and P = \langle (1,3,5) \rangle result in isomorphic wreath products. (If fixed points are desired the wreath product G \wr T has to be formed with a transitive overgroup T of P and then the pre-image of P under the projection G \wr T \rightarrow T has to be taken.)

<#Include Label="WreathProduct"> <#Include Label="WreathProductImprimitiveAction"> <#Include Label="WreathProductProductAction"> <#Include Label="KuKGenerators">

Free Products Let G and H be groups with presentations \langle X \mid R \rangle and \langle Y \mid S \rangle, respectively. Then the free product G*H is the group with presentation \langle X \cup Y \mid R \cup S \rangle. This construction can be generalized to an arbitrary number of groups. <#Include Label="FreeProduct">
Embeddings and Projections for Group Products The relation between a group product and its factors is provided via homomorphisms, the embeddings in the product and the projections from the product. Depending on the kind of product only some of these are defined.

returns the nr-th embedding in the group product P. The actual meaning of this embedding is described in the manual section for the appropriate product. returns the (nr-th) projection of the group product P. The actual meaning of the projection returned is described in the manual section for the appropriate product.

gap-4r6p5/doc/ref/types.xml0000644000175000017500000006666212172557252014370 0ustar billbill Types of Objects Every &GAP; object has a type. The type of an object is the information which is used to decide whether an operation is admissible or possible with that object as an argument, and if so, how it is to be performed (see Chapter ).

For example, the types determine whether two objects can be multiplied and what function is called to compute the product. Analogously, the type of an object determines whether and how the size of the object can be computed. It is sometimes useful in discussing the type system, to identify types with the set of objects that have this type. Partial types can then also be regarded as sets, such that any type is the intersection of its parts.

The type of an object consists of two main parts, which describe different aspects of the object.

The family determines the relation of the object to other objects. For example, all permutations form a family. Another family consists of all collections of permutations, this family contains the set of permutation groups as a subset. A third family consists of all rational functions with coefficients in a certain family.

The other part of a type is a collection of filters (actually stored as a bit-list indicating, from the complete set of possible filters, which are included in this particular type). These filters are all treated equally by the method selection, but, from the viewpoint of their creation and use, they can be divided (with a small number of unimportant exceptions) into categories, representations, attribute testers and properties. Each of these is described in more detail below.

This chapter does not describe how types and their constituent parts can be created. Information about this topic can be found in Chapter .

Note: Detailed understanding of the type system is not required to use &GAP;. It can be helpful, however, to understand how things work and why &GAP; behaves the way it does.

A discussion of the type system can be found in .

Families The family of an object determines its relationship to other objects.

More precisely, the families form a partition of all &GAP; objects such that the following two conditions hold: objects that are equal w.r.t. = lie in the same family; and the family of the result of an operation depends only on the families of its operands.

The first condition means that a family can be regarded as a set of elements instead of a set of objects. Note that this does not hold for categories and representations (see below), two objects that are equal w.r.t. = need not lie in the same categories and representations. For example, a sparsely represented matrix can be equal to a densely represented matrix. Similarly, each domain is equal w.r.t. = to the sorted list of its elements, but a domain is not a list, and a list is not a domain. <#Include Label="FamilyObj">

Filters A filter is a special unary &GAP; function that returns either true or false, depending on whether or not the argument lies in the set defined by the filter. Filters are used to express different aspects of information about a &GAP; object, which are described below (see , , , , , ).

Presently any filter in &GAP; is implemented as a function which corresponds to a set of positions in the bitlist which forms part of the type of each &GAP; object, and returns true if and only if the bitlist of the type of the argument has the value true at all of these positions.

The intersection (or meet) of two filters filt1, filt2 is again a filter, it can be formed as

and filt1 and filt2

See for more details.

For example, IsList and IsEmpty is a filter that returns true if its argument is an empty list, and false otherwise. The filter is defined as the intersection of the category and the property .

A filter that is not the meet of other filters is called a simple filter. For example, each attribute tester (see ) is a simple filter. Each simple filter corresponds to a position in the bitlist currently used as part of the data structure representing a type.

Every filter has a rank, which is used to define a ranking of the methods installed for an operation, see Section . The rank of a filter can be accessed with . For simple filters, an incremental rank is defined when the filter is created, see the sections about the creation of filters: , , , . For an arbitrary filter, its rank is given by the sum of the incremental ranks of the involved simple filters; in addition to the implied filters, these are also the required filters of attributes (again see the sections about the creation of filters). In other words, for the purpose of computing the rank and only for this purpose, attribute testers are treated as if they would imply the requirements of their attributes. returns a list of names of the implied simple filters of the filter filt, these are all those simple filters imp such that every object in filt also lies in imp. For implications between filters, see as well as sections , , , . <#Include Label="ShowImpliedFilters">

Categories The categories of an object are filters (see ) that determine what operations an object admits. For example, all integers form a category, all rationals form a category, and all rational functions form a category. An object which claims to lie in a certain category is accepting the requirement that it should have methods for certain operations (and perhaps that their behaviour should satisfy certain axioms). For example, an object lying in the category must have methods for , and the list element access operation .

An object can lie in several categories. For example, a row vector lies in the categories and ; each list lies in the category , and depending on whether or not it is mutable, it may lie in the category . Every domain lies in the category .

Of course some categories of a mutable object may change when the object is changed. For example, after assigning values to positions of a mutable non-dense list, this list may become part of the category .

However, if an object is immutable then the set of categories it lies in is fixed.

All categories in the library are created during initialization, in particular they are not created dynamically at runtime.

The following list gives an overview of important categories of arithmetic objects. Indented categories are to be understood as subcategories of the non indented category listed above it. Every object lies in the category .

The categories and contain objects that can be multiplied with other objects via * from the left and from the right, respectively. These categories are required for the operands of the operation *.

The category contains objects that can be multiplied from the left and from the right with objects from the same family. contains objects obj for which a multiplicatively neutral element can be obtained by taking the 0-th power obj^0. contains objects obj for which a multiplicative inverse can be obtained by forming obj^-1.

Likewise, the categories , , and contain objects that can be added via + to other objects, objects that can be added to objects of the same family, objects for which an additively neutral element can be obtained by multiplication with zero, and objects for which an additive inverse can be obtained by multiplication with -1.

So a vector lies in , and . A ring element must additionally lie in .

As stated above it is not guaranteed by the categories of objects whether the result of an operation with these objects as arguments is defined. For example, the category is a subcategory of . Clearly not every matrix has a multiplicative inverse. But the category makes each matrix an admissible argument of the operation , which may sometimes return fail. Likewise, two matrices can be multiplied only if they are of appropriate shapes.

Analogous to the categories of arithmetic elements, there are categories of domains of these elements. Of course is a subcategory of . A domain that is closed under multiplication * is called a magma and it lies in the category . If a magma is closed under taking the identity, it lies in , and if it is also closed under taking inverses, it lies in . The category denotes closure under taking inverses only for nonzero elements, every division ring lies in this category.

Note that every set of categories constitutes its own notion of generation, for example a group may be generated as a magma with inverses by some elements, but to generate it as a magma with one it may be necessary to take the union of these generators and their inverses. <#Include Label="CategoriesOfObject">

Representation The representation of an object is a set of filters (see ) that determines how an object is actually represented. For example, a matrix or a polynomial can be stored sparsely or densely; all dense polynomials form a representation. An object which claims to lie in a certain representation is accepting the requirement that certain fields in the data structure be present and have specified meanings.

&GAP; distinguishes four essentially different ways to represent objects. First there are the representations IsInternalRep for internal objects such as integers and permutations, and IsDataObjectRep for other objects that are created and whose data are accessible only by kernel functions. The data structures underlying such objects cannot be manipulated at the &GAP; level.

All other objects are either in the representation IsComponentObjectRep or in the representation IsPositionalObjectRep, see  and .

An object can belong to several representations in the sense that it lies in several subrepresentations of IsComponentObjectRep or of IsPositionalObjectRep. The representations to which an object belongs should form a chain and either two representations are disjoint or one is contained in the other. So the subrepresentations of IsComponentObjectRep and IsPositionalObjectRep each form trees. In the language of Object Oriented Programming, we support only single inheritance for representations.

These trees are typically rather shallow, since for one representation to be contained in another implies that all the components of the data structure implied by the containing representation, are present in, and have the same meaning in, the smaller representation (whose data structure presumably contains some additional components).

Objects may change their representation, for example a mutable list of characters can be converted into a string.

All representations in the library are created during initialization, in particular they are not created dynamically at runtime.

Examples of subrepresentations of IsPositionalObjectRep are IsModulusRep, which is used for residue classes in the ring of integers, and IsDenseCoeffVectorRep, which is used for elements of algebras that are defined by structure constants.

An important subrepresentation of IsComponentObjectRep is IsAttributeStoringRep, which is used for many domains and some other objects. It provides automatic storing of all attribute values (see below). <#Include Label="RepresentationsOfObject">

Attributes The attributes of an object describe knowledge about it.

An attribute is a unary operation without side-effects.

An object may store values of its attributes once they have been computed, and claim that it knows these values. Note that store and know have to be understood in the sense that it is very cheap to get such a value when the attribute is called again.

The stored value of an attribute is in general immutable (see ), except if the attribute had been specially constructed as mutable attribute.

It depends on the representation of an object (see ) which attribute values it stores. An object in the representation IsAttributeStoringRep stores all attribute values once they are computed. Moreover, for an object in this representation, subsequent calls to an attribute will return the same object; this is achieved via a special method for each attribute setter that stores the attribute value in an object in IsAttributeStoringRep, and a special method for the attribute itself that fetches the stored attribute value. (These methods are called the system setter and the system getter of the attribute, respectively.)system gettersystem setter

Note also that it is impossible to get rid of a stored attribute value because the system may have drawn conclusions from the old attribute value, and just removing the value might leave the data structures in an inconsistent state. If necessary, a new object can be constructed.

Several attributes have methods for more than one argument. For example is an attribute for a G-set that can also be called for the two arguments, being a group G and its action domain. If attributes are called with more than one argument then the return value is not stored in any of the arguments.

Properties are a special form of attributes that have the value true or false, see section .

Examples of attributes for multiplicative elements are , , and . is an attribute for domains, is an attribute for magmas, and is an attribute for groups. <#Include Label="KnownAttributesOfObject">

Setter and Tester for Attributes setter tester For every attribute, the attribute setter and the attribute tester are defined.

To check whether an object belongs to an attribute attr, the tester of the attribute is used, see . To store a value for the attribute attr in an object, the setter of the attribute is used, see . For an attribute attr, Tester(attr) is a filter (see ) that returns true or false, depending on whether or not the value of attr for the object is known. For example, Tester( Size )( obj ) is true if the size of the object obj is known. For an attribute attr, Setter(attr) is called automatically when the attribute value has been computed for the first time. One can also call the setter explicitly, for example, Setter( Size )( obj, val ) sets val as size of the object obj if the size was not yet known.

For each attribute attr that is declared with resp.  (see ), tester and setter are automatically made accessible by the names Hasattr and Setattr, respectively. For example, the tester for is called HasSize, and the setter is called SetSize.

g:=Group((1,2,3,4),(1,2));;Size(g); 24 gap> HasSize(g); true gap> SetSize(g,99); gap> Size(g); 24 ]]>

For two properties prop1 and prop2, the intersection prop1 and prop2 (see ) is again a property for which a setter and a tester exist. Setting the value of this intersection to true for a &GAP; object means to set the values of prop1 and prop2 to true for this object.

prop:= IsFinite and IsCommutative; >"> gap> g:= Group( (1,2,3), (4,5) );; gap> Tester( prop )( g ); false gap> Setter( prop )( g, true ); gap> Tester( prop )( g ); prop( g ); true true ]]>

It is not allowed to set the value of such an intersection to false for an object.

Setter( prop )( Rationals, false ); You cannot set an "and-filter" except to true not in any function Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can type 'return true;' to set all components true (but you might really want to reset just one component) to continue brk> ]]> If the value of the attribute attr is already stored for obj, AttributeValueNotSet simply returns this value. Otherwise the value of attr( obj ) is computed and returned without storing it in obj. This can be useful when large attribute values (such as element lists) are needed only once and shall not be stored in the object.

HasAsSSortedList(g); false gap> AttributeValueNotSet(AsSSortedList,g); [ (), (4,5), (1,2,3), (1,2,3)(4,5), (1,3,2), (1,3,2)(4,5) ] gap> HasAsSSortedList(g); false ]]>

<#Include Label="[1]{attr}"> <#Include Label="InfoAttributes"> <#Include Label="DisableAttributeValueStoring"> <#Include Label="EnableAttributeValueStoring">

Properties The properties of an object are those of its attributes (see ) whose values can only be true or false.

The main difference between attributes and properties is that a property defines two sets of objects, namely the usual set of all objects for which the value is known, and the set of all objects for which the value is known to be true.

(Note that it makes no sense to consider a third set, namely the set of objects for which the value of a property is true whether or not it is known, since there may be objects for which the containment in this set cannot be decided.)

For a property prop, the containment of an object obj in the first set is checked again by applying Tester( prop ) to obj, and obj lies in the second set if and only if Tester( prop )( obj ) and prop( obj ) is true.

If a property value is known for an immutable object then this value is also stored, as part of the type of the object. To some extent, property values of mutable objects also can be stored, for example a mutable list all of whose entries are immutable can store whether it is strictly sorted. When the object is mutated (for example by list assignment) the type may need to be adjusted.

Important properties for domains are , , , and , which mean that the multiplication of elements in the domain satisfies ( a * b ) * c = a * ( b * c ), a * b = b * a, a * b = - ( b * a ), a * ( b + c ) = a * b + a * c, and ( a + b ) * c = a * c + b * c, respectively, for all a, b, c in the domain.

<#Include Label="KnownPropertiesOfObject"> <#Include Label="KnownTruePropertiesOfObject">

Other Filters There are situations where one wants to express a kind of knowledge that is based on some heuristic.

For example, the filters (see ) and are defined in the &GAP; library. Note that such filters do not correspond to a mathematical concept, contrary to properties (see ). Also it need not be defined what easily means for an arbitrary &GAP; object, and in this case one cannot compute the value for an arbitrary &GAP; object. In order to access this kind of knowledge as a part of the type of an object, &GAP; provides filters for which the value is false by default, and it is changed to true in certain situations, either explicitly (for the given object) or via a logical implication (see ) from other filters.

For example, a true value of for a group means that certain methods are applicable that use a pcgs (see ) for the group. There are logical implications to set the filter value to true for permutation groups that are known to be solvable, and for groups that have already a (sufficiently nice) pcgs stored. In the case one has a solvable matrix group and wants to enable methods that use a pcgs, one can set the value to true for this particular group.

A filter filt of the kind described here is different from the other filters introduced in the previous sections. In particular, filt is not a category (see ) or a property (see ) because its value may change for a given object, and filt is not a representation (see ) because it has nothing to do with the way an object is made up from some data. filt is similar to an attribute tester (see ), the only difference is that filt does not refer to an attribute value; note that filt is also used in the same way as an attribute tester; namely, the true value may be required for certain methods to be applicable.

Types We stated above (see ) that, for an object obj, its type is formed from its family and its filters. There is a also a third component, used in a few situations, namely defining data of the type. <#Include Label="TypeObj"> The last part of the type, defining data, has not been mentioned before and seems to be of minor importance. It can be used, e.g., for cosets U g of a group U, where the type of each coset may contain the group U as defining data. As a consequence, two such cosets mod U and V can have the same type only if U = V. The defining data of the type type can be accessed via .
gap-4r6p5/doc/ref/algfp.xml0000644000175000017500000000226112172557252014276 0ustar billbill Finitely Presented Algebras Currently the &GAP; library contains only few functions dealing with general finitely presented algebras, so this chapter is merely a placeholder.

The special case of finitely presented Lie algebras is described in , and there is also a &GAP; package fplsa for computing structure constants of finitely presented Lie (super)algebras.

gap-4r6p5/doc/ref/grplib.xml0000644000175000017500000016570412172557252014500 0ustar billbill Group Libraries When you start &GAP;, it already knows several groups. Currently &GAP; initially knows the following groups: some basic groups, such as cyclic groups or symmetric groups (see ), Classical matrix groups (see ), the transitive permutation groups of degree at most 30 (see ), a library of groups of small order (see ), the finite perfect groups of size at most 10^6 (excluding 11 sizes) (see ). the primitive permutation groups of degree < 2499 (see ), the irreducible solvable subgroups of GL(n,p) for n>1 and p^n < 256 (see ), the irreducible maximal finite integral matrix groups of dimension at most 31 (see ), the crystallographic groups of dimension at most 4

There is usually no relation between the groups in the different libraries and a group may occur in different libraries in different incarnations.

Note that a system administrator may choose to install all, or only a few, or even none of the libraries. So some of the libraries mentioned below may not be available on your installation.

Basic Groups <#Include Label="[1]{basic}"> <#Include Label="TrivialGroup"> <#Include Label="CyclicGroup"> <#Include Label="AbelianGroup"> <#Include Label="ElementaryAbelianGroup"> <#Include Label="DihedralGroup"> <#Include Label="QuaternionGroup"> <#Include Label="ExtraspecialGroup"> <#Include Label="AlternatingGroup"> <#Include Label="SymmetricGroup"> <#Include Label="MathieuGroup"> <#Include Label="SuzukiGroup"> <#Include Label="ReeGroup">
Classical Groups <#Include Label="[1]{classic}"> <#Include Label="GeneralLinearGroup"> <#Include Label="SpecialLinearGroup"> <#Include Label="GeneralUnitaryGroup"> <#Include Label="SpecialUnitaryGroup"> <#Include Label="SymplecticGroup"> <#Include Label="GeneralOrthogonalGroup"> <#Include Label="SpecialOrthogonalGroup"> <#Include Label="Omega_orthogonal_groups"> <#Include Label="GeneralSemilinearGroup"> <#Include Label="SpecialSemilinearGroup"> <#Include Label="ProjectiveGeneralLinearGroup"> <#Include Label="ProjectiveSpecialLinearGroup"> <#Include Label="ProjectiveGeneralUnitaryGroup"> <#Include Label="ProjectiveSpecialUnitaryGroup"> <#Include Label="ProjectiveSymplecticGroup"> <#Include Label="ProjectiveOmega">
Conjugacy Classes in Classical Groups ConjugacyClasses For general and special linear groups (see  and ) &GAP; has an efficient method to generate representatives of the conjugacy classes. This uses results from linear algebra on normal forms of matrices. If you know how to do this for other types of classical groups, please, tell us.

g := SL(4,9); SL(4,9) gap> NrConjugacyClasses(g); 861 gap> cl := ConjugacyClasses(g);; gap> Length(cl); 861 ]]>

<#Include Label="NrConjugacyClassesGL">

Constructors for Basic Groups All functions described in the previous sections call constructor operations to do the work. The names of the constructors are obtained from the names of the functions by appending "Cons", so for example calls the constructor

CyclicGroupCons( cat, n )

The first argument cat for each method of this constructor must be the category for which the method is installed. For example the method for constructing a cyclic permutation group is installed as follows (see  for the meaning of the arguments.

Selection Functions AllPrimitiveGroups AllTransitiveGroups AllLibraryGroups AllLibraryGroups( fun1, val1, ... )

For a number of the group libraries two selection functions are provided. Each AllLibraryGroups selection function permits one to select all groups from the library Library that have a given set of properties. Currently, the library selection functions provided, of this type, are , , AllTransitiveGroups, and AllPrimitiveGroups. Corresponding to each of these there is a OneLibraryGroup function (see below) which returns at most one group.

These functions take an arbitrary number of pairs (but at least one pair) of arguments. The first argument in such a pair is a function that can be applied to the groups in the library, and the second argument is either a single value that this function must return in order to have this group included in the selection, or a list of such values. For the function the first such function must be , and, unlike the other library selection functions, it supports an alternative syntax where is omitted (see ). Also, see , for details pertaining to this function.

For an example, let us consider the selection function for the library of transitive groups (also see ). The command

AllTransitiveGroups(NrMovedPoints,[10..15], > Size, [1..100], > IsAbelian, false ); ]]>

returns a list of all transitive groups with degree between 10 and 15 and size less than 100 that are not abelian.

Thus AllTransitiveGroups behaves as if it was implemented by a function similar to the one defined below, where TransitiveGroupsList is a list of all transitive groups. (Note that in the definition below we assume for simplicity that AllTransitiveGroups accepts exactly 4 arguments. It is of course obvious how to change this definition so that the function would accept a variable number of arguments.)

Note that the real selection functions are considerably more difficult, to improve the efficiency. Most important, each recognizes a certain set of properties which are precomputed for the library without having to compute them anew for each group. This will substantially speed up the selection process. In the description of each library we will list the properties that are stored for this library.

OnePrimitiveGroup OneTransitiveGroup OneLibraryGroup OneLibraryGroup( fun1, val1, ... )

For each AllLibraryGroups function (see above) there is a corresponding function OneLibraryGroup on exactly the same arguments, i.e., there are OneSmallGroup, OneIrreducibleSolvableGroup, OneTransitiveGroup, and OnePrimitiveGroup. Each function simply returns one group in the library that has the prescribed properties, instead of all such groups. It returns fail if no such group exists in the library.

Transitive Permutation Groups The transitive groups library currently contains representatives for all transitive permutation groups of degree at most 30. Two permutations groups of the same degree are considered to be equivalent, if there is a renumbering of points, which maps one group into the other one. In other words, if they lie in the same conjugacy class under operation of the full symmetric group by conjugation.

The selection functions (see ) for the transitive groups library are AllTransitiveGroups and OneTransitiveGroup. They obtain the following attributes from the database without having to compute them anew:

, , , and .

This library was computed by Gregory Butler, John McKay, Gordon Royle and Alexander Hulpke. The list of transitive groups up to degree 11 was published in , the list of degree 12 was published in , degree 14 and 15 were published in and degrees 16-30 were published in and . (Groups of prime degree of course are primitive and were known long before.)

The arrangement and the names of the groups of degree up to 15 is the same as given in . With the exception of the symmetric and alternating group (which are represented as and ) the generators for these groups also conform to this paper with the only difference that 0 (which is not permitted in &GAP; for permutations to act on) is always replaced by the degree.

<#Include Label="TransitiveGroup"> <#Include Label="NrTransitiveGroups"> <#Include Label="TransitiveIdentification">

Small Groups The Small Groups library gives access to all groups of certain small orders. The groups are sorted by their orders and they are listed up to isomorphism; that is, for each of the available orders a complete and irredundant list of isomorphism type representatives of groups is given. Currently, the library contains the following groups:

those of order at most 2000 except 1024   (423\;164\;062 groups); those of cubefree order at most 50 000   (395 \; 703 groups); those of order p^7 for the primes p = 3,5,7,11   (907 \; 489 groups); those of order p^n for n \leq 6 and all primes p those of order q^n \cdot p for q^n dividing 2^8, 3^6, 5^5 or 7^4 and all primes p with p \neq q; those of squarefree order; those whose order factorises into at most 3 primes.

The first three items in this list cover an explicit range of orders; the last four provide access to infinite families of groups having orders of certain types.

The library also has an identification function: it returns the library number of a given group. This function determines library numbers using invariants of groups. The function is available for all orders in the library except for the orders 512 and 1536 and except for the orders p^5, p^6 and p^7 above 2000.

The library is organised in 11 layers. Each layer contains the groups of certain orders and their corresponding group identification routines. It is possible to install the first n layers of the group library and the first m layers of the group identification for each 1 \leq m \leq n \leq 11. This might be useful to save disk space. There is an extensive README file for the Small Groups library available in the small directory of the &GAP; distribution containing detailed information on the layers. A brief description of the layers is given here: (1) the groups whose order factorises into at most 3 primes. (2) the remaining groups of order at most 1000 except 512 and 768. (3) the remaining groups of order 2^n \cdot p with n \leq 8 and p an odd prime. (4) the remaining groups of order 5^5, 7^4 and of order q^n \cdot p for q^n dividing 3^6, 5^5 or 7^4 and p \neq q a prime. (5) the remaining groups of order at most 2000 except 1024, 1152, 1536 and 1920. (6) the groups of orders 1152 and 1920. (7) the groups of order 512. (8) the groups of order 1536. (9) the remaining groups of order p^n for 4 \leq n \leq 6. (10) the remaining groups of cubefree order at most 50 000 and of squarefree order. (11) the remaining groups of order p^7 for p = 3,5,7,11.

The data in this library has been carefully checked and cross-checked. It is believed to be reliable. However, no absolute guarantees are given and users should, as always, make their own checks in critical cases.

The data occupies about 30 MB (storing over 400 million groups in about 200 megabits). The group identification occupies about 47 MB of which 18 MB is used for the groups in layer (6). More information on the Small Groups library can be found on http://www.icm.tu-bs.de/ag_algebra/software/small/

This library has been constructed by Hans Ulrich Besche, Bettina Eick and E. A. O'Brien. A survey on this topic and an account of the history of group constructions can be found in . Further detailed information on the construction of this library is available in , , , , , , , , , , , , . TwoGroup library ThreeGroup library The Small Groups library incorporates the &GAP; 3 libraries TwoGroup and ThreeGroup. The data from these libraries was directly included into the Small Groups library, and the ordering there was preserved. The Small Groups library replaces the Gap 3 library of solvable groups of order at most 100. However, both the organisation and data descriptions of these groups has changed in the Small Groups library.

<#Include Label="SmallGroup"> <#Include Label="AllSmallGroups"> <#Include Label="OneSmallGroup"> <#Include Label="NumberSmallGroups"> <#Include Label="IdSmallGroup"> <#Include Label="IdsOfAllSmallGroups"> <#Include Label="IdGap3SolvableGroup"> <#Include Label="SmallGroupsInformation"> <#Include Label="UnloadSmallGroupsData">

Finite Perfect Groups perfect groups The &GAP; library of finite perfect groups provides, up to isomorphism, a list of all perfect groups whose sizes are less than 10^6 excluding the following sizes:

For n = 61440, 122880, 172032, 245760, 344064, 491520, 688128, or 983040, the perfect groups of size n have not completely been determined yet. The library neither provides the number of these groups nor the groups themselves. For n = 86016, 368640, or 737280, the library does not yet contain the perfect groups of size n, it only provides their numbers which are 52, 46, and 54, respectively.

Except for these eleven sizes, the list of altogether 1097 perfect groups in the library is complete. It relies on results of Derek F. Holt and Wilhelm Plesken which are published in their book Perfect Groups . Moreover, they have supplied us with files with presentations of 488 of the groups. In terms of these, the remaining 607 nontrivial groups in the library can be described as 276 direct products, 107 central products, and 224 subdirect products. They are computed automatically by suitable &GAP; functions whenever they are needed. Two additional groups omitted from the book Perfect Groups have also been included.

We are grateful to Derek Holt and Wilhelm Plesken for making their groups available to the &GAP; community by contributing their files. It should be noted that their book contains a lot of further information for many of the library groups. So we would like to recommend it to any &GAP; user who is interested in the groups.

The library has been brought into &GAP; format by Volkmar Felsch.

As all groups are stored by presentations, a permutation representation is obtained by coset enumeration. Note that some of the library groups do not have a faithful permutation representation of small degree. Computations in these groups may be rather time consuming. <#Include Label="SizesPerfectGroups"> <#Include Label="PerfectGroup"> <#Include Label="PerfectIdentification"> <#Include Label="NumberPerfectGroups"> <#Include Label="NumberPerfectLibraryGroups"> <#Include Label="SizeNumbersPerfectGroups"> <#Include Label="DisplayInformationPerfectGroups"> More about the Perfect Groups Library For any library group G, the library files do not only provide a presentation, but, in addition, a list of one or more subgroups S_1, \ldots, S_r of G such that there is a faithful permutation representation of G of degree \sum_{{i = 1}}^r [G:S_i] on the set \{ S_i g \mid 1 \leq i \leq r, g \in G \} of the cosets of the S_i. This allows one to construct the groups as permutation groups. The function displays only the available degree. The message

in the above example means that the available permutation representation is transitive and of degree 8, whereas the message means that a nontransitive permutation representation is available which acts on two orbits of size 5 and 16 respectively.

The notation used in the description of a group is explained in section 5.1.2 of . We quote the respective page from there:

Within a class Q\,\#\,p, an isomorphism type of groups will be denoted by an ordered pair of integers (r,n), where r \geq 0 and n > 0. More precisely, the isomorphism types in Q \# p of order p^r |Q| will be denoted by (r,1), (r,2), (r,3), \ldots\,. Thus Q will always get the size number (0,1).

In addition to the symbol (r,n), the groups in Q\,\#\,p will also be given a more descriptive name. The purpose of this is to provide a very rough idea of the structure of the group. The names are derived in the following manner. First of all, the isomorphism classes of irreducible F_pQ-modules M with |Q|.|M| \leq 10^6, where F_p is the field of order p, are assigned symbols. These will either be simply p^x, where x is the dimension of the module, or, if there is more than one isomorphism class of irreducible modules having the same dimension, they will be denoted byp^x, p^{{x'}}, etc. The one-dimensional module with trivial Q-action will therefore be denoted by p^1. These symbols will be listed under the description of Q. The group name consists essentially of a list of the composition factors working from the top of the group downwards; hence it always starts with the name of Q itself. (This convention is the most convenient in our context, but it is different from that adopted in the ATLAS , for example, where composition factors are listed in the reverse order. For example, we denote a group isomorphic to SL(2,5) by A_5 2^1 rather than 2.A_5.)

Some other symbols are used in the name, in order to give some idea of the relationship between these composition factors, and splitting properties. We shall now list these additional symbols.

\times between two factors denotes a direct product of F_pQ-modules or groups. C (for commutator) between two factors means that the second lies in the commutator subgroup of the first. Similarly, a segment of the form (f_1 \! \times \! f_2) C f_3 would mean that the factors f_1 and f_2 commute modulo f_3 and f_3 lies in [f_1,f_2]. A (for abelian) between two factors indicates that the second is in the pth power (but not the commutator subgroup) of the first. A may also follow the factors, if bracketed. E (for elementary abelian) between two factors indicates that together they generate an elementary abelian group (modulo subsequent factors), but that the resulting F_p Q-module extension does not split. N (for nonsplit) before a factor indicates that Q (or possibly its covering group) splits down as far at this factor but not over the factor itself. So Q f_1 N f_2 means that the normal subgroup f_1 f_2 of the group has no complement but, modulo f_2, f_1, does have a complement.

Brackets have their obvious meaning. Summarizing, we have:

\times = direct product; C = commutator subgroup; A = abelian; E = elementary abelian; and N = nonsplit.

Here are some examples.

(i) A_5 (2^4 E 2^1 E 2^4) A means that the pairs 2^4 E 2^1 and 2^1 E 2^4 are both elementary abelian of exponent 4. (ii) A_5 (2^4 E 2^1 A) C 2^1 means that O_2(G) is of symplectic type 2^{{1+5}}, with Frattini factor group of type 2^4 E 2^1. The A after the 2^1 indicates that G has a central cyclic subgroup 2^1 A 2^1 of order 4. (iii) L_3(2) ((2^1 E) \! \times \! ( N 2^3 E 2^{{3'}} A) C) 2^{{3'}} means that the 2^{{3'}} factor at the bottom lies in the commutator subgroup of the pair 2^3 E 2^{{3'}} in the middle, but the lower pair 2^{{3'}} A 2^{{3'}} is abelian of exponent 4. There is also a submodule 2^1 E 2^{{3'}}, and the covering group L_3(2) 2^1 of L_3(2) does not split over the 2^3 factor. (Since G is perfect, it goes without saying that the extension L_3(2) 2^1 cannot split itself.)

We must stress that this notation does not always succeed in being precise or even unambiguous, and the reader is free to ignore it if it does not seem helpful.

If such a group description has been given in the book for G (and, in fact, this is the case for most of the library groups), it is displayed by . Otherwise the function provides a less explicit description of the (in these cases unique) Holt-Plesken class to which G belongs, together with a serial number if this is necessary to make it unique.

Primitive Permutation Groups <#Include Label="[1]{primitiv}">

<#Include Label="[2]{primitiv}"> <#Include Label="PrimitiveGroup"> <#Include Label="NrPrimitiveGroups"> <#Include Label="PrimitiveGroupsIterator"> In the primitive groups are sorted in cohorts according to their socle. For each degree, the variable contains a list of the cohorts for the primitive groups of this degree. Each cohort is represented by a list of length 2, the first entry specifies the socle type (see ), the second entry listing the index numbers of the groups in this degree.

For example in degree 49, we have four cohorts with socles (&ZZ; / 7 &ZZ;)^2, L_2(7)^2, A_7^2 and A_{49} respectively. the group PrimitiveGroup(49,36), which is isomorphic to (A_7 \times A_7):2^2, lies in the third cohort with socle (A_7 \times A_7).

COHORTS_PRIMITIVE_GROUPS[49]; [ [ rec( parameter := 7, series := "Z", width := 2 ), [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33 ] ], [ rec( parameter := [ 2, 7 ], series := "L", width := 2 ), [ 34 ] ], [ rec( parameter := 7, series := "A", width := 2 ), [ 35, 36, 37, 38 ] ], [ rec( parameter := 49, series := "A", width := 1 ), [ 39, 40 ] ] ] ]]>

Index numbers of primitive groups <#Include Label="PrimitiveIdentification"> <#Include Label="SimsNo"> The system Magma also provides a list of primitive groups (see ). For historical reasons, its indexing up to degree 999 differs from the one used by &GAP;. The variable can be used to obtain this correspondence. The magma index number of the &GAP; group PrimitiveGroup(deg,nr) is stored in the entry PRIMITIVE_INDICES_MAGMA[deg][nr], for degree at most 999.

Vice versa, the group of degree deg with Magma index number nr has the &GAP; index

Position(PRIMITIVE_INDICES_MAGMA[deg],nr), in particular it can be obtained by the &GAP; command

PrimitiveGroup(deg,Position(PRIMITIVE_INDICES_MAGMA[deg],nr));

Irreducible Solvable Matrix Groups <#Include Label="IrreducibleSolvableGroupMS"> <#Include Label="NumberIrreducibleSolvableGroups"> <#Include Label="AllIrreducibleSolvableGroups"> <#Include Label="OneIrreducibleSolvableGroup"> <#Include Label="PrimitiveIndexIrreducibleSolvableGroup"> <#Include Label="IrreducibleSolvableGroup">
Irreducible Maximal Finite Integral Matrix Groups A library of irreducible maximal finite integral matrix groups is provided with &GAP;. It contains &QQ;-class representatives for all of these groups of dimension at most 31, and &ZZ;-class representatives for those of dimension at most 11 or of dimension 13, 17, 19, or 23.

The groups provided in this library have been determined by Wilhelm Plesken, partially as joint work with Michael Pohst, or by members of his institute (Lehrstuhl B für Mathematik, RWTH Aachen). In particular, the data for the groups of dimensions 2 to 9 have been taken from the output of computer calculations which they performed in 1979 (see , ). The &ZZ;-class representatives of the groups of dimension 10 have been determined and computed by Bernd Souvignier (), and those of dimensions 11, 13, and 17 have been recomputed for this library from the circulant Gram matrices given in , using the stand-alone programs for the computation of short vectors and Bravais groups which have been developed in Plesken's institute. The &ZZ;-class representatives of the groups of dimensions 19 and 23 had already been determined in . Gabriele Nebe has recomputed them for us. Her main contribution to this library, however, is that she has determined and computed the &QQ;-class representatives of the groups of non-prime dimensions between 12 and 24 and the groups of dimensions 25 to 31 (see , , , ).

The library has been brought into &GAP; format by Volkmar Felsch. He has applied several &GAP; routines to check certain consistency of the data. However, the credit and responsibility for the lists remain with the authors. We are grateful to Wilhelm Plesken, Gabriele Nebe, and Bernd Souvignier for supplying their results to &GAP;.

In the preceding acknowledgement, we used some notations that will also be needed in the sequel. We first define these.

Any integral matrix group G of dimension n is a subgroup of GL_n(&ZZ;) as well as of GL_n(&QQ;) and hence lies in some conjugacy class of integral matrix groups under GL_n(&ZZ;) and also in some conjugacy class of rational matrix groups under GL_n(&QQ;). As usual, we call these classes the &ZZ;-class and the &QQ;-class of G, respectively. Note that any conjugacy class of subgroups of GL_n(&QQ;) contains at least one &ZZ;-class of subgroups of GL_n(&ZZ;) and hence can be considered as the &QQ;-class of some integral matrix group.

In the context of this library we are only concerned with &ZZ;-classes and &QQ;-classes of subgroups of GL_n(&ZZ;) which are irreducible and maximal finite in GL_n(&ZZ;) (we will call them i.m.f. subgroups of GL_n(&ZZ;)). We can distinguish two types of these groups:

First, there are those i.m.f. subgroups of GL_n(&ZZ;) which are also maximal finite subgroups of GL_n(&QQ;). Let us denote the set of their &QQ;-classes by Q_1(n). It is clear from the above remark that Q_1(n) just consists of the &QQ;-classes of i.m.f. subgroups of GL_n(&QQ;).

Secondly, there is the set Q_2(n) of the &QQ;-classes of the remaining i.m.f. subgroups of GL_n(&ZZ;), i.e., of those which are not maximal finite subgroups of GL_n(&QQ;). For any such group G, say, there is at least one class C \in Q_1(n) such that G is conjugate under &QQ; to a proper subgroup of some group H \in C. In fact, the class C is uniquely determined for any group G occurring in the library (though there seems to be no reason to assume that this property should hold in general). Hence we may call C the rational i.m.f. class of G. Finally, we will denote the number of classes in Q_1(n) and Q_2(n) by q_1(n) and q_2(n), respectively.

As an example, let us consider the case n = 4. There are 6 &ZZ;-classes of i.m.f. subgroups of GL_4(&ZZ;) with representative subgroups G_1, \ldots, G_6 of isomorphism types G_1 \cong W(F_4), G_2 \cong D_{12} \wr C_2, G_3 \cong G_4 \cong C_2 \times S_5, G_5 \cong W(B_4), and G_6 \cong (D_{12} Y D_{12}) \!:\! C_2. The corresponding &QQ;-classes, R_1, \ldots, R_6, say, are pairwise different except that R_3 coincides with R_4. The groups G_1, G_2, and G_3 are i.m.f. subgroups of GL_4(&QQ;), but G_5 and G_6 are not because they are conjugate under GL_4(&QQ;) to proper subgroups of G_1 and G_2, respectively. So we have Q_1(4) = \{ R_1, R_2, R_3 \}, Q_2(4) = \{ R_5, R_6 \}, q_1(4) = 3, and q_2(4) = 2.

The q_1(n) &QQ;-classes of i.m.f. subgroups of GL_n(&QQ;) have been determined for each dimension n \leq 31. The current &GAP; library provides integral representative groups for all these classes. Moreover, all &ZZ;-classes of i.m.f. subgroups of GL_n(&ZZ;) are known for n \leq 11 and for n \in \{13,17,19,23\}. For these dimensions, the library offers integral representative groups for all &QQ;-classes in Q_1(n) and Q_2(n) as well as for all &ZZ;-classes of i.m.f. subgroups of GL_n(&ZZ;).

Any group G of dimension n given in the library is represented as the automorphism group G = Aut(F,L) = \{ g \in GL_n(&ZZ;) \mid Lg = L, g F g^{tr} = F \} of a positive definite symmetric n \times n matrix F \in &ZZ;^{{n \times n}} on an n-dimensional lattice L \cong &ZZ;^{{1 \times n}} (for details see e.g. ). &GAP; provides for G a list of matrix generators and the Gram matrix F.

The positive definite quadratic form defined by F defines a norm v F v^{tr} for each vector v \in L, and there is only a finite set of vectors of minimal norm. These vectors are often simply called the short vectors. Their set splits into orbits under G, and G being irreducible acts faithfully on each of these orbits by multiplication from the right. &GAP; provides for each of these orbits the orbit size and a representative vector.

Like most of the other &GAP; libraries, the library of i.m.f. integral matrix groups supplies an extraction function, ImfMatrixGroup. However, as the library involves only 525 different groups, there is no need for a selection or an example function. Instead, there are two functions, and , which provide some &ZZ;-class invariants that can be extracted from the library without actually constructing the representative groups themselves. The difference between these two functions is that the latter one displays the resulting data in some easily readable format, whereas the first one returns them as record components so that you can properly access them.

We shall give an individual description of each of the library functions, but first we would like to insert a short remark concerning their names: Any self-explaining name of a function handling irreducible maximal finite integral matrix groups would have to include this term in full length and hence would grow extremely long. Therefore we have decided to use the abbreviation Imf instead in order to restrict the names to some reasonable length.

The first three functions can be used to formulate loops over the classes.

ImfNumberQQClasses returns the number q_1(dim) of &QQ;-classes of i.m.f. rational matrix groups of dimension dim. Valid values of dim are all positive integers up to 31.

Note: In order to enable you to loop just over the classes belonging to Q_1(dim), we have arranged the list of &QQ;-classes of dimension dim for any dimension dim in the library such that, whenever the classes of Q_2(dim) are known, too, i.e., in the cases dim \leq 11 or dim \in \{13,17,19,23\}, the classes of Q_1(dim) precede those of Q_2(dim) and hence are numbered from 1 to q_1(dim).

ImfNumberQClasses returns the number of &QQ;-classes of groups of dimension dim which are available in the library. If dim \leq 11 or dim \in \{13,17,19,23\}, this is the number q_1(dim) + q_2(dim) of &QQ;-classes of i.m.f. subgroups of GL_{dim}(&ZZ;). Otherwise, it is just the number q_1(dim) of &QQ;-classes of i.m.f. subgroups of GL_{dim}(&QQ;). Valid values of dim are all positive integers up to 31.

returns the number of &ZZ;-classes in the q-th &QQ;-class of i.m.f. integral matrix groups of dimension dim. Valid values of dim are all positive integers up to 11 and all primes up to 23.

displays the following &ZZ;-class invariants of the groups in the z-th &ZZ;-class in the q-th &QQ;-class of i.m.f. integral matrix groups of dimension dim:

its &ZZ;-class number in the form dim.q.z, if dim is at most 11 or a prime at most 23, or its &QQ;-class number in the form dim.q, else, a message if the group is solvable, the size of the group, the isomorphism type of the group, the elementary divisors of the associated quadratic form, the sizes of the orbits of short vectors (these sizes are the degrees of the faithful permutation representations which you may construct using the functions or below), the norm of the associated short vectors, only in case that the group is not an i.m.f. group in GL_n(&QQ;): an appropriate message, including the &QQ;-class number of the corresponding rational i.m.f. class.

If you specify the value 0 for any of the parameters dim, q, or z, the command will loop over all available dimensions, &QQ;-classes of given dimension, or &ZZ;-classes within the given &QQ;-class, respectively. Otherwise, the values of the arguments must be in range. A value z \neq 1 must not be specified if the &ZZ;-classes are not known for the given dimension, i.e., if dim > 11 and dim \not \in \{ 13, 17, 19, 23 \}. The default value of z is 1. This value of z will be accepted even if the &ZZ;-classes are not known. Then it specifies the only representative group which is available for the q-th &QQ;-class. The greatest legal value of dim is 31.

DisplayImfInvariants( 3, 1, 0 ); #I Z-class 3.1.1: Solvable, size = 2^4*3 #I isomorphism type = C2 wr S3 = C2 x S4 = W(B3) #I elementary divisors = 1^3 #I orbit size = 6, minimal norm = 1 #I Z-class 3.1.2: Solvable, size = 2^4*3 #I isomorphism type = C2 wr S3 = C2 x S4 = C2 x W(A3) #I elementary divisors = 1*4^2 #I orbit size = 8, minimal norm = 3 #I Z-class 3.1.3: Solvable, size = 2^4*3 #I isomorphism type = C2 wr S3 = C2 x S4 = C2 x W(A3) #I elementary divisors = 1^2*4 #I orbit size = 12, minimal norm = 2 gap> DisplayImfInvariants( 8, 15, 1 ); #I Z-class 8.15.1: Solvable, size = 2^5*3^4 #I isomorphism type = C2 x (S3 wr S3) #I elementary divisors = 1*3^3*9^3*27 #I orbit size = 54, minimal norm = 8 #I not maximal finite in GL(8,Q), rational imf class is 8.5 gap> DisplayImfInvariants( 20, 23 ); #I Q-class 20.23: Size = 2^5*3^2*5*11 #I isomorphism type = (PSL(2,11) x D12).C2 #I elementary divisors = 1^18*11^2 #I orbit size = 3*660 + 2*1980 + 2640 + 3960, minimal norm = 4 ]]>

Note that the function uses a kind of shorthand to display the elementary divisors. E. g., the expression 1*3^3*9^3*27 in the preceding example stands for the elementary divisors 1,3,3,3,9,9,9,27. (See also the next example which shows that the function provides the elementary divisors in form of an ordinary &GAP; list.)

In the description of the isomorphism types the following notations are used: A x B denotes a direct product of a group A by a group B, A subd B denotes a subdirect product of A by B, A Y B denotes a central product of A by B, A wr B denotes a wreath product of A by B, A:B denotes a split extension of A by B, A.B denotes just an extension of A by B (split or nonsplit).

The groups involved are the cyclic groups C_n, dihedral groups D_n, and generalized quaternion groups Q_n of order n, denoted by Cn, Dn, and Qn, respectively, the alternating groups A_n and symmetric groups S_n of degree n, denoted by An and Sn, respectively, the linear groups GL_n(q), PGL_n(q), SL_n(q), and PSL_n(q), denoted by GL(n,q), PGL(n,q), SL(n,q), and PSL(n,q), respectively, the unitary groups SU_n(q) and PSU_n(q), denoted by SU(n,q) and PSU(n,q), respectively, the symplectic groups Sp(n,q) and PSp(n,q), denoted by Sp(n,q) and PSp(n,q), respectively, the orthogonal groups O_8^+(2) and PO_8^+(2), denoted by O+(8,2) and PO+(8,2), respectively, the extraspecial groups 2_+^{{1+8}}, 3_+^{{1+2}}, 3_+^{{1+4}}, and 5_+^{{1+2}}, denoted by 2+^(1+8), 3+^(1+2), 3+^(1+4), and 5+^(1+2), respectively, the Chevalley group G_2(3), denoted by G2(3), the twisted Chevalley group {^3}D_4(2), denoted by 3D4(2), the Suzuki group Sz(8), denoted by Sz(8), the Weyl groups W(A_n), W(B_n), W(D_n), W(E_n), and W(F_4), denoted by W(An), W(Bn), W(Dn), W(En), and W(F4), respectively, the sporadic simple groups Co_1, Co_2, Co_3, HS, J_2, M_{12}, M_{22}, M_{23}, M_{24}, and Mc, denoted by Co1, Co2, Co3, HS, J2, M12, M22, M23, M24, and Mc, respectively, a point stabilizer of index 11 in M_{11}, denoted by M10.

As mentioned above, the data assembled by the function are cheap data in the sense that they can be provided by the library without loading any of its large matrix files or performing any matrix calculations. The following function allows you to get proper access to these cheap data instead of just displaying them. returns a record which provides some &ZZ;-class invariants of the groups in the z-th &ZZ;-class in the q-th &QQ;-class of i.m.f. integral matrix groups of dimension dim. A value z \neq 1 must not be specified if the &ZZ;-classes are not known for the given dimension, i.e., if dim > 11 and dim \not \in \{ 13, 17, 19, 23 \}. The default value of z is 1. This value of z will be accepted even if the &ZZ;-classes are not known. Then it specifies the only representative group which is available for the q-th &QQ;-class. The greatest legal value of dim is 31.

The resulting record contains six or seven components:

size the size of any representative group G, isSolvable is true if G is solvable, isomorphismType a text string describing the isomorphism type of G (in the same notation as used by the function DisplayImfInvariants above), elementaryDivisors the elementary divisors of the associated Gram matrix F (in the same format as the result of the function , minimalNorm the norm of the associated short vectors, sizesOrbitsShortVectors the sizes of the orbits of short vectors under F, maximalQClass the &QQ;-class number of an i.m.f. group in GL_n(&QQ;) that contains G as a subgroup (only in case that not G itself is an i.m.f. subgroup of GL_n(&QQ;)).

Note that four of these data, namely the group size, the solvability, the isomorphism type, and the corresponding rational i.m.f. class, are not only &ZZ;-class invariants, but also &QQ;-class invariants.

Note further that, though the isomorphism type is a &QQ;-class invariant, you will sometimes get different descriptions for different &ZZ;-classes of the same &QQ;-class (as, e.g., for the classes 3.1.1 and 3.1.2 in the last example above). The purpose of this behaviour is to provide some more information about the underlying lattices.

ImfInvariants( 8, 15, 1 ); rec( elementaryDivisors := [ 1, 3, 3, 3, 9, 9, 9, 27 ], isSolvable := true, isomorphismType := "C2 x (S3 wr S3)", maximalQClass := 5, minimalNorm := 8, size := 2592, sizesOrbitsShortVectors := [ 54 ] ) gap> ImfInvariants( 24, 1 ).size; 10409396852733332453861621760000 gap> ImfInvariants( 23, 5, 2 ).sizesOrbitsShortVectors; [ 552, 53130 ] gap> for i in [ 1 .. ImfNumberQClasses( 22 ) ] do > Print( ImfInvariants( 22, i ).isomorphismType, "\n" ); od; C2 wr S22 = W(B22) (C2 x PSU(6,2)).S3 (C2 x S3) wr S11 = (C2 x W(A2)) wr S11 (C2 x S12) wr C2 = (C2 x W(A11)) wr C2 C2 x S3 x S12 = C2 x W(A2) x W(A11) (C2 x HS).C2 (C2 x Mc).C2 C2 x S23 = C2 x W(A22) C2 x PSL(2,23) C2 x PSL(2,23) C2 x PGL(2,23) C2 x PGL(2,23) ]]> is the essential extraction function of this library (note that its name has been changed from ImfMatGroup in &GAP; 3 to in &GAP; 4). It returns a representative group, G say, of the z-th &ZZ;-class in the q-th &QQ;-class of i.m.f. integral matrix groups of dimension dim. A value z \neq 1 must not be specified if the &ZZ;-classes are not known for the given dimension, i.e., if dim > 11 and dim \not \in \{ 13, 17, 19, 23 \}. The default value of z is 1. This value of z will be accepted even if the &ZZ;-classes are not known. Then it specifies the only representative group which is available for the q-th &QQ;-class. The greatest legal value of dim is 31.

G := ImfMatrixGroup( 5, 1, 3 ); ImfMatrixGroup(5,1,3) gap> for m in GeneratorsOfGroup( G ) do PrintArray( m ); od; [ [ -1, 0, 0, 0, 0 ], [ 0, 1, 0, 0, 0 ], [ 0, 0, 0, 1, 0 ], [ -1, -1, -1, -1, 2 ], [ -1, 0, 0, 0, 1 ] ] [ [ 0, 1, 0, 0, 0 ], [ 0, 0, 1, 0, 0 ], [ 0, 0, 0, 1, 0 ], [ 1, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 1 ] ] ]]>

The attributes and IsSolvable will be properly set in the resulting matrix group G. In addition, it has two attributes IsImfMatrixGroup and ImfRecord where the first one is just a logical flag set to true and the latter one is a record. Except for the group size and the solvability flag, this record contains the same components as the resulting record of the function described above, namely the components isomorphismType, elementaryDivisors, minimalNorm, and sizesOrbitsShortVectors and, if G is not a rational i.m.f. group, maximalQClass. Moreover, it has the two components

form the associated Gram matrix F, and repsOrbitsShortVectors representatives of the orbits of short vectors under F.

The last one of these components will be required by the function below.

Size( G ); 3840 gap> imf := ImfRecord( G );; gap> imf.isomorphismType; "C2 wr S5 = C2 x W(D5)" gap> PrintArray( imf.form ); [ [ 4, 0, 0, 0, 2 ], [ 0, 4, 0, 0, 2 ], [ 0, 0, 4, 0, 2 ], [ 0, 0, 0, 4, 2 ], [ 2, 2, 2, 2, 5 ] ] gap> imf.elementaryDivisors; [ 1, 4, 4, 4, 4 ] gap> imf.minimalNorm; 4 ]]>

If you want to perform calculations in such a matrix group G you should be aware of the fact that the permutation group routines of &GAP; are much more efficient than the matrix group routines. Hence we recommend that you do your computations, whenever possible, in the isomorphic permutation group which is induced by the action of G on one of the orbits of the associated short vectors. You may call one of the following functions or to get an isomorphism to such a permutation group (note that these &GAP; 4 functions have replaced the &GAP; 3 functions PermGroup and PermGroupImfGroup). returns an isomorphism, \varphi say, from the given i.m.f. integral matrix group G to a permutation group P := \varphi(G) acting on a minimal orbit, S say, of short vectors of G such that each matrix m \in G is mapped to the permutation induced by its action on S.

Note that in case of a large orbit the construction of \varphi may be space and time consuming. Fortunately, there are only six &QQ;-classes in the library for which the smallest orbit of short vectors is of size greater than 20000, the worst case being the orbit of size 196560 for the Leech lattice (dim = 24, q = 3).

The inverse isomorphism \varphi^{{-1}} from P to G is constructed by determining a &QQ;-base B \subset S of &QQ;^{{1 \times dim}} in S and, in addition, the associated base change matrix M which transforms B into the standard base of &ZZ;^{{1 \times dim}}. This allows a simple computation of the preimage \varphi^{{-1}}(p) of any permutation p \in P, as follows. If, for 1 \leq i \leq dim, b_i is the position number in S of the i-th base vector in B, it suffices to look up the vector whose position number in S is the image of b_i under p and to multiply this vector by M to get the i-th row of \varphi^{{-1}}(p).

You may use the functions and to switch from G to P and back from P to G.

As an example, let us continue the preceding example and compute the solvable residuum of the group G.

# Perform the computations in an isomorphic permutation group. gap> phi := IsomorphismPermGroup( G );; gap> P := Image( phi ); Group([ (1,7,6)(2,9)(4,5,10), (2,3,4,5)(6,9,8,7) ]) gap> D := DerivedSubgroup( P ); Group([ (1,2,10,9)(3,8)(4,5)(6,7), (1,6)(2,7,9,4)(3,8)(5,10), (1,2)(4,5)(6,7)(9,10), (1,8)(2,6,9,5)(3,10)(4,7) ]) gap> Size( D ); 960 gap> IsPerfectGroup( D ); true gap> # We have found the solvable residuum of P, gap> # now move the results back to the matrix group G. gap> R := PreImage( phi, D ); gap> for m in GeneratorsOfGroup( R ) do PrintArray( m ); od; [ [ -1, -1, -1, -1, 2 ], [ 0, -1, 0, 0, 0 ], [ 0, 0, 0, 1, 0 ], [ 0, 0, 1, 0, 0 ], [ -1, -1, 0, 0, 1 ] ] [ [ 0, 0, -1, 0, 0 ], [ 0, -1, 0, 0, 0 ], [ 1, 0, 0, 0, 0 ], [ -1, -1, -1, -1, 2 ], [ 0, -1, -1, 0, 1 ] ] [ [ 1, 1, 1, 1, -2 ], [ 0, 1, 0, 0, 0 ], [ 0, 0, 0, 1, 0 ], [ 0, 0, 1, 0, 0 ], [ 0, 1, 1, 1, -1 ] ] [ [ 0, 0, 0, -1, 0 ], [ -1, -1, -1, -1, 2 ], [ 0, 0, -1, 0, 0 ], [ 1, 0, 0, 0, 0 ], [ 0, 0, -1, -1, 1 ] ] ]]> returns an isomorphism, \varphi say, from the given i.m.f. integral matrix group G to a permutation group P acting on the n-th orbit, S say, of short vectors of G such that each matrix m \in G is mapped to the permutation induced by its action on S.

The only difference to the above function is that you can specify the orbit to be used. In fact, as the orbits of short vectors are sorted by increasing sizes, the function IsomorphismPermGroup( G ) has been implemented such that it is equivalent to IsomorphismPermGroupImfGroup( G, 1 ).

ImfInvariants( 12, 9 ).sizesOrbitsShortVectors; [ 120, 300 ] gap> G := ImfMatrixGroup( 12, 9 ); ImfMatrixGroup(12,9) gap> phi1 := IsomorphismPermGroupImfGroup( G, 1 );; gap> P1 := Image( phi1 ); gap> LargestMovedPoint( P1 ); 120 gap> phi2 := IsomorphismPermGroupImfGroup( G, 2 );; gap> P2 := Image( phi2 ); gap> LargestMovedPoint( P2 ); 300 ]]>

gap-4r6p5/doc/ref/grpperm.xml0000644000175000017500000006732412172557252014674 0ustar billbill Permutation Groups
IsPermGroup (Filter) <#Include Label="IsPermGroup">
The Natural Action The functions , , , and are defined for arbitrary collections of permutations (see ), in particular they can be applied to permutation groups. g:= Group( (2,3,5,6), (2,3) );; gap> MovedPoints( g ); NrMovedPoints( g ); [ 2, 3, 5, 6 ] 4 gap> LargestMovedPoint( g ); SmallestMovedPoint( g ); 6 2 ]]>

The action of a permutation group on the positive integers is a group action (via the acting function ). Therefore all action functions can be applied (see the Chapter ), for example , , , , .

If one has a list of group generators and is interested in the moved points (see above) or orbits, it may be useful to avoid the explicit construction of the group for efficiency reasons. For the special case of the action of permutations on positive integers via ^, the functions and are provided for this purpose.

Similarly, several functions concerning the natural action of permutation groups address stabilizer chains (see ) rather than permutation groups themselves, for example . <#Include Label="OrbitPerms"> <#Include Label="OrbitsPerms">

Computing a Permutation Representation <#Include Label="IsomorphismPermGroup"> <#Include Label="SmallerDegreePermutationRepresentation"> p:=Group((1,2,3,4,5,6),(1,2));;p:=Action(p,AsList(p),OnRight);; gap> Length(MovedPoints(p)); 720 gap> q:=SmallerDegreePermutationRepresentation(p);; gap> NrMovedPoints(Image(q)); 6 ]]>
Symmetric and Alternating Groups The commands and (see Section ) construct symmetric and alternating permutation groups. &GAP; can also detect whether a given permutation group is a symmetric or alternating group on the set of its moved points; if so then the group is called a natural symmetric or alternating group, respectively.

The functions and can be used to check whether a given group (not necessarily a permutation group) is isomorphic to a symmetric or alternating group.

<#Include Label="IsNaturalSymmetricGroup"> <#Include Label="IsSymmetricGroup"> <#Include Label="IsAlternatingGroup"> <#Include Label="SymmetricParentGroup">

Primitive Groups <#Include Label="ONanScottType"> <#Include Label="SocleTypePrimitiveGroup">
Stabilizer Chains Many of the algorithms for permutation groups use a stabilizer chain of the group. The concepts of stabilizer chains, bases, and strong generating sets were introduced by Charles Sims in . A further discussion of base change is given in section .

Let B = [ b_1, \ldots, b_n ] be a list of points, G^{(1)} = G and G^{{(i+1)}} = Stab_{{G^{(i)}}}(b_i), such that G^{(n+1)} = \{ () \}. Then the list [ b_1, \ldots, b_n ] is called a base of G, the points b_i are called base points. A set S of generators for G satisfying the condition \langle S \cap G^{(i)} \rangle = G^{(i)} for each 1 \leq i \leq n, is called a strong generating set (SGS) of G. (More precisely we ought to say that it is a SGS of G relative to B). The chain of subgroups G^{(i)} of G itself is called the stabilizer chain of G relative to B.

Since [ b_1, \ldots, b_n ], where n is the degree of G and b_i are the moved points of G, certainly is a base for G there exists a base for each permutation group. The number of points in a base is called the length of the base. A base B is called reduced if there exists no i such that G^{(i)} = G^{(i+1)}. (This however does not imply that no subset of B could also serve as a base.) Note that different reduced bases for one permutation group G may have different lengths. For example, the irreducible degree 416 permutation representation of the Chevalley Group G_2(4) possesses reduced bases of lengths 5 and 7.

Let R^{(i)} be a right transversal of G^{(i+1)} in G^{(i)}, i.e. a set of right coset representatives of the cosets of G^{(i+1)} in G^{(i)}. Then each element g of G has a unique representation as a product of the form g = r_n \ldots r_1 with r_i \in R^{(i)}. The cosets of G^{(i+1)} in G^{(i)} are in bijective correspondence with the points in O^{(i)} := b_i^{{G^{(i)}}}. So we could represent a transversal as a list T such that T[p] is a representative of the coset corresponding to the point p \in O^{(i)}, i.e., an element of G^{(i)} that takes b_i to p. (Note that such a list has holes in all positions corresponding to points not contained in O^{(i)}.)

This approach however will store many different permutations as coset representatives which can be a problem if the degree n gets bigger. Our goal therefore is to store as few different permutations as possible such that we can still reconstruct each representative in R^{(i)}, and from them the elements in G. A factorized inverse transversal T is a list where T[p] is a generator of G^{(i)} such that p^{{T[p]}} is a point that lies earlier in O^{(i)} than p (note that we consider O^{(i)} as a list, not as a set). If we assume inductively that we know an element r \in G^{(i)} that takes b_i to p^{{T[p]}}, then r T[p]^{{-1}} is an element in G^{(i)} that takes b_i to p. &GAP; uses such factorized inverse transversals.

Another name for a factorized inverse transversal is a Schreier tree. The vertices of the tree are the points in O^{(i)}, and the root of the tree is b_i. The edges are defined as the ordered pairs (p, p^{{T[p]}}), for p \in O^{(i)} \setminus \{ b_i \}. The edge (p, p^{{T[p]}}) is labelled with the generator T[p], and the product of edge labels along the unique path from p to b_i is the inverse of the transversal element carrying b_i to p.

Before we describe the construction of stabilizer chains in , we explain in  the idea of using non-deterministic algorithms; this is necessary for understanding the options available for the construction of stabilizer chains. After that, in  it is explained how a stabilizer chain is stored in &GAP;, lists operations for stabilizer chains, and  lists low level routines for manipulating stabilizer chains.

Randomized Methods for Permutation Groups Schreier-Sims For most computations with permutation groups, it is crucial to construct stabilizer chains efficiently. Sims's original construction in is deterministic, and is called the Schreier-Sims algorithm, because it is based on Schreier's Lemma (): given K = \langle S \rangle and a transversal T for K mod L, one can obtain |S||T| generators for L. This lemma is applied recursively, with consecutive point stabilizers G^{(i)} and G^{(i+1)} playing the role of K and L.

In permutation groups of large degree, the number of Schreier generators to be processed becomes too large, and the deterministic Schreier-Sims algorithm becomes impractical. Therefore, &GAP; uses randomized algorithms. The method selection process, which is quite different from Version 3, works the following way.

If a group acts on not more than a hundred points, Sims's original deterministic algorithm is applied. In groups of degree greater than hundred, a heuristic algorithm based on ideas in constructs a stabilizer chain. This construction is complemented by a verify-routine that either proves the correctness of the stabilizer chain or causes the extension of the chain to a correct one. The user can influence the verification process by setting the value of the record component random (cf. ).

If the random value equals 1000 then a slight extension of an unpublished method of Sims is used. The outcome of this verification process is always correct. The user also can prescribe any integer x, 1 \leq x \leq 999 as the value of random. In this case, a randomized verification process from is applied, and the result of the stabilizer chain construction is guaranteed to be correct with probability at least x/1000. The practical performance of the algorithm is much better than the theoretical guarantee.

If the stabilizer chain is not correct then the elements in the product of transversals R^{(m)} R^{(m-1)} \cdots R^{(1)} constitute a proper subset of the group G in question. This means that a membership test with this stabilizer chain returns false for all elements that are not in G, but it may also return false for some elements of G; in other words, the result true of a membership test is always correct, whereas the result false may be incorrect.

The construction and verification phases are separated because there are situations where the verification step can be omitted; if one happens to know the order of the group in advance then the randomized construction of the stabilizer chain stops as soon as the product of the lengths of the basic orbits of the chain equals the group order, and the chain will be correct (see the size option of the command).

Although the worst case running time is roughly quadratic for Sims's verification and roughly linear for the randomized one, in most examples the running time of the stabilizer chain construction with random value 1000 (i.e., guaranteed correct output) is about the same as the running time of randomized verification with guarantee of at least 90 percent correctness. Therefore, we suggest to use the default value random = 1000. Possible uses of random values less than 1000 are when one has to run through a large collection of subgroups, and a low value of random is used to choose quickly a candidate for more thorough examination; another use is when the user suspects that the quadratic bottleneck of the guaranteed correct verification is hit.

We will give two examples to illustrate these ideas.

h:= SL(4,7);; gap> o:= Orbit( h, [1,0,0,0]*Z(7)^0, OnLines );; gap> op:= Action( h, o, OnLines );; gap> NrMovedPoints( op ); 400 ]]>

We created a permutation group on 400 points. First we compute a guaranteed correct stabilizer chain (see ).

h:= Group( GeneratorsOfGroup( op ) );; gap> StabChain( h );; time; 1120 gap> Size( h ); 2317591180800 ]]>

Now randomized verification will be used. We require that the result is guaranteed correct with probability 90 percent. This means that if we would do this calculation many times over, &GAP; would guarantee that in least 90 percent of all calculations the result is correct. In fact the results are much better than the guarantee, but we cannot promise that this will really happen. (For the meaning of the random component in the second argument of .)

First the group is created anew.

h:= Group( GeneratorsOfGroup( op ) );; gap> StabChain( h, rec( random:= 900 ) );; time; 1410 gap> Size( h ); 2317591180800 ]]>

The result is still correct, and the running time is actually somewhat slower. If you give the algorithm additional information so that it can check its results, things become faster and the result is guaranteed to be correct.

h:=Group( GeneratorsOfGroup( op ) );; gap> SetSize( h, 2317591180800 ); gap> StabChain( h );; time; 170 ]]>

The second example gives a typical group when the verification with random value 1000 is slow. The problem is that the group has a stabilizer subgroup G^{(i)} such that the fundamental orbit O^{(i)} is split into a lot of orbits when we stabilize b_i and one additional point of O^{(i)}.

p1:=PermList(Concatenation([401],[1..400]));; gap> p2:=PermList(List([1..400],i->(i*20 mod 401)));; gap> d:=DirectProduct(Group(p1,p2),SymmetricGroup(5));; gap> h:=Group(GeneratorsOfGroup(d));; gap> StabChain(h);;time;Size(h); 1030 192480 gap> h:=Group(GeneratorsOfGroup(d));; gap> StabChain(h,rec(random:=900));;time;Size(h); 570 192480 ]]>

When stabilizer chains of a group G are created with random value less than 1000, this is noted in the group G, by setting of the record component random in the value of the attribute for G. As errors induced by the random methods might propagate, any group or homomorphism created from G inherits a random component in its value from the corresponding component for G.

A lot of algorithms dealing with permutation groups use randomized methods; however, if the initial stabilizer chain construction for a group is correct, these further methods will provide guaranteed correct output.

Construction of Stabilizer Chains <#Include Label="StabChain"> <#Include Label="StabChainOptions"> <#Include Label="DefaultStabChainOptions"> <#Include Label="StabChainBaseStrongGenerators"> <#Include Label="MinimalStabChain">
Stabilizer Chain Records If a permutation group has a stabilizer chain, this is stored as a recursive structure. This structure is itself a record S and it has (1) components that provide information about one level G^{(i)} of the stabilizer chain (which we call the current stabilizer) and (2) a component stabilizer that holds another such record, namely the stabilizer chain of the next stabilizer G^{(i+1)}.

This gives a recursive structure where the outermost record representing the topmost stabilizer is bound to the group record component stabChain and has the components explained below. Note: Since the structure is recursive, never print a stabilizer chain! (Unless you want to exercise the scrolling capabilities of your terminal.) identity the identity element of the current stabilizer. labels a list of permutations which contains labels for the Schreier tree of the current stabilizer, i.e., it contains elements for the factorized inverse transversal. The first entry in this list is always the identity. Note that &GAP; tries to arrange things so that the labels components are identical (i.e., the same &GAP; object) in every stabilizer of the chain; thus the labels of a stabilizer do not necessarily all lie in the this stabilizer (but see genlabels below). genlabels a list of integers indexing some of the permutations in the labels component. The labels addressed in this way form a generating set for the current stabilizer. If the genlabels component is empty, the rest of the stabilizer chain represents the trivial subgroup, and can be ignored, e.g., when calculating the size. generators a list of generators for the current stabilizer. Usually, it is labels{ genlabels }. orbit the vertices of the Schreier tree, which form the basic orbit b_i^{{G^{(i)}}}, ordered in such a way that the base point b_i is in the first position in the orbit. transversal The factorized inverse transversal found during the orbit algorithm. The element g stored at transversal[i] will map i to another point j that in the Schreier tree is closer to the base point. By iterated application (transversal[j] and so on) eventually the base point is reached and an element that maps i to the base point found as product. translabels An index list such that transversal[j] = labels[ translabels[j] ]. This list takes up comparatively little memory and is used to speed up base changes. stabilizer If the current stabilizer is not yet the trivial group, the stabilizer chain continues with the stabilizer of the current base point, which is again represented as a record with components labels, identity, genlabels, generators, orbit, translabels, transversal (and perhaps stabilizer). This record is bound to the stabilizer component of the current stabilizer. The last member of a stabilizer chain is recognized by the fact that it has no stabilizer component bound. It is possible that different stabilizer chains share the same record as one of their iterated stabilizer components.

g:=Group((1,2,3,4),(1,2));; gap> StabChain(g); gap> BaseOfGroup(g); [ 1, 2, 3 ] gap> StabChainOptions(g); rec( random := 1000 ) gap> DefaultStabChainOptions; rec( random := 1000, reduced := true, tryPcgs := true ) ]]>

Operations for Stabilizer Chains <#Include Label="BaseStabChain"> <#Include Label="BaseOfGroup"> <#Include Label="SizeStabChain"> <#Include Label="StrongGeneratorsStabChain"> <#Include Label="GroupStabChain"> <#Include Label="OrbitStabChain"> <#Include Label="IndicesStabChain"> <#Include Label="ListStabChain"> <#Include Label="ElementsStabChain"> <#Include Label="InverseRepresentative"> <#Include Label="SiftedPermutation"> <#Include Label="MinimalElementCosetStabChain"> <#Include Label="LargestElementStabChain"> <#Include Label="ApproximateSuborbitsStabilizerPermGroup">
Low Level Routines to Modify and Create Stabilizer Chains These operations modify a stabilizer chain or obtain new chains with specific properties. They are rather technical and should only be used if such low-level routines are deliberately required. (For all functions in this section the parameter S is a stabilizer chain.) <#Include Label="CopyStabChain"> <#Include Label="CopyOptionsDefaults"> <#Include Label="ChangeStabChain"> <#Include Label="ExtendStabChain"> <#Include Label="ReduceStabChain"> <#Include Label="RemoveStabChain"> <#Include Label="EmptyStabChain"> <#Include Label="InsertTrivialStabilizer"> <#Include Label="IsFixedStabilizer"> <#Include Label="AddGeneratorsExtendSchreierTree">
Backtrack A main use for stabilizer chains is in backtrack algorithms for permutation groups. &GAP; implements a partition-backtrack algorithm as described in and refined in .

<#Include Label="SubgroupProperty"> <#Include Label="ElementProperty"> <#Include Label="TwoClosure"> <#Include Label="InfoBckt">

Working with large degree permutation groups Permutation groups of large degree (usually at least a few 10000) can pose a challenge to the heuristics used in the algorithms for permutation groups. This section lists a few useful tricks that may speed up calculations with such large groups enormously.

The first aspect concerns solvable groups: A lot of calculations (including an initial stabilizer chain computation thanks to the algorithm from ) are faster if a permutation group is known to be solvable. On the other hand, proving nonsolvability can be expensive for higher degrees. Therefore &GAP; will automatically test a permutation group for solvability, only if the degree is not exceeding 100. (See also the tryPcgs component of .) It is therefore beneficial to tell a group of larger degree, which is known to be solvable, that it is, using SetIsSolvableGroup(G,true).

The second aspect concerns memory usage. A permutation on more than 65536 points requires 4 bytes per point for storing. So permutations on 256000 points require roughly 1MB of storage per permutation. Just storing the permutations required for a stabilizer chain might already go beyond the available memory, in particular if the base is not very short. In such a situation it can be useful, to replace the permutations by straight line program elements (see ).

The following code gives an example of usage: We create a group of degree 231000. Using straight line program elements, one can compute a stabilizer chain in about 200 MB of memory.

Read("largeperms"); # read generators from file gap> gens:=StraightLineProgGens(permutationlist);; gap> g:=Group(gens); gap> # use random algorithm (faster, but result is monte carlo) gap> StabChainOptions(g).random:=1;; gap> Size(g); # enforce computation of a stabilizer chain 3529698298145066075557232833758234188056080273649172207877011796336000 ]]>

Without straight line program elements, the same calculation runs into memory problems after a while even with 512MB of workspace: h:=Group(permutationlist); gap> StabChainOptions(h).random:=1;; gap> Size(h); exceeded the permitted memory (`-o' command line option) at mlimit := 1; called from SCRMakeStabStrong( S.stabilizer, [ g ], param, orbits, where, basesize, base, correct, missing, false ); called from SCRMakeStabStrong( S.stabilizer, [ g ], param, orbits, where, basesize, ... ]]>

The advantage in memory usage however is paid for in runtime: Comparisons of elements become much more expensive. One can avoid some of the related problems by registering a known base with the straight line program elements (see ). In this case element comparison will only compare the images of the given base points. If we are planning to do extensive calculations with the group, it can even be worth to recreate it with straight line program elements knowing a previously computed base:

# get the base we computed already gap> bas:=BaseStabChain(StabChainMutable(g)); [ 1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49, 52, 55, ... 2530, 2533, 2554, 2563, 2569 ] gap> gens:=StraightLineProgGens(permutationlist,bas);; gap> g:=Group(gens);; gap> SetSize(g, > 3529698298145066075557232833758234188056080273649172207877011796336000); gap> Random(g);; # enforce computation of a stabilizer chain ]]>

As we know already base and size, this second stabilizer chain calculation is much faster than the first one and takes less memory.

gap-4r6p5/doc/ref/grpoper.xml0000644000175000017500000003474012172557252014672 0ustar billbill Group Actions group actions A group action is a triple (G, \Omega, \mu), where G is a group, \Omega a set and \mu \colon \Omega \times G \rightarrow \Omega a function that is compatible with the group arithmetic. We call \Omega the domain of the action.

In &GAP;, \Omega can be a duplicate-free collection (an object that permits access to its elements via the \Omega[n] operation, for example a list), it does not need to be sorted (see ).

The acting function \mu is a binary &GAP; function that returns the image \mu( x, g ) for a point x \in \Omega and a group element g \in G.

In &GAP;, groups always act from the right, that is \mu( \mu( x, g ), h ) = \mu( x, gh ).

&GAP; does not test whether the acting function \mu satisfies the conditions for a group operation but silently assumes that is does. (If it does not, results are unpredictable.)

The first section of this chapter, , describes the various ways how operations for group actions can be called.

Functions for several commonly used action are already built into &GAP;. These are listed in section .

The sections and describe homomorphisms and mappings associated to group actions as well as the permutation group image of an action.

The other sections then describe operations to compute orbits, stabilizers, as well as properties of actions.

Finally section  describes the concept of external sets which represent the concept of a G-set and underly the actions mechanism.

About Group Actions group actions The syntax which is used by the operations for group actions is quite flexible. For example we can call the operation for the orbits of the group G on the domain Omega in the following ways:

OrbitsDomain( G, \Omega[, \mu] ) The acting function \mu is optional. If it is not given, the built-in action (which defines an action via the caret operator ^) is used as a default. OrbitsDomain( G, \Omega, gens, acts[, \mu] ) This second version of permits one to implement an action induced by a homomorphism: If the group H acts on \Omega via \mu and \varphi \colon G \rightarrow H is a homomorphism, G acts on \Omega via the induced action \mu'( x, g ) = \mu( x, g^{\varphi} ).

Here gens must be a set of generators of G and acts the images of gens under \varphi. \mu is the acting function for H. Again, the function \mu is optional and is used as a default.

The advantage of this notation is that &GAP; does not need to construct this homomorphism \varphi and the range group H as &GAP; objects. (If a small group G acts via complicated objects acts this otherwise could lead to performance problems.)

&GAP; does not test whether the mapping gens \mapsto acts actually induces a homomorphism and the results are unpredictable if this is not the case. OrbitsDomain( extset ) A third variant is to call the operation with an external set, which then provides G, \Omega and \mu. You will find more about external sets in Section .

For operations like of course the domain must be replaced by an element of the domain of the action.

Basic Actions group actions actions group operations &GAP; already provides acting functions for the more common actions of a group. For built-in operations such as special methods are available for many of these actions.

If one needs an action for which no acting function is provided by the library it can be implemented via a &GAP; function that conforms to the syntax

actfun( omega, g )

where omega is an element of the action domain, g is an element of the acting group, and the return value is the image of omega under g.

For example one could define the following function that acts on pairs of polynomials via :

Note that this function must implement a group action from the right. This is not verified by &GAP; and results are unpredictable otherwise. <#Include Label="OnPoints"> <#Include Label="OnRight"> <#Include Label="OnLeftInverse"> <#Include Label="OnSets"> <#Include Label="OnTuples"> <#Include Label="OnPairs"> <#Include Label="OnSetsSets"> <#Include Label="OnSetsDisjointSets"> <#Include Label="OnSetsTuples"> <#Include Label="OnTuplesSets"> <#Include Label="OnTuplesTuples"> <#Include Label="OnLines"> <#Include Label="OnIndeterminates"> The following example demonstrates being used to implement a permutation action on a domain:

g:=Group((1,2,3),(1,2));; gap> dom:=[ "a", "b", "c" ];; gap> Orbit(g,dom,Permuted); [ [ "a", "b", "c" ], [ "c", "a", "b" ], [ "b", "a", "c" ], [ "b", "c", "a" ], [ "a", "c", "b" ], [ "c", "b", "a" ] ] ]]> <#Include Label="OnSubspacesByCanonicalBasis">

Action on canonical representatives A variety of action functions assumes that the objects on which it acts are given in a particular form, for example canonical representatives. Affected actions are for example , , , , and .

If orbit seeds or domain elements are not given in the required form &GAP; will issue an error message: Orbit(SymmetricGroup(5),[[2,4],[1,3]],OnSetsSets); Error, Action not well-defined. See the manual section ``Action on canonical representatives''. ]]> In this case the affected domain elements have to be brought in canonical form, as documented for the respective action function. For interactive use this is most easily done by acting with the identity element of the group.

(A similar error could arise if a user-defined action function is used which actually does not implement an action from the right.)

Orbits If a group G acts on a set \Omega, the set of all images of x \in \Omega under elements of G is called the orbit of x. The set of orbits of G is a partition of \Omega. <#Include Label="Orbit"> <#Include Label="Orbits"> <#Include Label="OrbitsDomain"> <#Include Label="OrbitLength"> <#Include Label="OrbitLengths"> <#Include Label="OrbitLengthsDomain">
Stabilizers point stabilizerset stabilizer tuple stabilizer The stabilizer of a point x under the action of a group G is the set of all those elements in G which fix x. <#Include Label="OrbitStabilizer"> <#Include Label="Stabilizer"> <#Include Label="OrbitStabilizerAlgorithm">
Elements with Prescribed Images transporter <#Include Label="RepresentativeAction">
The Permutation Image of an Action When a group G acts on a domain \Omega, an enumeration of Omega yields a homomorphism from G into the symmetric group on \{ 1, \ldots, |\Omega| \}. In &GAP;, the enumeration of \Omega is provided by the value of \Omega which of course is \Omega itself if it is a list.

For an action homomorphism, the operation will return the external set on \Omega which affords the action. <#Include Label="ActionHomomorphism"> <#Include Label="Action"> <#Include Label="SparseActionHomomorphism">

Action of a group on itself Of particular importance is the action of a group on its elements or cosets of a subgroup. These actions can be obtained by using for a suitable domain (for example a list of subgroups). For the following (frequently used) types of actions however special (often particularly efficient) functions are provided. A special case is the regular action on all elements. <#Include Label="FactorCosetAction"> <#Include Label="RegularActionHomomorphism"> <#Include Label="AbelianSubfactorAction">
Permutations Induced by Elements and Cycles If only the permutation image of a single element is needed, it might not be worth to create the action homomorphism, the following operations yield the permutation image and cycles of a single element. <#Include Label="Permutation"> <#Include Label="PermutationCycle"> <#Include Label="Cycle"> <#Include Label="CycleLength"> <#Include Label="Cycles"> <#Include Label="CycleLengths"> <#Include Label="CycleIndex">
Tests for Actions <#Include Label="IsTransitive:oprt"> <#Include Label="Transitivity:oprt"> <#Include Label="RankAction"> <#Include Label="IsSemiRegular"> <#Include Label="IsRegular"> <#Include Label="Earns"> <#Include Label="IsPrimitive">
Block Systems A block system (system of imprimitivity) for the action of a group G on an action domain \Omega is a partition of \Omega which –as a partition– remains invariant under the action of G. <#Include Label="Blocks"> <#Include Label="MaximalBlocks"> <#Include Label="RepresentativesMinimalBlocks"> <#Include Label="AllBlocks">
External Sets G-sets When considering group actions, sometimes the concept of a G-set is used. This is a set \Omega endowed with an action of G. The elements of the G-set are the same as those of \Omega, however concepts like equality and equivalence of G-sets do not only consider the underlying domain \Omega but the group action as well.

This concept is implemented in &GAP; via external sets.

The constituents of an external set are stored in the attributes , and .

Most operations for actions are applicable as an attribute for an external set.

The most prominent external subsets are orbits, see .

Many subsets of a group, such as conjugacy classes or cosets (see  and ) are implemented as external orbits.

External sets also are implicitly underlying action homomorphisms, see and . <#Include Label="IsExternalSet"> <#Include Label="ExternalSet"> <#Include Label="ActingDomain"> <#Include Label="FunctionAction"> <#Include Label="HomeEnumerator"> <#Include Label="IsExternalSubset"> <#Include Label="ExternalSubset"> <#Include Label="IsExternalOrbit"> <#Include Label="ExternalOrbit"> <#Include Label="StabilizerOfExternalSet"> <#Include Label="ExternalOrbits"> <#Include Label="ExternalOrbitsStabilizers"> <#Include Label="CanonicalRepresentativeOfExternalSet"> <#Include Label="CanonicalRepresentativeDeterminatorOfExternalSet"> <#Include Label="ActorOfExternalSet"> <#Include Label="UnderlyingExternalSet"> <#Include Label="SurjectiveActionHomomorphismAttr">

gap-4r6p5/doc/ref/matobj.xml0000644000175000017500000000331512172557252014462 0ustar billbill Vector and matrix objects This chapter is work in progress. It will eventually describe the new interface to vector and matrix objects.

Traditionally, vectors in &GAP; have been lists and matrices have been lists of lists (of equal length). Unfortunately, such lists cannot store their type and so it is impossible to use the full advantages of &GAP;'s method selection on them. This situation is unsustainable in the long run since more special representations (compressed, sparse, etc.) have already been and even more will be implemented. To eventually solve this problem, this chapter describes a new programming interface to vectors and matrices.

Fundamental ideas and rules <#Include Label="MatObj_Overview">
Categories of vectors and matrices
Constructing vector and matrix objects
Operations for row vector objects
Operations for row list matrix objects
Operations for flat matrix objects
gap-4r6p5/doc/ref/makedocrel.g0000644000175000017500000000203412172557252014737 0ustar billbill## this creates the documentation, needs: GAPDoc package, latex, pdflatex, ## mkindex, dvips ## Read( "makedocreldata.g" ); SetGapDocLaTeXOptions("nocolor", rec(Maintitlesize := "\\fontsize{36}{38}\\selectfont")); MakeGAPDocDoc( GAPInfo.ManualDataRef.pathtodoc, GAPInfo.ManualDataRef.main, GAPInfo.ManualDataRef.files, GAPInfo.ManualDataRef.bookname, GAPInfo.ManualDataRef.pathtoroot, "MathJax" );; Exec ("mv -f manual.pdf manual-bw.pdf"); SetGapDocLaTeXOptions("color", rec(Maintitlesize := "\\fontsize{36}{38}\\selectfont")); MakeGAPDocDoc( GAPInfo.ManualDataRef.pathtodoc, GAPInfo.ManualDataRef.main, GAPInfo.ManualDataRef.files, GAPInfo.ManualDataRef.bookname, GAPInfo.ManualDataRef.pathtoroot, "MathJax" );; GAPDocManualLabFromSixFile( "ref", "manual.six" );; CopyHTMLStyleFiles("."); ############################################################################# ## #E gap-4r6p5/doc/ref/streams.xml0000644000175000017500000002453612172557252014674 0ustar billbill Streams <#Include Label="[1]{streams}">
Categories for Streams and the StreamsFamily <#Include Label="IsStream"> <#Include Label="IsClosedStream"> <#Include Label="IsInputStream"> <#Include Label="IsInputTextStream"> <#Include Label="IsInputTextNone"> <#Include Label="IsOutputStream"> <#Include Label="IsOutputTextStream"> <#Include Label="IsOutputTextNone"> <#Include Label="StreamsFamily">
Operations applicable to All Streams <#Include Label="CloseStream"> <#Include Label="FileDescriptorOfStream"> makes the UNIX C-library function select accessible from &GAP; for streams. The functionality is as described in the man page (see UNIX file descriptors (integers) for streams. They can be obtained via for streams to local processes and to local files. The argument timeoutsec is a timeout in seconds as in the struct timeval on the C level. The argument timeoutusec is analogously in microseconds. The total timeout is the sum of both. If one of those timeout arguments is not a small integer then no timeout is applicable (fail is allowed for the timeout arguments).

The return value is the number of streams that are ready, this may be 0 if a timeout was specified. All file descriptors in the three lists that are not yet ready are replaced by fail in this function. So the lists are changed!

This function is not available on the Macintosh architecture and is only available if your operating system has select, which is detected during compilation of &GAP;.

Operations for Input Streams Three operations normally used to read files: , and can also be used to read &GAP; input from a stream. The input is immediately parsed and executed. When reading from a stream str, the &GAP; kernel generates calls to ReadLine(str) to supply text to the parser.

Three further operations: , and , support reading characters from an input stream without parsing them. This can be used to read data in any format and process it in &GAP;.

Additional operations for input streams support detection of end of stream, and (for those streams for which it is appropriate) random access to the data.

reads the input-text-stream as input until end-of-stream occurs. See for details. reads the input-text-stream as function and returns this function. See for details. # a function with local `a' does not change the global one gap> a := 1;; gap> i := InputTextString( "local a; a := 10; return a*10;" );; gap> ReadAsFunction(i)(); 100 gap> a; 1 gap> # reading it via `Read' does gap> i := InputTextString( "a := 10;" );; gap> Read(i); gap> a; 10 ]]> reads the input-text-stream as test input until end-of-stream occurs. See for details. <#Include Label="ReadByte"> <#Include Label="ReadLine"> <#Include Label="ReadAll"> <#Include Label="IsEndOfStream"> <#Include Label="PositionStream"> <#Include Label="RewindStream"> <#Include Label="SeekPositionStream">

Operations for Output Streams <#Include Label="WriteByte"> <#Include Label="WriteLine"> <#Include Label="WriteAll"> PrintTo and AppendTo (for streams) These functions work like , except that the output is appended to the output stream output-stream.

str := "";; a := OutputTextString(str,true);; gap> AppendTo( a, (1,2,3), ":", Z(3) ); gap> CloseStream(a); gap> Print( str, "\n" ); (1,2,3):Z(3) ]]> <#Include Label="LogTo"> <#Include Label="InputLogTo"> <#Include Label="OutputLogTo"> <#Include Label="SetPrintFormattingStatus">

File Streams File streams are streams associated with files. An input file stream reads the characters it delivers from a file, an output file stream prints the characters it receives to a file. The following functions can be used to create such streams. They return fail if an error occurred, in this case can be used to get information about the error. <#Include Label="InputTextFile"> <#Include Label="OutputTextFile">
User Streams The commands described in this section create streams which accept characters from, or deliver characters to, the user, via the keyboard or the &GAP; session display. <#Include Label="InputTextUser"> <#Include Label="OutputTextUser"> <#Include Label="InputFromUser">
String Streams String streams are streams associated with strings. An input string stream reads the characters it delivers from a string, an output string stream appends the characters it receives to a string. The following functions can be used to create such streams. <#Include Label="InputTextString"> <#Include Label="OutputTextString">
Input-Output Streams <#Include Label="[2]{streams}"> <#Include Label="IsInputOutputStream"> <#Include Label="InputOutputLocalProcess"> <#Include Label="ReadAllLine">
Dummy Streams The following two commands create dummy streams which will consume all characters and never deliver one. <#Include Label="InputTextNone"> <#Include Label="OutputTextNone">
Handling of Streams in the Background This section describes a feature of the &GAP; kernel that can be used to handle pending streams somehow in the background. This is currently not available on the Macintosh architecture and only on operating systems that have select.

Right before &GAP; reads a keypress from the keyboard it calls a little subroutine that can handle streams that are ready to be read or ready to be written. This means that &GAP; can handle these streams during user input on the command line. Note that this does not work when &GAP; is in the middle of some calculation.

This feature is used in the following way. One can install handler functions for reading or writing streams via . Handlers can be removed via

Note that handler functions must not return anything and get one integer argument, which refers to an index in one of the following arrays (according to whether the function was installed for input, output or exceptions on the stream). Handler functions usually should not output anything on the standard output because this ruins the command line during command line editing. <#Include Label="InstallCharReadHookFunc"> <#Include Label="UnInstallCharReadHookFunc">

Comma separated files Spreadsheet Excel In some situations it can be desirable to process data given in the form of a spreadsheet (such as Excel). &GAP; can do this using the CSV (comma separated values) format, which spreadsheet programs can usually read in or write out.

The first line of the spreadsheet is used as labels of record components, each subsequent line then corresponds to a record. Entries enclosed in double quotes are considered as strings and are permitted to contain the separation character (usually a comma). <#Include Label="ReadCSV"> <#Include Label="PrintCSV">

gap-4r6p5/doc/ref/gptransv.xml0000644000175000017500000000637312172557252015061 0ustar billbill Transversals of subgroups (preliminary) <#Include Label="[1]{gptransv}">

The functions and operations described in this chapter have been added very recently and are still undergoing development. It is conceivable that names of variants of the functionality might change in future versions. If you plan to use these functions in your own code, please contact us.

General operations on transversals <#Include Label="[2]{gptransv}">

<#Include Label="TransversalElt"> <#Include Label="SiftOneLevel">[gptransv]!{for subgroup transversals}

Transversals by Schreier tree <#Include Label="[3]{gptransv}">

<#Include Label="SchreierTransversal"> <#Include Label="OrbitGenerators"> <#Include Label="OrbitGeneratorsInv"> <#Include Label="BasePointOfSchreierTransversal"> <#Include Label="One"> <#Include Label="ExtendSchreierTransversal"> <#Include Label="ExtendSchreierTransversalShortCube"> <#Include Label="ExtendSchreierTransversalShortTree"> <#Include Label="CompleteSchreierTransversal"> <#Include Label="PreferredGenerators"> <#Include Label="SchreierTreeDepth">

Transversals by homomorphic images <#Include Label="[4]{gptransv}">

<#Include Label="HomTransversal"> <#Include Label="Homomorphism">[gptransv]!{for subgroup transversals} <#Include Label="QuotientGroup"> <#Include Label="ImageGroup">

Transversals by direct products <#Include Label="[5]{gptransv}">

<#Include Label="Projection"> <#Include Label="Injection">

Transversals by Trivial subgroups <#Include Label="[6]{gptransv}">

<#Include Label="TransversalByTrivial">

Transversals by sift functions <#Include Label="[7]{gptransv}">

<#Include Label="TransversalBySiftFunction">

gap-4r6p5/doc/ref/preface.xml0000644000175000017500000001434512172557252014620 0ustar billbill Preface About &GAP; manual Welcome to &GAP;. This is one of three manuals documenting the core part of &GAP;, the other being the &GAP; Tutorial (see ). and the document called &GAP; - Changes from Earlier Versions (see ).

This preface serves not only to introduce The &GAP; Reference Manual, but also as an introduction to the whole system.

&GAP; stands for Groups, Algorithms and Programming. The name was chosen to reflect the aim of the system, which is introduced in this reference manual. Since that choice, the system has become somewhat broader, and you will also find information about algorithms and programming for other algebraic structures, such as semigroups and algebras.

This manual, the &GAP; reference manual contains the official definitions of &GAP; functions. It should contain all the information needed to use &GAP;, and is not intended to be read cover-to-cover.

To get started a new user may first look at parts of the &GAP; Tutorial (see ).

A lot of the functionality of the system and a number of contributed extensions are provided as &GAP; packages which are developed independently of the core part of &GAP; and can be loaded into a &GAP; session. Each package comes with a its own manual which is also available through the &GAP; help system.

This manual is divided into chapters, sections and subsections. Chapter  describes the help system, which provides access to all the manuals from a running &GAP; session. Chapter  gives technical advice for running &GAP;. Chapter  introduces the &GAP; language, and the next chapters deal with the environment provided by &GAP; for the user. These are followed by the main bulk of chapters which are devoted to the various mathematical structures that &GAP; can handle.

Subsequent sections of this preface explain the structure of the system and provide copyright and licensing information.

The &GAP; System <#Include SYSTEM "../ref/overview.xml">
Authors and Maintainers &GAP; is the work of very many people, many of whom still maintain parts of the system. A complete list of authors, and an approximation to the current list of maintainers can be found on the &GAP; World Wide Web site at http://www.gap-system.org/Contacts/People/authors.html and http://www.gap-system.org/Contacts/People/modules.html. All &GAP; packages have their own authors and maintainers. It should however be noted that some packages provide interfaces between &GAP; and an external program, a copy of which is included for convenience, and that, in these cases, we do not claim that the package authors or maintainers wrote, or maintain, this external program. Similarly, the system and some packages include large data libraries that may have been computed by many people. We try to make clear in each case what credit is attributable to whom.

We have, for some time, operated a refereeing system for contributed packages, both to ensure the quality of the software we distribute, and to provide recognition for the authors. We now consider this to be a refereeing system for modules, and we would note, in particular that, although it does not use the standard package interface, the library of small groups has been refereed and accepted on exactly the same basis as the accepted packages.

We also include with this distribution a number of packages which have not (yet) gone through our refereeing process. Some may be accepted in the future, in other cases the authors have chosen not to submit them. More information can be found on our World Wide Web site (see Section ).

Acknowledgements Very many people have worked on, and contributed to, &GAP; over the years since its inception. On our Web site you will find the prefaces to the previous releases, each of which acknowledges people who have made special contributions to that release. Even so, it is appropriate to mention here Joachim Neubüser whose vision of a free, open and extensible system for computational algebra inspired &GAP; in the first place, and Martin Schönert, who was the technical architect of &GAP; 3 and &GAP; 4.

Copyright and License <#Include SYSTEM "../ref/copyrigh.xml">
Further Information about &GAP; web sites email addresses support <#Include SYSTEM "../ref/moreinfo.xml">
gap-4r6p5/doc/ref/word.xml0000644000175000017500000000356212172557252014165 0ustar billbill Words <#Include Label="[1]{word}">
Categories of Words and Nonassociative Words <#Include Label="IsWord"> <#Include Label="IsWordCollection"> <#Include Label="IsNonassocWord"> <#Include Label="IsNonassocWordCollection">
Comparison of Words <#Include Label="[2]{word}">
Operations for Words <#Include Label="[3]{word}"> <#Include Label="MappedWord">
Free Magmas <#Include Label="[4]{word}"> <#Include Label="FreeMagma"> <#Include Label="FreeMagmaWithOne">
External Representation for Nonassociative Words <#Include Label="[5]{word}">
gap-4r6p5/doc/ref/language.xml0000644000175000017500000023452212172557252014777 0ustar billbill The Programming Language This chapter describes the &GAP; programming language. It should allow you in principle to predict the result of each and every input. In order to know what we are talking about, we first have to look more closely at the process of interpretation and the various representations of data involved.
Language Overview First we have the input to &GAP;, given as a string of characters. How those characters enter &GAP; is operating system dependent, e.g., they might be entered at a terminal, pasted with a mouse into a window, or read from a file. The mechanism does not matter. This representation of expressions by characters is called the external representation of the expression. Every expression has at least one external representation that can be entered to get exactly this expression.

The input, i.e., the external representation, is transformed in a process called reading to an internal representation. At this point the input is analyzed and inputs that are not legal external representations, according to the rules given below, are rejected as errors. Those rules are usually called the syntax of a programming language.

The internal representation created by reading is called either an expression or a statement. Later we will distinguish between those two terms. However for now we will use them interchangeably. The exact form of the internal representation does not matter. It could be a string of characters equal to the external representation, in which case the reading would only need to check for errors. It could be a series of machine instructions for the processor on which &GAP; is running, in which case the reading would more appropriately be called compilation. It is in fact a tree-like structure.

After the input has been read it is again transformed in a process called evaluation or execution. Later we will distinguish between those two terms too, but for the moment we will use them interchangeably. The name hints at the nature of this process, it replaces an expression with the value of the expression. This works recursively, i.e., to evaluate an expression first the subexpressions are evaluated and then the value of the expression is computed from those values according to rules given below. Those rules are usually called the semantics of a programming language.

The result of the evaluation is, not surprisingly, called a value. Again the form in which such a value is represented internally does not matter. It is in fact a tree-like structure again.

The last process is called printing. It takes the value produced by the evaluation and creates an external representation, i.e., a string of characters again. What you do with this external representation is up to you. You can look at it, paste it with the mouse into another window, or write it to a file.

Lets look at an example to make this more clear. Suppose you type in the following string of 8 characters

&GAP; takes this external representation and creates a tree-like internal representation, which we can picture as follows

This expression is then evaluated. To do this &GAP; first evaluates the right subexpression 2*3. Again, to do this &GAP; first evaluates its subexpressions 2 and 3. However they are so simple that they are their own value, we say that they are self-evaluating. After this has been done, the rule for * tells us that the value is the product of the values of the two subexpressions, which in this case is clearly 6. Combining this with the value of the left operand of the +, which is self-evaluating, too, gives us the value of the whole expression 7. This is then printed, i.e., converted into the external representation consisting of the single character 7.

In this fashion we can predict the result of every input when we know the syntactic rules that govern the process of reading and the semantic rules that tell us for every expression how its value is computed in terms of the values of the subexpressions. The syntactic rules are given in sections , , , , and , the semantic rules are given in sections , , , , , , , , , , , , , and the chapters describing the individual data types.

Lexical Structure Most input of &GAP; consists of sequences of the following characters.

Digits, uppercase and lowercase letters, Space, Tab, Newline, Return and the special characters

~ [ \ ] ^ _ { } ! ]]>

It is possible to use other characters in identifiers by escaping them with backslashes, but we do not recommend to use this feature. Inside strings (see section  and chapter ) and comments (see ) the full character set supported by the computer is allowed.

Symbols The process of reading, i.e., of assembling the input into expressions, has a subprocess, called scanning, that assembles the characters into symbols. A symbol is a sequence of characters that form a lexical unit. The set of symbols consists of keywords, identifiers, strings, integers, and operator and delimiter symbols.

A keyword is a reserved word (see ). An identifier is a sequence of letters, digits and underscores (or other characters escaped by backslashes) that contains at least one non-digit and is not a keyword (see ). An integer is a sequence of digits (see ), possibly prepended by - and + sign characters. A string is a sequence of arbitrary characters enclosed in double quotes (see ).

Operator and delimiter symbols are

< <= > >= ![ := . .. -> , ; !{ [ ] { } ( ) : ]]>

Note also that during the process of scanning all whitespace is removed (see ).

Whitespaces space blanktabulatornewline comments The characters Space, Tab, Newline, and Return are called whitespace characters. Whitespace is used as necessary to separate lexical symbols, such as integers, identifiers, or keywords. For example Thorondor is a single identifier, while Th or ondor is the keyword or between the two identifiers Th and ondor. Whitespace may occur between any two symbols, but not within a symbol. Two or more adjacent whitespace characters are equivalent to a single whitespace. Apart from the role as separator of symbols, whitespace characters are otherwise insignificant. Whitespace characters may also occur inside a string, where they are significant. Whitespace characters should also be used freely for improved readability.

A comment starts with the character #, which is sometimes called sharp or hatch, and continues to the end of the line on which the comment character appears. The whole comment, including # and the Newline character is treated as a single whitespace. Inside a string, the comment character # loses its role and is just an ordinary character.

For example, the following statement

is equivalent to

(which by the way shows that it is possible to write superfluous comments). However the first statement is not equivalent to

since the keyword if must be separated from the identifier i by a whitespace, and similarly then and a, and else and a must be separated.

Keywords GAPInfo.Keywords Keywords are reserved words that are used to denote special operations or are part of statements. They must not be used as identifiers. The list of keywords is contained in the GAPInfo.Keywords component of the GAPInfo record (see ). We will show how to print it in a nice table, demonstrating at the same time some list manipulation techniques:

keys:=SortedList( GAPInfo.Keywords );; l:=Length( keys );; gap> arr:= List( [ 0 .. Int( l/4 )-1 ], i-> keys{ 4*i + [ 1 .. 4 ] } );; gap> if l mod 4 <> 0 then Add( arr, keys{[ 4*Int(l/4) + 1 .. l ]} ); fi; gap> Length( keys ); PrintArray( arr ); 32 [ [ Assert, Info, IsBound, QUIT ], [ TryNextMethod, Unbind, and, break ], [ continue, do, elif, else ], [ end, false, fi, for ], [ function, if, in, local ], [ mod, not, od, or ], [ quit, rec, repeat, return ], [ then, true, until, while ] ] ]]>

Note that (almost) all keywords are written in lowercase and that they are case sensitive. For example else is a keyword; Else, eLsE, ELSE and so forth are ordinary identifiers. Keywords must not contain whitespace, for example el if is not the same as elif.

Note: Several tokens from the list of keywords above may appear to be normal identifiers representing functions or literals of various kinds but are actually implemented as keywords for technical reasons. The only consequence of this is that those identifiers cannot be re-assigned, and do not actually have function objects bound to them, which could be assigned to other variables or passed to functions. These keywords are true, false, , , , and .

Identifiers An identifier is used to refer to a variable (see ). An identifier usually consists of letters, digits, underscores _, and at-characters @, and must contain at least one non-digit. An identifier is terminated by the first character not in this class. Note that the at-character @ is used to implement namespaces, see Section for details.

Examples of valid identifiers are

Note that case is significant, so the three identifiers in the second line are distinguished.

The backslash \ can be used to include other characters in identifiers; a backslash followed by a character is equivalent to the character, except that this escape sequence is considered to be an ordinary letter. For example

is an identifier, not a call to a function G.

An identifier that starts with a backslash is never a keyword, so for example \* and \mod are identifiers.

The length of identifiers is not limited, however only the first 1023 characters are significant. The escape sequence \newline is ignored, making it possible to split long identifiers over multiple lines. <#Include Label="IsValidIdentifier"> Note that the at-character is used to implement namespaces for global variables in packages. See for details. namespace

Expressions evaluation An expression is a construct that evaluates to a value. Syntactic constructs that are executed to produce a side effect and return no value are called statements (see ). Expressions appear as right hand sides of assignments (see ), as actual arguments in function calls (see ), and in statements.

Note that an expression is not the same as a value. For example 1 + 11 is an expression, whose value is the integer 12. The external representation of this integer is the character sequence 12, i.e., this sequence is output if the integer is printed. This sequence is another expression whose value is the integer 12. The process of finding the value of an expression is done by the interpreter and is called the evaluation of the expression.

Variables, function calls, and integer, permutation, string, function, list, and record literals (see , , , , , , , ), are the simplest cases of expressions.

Expressions, for example the simple expressions mentioned above, can be combined with the operators to form more complex expressions. Of course those expressions can then be combined further with the operators to form even more complex expressions. The operators fall into three classes. operators The comparisons are =, <>, <, <=, >, >=, and in (see and ). The arithmetic operators are +, -, *, /, mod, and ^ (see ). The logical operators are not, and, and or (see ).

The following example shows a very simple expression with value 4 and a more complex expression.

2 * 2; 4 gap> 2 * 2 + 9 = Fibonacci(7) and Fibonacci(13) in Primes; true ]]>

For the precedence of operators, see .

Variables scopebound A variable is a location in a &GAP; program that points to a value. We say the variable is bound to this value. If a variable is evaluated it evaluates to this value.

Initially an ordinary variable is not bound to any value. The variable can be bound to a value by assigning this value to the variable (see ). Because of this we sometimes say that a variable that is not bound to any value has no assigned value. Assignment is in fact the only way by which a variable, which is not an argument of a function, can be bound to a value. After a variable has been bound to a value an assignment can also be used to bind the variable to another value.

A special class of variables is the class of arguments of functions. They behave similarly to other variables, except they are bound to the value of the actual arguments upon a function call (see ).

Each variable has a name that is also called its identifier. This is because in a given scope an identifier identifies a unique variable (see ). A scope is a lexical part of a program text. There is the global scope that encloses the entire program text, and there are local scopes that range from the function keyword, denoting the beginning of a function definition, to the corresponding end keyword. A local scope introduces new variables, whose identifiers are given in the formal argument list and the local declaration of the function (see ). Usage of an identifier in a program text refers to the variable in the innermost scope that has this identifier as its name. Because this mapping from identifiers to variables is done when the program is read, not when it is executed, &GAP; is said to have lexical scoping. The following example shows how one identifier refers to different variables at different points in the program text.

It is important to note that the concept of a variable in &GAP; is quite different from the concept of a variable in most compiled programming languages.

In those languages a variable denotes a block of memory. The value of the variable is stored in this block. So in those languages two variables can have the same value, but they can never have identical values, because they denote different blocks of memory. Note that some languages have the concept of a reference argument. It seems as if such an argument and the variable used in the actual function call have the same value, since changing the argument's value also changes the value of the variable used in the actual function call. But this is not so; the reference argument is actually a pointer to the variable used in the actual function call, and it is the compiler that inserts enough magic to make the pointer invisible. In order for this to work the compiler needs enough information to compute the amount of memory needed for each variable in a program, which is readily available in the declarations.

In &GAP; on the other hand each variable just points to a value, and different variables can share the same value. returns true if the variable ident points to a value, and false otherwise.

For records and lists can be used to check whether components or entries, respectively, are bound (see Chapters  and ). deletes the identifier ident. If there is no other variable pointing to the same value as ident was, this value will be removed by the next garbage collection. Therefore can be used to get rid of unwanted large objects.

For records and lists can be used to delete components or entries, respectively (see Chapters  and ).

More About Global Variables The vast majority of variables in &GAP; are defined at the outer level (the global scope). They are used to access functions and other objects created either in the &GAP; library or packages or in the user's code.

Note that for packages there is a mechanism to implement package local namespaces on top of this global namespace. See Section for details. namespace

Certain special facilities are provided for manipulating global variables which are not available for other types of variable (such as local variables or function arguments).

First, such variables may be marked read-only. In which case attempts to change them will fail. Most of the global variables defined in the &GAP; library are so marked.

Second, a group of functions are supplied for accessing and altering the values assigned to global variables. Use of these functions differs from the use of assignment, and statements, in two ways. First, these functions always affect global variables, even if local variables of the same names exist. Second, the variable names are passed as strings, rather than being written directly into the statements.

Note that the functions , , , and deal with the global namespace. returns true if the global variable named by the string name is read-only and false otherwise (the default). marks the global variable named by the string name as read-only.

A warning is given if name has no value bound to it or if it is already read-only. marks the global variable named by the string name as read-write.

A warning is given if name is already read-write.

xx := 17; 17 gap> IsReadOnlyGlobal("xx"); false gap> xx := 15; 15 gap> MakeReadOnlyGlobal("xx"); gap> xx := 16; Variable: 'xx' is read only not in any function Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can 'return;' after making it writable to continue brk> quit; gap> IsReadOnlyGlobal("xx"); true gap> MakeReadWriteGlobal("xx"); gap> xx := 16; 16 gap> IsReadOnlyGlobal("xx"); false ]]> returns the value currently bound to the global variable named by the string name. An error is raised if no value is currently bound. returns true if a value currently bound to the global variable named by the string name and false otherwise. removes any value currently bound to the global variable named by the string name. Nothing is returned.

A warning is given if name was not bound. The global variable named by name must be writable, otherwise an error is raised. <#Include Label="BindGlobal"> This function returns an immutable (see ) sorted (see ) list of all the global variable names known to the system. This includes names of variables which were bound but have now been unbound and some other names which have never been bound but have become known to the system by various routes. This function returns an immutable sorted list of all the global variable names created by the &GAP; library when &GAP; was started. This function returns an immutable sorted list of the global variable names created since the library was read, to which a value is currently bound. returns a string that can be used as the name of a global variable that is not bound at the time when is called. The optional argument prefix can specify a string with which the name of the global variable starts.

Namespaces for &GAP; packages As mentioned in Section above all global variables share a common namespace. This can relatively easily lead to name clashes, in particular when many &GAP; packages are loaded at the same time. To give package code a way to have a package local namespace without breaking backward compatibility of the &GAP; language, the following simple rule has been devised:

If in package code a global variable that ends with an at-character @ is accessed in any way, the name of the package is appended before accessing it. Here, package code refers to everything which is read with . As the name of the package the entry PackageName in its PackageInfo.g file is taken. As for all identifiers, this name is case sensitive.

For example, if the following is done in the code of a package with name xYz: a@ := 12; ]]> Then actually the global variable a@xYz is assigned. Further accesses to a@ within the package code will all be redirected to a@xYz. This includes all the functions described in Section and indeed all the functions described Section like for example . Note that from code in the same package it is still possible to access the same global variable via a@xYz explicitly.

All other code outside the package as well as interactive user input that wants to refer to that variable a@xYz must do so explicitly by using a@xYz.

Since in earlier releases of &GAP; the at-character @ was not a legal character (without using backslashes), this small extension of the language does not break any old code.

Function Calls Function Call With Arguments function-var( [arg-expr[, arg-expr, ...]] )

The function call has the effect of calling the function function-var. The precise semantics are as follows.

First &GAP; evaluates the function-var. Usually function-var is a variable, and &GAP; does nothing more than taking the value of this variable. It is allowed though that function-var is a more complex expression, such as a reference to an element of a list (see Chapter ) list-var[int-expr], or to a component of a record (see Chapter ) record-var.ident. In any case &GAP; tests whether the value is a function. If it is not, &GAP; signals an error.

functions arg Next &GAP; checks that the number of actual arguments arg-exprs agrees with the number of formal arguments as given in the function definition. If they do not agree &GAP; signals an error. An exception is the case when there is exactly one formal argument with the name arg, in which case any number of actual arguments is allowed (see  for examples).

Now &GAP; allocates for each formal argument and for each formal local (that is, the identifiers in the local declaration) a new variable. Remember that a variable is a location in a &GAP; program that points to a value. Thus for each formal argument and for each formal local such a location is allocated.

Next the arguments arg-exprs are evaluated, and the values are assigned to the newly created variables corresponding to the formal arguments. Of course the first value is assigned to the new variable corresponding to the first formal argument, the second value is assigned to the new variable corresponding to the second formal argument, and so on. However, &GAP; does not make any guarantee about the order in which the arguments are evaluated. They might be evaluated left to right, right to left, or in any other order, but each argument is evaluated once. An exception again occurs if the function has only one formal argument with the name arg. In this case the values of all the actual arguments are stored in a list and this list is assigned to the new variable corresponding to the formal argument arg.

The new variables corresponding to the formal locals are initially not bound to any value. So trying to evaluate those variables before something has been assigned to them will signal an error.

Now the body of the function, which is a statement, is executed. If the identifier of one of the formal arguments or formal locals appears in the body of the function it refers to the new variable that was allocated for this formal argument or formal local, and evaluates to the value of this variable.

If during the execution of the body of the function a return statement with an expression (see ) is executed, execution of the body is terminated and the value of the function call is the value of the expression of the return. If during the execution of the body a return statement without an expression is executed, execution of the body is terminated and the function call does not produce a value, in which case we call this call a procedure call (see ). If the execution of the body completes without execution of a return statement, the function call again produces no value, and again we talk about a procedure call.

Fibonacci( 11 ); 89 ]]>

The above example shows a call to the function with actual argument 11, the following one shows a call to the operation where the second actual argument is another function call.

RightCosets( G, Intersection( U, V ) );; ]]> Function Call With Options function-var( arg-expr[, arg-expr, ...][ : [ option-expr [,option-expr, ....]]])

As well as passing arguments to a function, providing the mathematical input to its calculation, it is sometimes useful to supply hints suggesting to &GAP; how the desired result may be computed more quickly, or specifying a level of tolerance for random errors in a Monte Carlo algorithm.

Such hints may be supplied to a function-call and to all subsidiary functions called from that call using the options mechanism. Options are separated from the actual arguments by a colon : and have much the same syntax as the components of a record expression. The one exception to this is that a component name may appear without a value, in which case the value true is silently inserted.

The following example shows a call to passing the options hard (with the value true) and tcselection (with the string "external" as value).

Size( fpgrp : hard, tcselection := "external" ); ]]>

Options supplied with function calls in this way are passed down using the global options stack described in chapter , so that the call above is exactly equivalent to

PushOptions( rec( hard := true, tcselection := "external") ); gap> Size( fpgrp ); gap> PopOptions( ); ]]>

Note that any option may be passed with any function, whether or not it has any actual meaning for that function, or any function called by it. The system provides no safeguard against misspelled option names.

Comparisons equality test left-expr = right-expr

inequality test left-expr <> right-expr

The operator = tests for equality of its two operands and evaluates to true if they are equal and to false otherwise. Likewise <> tests for inequality of its two operands. For each type of objects the definition of equality is given in the respective chapter. Objects in different families (see ) are never equal, i.e., = evaluates in this case to false, and <> evaluates to true.

smaller test left-expr < right-expr

larger test left-expr > right-expr

smaller or equal left-expr <= right-expr

larger or equal left-expr >= right-expr

< denotes less than, <= less than or equal, > greater than, and >= greater than or equal of its two operands. For each kind of objects the definition of the ordering is given in the respective chapter.

Note that < implements a total ordering of objects (which can be used for example to sort a list of elements). Therefore in general < will not be compatible with any inclusion relation (which can be tested using ). (For example, it is possible to compare permutation groups with < in a total ordering of all permutation groups, but this ordering is not compatible with the relation of being a subgroup.)

<#Include Label="[1]{object.gi}">

Comparison operators, including the operator in (see ), are not associative, Hence it is not allowed to write a = b <> c = d, you must use (a = b) <> (c = d) instead. The comparison operators have higher precedence than the logical operators operators (see ), but lower precedence than the arithmetic operators (see ). Thus, for instance, a * b = c and d is interpreted as ((a * b) = c) and d).

The following example shows a comparison where the left operand is an expression.

2 * 2 + 9 = Fibonacci(7); true ]]>

For the underlying operations of the operators introduced above, see .

Arithmetic Operators precedence associativity operators + - * / ^ mod modulo modulo positive number + right-expr

negative number - right-expr

addition left-expr + right-expr

subtraction left-expr - right-expr

multiplication left-expr * right-expr

division left-expr / right-expr

mod left-expr mod right-expr

power left-expr ^ right-expr

The arithmetic operators are +, -, *, /, mod, and ^. The meanings (semantics) of those operators generally depend on the types of the operands involved, and they are defined in the various chapters describing the types. However basically the meanings are as follows.

a + b denotes the addition of additive elements a and b.

a - b denotes the addition of a and the additive inverse of b.

a * b denotes the multiplication of multiplicative elements a and b.

a / b denotes the multiplication of a with the multiplicative inverse of b.

mod a mod b, for integer or rational left operand a and for non-zero integer right operand b, is defined as follows. If a and b are both integers, a mod b is the integer r in the integer range 0 .. |b| - 1 satisfying a = r + bq, for some integer q (where the operations occurring have their usual meaning over the integers, of course).

modular remaindermodular inverse coprimerelatively prime If a is a rational number and b is a non-zero integer, and a = m / n where m and n are coprime integers with n positive, then a mod b is the integer r in the integer range 0 .. |b| - 1 such that m is congruent to rn modulo b, and r is called the modular remainder of a modulo b. Also, 1 / n mod b is called the modular inverse of n modulo b. (A pair of integers is said to be coprime (or relatively prime) if their greatest common divisor is 1.)

With the above definition, 4 / 6 mod 32 equals 2 / 3 mod 32 and hence exists (and is equal to 22), despite the fact that 6 has no inverse modulo 32.

Note: For rational a, a mod b could have been defined to be the non-negative rational c less than |b| such that a - c is a multiple of b. However this definition is seldom useful and not the one chosen for &GAP;.

+ and - can also be used as unary operations. The unary + is ignored. The unary - returns the additive inverse of its operand; over the integers it is equivalent to multiplication by -1.

^ denotes powering of a multiplicative element if the right operand is an integer, and is also used to denote the action of a group element on a point of a set if the right operand is a group element.

arithmetic operators The precedence of those operators is as follows. The powering operator ^ has the highest precedence, followed by the unary operators + and -, which are followed by the multiplicative operators *, /, and mod, and the additive binary operators + and - have the lowest precedence. That means that the expression -2 ^ -2 * 3 + 1 is interpreted as (-(2 ^ (-2)) * 3) + 1. If in doubt use parentheses to clarify your intention.

operators The associativity of the arithmetic operators is as follows. ^ is not associative, i.e., it is invalid to write 2^3^4, use parentheses to clarify whether you mean (2^3)^4 or 2^(3^4). The unary operators + and - are right associative, because they are written to the left of their operands. *, /, mod, +, and - are all left associative, i.e., 1-2-3 is interpreted as (1-2)-3 not as 1-(2-3). Again, if in doubt use parentheses to clarify your intentions.

The arithmetic operators have higher precedence than the comparison operators (see  and ) and the logical operators (see ). Thus, for example, a * b = c and d is interpreted, ((a * b) = c) and d.

2 * 2 + 9; # a very simple arithmetic expression 13 ]]>

For other arithmetic operations, and for the underlying operations of the operators introduced above, see .

Statements execution Assignments (see ), Procedure calls (see ), if statements (see ), while (see ), repeat (see ) and for loops (see ), and the return statement (see ) are called statements. They can be entered interactively or be part of a function definition. Every statement must be terminated by a semicolon.

Statements, unlike expressions, have no value. They are executed only to produce an effect. For example an assignment has the effect of assigning a value to a variable, a for loop has the effect of executing a statement sequence for all elements in a list and so on. We will talk about evaluation of expressions but about execution of statements to emphasize this difference.

Using expressions as statements is treated as syntax error.

i := 7;; gap> if i <> 0 then k = 16/i; fi; Syntax error: := expected if i <> 0 then k = 16/i; fi; ^ gap> ]]>

As you can see from the example this warning does in particular address those users who are used to languages where = instead of := denotes assignment.

Empty statements are permitted and have no effect.

A sequence of one or more statements is a statement sequence, and may occur everywhere instead of a single statement. Each construct is terminated by a keyword. The simplest statement sequence is a single semicolon, which can be used as an empty statement sequence. In fact an empty statement sequence as in for i in [ 1 .. 2 ] do od is also permitted and is silently translated into the sequence containing just a semicolon.

Assignments assignment var := expr;

The assignment has the effect of assigning the value of the expressions expr to the variable var.

The variable var may be an ordinary variable (see ), a list element selection list-var[int-expr] (see ) or a record component selection record-var.ident (see ). Since a list element or a record component may itself be a list or a record the left hand side of an assignment may be arbitrarily complex.

Note that variables do not have a type. Thus any value may be assigned to any variable. For example a variable with an integer value may be assigned a permutation or a list or anything else.

data:= rec( numbers:= [ 1, 2, 3 ] ); rec( numbers := [ 1, 2, 3 ] ) gap> data.string:= "string";; data; rec( numbers := [ 1, 2, 3 ], string := "string" ) gap> data.numbers[2]:= 4;; data; rec( numbers := [ 1, 4, 3 ], string := "string" ) ]]>

If the expression expr is a function call then this function must return a value. If the function does not return a value an error is signalled and you enter a break loop (see ). As usual you can leave the break loop with quit;. If you enter return return-expr; the value of the expression return-expr is assigned to the variable, and execution continues after the assignment.

f1:= function( x ) Print( "value: ", x, "\n" ); end;; gap> f2:= function( x ) return f1( x ); end;; gap> f2( 4 ); value: 4 Function Calls: must return a value at return f1( x ); called from ( ) called from read-eval-loop Entering break read-eval-print loop ... you can 'quit;' to quit to outer loop, or you can supply one by 'return ;' to continue brk> return "hello"; "hello" ]]>

In the above example, the function f2 calls f1 with argument 4, and since f1 does not return a value (but only prints a line value: ...), the return statement of f2 cannot be executed. The error message says that it is possible to return an appropriate value, and the returned string "hello" is used by f2 instead of the missing return value of f1.

Procedure Calls procedure call procedure call with arguments procedure-var( [arg-expr [,arg-expr, ...]] );

The procedure call has the effect of calling the procedure procedure-var. A procedure call is done exactly like a function call (see ). The distinction between functions and procedures is only for the sake of the discussion, &GAP; does not distinguish between them. So we state the following conventions.

A function does return a value but does not produce a side effect. As a convention the name of a function is a noun, denoting what the function returns, e.g., "Length", "Concatenation" and "Order".

A procedure is a function that does not return a value but produces some effect. Procedures are called only for this effect. As a convention the name of a procedure is a verb, denoting what the procedure does, e.g., "Print", "Append" and "Sort".

Read( "myfile.g" ); # a call to the procedure Read gap> l := [ 1, 2 ];; gap> Append( l, [3,4,5] ); # a call to the procedure Append ]]>

There are a few exceptions of &GAP; functions that do both return a value and produce some effect. An example is which sorts a list and returns the corresponding permutation of the entries.

If fi then else elif if bool-expr1 then statements1 { elif bool-expr2 then statements2 }[ else statements3 ] fi; if statement

The if statement allows one to execute statements depending on the value of some boolean expression. The execution is done as follows.

First the expression bool-expr1 following the if is evaluated. If it evaluates to true the statement sequence statements1 after the first then is executed, and the execution of the if statement is complete.

Otherwise the expressions bool-expr2 following the elif are evaluated in turn. There may be any number of elif parts, possibly none at all. As soon as an expression evaluates to true the corresponding statement sequence statements2 is executed and execution of the if statement is complete.

If the if expression and all, if any, elif expressions evaluate to false and there is an else part, which is optional, its statement sequence statements3 is executed and the execution of the if statement is complete. If there is no else part the if statement is complete without executing any statement sequence.

Since the if statement is terminated by the fi keyword there is no question where an else part belongs, i.e., &GAP; has no dangling else. In

the else part belongs to the second if statement, whereas in

the else part belongs to the first if statement.

Since an if statement is not an expression it is not possible to write

0 then x; else -x; fi; ]]>

which would, even if legal syntax, be meaningless, since the if statement does not produce a value that could be assigned to abs.

If one of the expressions bool-expr1, bool-expr2 is evaluated and its value is neither true nor false an error is signalled and a break loop (see ) is entered. As usual you can leave the break loop with quit;. If you enter return true;, execution of the if statement continues as if the expression whose evaluation failed had evaluated to true. Likewise, if you enter return false;, execution of the if statement continues as if the expression whose evaluation failed had evaluated to false.

i := 10;; gap> if 0 < i then > s := 1; > elif i < 0 then > s := -1; > else > s := 0; > fi; gap> s; # the sign of i 1 ]]>

While loop while loop while bool-expr do statements od;

The while loop executes the statement sequence statements while the condition bool-expr evaluates to true.

First bool-expr is evaluated. If it evaluates to false execution of the while loop terminates and the statement immediately following the while loop is executed next. Otherwise if it evaluates to true the statements are executed and the whole process begins again.

The difference between the while loop and the repeat until loop (see ) is that the statements in the repeat until loop are executed at least once, while the statements in the while loop are not executed at all if bool-expr is false at the first iteration.

If bool-expr does not evaluate to true or false an error is signalled and a break loop (see ) is entered. As usual you can leave the break loop with quit;. If you enter return false;, execution continues with the next statement immediately following the while loop. If you enter return true;, execution continues at statements, after which the next evaluation of bool-expr may cause another error.

The following example shows a while loop that sums up the squares 1^2, 2^2, \ldots until the sum exceeds 200.

i := 0;; s := 0;; gap> while s <= 200 do > i := i + 1; s := s + i^2; > od; gap> s; 204 ]]>

A while loop may be left prematurely using break, see .

Repeat loop until repeat loop repeat statements until bool-expr;

The repeat loop executes the statement sequence statements until the condition bool-expr evaluates to true.

First statements are executed. Then bool-expr is evaluated. If it evaluates to true the repeat loop terminates and the statement immediately following the repeat loop is executed next. Otherwise if it evaluates to false the whole process begins again with the execution of the statements.

The difference between the while loop (see ) and the repeat until loop is that the statements in the repeat until loop are executed at least once, while the statements in the while loop are not executed at all if bool-expr is false at the first iteration.

If bool-expr does not evaluate to true or false an error is signalled and a break loop (see ) is entered. As usual you can leave the break loop with quit;. If you enter return true;, execution continues with the next statement immediately following the repeat loop. If you enter return false;, execution continues at statements, after which the next evaluation of bool-expr may cause another error.

The repeat loop in the following example has the same purpose as the while loop in the preceding example, namely to sum up the squares 1^2, 2^2, \ldots until the sum exceeds 200.

i := 0;; s := 0;; gap> repeat > i := i + 1; s := s + i^2; > until s > 200; gap> s; 204 ]]>

A repeat loop may be left prematurely using break, see .

For loop do od for simple-var in list-expr do statements od; for loop

The for loop executes the statement sequence statements for every element of the list list-expr.

The statement sequence statements is first executed with simple-var bound to the first element of the list list-expr, then with simple-var bound to the second element of list-expr and so on. simple-var must be a simple variable, it must not be a list element selection list-var[int-expr] or a record component selection record-var.ident.

The execution of the for loop over a list is exactly equivalent to the following while loop.

with the exception that loop_list and loop_index are different variables for each for loop, i.e., these variables of different for loops do not interfere with each other.

The list list-expr is very often a range (see ).

loop over range for variable in [from..to] do statements od;

corresponds to the more common

for variable from from to to do statements od;

in other programming languages.

s := 0;; gap> for i in [1..100] do > s := s + i; > od; gap> s; 5050 ]]>

Note in the following example how the modification of the list in the loop body causes the loop body also to be executed for the new values.

l := [ 1, 2, 3, 4, 5, 6 ];; gap> for i in l do > Print( i, " " ); > if i mod 2 = 0 then Add( l, 3 * i / 2 ); fi; > od; Print( "\n" ); 1 2 3 4 5 6 3 6 9 9 gap> l; [ 1, 2, 3, 4, 5, 6, 3, 6, 9, 9 ] ]]>

Note in the following example that the modification of the variable that holds the list has no influence on the loop.

l := [ 1, 2, 3, 4, 5, 6 ];; gap> for i in l do > Print( i, " " ); > l := []; > od; Print( "\n" ); 1 2 3 4 5 6 gap> l; [ ] ]]>

loop over iterator for variable in iterator do statements od;

It is also possible to have a for-loop run over an iterator (see ). In this case the for-loop is equivalent to

loop over object for variable in object do statements od;

Finally, if an object object which is not a list or an iterator appears in a for-loop, then &GAP; will attempt to evaluate the function call Iterator(object). If this is successful then the loop is taken to run over the iterator returned.

g := Group((1,2,3,4,5),(1,2)(3,4)(5,6)); Group([ (1,2,3,4,5), (1,2)(3,4)(5,6) ]) gap> count := 0;; sumord := 0;; gap> for x in g do > count := count + 1; sumord := sumord + Order(x); od; gap> count; 120 gap> sumord; 471 ]]>

The effect of

for variable in domain do

should thus normally be the same as

for variable in AsList(domain) do

but may use much less storage, as the iterator may be more compact than a list of all the elements.

See for details about iterators.

A for loop may be left prematurely using break, see . This combines especially well with a loop over an iterator, as a way of searching through a domain for an element with some useful property.

Break loops break; break statement

The statement break; causes an immediate exit from the innermost loop enclosing it.

g := Group((1,2,3,4,5),(1,2)(3,4)(5,6)); Group([ (1,2,3,4,5), (1,2)(3,4)(5,6) ]) gap> for x in g do > if Order(x) = 3 then > break; > fi; od; gap> x; (1,4,3)(2,6,5) ]]>

It is an error to use this statement other than inside a loop.

break; Error, A break statement can only appear inside a loop not in any function ]]>

Continue loops continue; continue statement

The statement continue; causes the rest of the current iteration of the innermost loop enclosing it to be skipped.

g := Group((1,2,3),(1,2)); Group([ (1,2,3), (1,2) ]) gap> for x in g do > if Order(x) = 3 then > continue; > fi; Print(x,"\n"); od; () (2,3) (1,3) (1,2) ]]>

It is an error to use this statement other than inside a loop.

continue; Error, A continue statement can only appear inside a loop not in any function ]]>

Function functions end local recursion functions environmentbody function( [ arg-ident {, arg-ident} ] )

  [local loc-ident {, loc-ident} ; ]

  statements

end

A function is in fact a literal and not a statement. Such a function literal can be assigned to a variable or to a list element or a record component. Later this function can be called as described in .

The following is an example of a function definition. It is a function to compute values of the Fibonacci sequence (see ).

fib := function ( n ) > local f1, f2, f3, i; > f1 := 1; f2 := 1; > for i in [3..n] do > f3 := f1 + f2; > f1 := f2; > f2 := f3; > od; > return f2; > end;; gap> List( [1..10], fib ); [ 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 ] ]]>

Because for each of the formal arguments arg-ident and for each of the formal locals loc-ident a new variable is allocated when the function is called (see ), it is possible that a function calls itself. This is usually called recursion. The following is a recursive function that computes values of the Fibonacci sequence.

fib := function ( n ) > if n < 3 then > return 1; > else > return fib(n-1) + fib(n-2); > fi; > end;; gap> List( [1..10], fib ); [ 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 ] ]]>

Note that the recursive version needs 2 * fib(n)-1 steps to compute fib(n), while the iterative version of fib needs only n-2 steps. Both are not optimal however, the library function only needs about Log(n) steps.

functions arg As noted in Section , the case where a function is defined with exactly one formal argument with the name arg, is special. It provides a way of defining a function with a variable number of arguments; the values of all the actual arguments are stored in a list and this list is assigned to the new variable corresponding to the formal argument arg. There are two typical scenarios for wanting such a possibility: having optional arguments and having any number of arguments.

The following example shows one way that the function might be encoded and demonstrates the optional argument scenario.

position := function ( arg ) > local list, obj, pos; > list := arg[1]; > obj := arg[2]; > if 2 = Length(arg) then > pos := 0; > else > pos := arg[3]; > fi; > repeat > pos := pos + 1; > if pos > Length(list) then > return fail; > fi; > until list[pos] = obj; > return pos; > end; function( arg ) ... end gap> position([1, 4, 2], 4); 2 gap> position([1, 4, 2], 3); fail gap> position([1, 4, 2], 4, 2); fail ]]>

The following example demonstrates the any number of arguments scenario.

sum := function ( arg ) > local total, x; > total := 0; > for x in arg do > total := total + x; > od; > return total; > end; function( arg ) ... end gap> sum(1, 2, 3); 6 gap> sum(1, 2, 3, 4); 10 gap> sum(); 0 ]]>

The user should compare the above with the &GAP; function which, for example, may take a list argument and optionally an initial element (which zero should the sum of an empty list return?).

Note that if a function f is defined as above with the single formal argument arg then NumberArgumentsFunction(f) returns -1 (see ).

The argument arg when used as the single argument name of some function f tells &GAP; that when it encounters f that it should form a list out of the arguments of f. What if one wishes to do the opposite: tell &GAP; that a list should be unwrapped and passed as several arguments to a function. The function is provided for this purpose.

Also see Chapter .

functions arrow notation for functions arg-ident -> expr

This is a shorthand for

function ( arg-ident ) return expr; end.

arg-ident must be a single identifier, i.e., it is not possible to write functions of several arguments this way. Also arg is not treated specially, so it is also impossible to write functions that take a variable number of arguments this way.

The following is an example of a typical use of such a function

Sum( List( [1..100], x -> x^2 ) ); 338350 ]]>

When the definition of a function fun1 is evaluated inside another function fun2, &GAP; binds all the identifiers inside the function fun1 that are identifiers of an argument or a local of fun2 to the corresponding variable. This set of bindings is called the environment of the function fun1. When fun1 is called, its body is executed in this environment. The following implementation of a simple stack uses this. Values can be pushed onto the stack and then later be popped off again. The interesting thing here is that the functions push and pop in the record returned by Stack access the local variable stack of Stack. When Stack is called, a new variable for the identifier stack is created. When the function definitions of push and pop are then evaluated (as part of the return statement) each reference to stack is bound to this new variable. Note also that the two stacks A and B do not interfere, because each call of Stack creates a new variable for stack.

Stack := function () > local stack; > stack := []; > return rec( > push := function ( value ) > Add( stack, value ); > end, > pop := function () > local value; > value := stack[Length(stack)]; > Unbind( stack[Length(stack)] ); > return value; > end > ); > end;; gap> A := Stack();; gap> B := Stack();; gap> A.push( 1 ); A.push( 2 ); A.push( 3 ); gap> B.push( 4 ); B.push( 5 ); B.push( 6 ); gap> A.pop(); A.pop(); A.pop(); 3 2 1 gap> B.pop(); B.pop(); B.pop(); 6 5 4 ]]>

This feature should be used rarely, since its implementation in &GAP; is not very efficient.

Return (With or without Value) return return;

In this form return terminates the call of the innermost function that is currently executing, and control returns to the calling function. An error is signalled if no function is currently executing. No value is returned by the function.

return expr; return

In this form return terminates the call of the innermost function that is currently executing, and returns the value of the expression expr. Control returns to the calling function. An error is signalled if no function is currently executing.

Both statements can also be used in break loops (see ). return; has the effect that the computation continues where it was interrupted by an error or the user hitting Ctrl-C. return expr; can be used to continue execution after an error. What happens with the value expr depends on the particular error.

For examples of return statements, see the functions fib and Stack in Section .

gap-4r6p5/doc/ref/fldabnum.xml0000644000175000017500000001565012172557252015003 0ustar billbill Abelian Number Fields <#Include Label="[1]{fldabnum}">
Construction of Abelian Number Fields Besides the usual construction using or (see ), abelian number fields consisting of cyclotomics can be created with and . <#Include Label="CyclotomicField"> <#Include Label="AbelianNumberField"> <#Include Label="GaussianRationals">
Operations for Abelian Number Fields For operations for elements of abelian number fields, e.g., or , see Chapter . Factoring of polynomials over abelian number fields consisting of cyclotomics works in principle but is not very efficient if the degree of the field extension is large.

x:= Indeterminate( CF(5) ); x_1 gap> Factors( PolynomialRing( Rationals ), x^5-1 ); [ x_1-1, x_1^4+x_1^3+x_1^2+x_1+1 ] gap> Factors( PolynomialRing( CF(5) ), x^5-1 ); [ x_1-1, x_1+(-E(5)), x_1+(-E(5)^2), x_1+(-E(5)^3), x_1+(-E(5)^4) ] ]]> <#Include Label="IsNumberField"> <#Include Label="IsAbelianNumberField"> <#Include Label="IsCyclotomicField"> <#Include Label="GaloisStabilizer">

Integral Bases of Abelian Number Fields <#Include Label="[2]{fldabnum}"> <#Include Label="ZumbroichBase"> <#Include Label="LenstraBase">
Galois Groups of Abelian Number Fields abelian number fields number fields automorphism group The field automorphisms of the cyclotomic field &QQ;_n (see Chapter ) are given by the linear maps *k on &QQ;_n that are defined by E(n)^{{*k}} = E(n)^k, where 1 \leq k < n and Gcd( n, k ) = 1 hold (see ). Note that this action is not equal to exponentiation of cyclotomics, i.e., for general cyclotomics z, z^{{*k}} is different from z^k.

(In &GAP;, the image of a cyclotomic z under *k can be computed as GaloisCyc( z, k ).)

( E(5) + E(5)^4 )^2; GaloisCyc( E(5) + E(5)^4, 2 ); -2*E(5)-E(5)^2-E(5)^3-2*E(5)^4 E(5)^2+E(5)^3 ]]>

For Gcd( n, k ) \neq 1, the map E(n) \mapsto E(n)^k does not define a field automorphism of &QQ;_n but only a &QQ;-linear map.

GaloisCyc( E(5)+E(5)^4, 5 ); GaloisCyc( ( E(5)+E(5)^4 )^2, 5 ); 2 -6 ]]> The Galois group Gal( &QQ;_n, &QQ; ) of the field extension &QQ;_n / &QQ; is isomorphic to the group (&ZZ; / n &ZZ;)^{*} of prime residues modulo n, via the isomorphism (&ZZ; / n &ZZ;)^{*} \rightarrow Gal( &QQ;_n, &QQ; ) that is defined by k + n &ZZ; \mapsto ( z \mapsto z^{*k} ).

The Galois group of the field extension &QQ;_n / L with any abelian number field L \subseteq &QQ;_n is simply the factor group of Gal( &QQ;_n, &QQ; ) modulo the stabilizer of L, and the Galois group of L / L', with L' an abelian number field contained in L, is the subgroup in this group that stabilizes L'. These groups are easily described in terms of (&ZZ; / n &ZZ;)^{*}. Generators of (&ZZ; / n &ZZ;)^{*} can be computed using .

In &GAP;, a field extension L / L' is given by the field object L with value L' (see ).

f:= CF(15); CF(15) gap> g:= GaloisGroup( f ); gap> Size( g ); IsCyclic( g ); IsAbelian( g ); 8 false true gap> Action( g, NormalBase( f ), OnPoints ); Group([ (1,6)(2,4)(3,8)(5,7), (1,4,3,7)(2,8,5,6) ]) ]]>

The following example shows Galois groups of a cyclotomic field and of a proper subfield that is not a cyclotomic field.

gens1:= GeneratorsOfGroup( GaloisGroup( CF(5) ) ); [ ANFAutomorphism( CF(5), 2 ) ] gap> gens2:= GeneratorsOfGroup( GaloisGroup( Field( Sqrt(5) ) ) ); [ ANFAutomorphism( NF(5,[ 1, 4 ]), 2 ) ] gap> Order( gens1[1] ); Order( gens2[1] ); 4 2 gap> Sqrt(5)^gens1[1] = Sqrt(5)^gens2[1]; true ]]>

The following example shows the Galois group of a cyclotomic field over a non-cyclotomic field.

g:= GaloisGroup( AsField( Field( [ Sqrt(5) ] ), CF(5) ) ); gap> gens:= GeneratorsOfGroup( g ); [ ANFAutomorphism( AsField( NF(5,[ 1, 4 ]), CF(5) ), 4 ) ] gap> x:= last[1];; x^2; IdentityMapping( AsField( NF(5,[ 1, 4 ]), CF(5) ) ) ]]> <#Include Label="ANFAutomorphism">

Gaussians <#Include Label="GaussianIntegers"> <#Include Label="IsGaussianIntegers">
gap-4r6p5/gap.shi0000755000175000017500000000471612172557252012430 0ustar billbill#!/bin/sh ############################################################################# ## ## gap.sh GAP Martin Schoenert ## ## This is a shell script for the UNIX operating system that starts GAP. ## This is the place where you make all the necessary customizations. ## Then copy this file to a directory in your search path, e.g., '~/bin'. ## If you later move GAP to another location you must only change this file. ## ############################################################################# ## ## GAP_DIR . . . . . . . . . . . . . . . . . . . . directory where GAP lives ## ## Set 'GAP_DIR' to the name of the directory where you have installed GAP, ## i.e., the directory with the subdirectories 'lib', 'grp', 'doc', etc. ## The default is '@gapdir@', which is where you installed GAP. ## You won't have to change this unless you move the installation. ## if [ "x$GAP_DIR" = "x" ]; then GAP_DIR="@gapdir@" fi ############################################################################# ## ## GAP_MEM . . . . . . . . . . . . . . . . . . . amount of initial workspace ## ## Set 'GAP_MEM' to the amount of memory GAP shall use as initial workspace. ## The default depends on whether GAP is compiled with in 32-bit or 64-bit ## mode. You have to uncomment and change the following if you want GAP ## to use a larger initial workspace. If you are not going to run GAP ## in parallel with other programs you may want to set this value close ## to the amount of memory your computer has. ## #if [ "x$GAP_MEM" = "x" ]; then #GAP_MEM="-m 256m" #fi ############################################################################# ## ## GAP_PRG . . . . . . . . . . . . . . . . . name of the executable program ## ## Set 'GAP_PRG' to the name of the executable program of the GAP kernel. ## The default is '/XX-bit/gap' where is the target you ## have selected during compilation and XX is 32 or 64 - set automatically ## according to your system architecture, unless specified by you at the ## './configure' stage. ## if [ "x$GAP_PRG" = "x" ]; then GAP_PRG=@GAPARCH@/gap@EXEEXT@ fi ############################################################################# ## ## GAP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . run GAP ## ## You probably should not change this line, which finally starts GAP. ## exec "$GAP_DIR/bin/$GAP_PRG" $GAP_MEM -l "$GAP_DIR" "$@" gap-4r6p5/makepkgs0000644000175000017500000000057312172557254012675 0ustar billbill#!/bin/sh if [ "x$GAPPACKAGES" = "x" ] ; then export GAPPACKAGES="io orb edim Browse" echo Taking \"$GAPPACKAGES\" as list of packages. echo Please set the GAPPACKAGES environment variable to overwrite. echo Starting in 5 seconds... sleep 5 fi for p in $GAPPACKAGES ; do cd pkg/$p ./configure make clean ./configure make cd ../.. done gap-4r6p5/etc/0000755000175000017500000000000012174560030011702 5ustar billbillgap-4r6p5/etc/install-tools.sh0000755000175000017500000000220112172557252015052 0ustar billbill#!/bin/sh ############################################################################# ## ## ## This script unpacks the tools.tar.gz archive which contains some utilities ## mainly for package authors (preparing documentation and archives, ...). ## ## The content of the archive will go to the 'doc' and 'dev' subdirectories ## of the GAP root directory. To ensure that they will go to the correct ## destination, run this script *ONLY* from the 'etc' directory where it is ## located (same directory with the tools.tar.gz archive). if [ -f tools.tar.gz ] then echo '============================================================================' echo 'Unpacking tools.tar.gz archive ...' tar -xvzf tools.tar.gz -C ../ echo 'Done!' echo '============================================================================' else echo '============================================================================' echo 'Error in install-tools.sh: can not find tools.tar.gz archive!' echo 'Please run install-tools.sh from the dev directory of your GAP installation!' echo '============================================================================' fi gap-4r6p5/etc/gap_indent.vim0000644000175000017500000000553612172557252014552 0ustar billbill" GAP indent file " Language: GAP (http://www.gap-system.org) " Maintainer: Frank Lübeck (Frank.Luebeck@Math.RWTH-Aachen.De) " Comments: " -- started from Matlab indent file in vim 6.0 " -- Many people like a 4 blank indentation, I prefer 2 blanks: this can " be adjusted by setting `GAPIndentShift' to 4, 2 (default) or whatever " you like " TODO: nice handling of `continuation' lines " Only load this indent file when no other was loaded. if exists("b:did_indent") finish endif let b:did_indent = 1 " Some preliminary setting setlocal nolisp " Make sure lisp indenting doesn't supersede us setlocal autoindent setlocal indentexpr=GetGAPIndent(v:lnum) setlocal indentkeys=o,O=end,=fi,=else,=elif,=od,=\) let GAPIndentShift = 2 " Only define the function once. if exists("*GetGAPIndent") finish endif " this function computes for line lnum of the current buffer the number of " blanks for the indentation function! GetGAPIndent(lnum) " Give up if this line is explicitly joined. if getline(a:lnum - 1) =~ '\\$' return -1 endif " Search backwards for the first non-empty line. let plnum = a:lnum - 1 while plnum > 0 && getline(plnum) =~ '^\s*$' let plnum = plnum - 1 endwhile if plnum == 0 " This is the first non-empty line, use zero indent. return 0 endif let curind = indent(plnum) " If the current line is a stop-block statement... if getline(v:lnum) =~ '^\s*\(end\|else\|elif\|fi\|od\|until\)\>' " See if this line does not follow the line right after an openblock if getline(plnum) =~ '^\s*\(for\|if\|then\|else\|elif\|while\|repeat\)\>' " See if the user has already dedented elseif indent(v:lnum) > curind - g:GAPIndentShift " If not, recommend one dedent let curind = curind - g:GAPIndentShift else " Otherwise, trust the user return -1 endif " If the previous line opened a block elseif (getline(plnum) =~ '^\s*\(for\|if\|then\|else\|elif\|while\|repeat\)\>' || getline(plnum) =~ '\ *(') " See if the user has already indented, or if block is also finished " im plnum if (indent(v:lnum) < curind + g:GAPIndentShift && getline(plnum) !~ '\<\(end\|fi\|od\)\>') "If not, recommend indent let curind = curind + g:GAPIndentShift else " Otherwise, trust the user return -1 endif " Handle assignments over several lines elseif (getline(plnum) =~ '^\s*[a-zA-Z0-9]*\s*:=[^;]*$') let curind = match(getline(plnum), ':=') + 3 " Handle continuing function calls over several lines elseif (getline(plnum) =~ '^\s*[a-zA-Z0-9]*\s*([^;]*$') let curind = indent(plnum) + 2*GAPIndentShift; endif " If we got to here, it means that the user takes the standard version, " so we return it return curind endfunction " vim:sw=2 gap-4r6p5/etc/GPL0000644000175000017500000004311012172557252012260 0ustar billbill GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. gap-4r6p5/etc/debug.vim0000644000175000017500000000067312172557252013525 0ustar billbill" " Keyboard configuration for vim sessions during the `Debug' call " from the library file "debug.g". " " By Thomas Breuer and Max Neunhöffer 2003 " " map OError("Breakpoint #"apa"); map OPrint("Watchpoint #"apa\n"); map ODEBUG_LIST["apa].count := DEBUG_LIST["apa].count - 1;if DEBUG_LIST["apa].count <= 0 then Error("Breakpoint #"apa"); fi; map OPrint("\n");5 gap-4r6p5/etc/README.vim-utils0000644000175000017500000000244612172557252014532 0ustar billbill HOWTO use the files gap.vim, gap_indent.vim with the `vim' editor (http://www.vim.org/) I have put the following lines in my ~/.vimrc file: ------------------- from ~/.vimrc ------------------------------------- if has("syntax") syntax on " Default to no syntax highlightning endif " For GAP files augroup gap " Remove all gap autocommands au! autocmd BufRead,BufNewFile *.g,*.gi,*.gd set filetype=gap comments=s:##\ \ ,m:##\ \ ,e:##\ \ b:# " I'm using the external program `par' for formating comment lines starting " with `## '. Include these lines only when you have par installed. autocmd BufRead,BufNewFile *.g,*.gi,*.gd set formatprg="par w76p4s0j" autocmd BufWritePost,FileWritePost *.g,*.gi,*.gd set formatprg="par w76p0s0j" augroup END --------------------------------------------------------------------------- Then I copied the file GAPPATH/etc/gap.vim to: ~/.vim/syntax/gap.vim Since I have now installed vim 6.0 I'm also using the new indent functionality. For this I copied the file GAPPATH/etc/gap_indent.vim to: ~/.vim/indent/gap.vim See the headers of the two mentioned files for additional comments. Adjust details according to your personal taste. Send comments and suggestions to Frank.Luebeck@Math.RWTH-Aachen.De Frank Lübeck gap-4r6p5/etc/debugvim.txt0000644000175000017500000000251312172557252014260 0ustar billbillShort introduction into debugging in GAP by Thomas Breuer and Max Neunhöffer (see library file lib/debug.g) Debug( [,]); # opens an editor to insert debugging code # the debugged function is stored under a number A "debugged" function gets a number and can later be accessed either as itself or via this number. Debug(); # opens an editor to edit debugging code UnDebug(); # restores the function to its old form ShowDebug(); # show currently debugged functions SetDebugCount(,); # Set counter of counting break point Keys in editor: F12 : this help F2 : Set break point before current line F3 : Set watch point before current line F4 : Set counting break point before current line F5 : Set Print statement before current line Put any other debugging code into the function. Note that the function object itself will be changed "in place"! This means that all places where this function is installed for example as a method will be changed simultanously. BEWARE of debugging functions that have been created within the scope of another function possibly with access to the surrounding local variables (see "Orbish" and friends)! ***Debugging of such functions does not work and might ruin them!*** gap-4r6p5/etc/gap.vim0000644000175000017500000002600612172557252013204 0ustar billbill" Vim syntax file " Language: GAP " Author: Frank Lübeck, highlighting based on file by Alexander Hulpke " Maintainer: Frank Lübeck " Last change: June 2010 " " Comments: If you want to use this file, you may want to adjust colors to " your taste. There are some functions/macros for " GAPnl -- newline, with reindenting the old line " (mapped on -j) " ToggleCommentGAP -- toggle comment, add or remove "## " " (mapped on F12) " -- macro to add word under cursor to `local' list " GAPlocal -- add whole `local' declaration to current function " (mapped on ) " Then the completion mechanism -p is extended to complete all " GAP variable names - search `GAPWORDS' below, how to do this. " " For vim version >= 6.0 folding is switched on. " " For vim version >= 6.0 there is another file gap_indent.vim which you " may want to copy into ~/.vim/indent/gap.vim -- this provides a nice " automatic indenting while writing GAP code. " " Please, send comments and suggestions to: Frank.Luebeck@Math.RWTH-Aachen.De " Remove any old syntax stuff hanging around syn clear " comments syn match gapComment "\(#.*\)*" contains=gapTodo,gapFunLine " strings and characters syn region gapString start=+"+ end=+\([^\\]\|^\)\(\\\\\)*"+ syn match gapString +"\(\\\\\)*"+ syn match gapChar +'\\\=.'+ syn match gapChar +'\\"'+ " must do syn keyword gapTodo TODO contained syn keyword gapTodo XXX contained " basic infos in file and folded lines syn match gapFunLine '^#[FVOMPCAW] .*$' contained syn keyword gapDeclare DeclareOperation DeclareGlobalFunction syn keyword gapDeclare DeclareGlobalVariable syn keyword gapDeclare DeclareAttribute DeclareProperty syn keyword gapDeclare DeclareCategory DeclareFilter DeclareCategoryFamily syn keyword gapDeclare DeclareRepresentation DeclareInfoClass syn keyword gapDeclare DeclareCategoryCollections DeclareSynonym " the CHEVIE utils syn keyword gapDeclare MakeProperty MakeAttribute MakeOperation syn keyword gapDeclare MakeGlobalVariable MakeGlobalFunction syn keyword gapMethsel InstallMethod InstallOtherMethod NewType Objectify syn keyword gapMethsel NewFamily InstallTrueMethod syn keyword gapMethsel InstallGlobalFunction ObjectifyWithAttributes syn keyword gapMethsel BindGlobal BIND_GLOBAL InstallValue " CHEVIE util syn keyword gapMethsel NewMethod syn keyword gapOperator and div in mod not or syn keyword gapFunction function -> return local end Error syn keyword gapConditional if else elif then fi syn keyword gapRepeat do od for while repeat until syn keyword gapOtherKey Info Unbind IsBound syn keyword gapBool true false fail syn match gapNumber "-\=\<\d\+\>\/" syn match gapListDelimiter "[][]" syn match gapParentheses "[)(]" syn match gapSublist "[}{]" "hilite " this is very much dependent on personal taste, must add gui case if you " use gvim hi gapString ctermfg=2 guifg=Green hi gapFunction ctermfg=1 guifg=Red hi gapDeclare cterm=bold ctermfg=4 guifg=DarkBlue hi gapMethsel ctermfg=6 guifg=Cyan hi gapOtherKey ctermfg=3 guifg=Yellow hi gapOperator cterm=bold ctermfg=8 guifg=DarkGray hi gapConditional cterm=bold ctermfg=9 guifg=DarkRed hi gapRepeat cterm=bold ctermfg=12 guifg=DarkGray hi gapComment ctermfg=4 guifg=Blue hi gapTodo ctermbg=2 ctermfg=0 guibg=Green guifg=Black hi link gapTTodoComment gapTodo hi link gapTodoComment gapComment hi gapNumber ctermfg=5 guifg=Magenta hi gapBool ctermfg=5 guifg=Magenta hi gapChar ctermfg=3 guifg=Yellow hi gapListDelimiter ctermfg=8 guifg=Gray hi gapParentheses ctermfg=12 guifg=Blue hi gapSublist ctermfg=14 guifg=LightBlue hi gapFunLine ctermbg=3 ctermfg=0 guibg=LightBlue guifg=Black syn sync maxlines=500 " an ex function which returns a `fold level' for line n of the current " buffer (only used with folding in vim >= 6.0) func! GAPFoldLevel(n) " none at top of file if (a:n==0) return 0 endif let l = getline(a:n) let lb = getline(a:n-1) " GAPDoc in comment is level 1 if (l =~ "^##.*<#GAPDoc") return 1 endif if (lb =~ "^##.*<#/GAPDoc") return 0 endif " recurse inside comment if (l =~ "^#" && lb =~ "^#") return GAPFoldLevel(a:n-1) endif " in code one level per 4 blanks indent " from previous non-blank line let n = a:n while (n>1 && getline(n) =~ '^\s*$') let n = n - 1 endwhile return (indent(n)+3)/4 endfunc " enable folding and much better indenting in vim >= 6.0 if version>=600 syn sync fromstart set foldmethod=expr set foldminlines=3 set foldexpr=GAPFoldLevel(v:lnum) hi Folded ctermbg=6 ctermfg=0 " load the indent file runtime indent/gap.vim endif let b:current_syntax = "gap" " some macros for editing GAP files (adjust as you like) " This adds word under cursor to local variables list. map miviwy?\/;i, p`i map! miviwy?\/;i, p`ia " for word completion, fall back to list of GAP global variable names " (after loading your favourite packages in GAP say: " for w in NamesGVars() do AppendTo("~/.vim/GAPWORDS",w,"\n"); od; ) set complete=.,w,b,u,t,i,k~/.vim/GAPWORDS " function for *toggling* GAP comments in beginning of line func! ToggleCommentGAP() let l = getline(".") if (l =~ "^## *$") let l = "" elseif (l =~ "^## ") let l = strpart(l, 4, strlen(l)) else let l = "## " . l endif call setline(".", l) endfunc " I put it on F12, adjust as you like map :call ToggleCommentGAP()j map! :call ToggleCommentGAP()ji " function for nice indenting after line breaks (bound to ) " helper, returns string with n spaces func! SpStr( n ) let i = 0 let res = "" while (i < a:n) let res = res . " " let i = i + 1 endwhile return res endfunc " reindents current line and puts next line " (outdated with vim 6.0's nice indent functionality) func! GAPnl() let nc = line(".") let cl = getline(nc) let nsp = matchend(cl, "^[ ]*") let m = match(cl, "^[ ]*\\(if\\|while\\|for\\) ") let m1 = match(cl, ".*[^a-zA-Z0-9_]function[ ]*(.*)[ ]*$") if (m != -1 || m1 != -1) call append(nc, SpStr(nsp + 2)) return endif let m = match(cl, "^ [ ]*\\(fi\\|end\\|od\\)\\([);,]\\)") if (m != -1) let cl = substitute(cl, "^ ", "", "") call setline(nc, cl) call append(nc, SpStr(nsp - 2)) return endif let m = match(cl, "^ [ ]*\\(else\\|elif\\)") if (m != -1) let cl = substitute(cl, "^ ", "", "") call setline(nc, cl) call append(nc, SpStr(nsp)) return endif call append(nc, SpStr(nsp)) endfunc " call GAPnl, goto end of next line and in append mode map! :call GAPnl()j$a " position count from 0 here " (we assume that pos is after the begin delimiter b to match) function! MatchingDelim(str, pos, b, e) let len = strlen(a:str) let res = a:pos + 1 let stop = 1 while (stop > 0 && res < len) if (a:str[res] == a:e) let stop = stop - 1 endif if (a:str == a:b) let stop = stop + 1 endif let res = res + 1 endwhile return res - 1 endfunction " insert complete list of local variable declaration on top of function function! GAPlocal() let t = "" let i = line(".") " collect forward to 'end' let stop = 1 while (stop > 0 && i < 10000) let cl = getline(i) " throw away comments let m = match(cl, "#") if (m != -1) let cl = strpart(cl, 0, m) endif let t = t . cl . " " let m = match(cl, "\\(^\\|[^a-zA-Z0-9_]\\)end[^a-zA-Z0-9_]") if (m != -1) let stop = stop - 1 endif let m = match(cl, "\\(^\\|[^a-zA-Z0-9_]\\)function[ ]*(") if (m != -1) let stop = stop + 1 endif let i = i + 1 endwhile " collect backward to matching 'function' let i = line(".") - 1 let stop = 1 while (stop > 0 && i > -1) let cl = getline(i) " throw away comments let m = match(cl, "#") if (m != -1) let cl = strpart(cl, 0, m) endif let t = cl . t . " " let m = match(cl, "\\(^\\|[^a-zA-Z0-9_]\\)function[ ]*(") if (m != -1) let stop = stop - 1 endif let m = match(cl, "\\(^\\|[^a-zA-Z0-9_]\\)end[^a-zA-Z]") if (m != -1) let stop = stop + 1 endif let i = i - 1 endwhile " line for 'local ...' let locline = i + 1 " filter out first 'function' and local functions, store parameters let m = matchend(t, "\\(^\\|[^a-zA-Z0-9_]\\)function[ ]*(") let param = strpart(t, m, MatchingDelim(t, m-1, "(", ")") - m) let param = "," . substitute(param, " ", "", "g") . "," let t = strpart(t, m, strlen(t)) let m = matchend(t, "\\(^\\|[^a-zA-Z0-9_]\\)function[ ]*(") while (m != -1) let tt = strpart(t, 0, m - 3) . "; " let m = match(t, "\\(^\\|[^a-zA-Z0-9_]\\)end[^a-zA-Z0-9_]") let tt = tt . strpart(t, m + 2, strlen(t)) let t = tt let m = matchend(t, "\\(^\\|[^a-zA-Z0-9_]\\)function[ ]*(") endwhile " filter out rec( .. ), which may contain := assignments let m = matchend(t, "\\(^\\|[^a-zA-Z0-9_]\\)rec[ ]*(") while (m != -1) let tt = strpart(t, 0, m-2) . "; " let tt = tt . strpart(t, MatchingDelim(t, m-1, "(", ")"), strlen(t)) let t = tt let m = matchend(t, "\\(^\\|[^a-zA-Z0-9_]\\)rec[ ]*(") endwhile " now collect local variables, " first lhd's of assignments, then vars in for loops let vars = "," let tt = t let m = matchstr(tt, "\\(^\\|[^.a-zA-Z_]\\)[a-zA-Z0-9_][a-zA-Z0-9_]*[ ]*:=") while (strlen(m) > 0) " XXX why is this necessary? let m = strpart(m, match(m, "[a-zA-Z0-9_]"), strlen(m)) let m = matchstr(m, "[a-zA-Z0-9_]*") if (vars.param !~# ("," . m . ",")) let vars = vars . matchstr(m, "[a-zA-Z0-9_]*") . "," endif let m = matchend(tt, "\\(^\\|[^.a-zA-Z0-9_]\\)[a-zA-Z0-9_][a-zA-Z0-9_]*[ ]*:=") let tt = strpart(tt, m, strlen(tt)) let m = matchstr(tt, "\\(^\\|[^.a-zA-Z0-9_]\\)[a-zA-Z0-9_][a-zA-Z0-9_]*[ ]*:=") endwhile let tt = t let m = matchstr(tt, "for[ ]*[a-zA-Z0-9_]*[ ]*in") while (strlen(m) > 0) let m = strpart(m, 4, strlen(m)) let m = matchstr(m, "[a-zA-Z0-9_]*") if (vars.param !~# ("," . m . ",")) let vars = vars . matchstr(m, "[a-zA-Z0-9_]*") . "," endif let m = matchend(tt, "for[ ]*[a-zA-Z0-9_]*[ ]*in") let tt = strpart(tt, m, strlen(tt)) let m = matchstr(tt, "for[ ]*[a-zA-Z0-9_]*[ ]*in") endwhile " now format the result vars (if not empty) if (strlen(vars) > 1) let vars = strpart(vars, 1, strlen(vars) - 2) let vars = substitute(vars, ",", ", ", "g") let vars = matchstr(getline(locline), "^[ ]*") . " local " . vars . ";" call append(locline, vars) endif return endfunction " I map it on F5 map! :call GAPlocal()i map :call GAPlocal() " very personal, for adding GAPDoc XML code in comments in GAP file vmap }F14 y:n bla.xmlGp:.,$ s/## \(.*\)/\1/i map }F15 :n bla.xml:1,$ s/\(.*\)/## \1/1GVGyugpi map! }F15 :n bla.xml:1,$ s/\(.*\)/## \1/1GVGyugpi vmap }F22 !(mv -f bla.xml bla1.xml; sed -e "s/^\#\# \(.*\)/\1/" >bla.xml;xterm -e vim bla.xml ;sed -e "s/\(.*\)/\#\# \1/" bla.xml) " vim: ts=2 gap-4r6p5/grp/0000755000175000017500000000000012174560027011725 5ustar billbillgap-4r6p5/grp/suzuki.gi0000644000175000017500000000534312172557252013611 0ustar billbill############################################################################# ## #W suzuki.gi GAP library Stefan Kohl ## ## #Y (C) 1999 School Math and Comp. Sci., University of St Andrews, Scotland ## ## This file contains constructors for the Suzuki groups. ## ## The generators are taken from ## ## Michio Suzuki. On a Class of Doubly Transitive Groups, ## Ann. Math. 75 (1962), 105-145. ## ## See the middle of page 140, in the proof of Theorem 12. ## ############################################################################# ## #M SuzukiGroupCons( , ) ## InstallMethod( SuzukiGroupCons, "matrix group for finite field size", true, [ IsMatrixGroup and IsFinite, IsInt and IsPosRat ], 0, function ( filter, q ) local G,f; if not IsPrimePowerInt(q) or SmallestRootInt(q) <> 2 or LogInt(q,2) mod 2 = 0 then Error(" must be a non-square power of 2\n"); fi; f := GF(q); G := GroupByGenerators( [ImmutableMatrix(f, [[1, 0, 0,0], [1, 1, 0,0], [1+Z(q), 1, 1,0], [1+Z(q)+Z(q)^RootInt(2 * q),Z(q),1,1]] * One(f),true), ImmutableMatrix(f, [[0,0,0,1], [0,0,1,0], [0,1,0,0], [1,0,0,0]] * One(f),true)]); SetName(G,Concatenation("Sz(",String(q),")")); SetDimensionOfMatrixGroup(G,4); SetFieldOfMatrixGroup(G,f); SetIsFinite(G,true); SetSize(G,q^2*(q-1)*(q^2+1)); if q > 2 then SetIsSimpleGroup(G,true); fi; return G; end ); ############################################################################# ## #M SuzukiGroupCons( , ) ## InstallMethod( SuzukiGroupCons, "permutation group for finite field size", true, [ IsPermGroup and IsFinite, IsInt and IsPosRat ], 0, function ( filter, q ) local G,Ovoid,f,r,a,b,v; if not IsPrimePowerInt(q) or SmallestRootInt(q) <> 2 or LogInt(q,2) mod 2 = 0 then Error(" must be a non-square power of 2\n"); fi; f := GF(q); r := RootInt(2 * q); v:=[1,0,0,0] * One(f); ConvertToVectorRep(v,q); MakeImmutable(v); Ovoid := [v]; for a in f do for b in f do v:=[a^(r+2) + a*b + b^r,b,a,One(f)]; ConvertToVectorRep(v,q); MakeImmutable(v); Add(Ovoid,NormedRowVector(v)); od; od; Sort(Ovoid); G := Action(SuzukiGroupCons(IsMatrixGroup,q),Ovoid,OnLines); SetName(G,Concatenation("Sz(",String(q),")")); SetSize(G,q^2*(q-1)*(q^2+1)); if q > 2 then SetIsSimpleGroup(G,true); fi; return G; end ); ############################################################################# ## #E suzuki.gi . . . . . . . . . . . . . . . . . . . . . . . . . . . ends heregap-4r6p5/grp/imf19.grp0000644000175000017500000005172412172557252013401 0ustar billbill############################################################################# ## #A imf19.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Z-class representative of the irreducible ## maximal finite integral matrix groups of dimension 19, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Z-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 19. ## IMFList[19].matrices := [ [ # Z-class [19][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]], [[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Z-class [19][02] [[4], [-4,8], [4,-8,12], [-4,8,-12,16], [4,-8,12,-16,20], [-4,8,-12,16,-20,24], [4,-8,12,-16,20,-24,28], [-4,8,-12,16,-20,24,-28,32], [4,-8,12,-16,20,-24,28,-32,36], [-4,8,-12,16,-20,24,-28,32,-36,40], [4,-8,12,-16,20,-24,28,-32,36,-40,44], [-4,8,-12,16,-20,24,-28,32,-36,40,-44,48], [4,-8,12,-16,20,-24,28,-32,36,-40,44,-48,52], [-4,8,-12,16,-20,24,-28,32,-36,40,-44,48,-52,56], [4,-8,12,-16,20,-24,28,-32,36,-40,44,-48,52,-56,60], [-4,8,-12,16,-20,24,-28,32,-36,40,-44,48,-52,56,-60,64], [4,-8,12,-16,20,-24,28,-32,36,-40,44,-48,52,-56,60,-64,68], [-4,8,-12,16,-20,24,-28,32,-36,40,-44,48,-52,56,-60,64,-68,72], [2,-4,6,-8,10,-12,14,-16,18,-20,22,-24,26,-28,30,-32,34,-36,19]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,-2], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,-2], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,-2], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,-2], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1]], [[1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-2,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,2,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-2,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,2,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,-2,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,2,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,-2,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,2,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,-2,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,2,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,-2,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,2,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Z-class [19][03] [[2], [1,2], [0,1,2], [0,0,1,2], [0,0,0,1,2], [0,0,0,0,1,2], [0,0,0,0,0,1,2], [0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,4]], [[[1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,2,-2,2,-2,2,-2,2,-2,2,-2,2,-2,2,-2,2,-2,1], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Z-class [19][04] [[19], [-1,19], [1,1,19], [1,1,-1,19], [1,1,-1,-1,19], [1,1,-1,-1,-1,19], [1,1,-1,-1,-1,-1,19], [1,1,-1,-1,-1,-1,-1,19], [1,1,-1,-1,-1,-1,-1,-1,19], [1,1,-1,-1,-1,-1,-1,-1,-1,19], [1,1,-1,-1,-1,-1,-1,-1,-1,-1,19], [1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,19], [1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,19], [1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,19], [1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,19], [1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,19], [1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,19], [-1,-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,19], [-1,-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,-1,19]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,1]], [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Z-class [19][05] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]]]], [ # Z-class [19][06] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,2], [-1,0,-1,0,-1,-1,0,-1,0,-1,0,0,0,0,5], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,-1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,-1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,-1,1,1,2], [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,-1,-1,-1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [1,0,1,-1,0,0,-1,1,-1,1,-1,0,0,-1,1,1,0,0,-1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [1,-1,1,-1,1,1,-1,1,-1,1,-1,-1,-1,-1,2,1,1,0,-1]], [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,1,0,1,-1,-1,0,-1,1,-1,1,0,1,1,-1,-1,0,-1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0]]]], [ # Z-class [19][07] [[10], [5,10], [5,5,10], [5,5,5,10], [5,5,5,5,10], [5,5,5,5,5,10], [5,5,5,5,5,5,10], [5,5,5,5,5,5,5,10], [5,5,5,5,5,5,5,5,10], [5,5,0,5,0,5,0,0,0,16], [5,5,5,5,5,5,5,5,5,0,10], [5,5,5,5,5,5,5,5,5,0,5,10], [5,5,5,5,5,5,5,5,5,0,5,5,10], [5,5,5,5,5,5,5,5,5,0,5,5,5,10], [5,5,5,5,5,5,5,5,5,0,5,5,5,5,10], [5,5,5,5,5,5,5,5,5,0,5,5,5,5,5,10], [-5,-5,0,-5,0,0,0,0,0,-11,0,0,0,0,0,0,16], [5,5,5,5,5,5,5,5,5,0,5,5,5,5,5,5,0,10], [-5,-5,-5,-5,-5,-5,-5,-5,-5,0,-5,-5,-5,-5,-5,-5,0,-5,10]], [[[0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,-1], [1,1,0,1,0,0,0,0,0,0,0,0,-1,0,-1,0,1,-1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [3,3,-1,3,-1,3,-1,-1,-1,-4,-1,-1,-1,-1,0,-1,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1], [1,1,0,1,0,0,0,0,0,0,0,0,0,-1,0,-1,1,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Z-class [19][08] [[8], [-4,8], [-4,4,8], [-4,4,4,8], [-4,4,4,4,8], [-4,4,4,4,4,8], [-4,4,4,4,4,4,8], [-4,4,4,4,4,4,4,8], [-4,4,4,4,4,4,4,4,8], [-4,4,4,4,4,4,4,4,4,8], [-4,4,4,4,4,4,4,4,4,4,8], [-4,4,4,4,4,4,4,4,4,4,4,8], [4,-4,0,-4,0,-4,0,-4,0,0,0,0,15], [-4,4,0,4,0,4,0,0,0,0,0,0,-11,15], [-4,4,0,4,0,4,0,0,0,0,0,0,-11,11,15], [-4,4,0,4,0,4,0,0,0,0,0,0,-11,11,11,15], [4,-4,0,-4,0,-4,0,0,0,0,0,0,11,-11,-11,-11,15], [-4,4,0,4,0,4,0,0,0,0,0,0,-11,11,11,11,-11,15], [4,-4,0,-4,0,-4,0,0,0,0,0,0,11,-11,-11,-11,11,-11,15]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1], [0,0,0,0,0,0,0,1,0,0,0,-1,1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,1,0,0,-1,0,1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,1,0,-1,0,0,1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,1,-1,0,0,0,1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1], [0,0,0,0,0,0,-1,1,0,0,0,0,1,0,0,0,0,0,-1], [0,0,0,0,0,-1,0,1,0,0,0,0,1,0,0,0,0,0,-1], [1,-1,0,-1,0,-1,0,2,0,1,0,1,2,0,1,0,-1,1,0], [-1,1,0,1,-1,1,0,-2,0,0,0,-1,-2,0,-1,0,1,-1,0], [-1,1,0,0,0,1,0,-2,0,0,0,-1,-2,0,-1,0,1,-1,0], [-1,1,-1,1,0,1,0,-2,0,0,0,-1,-2,0,-1,0,1,-1,0], [-2,2,-1,2,-1,2,-1,-1,-1,-1,-1,0,0,-1,0,-1,0,0,1], [-1,0,0,1,0,1,0,-2,0,0,0,-1,-2,0,-1,0,1,-1,0], [0,-1,0,-1,0,-1,0,2,0,0,0,1,2,0,1,0,-1,1,0]], [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1], [0,0,0,0,0,0,0,1,0,0,0,-1,1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,1,0,0,-1,0,1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,1,0,-1,0,0,1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,1,-1,0,0,0,1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1], [0,0,0,0,0,0,-1,1,0,0,0,0,1,0,0,0,0,0,-1], [1,-1,0,-1,0,-1,0,2,0,0,1,0,2,1,0,1,-1,0,0], [-1,1,0,1,0,0,0,-2,0,0,0,0,-2,-1,0,-1,1,0,0], [-1,1,0,1,-1,1,0,-2,0,0,0,0,-2,-1,0,-1,1,0,0], [-1,1,0,0,0,1,0,-2,0,0,0,0,-2,-1,0,-1,1,0,0], [0,-1,0,-1,0,-1,0,2,0,0,0,0,2,1,0,1,-1,0,0], [-1,1,-1,1,0,1,0,-2,0,0,0,0,-2,-1,0,-1,1,0,0], [1,0,0,-1,0,-1,0,2,0,0,0,0,2,1,0,1,-1,0,0]]]], [ # Z-class [19][09] [[9], [-4,9], [-4,4,9], [-4,4,4,9], [-4,-1,4,-1,9], [-4,-1,-1,-1,4,9], [-4,-1,-1,-1,4,4,9], [-4,-1,-1,-1,4,4,4,9], [-4,-1,-1,-1,4,4,4,4,9], [-4,-1,-1,-1,4,4,4,4,4,9], [-4,-1,-1,-1,4,4,4,4,4,4,9], [-4,-1,-1,-1,4,4,4,4,4,4,4,9], [-4,-1,-1,-1,4,4,4,4,4,4,4,4,9], [-4,-1,-1,-1,4,4,4,4,4,4,4,4,4,9], [-4,-1,-1,-1,4,4,4,4,4,4,4,4,4,4,9], [-4,-1,-1,-1,4,4,4,4,4,4,4,4,4,4,4,9], [-4,-1,-1,-1,4,4,4,4,4,4,4,4,4,4,4,4,9], [-4,-1,-1,-1,4,4,4,4,4,4,4,4,4,4,4,4,4,9], [-4,-1,-1,-1,4,4,4,4,4,4,4,4,4,4,4,4,4,4,9]], [[[-7,-1,-6,-1,5,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0], [8,1,6,1,-5,1,1,1,1,1,1,1,1,1,1,1,1,1,1], [7,1,6,1,-5,1,1,1,1,1,1,1,1,1,1,1,1,0,1], [7,1,6,1,-5,1,1,1,1,1,1,1,1,1,1,1,0,1,1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1], [-1,0,-1,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,-1], [-1,0,-1,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1], [-1,0,-1,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1], [-1,0,-1,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,-1], [-1,0,-1,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,-1], [-1,0,-1,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1], [-1,0,-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,-1], [-1,0,-1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,-1], [-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1]], [[1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1], [-1,0,-1,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,-1], [-1,0,-1,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1], [-1,0,-1,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1], [-1,0,-1,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,-1], [-1,0,-1,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,-1], [-1,0,-1,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1], [-1,0,-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,-1], [-1,0,-1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,-1], [-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1]]]] ]; MakeImmutable( IMFList[19].matrices ); gap-4r6p5/grp/simple.gi0000644000175000017500000004736312172557252013560 0ustar billbill############################################################################# ## #W simple.gi GAP Library Alexander Hulpke ## ## #Y Copyright (C) 2011 The GAP Group ## ## This file contains basic constructions for simple groups of bounded size, ## if necessary by calling the `atlasrep' package. ## # data for simple groups of order up to 10^18 that are not L_2(q) BindGlobal("SIMPLEGPSNONL2", [[60,"A",5],[360,"A",6],[2520,"A",7], [5616,"L",3,3],[6048,"U",3,3],[7920,"Spor","M(11)"], [20160,"A",8], [20160,"L",3,4], [25920,"S",4,3],[29120,"Sz",8],[62400,"U",3,4], [95040,"Spor","M(12)"],[126000,"U",3,5],[175560,"Spor","J(1)"], [181440,"A",9],[372000,"L",3,5],[443520,"Spor","M(22)"], [604800,"Spor","J(2)"],[979200,"S",4,4], [1451520,"S",6,2],[1814400,"A",10],[1876896,"L",3,7], [3265920,"U",4,3],[4245696,"G",2,3],[4680000,"S",4,5], [5515776,"U",3,8],[5663616,"U",3,7],[6065280,"L",4,3], [9999360,"L",5,2],[10200960,"Spor","M(23)"],[13685760,"U",5,2], [16482816,"L",3,8],[17971200,"T"], [19958400,"A",11],[32537600,"Sz",32],[42456960,"L",3,9], [42573600,"U",3,9],[44352000,"Spor","HS"],[50232960,"Spor","J(3)"], [70915680,"U",3,11],[138297600,"S",4,7],[174182400,"O+",8,2], [197406720,"O-",8,2],[211341312,"3D",4,2],[212427600,"L",3,11], [239500800,"A",12],[244823040,"Spor","M(24)"],[251596800,"G",2,4], [270178272,"L",3,13],[811273008,"U",3,13],[898128000,"Spor","McL"], [987033600,"L",4,4],[1018368000,"U",4,4],[1056706560,"S",4,8], [1425715200,"L",3,16],[1721606400,"S",4,9],[2317678272,"U",3,17], [3113510400,"A",13],[4030387200,"Spor","He"], [4279234560,"U",3,16],[4585351680,"S",6,3],[4585351680,"O",7,3],[5644682640,"L",3,19], [5859000000,"G",2,5],[6950204928,"L",3,17],[7254000000,"L",4,5], [9196830720,"U",6,2],[10073444472,"R",27], [12860654400,"S",4,11],[14742000000,"U",4,5],[16938986400,"U",3,19], [20158709760,"L",6,2],[26056457856,"U",3,23],[34093383680,"Sz",128], [43589145600,"A",14],[47377612800,"S",8,2],[50778000000,"L",3,25], [68518981440,"S",4,13],[78156525216,"L",3,23], [145926144000,"Spor","Ru"],[152353500000,"U",3,25], [166557358800,"U",3,29],[237783237120,"L",5,3], [258190571520,"U",5,3],[282027786768,"L",3,27], [282056445216,"U",3,27],[283991644800,"L",3,31], [366157135872,"U",3,32],[448345497600,"Spor","Suz"], [460815505920,"Spor","ON"],[495766656000,"Spor","Co(3)"], [499631102880,"L",3,29],[653837184000,"A",15], [664376138496,"G",2,7],[852032133120,"U",3,31], [1004497044480,"S",4,17],[1095199948800,"S",4,16], [1098404364288,"L",3,32],[1165572172800,"U",4,7], [1169948144736,"L",3,37],[2317591180800,"L",4,7], [2660096970720,"U",3,41],[3057017889600,"S",4,19], [3509983020816,"U",3,37],[3893910661872,"L",3,43], [4106059776000,"S",6,4],[4329310519296,"G",2,8], [4952179814400,"O+",8,3],[7933578895872,"U",3,47], [7980059337600,"L",3,41],[10151968619520,"O-",8,3], [10461394944000,"A",16],[11072935641600,"L",3,49], [11682025843488,"U",3,43],[20560831566912,"3D",4,3], [20674026236160,"S",4,23],[20745981365616,"U",3,53], [22594320403200,"G",2,9],[23499295948800,"O+",10,2], [23800278205248,"L",3,47],[25015379558400,"O-",10,2], [33219371640000,"U",3,49],[34558531338240,"L",4,8], [34693789777920,"U",4,8],[35115786567680,"Sz",512], [42305421312000,"Spor","Co(2)"],[47607300000000,"S",4,25], [48929657263200,"U",3,59],[50759843097600,"L",4,9], [53443952640000,"U",5,4],[62237108003616,"L",3,53], [63884982751200,"L",3,61],[64561751654400,"Spor","Fi(22)"], [93801727918080,"L",3,64],[101798586432000,"U",4,9], [102804157834560,"S",4,27],[135325289783376,"L",3,67], [146787542351760,"L",3,59],[163849992929280,"L",7,2], [177843714048000,"A",17],[191656636992240,"U",3,61], [210103196385600,"S",4,29],[215209078277760,"U",3,71], [227787103272960,"U",7,2],[228501000000000,"S",6,5],[228501000000000,"O",7,5], [258492255436800,"L",5,4],[268768894995072,"L",3,73], [273030912000000,"Spor","HN"],[281407330713600,"U",3,64], [376611192619200,"G",2,11],[405978568998816,"U",3,67], [409387254681600,"S",4,31],[505620881962560,"L",3,79], [645623627090400,"L",3,71],[750656410078176,"U",3,83], [806310830350368,"U",3,73],[1036388695478400,"U",4,11], [1124799322521600,"S",4,32],[1312032469255200,"U",3,89], [1516868799014400,"U",3,79],[1852734273062400,"L",3,81], [1852741245568320,"U",3,81],[2069665112592000,"L",4,11], [2251961353296816,"L",3,83],[2402534664555840,"S",4,37], [2612197345314816,"L",3,97],[3201186852864000,"A",18], [3311126603366400,"F",4,2],[3609172015066800,"U",3,101], [3914077489672896,"G",2,13],[3936086241056640,"L",3,89], [4222165056643872,"L",3,103],[5726791697419872,"U",3,107], [6641311310615520,"L",3,109],[6707334818822400,"S",4,41], [7836609208799616,"U",3,97],[8860792800073536,"U",3,113], [10799893897531200,"S",4,43],[10827495027060000,"L",3,101], [12666518353227648,"U",3,103],[12714519233969280,"L",4,13], [15315521833180800,"L",3,121],[17180347043675088,"L",3,107], [19866953531250000,"U",3,125],[19923964701735600,"U",3,109], [21032402889738240,"L",6,3],[22557001777261056,"L",3,127], [22837472432087040,"U",6,3],[24017743449686016,"U",3,128], [24815256521932800,"S",10,2],[25452197883665280,"U",4,13], [26287655087416320,"S",4,47],[26582341554402816,"L",3,113], [28908396044367840,"U",3,131],[36011213418659840,"Sz",2048], [39879509765760000,"S",4,49],[41363788790194272,"U",3,137], [45946617370848480,"U",3,121],[46448800925370480,"L",3,139], [49825657439340552,"R",243], [51765179004000000,"Spor","Ly"],[56653740000000000,"L",5,5], [57604365000000000,"U",5,5],[59600799562500000,"L",3,125], [60822550204416000,"A",19],[65784756654489600,"S",8,3],[65784756654489600,"O",9,3], [67010895544320000,"O+",8,4],[67536471195648000,"O-",8,4], [67671071404425216,"U",3,127],[67802350642790400,"3D",4,4], [71776114783027200,"G",2,16],[72053161633775616,"L",3,128], [80974721219670000,"U",3,149],[86725110978620400,"L",3,131], [87412594259315520,"S",4,53],[90089701905420000,"L",3,151], [90745943887872000,"Spor","Th"], [123043374372144096,"L",3,157],[124091269852276608,"L",3,137], [139346506548429600,"U",3,139],[166097514629752272,"L",3,163], [167795197370551296,"G",2,17],[201648518295622272,"U",3,167], [221797724414797440,"L",3,169],[242924016786074400,"L",3,149], [255484940347310400,"S",4,59],[267444174893824656,"U",3,173], [270269262714825600,"U",3,151],[273457218604953600,"S",6,7], [273457218604953600,"O",7,7],[351309192845176800,"U",3,179], [356575576421678400,"S",4,61],[369130313886677616,"U",3,157], [383967100578952800,"L",3,181],[498292774007829408,"U",3,163], [590382996204625920,"U",3,191],[604945295112210528,"L",3,167], [641690334200143872,"L",3,193],[665393448951722400,"U",3,169], [712975930219192320,"L",4,17],[756131656307437872,"U",3,197], [796793353927300800,"G",2,19],[802332214764045216,"L",3,173], [819770591880266400,"L",3,199],[911215823217986880,"S",4,67]]); # call atlasrep, possibly with extra parameters, but only if atlasrep is available BindGlobal("DoAtlasrepGroup",function(params) local g; if LoadPackage("atlasrep")<>true then Error("`atlasrep' package must be available to construct group ",params[1]); fi; g:=CallFuncList(ValueGlobal("AtlasGroup"),params); SetName(g,params[1]); return g; end); InstallGlobalFunction(SimpleGroup,function(arg) local brg,str,p,a,param,g,s,small; if IsRecord(arg[1]) then p:=arg[1]; if p.series="Spor" then brg:=p.parameter; else brg:=Concatenation([p.series],p.parameter); fi; else brg:=arg; fi; str:=brg[1]; # Case x(y gets replaced by x,y for x,y digits p:=Position(str,'('); if p>1 and pnot x in a)); # are there parameters in the string? # skip leading numbers for indicating 2/3 twist if Length(str)>1 then p:=PositionProperty(str{[2..Length(str)]}, x->x in CHARS_DIGITS or x in "+-"); if p<>fail then p:=p+1;fi; else p:=PositionProperty(str{[1..Length(str)]}, x->x in CHARS_DIGITS or x in "+-"); fi; param:=[]; if p<>fail then a:=str{[p..Length(str)]}; str:=str{[1..p-1]}; # special case `O+' or `O-' if Length(a)=1 and a[1] in "+-" then if a[1]='+' then param:=[1]; else param:=[-1]; fi; else p:=Position(a,','); while p<>fail do s:=a{[1..p-1]}; Add(param,Int(s)); a:=a{[p+1..Length(a)]}; p:=Position(a,','); od; Add(param,Int(a)); fi; fi; param:=Concatenation(param,brg{[2..Length(brg)]}); if ForAny(param,x->not IsInt(x)) then Error("parameters must be integral"); fi; # replace Lie names with classical/discoverer equivalents if possible # now parse the name. Is it sporadic, alternating, suzuki, or ree? if Length(param)<=1 then if str="A" or str="ALT" then if Length(param)=1 and param[1]>4 then g:=AlternatingGroup(param[1]); SetName(g,Concatenation("A",String(param[1]))); return g; else Error("Illegal Parameter for Alternating groups"); fi; elif (str="M" and Length(param)=0) or str="FG" then Error("Monster not yet supported"); elif (str="B" or str="BM") and Length(param)=0 then return DoAtlasrepGroup(["B"]); elif str="M" or str="MATHIEU" then if Length(param)=1 and param[1] in [11,12,22,23,24] then g:=MathieuGroup(param[1]); SetName(g,Concatenation("M",String(param[1]))); return g; else Error("Illegal Parameter for Mathieu groups"); fi; elif str="J" or str="JANKO" then if Length(param)=1 and param[1] in [1..4] then if param[1]=1 then g:=PrimitiveGroup(266,1); elif param[1]=2 then g:=PrimitiveGroup(100,1); else g:=[,,"J3","J4"]; g:=DoAtlasrepGroup([g[param[1]]]); fi; return g; else Error("Illegal Parameter for Janko groups"); fi; elif str="CO" or str="." or str="CONWAY" then if Length(param)=1 and param[1] in [1..3] then if param[1]=3 then g:=PrimitiveGroup(276,3); elif param[1]=2 then g:=PrimitiveGroup(2300,1); else g:=DoAtlasrepGroup(["Co1"]); fi; return g; else Error("Illegal Parameter for Conway groups"); fi; elif str="FI" or str="FISCHER" then if Length(param)=1 and param[1] in [22,23,24] then s:=Concatenation("Fi",String(param[1])); if param[1] = 24 then Append(s,"'"); fi; g:=DoAtlasrepGroup([s]); return g; else Error("Illegal Parameter for Fischer groups"); fi; elif str="SUZ" or str="SZ" or str="SUZUKI" then if Length(param)=0 and str="SUZ" then return PrimitiveGroup(1782,1); elif Length(param)=1 and param[1]>7 and Set(Factors(param[1]))=[2] and IsOddInt(LogInt(param[1],2)) then g:=SuzukiGroup(IsPermGroup,param[1]); SetName(g,Concatenation("Sz(",String(param[1]),")")); return g; else Error("Illegal Parameter for Suzuki groups"); fi; elif str="R" or str="REE" or str="2G" then if Length(param)=1 and param[1]>26 and Set(Factors(param[1]))=[3] and IsOddInt(LogInt(param[1],3)) then g:=ReeGroup(IsMatrixGroup,param[1]); SetName(g,Concatenation("Ree(",String(param[1]),")")); return g; else Error("Illegal Parameter for Ree groups"); fi; elif str="ON" then return DoAtlasrepGroup(["ON"]); elif str="HE" then return PrimitiveGroup(2058,1); elif str="HS" then return PrimitiveGroup(100,3); elif str="HN" then return DoAtlasrepGroup(["HN"]); elif str="LY" then return DoAtlasrepGroup(["Ly"]); elif str="MC" or str="MCL" then return PrimitiveGroup(275,1); elif str="TH" then return DoAtlasrepGroup(["Th"]); elif str="RU" then return DoAtlasrepGroup(["Ru"]); elif str="B" then return DoAtlasrepGroup(["B"]); elif str="T" then return PrimitiveGroup(1600,20); fi; fi; # now the name is ``classical''. and the second parameter a prime power if not IsPrimePowerInt(param[Maximum(2,Length(param))]) then Error("field order must be a prime power"); fi; small:=false; s:=fail; if str="L" or str="SL" or str="PSL" then g:=PSL(param[1],param[2]); s:=Concatenation("PSL(",String(param[1]),",",String(param[2]),")"); elif str="U" or str="SU" or str="PSU" then g:=PSU(param[1],param[2]); s:=Concatenation("PSU(",String(param[1]),",",String(param[2]),")"); small:=true; elif str="S" or str="SP" or str="PSP" then g:=PSp(param[1],param[2]); s:=Concatenation("PSp(",String(param[1]),",",String(param[2]),")"); small:=true; elif str="O" or str="SO" or str="PSO" then if Length(param)=2 and IsOddInt(param[1]) then g:=SO(param[1],param[2]); g:=Action(g,NormedRowVectors(GF(param[2])^param[1]),OnLines); g:=DerivedSubgroup(g); s:=Concatenation("O(",String(param[1]),",",String(param[2]),")"); small:=true; elif Length(param)=3 and param[1]=1 and IsEvenInt(param[2]) then g:=SO(1,param[2],param[3]); g:=Action(g,NormedRowVectors(GF(param[3])^param[2]),OnLines); g:=DerivedSubgroup(g); s:=Concatenation("O+(",String(param[2]),",",String(param[3]),")"); small:=true; elif Length(param)=3 and param[1]=-1 and IsEvenInt(param[2]) then g:=SO(-1,param[2],param[3]); g:=Action(g,NormedRowVectors(GF(param[3])^param[2]),OnLines); g:=DerivedSubgroup(g); s:=Concatenation("O-(",String(param[2]),",",String(param[3]),")"); small:=true; else Error("wrong dimension/parity for O"); fi; elif str="E" then if Length(param)<2 or not param[1] in [6,7,8] then Error("E(n,q) needs n=6,7,8"); fi; s:=Concatenation("E",String(param[1]),"(",String(param[2]),")"); g:=DoAtlasrepGroup([s]); elif str="F" then if Length(param)>1 and param[1]<>4 then Error("F(n,q) needs n=4"); fi; a:=param[Length(param)]; if a=2 then g:=DoAtlasrepGroup(["F4(2)"]); else Error("Can't do yet"); fi; s:=Concatenation("F_4(",String(a),")"); elif str="G" then if Length(param)>1 and param[1]<>2 then Error("G(n,q) needs n=2"); fi; a:=param[Length(param)]; if a=2 then return SimpleGroup("U",3,3); elif a=3 then g:=PrimitiveGroup(351,7); elif a=4 then g:=PrimitiveGroup(416,7); elif a=5 then g:=DoAtlasrepGroup(["G2(5)"]); else Error("Can't do yet"); fi; s:=Concatenation("G_2(",String(a),")"); elif str="3D" then if Length(param)>1 and param[1]<>4 then Error("3D(n,q) needs n=4"); fi; a:=param[Length(param)]; if a=2 then g:=PrimitiveGroup(819,5); elif a=3 then g:=DoAtlasrepGroup(["3D4(3)"]); else Error("Can't do yet"); fi; s:=Concatenation("3D4(",String(a),")"); elif str="2E" then if Length(param)>1 and param[1]<>6 then Error("3D(n,q) needs n=4"); fi; a:=param[Length(param)]; s:=Concatenation("2E6(",String(a),")"); g:=DoAtlasrepGroup([s]); else Error("Can't handle type ",str); fi; if small then a:=ShallowCopy(Orbits(g,MovedPoints(g))); if Length(a)>1 then SortParallel(List(a,Length),a); a:=Action(g,a[1]); SetSize(a,Size(g)); g:=a; fi; a:=Blocks(g,MovedPoints(g)); if Length(a)>1 then a:=Action(g,a,OnSets); SetSize(a,Size(g)); g:=a; fi; SetIsSimpleGroup(g,true); fi; if s<>fail and not HasName(g) then SetName(g,s); fi; return g; end); BindGlobal("SizeL2Q",q->q*(q-1)*(q+1)*Gcd(2,q)/2); # deal with irregular order for L2(2^a) # return [usedegree, nexta, stackvalue] BindGlobal("NextL2Q",function(a,stack) local NextL2PrimePowerInt; NextL2PrimePowerInt:=function(a) repeat a:=a+1; # L2(q) for q=4,5,9 duplicates others until IsPrimePowerInt(a) and not a in [4,5,9]; return a; end; a:=NextL2PrimePowerInt(a); if stack<>fail then if SizeL2Q(stack)SizeL2Q(NextL2PrimePowerInt(a)) then stack:=a; a:=NextL2PrimePowerInt(a); return [a,a,stack]; else return [a,a,fail]; fi; end); BindGlobal("NextIterator_SimGp",function(it) local a,l,pos,g; if it!.done then return fail;fi; a:=it!.b; if a>1259903 then # 1259903 is the last prime power whose L2 order is <10^18 Error("List of simple groups is only available up to order 10^18"); fi; l:=SizeL2Q(a); pos:=it!.pos; if la[1] then Error("order inconsistency"); fi; fi; #Print("pos=",it!.pos," b=",it!.b,"\n"); it!.done:=SIMPLEGPSNONL2[it!.pos][1]>it!.ende and (SizeL2Q(it!.b)>it!.ende or it!.nopsl2); return g; end); BindGlobal("IsDoneIterator_SimGp",function(it) return it!.done; end); InstallGlobalFunction(SimpleGroupsIterator,function(arg) local a,b,stack,ende,start,pos,nopsl2; ende:=infinity; if Length(arg)=0 then start:=60; else start:=Maximum(60,arg[1]); if Length(arg)>1 then ende:=arg[2]; fi; fi; nopsl2:=ValueOption("NOPSL2")=true or ValueOption("nopsl2")=true; # find relevant L2 order a:=RootInt(start,3)-1; stack:=fail; repeat a:=NextL2Q(a,stack); b:=a[1]; stack:=a[3]; a:=a[2]; until SizeL2Q(b)>=start; pos:=First([1..Length(SIMPLEGPSNONL2)],x->SIMPLEGPSNONL2[x][1]>=start); return IteratorByFunctions(rec( IsDoneIterator:=IsDoneIterator_SimGp, NextIterator:=NextIterator_SimGp, ShallowCopy:=ShallowCopy, a:=a, b:=b, ende:=ende, stack:=stack, pos:=pos, nopsl2:=nopsl2, # if nopsl2 then the l2size is irrelevant done:=(SizeL2Q(b)>ende or nopsl2) and SIMPLEGPSNONL2[pos][1]>ende )); end); InstallGlobalFunction(ClassicalIsomorphismTypeFiniteSimpleGroup,function(G) local t,r; t:=IsomorphismTypeInfoFiniteSimpleGroup(G); r:=rec(); if t.series in ["Z","A"] then r.series:=t.series; r.parameter:=[t.parameter]; elif t.series in ["L","E"] then r.series:=t.series; r.parameter:=t.parameter; elif t.series="Spor" then r.series:=t.series; # stupid naming of J2 if Length(t.name)>5 and t.name{[1..5]}="HJ = " then r.parameter:=["J2"]; else r.parameter:=[t.name]; fi; elif t.series="B" then r.series:="O"; r.parameter:=[t.parameter[1]*2+1,t.parameter[2]]; elif t.series="C" then r.series:="S"; r.parameter:=[t.parameter[1]*2,t.parameter[2]]; elif t.series="D" then r.series:="O+"; r.parameter:=[t.parameter[1]*2,t.parameter[2]]; elif t.series="F" then r.series:="F"; r.parameter:=[4,t.parameter]; elif t.series="G" then r.series:="G"; r.parameter:=[2,t.parameter]; elif t.series="2A" then r.series:="U"; r.parameter:=[t.parameter[1]+1,t.parameter[2]]; elif t.series="2B" then r.series:="Sz"; r.parameter:=[t.parameter]; elif t.series="2D" then r.series:="O-"; r.parameter:=[t.parameter[1]*2,t.parameter[2]]; elif t.series="3D" then r.series:="3D"; r.parameter:=[4,t.parameter]; elif t.series="2E" then r.series:="2E"; r.parameter:=[6,t.parameter]; elif t.series="2F" then if t.parameter=2 then r.series:="Spor"; r.parameter:="T"; else r.series:="2F"; r.parameter:=[t.parameter]; fi; elif t.series="2G" then r.series:="2G"; r.parameter:=[t.parameter]; fi; return r; end); gap-4r6p5/grp/basicfp.gi0000644000175000017500000001056412172557252013667 0ustar billbill############################################################################# ## #W basicfp.gi GAP Library Alexander Hulpke ## #Y Copyright (C) 2009, The GAP group ## ## This file contains the methods for the construction of the basic fp group ## types. ## ############################################################################# ## #M AbelianGroupCons( , ) ## InstallMethod( AbelianGroupCons, "fp group", true, [ IsFpGroup and IsFinite, IsList ], 0, function( filter, ints ) local f,g,i,j,rels,gfam,fam; if Length(ints)=0 or not ForAll( ints, IsInt ) then Error( " must be a list of integers" ); fi; f := FreeGroup(IsSyllableWordsFamily, Length(ints)); g := GeneratorsOfGroup(f); rels:=[]; for i in [1..Length(ints)] do for j in [1..i-1] do Add(rels,Comm(g[i],g[j])); od; if ints[i]<>0 then Add(rels,g[i]^ints[i]); fi; od; g:=f/rels; if ForAll(ints,IsPosInt) then SetSize( g, Product(ints) ); fi; fam:=FamilyObj(One(f)); gfam:=FamilyObj(One(g)); gfam!.redorders:=ints; SetFpElementNFFunction(gfam,function(x) local u,e,i,j,n; u:=UnderlyingElement(x); e:=ExtRepOfObj(u); # syllable form # bring in correct order and reduction n:=ListWithIdenticalEntries(Length(gfam!.redorders),0); for i in [1,3..Length(e)-1] do j:=e[i]; if gfam!.redorders[j]0 then Add(e,i); Add(e,n[i]); fi; od; return ObjByExtRep(fam,e); end); SetReducedMultiplication(g); SetIsAbelian( g, true ); return g; end ); ############################################################################# ## #M CyclicGroupCons( , ) ## InstallOtherMethod( CyclicGroupCons, "fp group", true, [ IsFpGroup,IsObject ], 0, function( filter, n ) local f,g,fam,gfam; if n=infinity then return FreeGroup("a"); elif not IsPosInt(n) then TryNextMethod(); fi; f:=FreeGroup( IsSyllableWordsFamily, "a" ); g:=f/[f.1^n]; SetSize(g,n); fam:=FamilyObj(One(f)); gfam:=FamilyObj(One(g)); SetFpElementNFFunction(gfam,function(x) local u,e; u:=UnderlyingElement(x); e:=ExtRepOfObj(u); # syllable form if Length(e)=0 or (e[2]>=0 and e[2], ) ## InstallMethod( DihedralGroupCons, "fp group", true, [ IsFpGroup and IsFinite, IsInt and IsPosRat ], 0, function( filter, n ) local f,rels,g; if n mod 2 = 1 then TryNextMethod(); elif n = 2 then return CyclicGroup( IsFpGroup, 2 ); fi; f := FreeGroup( IsSyllableWordsFamily, "r", "s" ); rels:= [f.1^(n/2),f.2^2,f.1^f.2*f.1]; g := f/rels; SetReducedMultiplication(g); SetSize(g,n); return g; end ); ############################################################################# ## #M QuaternionGroupCons( , ) ## InstallMethod( QuaternionGroupCons, "fp group", true, [ IsFpGroup and IsFinite, IsInt and IsPosRat ], 0, function( filter, n ) local f,rels,g; if 0 <> n mod 4 then TryNextMethod(); elif n = 4 then return CyclicGroup( IsFpGroup, 4 ); fi; f := FreeGroup( IsSyllableWordsFamily, "r", "s" ); rels:= [ f.1^2/f.2^(n/4), f.2^(n/2), f.2^f.1*f.2 ]; g := f/rels; SetSize(g,n); if n <= 10^4 then SetReducedMultiplication(g); fi; return g; end ); ############################################################################# ## #M ElementaryAbelianGroupCons( , ) ## InstallMethod( ElementaryAbelianGroupCons, "fp group", true, [ IsFpGroup and IsFinite, IsInt and IsPosRat ], 0, function( filter, n ) if n = 1 then return CyclicGroupCons( IsFpGroup, 1 ); elif not IsPrimePowerInt(n) then Error( " must be a prime power" ); fi; n:= AbelianGroupCons( IsFpGroup, Factors(n) ); SetIsElementaryAbelian( n, true ); return n; end ); gap-4r6p5/grp/suzuki.gd0000644000175000017500000000336112172557252013602 0ustar billbill############################################################################# ## #W suzuki.gd GAP library Stefan Kohl ## ## #Y (C) 1999 School Math and Comp. Sci., University of St Andrews, Scotland ## ############################################################################# ## #O SuzukiGroupCons( , ) ## ## ## ## ## ## ## ## DeclareConstructor( "SuzukiGroupCons", [ IsGroup, IsInt ] ); ############################################################################# ## #F SuzukiGroup( [, ] ) . . . . . . . . . . . . . . . Suzuki group #F Sz( [, ] ) ## ## <#GAPDoc Label="SuzukiGroup"> ## ## ## ## ## ## Constructs a group isomorphic to the Suzuki group Sz( q ) ## over the field with q elements, where q is a non-square ## power of 2. ##

## If filt is not given it defaults to , ## and the returned group is the Suzuki group itself. ## SuzukiGroup( 32 ); ## Sz(32) ## ]]> ## ## ## <#/GAPDoc> ## BindGlobal( "SuzukiGroup", function ( arg ) if Length(arg) = 1 then return SuzukiGroupCons( IsMatrixGroup, arg[1] ); elif IsOperation(arg[1]) then if Length(arg) = 2 then return SuzukiGroupCons( arg[1], arg[2] ); fi; fi; Error( "usage: SuzukiGroup( [, ] )" ); end ); DeclareSynonym( "Sz", SuzukiGroup ); ############################################################################# ## #E gap-4r6p5/grp/imf12.grp0000644000175000017500000005745612172557252013402 0ustar billbill############################################################################# ## #A imf12.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Q-class representative of the irreducible ## maximal finite integral matrix groups of dimension 12, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Q-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 12. ## IMFList[12].matrices := [ [ # Q-class [12][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1]], [[[0,-1,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1]], [[0,1,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [12][02] [[2], [0,2], [-1,1,2], [-1,1,1,2], [0,0,0,0,2], [0,0,0,0,0,2], [0,0,0,0,-1,1,2], [0,0,0,0,-1,1,1,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,-1,1,2], [0,0,0,0,0,0,0,0,-1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1,-1,0], [0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,-1,1,-1,-1], [1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0]], [[-1,0,0,-1,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [12][03] [[2], [-1,2], [0,-1,2], [0,0,-1,2], [0,0,0,-1,2], [0,0,-1,0,0,2], [0,0,0,0,0,0,2], [0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,-1,0,0,2]], [[[0,0,0,0,0,1,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0], [1,2,2,1,0,1,0,0,0,0,0,0], [0,-1,-2,-2,-1,-1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,-2,-3,-2,-1,-1,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,1,0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0]]]], [ # Q-class [12][04] [[2], [1,2], [0,0,2], [0,0,1,2], [0,0,0,0,2], [0,0,0,0,1,2], [0,0,0,0,0,0,2], [0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,1,2]], [[[0,0,0,1,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1]], [[0,1,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [12][05] [[4], [0,4], [1,0,4], [-2,2,1,4], [0,1,-2,-1,4], [-2,1,-2,1,2,4], [0,-2,0,-2,0,-1,4], [1,-2,2,-1,-2,-2,2,4], [-2,0,0,2,0,2,-2,-1,4], [1,0,0,0,-2,-2,0,1,-2,4], [0,2,1,2,-1,-1,-2,0,0,2,4], [-2,0,-2,0,2,2,0,-1,2,-2,-1,4]], [[[0,0,0,0,0,0,0,0,0,0,0,1], [0,0,-1,1,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,-1,0,0,1], [0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,-1,0,1,-1,0,-1,1,0], [-1,0,0,0,0,0,0,0,0,0,0,-1], [0,0,1,0,1,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,1,0,0,0,0], [0,0,0,0,-1,1,0,0,-1,0,0,0], [0,0,0,0,1,-1,0,0,1,1,-1,0], [0,0,-1,0,0,-1,0,0,0,0,0,0], [1,-1,0,1,-1,1,1,-1,-1,-1,1,0]], [[-2,1,0,-1,1,-1,-1,1,1,1,-1,-1], [0,1,0,0,0,0,1,0,1,0,0,0], [-1,1,0,-1,1,-1,-1,1,1,0,-1,-1], [1,1,0,0,0,0,1,0,1,0,0,0], [0,0,0,0,-1,1,0,0,-1,0,0,1], [1,0,0,0,-2,1,1,-1,-1,-1,1,1], [0,-1,0,1,0,0,-1,0,-1,0,-1,0], [-1,0,0,0,1,-1,-1,1,0,0,-1,-1], [1,0,1,-1,-1,1,1,-1,0,0,1,1], [0,0,-1,1,1,-1,0,1,1,0,0,-1], [0,1,-1,0,1,-1,1,1,2,0,0,-1], [1,-1,1,0,-1,2,1,-1,-1,0,1,1]]]], [ # Q-class [12][06] [[4], [2,4], [-1,1,4], [-1,0,0,4], [0,0,0,-1,4], [-1,0,2,1,1,4], [-1,-1,0,0,2,2,4], [1,0,0,1,1,1,0,4], [2,1,1,0,-1,0,-1,1,4], [-1,-1,0,1,0,1,0,1,0,4], [0,-1,-1,2,1,1,1,2,1,2,4], [0,0,0,-1,0,-1,0,-1,1,2,1,4]], [[[0,0,1,-1,0,-1,0,-1,0,1,1,-2], [0,0,0,0,0,0,0,-1,0,1,0,-1], [0,0,-1,0,0,1,0,0,0,0,0,0], [0,0,-1,1,1,1,0,0,1,0,-2,1], [-1,1,0,-1,-1,-1,1,0,0,0,1,-1], [0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,-1,1,0,0,0,0,0], [0,1,1,-2,-1,-1,1,-1,0,1,2,-2], [0,0,0,-1,0,0,0,0,0,1,0,-1], [-1,1,0,-1,0,0,0,0,0,0,1,0], [-1,1,0,-1,0,-1,1,0,1,1,0,-1], [-1,1,0,-1,0,-1,0,0,0,1,1,-1]], [[1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,-1,0,-1,-1,0,1], [-1,1,0,-1,-1,-1,1,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,-1,0,0,0], [-1,0,-1,0,1,0,0,0,1,0,-1,0], [0,0,0,0,0,-1,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0], [-1,1,0,-1,0,-1,1,-1,1,1,1,-2], [1,-1,0,2,1,0,0,0,0,0,-2,1], [0,0,1,0,0,-1,1,0,0,0,0,0], [0,0,1,0,0,-2,1,0,0,1,0,-1], [1,0,1,0,0,-1,1,-1,0,1,1,-1], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,-1,0,1,0,0,0,0,0], [0,0,0,0,0,-1,1,-1,1,1,0,-1], [0,0,0,0,-1,0,0,0,0,0,0,0]]]], [ # Q-class [12][07] [[3], [1,3], [0,1,3], [-1,1,1,3], [1,0,1,-1,3], [-1,-1,1,0,1,3], [0,0,0,0,0,0,3], [0,0,0,0,0,0,1,3], [0,0,0,0,0,0,0,1,3], [0,0,0,0,0,0,-1,1,1,3], [0,0,0,0,0,0,1,0,1,-1,3], [0,0,0,0,0,0,-1,-1,1,0,1,3]], [[[0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0], [0,0,-1,1,1,0,0,0,0,0,0,0], [-1,0,0,0,1,-1,0,0,0,0,0,0], [0,1,-1,0,0,1,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0], [0,1,-1,0,0,1,0,0,0,0,0,0], [-1,1,0,-1,0,0,0,0,0,0,0,0], [1,0,0,0,-1,1,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0]]]], [ # Q-class [12][08] [[2], [1,2], [1,1,2], [1,1,1,2], [0,0,0,0,2], [0,0,0,0,1,2], [0,0,0,0,1,1,2], [0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,-1,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0]], [[-1,0,1,0,0,0,0,0,0,0,0,0], [0,0,1,-1,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0], [0,-1,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [12][09] [[4], [-2,4], [0,-1,4], [0,1,-2,4], [-2,0,-1,0,4], [0,0,0,-2,-1,4], [0,-2,1,0,1,-2,4], [2,0,1,-1,-1,0,0,4], [-1,1,0,0,2,0,0,1,4], [1,-1,2,0,0,-1,1,2,2,4], [-1,0,1,1,1,-2,2,0,1,2,4], [0,0,0,0,1,0,1,2,2,2,2,4]], [[[0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,1,0,0,-1,0,0,0,-1,-1,1], [0,1,-1,0,1,1,1,0,-1,2,0,-1], [-1,-1,0,1,0,1,0,1,0,0,0,-1], [0,0,0,-1,-1,-1,-1,-1,0,0,0,1], [1,1,1,1,1,1,1,0,0,0,-1,0], [0,0,1,1,0,0,0,0,0,-1,0,1], [0,0,1,1,1,1,0,0,-1,0,0,0], [0,0,1,1,1,0,0,0,-1,0,-1,1], [0,0,1,1,1,0,0,0,0,0,-1,0], [0,0,1,1,0,0,0,-1,0,0,-1,1]], [[-1,-2,0,0,-1,-1,-1,0,1,-1,0,0], [1,2,0,0,1,1,1,-1,-1,1,0,0], [-1,-1,0,1,0,1,0,2,0,-1,1,-1], [1,1,0,-1,0,-1,0,-1,0,0,0,0], [0,1,0,0,0,0,1,0,0,1,-1,0], [0,0,0,0,1,1,0,0,-1,1,0,0], [-1,-1,0,0,-1,-1,-1,1,1,-1,0,0], [-1,-1,0,0,-1,0,0,0,1,-1,0,0], [0,1,0,0,0,1,1,0,0,1,0,-1], [-1,-1,0,0,-1,0,0,1,1,-1,1,-1], [0,0,0,0,0,0,0,1,1,-1,1,-1], [0,0,1,0,0,0,0,0,1,-1,0,0]]]], [ # Q-class [12][10] [[4], [-1,4], [2,-1,4], [-1,2,-1,4], [-2,2,-1,1,4], [-1,1,1,0,1,4], [1,0,1,-1,0,1,4], [0,-1,-1,1,-1,-1,1,4], [0,0,1,2,0,1,-1,1,4], [-1,1,1,2,1,1,1,1,2,4], [-1,-1,0,-1,0,1,1,1,1,1,4], [1,0,1,1,-1,1,1,0,1,2,1,4]], [[[0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,1,-1,0,0,-1,0,0,1,-1], [-2,1,1,-1,0,-1,1,1,1,-2,-1,2], [0,0,0,0,0,0,0,0,1,-1,0,0], [1,-1,-1,2,-1,1,0,-1,-1,1,1,-2], [0,0,0,1,-1,0,1,-1,0,0,0,-1], [-2,0,1,0,0,-1,1,0,1,-1,-1,1], [-1,0,0,-1,1,-1,1,0,2,-1,-1,1], [0,0,0,0,0,0,1,0,1,-1,0,0], [-2,1,1,-1,0,-1,1,1,2,-2,-1,1], [-1,0,0,-1,0,0,1,0,1,0,-1,0], [-1,1,1,-1,0,0,0,1,1,-1,-1,1]], [[-3,1,2,-1,1,-2,1,1,2,-3,-1,2], [1,0,0,1,0,1,-1,0,-2,1,1,-1], [-2,0,1,0,0,-1,1,0,1,-1,-1,1], [1,0,0,0,0,1,-1,0,-1,1,0,-1], [1,0,0,1,-1,1,-1,0,-2,1,1,-1], [0,-1,0,1,0,1,0,0,-1,0,0,0], [-2,0,0,-1,0,-1,1,0,1,-1,-1,1], [0,0,-1,-1,0,0,0,0,1,0,-1,0], [1,-1,0,1,0,1,-1,0,-1,1,0,-1], [1,-1,-1,1,-1,1,0,-1,-1,2,0,-2], [2,-2,-2,2,-1,1,0,-2,-1,2,1,-2], [0,-1,0,1,0,0,1,-1,0,0,0,-1]]]], [ # Q-class [12][11] [[6], [2,6], [2,2,6], [-2,2,0,6], [-2,0,2,2,6], [0,-2,2,-2,2,6], [3,1,1,-1,-1,0,6], [1,3,1,1,0,-1,2,6], [1,1,3,0,1,1,2,2,6], [-1,1,0,3,1,-1,-2,2,0,6], [-1,0,1,1,3,1,-2,0,2,2,6], [0,-1,1,-1,1,3,0,-2,2,-2,2,6]], [[[0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,1,0,0,-1], [0,0,0,0,0,0,0,0,0,-1,1,-1], [0,0,0,0,0,0,1,0,-1,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,1,0,0,0], [0,0,0,0,-1,0,0,0,0,0,1,0], [0,1,-1,0,0,1,0,-1,1,0,0,-1], [0,0,0,1,-1,1,0,0,0,-1,1,-1], [-1,0,1,0,-1,0,1,0,-1,0,1,0]], [[1,-1,0,1,0,0,-1,1,0,-1,0,0], [0,0,0,1,0,0,0,0,0,-1,0,0], [0,0,0,1,-1,1,0,0,0,-1,1,-1], [0,1,0,0,0,0,0,-1,0,0,0,0], [0,1,-1,0,0,1,0,-1,1,0,0,-1], [0,0,0,0,0,1,0,0,0,0,0,-1], [0,0,0,0,0,0,-1,1,0,-1,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,-1,1,-1], [0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,-1,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,-1]], [[1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0], [-1,1,0,-1,0,0,0,0,0,0,0,0], [-1,0,1,0,-1,0,0,0,0,0,0,0], [0,-1,1,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,-1,1,0,-1,0,0], [0,0,0,0,0,0,-1,0,1,0,-1,0], [0,0,0,0,0,0,0,-1,1,0,0,-1]]]], [ # Q-class [12][12] [[8], [1,8], [2,0,8], [4,-1,-1,8], [0,2,2,-2,8], [3,-1,4,0,4,8], [-4,-3,-3,-3,-3,-4,8], [-3,3,2,-1,2,-2,-1,8], [-2,-2,3,-4,4,2,1,1,8], [-2,1,-4,-2,-2,-4,2,1,-2,8], [-3,-4,-4,1,0,-1,3,-1,1,2,8], [2,4,0,-2,4,1,-3,0,2,2,-2,8]], [[[0,0,0,0,0,0,0,0,0,0,0,1], [0,0,1,1,1,0,1,0,0,1,0,0], [1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,-1,-1,1,1], [0,0,1,0,1,-1,-1,-1,0,1,0,-1], [0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,-1,0,0,0,0,0,1,0,-1,-1], [0,1,1,1,1,0,1,-1,0,1,0,-1], [1,0,0,-1,0,-1,-1,0,0,0,0,-1], [-1,0,0,1,0,1,1,0,0,1,-1,0], [0,0,-1,-1,0,0,-1,0,0,0,0,-1], [0,0,1,0,0,0,0,0,0,1,0,0]], [[-1,-1,0,1,0,0,0,0,0,0,-1,1], [0,0,-1,1,0,1,0,0,1,1,-1,-1], [1,-1,-1,-1,-1,0,0,1,0,-1,0,1], [-1,0,0,1,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,-1,0,1], [0,0,1,-1,0,0,0,0,-1,0,1,0], [1,0,-1,0,0,1,1,1,0,0,0,0], [1,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,-1], [0,1,1,0,0,0,0,0,0,0,1,0], [0,0,0,1,1,0,0,-1,1,1,-1,-1]], [[1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,1,1,0,1,-1,1,1,-1,-1], [0,0,0,0,0,0,0,0,0,-1,0,0], [1,-1,0,-1,0,-1,-1,0,0,0,0,0], [-1,1,0,1,0,1,0,-1,1,1,-1,-1], [0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,-1,-1,0,0,1,-1,-1,1,1], [0,0,-1,0,0,0,0,0,1,0,-1,-1], [-1,1,0,1,-1,1,0,0,1,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,-1,-1,0,-1,0,0,0,1,0], [-1,1,0,2,0,1,1,-1,1,1,-1,0]]]], [ # Q-class [12][13] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [0,0,0,0,0,0,2], [0,0,0,0,0,0,1,2], [0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,1,1,1,1,1,2]], [[[0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,-1,1,0,0,0,0,0,0], [0,0,0,-1,0,1,0,0,0,0,0,0], [0,0,-1,0,0,1,0,0,0,0,0,0], [0,-1,0,0,0,1,0,0,0,0,0,0], [-1,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,1,-1,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,-1,1,0,0,0,0,0,0,0], [0,0,-1,0,1,0,0,0,0,0,0,0], [0,-1,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0]]]], [ # Q-class [12][14] [[4], [0,4], [2,-2,4], [2,1,1,4], [1,-1,1,2,4], [0,-1,2,1,2,4], [0,0,0,0,0,0,4], [0,0,0,0,0,0,0,4], [0,0,0,0,0,0,2,-2,4], [0,0,0,0,0,0,2,1,1,4], [0,0,0,0,0,0,1,-1,1,2,4], [0,0,0,0,0,0,0,-1,2,1,2,4]], [[[-1,0,1,0,0,-1,0,0,0,0,0,0], [0,0,0,0,1,-1,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,1,0,0,-1,0,0,0,0,0,0], [0,-1,0,1,-1,0,0,0,0,0,0,0], [0,0,0,1,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0], [1,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,1,-1,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0]]]], [ # Q-class [12][15] [[4], [-1,4], [-2,1,4], [0,-2,1,4], [1,2,0,-2,4], [0,-1,0,-1,0,4], [1,-1,1,2,0,-1,4], [0,0,1,0,0,1,0,4], [-1,1,0,-1,0,0,1,-1,4], [2,0,0,0,2,0,1,0,0,4], [-1,0,2,2,-1,0,2,0,1,1,4], [1,0,-1,-1,1,1,1,1,2,2,1,4]], [[[-1,0,-2,-1,0,0,1,1,0,1,1,-2], [1,-2,1,0,2,-1,-2,0,1,-1,1,0], [1,0,1,1,0,0,-1,0,1,0,-1,0], [0,1,0,0,-1,0,1,0,0,0,-1,0], [1,-2,0,0,2,-1,-2,1,1,-1,2,-1], [0,0,0,0,-1,0,0,0,0,1,0,0], [0,0,-1,0,0,0,0,1,1,0,0,-1], [0,0,0,0,0,0,0,1,1,1,0,-1], [1,-1,0,0,1,0,-1,0,1,-1,1,0], [0,-1,-1,0,1,0,0,1,1,0,1,-2], [0,0,0,1,0,0,0,0,1,0,-1,0], [0,-1,-1,0,1,0,0,1,1,0,1,-1]], [[-1,2,0,0,-2,1,2,-1,-1,1,-2,1], [0,-1,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,1,0,-1,1,1,-1,1,-1], [0,0,0,0,1,0,0,0,0,-1,0,0], [-1,1,-1,1,-1,1,1,0,0,1,-1,0], [0,0,0,0,0,0,0,1,1,1,0,-1], [0,1,-1,0,0,1,1,0,0,0,0,-1], [-1,1,0,0,-1,1,1,0,-1,1,-1,0], [1,-1,0,0,1,0,-1,0,1,0,1,-1], [-1,1,-1,0,-1,1,1,0,0,1,-1,0], [0,-1,-1,-1,1,0,0,1,1,0,1,-2], [-1,1,-1,0,-1,1,1,0,0,2,-1,-1]]]], [ # Q-class [12][16] [[8], [-2,8], [-4,4,8], [4,-2,-1,8], [-2,-3,1,-2,8], [-3,4,3,0,1,8], [1,3,3,3,-4,2,8], [3,-4,-3,0,0,-4,-3,8], [4,-1,0,0,0,-1,1,4,8], [-4,2,1,0,0,2,1,-2,-4,8], [4,-1,-4,4,-2,-1,-1,0,0,0,8], [4,-1,-4,3,-1,-2,-2,3,0,-1,4,8]], [[[0,-1,1,0,-1,0,-1,-1,1,1,0,1], [1,-1,1,-1,-1,1,0,1,-1,0,0,0], [-1,1,-1,0,1,0,2,2,-1,-1,1,-1], [0,0,0,0,0,0,0,0,0,0,1,0], [-2,2,-2,2,2,-1,1,1,0,-1,0,-1], [1,0,0,0,0,0,0,1,-1,0,0,-1], [0,0,0,-1,0,0,1,1,-1,0,1,0], [0,-1,0,0,-1,0,-1,-2,2,1,-1,1], [0,-2,1,-1,-1,0,0,-1,1,1,0,1], [0,1,-1,0,1,0,1,1,-1,-1,0,0], [2,-2,2,-1,-1,1,-1,-1,0,1,0,1], [1,-2,1,0,-2,1,-2,-2,1,1,-1,1]], [[0,-2,1,-1,-1,0,0,-1,1,1,0,1], [0,1,-1,0,1,0,1,0,0,0,0,0], [0,1,-1,1,0,0,-1,-1,1,0,-1,0], [0,-1,0,0,-1,0,-1,-1,1,1,-1,0], [-1,2,-1,2,1,-1,0,1,0,-1,0,-1], [-2,3,-2,2,2,-1,1,1,0,-1,0,-1], [-1,0,-1,0,0,0,0,-1,1,0,0,0], [0,-1,1,-1,-1,0,0,0,0,0,0,1], [-1,0,0,0,0,-1,0,-1,1,0,0,1], [0,1,-1,0,1,0,1,1,-1,-1,0,-1], [1,-1,1,-1,0,0,0,0,0,1,0,0], [1,-1,1,-1,-1,0,0,0,0,1,0,0]]]], [ # Q-class [12][17] [[4], [2,4], [2,1,4], [1,2,2,4], [2,1,2,1,4], [1,2,1,2,2,4], [2,1,2,1,2,1,4], [1,2,1,2,1,2,2,4], [2,1,2,1,2,1,2,1,4], [1,2,1,2,1,2,1,2,2,4], [2,1,2,1,2,1,2,1,2,1,4], [1,2,1,2,1,2,1,2,1,2,2,4]], [[[0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,-1,1,0,0], [0,0,0,0,0,0,0,0,0,1,0,-1], [0,0,0,0,0,0,0,0,-1,1,1,-1], [0,0,0,0,0,0,0,-1,0,1,0,0], [0,0,0,0,0,0,1,-1,-1,1,0,0], [0,0,0,0,0,-1,0,0,0,1,0,0], [0,0,0,0,1,-1,0,0,-1,1,0,0], [0,0,0,-1,0,0,0,0,0,1,0,0], [0,0,1,-1,0,0,0,0,-1,1,0,0], [0,-1,0,0,0,0,0,0,0,1,0,0], [1,-1,0,0,0,0,0,0,-1,1,0,0]], [[-1,0,0,0,0,0,0,0,0,0,1,0], [-1,1,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,-1,1,1,-1], [0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,-1,1,0,0,1,-1], [0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,-1,1,0,0,0,0,1,-1], [0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,-1,1,0,0,0,0,0,0,1,-1]], [[1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,0,0,0,0,0,0,0], [0,1,0,-1,0,0,0,0,0,0,0,0], [1,0,0,0,-1,0,0,0,0,0,0,0], [0,1,0,0,0,-1,0,0,0,0,0,0], [1,0,0,0,0,0,-1,0,0,0,0,0], [0,1,0,0,0,0,0,-1,0,0,0,0], [1,0,0,0,0,0,0,0,-1,0,0,0], [0,1,0,0,0,0,0,0,0,-1,0,0], [1,0,0,0,0,0,0,0,0,0,-1,0], [0,1,0,0,0,0,0,0,0,0,0,-1]]]], [ # Q-class [12][18] [[8], [4,8], [4,2,8], [2,4,4,8], [-2,-1,2,1,8], [-1,-2,1,2,4,8], [0,0,-2,-1,2,1,8], [0,0,-1,-2,1,2,4,8], [4,2,0,0,-4,-2,2,1,8], [2,4,0,0,-2,-4,1,2,4,8], [4,2,4,2,-2,-1,-4,-2,2,1,8], [2,4,2,4,-1,-2,-2,-4,1,2,4,8]], [[[0,0,0,1,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,0,0,0], [0,-1,0,1,0,0,0,0,0,1,0,0], [1,-1,-1,1,0,0,0,0,-1,1,0,0], [0,-1,0,0,0,0,0,1,0,0,0,1], [1,-1,0,0,0,0,-1,1,0,0,-1,1], [0,0,0,0,0,-1,0,1,0,-1,0,1], [0,0,0,0,1,-1,-1,1,1,-1,-1,1], [0,1,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,-1,0,1,0,0], [0,0,0,0,-1,1,1,-1,-1,1,0,0]], [[-1,0,0,0,0,0,0,0,0,0,1,0], [-1,1,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,1,-1,0,0], [-1,0,1,0,-1,0,1,0,0,0,0,0], [-1,1,1,-1,-1,1,1,-1,0,0,0,0], [-1,0,1,0,0,0,0,0,0,0,0,0], [-1,1,1,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0], [-1,0,1,0,-1,0,0,0,0,0,0,0], [0,-1,0,1,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,1,0,-1,0], [0,0,0,0,0,0,0,-1,0,1,0,-1], [1,0,0,0,0,0,0,0,0,0,-1,0], [0,1,0,0,0,0,0,0,0,0,0,-1], [1,0,0,0,0,0,0,0,-1,0,0,0], [0,1,0,0,0,0,0,0,0,-1,0,0]]]], [ # Q-class [12][19] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,1,0]]]] ]; MakeImmutable( IMFList[12].matrices ); gap-4r6p5/grp/imf21.grp0000644000175000017500000005667612172557252013405 0ustar billbill############################################################################# ## #A imf21.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Q-class representative of the irreducible ## maximal finite integral matrix groups of dimension 21, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Q-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 2.-i1 ## IMFList[21].matrices := [ [ # Q-class [21][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]], [[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [21][02] [[2], [-1,2], [0,-1,2], [0,0,-1,2], [0,0,0,-1,2], [0,0,0,0,-1,2], [0,0,-1,0,0,0,2], [0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,-1,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,-1,-2,-2,-2,-1,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,2,3,4,3,2,1,2,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,-2,-2,-1,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,-2,-3,-3,-2,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,2,2,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,2,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [21][03] [[3], [-1,3], [1,1,3], [-1,1,1,3], [1,-1,1,1,3], [-1,-1,-1,1,1,3], [1,1,1,0,0,-1,3], [-1,1,1,1,0,0,1,3], [1,0,1,1,1,0,1,1,3], [-1,0,0,1,1,1,-1,1,1,3], [1,-1,0,0,1,1,-1,-1,1,1,3], [-1,1,-1,0,-1,0,-1,-1,-1,0,0,3], [0,1,0,-1,-1,-1,1,0,-1,-1,-1,1,3], [0,-1,-1,-1,-1,0,-1,-1,-1,-1,0,1,1,3], [1,-1,0,-1,0,-1,1,0,0,-1,-1,-1,1,1,3], [1,0,1,-1,0,-1,1,1,1,0,0,-1,1,0,1,3], [0,1,1,0,-1,-1,0,0,0,0,0,1,1,1,0,1,3], [0,0,-1,-1,-1,-1,0,0,0,0,0,1,1,1,1,1,1,3], [1,0,0,-1,-1,-1,1,0,1,-1,0,0,1,1,1,1,1,1,3], [1,-1,0,-1,0,-1,0,0,1,0,0,-1,-1,0,1,1,0,1,1,3], [-1,0,-1,0,-1,1,-1,0,0,1,1,1,0,1,-1,0,1,1,0,0,3]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,-1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,1,0,0,0,0,-1,1], [1,0,0,0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,1,0,-1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,-1,1,0,1,-1,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,-1,-1,1,0,0,0,1,-1,1], [0,0,0,0,1,-1,0,0,-1,0,0,0,-1,-1,1,0,0,0,1,-1,1], [1,0,1,0,0,0,0,0,-1,1,-1,0,-1,0,0,0,-1,1,1,-1,1], [0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,-1,0,0,0,0], [-1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,1,-1,-1,1,1,0,-1,1,0,1], [0,1,0,0,1,0,0,0,-1,0,0,1,-1,0,1,1,-1,-1,1,0,1], [-1,0,1,0,0,0,1,-1,-1,1,0,1,-1,0,0,1,-1,0,1,0,0], [0,1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,1,0,-1,0,1,0,0,0,0,0,0,0,0,1,0], [1,0,0,1,0,0,1,0,-2,1,0,1,-1,0,0,1,-1,0,1,0,0]], [[-1,-1,0,-1,0,0,0,0,2,-1,0,0,1,-1,0,-1,1,0,-1,0,0], [1,1,0,0,0,1,0,-1,0,1,-1,-1,0,1,-1,0,0,1,0,0,-1], [0,-1,1,0,-1,1,1,-1,0,1,-1,0,0,0,-1,0,0,1,0,0,-1], [1,0,1,0,-1,1,0,0,0,1,-1,0,0,1,-1,0,-1,1,0,0,-1], [0,-1,1,0,-1,0,1,0,0,1,0,1,0,0,0,0,-1,0,0,0,0], [0,0,1,0,-1,0,0,0,0,1,0,0,0,1,0,0,-1,0,0,0,0], [0,0,0,-1,0,1,0,0,1,0,0,0,1,0,0,-1,1,0,-1,1,-1], [1,0,0,1,-1,1,0,0,-1,1,0,0,1,0,0,0,0,0,0,1,-1], [0,0,0,0,-1,1,0,0,1,0,0,0,1,0,0,0,0,0,-1,1,-1], [1,0,0,1,-1,0,0,0,-1,1,0,0,0,0,0,1,-1,0,0,0,0], [0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0,0], [0,1,-1,0,1,-1,0,0,0,0,0,-1,0,1,-1,0,0,0,0,0,0], [0,0,-1,0,1,-1,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0], [-1,0,-1,0,1,-1,0,1,0,-1,1,0,0,0,0,0,1,-1,0,0,0], [-1,-1,-1,0,1,-1,0,1,0,-1,1,1,0,-1,1,0,1,-1,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,-1,1,0,1,-1,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,-1,0,0,-1,0,1,0,0,0,-1], [0,1,-2,0,1,-1,-1,1,0,-1,1,0,0,-1,1,0,1,-1,0,0,0], [-1,0,-1,0,0,0,0,0,1,-1,1,0,1,0,0,0,1,-1,-1,1,-1], [-1,0,0,0,0,0,0,0,0,-1,1,0,0,-1,1,0,0,0,0,0,0], [0,1,0,0,0,0,-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [21][04] [[3], [1,3], [0,0,3], [0,0,0,3], [-1,-1,0,0,3], [-1,-1,0,1,1,3], [-1,-1,0,1,1,1,3], [-1,0,-1,0,0,0,0,3], [0,0,-1,0,-1,0,1,0,3], [0,0,0,0,0,0,-1,0,-1,3], [0,1,-1,0,0,0,-1,1,0,1,3], [-1,-1,0,0,0,0,1,0,0,0,-1,3], [0,-1,1,0,1,1,1,-1,0,1,0,1,3], [0,0,0,1,-1,0,-1,1,-1,1,0,0,-1,3], [1,1,1,0,-1,-1,-1,-1,-1,1,0,0,0,1,3], [0,0,1,0,1,0,0,0,-1,1,1,-1,1,-1,0,3], [-1,0,1,1,0,1,1,0,0,-1,-1,1,0,0,0,0,3], [1,0,0,0,0,0,-1,-1,-1,1,-1,0,0,1,1,-1,-1,3], [-1,-1,1,-1,0,0,1,0,1,-1,-1,1,1,-1,-1,0,1,-1,3], [0,0,1,0,-1,-1,0,0,0,0,-1,1,0,1,1,-1,0,1,1,3], [-1,-1,1,1,1,1,1,0,-1,1,-1,1,1,1,1,0,1,1,0,1,3]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,1,1,0,1,1,0,0,1,0,0,2,-2,1,0,1,-2,0,1,-1,1], [1,1,0,0,0,1,0,-1,0,0,0,1,-2,0,0,0,-2,-1,2,-1,2], [0,1,-1,-1,-1,0,-1,-1,0,-1,-1,0,1,1,-2,1,0,-1,-1,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [-1,0,0,-1,0,0,0,0,1,-1,0,0,1,1,0,1,1,1,-1,0,-1], [-1,0,0,0,-1,-1,0,0,-1,0,0,-1,1,-1,-1,-1,1,0,-1,0,0], [0,0,0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,1,1,-1,-1], [-1,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,1,1,-1,0,-1], [1,0,0,0,0,1,-1,0,0,0,0,1,-1,0,0,0,-1,-1,1,0,1], [0,0,0,0,0,0,-1,0,1,-1,0,1,0,1,0,1,-1,0,0,-1,1], [0,-1,0,0,0,-1,0,1,-1,1,0,-2,1,-2,0,-2,2,0,-1,1,-1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,-1,0,-1,0,0,1], [1,0,0,0,0,1,0,0,0,1,0,0,-1,0,0,0,0,0,1,0,0], [1,0,0,0,0,1,0,0,-1,1,0,0,-1,-1,0,-1,-1,-1,1,0,1], [0,1,-1,0,-1,0,-1,-1,0,-2,0,1,0,1,-1,1,-2,-1,1,-1,3], [0,1,-1,-1,0,0,0,-1,0,-1,0,0,0,1,-1,1,0,0,0,0,1], [1,-1,1,0,1,1,1,1,0,2,0,0,-1,-1,1,-1,1,0,0,1,-2], [0,0,0,1,1,0,0,0,0,1,0,0,-1,-1,1,-1,0,0,1,0,-1], [1,-1,1,1,1,0,1,1,-1,3,0,-1,-1,-2,1,-3,1,0,1,0,-2], [1,0,0,0,0,1,0,0,-1,1,0,0,-1,-1,0,-1,0,-1,1,0,0]], [[-1,-1,-1,-1,-1,-2,0,0,-1,-1,0,-2,3,0,-1,-1,2,0,-2,1,0], [-1,-3,1,0,0,-2,2,2,-1,2,1,-3,2,-2,1,-3,4,2,-2,1,-4], [0,0,0,0,0,0,0,-1,1,-1,1,1,-1,1,0,1,-1,1,1,-1,1], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,-1], [1,1,1,1,1,2,-1,0,1,0,-1,2,-3,0,1,1,-3,-1,2,-1,1], [1,1,0,0,1,1,0,-1,1,0,0,1,-2,1,0,1,-1,-1,1,0,1], [1,1,0,1,1,2,-1,0,1,0,-1,2,-2,0,1,1,-2,-1,1,0,0], [0,0,0,1,1,1,0,1,0,1,-1,0,0,0,2,0,0,0,1,0,-2], [1,0,0,0,1,1,0,0,0,1,0,1,-1,0,0,0,0,-1,0,1,-1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [-1,-1,1,0,1,-1,1,1,0,1,0,-1,1,0,1,-1,2,1,-1,0,-3], [1,1,0,0,0,1,0,0,0,0,0,1,-1,0,0,0,-1,0,1,-1,1], [1,1,0,0,1,1,-1,-1,1,-1,0,2,-2,1,0,1,-2,-1,1,-1,2], [-1,0,-1,-1,-1,-1,1,0,0,-1,0,-1,2,1,0,1,1,1,-1,0,0], [-1,-1,0,-1,-1,-2,1,0,0,-1,1,-1,2,0,-1,0,2,2,-2,0,0], [0,0,1,1,1,0,-1,0,1,0,0,1,-1,0,1,0,-1,0,1,-1,0], [1,0,1,0,1,1,1,0,1,1,1,1,-2,0,1,0,0,1,1,0,-1], [0,0,-1,-1,-2,-1,0,-1,-1,-1,0,-1,1,0,-2,0,0,-1,-1,0,3], [1,1,0,0,1,2,-1,-1,1,0,0,2,-2,1,0,1,-2,-1,1,0,1], [0,0,-1,-1,-1,0,0,-1,0,-1,0,0,1,1,-1,1,0,0,-1,0,1], [1,1,0,0,0,1,0,-1,1,-1,0,2,-2,1,0,2,-2,0,1,-1,2]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0], [1,0,1,1,1,1,0,1,1,1,0,1,-2,-1,1,0,-1,0,1,0,0], [-1,-1,0,1,0,-1,1,1,-1,1,0,-1,1,-1,1,-1,1,1,0,0,-2], [0,0,0,1,1,1,-1,0,1,0,0,1,-1,0,1,1,-1,0,1,0,0], [0,-1,1,1,0,0,1,1,0,1,1,0,-1,-1,1,-1,0,1,1,-1,-1], [-1,0,0,-1,0,-1,0,0,1,-1,0,0,1,1,-1,1,1,1,-2,0,0], [1,0,1,0,0,1,0,0,0,0,1,1,-2,0,0,0,-1,0,1,-1,1], [-1,0,-1,-1,-1,-1,0,-1,0,-2,0,-1,2,1,-1,1,1,0,-2,1,1], [0,1,0,-1,0,0,0,-1,1,-1,0,1,0,2,-1,2,0,0,-1,0,1], [0,-1,1,0,0,0,1,0,0,1,1,0,-1,-1,0,-1,1,1,0,0,-1], [0,-1,0,0,0,0,1,0,0,0,1,0,0,0,1,0,1,1,0,0,-1], [0,0,0,0,1,0,-1,0,1,0,-1,0,0,0,0,0,0,-1,-1,1,0], [0,0,0,0,0,-1,0,0,0,0,0,-1,1,0,0,-1,1,0,0,0,0], [-1,0,-1,-1,-1,-1,1,0,0,-1,0,-1,2,1,0,1,1,1,-1,0,0], [0,0,1,1,1,1,0,1,1,1,0,1,-2,-1,2,0,-1,1,2,-1,-1], [0,0,-1,1,0,0,-1,0,-1,0,-1,-1,1,-1,0,-1,0,-1,0,1,0], [0,0,0,0,0,1,0,0,0,0,0,1,-1,0,1,0,-1,0,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [-1,-1,0,1,0,-1,0,1,0,0,0,-1,1,-1,1,-1,1,1,0,0,-1]]]], [ # Q-class [21][05] [[4], [2,4], [1,1,4], [1,1,1,4], [2,1,1,1,4], [1,2,1,2,1,4], [2,1,2,1,2,1,4], [2,1,1,1,2,1,2,4], [2,2,1,2,1,1,1,1,4], [1,1,2,1,2,2,1,1,1,4], [1,2,1,1,2,2,1,1,1,1,4], [1,1,2,2,1,1,1,2,1,2,1,4], [2,2,2,1,1,1,1,1,2,2,1,2,4], [2,1,1,1,1,2,1,1,1,2,1,1,1,4], [1,2,2,1,1,2,2,1,1,1,2,1,1,1,4], [1,1,2,2,1,2,1,1,1,1,1,1,1,1,1,4], [2,1,1,2,1,1,1,1,1,1,1,2,1,2,2,1,4], [2,1,1,1,1,1,1,1,1,1,2,1,1,2,1,1,2,4], [2,1,1,2,2,2,2,2,1,1,1,1,1,1,1,2,1,1,4], [2,2,1,1,1,1,1,1,2,1,1,1,2,1,1,2,1,1,1,4], [2,1,-1,0,1,0,1,1,1,0,0,0,1,0,0,-1,0,0,1,1,4]], [[[-1,0,1,0,1,1,0,0,0,-1,0,0,0,0,-1,-1,1,0,0,1,0], [-1,0,1,0,0,1,0,0,0,-1,0,0,0,0,-1,-1,1,0,0,1,0], [1,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,-1,-1,0,0,1,-1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [-1,0,1,0,1,1,0,0,0,-1,0,-1,0,0,-1,-1,1,0,0,1,0], [0,-1,1,0,0,1,0,0,0,-1,0,0,0,0,0,-1,0,0,0,1,0], [-1,0,1,0,1,1,0,0,0,-1,0,0,0,0,-1,-1,0,0,0,1,0], [-1,0,1,-1,1,1,0,0,0,-1,0,0,0,0,-1,-1,1,0,0,1,0], [-1,0,1,0,1,1,0,0,0,-1,-1,0,0,0,-1,-1,1,0,0,1,0], [0,0,1,1,0,0,0,0,-1,0,0,-1,0,0,0,-1,0,0,0,1,0], [-1,0,1,0,0,1,0,1,0,-1,0,-1,0,0,-1,-1,1,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0,0,1,0], [-1,0,1,0,1,1,0,0,0,-1,-1,0,0,0,0,-1,0,1,0,1,0], [0,0,1,0,0,1,0,0,0,-1,0,0,0,0,-1,-1,0,0,0,1,0], [1,-1,0,0,0,1,0,0,0,0,0,0,0,-1,0,-1,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [-1,0,1,0,0,1,0,1,0,0,0,-1,0,0,-1,-1,1,0,0,1,0], [0,-1,1,0,1,1,-1,0,0,-1,0,0,0,0,0,-1,0,0,0,1,0], [0,0,1,0,0,1,0,0,0,0,0,0,-1,-1,-1,-1,1,0,0,1,0], [-1,0,1,0,1,1,0,0,0,-1,0,0,0,0,-1,0,1,0,-1,0,1]], [[1,0,-1,0,0,-1,0,-1,0,0,0,1,0,0,1,1,-1,0,0,-1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,-1,-1,0,0,0,0,-1,0,0,0,1,0,0,1,0,-1,0,0,0,-1], [0,0,-1,-1,0,0,1,-1,0,0,0,1,0,0,0,1,0,0,0,0,0], [1,0,-1,0,0,-1,0,-1,0,1,0,1,0,0,1,1,-1,0,0,-1,0], [0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,-1,0,-1,0,0,0,1,0,1,1,1,-1,0,0,-1,0], [1,0,-1,0,0,0,0,-1,0,0,0,1,0,0,1,1,-1,0,0,-1,0], [0,0,0,-1,1,1,0,-1,0,-1,-1,1,0,0,0,0,0,0,0,0,0], [1,-1,0,0,0,0,0,-1,0,0,0,1,0,0,1,0,-1,0,0,0,0], [0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,-1,0,0,0,0,-1,0,0,0,1,0,0,1,1,-1,0,0,0,0], [1,-1,-1,0,0,0,0,-1,0,0,0,1,0,0,1,0,-1,0,0,0,0], [0,0,0,0,1,0,0,-1,0,-1,-1,1,0,0,1,0,-1,1,0,0,0], [1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,0,1,-1,0,0,0,1,0,0,0,0,-1,0,0,0,-1], [1,0,-1,0,0,-1,0,-1,0,0,0,1,0,0,1,1,-1,0,0,0,0], [0,0,0,0,1,0,0,-1,0,-1,0,1,0,0,0,0,0,0,0,0,0], [0,0,-1,-1,0,0,1,-1,1,0,0,1,0,0,0,1,0,0,0,-1,0], [1,0,0,0,0,0,0,-1,0,0,0,1,-1,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,-1,1]]]], [ # Q-class [21][06] [[21], [7,21], [9,3,21], [-3,7,3,21], [3,3,7,9,21], [7,7,3,1,-1,21], [3,9,7,3,7,3,21], [3,3,7,-1,1,9,7,21], [-1,3,1,3,7,3,7,7,21], [7,1,3,-3,3,7,-1,3,3,21], [3,9,7,3,7,3,1,7,7,9,21], [1,-3,9,-3,3,7,3,3,9,7,3,21], [7,7,3,1,9,1,3,-1,3,7,3,7,21], [9,3,1,3,7,3,-3,-3,1,3,7,-1,3,21], [3,3,-3,-1,1,9,-3,1,7,3,7,3,-1,7,21], [7,-3,3,1,9,1,3,9,3,7,3,-3,1,3,-1,21], [-7,-1,-3,3,7,3,1,7,7,-1,1,3,3,-3,7,3,21], [1,-3,-1,7,3,7,-7,3,-1,7,3,1,-3,9,3,7,3,21], [-3,1,3,7,3,7,-1,3,3,1,-1,7,7,3,3,-3,9,7,21], [-1,3,1,3,7,3,7,7,1,3,7,-1,3,1,7,3,7,-1,3,21], [1,7,9,7,3,7,3,3,-1,-3,3,1,-3,-1,3,-3,3,1,7,-1,21]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,1,0,-1,0,1,-1,0,0,1,0,0,0,0,0,0,0,0,0], [-1,0,2,-1,-1,1,-1,-1,2,-1,-1,-1,2,0,-1,0,0,2,-2,2,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [-1,0,2,0,-1,1,0,-1,1,0,-1,-1,1,0,0,0,0,1,-1,1,0], [-1,0,2,-1,-1,1,0,-2,1,-1,0,-1,1,0,0,1,0,1,0,1,0], [-1,0,1,0,0,0,0,0,0,0,-1,0,1,0,1,0,0,1,-1,0,0], [0,0,0,-1,0,0,0,-1,1,0,0,0,0,0,-1,0,0,1,0,1,1], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,-1,0,0,-1,1,0,-1,1,-1,1,0,1,0,-1,0,0,1,-1,1,1], [-1,0,0,0,0,0,0,1,0,0,-1,0,1,1,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [-1,1,2,-2,-1,1,-1,-2,2,-1,-1,-1,1,0,-1,1,0,2,-1,2,1], [1,0,-1,0,1,0,0,0,-1,-1,1,1,-1,-1,0,0,0,0,1,0,-1], [0,0,0,-1,-1,0,0,-1,1,-1,0,0,1,0,-1,1,0,1,0,1,1], [0,-1,0,0,-1,0,1,0,0,-1,1,0,1,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [-1,0,3,-1,-2,1,0,-2,2,-1,0,-2,2,0,-1,0,1,2,-1,1,0]], [[-3,0,3,-1,-2,1,0,-1,2,0,-2,-2,3,1,0,0,0,2,-2,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,-1,2,-1,-3,1,0,-3,3,-1,1,-2,2,0,-2,0,1,2,-1,2,1], [-1,-1,2,-1,-2,1,0,-2,2,0,0,-2,2,1,-1,0,1,1,-1,1,1], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,-1,0,-1,0,1,0,-1,0,1,1,0,0,0,0,-1,1,1], [0,1,-2,1,2,-2,0,3,-3,1,0,2,-2,0,2,0,-1,-2,2,-2,-1], [-1,0,1,0,-1,0,0,0,0,0,0,0,1,1,0,0,1,0,-1,0,0], [-3,0,4,-2,-3,2,0,-3,3,-1,-1,-3,3,1,-1,1,1,2,-2,2,1], [1,0,-2,1,2,-1,1,2,-3,1,1,1,-2,0,1,-1,0,-2,2,-2,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [-2,1,3,-2,-2,1,-1,-2,3,0,-2,-2,2,1,-1,0,1,2,-2,2,1], [-2,0,3,-1,-2,1,0,-2,2,0,-1,-2,2,1,-1,0,1,2,-2,1,1], [0,-1,-1,0,1,0,1,1,-1,0,1,0,0,0,0,-1,0,0,0,-1,0], [-2,0,2,-1,-2,0,0,-1,1,0,-1,-1,2,1,0,1,0,1,-1,1,1], [1,0,-2,0,1,-1,0,1,-1,0,1,1,-1,0,0,0,0,-1,1,-1,0], [-1,-1,2,-1,-3,1,1,-3,2,-1,1,-2,2,0,-1,1,1,2,-1,1,1], [-1,1,2,-2,-2,1,-1,-3,3,-1,0,-1,1,0,-2,1,1,2,-1,2,1], [0,0,-1,0,2,-1,0,2,-1,1,0,0,-1,0,1,-1,-1,-1,1,-1,0], [1,-1,-1,0,0,1,0,-1,0,-1,2,0,0,-1,-1,0,0,0,1,0,0]]]], [ # Q-class [21][07] [[6], [-2,6], [0,2,6], [-2,1,0,6], [2,2,0,-1,6], [2,0,0,-2,0,6], [-1,0,-1,-1,-2,1,6], [0,0,2,0,0,0,-2,6], [2,0,-1,2,1,0,-2,1,6], [2,2,0,-1,2,0,0,-1,0,6], [-2,1,0,-2,-1,-2,0,0,-2,-1,6], [1,0,-2,0,2,2,0,0,1,0,-2,6], [1,1,0,-2,2,0,2,-2,-1,2,1,0,6], [0,-1,-1,0,0,1,-2,1,2,-2,0,0,0,6], [-2,0,-1,0,0,-1,1,1,-2,0,1,1,0,-2,6], [-1,0,-2,0,1,-2,-1,-1,-1,0,2,2,0,-1,2,6], [0,-2,0,0,0,-1,0,0,0,-1,0,0,0,-1,1,0,6], [0,2,2,0,0,2,0,1,0,2,0,0,0,-1,0,0,-2,6], [0,-1,-1,-2,0,0,0,0,0,1,0,0,0,1,0,0,2,-1,6], [-2,0,0,0,-2,-1,0,0,-2,0,1,-2,-1,0,-2,-1,-2,0,0,6], [2,0,-1,-2,1,0,0,0,0,0,2,-1,0,0,0,1,-2,0,-2,0,6]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-6,-6,3,3,2,4,0,1,2,4,3,1,1,-2,-2,0,-1,-2,1,-1,2], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,3,-2,-2,-2,-2,-1,0,-1,-2,-2,0,0,0,0,0,1,1,-1,0,-1], [-10,-11,6,6,4,7,1,1,3,7,6,2,1,-3,-3,0,-3,-4,2,-2,4], [-2,-3,2,2,2,2,1,0,1,2,2,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [2,1,0,0,0,0,0,0,0,-1,0,-1,0,0,1,1,0,0,0,1,-1], [-1,0,-1,0,-1,0,-1,1,-1,0,-1,0,1,-1,-1,0,0,0,0,-1,1], [-2,-2,2,1,1,2,1,0,2,2,1,0,0,0,0,1,0,-1,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [-6,-8,4,5,4,5,2,1,2,5,5,1,0,-2,-2,0,-2,-3,1,-1,2], [-4,-4,2,2,1,2,0,0,1,3,2,1,0,-1,-1,-1,-1,-1,1,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [-3,-4,3,3,2,3,1,0,1,3,3,1,0,-1,-1,0,-1,-2,1,0,1], [-3,-4,2,2,2,2,1,0,1,2,2,1,0,-1,-1,0,-1,-1,1,0,1], [-2,-2,1,2,1,2,0,0,0,1,1,0,0,-1,-1,0,-1,-1,1,-1,1], [-3,-4,3,2,2,3,1,0,2,3,2,0,0,0,0,1,0,-2,0,1,1], [-2,-2,1,2,1,2,0,0,1,1,1,0,1,-1,0,0,-1,-1,1,0,1], [8,8,-4,-5,-3,-5,0,-1,-1,-5,-4,-2,-1,3,3,1,2,3,-2,2,-4], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,-2,1,2,1,1,0,0,0,1,2,1,0,-1,-1,-1,-1,-1,1,-1,1], [-5,-6,4,4,3,5,1,0,2,4,4,1,0,-1,-1,0,-1,-3,1,0,2], [2,4,-3,-2,-2,-3,-2,0,-2,-3,-3,0,1,0,0,-1,1,2,0,0,0], [1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [1,1,0,-1,-1,-1,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [6,7,-5,-4,-3,-5,-2,0,-3,-5,-4,-1,0,1,1,-1,1,3,-1,0,-2], [-2,-3,1,2,1,1,0,0,0,2,2,1,0,-1,-1,-1,-1,-1,1,-1,1], [-3,-4,3,2,3,3,2,0,2,3,3,0,-1,0,0,1,-1,-2,0,0,0], [4,5,-3,-3,-3,-4,-1,0,-2,-3,-3,0,0,1,0,0,1,2,-1,0,-1], [-6,-8,4,5,4,5,2,1,2,5,5,1,0,-2,-2,0,-2,-3,1,-1,2], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,-1,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [3,2,0,-1,0,-1,1,-1,0,-1,-1,-1,-1,2,2,1,1,1,-1,2,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [2,1,0,0,0,0,1,0,0,0,0,-1,-1,1,1,1,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0]]]], [ # Q-class [21][08] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]]]] ]; MakeImmutable( IMFList[21].matrices ); gap-4r6p5/grp/imf28.grp0000644000175000017500000061460312172557252013402 0ustar billbill############################################################################# ## #A imf28.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Q-class representative of the irreducible ## maximal finite integral matrix groups of dimension 28, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Q-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 28. ## IMFList[28].matrices := [ [ # Q-class [28][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [28][02] [[2], [1,2], [0,0,2], [0,0,1,2], [0,0,0,0,2], [0,0,0,0,1,2], [0,0,0,0,0,0,2], [0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [28][03] [[2], [0,2], [0,0,2], [1,1,1,2], [0,0,0,0,2], [0,0,0,0,0,2], [0,0,0,0,0,0,2], [0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,-1,-1,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [28][04] [[2], [1,2], [1,1,2], [1,1,1,2], [0,0,0,0,2], [0,0,0,0,1,2], [0,0,0,0,1,1,2], [0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [28][05] [[2], [-1,2], [0,-1,2], [0,0,-1,2], [0,0,0,-1,2], [0,0,0,0,-1,2], [0,0,0,-1,0,0,2], [0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,-1,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,2]], [[[0,0,0,0,0,0,0,-1,-2,-3,-4,-3,-2,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,2,2,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,-1,-1,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2,-3,-4,-3,-2,-2,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,1,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2,-3,-4,-3,-2,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,-1,-2,-2,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,2,2,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-2,-2,-3,-2,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,-1,-2,-3,-2,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2,-3,-4,-3,-2,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,1,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2,-3,-4,-3,-2,-2,0,0,0,0,0,0,0]]]], [ # Q-class [28][06] [[4], [-2,4], [-2,1,4], [1,-2,-2,4], [0,0,-2,1,4], [0,0,1,-2,-2,4], [0,0,0,0,-2,1,4], [0,0,0,0,1,-2,-2,4], [0,0,0,0,0,0,-2,1,4], [0,0,0,0,0,0,1,-2,-2,4], [0,0,0,0,0,0,0,0,-2,1,4], [0,0,0,0,0,0,0,0,1,-2,-2,4], [0,0,0,0,0,0,-2,1,0,0,0,0,4], [0,0,0,0,0,0,1,-2,0,0,0,0,-2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-2,-2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-2,-2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-2,-2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-2,-2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-2,-2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,1,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-2,0,0,0,0,-2,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,2,0,2,0,1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,2,0,2,0,1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-2,0,-3,0,-4,0,-3,0,-2,0,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-2,0,-3,0,-4,0,-3,0,-2,0,-2,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,2,0,2,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,2,0,2,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,-2,0,-3,0,-4,0,-3,0,-2,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,-2,0,-3,0,-4,0,-3,0,-2,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,-1,-2,-2,-2,-2,-3,-3,-2,-2,-1,-1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,2,0,2,0,3,0,2,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,1,2,2,2,2,1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,-2,0,-2,0,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,-1,-2,-2,-2,-2,-1,-1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,2,0,2,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,2,0,2,0,1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,2,0,2,0,1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-2,0,-3,0,-4,0,-3,0,-2,0,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-2,0,-3,0,-4,0,-3,0,-2,0,-2,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-2,0,-3,0,-4,0,-2,0,-1,0,-2,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2,2,3,3,4,4,2,2,1,1,2,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,2,0,3,0,4,0,3,0,1,0,2,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-2,-2,-3,-3,-4,-4,-3,-3,-1,-1,-2,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1]]]], [ # Q-class [28][07] [[4], [1,4], [1,1,4], [1,-1,1,4], [1,1,-1,1,4], [1,1,1,-1,1,4], [1,-1,1,1,-1,1,4], [1,-1,-1,1,1,-1,1,4], [1,-1,-1,-1,1,1,-1,1,4], [1,-1,-1,-1,-1,1,1,-1,1,4], [1,1,-1,-1,-1,-1,1,1,-1,1,4], [1,1,1,-1,-1,-1,-1,1,1,-1,1,4], [1,-1,1,1,-1,-1,-1,-1,1,1,-1,1,4], [1,1,-1,1,1,-1,-1,-1,-1,1,1,-1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,-1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,-1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,1,-1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-1,1,1,-1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-1,-1,1,1,-1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-1,-1,-1,1,1,-1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,-1,-1,-1,-1,1,1,-1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,-1,-1,-1,-1,1,1,-1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,1,-1,-1,-1,-1,1,1,-1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,-1,1,1,-1,-1,-1,-1,1,1,-1,1,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,1,-1,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,1,-1,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,1,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,1,0,0,0,1,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,1,0,0,0,0,-1,1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,-1,0,0,0,0,-1,0,-1,1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,-1,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,1,0,-1,1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,1,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,-1,0,-1,1,-1,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,1,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,0,1,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,-1,1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,-1,1,0,0,0,0,-1,1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,-1,0,0,0,0,-1,0,-1,1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,1,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,1,-1,1,0,-1,1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,1,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,0,0,-1,0,-1,1,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,1,-1,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,1,-1,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,1,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,1,0,0,0,1,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,1,0,0,0,0,-1,1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,-1,0,0,0,0,-1,0,-1,1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,-1,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,1,0,-1,1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,1,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,-1,0,-1,1,-1,1,-1]]]], [ # Q-class [28][08] [[4], [0,4], [2,1,4], [0,0,0,4], [0,-2,0,0,4], [0,2,1,0,-1,4], [0,0,-1,-1,0,1,4], [-1,2,1,-1,-1,1,0,4], [0,0,-1,1,-1,0,1,0,4], [2,-1,1,0,0,1,1,0,0,4], [2,0,1,0,0,0,0,0,-1,1,4], [0,0,0,0,1,1,0,0,0,0,-1,4], [2,0,1,0,1,0,-1,0,0,2,1,1,4], [1,0,1,0,-1,0,-1,0,2,1,-1,0,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,0,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2,1,-1,-1,1,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,0,1,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-1,1,0,0,1,1,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,1,0,0,0,0,0,-1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,1,0,1,0,-1,0,0,2,1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,-1,0,-1,0,2,1,-1,0,2,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,1,0,0,0,-1,1,1,0,-2,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,1,0,0,1,1,-1,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,0,0,0,1,-1,-1,-1,2,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,-1,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,-1,-1,1,1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-1,0,1,-1,-1,0,0,2,1,1,-2,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,0,1,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,-1,0,-1,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,-1,0,0,0,1,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-1,0,2,-1,-1,0,0,2,1,1,-3,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,0,1,0,0,0,-1,1,1,0,-2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,1,0,0,1,1,-1,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,-1,0,0,0,1,-1,-1,-1,2,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,0,0,0,-1,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,-1,0,0,-1,-1,1,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,2,-1,0,1,-1,-1,0,0,2,1,1,-2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,-1,0,1,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,1,-1,0,0,0,1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,2,-1,0,2,-1,-1,0,0,2,1,1,-3,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,-1,0,0,-1,1,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,-1,0,0,0,-1,1,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,-1,0,1,0,-1,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,1,0,0,0,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-2,0,1,-1,1,1,1,-1,-2,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,1,0,0,0,-1,1,1,0,-2,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,1,0,0,1,1,-1,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,0,0,0,1,-1,-1,-1,2,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,-1,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,-1,-1,1,1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-1,0,1,-1,-1,0,0,2,1,1,-2,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,0,1,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,-1,0,-1,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,-1,0,0,0,1,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-1,0,2,-1,-1,0,0,2,1,1,-3,2]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,-1,0,0,-1,1,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,-1,0,0,0,-1,1,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,-1,0,1,0,-1,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,-1,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,1,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-2,0,1,-1,1,1,1,-1,-2,0,0,1,0]]]], [ # Q-class [28][09] [[4], [-1,4], [2,-2,4], [1,0,0,4], [0,0,0,0,4], [0,0,1,1,-1,4], [-1,0,-1,2,0,1,4], [-1,0,0,0,2,0,0,4], [0,1,0,-1,0,-1,1,1,4], [1,1,0,1,1,1,1,2,2,4], [1,-1,1,2,1,1,1,1,0,2,4], [0,0,1,0,1,1,-1,1,-1,0,1,4], [0,0,-1,-1,0,-1,1,-1,2,1,1,-1,4], [-1,0,-1,1,1,0,2,0,0,1,2,1,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,2,0,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,2,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,-1,1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,2,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,2,1,1,1,1,0,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,-1,1,-1,0,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,-1,1,-1,2,1,1,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,1,1,0,2,0,0,1,2,1,2,4]], [[[1,1,1,-1,-1,-1,1,1,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,-1,0,-1,0,-2,1,-3,-1,3,1,1,-1,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,0,-1,1,0,2,-2,2,2,-3,-1,-1,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,1,-1,-1,-1,2,1,-2,0,0,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,0,-1,1,0,-1,1,-1,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,1,0,0,0,1,0,2,0,-3,0,-1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,1,0,-1,-1,2,1,-2,0,0,1,2,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,1,1,0,0,-1,0,1,-1,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,-1,0,1,0,-1,0,-2,0,2,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,0,-1,1,-1,-1,1,0,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,1,0,1,1,-2,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,-1,1,1,2,-2,0,3,-2,-1,-1,-1,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,-1,1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-2,-1,1,1,0,-2,-3,2,2,0,0,-2,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,1,0,1,-1,1,1,-2,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,1,-1,0,1,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,1,0,-1,1,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,-1,-1,1,1,-2,1,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,-1,0,1,1,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,1,2,-1,-1,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,-1,1,1,-2,0,-1,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,1,1,2,-2,1,2,-2,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1,0,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,-1,0,1,0,0,1,-1,1,0,-1,0]], [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-2,-1,1,1,0,-2,-3,2,2,0,0,-2,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,1,0,1,-1,1,1,-2,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,1,-1,0,1,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,1,0,-1,1,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,-1,-1,1,1,-2,1,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,-1,0,1,1,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,1,2,-1,-1,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,-1,1,1,-2,0,-1,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,1,1,2,-2,1,2,-2,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1,0,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,-1,0,1,0,0,1,-1,1,0,-1,0], [-2,-2,-1,1,1,0,-2,-3,2,2,0,0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,1,0,1,-1,1,1,-2,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,1,0,0,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,-1,1,0,1,-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,-1,1,0,-1,1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,1,0,-1,-1,1,1,-2,1,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,-1,-1,0,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,1,0,0,0,1,2,-1,-1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,1,-1,1,1,-2,0,-1,-1,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,1,1,2,-2,1,2,-2,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,-1,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,-1,0,1,0,0,1,-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,-1,-1,1,0,-2,2,-1,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,-1,1,-1,-1,1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-2,-1,2,1,1,-2,-1,2,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,-2,-1,-1,2,1,-2,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,1,-1,1,1,-2,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,-1,1,1,2,-2,0,2,-1,-1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,1,0,1,0,-1,-1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,1,0,1,0,-1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,1,-1,1,1,-2,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,1,-1,1,0,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,1,0,1,1,-2,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,1,-1,1,1,-2,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-2,-1,1,1,0,-2,-3,2,2,0,0,-2,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,1,0,1,-1,1,1,-2,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,1,-1,0,1,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,1,0,-1,1,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,-1,-1,1,1,-2,1,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,-1,0,1,1,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,1,2,-1,-1,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,-1,1,1,-2,0,-1,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,1,1,2,-2,1,2,-2,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1,0,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,-1,0,1,0,0,1,-1,1,0,-1,0]]]], [ # Q-class [28][10] [[3], [-1,3], [1,1,3], [1,0,1,3], [0,1,0,-1,3], [0,1,0,-1,1,3], [-1,0,-1,0,0,0,3], [0,-1,0,0,0,0,-1,3], [0,1,0,0,0,0,1,-1,3], [-1,0,0,0,-1,0,1,1,0,3], [0,-1,-1,0,0,-1,0,1,0,1,3], [1,-1,0,1,0,-1,0,0,1,-1,1,3], [-1,1,0,-1,1,0,1,0,1,1,1,0,3], [-1,0,0,0,0,-1,0,1,0,0,0,1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,0,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1,0,1,1,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,-1,0,1,0,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,1,0,-1,0,0,1,-1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,1,0,1,0,1,1,1,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,0,1,0,0,0,1,1,3]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,-1,1,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,-1,-1,1,1,0,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0,0,0,0,1,-1,1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,1,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,1,0,1,0,0,1,-1,1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,-1,0,0,1,0,0,0,1,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,1,0,-1,1,0,1,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,1,0,0,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,1,0,0,-1,1,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,1,0,-1,-1,1,1,0,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,1,0,0,0,0,0,1,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,-1,0,0,1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,1,1,0,1,0,0,1,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,-1,0,0,1,0,0,0,1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,0,1,0,-1,1,0,1,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,-1,0,0,1,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,-2,0,1,1,1,-1,-1,1,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,1,0,-1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,-1,0,-1,1,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,-1,-1,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,1,-1,-1,0,1,1,0,-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,-1,0,0,1,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,-1,-1,0,1,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,-1,1,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,-1,-1,1,1,0,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0,0,0,0,1,-1,1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,1,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,1,0,1,0,0,1,-1,1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,-1,0,0,1,0,0,0,1,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,1,0,-1,1,0,1,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,1,0,0,0,1,0,-1,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,2,0,-1,-1,0,1,1,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,-1,0,-1,1,1,-1,0,-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,1,0,-1,0,0,1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-2,1,1,1,1,0,-1,1,0,1,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,-1,0,1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,1,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,-1,1,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,-1,-1,1,1,0,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0,0,0,0,1,-1,1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,1,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,1,0,1,0,0,1,-1,1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,-1,0,0,1,0,0,0,1,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,1,0,-1,1,0,1,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,1,0,0,0,1,0,-1,0]]]], [ # Q-class [28][11] [[7], [2,7], [-1,1,7], [1,-1,3,7], [3,3,-1,-1,7], [1,3,1,1,1,7], [1,1,1,2,1,-1,7], [1,1,2,1,1,2,1,7], [1,1,-3,-1,0,3,-1,0,7], [3,-2,1,1,-1,-1,2,1,1,7], [2,0,1,3,-2,-1,1,-1,-1,3,7], [1,-1,-2,2,1,1,-1,-2,2,1,1,7], [0,3,2,1,2,3,-1,3,-1,-1,1,0,7], [2,3,-1,-2,1,-1,0,1,1,2,2,1,1,7], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,7], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,7], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,7], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,3,7], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,3,-1,-1,7], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,3,1,1,1,7], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2,1,-1,7], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2,1,1,2,1,7], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,-3,-1,0,3,-1,0,7], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,-2,1,1,-1,-1,2,1,1,7], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,1,3,-2,-1,1,-1,-1,3,7], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-2,2,1,1,-1,-2,2,1,1,7], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,2,1,2,3,-1,3,-1,-1,1,0,7], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,-1,-2,1,-1,0,1,1,2,2,1,1,7]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,-1,0,1,-1,0,-1,-1,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,-1,0,1,0,0,1,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,1,0,0,-1,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,-1,-1,0,1,0,0,-1,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,1,0,0,-1,1,-1,1,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2,-1,1,0,0,-1,0,-1,2,-1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,1,0,-1,-1,1,-1,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,-1,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2,-2,1,0,0,-1,0,-1,2,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,-1,0,1,-1,0,-1,-1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,-1,0,-1,0,1,0,0,1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,-1,1,0,0,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,1,-1,-1,0,1,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,-1,1,0,0,-1,1,-1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,2,-1,1,0,0,-1,0,-1,2,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,1,0,-1,-1,1,-1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,-1,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,2,-2,1,0,0,-1,0,-1,2,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-2,1,-1,1,1,1,-1,0,-1,2,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,-1,1,1,0,-1,0,-1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,2,-2,2,1,0,-1,0,-1,2,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,1,0,-1,0,0,-1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,2,-1,1,0,0,-1,0,-1,2,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,-1,1,0,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,2,-1,1,0,0,-1,0,-1,2,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,1,0,0,1,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-2,1,0,0,0,1,-1,1,-1,0,-1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-2,1,-1,0,1,1,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,-1,0,1,-1,0,-1,-1,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,-1,0,1,0,0,1,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,1,0,0,-1,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,-1,-1,0,1,0,0,-1,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,1,0,0,-1,1,-1,1,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2,-1,1,0,0,-1,0,-1,2,-1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,1,0,-1,-1,1,-1,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,-1,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2,-2,1,0,0,-1,0,-1,2,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,1,-1,0,0,1,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,-1,0,1,-1,0,-1,-1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,0,0,-1,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,-1,2,-2,-1,-1,1,0,1,-2,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-2,1,-1,0,0,1,-1,1,-1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,1,0,0,1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,-2,1,-1,-1,0,1,0,1,-2,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-2,1,0,0,0,1,-1,1,-1,-1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-2,1,-1,0,1,1,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,-1,0,1,-1,0,-1,-1,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,-1,0,1,0,0,1,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,1,0,0,-1,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,-1,-1,0,1,0,0,-1,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,1,0,0,-1,1,-1,1,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2,-1,1,0,0,-1,0,-1,2,-1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,1,0,-1,-1,1,-1,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,-1,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2,-2,1,0,0,-1,0,-1,2,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0]]]], [ # Q-class [28][12] [[6], [0,6], [-2,3,6], [-2,2,1,6], [-2,2,3,3,6], [2,-2,0,0,0,6], [2,-2,-2,0,0,0,6], [-2,-2,0,2,0,0,2,6], [2,0,0,1,2,3,0,-2,6], [-2,0,1,0,-1,0,-1,0,0,6], [0,-3,-2,-2,-2,2,-1,1,0,-1,6], [-2,-2,1,-2,-1,-1,0,0,-2,3,0,6], [-1,-2,-1,-2,-2,-2,-1,0,-1,2,0,3,6], [-1,2,3,0,2,0,-1,-2,0,-1,0,1,-1,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,3,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,2,1,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,2,3,3,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-2,0,0,0,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-2,-2,0,0,0,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-2,0,2,0,0,2,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,1,2,3,0,-2,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,1,0,-1,0,-1,0,0,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,-2,-2,-2,2,-1,1,0,-1,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-2,1,-2,-1,-1,0,0,-2,3,0,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2,-1,-2,-2,-2,-1,0,-1,2,0,3,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2,3,0,2,0,-1,-2,0,-1,0,1,-1,6]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,-1,0,0,0,1,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,1,0,0,-1,1,1,-1,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,1,-1,0,0,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,0,1,0,1,-1,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,1,-1,-1,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,1,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,1,0,-1,1,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-2,-1,0,1,-1,-2,1,0,1,-1,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-1,1,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,-1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,-1,-1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,1,0,0,-1,1,1,-1,0,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,1,-1,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,-1,0,1,0,1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,1,0,1,1,-1,-1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,1,0,-1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,-2,-1,0,1,-1,-2,1,0,1,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,-1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-2,1,1,1,-1,1,2,-2,0,-1,1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,-1,1,0,-1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,-1,0,0,-1,1,1,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,-1,0,-1,-1,1,1,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,1,-1,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,-1,0,1,0,1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-2,-1,0,0,-1,2,1,0,-1,1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,0,0,1,-1,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,1,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,1,0,0,0,-1,1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,-1,0,0,0,1,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,1,0,0,-1,1,1,-1,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,1,-1,0,0,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,0,1,0,1,-1,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,1,-1,-1,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,1,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,1,0,-1,1,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-2,-1,0,1,-1,-2,1,0,1,-1,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-1,1,0,0,1,0,0,0,0,0,0]]]], [ # Q-class [28][13] [[6], [-1,6], [-3,-2,6], [-1,3,-2,6], [2,-3,1,0,6], [-2,2,2,-1,-1,6], [3,0,-3,1,2,0,6], [3,1,-1,1,2,1,1,6], [-3,3,0,2,-2,3,0,0,6], [-2,3,0,3,0,0,-1,1,3,6], [-1,-1,0,-2,-2,0,-1,-2,1,0,6], [2,1,0,1,0,-1,0,2,-1,0,0,6], [2,2,-1,-1,-2,2,0,2,1,-1,1,3,6], [3,-2,0,-1,1,-3,1,0,-3,-2,1,3,0,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,-2,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,3,-2,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-3,1,0,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,2,2,-1,-1,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,0,-3,1,2,0,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,1,-1,1,2,1,1,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,3,0,2,-2,3,0,0,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,3,0,3,0,0,-1,1,3,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,-2,-2,0,-1,-2,1,0,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,0,1,0,-1,0,2,-1,0,0,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,-1,-1,-2,2,0,2,1,-1,1,3,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,3,-2,0,-1,1,-3,1,0,-3,-2,1,3,0,6]], [[[-2,-1,-2,-1,0,0,0,0,0,1,-1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,-1,1,0,2,-1,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,2,0,-1,-1,1,1,0,-1,1,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,0,0,-1,0,-1,1,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,-1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,-2,-2,0,0,1,0,0,0,1,-1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,-1,-2,-1,0,1,0,0,-1,1,-1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,-1,0,0,0,0,0,0,0,1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,-1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,-1,0,0,0,0,1,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-2,-2,0,0,1,0,0,-1,1,-1,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2,0,-1,1,-1,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,2,1,0,-1,0,0,1,-1,1,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,0,0,1,0,0,-1,1,-1,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-1,-1,0,0,0,0,0,0,0,-1,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,-1,-1,1,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-1,0,0,2,-1,-1,0,1,0,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,1,0,0,0,0,0,1,-1,0]], [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-1,-2,-1,0,1,0,0,-1,1,-1,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,0,0,-1,0,0,1,-1,1,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-1,-2,0,0,1,0,0,-1,1,-1,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,-1,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,-1,0,0,0,-1,1,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,0,-1,0,-1,1,1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-1,-1,-1,0,0,0,0,0,1,-1,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,-1,0,0,0,1,0,0,0,0,0,0], [-2,-2,-2,0,0,1,0,0,-1,1,-1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,2,0,-1,1,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,1,2,1,0,-1,0,0,1,-1,1,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,-1,0,0,1,0,0,-1,1,-1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,-1,-1,0,0,0,0,0,0,0,-1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,0,1,0,-1,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,-1,0,0,2,-1,-1,0,1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,-1,0,0,1,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,1,0,0,0,1,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,0,1,-1,0,0,0,-1,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2,-1,0,-1,1,0,0,0,1,-1,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,-1,0,0,0,-1,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,-1,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,-1,0,0,1,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,-1,-1,1,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,1,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1]]]], [ # Q-class [28][14] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [28][15] [[6], [3,6], [3,2,6], [1,3,3,6], [2,1,3,3,6], [2,3,1,3,2,6], [3,3,1,2,3,1,6], [3,1,1,2,3,3,2,6], [3,2,2,1,1,1,1,1,6], [2,1,1,1,2,0,3,1,3,6], [1,3,1,2,1,1,2,0,3,3,6], [1,2,2,3,1,1,1,1,0,1,1,6], [1,1,1,2,1,3,0,2,1,1,2,1,6], [1,2,2,1,1,1,1,1,2,1,3,0,1,6], [2,3,1,1,0,2,1,1,1,0,1,1,3,1,6], [2,1,1,1,2,2,1,3,3,2,1,1,1,3,0,6], [2,3,1,1,-2,2,1,1,1,0,1,1,1,1,2,0,6], [2,1,1,1,2,2,1,1,1,2,1,1,3,1,2,2,0,6], [0,1,1,1,2,2,1,1,1,2,1,1,3,1,2,2,0,2,6], [3,2,2,1,1,1,1,1,2,1,1,2,1,2,1,3,1,3,1,6], [1,0,2,1,1,1,1,1,2,1,1,0,3,2,1,1,1,1,3,0,6], [1,1,1,2,1,1,2,2,1,3,2,1,2,3,1,3,1,1,1,1,1,6], [2,3,1,1,0,2,1,1,1,0,1,1,1,3,2,2,2,2,2,3,1,1,6], [2,1,1,1,0,2,1,1,1,2,1,1,3,1,2,2,2,2,2,3,1,3,2,6], [1,1,1,2,3,1,2,2,1,3,2,3,2,1,1,3,-1,3,3,1,1,2,1,1,6], [1,2,0,1,-1,1,1,1,0,1,1,2,1,2,3,1,3,1,1,2,0,3,3,3,1,6], [3,2,2,1,1,1,1,1,2,1,1,0,1,2,1,1,1,1,1,2,2,1,3,1,1,2,6], [2,1,1,1,0,2,1,1,3,2,1,1,1,1,0,2,2,0,2,1,3,1,2,2,1,1,3,6]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,-1,1,0,-1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,1,0,-1,0,0,-1,1], [0,0,1,0,0,0,0,-1,-1,1,0,-1,2,-1,0,1,0,-1,-1,1,0,0,1,-2,0,1,-1,1], [-1,1,1,-1,-1,0,1,1,1,-1,0,0,0,0,-1,-1,-1,1,0,0,0,0,0,0,0,1,-1,1], [0,1,0,0,1,0,-1,-1,-1,1,0,-1,1,-1,0,1,0,-1,-1,1,1,0,0,-1,0,1,-1,1], [0,-1,0,0,0,1,0,-1,-1,1,1,0,0,-1,1,1,0,-1,-1,1,1,0,1,-1,0,0,0,0], [-1,-1,1,0,-1,0,1,1,1,-1,1,1,-1,0,0,0,0,1,1,-1,-1,0,0,1,-1,-1,1,0], [0,0,0,0,0,0,0,0,1,-1,0,0,0,0,-1,-1,0,0,1,0,0,1,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,1,-1,0,0,0,0,-1,-1,0,0,1,0,0,1,0,0,0,0,-1,0], [-1,-2,0,0,1,0,1,-1,-2,2,1,1,1,-1,2,3,1,-1,-1,0,0,-1,1,-1,-2,-1,1,0], [1,0,-1,0,0,0,0,0,2,-1,-1,0,0,1,-1,-3,0,0,1,1,0,1,0,0,1,0,-1,0], [-1,0,2,-1,-2,1,1,1,0,0,1,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,1,0,-1,1,0,1,0,-1,0,0,0,0,0,0,0,1,0,-1,0,0], [-3,-1,3,-1,-2,1,2,1,-1,1,2,0,0,-2,1,2,-1,0,-1,0,0,-1,1,0,-1,0,1,0], [1,0,-1,0,0,0,0,0,1,-1,0,1,-1,1,-1,-1,0,1,1,-1,0,0,-1,1,0,0,0,0], [0,0,0,0,-1,0,1,0,1,0,-1,0,1,1,-1,-1,0,0,1,0,-1,0,0,0,0,0,0,0], [-2,0,1,-1,0,0,1,0,1,0,0,0,1,-1,0,0,0,0,-1,0,0,0,1,0,0,0,0,0], [-1,0,1,-1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,-1,-1,1,0,1,0,0,1,0,-1,-1,0,-1,-1,0,0,1,1,1,0,0,0,0,0,0], [-2,0,1,-1,-1,0,1,1,0,0,1,1,-1,-1,1,1,0,1,0,-1,0,0,0,1,-1,-1,1,0], [0,2,0,-1,0,-1,0,1,2,-2,-1,0,0,1,-2,-3,-1,1,1,0,0,1,-1,1,1,1,-1,1], [-2,-2,1,0,0,1,1,-1,-2,3,1,0,1,-2,2,3,1,-2,-2,1,1,-1,2,-1,-1,-1,1,-1], [0,1,-1,-1,1,0,-1,0,0,0,0,1,-1,0,0,-1,0,0,0,0,1,1,0,1,0,-1,0,0], [-1,0,0,-1,1,1,-1,0,0,1,0,0,-1,-1,1,-1,1,-1,-1,1,1,1,1,0,1,-1,0,0], [-2,0,1,-1,0,0,1,1,1,-1,1,1,-1,-1,0,0,0,1,0,-1,0,0,0,1,-1,0,1,0]], [[-3,-2,1,-1,0,1,1,0,-2,2,2,1,-1,-2,3,4,1,0,-2,0,1,-1,1,0,-2,-2,2,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,-1,0,0,0,0,-1,0,0,0], [-3,-2,2,-1,-1,1,2,1,-1,1,2,1,-1,-2,2,3,0,1,-1,-1,0,-1,1,0,-2,-1,2,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,-1,0,1,1,-1,0,1,1,0,1,0,-1,0,0,0,0,-1,-1,1,0], [1,2,-1,0,0,-1,-1,1,1,-2,0,0,-1,1,-1,-2,-1,2,1,-1,0,1,-1,1,0,0,-1,1], [1,-2,-1,1,0,0,0,-1,-1,1,0,1,0,1,1,2,1,0,0,-1,0,-1,0,0,-1,-1,1,-1], [0,0,-1,0,1,-1,-1,0,-1,0,1,1,-1,0,1,1,1,1,0,-1,0,0,0,1,-1,-2,1,0], [0,0,0,0,0,0,0,0,-1,0,1,0,-1,-1,0,1,0,1,0,0,1,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,1,0,0,-1,0,1,-1,0,0,0,0,0,0], [0,0,1,0,-1,0,1,0,0,0,0,0,1,0,-1,1,-1,1,0,-1,0,-1,0,0,-1,1,0,0], [-2,-1,2,-1,-1,2,1,0,-1,2,0,-1,1,-1,1,1,0,-1,-2,1,0,-1,1,-1,1,0,0,0], [0,1,0,0,-1,-1,1,1,1,-2,0,0,0,1,-1,-1,-1,2,1,-1,-1,0,-1,1,0,0,0,1], [0,0,1,0,-2,-1,1,2,1,-2,1,1,-1,0,-1,0,-1,3,2,-2,-1,0,-1,1,-2,0,1,0], [0,0,0,0,0,-1,1,0,0,-1,0,0,1,0,0,1,0,1,0,-1,-1,0,0,0,-1,0,0,1], [0,0,0,0,-1,0,0,1,0,-1,1,1,-2,0,0,0,0,2,1,-1,0,0,-1,1,-1,-1,1,0], [-1,1,0,0,0,-1,0,1,0,0,0,0,0,0,0,1,0,1,0,-1,0,-1,0,1,-1,0,0,0], [-1,1,1,-1,-1,0,1,1,0,-1,0,0,0,0,0,0,-1,1,0,0,0,0,-1,0,0,0,0,1], [2,1,-1,1,-1,-1,0,1,2,-3,-1,0,-1,2,-2,-3,-1,2,2,-1,-1,1,-1,1,1,0,-1,1], [-2,-1,1,-1,-1,1,1,1,0,0,1,1,-1,-1,1,1,0,1,0,0,0,0,0,0,-1,-1,1,0], [1,0,0,1,-2,-1,1,1,1,-2,0,0,-1,1,-1,-1,-1,2,2,-1,-1,0,-1,1,0,0,0,0], [0,0,0,0,-1,-1,1,1,1,-1,0,1,0,1,-1,0,0,2,1,-2,-1,-1,-1,1,-1,0,1,0], [0,0,0,0,-1,0,0,1,1,-1,0,0,-1,0,0,-1,0,1,1,0,0,1,0,0,0,-1,0,0], [-1,-1,0,0,-1,0,1,1,0,0,1,1,-1,0,1,1,0,1,0,-1,0,-1,0,1,-1,-1,1,0], [-1,-1,1,0,-1,1,1,0,-1,1,0,0,0,0,1,1,0,0,-1,0,0,-1,0,0,0,-1,1,0], [-1,0,1,0,-1,-1,1,1,0,0,0,0,1,0,0,1,0,1,0,-1,-1,-1,0,0,-1,0,0,1], [-2,-1,1,0,-1,0,1,1,0,0,1,0,-1,-1,1,1,0,1,0,0,0,0,0,0,-1,-1,1,0], [1,0,-1,1,0,0,-1,0,0,0,0,-1,-1,0,0,-1,0,0,0,1,1,0,0,0,1,0,-1,0]]]], [ # Q-class [28][16] [[6], [3,6], [2,3,6], [2,3,2,6], [2,3,2,2,6], [2,1,2,2,2,6], [0,3,2,2,2,2,6], [1,2,3,3,1,3,3,6], [2,3,2,2,2,2,2,3,6], [2,3,2,2,2,2,2,3,2,6], [1,1,1,1,3,3,1,1,1,1,6], [3,3,1,3,1,1,1,1,1,1,0,6], [2,3,2,2,2,2,2,3,2,2,1,3,6], [0,1,0,0,2,0,2,1,2,0,1,1,2,6], [1,2,1,1,3,1,1,0,1,1,1,1,1,1,6], [1,2,1,1,3,3,1,2,1,1,3,1,1,1,2,6], [2,1,2,2,2,2,-2,1,2,2,3,1,2,0,1,1,6], [3,2,1,3,1,1,1,2,1,1,1,3,3,1,-2,0,1,6], [2,1,0,2,2,0,0,1,2,0,1,1,2,2,3,1,2,1,6], [3,1,1,1,3,3,1,1,1,1,2,2,1,1,1,3,1,1,1,6], [1,1,3,1,1,1,1,1,1,-1,2,2,1,1,1,1,1,1,1,2,6], [1,2,1,1,1,1,3,2,1,1,1,1,3,1,0,0,-1,2,1,1,1,6], [1,2,3,1,1,1,1,2,1,1,1,1,1,1,2,2,1,0,1,1,3,2,6], [2,3,2,2,2,0,2,1,2,0,1,3,2,2,1,1,0,3,2,1,3,3,3,6], [2,1,2,0,0,2,0,1,2,0,1,1,2,2,1,1,2,1,2,1,3,1,3,2,6], [2,1,0,0,2,2,2,1,2,2,1,1,2,2,1,1,0,1,2,3,1,3,1,2,2,6], [0,1,2,0,2,0,2,1,0,0,1,1,2,2,1,1,0,1,2,1,3,1,1,2,2,2,6], [2,1,2,0,2,0,0,1,0,2,1,1,2,2,1,1,2,1,2,1,1,1,3,2,2,2,2,6]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [-1,1,1,-1,1,1,-1,0,-1,1,1,1,0,0,-1,-1,-2,0,2,0,0,-1,0,0,0,0,-1,0], [0,0,0,1,0,0,-1,-1,1,0,1,0,1,0,0,0,-2,0,0,0,0,0,0,-1,0,0,0,1], [1,-1,-1,0,-1,0,1,-1,1,0,-1,-1,0,0,1,1,1,1,-1,0,0,1,0,0,-1,-1,1,1], [-1,-1,2,0,1,-1,-1,-1,1,1,3,2,1,-1,-1,-1,-4,0,2,0,-1,-1,1,-1,1,0,-1,0], [0,-1,0,1,-1,1,-1,-2,2,1,1,0,1,0,0,0,-2,0,0,0,0,0,0,0,-1,-1,1,1], [-3,0,3,1,2,0,-4,-1,1,2,5,3,2,-1,-2,-3,-8,-1,3,1,-2,-2,1,-1,2,0,-1,0], [-3,1,2,0,1,0,-3,0,1,1,3,2,1,-1,-1,-2,-5,0,2,1,-1,-1,0,-1,1,0,-1,1], [-1,-1,1,0,2,-1,-1,0,0,1,2,2,1,-1,-1,-1,-3,-1,1,0,-1,-1,0,0,2,0,-1,0], [1,-1,0,0,0,-1,1,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0], [0,-1,1,1,0,0,-1,-1,1,0,1,0,1,0,0,0,-2,0,0,0,0,0,0,-1,0,0,0,1], [-3,0,3,1,1,0,-3,-1,1,1,4,2,1,-1,-1,-2,-6,0,2,1,-2,-1,0,-1,2,0,-1,1], [-1,0,1,1,-1,1,-3,-1,2,1,2,0,1,0,0,-1,-4,0,0,1,-1,0,0,0,0,-1,1,1], [1,-1,0,0,-1,0,1,-1,0,0,-1,-1,1,0,0,1,1,0,0,0,0,0,0,1,-1,0,0,0], [1,-1,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,1,2,-1,2,-1,-1,1,-1,0,2,2,0,-1,-1,-1,-3,0,2,0,-1,-1,0,-1,2,1,-2,0], [-1,0,1,1,1,0,-2,0,1,0,2,1,0,0,0,-1,-3,0,0,0,-1,0,0,-1,1,0,0,1], [-1,0,1,1,-1,0,-1,-1,1,0,1,0,1,0,0,0,-2,0,0,1,-1,0,0,0,0,0,0,1], [1,-1,-1,0,-1,0,1,-1,1,0,-1,-1,0,0,1,1,1,1,-1,0,1,1,0,0,-1,-1,1,1], [-1,1,1,-1,1,1,-1,1,-1,0,1,1,0,0,-1,-1,-2,0,2,0,0,-1,0,0,0,0,-1,0], [-1,-1,1,2,-1,0,-2,-2,2,1,2,0,1,0,0,0,-3,0,0,1,-1,0,0,0,0,-1,1,1], [-3,1,3,-1,3,0,-3,1,-1,1,4,3,1,-1,-3,-3,-6,-1,4,1,-2,-3,1,0,2,1,-2,-1], [-1,0,1,1,0,0,-2,0,1,0,2,0,1,0,0,-1,-3,0,0,1,-1,-1,0,0,0,0,0,1], [-3,2,3,-1,2,0,-3,2,-1,0,4,3,0,-1,-2,-3,-5,-1,3,1,-2,-2,0,0,2,1,-2,0], [-1,-2,1,1,0,-1,-1,-1,2,1,2,1,1,-1,0,0,-3,0,0,1,-1,0,0,0,1,-1,0,1], [0,-1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0], [-2,0,2,0,2,0,-2,0,0,1,3,2,1,-1,-2,-2,-5,-1,2,1,-2,-2,1,0,2,0,-1,0]], [[-4,0,4,-1,3,-1,-3,1,0,1,5,4,1,-2,-2,-3,-7,0,4,1,-3,-3,1,-1,3,1,-2,-1], [-3,-1,4,0,3,-2,-3,0,1,1,6,4,2,-2,-2,-3,-8,0,3,1,-3,-3,2,-2,3,1,-2,-1], [-2,-1,3,1,1,-1,-2,-1,1,1,4,2,2,-1,-1,-2,-6,0,2,1,-2,-2,1,-1,2,0,-1,0], [1,-1,1,0,0,-1,0,0,0,0,1,0,1,0,0,0,-1,0,0,0,-1,-1,1,0,0,0,0,-1], [-4,2,3,-1,2,0,-3,1,0,0,4,3,0,-1,-1,-3,-6,1,3,1,-2,-2,1,-2,2,1,-2,0], [-1,1,1,-1,1,1,-1,1,-1,0,1,1,0,0,-1,-1,-2,0,2,0,0,-1,0,0,0,0,-1,0], [-1,0,2,0,3,-1,-1,1,-1,0,3,2,1,-1,-2,-2,-4,-1,2,0,-1,-2,1,-1,2,1,-2,-1], [1,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [-2,0,2,0,1,0,-2,0,1,0,3,2,0,-1,0,-2,-4,1,1,1,-2,-1,1,-1,1,0,0,0], [-1,0,1,-1,2,0,-1,1,0,0,2,2,0,-1,-1,-2,-3,0,2,0,-1,-1,1,-1,1,0,-1,0], [-2,2,1,-1,1,1,-2,1,-1,0,2,1,0,0,-1,-2,-3,0,2,1,-1,-1,0,0,1,0,-1,0], [-1,-1,2,0,2,-2,-1,1,0,0,3,2,1,-1,-1,-1,-3,0,1,0,-2,-2,1,-1,2,1,-1,-1], [-1,0,1,0,2,-1,-1,1,0,0,2,2,0,-1,-1,-1,-3,0,1,0,-1,-1,0,-1,2,0,-1,0], [-1,0,1,1,1,0,-2,0,1,0,2,1,0,0,0,-1,-3,0,0,0,-1,0,0,-1,1,0,0,0], [0,0,0,0,0,-1,0,1,0,-1,0,0,0,0,1,0,0,1,-1,0,0,0,0,-1,0,1,0,0], [-1,0,1,-1,0,0,0,0,0,0,1,1,0,0,0,0,-1,1,1,0,0,0,0,-1,0,0,-1,0], [-1,1,0,0,-1,1,-2,0,1,0,1,0,0,0,1,-1,-2,1,0,1,-1,0,0,0,0,-1,1,1], [-1,-1,2,0,2,-1,-1,0,0,1,3,2,1,-1,-2,-1,-4,-1,2,0,-2,-2,1,0,2,0,-1,-1], [1,0,-1,0,-1,-1,1,1,0,-1,-1,-1,-1,0,2,1,2,1,-2,0,0,1,-1,0,0,0,1,0], [-4,2,3,-1,2,0,-3,2,-1,0,4,3,0,-1,-1,-3,-5,0,3,1,-2,-2,0,-1,2,1,-2,0], [-1,0,1,1,0,-1,-1,0,0,0,2,0,1,0,0,-1,-2,0,0,1,-1,-1,0,0,1,0,0,0], [-1,1,1,-1,3,-1,0,2,-2,0,2,2,0,-1,-2,-2,-2,-1,2,0,-1,-2,0,0,2,1,-2,-1], [0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,-1,-1,0,0,0,0,-1,0,0,0,0,0,0], [-1,-1,2,0,2,-2,0,0,0,0,3,2,1,-1,-1,-1,-3,0,1,0,-2,-2,1,-1,2,1,-1,-1], [0,-1,0,1,0,0,-1,-1,1,1,1,0,1,0,0,0,-2,0,0,0,0,0,0,0,0,-1,1,0], [-2,2,1,-1,2,0,-1,2,-1,-1,2,2,-1,-1,-1,-2,-2,0,2,0,-1,-1,0,-1,1,1,-1,0], [0,0,0,1,0,-1,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,-1,1,0,0,0], [-2,1,1,-1,2,0,-1,1,0,0,2,2,0,-1,-1,-2,-3,0,2,0,-1,-1,0,-1,2,0,-1,0]]]], [ # Q-class [28][17] [[6], [2,6], [2,2,6], [2,2,2,6], [2,2,2,2,6], [2,2,2,2,2,6], [2,2,0,2,0,2,6], [2,2,2,2,2,2,2,6], [2,2,2,2,2,0,0,2,6], [2,2,2,0,2,2,0,2,0,6], [2,2,2,2,2,2,0,2,2,0,6], [2,2,2,0,0,2,0,2,2,2,2,6], [3,1,3,1,1,1,1,1,1,3,1,1,6], [2,0,2,2,2,0,0,2,2,2,0,0,3,6], [2,2,2,2,2,2,2,2,2,2,0,2,1,2,6], [2,2,0,2,2,2,2,2,0,2,0,0,1,2,2,6], [2,2,2,2,0,2,2,2,0,2,2,2,3,2,2,2,6], [2,2,2,2,2,2,0,2,0,2,2,0,1,2,0,2,2,6], [2,2,2,2,0,2,2,2,0,2,2,2,1,0,2,2,2,2,6], [2,0,2,2,2,0,0,2,2,0,2,0,1,2,0,2,0,2,2,6], [2,0,2,2,0,2,0,2,0,2,2,2,1,2,0,0,2,2,2,2,6], [2,2,2,2,2,2,0,2,2,2,2,2,1,0,0,0,0,2,2,2,2,6], [0,0,2,2,2,2,0,2,0,2,2,0,1,2,2,2,2,2,2,2,2,0,6], [2,2,2,0,2,0,0,2,2,2,2,2,1,2,2,2,2,2,2,2,0,0,2,6], [2,2,2,2,0,0,0,0,2,2,0,2,1,2,2,0,2,2,2,0,2,2,0,2,6], [2,2,2,2,2,2,0,2,2,2,2,2,1,2,2,0,2,2,0,0,2,0,2,2,2,6], [2,0,2,0,2,2,0,2,0,2,2,2,1,2,2,2,2,2,2,2,2,0,2,2,0,2,6], [0,0,2,2,0,0,0,2,2,0,2,2,1,2,2,0,2,0,2,2,2,0,2,2,2,2,2,6]], [[[-22,-1,-10,3,2,-2,-5,10,2,-26,-5,-7,34,-20,12,9,-11,-2,0,-7,23,5,-4,17,10,6,12,-16], [4,-1,3,-2,0,-2,1,-4,2,3,-1,0,-6,2,-1,1,3,2,2,-2,-1,2,0,-2,-6,1,-3,4], [-1,0,0,0,0,-1,0,0,1,-2,-1,-1,2,-2,1,1,0,0,0,-1,2,1,0,1,0,1,1,-1], [-9,0,-4,1,0,-1,-2,4,1,-11,-2,-3,14,-8,5,4,-5,-1,0,-3,9,3,-1,7,4,3,5,-7], [-4,0,-2,1,0,0,-1,2,1,-4,-1,-2,6,-4,2,1,-2,-1,0,-1,4,1,-1,3,2,1,3,-3], [-9,0,-4,2,0,-1,-2,4,1,-10,-2,-3,14,-8,5,3,-5,-1,0,-3,9,2,-1,7,4,2,6,-7], [-16,-1,-7,2,1,-1,-4,7,1,-19,-3,-5,24,-13,9,7,-8,-2,1,-5,16,4,-3,12,7,5,8,-12], [-15,-1,-6,1,1,-2,-3,6,1,-18,-3,-5,22,-12,8,7,-7,-2,1,-5,15,5,-3,11,6,6,8,-11], [-2,-1,0,-1,1,-1,0,0,1,-2,0,-1,2,-2,1,2,0,0,1,-1,2,1,-1,1,0,2,0,-1], [-1,0,0,-1,1,-2,0,-1,2,-3,-2,-1,2,-2,1,2,0,1,1,-3,4,2,0,1,-2,1,1,0], [-3,-1,0,0,0,-1,0,1,0,-3,0,-1,4,-3,2,2,-2,0,0,-1,3,1,-1,2,1,2,1,-2], [-7,-1,-2,0,1,-2,-1,2,1,-8,-1,-2,10,-6,4,4,-3,0,1,-3,8,2,-2,5,2,3,3,-5], [-4,0,-2,1,1,-1,-1,2,1,-6,-2,-1,7,-5,2,2,-2,0,0,-2,5,1,0,3,2,1,3,-3], [-7,0,-3,1,1,-1,-1,3,1,-8,-2,-2,10,-6,3,3,-3,-1,0,-2,7,2,-1,5,3,2,4,-5], [-10,-1,-4,1,1,-1,-2,4,2,-11,-2,-3,14,-8,5,4,-4,-1,1,-3,10,2,-2,7,4,3,5,-8], [-8,0,-4,1,0,0,-2,4,1,-9,-2,-3,12,-7,4,3,-4,-1,0,-2,8,2,-1,6,4,2,5,-6], [-7,-1,-2,0,1,-2,-1,2,1,-9,-2,-2,10,-6,4,4,-3,0,1,-3,8,3,-1,5,2,3,3,-5], [-3,1,-2,1,0,-1,-1,1,1,-5,-3,-2,6,-4,2,1,-2,0,0,-2,5,2,0,4,0,1,3,-2], [-9,0,-4,1,0,-1,-2,4,1,-11,-2,-3,14,-8,5,4,-5,-1,0,-3,10,2,-1,7,4,3,5,-7], [-9,1,-5,2,0,1,-2,5,0,-10,-2,-3,14,-8,4,2,-5,-2,-1,-1,8,1,-1,7,6,2,6,-7], [-13,0,-5,1,1,-2,-2,5,1,-16,-3,-4,20,-11,7,6,-7,-1,0,-5,14,4,-2,10,5,4,7,-9], [-3,1,-2,1,0,-1,-1,1,1,-5,-2,-2,6,-4,2,1,-2,0,0,-3,5,2,0,4,0,1,3,-2], [-3,0,-1,0,0,0,0,2,0,-3,0,-1,4,-2,1,1,-2,-1,0,0,2,0,0,1,3,1,2,-3], [-2,-1,0,-1,1,-1,0,0,1,-2,-1,-1,2,-2,1,2,0,0,1,-1,3,1,-1,1,0,2,0,-1], [-1,0,0,-1,1,-2,0,-1,2,-3,-2,-1,2,-2,1,2,0,1,1,-3,4,2,0,2,-2,1,0,0], [-3,-1,0,-1,1,-2,0,0,1,-4,-1,-1,4,-3,2,3,-1,0,1,-2,4,2,-1,2,0,2,1,-2], [-10,0,-4,2,0,0,-2,5,0,-10,-1,-3,14,-8,5,3,-5,-2,-1,-1,9,1,-2,7,6,2,6,-8], [-2,0,0,0,0,0,0,1,0,-2,0,0,2,-1,0,1,-1,-1,0,0,1,0,0,1,2,1,1,-2]], [[-7,0,-4,1,1,1,-2,5,0,-8,-1,-2,11,-6,3,2,-4,-2,0,-1,6,0,-1,5,6,1,4,-6], [0,-1,1,-1,0,0,0,0,0,1,1,0,-1,1,0,1,0,0,1,0,-1,0,-1,-1,0,1,-1,0], [0,-1,1,-2,1,-1,0,-1,1,0,0,0,-1,0,1,2,1,1,1,-1,1,1,-1,-1,-2,1,-2,1], [1,-1,1,-1,0,0,0,0,0,1,1,0,-1,0,0,1,0,0,0,0,-1,0,0,-1,0,0,-1,1], [-10,-1,-4,0,1,-1,-2,4,1,-12,-2,-3,15,-8,6,5,-5,-1,1,-3,10,3,-2,7,4,4,4,-7], [-7,-1,-3,0,1,-1,-2,3,1,-9,-2,-3,11,-6,4,4,-3,-1,1,-3,8,3,-2,6,2,3,3,-5], [-2,0,-1,1,0,1,-1,2,0,-2,-1,-1,3,-2,0,0,-1,-1,0,0,1,0,0,2,2,0,2,-2], [-2,0,-1,0,0,1,-1,2,0,-2,0,-1,3,-1,1,0,-1,-1,0,0,1,0,0,1,2,0,1,-2], [-9,-1,-4,1,1,0,-2,5,0,-9,0,-2,13,-7,5,3,-5,-1,0,-1,7,0,-2,5,6,2,4,-7], [1,0,0,-1,0,0,0,-1,1,0,-1,0,-1,1,0,0,1,1,1,-1,0,1,0,0,-2,0,-1,1], [4,-1,3,-2,0,0,1,-2,0,5,2,1,-7,4,-2,0,2,0,1,1,-4,-1,0,-4,-2,0,-4,3], [-9,-1,-4,0,1,-1,-2,4,1,-10,-1,-3,13,-7,5,4,-4,-1,1,-3,9,2,-2,6,4,3,4,-7], [1,0,0,0,0,1,0,0,0,2,0,1,-2,1,-1,-1,1,0,0,1,-2,-1,0,-1,0,-1,-1,1], [-7,0,-4,1,0,1,-2,4,0,-8,-1,-2,11,-6,4,2,-4,-1,-1,-1,6,1,-1,5,5,1,4,-5], [-5,-1,-2,-1,1,-1,-1,2,1,-6,-1,-2,7,-4,3,3,-2,0,1,-2,5,2,-1,3,2,2,2,-3], [-6,0,-3,0,0,1,-2,4,-1,-7,0,-2,9,-4,3,2,-3,-2,0,0,4,1,-1,4,5,2,3,-5], [11,0,5,-2,-1,1,2,-5,0,13,2,3,-17,9,-6,-4,6,1,0,3,-11,-2,2,-8,-5,-3,-6,8], [1,0,1,-1,0,0,0,-1,0,0,0,0,-1,1,0,1,0,0,0,-1,0,1,0,0,-1,0,-1,1], [6,0,3,-2,0,0,1,-3,0,6,1,1,-9,5,-3,-1,3,1,1,0,-5,0,1,-4,-4,-1,-4,5], [-7,0,-3,0,1,0,-2,4,0,-9,-1,-2,11,-6,4,3,-4,-1,0,-2,7,1,-1,5,4,2,3,-5], [-1,0,-1,0,0,0,-1,1,1,-3,-1,-1,3,-2,1,1,-1,0,0,-2,3,1,0,2,0,0,1,-1], [-6,-1,-2,0,1,-1,-1,2,1,-7,-1,-2,9,-5,4,3,-3,0,1,-3,7,2,-2,5,1,2,2,-4], [6,0,3,-2,-1,0,1,-3,0,6,1,1,-9,5,-2,-1,3,1,0,1,-5,0,1,-4,-4,-1,-4,5], [0,0,0,-1,0,1,0,0,0,1,1,0,-1,1,0,0,0,0,0,1,-1,-1,0,-1,1,0,-1,0], [1,0,0,0,0,0,0,-1,1,1,0,0,-1,0,0,0,0,1,0,-1,0,0,0,0,-1,-1,0,1], [-1,0,-1,0,0,0,-1,1,1,-2,-1,-1,3,-2,1,1,-1,0,0,-1,2,0,0,1,1,0,1,-1], [-7,0,-3,-1,1,-1,-2,3,1,-10,-2,-3,11,-6,4,4,-3,-1,1,-3,8,3,-1,5,3,3,3,-5], [-2,0,-1,0,0,0,-1,1,1,-2,0,-1,3,-2,1,1,-1,0,0,-1,2,0,0,1,1,0,1,-1]]]], [ # Q-class [28][18] [[6], [3,6], [3,2,6], [3,2,2,6], [2,3,3,1,6], [2,3,3,3,2,6], [1,1,3,1,3,1,6], [3,3,1,3,1,3,-2,6], [3,1,1,3,1,1,2,2,6], [3,3,1,1,1,1,0,2,2,6], [3,2,2,2,1,1,1,1,1,3,6], [1,1,1,1,1,1,0,2,0,2,3,6], [0,1,1,1,2,2,1,1,-1,1,1,3,6], [2,1,3,1,2,2,1,1,1,3,3,3,2,6], [1,3,1,1,1,1,0,2,0,2,1,0,1,1,6], [1,3,1,1,1,1,0,2,0,2,3,2,1,1,2,6], [1,1,3,1,1,1,2,0,0,0,1,2,1,1,2,0,6], [2,3,1,1,0,2,-1,3,1,3,1,1,0,2,3,3,1,6], [1,2,2,2,1,3,3,1,1,1,2,1,1,1,1,1,1,1,6], [1,3,1,1,1,1,2,0,0,2,3,2,1,1,2,2,2,1,3,6], [2,3,1,1,2,2,-1,3,-1,1,1,1,2,0,1,1,1,2,1,1,6], [1,0,2,2,1,1,1,1,1,1,2,3,3,3,1,1,3,1,0,1,1,6], [1,2,2,2,3,3,3,1,1,1,0,1,3,1,1,1,1,1,2,1,1,2,6], [1,2,2,0,1,1,1,1,-1,1,2,3,3,1,1,1,3,1,2,3,3,2,2,6], [3,2,2,2,1,3,1,1,1,3,2,1,1,3,1,1,1,3,2,1,1,2,2,0,6], [2,1,1,1,2,0,1,1,1,1,3,3,2,2,-1,1,1,0,1,1,2,3,1,3,1,6], [1,1,1,1,1,1,0,2,0,0,1,2,1,1,0,0,2,1,1,2,3,3,1,3,1,3,6], [1,2,2,2,3,1,1,1,1,1,0,1,1,1,1,1,1,1,0,1,1,2,2,0,2,1,1,6]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [2,-2,-4,1,1,3,2,0,-2,2,-1,-1,-2,1,0,2,0,-1,0,-2,-1,1,-2,4,-1,-1,0,2], [-2,1,2,-1,0,-2,-1,2,1,-1,2,0,1,-1,-1,-2,0,1,0,1,0,0,1,-1,1,0,-1,0], [2,-1,-2,1,1,1,0,-1,-1,1,-1,0,-1,0,0,1,0,0,1,-1,-1,1,-1,2,-1,-1,0,1], [0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,-1,0,1], [2,-1,-4,1,1,2,2,1,-3,2,0,-2,-1,1,-1,1,1,0,1,-2,-2,1,-2,3,-2,-1,0,2], [-1,1,2,-1,-1,-2,-2,0,2,-2,1,1,1,0,0,-1,0,0,0,1,1,-1,2,-2,1,0,0,0], [0,1,0,-1,0,-1,-1,1,0,-1,2,-1,1,0,-1,-1,1,1,1,0,-1,0,1,-1,-1,0,0,1], [0,-1,0,0,-1,1,1,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,-1,0,0,0,1,0,1], [0,-1,-1,0,0,1,2,2,-1,1,0,-1,0,0,0,0,0,0,-1,0,-1,0,-1,1,0,0,0,1], [-2,0,2,0,0,-2,-1,2,1,-1,0,0,1,0,0,-1,0,0,-1,2,0,-1,1,-1,2,1,-1,-1], [0,0,-1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,-1,2,1,-1,0,0], [1,-2,-2,1,1,2,2,0,-1,1,-1,0,-1,0,1,1,-1,0,-1,-1,-1,0,-2,3,0,0,0,1], [1,0,-1,0,0,1,1,0,-1,0,0,0,-1,0,0,0,-1,0,0,-1,-1,1,-1,2,0,-1,0,1], [1,0,-1,0,-1,1,1,0,-1,1,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,-1,0,1,1], [1,-1,-3,1,1,2,2,1,-2,1,-1,-1,-2,1,0,1,-1,-1,0,-1,-1,2,-2,4,0,-1,-1,1], [1,0,0,0,-1,1,0,-2,0,0,0,1,0,0,1,0,-1,0,0,-1,0,0,0,0,-1,0,1,1], [1,-1,-3,0,0,1,2,2,-2,1,1,-2,0,1,-1,0,1,0,0,-1,-1,0,-1,2,-1,-1,0,2], [0,-1,-1,0,0,1,1,1,-1,1,0,-1,0,0,0,0,0,0,0,0,-1,0,-1,1,0,0,0,1], [2,0,-1,0,-1,1,-1,-3,1,0,-1,1,0,1,1,1,0,-1,1,-1,1,0,0,0,-1,-1,1,1], [1,-1,-3,1,1,2,2,0,-1,1,-1,0,-2,1,1,1,-1,-1,0,-2,-1,1,-2,4,0,-1,0,1], [1,0,-2,1,1,1,0,-1,-1,1,0,0,-1,0,0,0,0,0,1,-2,-1,1,-1,2,-1,-1,0,1], [1,-1,-3,1,1,2,1,0,-1,1,-1,-1,-1,1,0,1,0,-1,0,-1,-1,1,-2,3,0,-1,0,1], [0,-1,-1,1,0,1,2,0,-1,1,0,0,-1,0,1,0,-1,0,-1,-1,0,0,-1,2,0,0,0,1], [1,-1,-3,1,1,1,2,1,-1,1,-1,-1,-1,1,0,1,0,-1,0,-1,-1,1,-2,3,0,-1,0,1], [1,-2,-3,1,1,2,2,0,-1,1,-1,0,-2,1,1,1,-1,-1,0,-1,0,1,-2,3,0,-1,0,1], [0,0,1,0,0,-1,-2,-1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0]], [[-5,1,7,-1,-1,-4,-3,2,3,-2,1,1,2,-2,0,-3,0,1,-2,5,2,-2,3,-5,3,3,-2,-3], [0,0,1,-1,-1,0,-1,-1,1,0,0,0,1,0,0,0,1,0,0,1,1,-1,1,-2,-1,1,0,0], [-3,0,4,0,-1,-1,-1,0,2,-1,-1,2,0,-1,1,-1,-1,0,-2,3,2,-1,1,-2,2,2,-1,-2], [-3,0,3,0,-1,-2,0,2,1,-1,0,0,1,0,0,-1,0,0,-2,3,1,-2,1,-2,2,2,-1,-1], [-1,1,3,-1,-1,-1,-2,-1,2,-1,0,1,2,-1,0,-1,0,1,0,2,1,-1,1,-3,0,1,0,-1], [0,-1,0,0,-1,1,0,-1,1,0,-1,0,0,1,1,1,0,-1,-1,1,1,-1,0,0,0,1,0,0], [-2,0,2,0,0,-1,0,1,1,-1,0,1,0,-1,0,-1,-1,1,-1,2,1,0,0,-1,1,1,-1,-1], [-2,1,3,-1,-1,-2,-2,0,2,-1,1,0,2,0,0,-1,1,0,-1,2,1,-2,2,-3,1,1,0,-1], [-4,1,6,-1,-1,-4,-3,1,3,-2,1,1,2,-1,0,-2,0,1,-1,4,2,-2,3,-5,2,2,-1,-2], [-2,1,5,-1,-1,-3,-4,-1,3,-1,0,1,2,-1,0,-1,1,0,0,3,2,-2,3,-5,1,2,0,-2], [-3,1,5,-1,-1,-4,-3,2,2,-2,1,0,2,-1,-1,-2,1,1,-1,4,1,-2,3,-4,2,2,-1,-2], [-1,2,3,-1,-1,-3,-3,0,2,-2,1,0,2,0,-1,-1,1,0,0,2,1,-1,2,-3,1,0,0,-1], [1,1,0,0,-1,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,-1,-1,0,1,0], [-2,2,5,-1,-2,-3,-4,-1,3,-2,0,1,2,0,0,-1,1,0,0,3,2,-2,3,-5,1,2,0,-2], [0,0,1,0,-1,0,-1,-2,1,0,0,1,1,0,1,0,1,0,0,0,1,-2,1,-2,-1,1,1,0], [-1,1,3,-1,0,-2,-3,0,1,-1,1,0,2,-1,-1,-1,1,1,0,2,0,-1,2,-3,0,1,0,-1], [0,-1,0,1,0,1,1,-1,0,0,-1,1,-1,0,1,0,-1,0,-1,0,1,0,-1,1,0,0,0,0], [-1,0,2,0,0,-1,-2,-1,1,0,0,0,1,0,0,0,1,0,0,1,1,-1,1,-2,0,1,0,-1], [-2,-1,1,0,0,-1,1,2,1,-1,0,0,0,0,0,0,0,0,-2,2,1,-1,0,0,2,1,-1,-1], [0,0,1,-1,-1,-1,-1,0,1,-1,0,0,1,0,0,0,1,0,0,1,1,-1,1,-2,0,1,0,0], [0,-1,-1,0,0,1,2,1,-1,1,0,-1,0,0,0,0,0,0,-1,0,0,0,-1,1,0,0,0,0], [-2,1,3,0,-1,-2,-1,1,1,-1,0,0,1,0,0,-1,0,0,-1,2,1,-1,1,-2,1,1,0,-1], [-1,0,1,0,-1,0,0,0,1,0,0,0,1,0,0,0,0,0,-1,1,1,-1,0,-1,0,1,0,0], [0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0], [-3,0,4,0,0,-2,-2,1,2,-1,0,0,1,-1,0,-1,0,0,-1,3,1,-1,1,-2,2,2,-1,-2], [-3,2,5,-1,-1,-4,-2,2,2,-2,1,0,2,-1,-1,-2,0,1,-1,3,1,-1,2,-3,2,1,-1,-2], [-1,0,0,0,0,0,1,1,0,0,0,-1,0,0,0,0,0,0,-1,0,0,0,-1,1,1,0,0,0], [-2,1,4,-1,-1,-2,-2,0,2,-1,0,1,2,-1,0,-1,0,0,0,2,1,-1,1,-3,1,1,0,-1]]]], [ # Q-class [28][19] [[4], [0,4], [1,2,4], [2,0,2,4], [1,2,2,2,4], [2,1,0,1,1,4], [0,1,1,1,0,0,4], [2,1,1,1,2,2,0,4], [1,1,1,1,0,1,2,0,4], [1,1,1,1,0,1,2,0,2,4], [1,1,2,1,1,0,1,1,2,1,4], [0,1,2,1,1,0,2,0,1,1,2,4], [0,1,1,1,0,0,2,0,2,2,1,1,4], [1,1,1,1,0,1,2,0,2,2,1,1,2,4], [1,1,2,1,1,0,1,1,1,2,2,2,1,1,4], [1,1,2,1,1,0,1,1,1,1,2,2,1,2,2,4], [2,0,1,2,1,1,1,1,1,1,1,1,0,0,1,0,4], [0,1,2,1,1,0,1,0,1,1,2,2,2,1,2,2,0,4], [2,0,1,2,1,1,0,1,1,1,1,0,1,0,1,0,2,1,4], [0,2,1,0,1,1,1,1,2,1,2,1,1,1,1,1,0,1,0,4], [0,2,1,0,1,0,1,0,1,0,1,1,0,0,0,0,0,0,0,2,4], [2,0,1,2,1,1,1,1,1,2,1,1,1,1,2,1,2,1,2,0,0,4], [0,2,1,0,1,0,0,0,1,0,1,0,1,0,0,0,0,1,0,2,2,0,4], [2,1,1,1,0,2,0,0,2,2,1,0,0,2,1,1,1,0,1,1,0,1,0,4], [2,0,1,2,1,1,1,1,2,1,2,1,1,1,1,1,2,1,2,0,0,2,0,1,4], [0,2,1,0,1,1,0,1,1,0,1,0,0,1,0,1,0,0,0,2,2,0,2,1,0,4], [2,0,1,2,1,1,0,1,0,0,0,0,0,0,0,0,2,0,2,0,0,0,0,1,0,0,4], [1,1,0,1,1,2,0,1,1,1,0,0,0,0,0,0,1,0,1,1,1,1,1,1,1,1,0,4]], [[[-2,-1,0,0,0,0,0,2,0,0,0,0,0,1,0,0,0,0,0,-1,1,0,1,1,0,-1,0,0], [0,0,1,0,0,1,0,-1,0,0,1,-1,0,0,0,0,0,-1,0,0,0,0,0,-1,0,0,0,0], [0,-1,1,-1,1,1,1,-1,-1,0,1,-1,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [-1,-2,0,-1,1,0,1,1,-1,0,0,0,1,0,0,0,0,0,0,-1,1,0,1,2,0,0,0,0], [0,-2,0,0,1,0,1,1,-1,0,0,0,1,0,0,0,1,0,1,-1,1,-2,1,2,-1,0,-2,0], [-2,-1,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,1,2,0,-1,0,0], [0,0,0,0,0,1,0,-1,0,0,1,0,0,0,0,0,-1,-1,0,0,0,1,0,-1,0,0,1,0], [-1,-1,0,0,0,0,0,2,0,0,0,0,0,1,0,0,1,0,1,-1,1,-1,1,1,-1,-1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,-1,0,0,1,0,0,1,0,1,0], [0,0,0,0,0,-1,0,1,0,0,0,1,0,0,-1,-1,-1,0,0,0,0,1,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,-1,-1,0,1,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,1,0,0,1,0,1,0], [0,0,0,0,0,-1,-1,1,0,1,0,1,0,1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,0,0,0,0,1,-1,0,0,0,0,1,0,0,0,0,0,0,1,0,1,1,0,-1,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,-1,1,0,-1,0,3,0,1,-1,1,-1,1,-1,0,1,1,1,-1,1,-1,2,2,-1,-1,-2,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,2,0,-2,0,0,1,-1,0,0,1,0,0,-1,0,0,0,0,0,-2,0,0,0,0], [-1,-1,-1,1,0,-1,-1,3,0,1,-1,1,0,1,-1,0,1,1,1,-1,2,-1,1,2,-1,-1,-2,-1], [0,0,1,0,0,1,0,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [-1,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,-1,-1,0,-1,0,0,1,0,1,1,0,1,0], [-1,-1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,-1,1,0,1,1,0,-1,0,0], [0,0,1,0,0,1,0,-1,0,0,0,-1,0,0,1,0,0,-1,0,0,0,0,0,-1,0,0,0,0], [-1,-1,0,0,0,0,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0], [-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,1,1,0,-1,0,0]], [[0,1,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,-1,0,0,0,-1,1,0,-1,0,0,1,0], [0,0,0,0,0,1,0,-1,0,0,1,0,0,0,1,0,-1,-1,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,-1,1,0,-1,0,2,1,1,-1,1,-1,0,-1,0,0,1,1,-1,0,-1,1,1,-1,0,-1,-1], [0,0,0,0,0,0,0,0,1,1,0,0,-1,0,0,0,-1,0,0,0,0,0,0,-1,0,0,1,0], [0,1,0,0,0,1,0,-1,1,0,1,0,-1,0,0,0,-1,-1,0,0,-1,1,0,-2,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,-1,0,0,0,0,1,0,-1,0,0,1,0], [1,1,0,0,0,0,0,-1,0,0,1,0,0,0,0,-1,-1,0,-1,0,-1,1,-1,-1,0,1,1,0], [0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,0,1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [1,0,-1,1,0,-1,0,1,0,0,0,1,0,0,0,-1,0,1,0,-1,0,-1,0,1,-1,1,-1,0], [0,1,-1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,1,0,0,-1,0,0,0,1,0,0,0,-1,0,0,0,-1,0,0,0,-1,1,0,-1,0,0,1,0], [1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,-1,0], [1,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,-1,0,0,0,-1,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,-1,0,-1,0,0,1,0,0,0,0,1,0], [-1,0,1,-1,0,1,0,-1,0,0,1,-1,0,0,1,0,-1,-1,-1,0,0,1,0,-1,1,0,2,0], [0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-1,0,-1,0,0,0,0,0,1,0,1,0], [0,1,0,0,0,1,0,-1,0,0,1,0,0,0,0,0,-1,-1,0,0,-1,1,0,-1,0,0,1,0], [1,1,0,0,0,0,0,-1,1,0,0,0,0,-1,0,0,-1,0,-1,0,-1,1,-1,-1,0,1,1,0], [-1,0,0,0,0,1,0,-1,0,0,1,-1,0,0,1,0,-1,-1,-1,0,0,1,0,-1,1,0,2,0], [0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,-1,0,1,0,-1,0,1,0,0,0,0,0], [0,1,0,1,-1,1,-1,0,1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,-2,0,0,0,-1]]]], [ # Q-class [28][20] [[8], [-2,8], [1,2,8], [0,3,3,8], [-1,4,4,3,8], [2,1,1,3,2,8], [2,1,1,3,2,2,8], [2,4,1,0,2,-1,-1,8], [3,0,0,1,0,3,0,0,8], [3,0,3,2,0,3,0,0,4,8], [3,0,3,2,3,3,3,0,1,2,8], [0,3,3,2,3,0,3,0,1,2,2,8], [1,2,2,3,4,4,1,1,0,0,3,0,8], [1,2,2,0,1,1,1,1,0,0,0,0,2,8], [1,2,2,3,1,1,1,1,3,3,0,0,-1,2,8], [0,3,3,4,3,3,0,0,2,4,1,1,3,0,3,8], [3,0,0,2,0,3,3,0,4,2,2,2,3,0,0,1,8], [0,3,0,4,3,3,0,3,2,1,1,1,3,0,0,2,1,8], [1,2,2,3,1,4,1,1,0,3,3,0,2,2,2,3,0,3,8], [2,1,1,3,2,2,2,2,3,3,0,0,1,1,1,3,3,3,1,8], [0,3,0,4,0,3,3,0,2,1,1,1,0,0,3,2,1,2,3,0,8], [3,0,0,1,0,3,3,0,2,1,4,1,3,3,0,-1,4,2,3,0,2,8], [2,1,4,3,2,2,2,2,0,3,3,0,1,1,4,3,0,0,4,2,3,0,8], [1,2,2,3,1,1,1,1,0,0,0,0,2,2,2,3,0,0,2,1,3,0,4,8], [0,3,3,4,3,3,3,0,-1,1,4,4,3,0,0,2,1,2,3,0,2,2,3,3,8], [2,1,1,3,-1,2,2,-1,3,3,0,0,1,1,4,3,3,0,1,2,3,0,2,1,0,8], [2,1,4,3,2,2,2,-1,0,3,3,3,1,1,1,3,0,0,1,2,0,0,2,1,3,2,8], [2,1,1,3,2,2,2,2,0,0,3,0,4,1,1,0,3,3,1,2,0,3,2,1,3,2,2,8]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,2,1,-2,-3,1,-1,-2,-2,-1,2,2,2,-2,3,-1,-1,1,-1,3,-1,1,0,1,-1,0,-1,-1], [0,1,0,0,0,0,0,-1,0,0,0,-1,-1,0,0,0,1,1,0,-1,-1,0,1,0,0,0,0,0], [0,2,0,0,-1,1,0,-1,-1,0,1,0,0,-1,1,-1,0,1,-1,0,-2,1,1,1,-1,0,0,-1], [0,2,1,-4,-2,-1,-1,-3,-3,0,2,0,3,-2,5,-3,2,3,0,3,1,-1,-1,1,0,-1,1,-2], [0,0,0,-1,0,-1,0,0,0,1,0,-1,1,0,1,-1,1,0,1,0,1,-1,-1,0,1,-1,1,0], [-1,0,0,1,0,1,1,1,1,0,0,0,-1,0,-1,1,-1,-1,0,-1,-1,1,0,0,-1,0,0,1], [0,1,0,0,-2,1,-1,-1,-1,-1,1,2,1,-1,1,0,-1,0,-1,2,-1,1,1,0,-1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,1,1,-3,-1,-1,0,-2,-2,1,1,-1,2,-1,3,-2,2,3,0,1,1,-1,-1,1,0,-1,1,-1], [0,1,1,-3,-1,0,-1,-2,-3,0,2,0,1,-1,3,-1,1,2,-1,2,1,0,-1,1,0,0,0,-1], [1,2,1,-4,-2,-1,-1,-3,-3,0,2,0,3,-2,5,-3,2,3,0,3,1,-1,-1,1,0,-1,1,-2], [0,1,0,1,-1,1,0,0,1,-1,0,1,-1,0,-1,1,-1,-1,0,0,-1,1,1,0,-1,0,-1,1], [-1,0,-1,3,0,2,1,2,2,-1,-1,1,-2,0,-3,2,-2,-2,0,-2,-3,2,2,0,-1,1,-1,1], [0,1,0,-1,-1,0,0,-1,-1,0,1,0,1,-1,2,-1,0,1,0,1,-1,0,0,1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,2,1,-3,-2,0,-2,-3,-4,0,2,1,3,-2,5,-3,1,2,-1,4,1,0,-1,1,0,-1,0,-2], [0,0,0,0,-1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,1,0,0,-1,0,0,-1,0,0,1,0,1,0,1,-1,0,0,0,1,0,-1,0,0,0,-1,0,0], [-1,0,-1,3,0,2,1,2,2,0,-1,1,-2,0,-3,2,-3,-2,-1,-2,-3,3,2,0,-1,1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [-1,0,-1,2,0,1,1,1,2,0,-1,0,-1,0,-2,1,-1,-1,0,-2,-2,1,2,0,-1,0,0,1], [0,1,-1,2,0,0,1,0,2,0,-1,0,-1,0,-2,1,-1,-1,0,-2,-2,1,2,0,-1,0,0,1], [0,1,1,-3,-1,-1,0,-2,-2,1,1,-1,2,-1,3,-2,2,2,0,1,1,-1,-1,1,0,-1,1,-1], [0,0,0,1,0,1,1,1,1,0,0,0,-1,0,-1,1,-1,-1,0,-1,-1,0,0,0,0,0,-1,1], [0,1,0,-1,0,0,0,-1,-1,1,1,-1,0,0,1,-1,1,1,0,0,0,-1,-1,1,0,0,0,0], [1,2,1,-3,-2,0,-1,-3,-3,0,2,1,3,-2,4,-3,1,2,0,3,1,-1,-1,1,-1,-1,0,-1]], [[-2,-2,-2,7,2,2,2,5,5,0,-2,0,-5,2,-7,4,-3,-4,0,-5,-4,3,2,-1,-1,2,-1,2], [1,1,0,0,1,0,-1,-1,-1,0,0,-1,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,1,0,1,0,0,0,0,0,0,-1,0,-1,1,0,0,-1,-1,-1,1,1,0,-1,0,0,0], [0,0,0,0,1,1,-1,0,-1,0,0,0,-1,0,0,0,0,0,-1,0,0,1,0,0,0,1,0,0], [1,1,0,0,1,0,-1,-1,-1,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,2,1,1,0,2,1,0,-1,0,-2,0,-2,1,-1,-2,0,-1,-1,2,0,0,0,1,0,1], [0,1,0,1,-1,2,-1,0,0,-1,0,2,0,-1,0,0,-2,-1,-1,1,-2,2,1,0,-1,1,-1,0], [0,0,-1,3,1,1,0,1,1,0,0,0,-3,1,-3,2,-1,-1,0,-2,-2,1,1,0,-1,1,-1,1], [-2,-2,-1,4,2,1,2,4,4,0,-2,-1,-4,2,-5,3,-1,-3,1,-4,-2,1,1,-1,0,1,0,2], [-1,0,0,1,0,1,1,1,1,0,0,0,-1,0,-1,1,-1,-1,0,-1,-1,1,0,0,-1,0,0,1], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [1,2,1,-2,-1,0,-1,-2,-2,0,1,0,2,-1,3,-2,1,1,0,2,1,-1,-1,0,0,-1,0,-1], [0,0,0,1,1,0,-1,0,0,0,0,0,-1,0,-1,0,0,-1,0,0,0,1,0,0,0,1,0,0], [-1,0,-1,3,0,2,0,2,1,-1,0,1,-2,0,-3,2,-2,-2,-1,-1,-3,3,2,0,-1,2,-1,0], [-1,-1,-1,2,2,1,1,2,2,0,-1,-1,-3,1,-3,2,0,-1,0,-3,-2,1,1,0,0,1,0,1], [0,0,0,0,1,0,0,0,0,0,0,-1,-1,0,0,0,1,0,0,-1,0,0,0,0,0,0,1,0], [-1,0,0,1,0,1,0,1,1,0,0,0,-1,0,-1,0,-1,-1,0,0,-1,1,0,0,0,1,0,0], [0,0,0,0,1,0,-1,0,-1,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0], [0,1,1,-1,-1,1,-1,-1,-2,-1,1,1,1,-2,2,-1,-1,1,-1,2,-1,2,0,1,-1,1,0,-1], [-1,0,-1,3,0,3,0,2,1,-1,0,2,-3,0,-3,2,-3,-2,-1,-1,-3,3,2,0,-2,2,-1,1], [0,-1,0,1,1,0,0,1,1,0,-1,-1,-1,1,-1,1,0,-1,0,-1,0,0,0,-1,1,0,0,1], [-1,0,0,1,0,0,0,1,1,0,0,0,0,0,-1,0,-1,-1,0,0,-1,1,0,0,0,1,0,0], [0,0,0,2,0,2,0,1,1,-1,0,1,-2,0,-2,2,-2,-1,-1,-1,-2,2,1,0,-1,1,-1,1], [0,-1,-1,3,1,1,0,2,2,-1,-1,0,-2,1,-3,2,-1,-2,0,-2,-1,1,1,-1,0,1,0,1], [1,1,1,-1,0,0,-1,-1,-1,0,0,0,1,-1,1,-1,0,0,0,1,1,0,-1,0,0,0,0,0], [-1,-1,-1,3,2,1,1,2,3,0,-2,-1,-3,1,-4,2,-1,-2,0,-3,-2,2,2,-1,0,1,0,1], [0,1,0,1,0,1,0,0,0,0,0,0,-1,0,-1,0,0,0,-1,-1,-1,1,1,0,-1,0,0,0], [0,0,0,0,1,0,-1,0,0,0,0,0,-1,0,-1,0,0,0,0,0,0,1,0,0,0,1,0,0]]]], [ # Q-class [28][21] [[6], [3,6], [2,2,6], [2,2,3,6], [2,2,2,2,6], [2,2,2,2,2,6], [2,2,2,2,3,2,6], [2,2,2,2,2,3,2,6], [3,3,3,3,3,3,3,3,6], [2,2,0,0,2,2,2,2,3,6], [2,2,2,2,3,2,3,2,3,2,6], [3,3,2,2,2,2,2,2,3,2,2,6], [2,2,3,3,2,2,2,2,3,3,2,2,6], [2,2,2,2,2,0,2,0,3,2,2,2,2,6], [2,2,2,2,2,2,2,2,3,2,2,2,2,2,6], [2,2,2,2,2,2,2,2,3,2,2,2,2,2,2,6], [0,0,2,2,2,2,2,2,3,2,2,3,2,2,2,2,6], [2,2,0,0,3,2,2,1,1,1,1,2,0,0,2,2,1,6], [2,1,0,0,1,1,3,1,1,1,2,0,0,0,0,0,0,2,6], [0,0,0,1,1,2,1,2,1,2,1,0,2,1,2,0,2,2,2,6], [2,2,2,2,2,2,2,2,3,2,2,2,2,2,2,3,2,2,2,2,6], [2,2,2,1,2,2,2,2,2,0,2,2,0,0,0,1,0,2,2,0,2,6], [2,2,2,2,2,2,2,2,3,2,2,2,2,2,2,0,2,1,1,1,0,0,6], [2,2,2,2,2,2,2,2,3,2,2,2,2,2,0,2,2,0,1,0,2,2,2,6], [2,0,3,1,2,2,2,2,2,0,2,1,2,0,2,1,1,2,2,2,3,3,1,1,6], [-1,1,1,1,2,2,2,2,2,0,2,0,1,0,1,2,2,2,2,2,2,2,0,0,2,6], [1,1,0,0,2,2,2,0,1,1,2,1,0,2,2,0,0,2,2,1,2,1,1,0,1,1,6], [1,1,1,-1,2,2,2,0,2,1,2,1,0,1,2,1,2,2,2,1,2,1,0,1,2,2,2,6]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-33,-14,-1,16,-10,21,-14,21,3,13,6,4,8,39,5,-23,-16,36,24,-37,-5,-10,-18,-2,9,-7, -20,3],[-98,-41,-4,47,-29,61,-41,63,8,37,18,12,25,115,13,-67,-46,106,71,-110,-15, -30,-52,-7,28,-22,-58,9],[205,83,8,-100,60,-127,86,-132,-16,-79,-37,-25,-50,-240, -26,141,94,-220,-149,230,32,64,110,15,-62,46,120,-17], [420,170,17,-206,124,-259,176,-271,-34,-162,-76,-50,-102,-491,-53,288,193,-452,-304,471, 67,131,225,30,-128,95,245,-36],[78,31,3,-38,22,-48,33,-50,-6,-30,-14,-9,-19,-91, -10,53,35,-83,-57,87,13,24,42,6,-24,18,45,-6], [172,69,7,-84,51,-106,72,-111,-14,-66,-31,-20,-42,-201,-22,118,78,-185,-125,193,28,54, 93,12,-53,39,100,-14],[45,18,2,-22,13,-28,19,-29,-3,-17,-8,-5,-11,-53,-6,31,20, -48,-33,51,7,14,24,3,-14,10,26,-3], [238,97,10,-116,70,-147,100,-153,-19,-91,-43,-28,-59,-278,-31,163,109,-256,-173,267,37, 73,127,17,-71,54,139,-20],[157,64,6,-77,46,-97,66,-101,-12,-61,-28,-19,-38,-184,-20, 108,72,-169,-114,176,25,49,84,11,-48,35,92,-13], [208,85,8,-101,61,-129,87,-134,-17,-79,-38,-25,-51,-243,-27,143,96,-224,-151,233,32,65, 111,15,-62,47,122,-17],[178,72,8,-87,52,-110,75,-115,-14,-68,-32,-21,-44,-208,-23, 122,81,-191,-130,200,28,55,95,13,-54,41,104,-15], [-214,-87,-8,105,-64,132,-90,138,18,83,39,26,52,250,27,-147,-99,231,155,-240,-35,-67, -115,-15,65,-48,-125,19],[58,23,3,-28,17,-36,24,-37,-4,-22,-11,-7,-14,-68,-8,40,26, -62,-42,65,9,18,31,4,-18,13,34,-4], [-94,-39,-4,46,-28,58,-40,61,8,36,17,12,23,110,12,-64,-44,101,68,-105,-15,-29,-50,-7, 28,-21,-55,9],[-2,-1,0,2,-1,1,-1,1,0,2,0,1,0,2,0,-1,-2,2,1,-2,-1,-1,-1,0,1, 0,-1,1],[203,82,8,-99,60,-126,85,-131,-16,-78,-37,-24,-50,-238,-26,140,93,-219,-147, 228,32,63,109,15,-61,46,119,-17], [-44,-18,-2,21,-13,27,-18,28,4,16,8,6,11,51,6,-30,-21,47,32,-49,-6,-14,-23,-3,13,-10, -26,4],[233,94,10,-114,69,-144,98,-151,-18,-90,-42,-27,-57,-273,-30,160,106,-251, -169,262,37,72,125,17,-71,53,136,-20], [134,53,6,-65,39,-83,56,-86,-10,-51,-24,-15,-33,-156,-17,91,60,-143,-97,150,21,41,71, 10,-41,31,78,-11],[374,151,15,-183,110,-231,157,-241,-30,-144,-67,-45,-91,-437,-47, 256,172,-402,-271,419,60,117,200,27,-114,84,218,-32], [-150,-60,-6,73,-44,93,-63,96,12,58,27,18,36,175,19,-102,-69,161,109,-168,-24,-47,-80, -11,46,-34,-88,13],[-22,-9,-1,11,-7,14,-9,14,2,9,4,3,5,26,3,-15,-10,24,16,-25, -4,-7,-12,-2,7,-5,-13,2],[167,67,7,-81,49,-103,70,-108,-13,-64,-30,-20,-41,-195, -21,114,76,-179,-121,187,27,52,89,12,-51,38,97,-14], [96,38,4,-47,28,-60,40,-62,-7,-37,-17,-11,-23,-113,-12,66,43,-103,-70,108,16,30,52,7, -30,22,56,-8],[260,105,11,-127,76,-161,109,-167,-21,-100,-47,-31,-63,-304,-33,178, 119,-279,-188,291,41,81,139,19,-79,59,152,-22], [98,40,4,-47,28,-61,41,-63,-7,-37,-18,-12,-24,-115,-13,67,45,-105,-71,110,15,30,52,7, -29,22,58,-8]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [174,71,7,-85,51,-108,73,-112,-14,-67,-31,-21,-42,-204,-22,119,80,-187,-126,195,28,54, 93,13,-53,39,102,-15],[142,58,6,-69,42,-88,60,-91,-12,-54,-26,-17,-35,-166,-18,97, 65,-153,-103,159,23,44,76,10,-43,32,83,-12], [-128,-52,-5,62,-38,79,-54,83,10,49,23,15,32,150,17,-88,-59,138,93,-144,-20,-39,-68,-9, 38,-29,-75,11],[9,4,0,-5,3,-5,4,-6,-1,-4,-2,-1,-2,-10,-1,6,4,-10,-6,10,2,3,5, 1,-3,2,5,-1],[20,9,0,-10,6,-12,8,-13,-2,-8,-4,-3,-4,-23,-2,14,10,-22,-14,22,3, 7,11,1,-6,4,12,-2],[-26,-10,-1,13,-8,16,-11,17,2,10,5,3,6,31,3,-18,-12,28,19, -29,-4,-8,-14,-2,8,-6,-15,2],[67,27,3,-33,20,-41,28,-43,-6,-26,-12,-8,-16,-78,-8, 46,30,-72,-48,75,11,21,36,5,-21,15,39,-6], [-154,-63,-6,75,-45,96,-65,99,12,59,28,19,38,181,20,-106,-72,166,112,-173,-24,-48,-82, -11,46,-34,-91,13],[72,29,3,-35,21,-44,30,-46,-6,-28,-13,-9,-17,-84,-9,49,33,-77, -52,80,12,23,39,5,-23,16,42,-6], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [84,34,4,-41,25,-52,35,-54,-7,-32,-15,-10,-20,-98,-11,57,38,-90,-61,94,14,26,45,6,-26, 19,49,-7],[-66,-27,-3,32,-19,41,-28,43,5,25,12,8,17,77,9,-45,-31,71,48,-74,-10, -20,-35,-5,19,-15,-39,6],[82,34,3,-40,25,-51,34,-53,-7,-32,-15,-10,-20,-96,-10,57, 38,-89,-59,92,13,26,44,6,-25,18,48,-7], [265,108,11,-129,78,-164,111,-171,-22,-101,-48,-32,-65,-310,-34,182,122,-285,-192,297,42, 83,142,19,-80,60,155,-23],[66,27,3,-33,20,-41,28,-43,-5,-26,-12,-8,-16,-78,-8,46, 30,-72,-48,75,11,21,36,5,-21,15,39,-6], [275,112,11,-135,81,-170,115,-177,-22,-106,-50,-33,-67,-321,-35,189,127,-296,-199,308,43, 86,147,20,-83,62,161,-24],[-1,0,0,1,-1,1,-1,1,0,1,0,0,0,2,0,-1,0,2,1,-2,-1, -1,-1,0,1,0,0,0],[94,38,4,-46,28,-58,39,-60,-8,-36,-17,-11,-23,-109,-12,64,43, -101,-68,105,15,29,50,7,-29,22,55,-8], [317,128,13,-155,93,-196,133,-204,-26,-122,-57,-38,-77,-370,-40,217,145,-340,-230,355,51, 99,170,23,-97,72,185,-27],[151,61,6,-74,44,-93,63,-97,-12,-58,-27,-18,-37,-176,-19, 103,69,-162,-109,169,24,47,81,11,-46,34,88,-13], [50,21,2,-25,15,-30,21,-32,-4,-20,-9,-6,-12,-58,-6,34,23,-54,-36,56,8,15,26,4,-15,11, 29,-5],[-81,-33,-3,39,-24,51,-34,52,6,31,15,10,20,95,11,-56,-38,87,59,-91,-12,-25, -43,-6,24,-18,-48,7],[395,160,16,-193,116,-244,165,-254,-32,-152,-71,-48,-96,-461, -50,270,182,-424,-286,442,63,123,211,29,-120,89,231,-34], [191,78,8,-93,56,-119,80,-123,-16,-73,-35,-23,-47,-224,-25,132,88,-206,-139,215,30,60, 103,14,-58,43,113,-16],[-147,-59,-7,71,-43,91,-62,95,12,55,26,17,37,172,19,-100, -67,158,107,-165,-23,-45,-78,-11,44,-34,-86,13], [-173,-71,-7,84,-51,107,-73,111,14,66,31,21,43,202,23,-118,-80,186,126,-194,-27,-53,-92, -12,51,-39,-101,15]]]], [ # Q-class [28][22] [[8], [1,8], [4,2,8], [3,3,3,8], [3,3,3,2,8], [3,3,3,4,1,8], [2,1,1,2,2,1,8], [2,4,4,3,3,0,2,8], [0,3,3,2,2,1,2,3,8], [2,4,1,0,3,3,2,2,0,8], [2,1,1,2,2,1,4,2,2,2,8], [1,2,2,3,3,0,4,4,3,1,4,8], [3,3,3,1,1,-1,1,3,1,3,1,3,8], [3,0,0,1,1,2,4,0,1,3,4,0,-1,8], [3,3,0,4,1,2,1,3,-2,3,1,0,2,2,8], [4,2,2,1,1,2,2,1,1,1,0,-1,2,2,2,8], [2,1,1,-1,2,1,1,2,2,2,2,1,1,1,1,0,8], [1,2,2,1,1,-1,2,4,1,1,0,2,2,2,2,2,0,8], [1,2,2,-1,2,1,3,1,2,1,1,2,1,1,-2,1,1,1,8], [1,2,2,-1,2,1,2,1,2,1,3,2,1,1,-2,0,3,0,4,8], [4,2,2,1,1,2,1,1,1,1,2,-1,2,2,2,4,2,1,3,1,8], [2,1,1,1,-2,2,1,2,1,2,3,1,2,2,2,0,3,0,2,1,2,8], [0,3,-3,-1,2,1,2,0,2,3,2,0,-2,4,1,1,2,1,2,2,1,1,8], [1,2,2,1,1,-1,4,4,1,1,2,2,2,2,2,1,2,4,3,1,2,2,1,8], [2,1,1,-1,2,1,2,2,2,2,1,1,1,1,1,2,4,2,3,2,4,1,2,1,8], [2,1,1,1,-2,2,0,2,1,2,1,1,2,2,2,1,1,1,0,2,0,4,1,0,0,8], [1,2,-1,1,1,2,2,1,1,1,0,2,-1,2,2,2,0,2,1,0,1,0,4,1,2,1,8], [1,2,-1,1,1,2,4,1,1,1,2,2,-1,2,2,1,2,1,3,1,2,2,4,2,4,0,4,8]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,1,0,0,-1,1,0,-1,1,-1,0,1,0,-1,0,-1,1,1,1,-1,1,0,0,0,0], [0,2,1,0,1,-1,1,-1,-1,-1,0,0,-1,0,-1,0,0,0,-1,-1,0,1,0,0,1,1,0,0], [1,-2,-2,-2,1,2,-1,0,3,1,-1,1,-1,-1,2,0,-2,1,-1,2,1,1,-1,1,-1,-1,-1,1], [1,-1,1,0,-1,-2,-1,-2,2,3,-2,3,-3,-1,2,1,-1,0,-1,2,1,1,0,1,-1,-1,-1,1], [-1,-1,-2,-3,3,5,1,2,0,-4,-1,0,3,1,0,-1,-2,0,-2,0,1,1,1,1,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [2,1,1,2,-2,-5,-1,-3,2,5,1,0,-5,-2,1,1,1,1,1,1,0,0,-3,0,-1,0,1,1], [0,1,1,0,0,-1,0,-1,0,0,-1,1,-1,0,0,0,0,0,-1,0,1,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0], [0,1,1,0,0,-1,0,-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,2,1,1,0,-2,0,-1,-1,0,1,-1,-1,0,-1,0,1,0,1,-1,-1,0,-1,0,1,1,1,0], [0,-1,0,0,-1,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0], [1,-2,-2,-1,0,1,-1,0,3,2,0,0,-1,-1,2,0,-1,1,0,2,0,0,-2,1,-1,-1,0,1], [0,0,0,-1,0,1,0,0,0,-1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,-1,0,0,0,1,0,-1,0,0,-1,0,1,0,0,0,0,0,-1,0,-1,0,1,1], [1,1,1,-1,-1,-1,0,-1,1,1,0,1,-2,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,1,2,2,-1,-3,1,-1,-1,1,1,-1,-1,-1,-1,0,1,0,1,-1,0,0,0,-1,0,1,1,0], [-2,2,2,1,1,-1,2,0,-3,-2,0,-1,1,1,-2,0,1,-1,0,-2,0,1,1,-1,1,1,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,1,0,2,0,-1,1,0,-1,0,3,-4,1,-1,-2,-1,2,1,2,-2,-1,-1,-1,-1,0,1,2,0], [0,-1,0,0,-1,0,0,0,1,1,-1,1,0,0,1,0,0,0,0,1,1,0,0,0,-1,-1,0,0], [2,0,0,2,-2,-4,-1,-2,2,5,1,0,-4,-2,0,1,1,1,1,1,0,0,-3,0,-1,0,1,1], [0,0,0,-1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,-1,0,0,1], [-2,2,1,0,1,1,2,1,-3,-3,1,-2,2,1,-2,-1,1,0,0,-2,0,0,1,-1,1,1,1,-1], [-1,0,0,0,0,1,0,0,0,-1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,-1,-2,2,3,1,1,0,-3,0,-1,3,1,0,-1,-1,0,-1,0,0,1,0,0,0,0,0,0]], [[0,-2,-1,-1,0,1,-1,0,2,1,-2,2,0,0,2,0,-1,0,-1,2,1,0,0,1,-1,-1,-1,1], [2,-2,-1,1,-2,-2,-2,-1,3,5,0,1,-3,-2,2,1,0,1,2,2,0,-1,-2,0,-2,-1,0,1], [1,0,1,2,-2,-4,-1,-2,1,4,0,1,-3,-1,1,1,1,0,1,1,0,-1,-1,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0], [-1,0,1,0,0,0,0,0,-1,-1,-1,1,1,1,0,0,0,-1,0,0,0,0,1,0,0,0,0,0], [0,0,0,1,-1,-1,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,-1,0,-1,0,0,0,0], [0,0,-1,-1,1,2,0,1,0,-2,0,-1,2,1,0,-1,0,0,0,0,-1,0,0,0,0,0,0,0], [1,-2,0,0,-1,-1,-2,-1,2,3,-1,2,-2,-1,2,1,-1,0,0,2,0,0,0,1,-1,-1,-1,1], [0,1,0,0,1,-1,0,-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0], [0,-2,-1,0,-1,1,-1,1,1,1,0,0,1,0,1,0,0,0,1,1,0,-1,0,0,-1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [2,-2,-1,1,-2,-2,-2,-1,3,5,0,1,-3,-2,2,1,0,1,1,2,0,-1,-2,1,-2,-1,0,1], [-1,0,-1,-1,1,2,0,1,0,-2,0,-1,2,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,-2,-1,-1,0,2,-1,1,1,0,-1,1,1,0,1,0,-1,0,0,1,0,0,1,1,0,-1,-1,0], [1,-1,-1,-2,0,1,-1,0,2,1,-2,2,-1,0,2,0,-1,0,-1,2,1,0,-1,1,-1,-1,-1,1], [1,-1,-1,-1,0,0,-1,-1,2,1,0,1,-1,-1,2,0,-1,0,0,1,0,0,-1,1,0,0,0,0], [1,-1,-1,-1,-1,0,-2,0,2,2,-1,2,-2,0,2,1,-1,0,0,2,0,0,-1,1,-1,-1,-1,1], [2,-1,0,4,-3,-5,-2,-1,2,6,2,-2,-3,-2,0,1,2,1,3,1,-1,-2,-3,-1,-2,0,2,2], [0,1,1,3,-1,-3,0,-1,-1,2,2,-2,-1,-1,-1,0,2,0,2,-1,-1,-1,-1,-1,0,1,2,0], [3,-2,-1,2,-3,-4,-3,-2,4,7,-1,2,-5,-2,2,1,0,1,1,3,1,-1,-3,1,-2,-1,0,2], [1,-2,-1,1,-1,-1,-1,0,2,3,1,-1,-1,-2,1,0,0,1,1,1,0,-1,-1,0,-1,0,0,1], [-1,-1,-2,-2,2,4,0,2,0,-3,0,-1,3,1,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0], [3,-2,-2,1,-2,-2,-3,-1,4,5,1,0,-3,-2,2,1,0,1,2,2,-1,-1,-3,1,-2,-1,0,2], [0,0,0,0,0,0,-1,0,0,0,-1,1,0,1,0,0,-1,-1,-1,1,0,0,0,1,1,0,0,0], [-1,-1,-1,0,1,1,0,1,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,-1,0,1,2,0,1,-1,-2,0,-1,2,1,-1,0,0,0,0,0,-1,0,0,0,1,0,0,0], [0,0,-1,-1,1,2,0,1,0,-2,0,-1,2,1,0,-1,-1,0,0,0,-1,0,0,0,1,0,0,0]]]], [ # Q-class [28][23] [[6], [2,6], [1,3,6], [1,1,2,6], [2,2,1,0,6], [0,2,1,1,2,6], [1,1,2,0,3,1,6], [0,1,2,2,1,0,2,6], [0,1,2,2,1,3,2,0,6], [0,2,1,1,2,0,1,3,0,6], [3,1,2,2,1,0,2,0,0,0,6], [2,2,1,3,0,2,0,1,1,2,1,6], [2,0,0,1,-2,0,-1,0,0,0,1,2,6], [1,0,0,2,1,0,2,0,0,0,2,1,0,6], [0,2,1,1,0,0,0,1,0,2,0,2,2,1,6], [0,0,0,1,2,2,1,1,1,2,0,2,-2,1,0,6], [1,0,0,0,1,0,2,2,0,1,2,0,0,0,-1,1,6], [0,0,0,-2,1,0,2,0,0,0,0,-1,0,0,1,-1,0,6], [2,0,0,1,2,0,1,0,0,0,1,2,0,3,2,2,0,0,6], [0,1,2,2,0,0,0,2,0,1,0,1,1,2,3,0,-2,2,1,6], [0,0,0,2,1,1,2,2,2,1,0,1,-1,2,0,3,2,-2,1,0,6], [2,0,0,0,2,0,1,1,0,2,1,0,0,0,-2,2,3,0,0,-1,1,6], [2,0,0,1,2,2,1,0,1,0,1,2,0,0,-2,0,1,1,0,-1,0,2,6], [1,0,0,0,1,-1,2,2,-2,1,2,0,0,2,1,0,0,2,1,2,0,0,0,6], [2,-2,-1,0,0,0,0,-1,0,-2,1,0,2,0,0,-2,0,1,0,0,-1,0,2,1,6], [1,0,0,2,-1,0,-2,0,0,0,2,1,3,0,1,-1,0,0,0,2,-2,0,0,0,1,6], [2,0,0,0,2,2,1,0,1,0,1,0,0,0,0,2,0,0,0,0,1,0,0,0,2,0,6], [1,1,2,2,0,0,0,0,0,0,2,1,0,0,0,1,2,-2,0,0,2,1,0,-2,0,0,1,6]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,-1,-1,0,0,0,1,1,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [-1,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,0,0,0,0,1,0,-1,0,0,0,1,0,0,0,0,0,-1,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,1,0,0,0,0,0,-1,1,0,-1,1,0,0,0,0,0,0,0], [-1,1,0,0,0,-1,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,1,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1], [0,0,0,0,1,-1,0,0,0,-1,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,-1,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,-1,0,0,0,1,0,0,0,0,0,0,-1,0,1,0,0,0,-1,0,0,0,-1,0,0,0,-1,0], [0,0,0,1,0,0,1,-1,-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,1,-1,0,0,0,0,-1,0,0], [-1,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,1,0]], [[-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,0,1,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,1,0,0,0,0,0,1,0,0,-1,0,0,-1,0,0,0,0,0,1,0,1], [-1,0,0,0,1,0,-1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,-1,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,1,0,0,-1,1,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,1,1,-1,1,0,0,0,0,0,1,0,0,-1,1,-1,-1,0,0,-1,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,-1,0,1,0,1,0,0,0,0,-1,1,1,0,-1,0,-1,-1,0,0,0,0,0,1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,-1,0,0,-1,1,1,0,0,0,0,1,0,0,0,0,0,-1,-1,0,0,1,0,0,0,1], [1,-1,0,-1,1,0,-1,1,1,0,0,0,0,1,0,1,0,0,-1,0,-1,-1,0,0,0,0,-1,1], [0,-1,0,-1,1,0,-1,1,1,-1,0,1,0,1,1,-1,-1,0,-1,-1,0,1,0,1,-1,0,0,1], [0,0,0,0,0,0,-1,1,0,0,1,0,0,0,0,0,-1,1,0,-1,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,0,-1,0,-1,0,-1], [0,-1,0,-1,1,0,-1,1,1,-1,0,1,0,1,1,0,0,0,-1,-1,-1,0,0,1,-1,0,0,1], [0,0,0,-1,0,0,-1,1,1,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,-1,0,0,-1,1,1,0,0,0,0,1,0,0,-1,0,0,-1,0,0,0,1,0,0,0,1], [-1,0,0,0,1,0,-1,1,0,-1,1,1,0,0,0,-1,-1,1,0,-1,1,1,-1,0,0,0,0,0], [-1,1,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,-1,1,0,0,-1], [0,0,1,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,1,0,-1,0,0,0,0,0,0,0,0], [-1,1,0,0,0,-1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,-1,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [-1,1,-1,0,0,-1,0,0,1,0,1,-1,1,0,0,1,0,-1,0,1,-1,0,1,0,0,-1,0,0], [0,0,-1,-1,0,0,0,1,1,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,1,0,0,-1,0,0,1,-1,0,2,0,0,0,0,0,-1,0,-1], [0,1,0,0,0,-1,0,0,0,0,0,-1,1,0,0,1,0,0,0,0,0,-1,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1,1,0,-1,1,0,0,0,0,1,0,0], [0,0,1,1,0,0,0,-1,-1,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,-1,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,-1,0,0,0,1,0,0,0,0,0,0,-1,0,1,0,0,0,-1,0,0,0,-1,0,0,0,-1,0], [1,-1,0,0,0,1,0,0,0,0,0,1,-1,0,0,-1,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,1,-1,-1,0,1,0,0,-1,0,0,0,0,0,1,1,0,0,-1,0,0,0,-1], [0,0,0,0,1,0,0,0,0,-1,0,1,0,0,0,0,0,0,-1,0,0,0,-1,0,0,0,0,0], [1,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,-1,1,0,0,1,0,0,0,0,0,-1,1,0,-1,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,-1,0,0,-1,0,0,0,1,0,1,0,1], [1,-1,0,0,1,0,0,0,0,-1,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,1,-1,0,0,0,0,0,-1,0,0,0,-1,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,1,0,0,-1,0,0,0,0,0,1,1,0,0,-1,0,0,0,-1], [1,0,0,0,-1,0,0,0,0,1,0,-1,0,0,0,1,0,0,0,0,0,-1,1,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,1,0,0,0,0,0,-1,0,0,1,0,-1,0], [0,0,0,1,0,0,1,-1,-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,-1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,-1,0,1,-1,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,-1,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [28][24] [[4], [0,4], [1,0,4], [1,1,1,4], [1,1,1,0,4], [0,0,1,1,0,4], [0,1,1,0,0,1,4], [1,0,1,0,1,0,1,4], [1,0,1,0,1,1,0,1,4], [0,1,0,0,1,1,1,0,0,4], [1,1,0,1,1,0,0,1,1,0,4], [1,1,0,0,1,1,1,1,1,1,0,4], [0,1,1,1,0,1,0,1,0,1,1,0,4], [1,1,0,0,0,1,1,0,0,1,1,1,0,4], [1,1,0,1,1,1,1,1,1,0,1,0,0,0,4], [1,0,1,0,1,0,1,1,1,1,1,1,0,1,0,4], [1,1,1,1,1,0,0,1,1,1,1,1,0,0,1,0,4], [1,0,0,0,1,0,1,1,1,1,0,1,1,1,0,1,0,4], [1,1,0,0,0,1,1,0,0,1,1,0,1,1,1,1,1,0,4], [0,1,0,1,0,1,1,0,1,1,0,1,0,1,0,1,0,1,1,4], [1,0,0,-1,1,0,1,1,1,1,0,1,-1,1,0,1,0,1,0,1,4], [0,1,0,0,0,0,1,1,0,1,1,0,1,1,1,0,1,0,1,1,0,4], [1,0,0,0,1,1,0,1,-1,0,0,1,1,0,1,0,0,0,1,-1,0,0,4], [0,1,1,1,0,1,1,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,-1,4], [0,0,1,0,1,1,0,0,0,0,1,0,0,1,1,0,1,-1,0,-1,1,1,1,-1,4], [1,1,1,1,0,0,1,0,-1,1,0,0,1,1,0,0,0,0,0,-1,0,0,1,0,1,4], [-1,1,1,1,1,0,0,1,1,0,0,0,1,-1,0,0,0,0,-1,1,0,0,0,0,0,1,4], [1,1,1,0,1,1,0,1,1,0,0,0,1,1,1,0,0,1,0,0,0,0,0,1,0,0,0,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,1,0,1,-1,-1,0,2,1,2,0,0,-2,-1,-1,-1,-2,1,1,0,-2,-1,0,0,3,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [3,2,-1,1,-2,-2,2,2,2,3,-1,-1,-1,0,-2,-1,-2,0,0,0,-3,-2,1,0,4,-3,1,0], [-3,-2,0,-2,3,4,-2,-2,-2,-5,1,0,2,0,2,2,4,-1,-2,1,4,2,-1,0,-6,5,-2,0], [3,1,-2,0,0,0,2,1,1,1,-2,-2,1,1,-1,0,0,-1,-1,0,-2,-1,0,0,2,-2,1,-1], [0,1,1,0,-1,0,-1,1,0,1,0,0,-2,-1,0,0,-1,1,1,0,-1,0,0,0,1,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [3,2,-1,1,0,-1,2,3,2,3,-2,-2,0,1,-2,-1,-2,-1,0,0,-3,-2,0,-1,3,-3,0,-1], [-3,-1,1,-1,1,3,-3,-1,-2,-3,1,1,0,-1,2,1,2,1,0,0,3,2,-1,0,-4,4,-1,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,1,0,0,0,2,1,1,-1,-1,-1,0,-1,0,-1,0,0,0,-1,0,0,-1,1,0,-1,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,0,1,-2,0,-1,-1,0,1,-1,0,1,0,0,1,1,-1,1,1,-1,0,-1,1,0,0], [2,1,0,0,-1,-1,1,1,1,2,0,-1,-1,0,-1,-1,-1,0,0,0,-2,-1,1,0,2,-2,1,0], [-1,0,1,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,-1,1,-1,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,0,1,0,1,2,-2,0,-1,-2,0,0,0,0,1,1,1,0,0,0,2,1,-1,-1,-3,2,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [3,3,-1,1,-1,-1,2,3,2,3,-2,-2,-1,0,-2,-1,-2,0,0,0,-3,-2,0,-1,4,-3,0,-1], [-2,-1,0,-1,2,2,-1,-1,-1,-3,0,0,1,0,1,1,2,0,0,0,2,1,-1,0,-3,3,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [-3,-3,0,-1,2,1,-1,-3,-1,-4,1,1,2,0,2,1,3,-1,-1,1,3,2,0,1,-4,4,-1,1], [3,2,0,0,-2,-1,1,2,1,3,-1,-1,-1,0,-1,-1,-2,1,0,0,-3,-2,0,0,4,-3,1,-1], [-1,-2,-1,-1,2,1,0,-2,-1,-3,0,0,2,1,1,1,3,-1,-1,0,2,1,0,1,-3,2,0,0], [-2,-1,1,0,0,0,-2,-1,-1,-1,1,2,-1,-1,1,0,0,1,1,0,1,1,0,1,-1,2,0,1], [1,1,-1,0,1,0,1,1,1,0,-1,-1,1,0,-1,0,0,-1,-1,1,-1,-1,0,0,1,0,-1,-1], [1,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,0,-1,1,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,0,-1,0,0,0,0,1,0,0,-1,0,0,0,-1,1,0,-1,-1,0,0,0,1,-1,1,0], [1,1,-1,-1,1,1,1,0,0,-1,-1,-2,2,1,0,1,2,-1,-2,1,0,-1,0,-1,-1,0,-1,-1], [3,2,0,0,-1,-1,1,2,1,3,-1,-1,-1,1,-1,-1,-2,0,0,0,-3,-2,0,-1,3,-3,1,-1], [-2,-1,1,-1,1,2,-2,-2,-2,-3,1,1,1,0,2,1,2,0,-1,0,3,2,-1,0,-4,3,-1,0], [3,2,-1,0,0,-1,2,2,1,2,-2,-2,1,1,-1,0,-1,-1,-1,1,-3,-2,0,-1,3,-3,0,-1], [0,0,0,-1,0,1,0,-1,-1,-1,0,0,1,0,1,1,1,0,-1,0,1,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [3,1,-2,0,0,-1,2,1,1,1,-2,-2,2,1,-1,0,0,-1,-1,1,-2,-2,0,0,3,-2,0,-1], [2,0,-1,0,0,-1,2,0,0,1,-1,-1,1,1,0,0,0,-1,-1,0,-1,-1,0,0,1,-2,1,0], [-1,0,1,0,0,1,-2,0,-1,-1,0,1,-1,0,1,0,0,1,1,-1,1,1,-1,0,-1,1,0,0], [0,-1,0,0,0,-1,0,-1,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0], [3,2,0,1,-2,-3,2,2,2,4,-1,-1,-2,0,-2,-2,-3,1,1,0,-4,-2,1,0,5,-4,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,2,1,1,-2,-1,0,2,0,3,0,0,-2,0,-1,-1,-3,1,1,-1,-2,-1,0,-1,3,-3,1,0], [-1,0,1,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,-1,1,-1,0], [0,-1,-1,-1,1,1,0,-1,-1,-2,0,0,2,1,1,1,2,-1,-1,0,1,0,-1,0,-2,1,0,0], [1,0,0,0,-1,-2,1,0,1,1,0,0,0,0,0,-1,-1,0,0,1,-1,-1,1,1,2,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,-1,0,0,-1,1,0,1,1,-1,-1,1,1,0,0,0,-1,-1,1,-1,-1,1,0,1,-1,0,0], [0,-1,-1,-1,1,1,0,-2,-1,-2,0,0,2,0,1,1,2,-1,-1,0,2,1,0,1,-2,1,0,0], [-1,-1,1,0,-1,0,-1,-1,-1,0,1,1,-1,0,1,0,0,1,1,-1,1,1,0,0,-1,0,1,1], [-1,0,2,1,-1,-1,-1,0,0,1,1,2,-2,-1,0,-1,-2,1,2,-1,0,1,0,0,0,0,0,1], [1,1,-1,-1,1,1,1,1,0,0,-1,-2,1,1,0,1,1,-1,-2,1,-1,-1,0,-1,0,0,-1,-1], [-2,-1,1,-1,1,2,-2,-2,-2,-3,1,1,1,0,2,1,2,0,0,-1,3,2,-1,0,-4,2,0,0], [1,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,2,-1,0,0,0,1,2,1,1,-1,-2,0,0,-1,0,-1,0,-1,1,-2,-1,0,-1,2,-1,-1,-1]]]], [ # Q-class [28][25] [[4], [0,4], [-1,0,4], [-1,0,2,4], [1,0,0,0,4], [0,0,-2,0,-2,4], [1,0,0,-2,2,-2,4], [2,0,-2,-2,2,0,2,4], [0,-2,1,1,1,-1,0,0,4], [2,-1,1,0,1,-1,1,1,0,4], [-2,-1,1,2,0,0,-1,-1,0,0,4], [-2,-1,1,1,1,-1,0,-1,0,0,2,4], [0,1,-1,-1,0,1,0,0,0,-2,-2,0,4], [-1,0,-1,0,-1,1,-1,-1,0,-2,0,0,1,4], [0,-2,0,0,0,0,0,0,2,0,0,0,0,-1,4], [1,0,-1,-2,0,0,1,1,0,0,-2,-1,1,0,-1,4], [0,0,1,1,0,0,-1,0,0,1,1,0,-1,-2,1,-2,4], [-1,0,1,1,1,-1,0,-1,0,0,1,2,0,0,1,-2,0,4], [1,0,0,0,0,1,0,1,0,1,0,-1,0,-2,0,0,2,-2,4], [2,0,0,0,0,0,1,1,0,2,0,-2,-2,-1,0,0,0,-1,1,4], [2,0,-1,-1,1,0,1,2,0,1,-1,-1,0,-2,0,2,0,-2,2,1,4], [-1,-1,-1,0,-1,1,-1,-1,1,-2,0,0,1,2,1,0,-1,0,-1,-1,-1,4], [1,-1,-1,-2,0,0,1,1,1,0,-2,-1,1,0,1,2,-1,-1,0,0,1,0,4], [0,1,1,1,0,0,-1,0,-1,1,1,0,-1,-1,-1,-1,2,0,1,0,0,-2,-2,4], [-1,1,1,1,1,-1,0,-1,-1,0,1,2,0,0,-1,-1,0,2,-1,-1,-1,0,-2,0,4], [1,0,0,0,0,1,0,1,0,1,0,-1,0,-1,0,0,1,-1,2,1,1,-2,0,2,-2,4], [0,2,1,1,1,-1,0,0,-2,1,1,1,-1,-1,-2,-1,1,1,0,0,0,-2,-2,2,2,0,4], [2,0,-1,-1,1,0,1,2,0,1,-1,-1,0,-1,0,1,0,-1,1,1,2,-2,2,0,-2,2,0,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,1,-1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0], [1,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,1,1,0,-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,-1,1,1,0,-1,0,0,0,0,0,-1,0,-1,0,-1,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,-1,-1,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,1,0,0,1,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,1,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,1,-1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,-1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,0,0], [0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1], [0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0], [0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,-1,1,0,-1,-1,0,0,0,0,0,-1,0,-1,-1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,-1,-1,0,-1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,-1,0,0,-1,-1,0,0], [-1,-1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [1,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,1,-1], [1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,0,-1,0,0,-1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,-1,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,1,0,0,1,0,1,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,1,0,0,0,-1,-1,-1,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,1,0,0,0,-1,0,0,-1]]]], [ # Q-class [28][26] [[4], [1,4], [-2,-2,4], [1,0,0,4], [-2,0,1,-1,4], [1,-1,1,1,-2,4], [-1,-1,0,-2,1,-1,4], [0,2,-1,-1,0,-1,-1,4], [0,-1,0,1,-1,1,1,-2,4], [2,2,-1,1,-1,1,-2,1,-1,4], [1,1,0,1,-1,1,-2,1,-1,2,4], [2,0,-1,2,-2,1,-2,0,0,1,1,4], [-1,-1,1,1,0,0,-1,0,0,-1,0,1,4], [-1,0,1,1,0,1,0,-1,2,0,0,-1,0,4], [-1,1,-1,-1,1,-2,1,1,0,-1,-2,-1,1,0,4], [-1,-1,1,1,1,-1,-1,0,-1,-1,0,1,2,-1,0,4], [-1,-1,1,-1,1,-1,0,1,-2,-1,1,0,1,-2,-1,2,4], [-1,0,1,1,1,-1,0,-1,1,0,0,-1,0,2,0,0,-1,4], [0,1,0,-1,0,1,-1,2,-2,1,1,0,0,-1,0,0,1,-2,4], [1,1,0,1,-2,2,-2,1,0,2,2,1,0,1,-1,-1,-1,0,1,4], [-1,1,-1,-2,1,-2,2,1,0,-1,-1,-2,-1,0,2,-1,0,0,0,-1,4], [-2,0,1,0,2,-1,1,-1,1,-1,-1,-2,0,2,1,0,-1,2,-1,-1,1,4], [2,0,-1,1,-2,1,-1,0,0,1,2,2,0,-1,-2,0,1,-1,0,1,-1,-2,4], [1,0,0,2,-2,2,-1,-1,2,1,1,1,0,2,-1,-1,-2,1,-1,2,-1,0,1,4], [0,-1,1,2,-1,1,-2,0,0,0,1,2,2,0,-1,2,1,0,0,1,-2,-1,1,1,4], [-1,1,1,2,1,0,-1,-1,1,0,0,0,1,2,0,1,-1,2,-1,0,-1,2,-1,1,1,4], [-1,-1,0,0,1,-1,2,-2,2,-2,-2,-1,0,1,1,0,-1,1,-2,-2,1,2,-1,0,-1,1,4], [1,1,-2,-1,-1,-1,0,2,-1,0,0,1,0,-2,1,0,1,-2,1,0,1,-2,1,-1,0,-2,-1,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,-1,0], [0,-1,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0,0], [0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,0,0], [0,-1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,-1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,-1,0,0,0,1,0,0,0,0,1,0,0], [0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0,0,0], [0,-1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1,0,0,0,1,0,1,0,0,1,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,1,-1,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,-1,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,-1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0]], [[-1,0,-1,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,1,0,0,-1,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,0,0], [1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,-1,0,0,0,0,0,-1,0,0], [-1,1,0,0,1,1,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0], [0,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1], [1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,-1,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,-1,0,0,0,0,0], [-1,1,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,-1,0,-1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [1,-1,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-1,0,-1,0,0,0,1,0,0,0,0,0,0,0]]]], [ # Q-class [28][27] [[16], [2,16], [4,-4,16], [4,-4,4,16], [-4,4,-4,-4,16], [-4,-2,-4,8,4,16], [1,8,-2,-2,2,-1,16], [2,4,-4,2,-2,4,2,16], [-8,2,-2,-2,2,2,1,-1,16], [2,1,-1,-1,-2,-2,2,1,-4,16], [-2,2,-2,-8,2,-4,-2,2,1,-1,16], [-2,-4,-2,4,2,2,-2,-4,-2,-4,-2,16], [-1,4,-1,2,-2,1,8,1,-1,4,-4,-4,16], [-4,-2,-4,-4,4,-2,-4,-8,2,-2,2,8,-2,16], [-2,2,1,-2,2,-4,4,-1,4,-4,1,4,-4,2,16], [4,2,-2,-2,-4,-4,1,2,-2,8,-2,-8,2,-4,-2,16], [2,4,-4,-4,1,-2,-4,-2,2,-2,2,-4,-2,4,-4,2,16], [-4,-2,-1,2,-2,4,-1,4,2,-2,-4,2,1,-2,-4,-4,-2,16], [4,2,-2,4,2,2,1,8,-2,2,-2,-2,2,-4,1,4,-1,-4,16], [-2,2,1,-2,2,-1,4,-1,-2,8,-2,-2,8,2,-2,4,-4,2,-2,16], [-2,2,4,4,2,2,-2,2,-2,2,-2,-2,2,-4,4,1,-4,-1,4,4,16], [8,4,2,2,-2,-2,2,4,-4,-2,-4,2,-2,-2,2,-4,4,4,2,-4,-1,16], [-2,8,-8,-2,2,2,4,2,-2,-1,1,4,2,2,-2,-2,2,2,-2,-2,-2,2,16], [8,1,2,2,-2,-2,-1,-2,-4,-2,-4,2,1,4,-4,2,4,-2,2,2,-4,4,-1,16], [-2,2,-2,1,2,2,4,2,4,8,-2,-2,2,-4,4,4,-4,-4,4,4,4,-4,-2,-4,16], [4,-4,4,-2,-4,-4,-2,-4,-2,-4,4,1,-4,2,-2,-2,2,2,-8,-2,-8,2,-2,2,-8,16], [2,-2,-4,-4,4,-2,-1,4,-4,4,2,-4,-2,-2,-1,8,1,-2,8,2,2,-2,-4,1,2,-4,16], [-4,4,-1,-4,4,-2,2,-2,2,4,-4,-1,4,1,-1,2,-2,4,-4,8,2,-2,2,-2,2,-4,-2,16]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,1,1,-1,0,1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [1,-1,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,-1,-1,0], [0,-1,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0,0], [1,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,-1,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1], [0,0,-1,0,0,0,0,-1,0,0,0,0,-1,-1,0,0,0,0,1,1,0,0,0,0,-1,0,-1,0], [-1,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0], [0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,0,-1,-1,0], [0,1,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,1,0,-1,0,-1,-1,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,1,0,0,-1,1,0,0,1,-1,1,0,0,0,0,1,1,0,0,1,0,-1,0], [0,1,0,0,-1,1,0,-1,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,1,1,1], [0,1,0,0,-1,0,0,0,0,0,-1,0,0,0,0,-1,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,1,0,-1,0,0,1,0,0,1,-1,1,0,0,0,-1,0,-1,0,0,0,-1,-1,0,-1], [0,0,0,0,-1,1,1,-1,-1,-1,1,-1,-1,1,0,0,0,1,1,0,0,0,0,0,1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,-1,0,0,1,0,1,0,0,0,1,0,0,0,0,1,0,1,0,-1,1,0,0,1,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0], [-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,1], [0,-1,-1,0,0,0,1,-1,0,-1,1,0,-1,0,-1,1,0,0,1,1,1,1,0,0,0,0,-1,0], [0,1,1,0,0,0,-1,1,0,0,-1,1,1,0,0,0,0,-1,-1,0,-1,0,0,-1,0,0,1,0], [0,0,0,0,-1,1,0,-1,0,0,0,-1,0,0,1,-1,0,0,1,0,0,0,1,0,0,1,1,1], [0,0,0,0,0,0,0,0,0,1,0,0,0,-1,1,-1,1,0,0,0,0,-1,0,1,-1,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,-1,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,-1,0,1,0,1,0,0,-1,0,0,0], [1,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,1,0,-1,0,0,1,0,0,1,-1,1,0,0,0,-1,-1,0,0,0,1,0,0,0,0], [-1,0,-1,0,1,-1,0,0,0,0,0,0,0,0,-1,1,-1,0,0,0,0,1,-1,0,0,0,-1,-1], [-1,0,0,0,1,0,-1,0,0,1,0,0,1,-1,1,0,0,0,0,-1,0,0,0,1,0,1,0,0], [0,0,-1,0,0,0,-1,0,1,0,0,0,0,-1,0,0,-1,-1,0,1,0,1,0,0,-1,0,0,0], [0,0,0,0,0,0,-1,0,1,1,-1,0,1,-1,1,-1,0,-1,0,0,0,0,1,0,-1,1,1,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,-1,0,0,0,1,0,1,-1,1,0,-1,1,-1,1,0,0,0,0,-2,0,0,-1,0,0,0], [0,0,0,0,-1,0,1,-1,0,-1,0,0,-1,0,-1,0,0,0,1,1,0,0,0,-1,0,0,0,0], [-1,1,0,0,0,0,0,0,-1,-1,0,0,0,1,-1,1,-1,0,-1,-1,0,1,-1,0,1,0,0,0], [0,-1,-1,0,0,0,-1,0,1,1,0,0,0,-2,1,-1,0,-1,0,1,0,0,1,1,-1,0,0,0], [-1,1,0,0,-1,0,1,0,-1,-1,0,0,-1,1,-1,0,0,0,0,0,0,0,-1,0,1,0,0,0], [0,1,0,0,0,0,0,0,0,-1,0,0,0,1,-1,1,-1,0,-1,0,0,1,-1,-1,0,-1,0,-1], [1,0,0,0,0,0,0,1,0,1,-1,0,0,0,1,-1,1,0,0,0,0,-2,0,0,-1,0,0,0], [0,-1,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,1,0,1,1,0,0,0,0,0,0,-1,0], [-1,0,0,1,0,0,0,0,0,1,0,-1,0,0,1,-1,0,0,0,-1,0,0,1,1,0,1,1,1], [0,0,0,0,1,-1,-1,1,1,1,-1,1,1,-1,0,0,0,-1,-1,0,0,0,0,0,-1,0,0,-1], [0,0,-1,0,0,0,0,0,0,1,0,0,0,-1,1,-1,0,0,0,0,0,-1,0,1,-1,0,0,0], [0,0,0,0,1,0,-1,0,0,1,0,0,1,-1,1,0,0,0,-1,0,-1,0,0,0,-1,-1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [-1,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,1,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [1,0,0,-1,1,0,-1,1,1,1,-1,1,1,-1,1,0,0,0,-1,0,0,-1,0,0,-1,0,0,-1], [0,0,0,1,-1,0,1,-1,-1,-1,1,-1,-1,1,0,0,0,1,1,0,0,0,0,0,1,0,0,1], [0,0,0,0,1,-1,0,1,0,1,-1,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,-1,-1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [28][28] [[8], [1,8], [1,4,8], [1,4,4,8], [4,1,1,2,8], [4,2,1,1,2,8], [4,1,1,1,2,2,8], [2,1,1,2,4,4,4,8], [2,1,1,2,4,2,2,4,8], [2,1,2,1,2,2,2,2,4,8], [2,2,2,4,4,2,2,4,4,2,8], [2,1,1,2,2,2,4,2,2,4,4,8], [2,1,2,1,2,2,4,2,4,2,2,4,8], [2,1,1,1,2,4,2,4,2,4,2,4,2,8], [2,1,2,1,2,4,2,4,2,2,2,2,4,4,8], [4,1,2,1,4,2,2,2,2,2,2,2,4,2,4,8], [1,2,4,2,1,2,1,2,1,1,1,1,2,2,4,2,8], [4,2,1,1,4,2,2,2,2,4,2,4,2,4,2,4,1,8], [1,4,2,2,2,2,2,1,1,1,1,2,2,1,1,1,2,1,8], [2,4,2,2,2,1,1,1,1,2,1,2,1,2,1,2,2,4,2,8], [1,2,2,4,2,2,2,4,2,1,2,1,1,2,2,1,4,1,2,2,8], [2,2,4,2,2,1,1,1,1,1,1,1,2,1,2,4,4,2,2,4,2,8], [2,2,2,4,4,1,1,2,2,1,2,1,1,1,1,2,2,2,4,4,4,4,8], [1,2,2,2,1,2,1,2,1,2,1,2,1,4,2,1,4,2,2,4,4,2,2,8], [2,4,4,4,1,1,2,1,1,1,2,1,1,2,1,1,2,1,2,2,2,2,2,4,8], [1,4,2,2,1,2,1,1,2,2,1,1,1,1,1,2,2,1,4,2,2,4,2,2,2,8], [1,2,2,4,2,1,1,2,4,2,2,1,2,1,1,1,2,1,2,2,4,2,4,2,2,4,8], [1,2,1,1,0,2,0,1,0,0,-1,0,0,1,1,0,-1,-1,0,1,-1,0,0,-1,1,0,0,8]], [[[-1,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,1,0,0,0], [1,0,0,0,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-1,0,0,0,0,1,0,0,0,0,0,0], [-1,-1,0,0,0,1,1,-1,0,0,1,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,-1,1,-1,0,0,0,1,0,0,0,0,0,0,1,0,-1,0,-1,1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,1,-1,-1,1,-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,-1,0,1,0,0,1,-1,0,0,-1,1,0], [0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,-1,1,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,1,0,-1,0,-1,0,1,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,1,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0], [1,0,0,0,0,0,-1,1,-1,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,-1,1,0,0,-1,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,-1,-1,1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0]], [[0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,1,-1,1,-1,0,0,-1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,1,-1,0,0,1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0], [0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,1,1,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,0,1,1,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,1,0,1,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,1,0,1,0,0,0,0], [-1,0,0,0,0,0,1,-1,0,0,1,-1,0,0,0,0,0,1,0,-1,0,0,0,1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0], [0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,1,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,1,1,0,0,0,0], [0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,1,0,-1,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,-1,1,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,-1,1,-1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,-1,0,0,1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,-1,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,1,0,1,-1,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,1,-1,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,0,0,-1,-1,2,0,0,-1,1,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,-1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,-1,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,-1,1,-1,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,-1,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,-1,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,-1,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,-1,1,1,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,-1,-1,1,0,0,0], [1,0,0,0,0,0,-1,1,0,0,-1,1,0,0,0,0,0,-1,0,0,0,0,0,-1,1,0,0,-1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,-1,-1,1,0,0,0], [1,0,0,0,0,0,-1,1,0,0,-1,1,0,0,0,0,0,-1,0,1,0,-1,0,-1,1,0,0,-1], [1,0,0,0,0,0,-1,1,0,0,-1,1,0,0,0,0,0,-1,0,1,0,0,-1,-1,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,-1,0,-1,1,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,-1,0,-1,1,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,-1,0,0,0,1,0,0,0,0]]]], [ # Q-class [28][29] [[4], [2,4], [2,2,4], [0,0,0,4], [2,2,2,1,4], [2,2,2,0,2,4], [1,1,1,0,1,1,4], [1,1,1,0,1,2,2,4], [2,2,2,0,2,2,1,1,4], [2,2,2,0,2,2,1,1,2,4], [2,2,2,0,2,2,1,1,2,2,4], [1,1,1,0,1,1,2,2,1,1,1,4], [2,2,2,0,2,2,1,1,2,2,2,1,4], [2,2,2,0,2,2,2,1,2,2,2,1,2,4], [1,1,1,0,1,1,2,2,1,1,1,2,1,1,4], [1,1,1,0,1,1,2,2,1,1,1,2,2,1,2,4], [2,2,2,0,2,2,1,1,2,2,2,2,2,2,1,1,4], [1,1,1,0,1,1,2,2,1,1,1,2,1,1,2,2,1,4], [2,1,1,0,1,1,2,2,1,1,1,2,1,1,2,2,1,2,4], [1,1,1,0,1,1,2,2,2,1,1,2,1,1,2,2,1,2,2,4], [1,1,2,0,1,1,2,2,1,1,1,2,1,1,2,2,1,2,2,2,4], [1,1,1,0,1,1,2,2,1,1,2,2,1,1,2,2,1,2,2,2,2,4], [1,1,1,1,1,1,2,2,1,1,1,2,1,1,2,2,1,2,2,2,2,2,4], [1,2,1,0,1,1,2,2,1,1,1,2,1,1,2,2,1,2,2,2,2,2,2,4], [1,1,1,-1,2,1,2,2,1,1,1,2,1,1,2,2,1,2,2,2,2,2,2,2,4], [1,1,1,0,1,1,2,2,1,2,1,2,1,1,2,2,1,2,2,2,2,2,2,2,2,4], [2,2,2,0,2,2,1,1,2,2,2,1,2,2,1,1,2,2,1,1,1,1,1,1,1,1,4], [2,2,2,0,2,2,1,1,2,2,2,1,2,2,2,1,2,1,1,1,1,1,1,1,1,1,2,4]], [[[-1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0], [-1,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0], [-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0], [-1,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [28][30] [[24], [6,24], [4,6,24], [2,3,12,24], [6,4,-4,-2,24], [2,3,-3,-6,3,24], [4,6,4,2,6,2,24], [6,4,6,3,4,3,6,24], [-4,-6,6,3,4,3,6,4,24], [3,12,3,6,2,6,3,2,-3,24], [12,3,2,4,3,4,2,3,-2,6,24], [3,2,-2,-4,12,6,3,2,2,4,6,24], [4,6,-6,-3,6,12,4,6,6,3,2,3,24], [2,3,2,4,3,4,12,3,3,6,4,6,2,24], [-2,-3,3,6,2,6,3,2,12,-6,-4,4,3,6,24], [6,4,6,3,-6,-2,6,4,4,2,3,-3,-4,3,2,24], [3,2,3,6,2,6,3,12,2,4,6,4,3,6,4,2,24], [2,3,-3,3,3,-2,2,3,-2,-3,-2,-3,2,-2,2,-2,-3,24], [6,4,6,3,-6,-2,6,4,-6,2,3,-3,-4,3,-3,4,2,-2,24], [3,2,3,6,-3,-4,3,2,-3,4,6,-6,-2,6,-6,2,4,2,12,24], [4,6,-6,-3,6,2,4,6,-4,3,2,3,4,2,-2,-4,3,12,-4,-2,24], [6,4,6,3,4,3,-4,-6,4,2,3,2,6,-2,2,4,-3,-2,-6,-3,-4,24], [2,3,2,4,3,4,-3,-2,3,6,4,6,2,-6,6,3,-4,3,-2,-4,-3,3,24], [-3,3,2,4,3,-6,2,-2,-2,6,-6,6,-3,4,-4,-2,-4,-2,3,6,2,-2,4,24], [3,2,3,6,2,6,-2,-3,2,4,6,4,3,-4,4,2,-6,2,-3,-6,-2,12,6,-4,24], [-6,6,4,2,6,-3,4,-4,-4,3,-3,3,-6,2,-2,-4,-2,2,6,3,4,-4,2,12,-2,24], [3,2,-2,-4,2,6,3,2,-3,4,6,4,3,6,-6,-3,4,-3,-3,-6,3,-3,-4,-4,-6,-2,24], [6,4,-4,-2,4,3,6,4,-6,2,3,2,6,3,-3,-6,2,3,-6,-3,6,-6,-2,-2,-3,-4,12,24]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [1,1,-1,0,-1,0,0,0,1,-1,-1,0,-1,1,-1,-1,1,0,0,0,0,0,1,0,1,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,1,-1,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,-1,0,0,0,0,0,-1,0,1,0,-1,1,0,0,0,0,0,1,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0], [1,1,-1,0,-1,0,0,0,1,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,1,0,1,0,0,1,-1,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,-1,0,1,1,0,0,0,0,-1,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,1,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1,0,0], [1,1,-1,0,-1,0,0,1,1,-1,-1,0,-1,1,-1,-1,0,-1,-1,1,0,0,1,-1,1,1,0,0], [1,0,-1,0,-1,-1,1,1,0,0,-1,0,0,0,0,-1,0,-1,-1,1,0,0,1,-1,1,1,1,-1], [0,0,1,-1,1,0,0,-1,0,0,0,-1,0,0,0,0,1,0,0,0,0,-1,0,1,1,-1,0,0], [1,0,-1,0,-1,0,1,1,0,0,0,0,0,0,0,-1,0,0,-1,0,-1,0,0,0,0,1,0,-1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,-1,1,0,1,0,-1,-1,0,1,1,0,1,0,0,1,0,1,1,-1,0,0,-1,0,-1,0,-1,1], [0,0,1,0,1,0,-1,-1,0,0,0,0,1,0,0,1,0,0,0,0,0,-1,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,-1,1,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,1,0,1,0,0,0,-1,1,1,0,1,-1,1,1,-1,0,0,0,0,0,-1,0,-1,0,0,0], [1,0,-1,0,-1,0,1,1,0,0,-1,0,-1,0,0,-1,0,-1,-1,1,0,1,1,-1,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,0,-1,-1,0,-1,0,-1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,-1,1,0,1,0,0,-1,-1,1,0,0,1,-1,1,1,0,0,0,0,0,-1,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,1,1,0,1,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,1,0,0,-1,1,0,-1,0,0,0,0,0,-1,0,-1,0,0,0], [-1,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,1,1,1,-1,0,0,0,1,0,0,0,0,1,-1,0,1,-1,0,0,-1,0,-1,0,-1,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,1,1,-1,0,0,1,0,0,1,0,-1,-1,0,-1,1,0,0,0,0], [-1,-1,2,-1,2,0,-1,-1,-1,1,1,-1,1,0,1,1,0,1,1,-1,0,-1,-1,1,0,-1,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,1,0,0,-1,-1,0,0,0,1,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0], [1,0,-1,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,-1,0,0,0,0,0,0,1,-1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,-1,-1,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,1,-1,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,1,0], [1,0,-1,0,-1,0,1,1,0,0,-1,0,-1,0,0,-1,0,-1,-1,1,0,1,1,-1,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [1,0,-1,0,-1,0,1,1,0,0,0,0,-1,0,0,-1,0,0,-1,0,-1,1,0,0,0,1,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [28][31] [[6], [3,6], [3,3,6], [2,1,2,6], [1,0,1,2,6], [2,1,1,3,3,6], [3,1,2,3,1,2,6], [3,2,1,1,1,1,2,6], [1,0,0,2,3,2,2,1,6], [1,1,0,3,2,2,3,3,3,6], [1,0,1,3,3,3,2,1,3,2,6], [2,1,0,1,1,1,1,3,3,2,2,6], [3,1,1,2,1,3,3,2,1,2,2,2,6], [2,1,2,1,1,1,1,2,1,1,-1,1,0,6], [2,2,3,3,1,1,1,1,-1,1,1,0,1,2,6], [2,2,0,2,0,1,1,3,2,3,2,3,1,2,1,6], [1,1,0,2,2,3,2,2,3,3,1,3,2,1,0,1,6], [1,-1,1,2,2,1,2,0,2,1,3,2,3,0,1,0,1,6], [1,2,1,2,0,1,2,2,1,3,1,1,3,2,1,3,1,1,6], [1,0,2,3,1,2,1,1,1,1,2,1,1,1,2,2,1,2,1,6], [1,2,1,1,2,2,1,1,2,1,1,1,2,1,0,0,3,1,1,-1,6], [3,2,2,1,2,2,2,1,-1,1,1,0,2,1,3,1,0,1,1,1,0,6], [2,3,2,1,0,1,1,2,0,1,0,1,1,1,2,1,1,-1,1,1,2,2,6], [1,2,1,1,1,1,1,2,-1,2,0,0,1,3,3,2,0,0,3,1,0,3,1,6], [1,2,2,1,2,1,1,3,1,3,0,1,1,2,1,2,1,0,2,2,1,2,2,3,6], [1,0,1,3,3,1,0,2,2,3,2,1,1,1,2,1,1,2,1,1,1,0,0,1,2,6], [1,2,3,1,2,1,0,2,1,1,1,2,1,2,2,1,2,1,1,1,2,1,1,1,2,2,6], [2,1,0,1,1,1,2,3,1,2,1,1,3,1,0,1,1,2,3,1,2,1,2,2,2,2,0,6]], [[[0,0,0,1,0,-1,-1,0,0,1,1,0,1,1,0,-1,0,-1,-1,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,-1,0,0,0,0,1,0,1,1,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,-1,0,1,1,0,1,1,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0], [-2,0,2,1,0,0,-1,1,1,0,-1,0,1,0,0,1,0,0,-1,-1,0,1,0,0,-1,0,-1,0], [0,0,0,0,-1,0,-1,0,0,1,1,0,0,1,0,-1,0,0,0,0,0,1,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [-2,0,2,1,0,-1,-2,1,1,1,0,0,2,1,0,0,0,-1,-2,0,0,1,-1,0,-1,-1,-1,1], [0,0,0,-1,0,1,0,0,0,0,0,0,-1,0,1,0,0,0,1,0,0,0,0,-1,0,0,0,0], [-2,0,2,0,0,0,-1,1,1,0,-1,0,1,0,0,1,0,0,-1,0,0,1,0,0,-1,0,-1,0], [0,0,1,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,-1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0], [-1,0,1,1,0,0,-1,1,1,1,-1,0,1,0,0,0,-1,0,-1,0,0,0,0,0,-1,-1,0,0], [-2,1,1,1,0,-1,-1,0,0,1,1,0,2,2,0,0,0,-1,-2,0,0,1,-1,-1,0,-1,-1,1], [-2,1,1,1,0,-2,-1,0,0,1,1,0,3,2,-1,0,0,-1,-2,0,0,1,0,0,-1,0,-1,0], [-2,1,2,1,0,-1,-2,1,1,1,0,0,2,1,0,0,0,-1,-2,0,0,1,-1,0,-1,-1,-1,1], [-1,0,0,-1,0,1,1,0,0,-1,-1,0,0,0,1,1,0,0,0,0,0,0,0,-1,0,1,0,0], [-1,0,1,0,0,1,0,0,0,1,-1,1,0,0,0,0,-1,0,0,0,0,0,0,0,-1,0,0,0], [-4,1,3,2,0,-1,-2,2,2,1,-1,0,3,1,-1,1,-1,-1,-3,0,0,2,-1,0,-2,-1,-1,1], [-4,1,3,2,0,-1,-2,1,2,1,-1,0,3,1,0,1,0,-1,-3,-1,-1,2,-1,0,-2,-1,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,1,-1,1,-1,-2,-1,0,0,1,2,0,2,2,-1,-2,0,-1,-1,1,0,1,0,0,0,0,0,-1], [-2,1,1,1,0,-2,-1,1,1,0,1,-1,3,2,-1,0,1,-1,-2,0,-1,1,0,0,-1,0,-1,0], [-3,1,2,2,-1,-2,-2,1,1,1,1,0,3,2,-1,0,0,-1,-3,0,0,2,-1,0,-1,-1,-1,1], [-2,0,2,1,-1,-1,-2,1,2,1,0,0,2,1,0,0,0,-1,-2,0,0,2,-1,0,-1,-1,-1,1], [-2,-1,3,1,0,0,-2,1,1,1,-1,0,1,0,0,1,0,0,-1,-1,0,1,0,0,-1,-1,-1,1], [1,0,-1,-1,0,0,0,-1,-1,1,1,0,0,1,1,0,0,0,0,0,0,-1,0,-1,1,0,0,0], [-4,0,4,3,0,-1,-3,2,2,1,-1,0,3,1,-1,1,0,-1,-3,-1,-1,2,-1,0,-2,-2,-1,2]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [1,0,-1,-1,0,1,1,0,-1,0,0,1,-1,0,0,-1,-1,0,1,1,1,0,0,0,0,1,0,-1], [-1,0,1,0,1,0,0,0,0,0,-1,0,1,0,0,1,0,0,-1,0,0,0,0,0,-1,0,0,1], [0,0,0,1,0,-1,-1,0,0,1,1,0,1,1,0,-1,0,-1,-1,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [-1,1,0,0,0,-1,1,0,0,0,0,0,1,1,-1,0,0,-1,-1,1,0,1,0,0,-1,1,0,0], [0,0,0,0,0,-1,0,-1,0,0,1,0,1,1,0,0,0,-1,-1,0,0,0,0,0,0,0,0,1], [-2,0,1,0,0,0,1,0,1,-1,-1,0,1,0,0,1,0,-1,-1,0,0,1,0,0,-1,1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,1,-1,-1,0,-1,1,-1,0,0,1,0,1,1,0,0,0,-1,-1,1,0,0,0,0,0,1,0,0], [0,1,-1,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,1,0,0,-1,1,1,0,-1,0,1,0,-1,0,0,0,-1,0,0,1,0,1,-1,0,0,0], [-1,0,1,0,0,0,0,0,1,0,-1,0,0,0,0,1,0,0,-1,0,0,1,0,0,-1,0,0,1], [0,1,-1,-1,0,-1,1,-1,0,0,1,0,1,1,0,-1,0,-1,0,1,0,0,0,0,0,1,0,0], [-2,1,1,1,0,-1,-1,1,1,0,0,0,2,1,0,0,0,-1,-2,0,0,1,-1,0,-1,0,-1,1], [-1,1,-1,0,0,0,1,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,1,0,-1,0,1,0,0], [-3,1,2,1,0,-1,-1,1,1,1,-1,1,2,1,-1,0,-1,-1,-2,1,1,2,-1,0,-2,0,-1,1], [2,0,-2,-1,0,0,1,-1,-1,0,1,0,-1,0,1,-1,0,0,1,0,0,-1,0,0,1,0,1,0], [0,0,0,1,-1,0,-1,1,1,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0], [2,0,-2,-1,-1,0,1,-1,-1,0,1,0,-1,0,0,-1,0,0,1,1,1,0,0,0,1,1,1,-1], [-1,0,0,1,0,0,0,1,1,-1,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [-1,0,0,0,0,0,1,0,0,0,-1,1,0,0,0,0,-1,-1,0,1,1,1,0,0,-1,1,0,0], [-1,0,1,0,1,0,0,0,0,0,-1,0,1,0,0,1,0,-1,-1,0,0,0,0,0,-1,0,0,1], [0,1,-1,-1,0,0,1,-1,-1,0,1,1,0,1,0,-1,0,-1,0,1,0,0,0,0,0,1,0,0], [-1,1,0,1,0,-1,0,0,0,0,0,0,1,1,0,0,0,-1,-1,0,0,1,-1,-1,0,0,0,1]]]], [ # Q-class [28][32] [[8], [2,8], [4,0,8], [3,3,3,8], [3,3,3,4,8], [2,1,0,2,1,8], [0,4,2,3,3,1,8], [3,3,3,4,2,0,3,8], [4,1,2,1,2,2,-1,0,8], [1,2,1,3,3,1,2,0,1,8], [2,3,0,-1,1,0,3,1,2,1,8], [2,2,1,3,3,-1,1,0,1,2,3,8], [3,1,2,1,2,-2,0,2,0,1,1,3,8], [3,0,3,2,1,2,0,0,3,3,2,2,2,8], [3,1,0,1,2,2,1,1,3,1,2,2,4,4,8], [4,1,2,0,0,2,1,0,2,2,3,2,3,3,3,8], [2,2,1,2,1,1,1,0,4,2,1,2,0,3,3,1,8], [3,1,3,1,2,-1,0,1,3,3,2,2,2,2,1,2,3,8], [1,1,0,2,1,3,2,0,2,2,0,0,0,1,3,1,4,0,8], [1,1,1,2,1,0,2,2,2,4,1,1,1,3,3,1,4,3,2,8], [3,0,3,1,2,1,0,2,3,0,1,0,2,1,2,3,3,4,3,1,8], [2,2,1,0,0,1,0,1,1,0,0,0,2,-1,0,2,2,2,0,0,2,8], [2,2,1,0,0,1,2,3,1,1,3,1,0,0,0,4,2,1,2,2,3,1,8], [4,1,2,3,0,1,0,3,2,2,1,1,0,3,0,2,4,3,2,2,3,1,4,8], [3,3,0,2,1,1,0,2,3,2,1,1,1,1,2,1,3,0,3,0,2,1,2,3,8], [1,3,1,2,1,2,3,1,3,2,2,0,0,1,1,1,3,1,3,0,1,1,2,2,4,8], [3,1,2,1,2,1,1,-1,3,0,2,3,0,2,1,3,3,1,3,0,2,0,3,3,1,2,8], [1,2,1,2,1,1,4,3,1,0,3,1,0,0,1,2,2,0,2,1,3,-1,4,2,2,3,3,8]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,1,0,1,0,-1,0,0,-1,0,0,0,0,0,1,0,1,1,0,-2,0,0,1,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [-3,0,2,2,2,0,-2,-1,0,-2,2,-2,1,-1,0,2,1,1,1,0,-3,0,0,1,1,-1,-1,1], [-1,0,1,2,0,0,-1,-1,0,0,1,-2,1,-1,1,0,1,1,0,-1,-2,0,1,0,0,-1,0,1], [-1,0,1,2,0,0,-1,-1,0,0,1,-1,0,-1,1,0,0,0,-1,0,0,0,1,0,0,0,0,0], [-1,0,1,0,1,0,-1,0,0,-1,0,0,0,0,0,1,0,1,1,0,-2,0,0,0,0,0,-1,1], [-2,0,2,1,1,0,-1,-1,0,-1,1,-1,0,-1,1,1,0,1,1,0,-2,0,0,1,1,-1,-1,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-2,1,2,1,3,-1,-3,-2,-1,-3,1,-1,-1,0,1,2,-1,1,2,1,-3,1,0,2,0,0,-2,2], [1,0,-1,-3,1,0,0,2,0,0,-2,2,-1,1,-1,1,0,0,1,0,0,0,-1,0,-1,1,-1,1], [-1,0,0,-1,2,0,-1,1,0,-1,0,0,0,0,-1,2,1,0,1,0,-2,0,-1,1,0,0,-1,1], [0,0,0,-1,1,0,0,0,0,-1,0,0,0,0,-1,1,0,0,1,1,-1,0,-1,1,0,0,-1,1], [-1,0,0,0,2,0,-1,0,0,-2,0,0,0,0,-1,2,0,0,1,1,-1,0,-1,1,0,0,-1,1], [0,0,0,0,1,0,-1,0,0,-1,0,0,0,0,-1,1,0,0,1,1,-1,0,0,0,0,0,-1,1], [1,1,0,-2,0,0,0,0,0,0,-1,2,-1,0,0,0,-1,-1,0,1,1,0,-1,1,-1,1,-1,1], [0,0,0,0,1,0,-1,0,0,-1,0,0,0,1,-1,1,0,0,1,0,-1,0,0,0,0,0,-1,1], [0,0,0,0,2,-1,-1,-1,0,-2,0,0,-1,1,0,1,-1,1,2,0,-2,1,0,1,0,0,-2,2], [-1,0,1,1,2,0,-2,-1,-1,-2,1,-1,0,0,-1,2,0,1,1,1,-2,0,0,0,1,0,-1,1], [-1,1,2,0,2,-1,-2,-2,0,-2,0,0,-1,0,1,1,-2,0,2,1,-2,1,0,2,0,0,-2,2], [1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [1,0,0,-1,-1,0,0,1,0,1,0,1,-1,0,0,0,0,-1,0,0,1,0,-1,0,-1,1,0,0], [0,1,1,-1,0,0,0,-1,0,0,-1,1,-1,0,1,0,-1,0,0,0,0,0,0,1,0,0,-1,1], [-2,0,1,1,2,0,-1,-1,0,-2,1,-1,0,0,0,2,0,1,1,0,-2,0,0,1,1,-1,-1,1], [-2,0,1,1,2,0,-2,-1,-1,-2,1,-1,0,0,0,2,0,1,1,1,-2,0,0,1,1,0,-1,1], [-1,0,0,0,1,0,-1,0,0,-1,0,0,0,1,-1,1,0,1,1,0,-1,0,0,0,0,0,-1,1], [-2,0,1,1,1,1,-1,-1,0,-1,1,-1,1,-1,0,1,0,1,0,0,-2,0,0,1,1,-1,0,1], [-2,0,2,1,1,1,-1,-2,0,-1,1,-1,1,-1,1,0,0,1,0,0,-2,0,1,1,1,-1,-1,1]], [[-4,0,3,2,4,0,-3,-3,-1,-4,2,-2,0,-1,1,3,-1,2,2,1,-5,1,0,3,2,-1,-2,2], [-2,-1,1,1,1,1,0,-1,0,-2,1,-1,1,-1,0,1,0,1,0,1,-2,0,0,1,2,-1,0,0], [-1,0,1,1,2,0,-1,-2,-1,-2,1,-1,0,0,0,1,-1,1,1,1,-2,1,0,1,1,0,-1,1], [-1,0,1,0,2,0,-1,-1,-1,-2,0,0,-1,0,1,1,-1,1,1,1,-2,1,0,1,1,0,-1,1], [-1,0,1,0,1,1,-1,0,-1,-1,1,0,0,-1,0,1,0,0,0,1,-1,0,-1,1,1,0,0,0], [-3,0,2,2,2,0,-2,-2,0,-2,2,-2,0,-1,2,1,-1,1,1,0,-3,1,1,2,1,-1,-1,1], [-1,-1,0,1,0,1,1,0,0,0,1,-1,1,-1,0,0,1,0,-1,0,0,0,0,0,1,-1,1,-1], [-2,0,2,1,2,0,-1,-2,0,-2,1,-1,0,-1,1,1,-1,1,1,1,-3,1,0,2,1,-1,-1,1], [-2,0,1,0,3,0,-2,0,-1,-3,1,-1,0,0,-1,3,0,1,2,1,-3,0,-1,1,1,0,-1,1], [-1,0,1,1,1,0,-1,-1,-1,-1,1,-1,0,-1,1,1,0,0,0,1,-1,0,0,1,1,0,0,0], [-1,-1,0,1,1,0,0,0,0,-1,1,-1,1,0,-1,1,1,0,0,0,-1,0,0,0,1,-1,0,0], [0,-1,-1,0,1,0,0,1,-1,-1,0,0,0,1,-1,1,1,1,0,0,-1,0,0,-1,1,0,0,0], [1,0,-1,-1,0,0,1,0,0,0,-1,1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,2,-1,-1,-1,-1,-2,0,0,-1,1,0,1,-1,0,1,1,-1,1,0,1,0,1,-1,1], [-1,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,-1,0,0,1,0,0,0,0], [-1,-1,0,2,1,0,0,-1,0,-1,1,-2,1,0,0,1,1,1,0,-1,-2,0,1,0,1,-1,0,0], [-2,0,1,1,2,0,-1,-1,-1,-3,1,-1,0,0,0,2,0,1,1,1,-2,0,0,1,1,0,-1,0], [-1,0,1,1,1,0,-1,-1,-1,-1,1,-1,0,0,0,1,0,0,0,1,-1,0,0,0,1,0,0,0], [-1,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,1,0,0,1,0,-1,0,0,1,0,0,-1,0], [-1,0,1,1,1,0,-1,-1,-1,-1,1,-1,0,-1,1,1,0,0,0,1,-1,0,0,1,0,0,0,0], [0,0,0,0,1,0,0,0,0,-1,0,0,0,1,-1,1,0,0,1,0,-1,0,0,0,0,0,-1,0], [-3,0,2,3,1,1,-1,-3,0,-2,2,-3,2,-1,1,0,0,2,0,0,-3,0,2,1,2,-2,0,0], [-2,-1,1,2,2,0,-1,-1,0,-2,2,-2,1,-1,0,2,1,1,1,0,-3,0,0,1,1,-1,-1,0], [-2,0,2,1,3,-1,-2,-2,-1,-3,1,-1,-1,0,1,2,-1,1,2,1,-3,1,0,2,1,0,-2,1], [-2,0,1,-1,3,0,-1,0,0,-3,0,0,0,0,-1,3,0,1,2,1,-3,0,-1,2,1,0,-2,1], [-1,0,0,-1,2,0,0,0,0,-2,0,0,0,0,-1,2,0,0,1,1,-1,0,-1,1,1,0,-1,0], [-1,-1,0,1,2,0,-1,0,-1,-2,1,-1,0,0,-1,2,1,1,1,0,-2,0,0,0,1,0,-1,0], [-1,-1,0,1,2,0,0,0,0,-2,1,-1,0,0,-1,2,1,1,1,0,-2,0,0,0,1,-1,-1,0]]]], [ # Q-class [28][33] [[12], [6,12], [3,6,12], [3,6,6,12], [1,2,6,6,12], [3,6,4,6,6,12], [3,6,6,4,6,6,12], [1,2,2,6,4,4,2,12], [1,2,2,2,6,2,4,2,12], [1,2,2,4,4,4,4,2,4,12], [6,3,3,6,3,3,2,3,1,2,12], [2,1,1,1,3,1,2,1,6,2,2,12], [6,3,2,2,0,2,1,1,2,1,4,4,12], [3,6,4,4,0,4,2,2,4,2,2,2,6,12], [6,3,6,3,3,2,3,1,1,1,6,2,4,2,12], [1,2,0,4,6,6,0,4,4,6,2,2,1,2,0,12], [6,3,3,2,3,3,6,1,2,2,4,4,2,1,6,0,12], [2,4,2,4,2,6,2,4,0,6,2,0,3,6,1,6,1,12], [4,2,3,2,2,0,0,1,2,1,4,4,4,2,6,1,0,-1,12], [2,1,3,3,6,3,3,2,3,2,6,6,0,0,6,3,6,1,4,12], [4,2,3,0,2,1,1,1,3,0,0,6,2,1,6,0,2,0,4,4,12], [6,3,3,0,1,1,1,1,1,0,0,2,6,3,6,0,2,1,6,2,6,12], [2,1,1,2,3,1,1,2,2,2,4,4,4,2,2,1,2,2,6,6,2,4,12], [2,4,4,4,2,2,4,2,2,4,2,1,2,4,2,4,2,6,0,1,1,-1,0,12], [2,1,2,1,3,1,1,-1,3,-1,2,6,4,2,4,0,2,0,4,6,6,2,6,1,12], [4,2,2,0,2,0,3,1,2,0,0,4,4,2,4,-1,6,1,2,4,6,6,6,2,6,12], [1,2,2,2,6,4,2,2,6,6,1,3,1,2,1,4,1,0,3,3,3,2,3,0,2,2,12], [2,1,1,1,3,2,1,1,3,3,2,6,2,1,2,2,2,0,6,6,6,4,6,0,4,4,6,12]], [[[-1,-1,1,1,-3,-1,2,-1,1,-2,1,-1,0,-1,-1,2,1,2,1,0,1,0,0,-1,0,0,2,-1], [-1,0,0,0,0,0,0,0,0,0,1,-1,0,0,-1,0,1,0,1,0,1,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,1,-1,0,2,0,-1,0,-1,-1,-1,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,-1,0,0,-1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,1,0,0,0,1,0,0,0,0,-1,0,0], [-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0], [0,0,0,0,-1,0,1,0,0,-1,0,1,-1,0,2,1,-1,0,-1,-1,-1,0,1,0,0,0,1,0], [-1,1,-1,0,1,-1,0,0,0,0,0,-1,1,0,0,0,1,0,0,0,1,0,0,0,0,-1,0,0], [-1,1,0,-1,1,0,-1,0,0,0,1,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0], [-1,1,-1,-1,2,0,-1,0,-1,1,1,0,0,1,-1,-1,1,-1,0,0,1,1,0,1,0,-1,0,-1], [0,2,-2,-2,4,1,-2,1,-1,3,0,0,0,2,1,-2,-1,-3,-1,0,0,0,0,1,0,0,-2,0], [-1,1,-1,0,1,0,-1,0,0,1,0,-1,1,0,-1,-1,1,0,1,1,1,0,-1,0,0,0,0,-1], [-1,1,0,-1,1,0,-1,0,0,1,1,-1,1,0,-2,-1,1,0,1,1,1,0,-1,0,0,0,0,-1], [-1,3,-2,-3,5,2,-4,1,-1,4,1,0,0,2,0,-3,0,-4,-1,0,0,1,0,2,0,0,-3,0], [-1,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,1,0,0,-2,0,1,0,0,1,0,0,0], [0,2,-2,-2,4,1,-3,1,-1,3,0,0,0,2,1,-2,0,-3,-1,0,0,0,0,1,0,0,-2,0], [-1,2,-1,-2,3,1,-3,1,0,3,1,-1,0,1,-1,-2,1,-2,0,0,0,1,-1,1,1,0,-2,0], [-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0], [-1,3,-3,-3,6,2,-4,1,-1,4,1,0,0,2,0,-4,0,-3,0,0,0,1,-1,2,0,0,-3,0]], [[-1,-1,1,1,-2,-2,2,-1,0,-2,1,-1,1,-1,-2,2,2,2,1,0,2,0,0,-1,0,-1,2,-1], [-1,0,0,0,0,0,0,0,0,0,1,-1,1,0,-2,0,2,0,1,0,2,0,0,0,0,-1,0,-1], [-2,0,0,0,0,0,0,0,0,0,1,-1,1,0,-2,0,2,0,1,0,2,1,0,0,0,-1,0,-1], [-1,0,0,0,0,0,0,0,0,0,0,-1,1,0,-2,0,2,0,1,0,2,0,0,0,0,-1,0,-1], [-1,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,0,1,0,1,0,1,0,0,0,0,0,0,-1], [-1,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,1,0,1,-1,1,0,0,0,0,0,0,-1], [-1,0,0,0,0,0,0,0,0,0,1,-1,1,0,-2,0,1,0,1,0,2,0,0,0,0,0,0,-1], [-1,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,1,0,0,-1,0,1,-1,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,-1,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1], [-1,-1,1,2,-2,-2,2,-1,0,-2,0,-1,1,-1,-2,2,2,2,1,0,2,0,0,-1,0,-1,2,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,-1,-1,-1,0,0,1,0,0,0,0,0], [0,0,0,0,0,-1,1,0,-1,-1,0,1,0,0,1,1,0,0,-1,-1,0,0,1,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,-1,-1,0,0,1,0,0,-1,0,0], [-2,0,0,1,-1,-1,1,-1,0,-1,1,-1,1,-1,-2,1,2,1,1,0,2,1,0,0,0,-1,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [-1,-1,1,1,-2,-1,2,-1,0,-1,1,-1,1,-1,-2,2,1,1,1,0,2,0,0,-1,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [-1,1,-1,0,1,-1,0,0,0,0,0,-1,1,0,0,0,1,0,0,0,1,0,0,0,0,-1,0,0], [-1,-1,1,2,-3,-1,2,-1,1,-2,0,-1,1,-2,-1,2,1,2,1,0,1,0,0,-1,0,0,2,-1], [-1,1,-1,-1,2,1,-2,0,0,1,1,0,0,0,0,-1,1,-1,0,-1,0,1,0,1,0,0,-1,0], [-1,0,0,0,-1,-1,1,0,0,-1,1,0,0,-1,0,1,1,1,0,-1,0,1,0,0,1,-1,1,0], [0,0,0,1,-1,-1,1,0,0,-1,-1,0,1,-1,1,1,0,1,0,0,0,-1,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,1,1,0,0,0,-1,0,0,-1], [0,-1,1,2,-3,-1,2,-1,1,-3,-1,0,1,-2,1,2,0,2,0,0,0,-1,1,-1,-1,0,2,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,-1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,-2,3,1,-2,1,-1,2,1,1,-1,1,1,-1,0,-2,-1,-2,-1,1,0,1,1,0,-2,1], [1,-1,1,1,-2,-1,2,0,0,-2,-1,1,0,-1,2,2,-1,1,-1,-1,-1,-1,1,-1,0,0,1,1], [0,-2,1,2,-3,-2,3,-1,0,-3,0,0,0,-1,0,3,1,2,0,-1,1,0,1,-1,0,-1,2,0], [0,-2,2,2,-4,-2,3,-1,1,-3,0,-1,1,-2,-1,3,1,3,1,0,1,-1,0,-2,0,0,2,0], [0,2,-2,-2,5,1,-3,1,-1,3,0,0,0,2,1,-2,0,-3,-1,-1,0,0,0,1,0,0,-3,1], [1,-1,1,1,-3,-1,2,0,1,-2,-1,0,0,-1,2,2,-1,1,-1,0,-1,-1,1,-1,0,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,1,1,-1,0,1,0,0,0,-1,-2,-1,1,0,0,1,0,0,1], [1,0,0,0,0,0,0,0,0,0,-1,0,0,0,2,0,-1,0,-1,0,-1,-1,1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,1,-1,0,1,0,0,-1,-1,1,-1,0,2,1,-1,0,-1,-1,-1,0,1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,0,1,0,1,0,1,-1,0,0,0,0,0,0], [0,0,-1,0,1,0,0,0,-1,1,0,0,0,1,0,0,0,-1,0,0,1,0,0,0,0,0,-1,0], [1,0,0,0,0,0,0,0,0,0,-1,1,0,0,2,0,-1,0,-1,0,-2,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,-1,1,0,0,2,0,-1,0,-1,-1,-1,-1,1,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,-1,0,1,0,1,0,-1,0,-1,1,0,-1,1,0,-1,0,0,0], [1,0,0,0,0,0,0,0,0,0,-1,0,1,0,1,0,-1,0,0,1,0,-1,0,0,-1,0,0,0], [1,0,0,0,0,0,0,0,0,0,-1,1,0,0,2,0,-1,0,-1,0,-1,-1,0,0,0,0,0,1], [0,0,0,0,0,1,-1,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,-1,0], [1,0,0,0,0,0,0,0,0,0,-1,1,0,0,2,0,-1,0,-1,0,-1,-1,1,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,-1,0,1,0,1,0,-1,0,0,1,0,-2,0,0,-1,1,0,0], [1,0,0,0,0,0,0,0,0,-1,-1,1,0,0,2,0,-1,0,-1,0,-1,-1,1,0,-1,0,0,1], [1,0,0,0,0,0,0,0,0,0,-1,1,0,0,2,0,-1,0,-1,0,-1,-1,1,0,-1,0,0,1]]]], [ # Q-class [28][34] [[14], [6,14], [6,6,14], [4,2,2,14], [6,4,2,2,14], [2,4,6,6,4,14], [6,2,6,6,6,6,14], [4,6,2,6,6,4,2,14], [4,2,6,4,2,6,2,6,14], [6,6,2,0,2,2,4,2,2,14], [2,1,1,7,1,3,3,3,2,0,14], [2,1,3,2,1,3,1,3,7,1,4,14], [7,3,3,2,3,1,3,2,2,3,4,4,14], [3,3,7,1,1,3,3,1,3,1,2,6,6,14], [2,3,1,3,3,2,1,7,3,1,6,6,4,2,14], [3,7,3,1,2,2,1,3,1,3,2,2,6,6,6,14], [2,4,2,2,6,6,4,2,-2,6,1,-1,1,1,1,2,14], [1,2,3,3,2,7,3,2,3,1,6,6,2,6,4,4,3,14], [1,2,1,1,3,3,2,1,-1,3,2,-2,2,2,2,4,7,6,14], [2,0,4,6,2,6,2,2,2,-2,3,1,1,2,1,0,6,3,3,14], [2,6,4,-2,4,6,2,2,2,-2,-1,1,1,2,1,3,2,3,1,-2,14], [3,2,1,1,7,2,3,3,1,1,2,2,6,2,6,4,3,4,6,1,2,14], [3,3,1,0,1,1,2,1,1,7,0,2,6,2,2,6,3,2,6,-1,-1,2,14], [1,3,3,1,1,1,2,-1,-1,2,2,-2,2,6,-2,6,3,2,6,2,1,2,4,14], [2,6,6,2,2,2,4,-2,-2,4,1,-1,1,3,-1,3,6,1,3,4,2,1,2,7,14], [3,1,3,3,3,3,7,1,1,2,6,2,6,6,2,2,2,6,4,1,1,6,4,4,2,14], [1,0,2,3,1,3,1,1,1,-1,6,2,2,4,2,0,3,6,6,7,-1,2,-2,4,2,2,14], [1,3,2,-1,2,3,1,1,1,-1,-2,2,2,4,2,6,1,6,2,-1,7,4,-2,2,1,2,-2,14]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1,0,-1,1,-1,0,0,-1,0,0,0,1,1,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,-1,0,0,1,1,0,0,0,1,1], [0,0,0,0,0,0,0,0,0,0,1,-1,0,1,0,-1,0,0,-1,0,0,1,1,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,1,0,-1,1,0,-1,0,-1,0,0,0,1,1,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,1,-1,-1,1,0,-1,0,-1,-1,0,0,1,2,-1,0,-1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,1,-1,0,0,0,1,1,0,0,0,-2,1,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,1], [1,0,0,0,-1,1,0,0,0,-1,0,0,-1,0,0,0,1,-1,-1,-1,-1,1,1,0,0,0,1,1], [-1,0,1,1,0,-1,0,0,-1,2,-1,1,1,-1,0,0,-1,1,1,1,1,0,-2,1,-1,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,1,1,0,0,-1,0,0,0,-1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [1,0,-1,-1,-1,1,0,1,0,-1,1,0,-1,1,-1,0,0,-1,0,0,-1,1,1,-1,1,0,0,1], [0,0,0,0,0,0,0,0,0,0,1,-1,-1,1,0,-1,0,0,-1,0,0,1,2,0,0,-1,0,1], [1,1,-1,-1,-1,1,1,0,0,-1,1,0,-1,1,0,-1,0,-1,0,0,-1,1,1,0,0,-1,0,1], [1,1,-1,-1,-1,0,1,0,1,-2,1,-1,-1,1,0,-1,1,0,-1,0,-1,1,2,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,1,0,0,0,0,-1,1,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,2,0,-1,1,-1,0,0,-1,0,0,0,1,1,-1,0,-1,0,1], [0,1,-1,-1,-1,0,1,0,1,-1,1,-1,0,1,0,-1,1,0,-1,0,-1,1,1,0,0,-1,0,1], [0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,-1,0,0,0,0,-1,0,1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [1,1,-1,-1,-1,1,1,0,1,-2,1,-1,-1,1,0,-1,1,-1,-1,-1,-2,1,2,-1,1,-1,1,2], [0,0,0,1,0,-1,0,-1,0,1,-1,0,0,0,1,0,0,1,0,1,1,0,-1,1,-1,0,-1,-1], [1,0,-1,-2,-1,1,1,1,0,-1,2,0,-1,1,-1,0,0,-1,0,0,-1,1,1,-1,1,-1,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,-1,0,0,1,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0], [-1,0,1,1,1,-1,0,-1,-1,2,0,0,0,0,0,0,-1,0,0,1,1,0,0,0,-1,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,1,0,-1,0,0,-1,2,0,0,0,0,0,0,-1,0,0,1,1,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,-1,0,0,1,1,0,0,0,0,0,0,0], [1,1,-1,-1,-1,1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,-1,0,0,0], [-1,0,1,1,1,-1,0,-1,-1,2,-1,1,1,-1,1,0,-1,1,1,1,1,-1,-2,1,-1,0,-1,-1], [1,1,-1,-1,-1,1,1,0,0,-1,1,0,-1,1,0,-1,0,-1,0,0,-1,1,1,0,0,-1,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,1,1,0,0,-1,0,0,0,-1,0], [0,0,0,0,0,0,0,0,-1,1,0,1,0,0,0,0,-1,0,1,1,1,0,-1,0,0,0,-1,-1], [0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,-1,1,1,1,1,0,-1,0,0,0,-1,-1], [-1,0,1,1,1,-1,-1,0,-1,2,0,0,0,0,0,0,-1,0,0,1,1,0,0,0,-1,0,0,0], [-1,0,1,1,0,-1,0,0,-1,2,-1,1,1,-1,0,0,-1,1,1,1,1,0,-2,1,-1,0,-1,-1], [-1,0,1,1,1,-1,-1,0,-1,2,-1,1,1,-1,0,0,-1,1,1,1,1,-1,-2,1,-1,1,-1,-1], [-1,0,1,2,1,-1,-1,-1,-1,2,0,0,0,0,0,0,-1,0,0,1,1,0,0,0,-1,0,0,0], [1,0,0,-1,-1,1,0,1,0,-1,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,1,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,1,0,1,1,0,-1,1,-1,0,-1,-1], [-1,0,1,1,1,-1,-1,-1,0,2,-1,0,1,-1,1,0,-1,1,1,1,1,-1,-2,1,-1,1,-1,-1], [-1,0,1,1,1,-1,-1,-1,0,2,0,0,0,0,0,0,-1,0,0,1,1,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [-1,0,1,2,1,-1,-1,-1,-1,2,-2,1,1,-1,1,0,-1,1,1,1,1,-1,-2,1,-1,1,-1,-1], [1,0,0,-1,-1,1,0,1,0,-1,1,0,-1,0,-1,0,0,-1,0,-1,-1,1,1,-1,1,0,1,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,-1,0,0,1,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0], [-1,0,1,1,1,-1,0,-1,-1,2,0,0,0,0,0,0,-1,0,0,1,1,0,0,0,-1,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,1,0,-1,0,0,-1,2,0,0,0,0,0,0,-1,0,0,1,1,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,-1,0,0,1,1,0,0,0,0,0,0,0], [1,1,-1,-1,-1,1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,-1,1,-1,0,0,-1,-1,0,0,1,2,-1,0,0,1,1], [0,0,0,0,0,0,0,0,0,0,-1,0,1,-1,0,1,0,1,0,0,0,-1,-1,0,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,1,0,0,0,1,1], [-1,0,1,1,1,-1,-1,0,-1,2,0,0,0,0,0,0,-1,0,0,1,1,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,-1,1,0,0,0,-1,-1,0,0,0,2,-1,0,0,1,1], [0,0,0,0,0,0,0,0,0,0,1,-1,-1,1,0,0,0,-1,-1,0,0,1,2,-1,0,-1,1,1], [-1,0,1,2,1,-1,-1,-1,-1,2,0,0,0,0,0,0,-1,0,0,1,1,0,0,0,-1,0,0,0], [1,0,0,-1,-1,1,0,1,0,-1,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,-1,0,0,1,1], [0,0,0,0,0,0,0,0,0,0,1,0,-1,1,-1,0,0,-1,-1,0,0,1,2,-1,0,-1,1,1], [-1,0,1,1,1,-1,-1,-1,0,2,0,0,0,0,0,0,-1,0,0,1,1,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,2,-1,-1,1,-1,0,0,-1,-1,0,0,1,2,-1,0,-1,1,1], [0,0,0,0,0,0,0,0,0,0,-1,0,1,0,1,0,0,1,0,0,0,-1,-1,1,0,0,-1,-1]]]], [ # Q-class [28][35] [[26], [13,26], [2,1,26], [0,0,6,26], [1,2,1,6,26], [6,6,0,-2,6,26], [0,6,0,-1,6,-1,26], [-1,1,1,0,-1,0,6,26], [-1,1,-1,0,13,0,6,-2,26], [0,0,0,13,6,-1,-2,6,6,26], [0,6,0,-1,-6,-1,-2,6,-6,-2,26], [1,2,1,6,2,6,0,1,1,6,6,26], [-1,1,-1,0,-1,0,-6,-2,-2,6,6,-1,26], [0,-6,0,1,0,1,2,6,0,2,-2,-6,6,26], [0,-6,0,1,6,-1,2,0,6,2,2,-6,6,2,26], [2,1,2,6,-1,6,0,-1,1,0,0,1,-1,0,0,26], [1,2,1,6,-2,6,6,1,-1,6,0,2,1,6,-6,13,26], [1,2,13,6,2,0,6,-1,1,6,6,2,1,-6,6,1,2,26], [6,6,6,-2,-6,-2,-1,0,0,-1,13,6,0,-1,1,0,0,6,26], [6,0,6,-1,0,-1,-1,6,6,1,1,0,0,1,1,6,0,0,-1,26], [1,-1,-1,0,-1,0,6,-2,-2,-6,6,1,-2,6,6,-1,1,1,0,6,26], [0,6,0,-1,6,13,-2,-6,6,-2,-2,6,6,2,-2,0,6,0,-1,1,6,26], [6,6,6,-2,6,-2,13,0,0,-1,-1,0,0,1,1,6,6,6,-2,1,0,-1,26], [6,0,6,-1,0,-1,1,6,0,1,-1,0,6,13,1,-6,0,0,1,2,6,1,-1,26], [6,0,-6,-1,0,1,1,6,-6,1,-1,0,-6,-1,1,-6,0,0,1,-2,6,-1,-1,-2,26], [2,1,-2,6,1,-6,0,1,-1,0,0,1,-1,0,0,-2,-1,-1,-6,6,1,0,6,6,0,26], [1,2,-1,6,2,-6,6,-1,1,6,-6,2,1,-6,6,-1,-2,-2,-6,0,-1,-6,6,0,0,13,26], [6,6,-6,-2,6,2,-1,0,0,-1,1,6,0,1,-1,-6,-6,-6,2,-1,0,1,-2,-1,13,0,0,26]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,-1,1,0,-1,2,0,-1,-3,1,2,0,0,0,1,1,1,-1,2,-2,-1,-2,-1,2,-1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0], [1,-1,2,-1,0,0,2,0,0,2,0,0,1,-1,0,1,-1,-2,0,-1,1,0,-1,-1,0,2,-2,0], [2,-1,2,-2,0,-1,2,0,0,2,1,0,0,0,0,2,-1,-1,-1,-2,0,1,-2,-1,0,2,-1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,1,-1,0,-1,2,-2,-1,2,2,0,-1,1,0,2,-2,-1,-1,0,-2,2,-1,1,2,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [3,0,8,-6,1,-4,10,-6,-3,7,5,2,0,2,2,6,-4,-6,-4,-2,-4,3,-8,-2,5,5,-4,-3], [1,-1,3,-2,0,-2,7,-6,-3,5,6,0,-2,1,1,4,-4,-4,-3,1,-5,4,-3,2,4,0,-1,-2], [1,-1,1,-1,0,-1,2,-1,-1,2,2,0,-1,0,0,1,-1,-1,-1,0,-1,2,-1,0,0,0,0,0], [-1,-1,-3,3,-1,2,-3,2,1,-2,-1,-2,0,-1,-1,-2,1,2,2,1,1,0,3,1,-2,-2,2,2], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [-1,1,-1,1,0,1,-2,1,1,-2,-2,0,1,0,0,-1,1,1,1,0,1,-2,1,0,0,0,0,0], [-2,0,-6,4,0,2,-7,4,2,-6,-3,-1,0,0,-2,-4,3,5,3,2,2,-2,5,1,-3,-4,4,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [3,1,5,-5,2,-2,2,1,0,2,-2,2,3,1,0,2,0,-1,-1,-4,3,-2,-5,-5,0,5,-3,-1], [2,1,6,-5,1,-3,6,-4,-2,5,3,2,0,2,2,4,-2,-4,-3,-2,-2,1,-6,-2,3,4,-3,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,1,4,-3,0,-2,6,-5,-2,4,4,2,-1,2,2,3,-3,-4,-3,0,-4,2,-4,0,4,2,-2,-3], [2,0,3,-2,0,-1,1,1,1,1,-1,1,2,0,0,1,0,-1,-1,-3,2,-1,-2,-3,0,3,-2,0], [0,0,-1,1,0,0,-2,1,1,-2,0,0,0,0,0,-1,1,1,0,0,0,0,1,0,0,-1,1,0], [1,0,3,-2,0,-1,5,-4,-1,3,3,1,0,1,1,2,-2,-3,-2,0,-3,1,-3,0,3,2,-2,-2]]]], [ # Q-class [28][36] [[28], [4,28], [9,6,28], [9,-5,9,28], [1,6,9,2,28], [6,2,10,6,10,28], [10,3,6,9,-2,-5,28], [1,9,2,4,6,1,6,28], [6,9,-3,3,-5,-2,9,10,28], [-2,9,9,-2,10,6,9,10,6,28], [3,4,10,9,9,6,10,10,-1,5,28], [10,-2,3,9,6,10,6,-2,9,-5,9,28], [-2,10,9,0,9,2,1,10,3,9,9,-3,28], [9,3,9,10,5,10,6,6,9,9,4,-1,10,28], [9,2,6,1,3,9,5,9,9,10,1,6,9,6,28], [4,-1,-1,10,9,10,6,6,2,2,9,9,1,6,9,28], [4,5,5,4,6,9,-1,-4,-6,-3,10,6,1,3,3,6,28], [10,0,6,10,2,9,3,-2,1,-3,-2,9,-2,-1,6,9,3,28], [9,1,-2,2,9,3,9,9,5,6,6,10,6,4,10,10,-5,9,28], [10,9,6,4,6,9,-1,3,10,9,4,5,-2,6,6,3,6,9,1,28], [9,5,6,2,9,10,-2,-2,2,1,1,9,1,9,5,5,6,-2,0,6,28], [9,-2,6,10,-1,4,2,6,9,4,2,9,-5,3,3,2,0,3,2,5,0,28], [2,2,2,9,9,5,-2,-6,-1,-1,-1,10,3,4,-6,0,2,1,2,-3,10,4,28], [6,10,-2,-1,10,9,2,4,6,9,3,2,9,10,10,9,1,1,9,9,4,-6,6,28], [2,5,-1,9,0,1,6,5,10,4,1,9,0,2,3,-1,-1,-2,4,5,9,3,9,-3,28], [10,6,6,1,6,4,2,-2,-2,-6,1,9,2,-2,-1,3,9,5,4,-4,9,9,9,-5,2,28], [2,9,9,6,10,9,-3,9,6,3,6,9,6,1,-2,-2,1,9,6,10,4,10,6,-1,10,10,28], [-1,2,2,5,2,3,4,1,5,9,6,4,9,10,4,-6,9,-6,-1,1,0,4,9,2,10,-3,0,28]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,-1,2,0,0,0,0,0,2,0,-1,-1,0,-2,-2,1,1,0,1,-1,1,0,-1,1,0,0,0,1], [0,0,-1,-1,1,0,0,0,0,0,1,0,0,1,0,-1,0,2,-1,-1,0,1,0,0,1,0,-1,-1], [0,-2,2,-1,0,1,0,1,2,-1,0,-2,1,-2,-2,0,1,1,1,0,1,1,0,1,1,0,-2,0], [0,1,-2,0,0,-2,-1,0,-2,2,1,3,-1,3,2,-1,-1,1,-2,0,-1,-1,0,-1,0,1,0,-1], [0,1,-2,0,0,-1,0,0,-2,1,1,2,0,2,1,-1,-1,1,-1,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,1,-1,0,0,-1,0,0,-2,1,0,2,0,2,1,0,0,0,-1,0,-1,0,0,-1,0,0,0,-1], [1,3,-4,1,-1,-2,0,-2,-4,2,1,3,-1,4,5,1,-2,-2,-2,1,-2,-2,2,-4,-3,0,4,-1], [-1,-1,2,-1,1,1,0,0,2,-1,0,-1,1,-1,-3,-1,1,2,1,-1,1,2,-2,2,2,0,-3,0], [0,0,0,-1,0,-1,0,1,-1,0,0,1,0,1,0,0,0,1,-1,0,0,0,0,0,0,0,0,0], [1,3,-5,1,-1,-3,-1,-1,-5,3,2,4,-2,5,6,0,-3,-1,-3,1,-2,-3,2,-4,-3,1,4,-1], [0,0,0,-1,0,-1,0,0,-1,0,0,1,0,1,0,0,0,1,-1,-1,0,1,-1,1,1,0,0,0], [0,2,-3,0,0,-1,1,-1,-3,0,1,2,0,3,3,0,-2,0,-2,1,-1,0,1,-2,-1,0,1,-1], [0,2,-3,0,0,-2,-1,-1,-3,2,2,3,-1,4,3,-1,-1,1,-2,-1,-1,0,0,-1,0,0,1,-2], [0,0,-1,0,0,-1,0,0,-1,1,1,1,0,1,1,-1,0,1,-1,0,0,0,0,0,0,0,0,-1], [0,1,-1,0,0,-1,0,0,-1,0,1,1,-1,1,2,0,-1,0,-1,0,0,-1,1,-1,-1,0,1,0], [1,-1,1,0,0,1,0,0,2,0,0,-2,0,-2,-1,0,1,0,1,-1,1,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,-1,2,0,0,0,-1,0,2,0,0,-1,0,-1,-2,0,1,1,1,-1,1,0,-1,1,1,0,-1,0], [0,3,-5,1,-1,-4,-2,-1,-5,4,3,5,-2,6,5,-1,-3,1,-4,0,-2,-2,1,-2,-1,2,2,-2], [-1,-1,2,-1,1,3,2,0,2,-3,-1,-3,2,-3,-2,0,1,0,2,1,1,2,0,0,1,-1,-2,0], [1,1,-2,1,-1,-2,-2,0,-2,3,1,3,-1,2,2,0,-2,0,-2,0,-1,-2,0,-1,-1,2,1,0], [0,1,-1,1,-1,-2,-1,0,-2,2,0,3,-1,2,1,0,-1,0,-1,0,0,-1,-1,0,-1,1,1,0], [0,-1,1,0,0,-1,-2,0,1,1,1,0,0,0,-1,0,0,1,0,-1,0,0,-1,1,1,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,1,-1,0,0,0,0,0,-1,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,1]], [[-2,-5,8,-2,2,6,3,1,8,-7,-3,-8,4,-9,-9,0,4,1,6,0,4,5,-3,5,4,-2,-6,2], [-1,0,-1,0,1,1,1,0,0,-1,0,0,1,0,0,-1,0,0,0,1,0,1,0,0,0,0,-1,-1], [-1,-2,3,0,1,3,2,0,4,-3,-2,-4,2,-5,-4,0,2,0,3,0,2,2,-1,2,1,-1,-2,1], [-1,-4,6,-2,1,4,3,1,6,-5,-3,-6,3,-7,-6,1,3,0,4,0,3,3,-1,3,2,-2,-3,2], [0,-1,1,0,0,1,0,0,2,-1,0,-2,0,-2,-1,0,0,0,1,0,1,0,0,1,0,0,0,1], [-1,-1,1,-1,1,2,2,0,2,-3,0,-3,1,-2,-1,-1,1,1,1,0,1,2,0,1,1,-1,-1,0], [0,-1,2,0,0,2,2,0,2,-2,-2,-2,1,-3,-2,1,1,-2,2,1,1,0,0,0,-1,-1,0,1], [0,-3,3,-1,0,2,1,1,3,-2,-2,-3,2,-4,-4,1,2,0,2,0,2,1,-1,2,1,-1,-1,1], [0,1,-2,0,0,0,1,0,-2,0,0,2,0,2,2,0,-1,-1,-1,1,-1,-1,1,-2,-1,0,1,-1], [0,1,-2,1,-1,-1,0,0,-2,1,0,2,-1,2,2,0,-1,-1,-1,1,-1,-2,1,-1,-2,1,2,0], [0,0,0,-1,1,2,3,-1,1,-3,-1,-3,1,-2,0,1,0,-1,1,1,1,1,1,-1,-1,-2,1,1], [0,1,-1,0,1,1,2,-1,0,-2,0,-1,0,0,2,0,-1,-1,0,1,0,0,1,-2,-1,-1,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-2,3,-1,0,3,2,1,3,-3,-2,-3,2,-4,-4,0,2,0,3,0,2,2,-1,2,1,-1,-2,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-3,4,-2,1,2,1,1,4,-3,-1,-4,1,-4,-4,0,2,1,2,-1,2,2,-1,3,2,-1,-2,1], [-1,0,1,-1,1,2,2,0,1,-3,-1,-2,1,-2,-1,0,0,0,1,1,1,2,0,0,0,-1,-1,1], [-1,-2,2,-1,1,1,1,0,2,-2,0,-2,1,-2,-2,-1,1,1,1,0,1,2,-1,2,2,0,-2,0], [0,-1,1,0,0,0,0,0,1,-1,0,-1,0,-1,-1,0,0,0,1,0,1,0,-1,1,0,0,0,1], [-2,-1,1,-1,1,2,2,0,1,-3,0,-2,1,-1,-1,-1,0,1,1,1,1,2,0,1,1,0,-2,0], [0,-1,1,0,1,2,0,0,3,-1,0,-2,1,-2,-2,-1,1,1,1,-1,1,1,-1,1,1,0,-2,0], [-1,-3,5,-1,1,3,2,1,4,-4,-3,-4,2,-5,-5,1,2,0,3,0,2,2,-2,3,2,-1,-2,2], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,-1,0,0,0,0,0,-1,1,0,0,1,0,-1,0,1,0,0,0,1,0,1,1,0,-1,-1], [0,1,-2,1,0,0,1,0,-1,0,0,1,0,1,2,0,-1,-1,-1,1,0,-1,1,-2,-2,0,1,0], [-1,-4,6,-1,2,4,1,1,7,-4,-2,-6,2,-7,-7,0,3,1,4,-1,3,3,-3,4,3,-1,-4,2], [-1,-1,0,0,1,1,1,0,1,-1,0,-1,1,-1,-1,-1,0,1,0,0,1,1,-1,1,1,0,-1,0], [0,4,-5,1,-1,-1,2,-1,-5,0,0,3,-1,4,6,1,-3,-3,-2,3,-2,-2,3,-5,-4,0,4,0]]]], [ # Q-class [28][37] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]]]] ]; MakeImmutable( IMFList[28].matrices ); gap-4r6p5/grp/perf11.grp0000644000175000017500000012225212172557252013545 0ustar billbill############################################################################# ## #W perf11.grp GAP Groups Library Volkmar Felsch ## Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains the perfect groups of sizes 524880-786240 ## All data is based on Holt/Plesken: Perfect Groups, OUP 1989 ## PERFGRP[250]:=[# 524880.1 [[1,"abcuvwxyz", function(a,b,c,u,v,w,x,y,z) return [[a^4,b^3,c^3,(b*c)^4*a^2,(b*c^-1)^5,a^2*b*a^2 *b^-1,a^2*c*a^2*c^-1, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,u^3, v^3,w^3,x^3,y^3,z^3,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*u*a*(u^2*v*w^2*x^2*y)^-1, a^-1*v*a*(u*v*w^2*z)^-1, a^-1*w*a*(u^2*w*x*y^2*z^2)^-1, a^-1*x*a*(v^2*w*y^2)^-1, a^-1*y*a*(u*v^2*w^2*y^2*z)^-1, a^-1*z*a*(u^2*v^2*x^2*y*z)^-1, b^-1*u*b*(u*w^2*y)^-1, b^-1*v*b*(v*x^2*z)^-1, b^-1*w*b*(w*y)^-1,b^-1*x*b*(x*z)^-1, b^-1*y*b*y^-1,b^-1*z*b*z^-1, c^-1*u*c*u^-1,c^-1*v*c*v^-1, c^-1*w*c*(v*w)^-1, c^-1*x*c*(u*v^2*x)^-1, c^-1*y*c*(u*v^2*x^2*y)^-1, c^-1*z*c*(u^2*v^2*w^2*x*z)^-1], [[c*b*a^-1,b,u,v],[b,c*a*b*c,y,z,w,x]]]; end, [80,90]], "A6 2^1 x 3^6",[14,6,1],2, 3,[80,90]], # 524880.2 [[1,"abcuvwxyz", function(a,b,c,u,v,w,x,y,z) return [[a^4*v^-1*w*x*y^-1,b^3*z^-1,c^3*v,(b*c)^4 *a^2*(v^-1*w*x*y^-1)^-1 *(v*x^-1*y^-1)^-1, (b*c^-1)^5*(v*x^-1*y)^-1, a^2*(v^-1*w*x*y^-1)^-1*b*v^-1*w*x *y^-1*a^(-1*2)*b^-1, a^2*(v^-1*w*x*y^-1)^-1*c*v^-1*w*x *y^-1*a^(-1*2)*c^-1, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,u^3, v^3,w^3,x^3,y^3,z^3,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*u*a*(u^-1*v*w^-1*x^-1*y)^-1 ,a^-1*v*a*(u*v*w^-1*z)^-1, a^-1*w*a*(u^-1*w*x*y^-1*z^-1)^-1 ,a^-1*x*a*(v^-1*w*y^-1)^-1, a^-1*y*a*(u*v^-1*w^-1*y^-1*z)^-1 ,a^-1*z*a*(u^-1*v^-1*x^-1*y*z) ^-1,b^-1*u*b*(u*w^-1*y)^-1, b^-1*v*b*(v*x^-1*z)^-1, b^-1*w*b*(w*y)^-1,b^-1*x*b*(x*z)^-1, b^-1*y*b*y^-1,b^-1*z*b*z^-1, c^-1*u*c*u^-1,c^-1*v*c*v^-1, c^-1*w*c*(v*w)^-1, c^-1*x*c*(u*v^-1*x)^-1, c^-1*y*c*(u*v^-1*x^-1*y)^-1, c^-1*z*c*(u^-1*v^-1*w^-1*x*z)^-1 ],[[c*b*a^-1,b,u,v],[b,c*a*b*c,y,z,w,x]]]; end, [80,90],[0,[2,-3]]], "A6 2^1 x N 3^6",[14,6,2],2, 3,[80,90]], # 524880.3 [[1,"abcdwxyze", function(a,b,c,d,w,x,y,z,e) return [[a^4*d,b^3,c^3*(w*x*y^-1)^-1,(b*c)^4*(a^2*d ^-1)^-1,(b*c^-1)^5, a^2*d^-1*b*(a^2*d^-1)^-1*b^-1, a^2*d^-1*c*(a^2*d^-1)^-1*c^-1, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,e^3, a^-1*e*a*e^-1,b^-1*e*b*e^-1, c^-1*e*c*e^-1,d^-1*e*d*e^-1, w^-1*e*w*e^-1,x^-1*e*x*e^-1, y^-1*e*y*e^-1,z^-1*e*z*e^-1, d^3*e^-1,w^3,x^3,y^3,z^3,d^-1*w^-1*d*w, d^-1*x^-1*d*x,d^-1*y^-1*d*y, d^-1*z^-1*d*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*d*a*d^-1, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*d*b*(d*w*y^-1*z*e)^-1, b^-1*w*b*(x*e)^-1, b^-1*x*b*(y*e^-1)^-1, b^-1*y*b*w^-1, b^-1*z*b*(z*e^-1)^-1, c^-1*d*c*(d*x^-1*z^-1*e)^-1, c^-1*w*c*(w^-1*x*y^-1*z^-1*e^-1) ^-1,c^-1*x*c*(x^-1*z*e^-1)^-1, c^-1*y*c*(w*x^-1*e)^-1, c^-1*z*c*(x^-1*e)^-1], [[c*b*a^-1,b,w], [a*b,b*a*b*a*b^-1*a*b^-1,w*e]]]; end, [80,324],[0,[2,-3]]], "A6 2^1 x ( 3^1 E 3^4' E 3^1 ) A",[14,6,3],6, 3,[80,324]], # 524880.4 [[1,"abcwxyzef", function(a,b,c,w,x,y,z,e,f) return [[a^4,b^3,c^3,(b*c)^4*a^2,(b*c^-1)^5,a^2*b*a^2 *b^-1,a^2*c*a^2*c^-1, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,w^3, x^3,y^3,z^3,e^3,f^3,w^-1*e^-1*w*e, x^-1*e^-1*x*e,y^-1*e^-1*y*e, z^-1*e^-1*z*e,w^-1*f^-1*w*f, x^-1*f^-1*x*f,y^-1*f^-1*y*f, z^-1*f^-1*z*f,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*w*a*z^-1, a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, a^-1*e*a*e^-1,a^-1*f*a*f^-1, b^-1*w*b*x^-1, b^-1*x*b*(y*e^-1)^-1, b^-1*y*b*(w*e)^-1,b^-1*z*b*(z*e)^-1, b^-1*e*b*e^-1,b^-1*f*b*f^-1, c^-1*w*c*(w^-1*x*y^-1*z^-1*f)^-1 ,c^-1*x*c*(x^-1*z*f)^-1, c^-1*y*c*(w*x^-1*f)^-1, c^-1*z*c*(x^-1*f^-1)^-1, c^-1*e*c*e^-1,c^-1*f*c*f^-1], [[c*b*a^-1,b,w],[a,b,w],[a,c,w]]]; end, [80,18,18]], "A6 2^1 x 3^4' E ( 3^1 x 3^1 )",[14,6,4],18, 3,[80,18,18]], # 524880.5 [[1,"abcwxyzdf", function(a,b,c,w,x,y,z,d,f) return [[a^4*d,b^3,c^3,(b*c)^4*(a^2*d^-1)^-1,(b*c^(-1 *1))^5,a^2*d^-1*b*(a^2*d^-1)^-1 *b^-1,a^2*d^-1*c*(a^2*d^-1)^-1 *c^-1,a^-1*b^-1*c*b*c*b^-1*c*b *c^-1,b^-1*d^-1*b*d, c^-1*d^-1*c*d,w^3,x^3,y^3,z^3,d^3,f^3, w^-1*d^-1*w*d,x^-1*d^-1*x*d, y^-1*d^-1*y*d,z^-1*d^-1*z*d, d^-1*f^-1*d*f,w^-1*f^-1*w*f, x^-1*f^-1*x*f,y^-1*f^-1*y*f, z^-1*f^-1*z*f,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*w*a*z^-1, a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, a^-1*f*a*f^-1,b^-1*w*b*x^-1, b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1,b^-1*f*b*f^-1, c^-1*w*c*(w^-1*x*y^-1*z^-1*f)^-1 ,c^-1*x*c*(x^-1*z*f)^-1, c^-1*y*c*(w*x^-1*f)^-1, c^-1*z*c*(x^-1*f^-1)^-1, c^-1*f*c*f^-1], [[c*b*a^-1,b,w],[a,b,w],[a*d,c*d,w]]]; end, [80,18,18]], "A6 2^1 x 3^1 x ( 3^4' E 3^1 ) I",[14,6,5],18, 3,[80,18,18]], # 524880.6 [[1,"abcwxyzde", function(a,b,c,w,x,y,z,d,e) return [[a^4*d,b^3,c^3,(b*c)^4*(a^2*d^-1)^-1,(b*c^(-1 *1))^5,a^2*d^-1*b*(a^2*d^-1)^-1 *b^-1,a^2*d^-1*c*(a^2*d^-1)^-1 *c^-1,a^-1*b^-1*c*b*c*b^-1*c*b *c^-1,b^-1*d^-1*b*d, c^-1*d^-1*c*d,d^3,w^3,x^3,y^3,z^3,e^3, w^-1*d^-1*w*d,x^-1*d^-1*x*d, y^-1*d^-1*y*d,z^-1*d^-1*z*d, e^-1*d^-1*e*d,w^-1*e^-1*w*e, x^-1*e^-1*x*e,y^-1*e^-1*y*e, z^-1*e^-1*z*e,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*w*a*z^-1, a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, a^-1*e*a*e^-1,b^-1*w*b*x^-1, b^-1*x*b*(y*e^-1)^-1, b^-1*y*b*(w*e)^-1,b^-1*z*b*(z*e)^-1, b^-1*e*b*e^-1, c^-1*w*c*(w^-1*x*y^-1*z^-1*e^-1) ^-1,c^-1*x*c*(x^-1*z*e^-1)^-1, c^-1*y*c*(w*x^-1*e^-1)^-1, c^-1*z*c*(x^-1*e)^-1, c^-1*e*c*e^-1], [[c*b*a^-1,b,w],[a*b,b*a*b*a*b^-1*a*b^-1 ,w*e,d],[a*d,c*d,w]]]; end, [80,108,18]], "A6 2^1 x 3^1 x ( 3^4' E 3^1 ) II",[14,6,6],18, 3,[80,108,18]], # 524880.7 [[1,"abcstuvde", function(a,b,c,s,t,u,v,d,e) return [[a^4*d,b^3,c^3,(b*c)^4*a^(-1*2)*d,(b*c^-1)^5,a^(-1 *1)*b^-1*c*b*c*b^-1*c*b *c^-1,a^(-1*2)*b^-1*a^2*b, a^(-1*2)*c^-1*a^2*c,d^3,s^3,t^3,u^3,v^3,e^3, d^-1*e^-1*d*e,d^-1*s^-1*d*s, d^-1*t^-1*d*t,d^-1*u^-1*d*u, d^-1*v^-1*d*v,e^-1*s^-1*e*s, e^-1*t^-1*e*t,e^-1*u^-1*e*u, e^-1*v^-1*e*v,s^-1*t^-1*s*t, s^-1*u^-1*s*u*e^-1,s^-1*v^-1*s *v,t^-1*u^-1*t*u,t^-1*v^-1*t*v *e^-1,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*(s^-1*e)^-1, a^-1*v*a*(t^-1*e)^-1, a^-1*e*a*e^-1, b^-1*s*b*(s*v^-1*e^-1)^-1, b^-1*t*b*(t*u^-1*v*e)^-1, b^-1*u*b*u^-1,b^-1*v*b*v^-1, b^-1*e*b*e^-1, c^-1*s*c*(s^-1*t*u^-1*v*e)^-1, c^-1*t*c*(s*t*u*v*e^-1)^-1, c^-1*u*c*(s^-1*v^-1)^-1, c^-1*v*c*(t^-1*u^-1*v)^-1, c^-1*e*c*e^-1],[[a,b,c],[a*d,c*d,s]]]; end, [243,18]], "A6 2^1 3^1 x ( 3^4 C 3^1 )",[14,6,7],9, 3,[243,18]], # 524880.8 [[1,"abcstuved", function(a,b,c,s,t,u,v,e,d) return [[a^4*d,b^3,c^3,(b*c)^4*a^(-1*2)*d,(b*c^-1)^5,a^(-1 *1)*b^-1*c*b*c*b^-1*c*b *c^-1,a^(-1*2)*b^-1*a^2*b, a^(-1*2)*c^-1*a^2*c,s^3,t^3,u^3,v^3,e^3,d^3, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v, d^-1*s^-1*d*s,d^-1*t^-1*d*t, d^-1*u^-1*d*u,d^-1*v^-1*d*v, d^-1*e^-1*d*e,s^-1*t^-1*s*t, s^-1*u^-1*s*u*e^-1, s^-1*v^-1*s*v*d^-1, t^-1*u^-1*t*u*d^-1, t^-1*v^-1*t*v*(e*d^-1)^-1, u^-1*v^-1*u*v, a^-1*s*a*(u*d^-1)^-1, a^-1*t*a*(v*d)^-1, a^-1*u*a*(s^-1*e)^-1, a^-1*v*a*(t^-1*e)^-1, a^-1*e*a*e^-1, b^-1*s*b*(s*v^-1*e^-1)^-1, b^-1*t*b*(t*u^-1*v*e*d^-1)^-1, b^-1*u*b*u^-1,b^-1*v*b*v^-1, b^-1*e*b*e^-1, c^-1*s*c*(s^-1*t*u^-1*v*e*d)^-1, c^-1*t*c*(s*t*u*v*e^-1)^-1, c^-1*u*c*(s^-1*v^-1*d^-1)^-1, c^-1*v*c*(t^-1*u^-1*v)^-1, c^-1*e*c*e^-1], [[a*d,b*d^-1,e],[a,b,c,d]]]; end, [1458,243]], "A6 2^1 3^4 C ( 3^1 x N 3^1 )",[14,6,8],9, 3,[1458,243]], # 524880.9 [[1,"abcstuvef", function(a,b,c,s,t,u,v,e,f) return [[a^4,b^3,c^3,(b*c)^4*a^(-1*2),(b*c^-1)^5,a^-1 *b^-1*c*b*c*b^-1*c*b*c^-1, a^(-1*2)*b^-1*a^2*b,a^(-1*2)*c^-1*a^2*c, s^3,t^3,u^3,v^3,e^3,f^3,e^-1*s^-1*e*s, e^-1*t^-1*e*t,e^-1*u^-1*e*u, e^-1*v^-1*e*v,f^-1*s^-1*f*s, f^-1*t^-1*f*t,f^-1*u^-1*f*u, f^-1*v^-1*f*v,f^-1*e^-1*f*e, s^-1*t^-1*s*t,s^-1*u^-1*s*u *e^-1,s^-1*v^-1*s*v*f^-1, t^-1*u^-1*t*u*f^-1, t^-1*v^-1*t*v*(e*f^-1)^-1, u^-1*v^-1*u*v, a^-1*s*a*(u*f^-1)^-1, a^-1*t*a*(v*f)^-1, a^-1*u*a*(s^-1*e)^-1, a^-1*v*a*(t^-1*e)^-1, a^-1*e*a*e^-1,a^-1*f*a*f^-1, b^-1*s*b*(s*v^-1*e^-1)^-1, b^-1*t*b*(t*u^-1*v*e*f^-1)^-1, b^-1*u*b*u^-1,b^-1*v*b*v^-1, b^-1*e*b*e^-1,b^-1*f*b*f^-1, c^-1*s*c*(s^-1*t*u^-1*v*e*f)^-1, c^-1*t*c*(s*t*u*v*e^-1)^-1, c^-1*u*c*(s^-1*v^-1*f^-1)^-1, c^-1*v*c*(t^-1*u^-1*v)^-1, c^-1*e*c*e^-1,c^-1*f*c*f^-1], [[a,b,c,e],[a,b,c,f]]]; end, [243,243]], "A6 2^1 3^4 C ( 3^1 x 3^1 )",[14,6,9],9, 3,[243,243]] ]; PERFGRP[251]:=[# 531360.1 [[1,"abc", function(a,b,c) return [[c^40*a^2,b^3,c^(-1*12)*b*c*b*c^11*b^-1,c^(-1*20) *b*c^20*b^(-1*2),a^4,a^2*b^-1*a^2*b, a^2*c^-1*a^2*c,c*a*c*a^-1,(b*a)^3, c^2*b^2*c^2*b*c*a*b*a*c^3*b*c*a*b^(-1*2) *c^(-1*2)*b^-1*a],[[b,c^16]]]; end, [1312],[0,0,2,2,2]], "L2(81) 2^1 = SL(2,81)",22,-2, 42,1312] ]; PERFGRP[252]:=[# 544320.1 [[2,1080,1,504,1], "A6 3^1 x L2(8)",40,3, [3,4],[18,9]] ]; PERFGRP[253]:=[# 546312.1 [[1,"abc", function(a,b,c) return [[c^51,c*b^25*c^-1*b^-1,b^103,a^2,c*a*c*a^(-1 *1),(b*a)^3],[[b,c]]]; end, [104],[0,4,3]], "L2(103)",22,-1, 49,104] ]; PERFGRP[254]:=[# 550368.1 [[2,504,1,1092,1], "L2(8) x L2(13)",40,1, [4,6],[9,14]] ]; PERFGRP[255]:=[# 552960.1 [[4,184320,1,1080,2,360,1,1], "A6 3^1 x ( 2^4 x 2^4 ) 2^1 I",[13,9,1],6, 3,[16,12,18]], # 552960.2 [[4,184320,2,1080,2,360,2,1], "A6 3^1 x ( 2^4 x 2^4 ) 2^1 II",[13,9,2],6, 3,[16,80,18]], # 552960.3 [[4,184320,3,1080,2,360,3,1], "A6 3^1 x ( 2^4 x 2^4 ) 2^1 III",[13,9,3],6, 3,[16,16,80,18]], # 552960.4 [[4,184320,4,1080,2,360,4,1], "A6 3^1 x ( 2^4 x 2^4 ) 2^1 IV",[13,9,4],6, 3,[32,18]], # 552960.5 [[4,184320,5,1080,2,360,5,1], "A6 3^1 x ( 2^4 x 2^4 ) 2^1 V",[13,9,5],6, 3,[1280,18]], # 552960.6 [[4,184320,6,1080,2,360,6,1], "A6 3^1 x ( 2^4 E 2^1 E 2^4 ) A",[13,9,6],3, 3,[480,18]], # 552960.7 [[4,184320,7,1080,2,360,7,1], "A6 3^1 x 2^4 E 2^1 E 2^4'",[13,9,7],3, 3,[240,18]], # 552960.8 [[4,184320,8,1080,2,360,8,1], "A6 3^1 x ( 2^4 E N 2^1 E 2^4 ) A",[13,9,8],3, 3,[480,18]], # 552960.9 [[4,184320,9,1080,2,360,9,1], "A6 3^1 x 2^4 E N 2^1 E 2^4'",[13,9,9],3, 3,[240,18]], # 552960.10 [[4,184320,10,1080,2,360,10,1], "A6 3^1 x ( 2^4 x 2^4' ) 2^1 I",[13,9,10],6, 3,[16,12,18]], # 552960.11 [[4,184320,11,1080,2,360,11,1], "A6 3^1 x ( 2^4 x 2^4' ) 2^1 II",[13,9,11],6, 3,[16,80,18]], # 552960.12 [[4,184320,12,1080,2,360,12,1], "A6 3^1 x ( 2^4 x 2^4' ) 2^1 III",[13,9,12],6, 3,[16,16,80,18]], # 552960.13 [[4,184320,13,1080,2,360,13,1], "A6 3^1 x ( 2^4 x 2^4' ) 2^1 IV",[13,9,13],6, 3,[20,18]], # 552960.14 [[4,184320,14,1080,2,360,14,1], "A6 3^1 x ( 2^4 x 2^4' ) 2^1 V",[13,9,14],6, 3,[80,18]], # 552960.15 [[4,184320,15,1080,2,360,15,1], "A6 3^1 x 2^1 ( 2^4 x 2^4 )",[13,9,15],3, 3,[256,18]], # 552960.16 [[4,184320,16,1080,2,360,16,1], "A6 3^1 x 2^4 x ( 2^1 E 2^4 )",[13,9,16],3, 3,[16,80,18]], # 552960.17 [[4,184320,17,1080,2,360,17,1], "A6 3^1 x 2^4 x ( 2^1 E 2^4' )",[13,9,17],3, 3,[16,80,18]], # 552960.18 [[4,184320,18,1080,2,360,18,1], "A6 3^1 x 2^1 E 2^4 A 2^4",[13,9,18],3, 3,[480,18]], # 552960.19 [[4,184320,19,1080,2,360,19,1], "A6 3^1 x 2^1 E ( 2^4 x 2^4' )",[13,9,19],3, 3,[80,80,18]] ]; PERFGRP[256]:=[# 571704.1 [[1,"abc", function(a,b,c) return [[c^41*a^2,c*b^4*c^-1*b^-1,b^83,a^4,a^2*b^(-1 *1)*a^2*b,a^2*c^-1*a^2*c, c*a*c*a^-1,(b*a)^3],[[b,c^2]]]; end, [168]], "L2(83) 2^1 = SL(2,83)",22,-2, 43,168] ]; PERFGRP[257]:=[# 574560.1 [[2,168,1,3420,1], "L3(2) x L2(19)",40,1, [2,9],[7,20]] ]; PERFGRP[258]:=[# 583200.1 [[2,60,1,9720,1], "( A5 x A5 ) 2^1 # 3^4 [1]",[30,4,1],2, [1,1],[5,24,15]], # 583200.2 [[2,120,1,4860,1], "( A5 x A5 ) 2^1 # 3^4 [2]",[30,4,1],2, [1,1],[24,15]], # 583200.3 [[3,120,1,9720,1,"d1","a2","a2"], "( A5 x A5 ) 2^1 # 3^4 [3]",[30,4,1],2, [1,1],[288,180]], # 583200.4 [[2,60,1,9720,2], "( A5 x A5 ) 2^1 # 3^4 [4]",[30,4,2],2, [1,1],[5,24,60]], # 583200.5 [[2,120,1,4860,2], "( A5 x A5 ) 2^1 # 3^4 [5]",[30,4,2],2, [1,1],[24,60]], # 583200.6 [[3,120,1,9720,2,"d1","a2","a2"], "( A5 x A5 ) 2^1 # 3^4 [6]",[30,4,2],2, [1,1],[288,720]], # 583200.7 [[2,60,1,9720,3], "( A5 x A5 ) 2^1 # 3^4 [7]",[30,4,3],1, [1,1],[5,45]] ]; PERFGRP[259]:=[# 587520.1 [[2,120,1,4896,1], "( A5 x L2(17) ) 2^2",40,4, [1,7],[24,288]] ]; PERFGRP[260]:=[# 589680.1 [[2,60,1,9828,1], "A5 x L2(27)",40,1, [1,16],[5,28]] ]; PERFGRP[261]:=[# 600000.1 [[4,960,1,37500,1,60], "A5 # 2^4 5^4 [1]",6,5, 1,[16,25]], # 600000.2 [[4,960,2,37500,1,60], "A5 # 2^4 5^4 [2]",6,5, 1,[10,25]] ]; PERFGRP[262]:=[# 604800.1 [[1,"ab", function(a,b) return [[a^2,b^5,(a*b)^10,(a^-1*b^(-1*2)*a*b^2)^3,(a*b^2*a *b^-1)^7,a*b^2*a*b^2*a*b^(-1*2) *(a*b^-1*a*b^2*a*b*a*b^2)^2], [[a*b^2*a*b^(-1*2)*a,(b*a*b)^2]]]; end, [100]], "J2",28,-1, 50,100], # 604800.2 [[2,120,1,5040,1], "( A5 x A7 ) 2^2",40,4, [1,8],[24,240]], # 604800.3 [[2,3600,1,168,1], "A5 x A5 x L3(2)",40,1, [1,1,2],[5,5,7]] ]; PERFGRP[263]:=[# 604920.1 [[1,"abyz", function(a,b,y,z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,y^71,z^71,y^-1 *z^-1*y*z,a^-1*y*a*z^-1, a^-1*z*a*y, b^-1*y*b*(y^-1*z^(-1*25))^-1, b^-1*z*b*y^17],[[a*b,a^2,y]]]; end, [852],[0,0,2,2,2,2,2,2]], "A5 2^1 71^2",[5,2,1],1, 1,852] ]; PERFGRP[264]:=[# 607500.1 [[4,4860,1,7500,1,60], "A5 # 3^4 5^3 [1]",6,1, 1,[15,30]], # 607500.2 [[4,4860,2,7500,1,60], "A5 # 3^4 5^3 [2]",6,1, 1,[60,30]], # 607500.3 [[4,4860,1,7500,2,60], "A5 # 3^4 5^3 [3]",6,1, 1,[15,30]], # 607500.4 [[4,4860,2,7500,2,60], "A5 # 3^4 5^3 [4]",6,1, 1,[60,30]] ]; PERFGRP[265]:=[# 612468.1 [[1,"abc", function(a,b,c) return [[c^53,c*b^4*c^-1*b^-1,b^107,a^2,c*a*c*a^-1 ,(b*a)^3],[[b,c]]]; end, [108]], "L2(107)",22,-1, 51,108] ]; PERFGRP[266]:=[# 622080.1 [[4,7680,1,4860,1,60], "A5 # 2^7 3^4 [1]",6,8, 1,[12,64,15]], # 622080.2 [[4,7680,2,4860,1,60], "A5 # 2^7 3^4 [2]",6,8, 1,[24,64,15]], # 622080.3 [[4,7680,3,4860,1,60], "A5 # 2^7 3^4 [3]",6,8, 1,[24,64,15]], # 622080.4 [[4,7680,4,4860,1,60], "A5 # 2^7 3^4 [4]",6,8, 1,[24,64,15]], # 622080.5 [[4,7680,5,4860,1,60], "A5 # 2^7 3^4 [5]",6,8, 1,[24,24,15]], # 622080.6 [[4,7680,1,4860,2,60], "A5 # 2^7 3^4 [6]",6,8, 1,[12,64,60]], # 622080.7 [[4,7680,2,4860,2,60], "A5 # 2^7 3^4 [7]",6,8, 1,[24,64,60]], # 622080.8 [[4,7680,3,4860,2,60], "A5 # 2^7 3^4 [8]",6,8, 1,[24,64,60]], # 622080.9 [[4,7680,4,4860,2,60], "A5 # 2^7 3^4 [9]",6,8, 1,[24,64,60]], # 622080.10 [[4,7680,5,4860,2,60], "A5 # 2^7 3^4 [10]",6,8, 1,[24,24,60]], # 622080.11 [[4,7680,4,9720,4,120,4,3], "A5 # 2^7 3^4 [11]",6,4, 1,[24,64,45]], # 622080.12 [[4,7680,5,9720,4,120,5,3], "A5 # 2^7 3^4 [12]",6,4, 1,[24,24,45]] ]; PERFGRP[267]:=[# 626688.1 [[1,"abcstuvwxyz", function(a,b,c,s,t,u,v,w,x,y,z) return [[a^2,b^17,c^8,(a*b)^3,(a*c)^2,c^-1*b*c*b^(-1*9), b^5*a*b^-1*a*b^2*a*b^6*a*c^-1,s^2,t^2, u^2,v^2,w^2,x^2,y^2,z^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, s^-1*w^-1*s*w,s^-1*x^-1*s*x, s^-1*y^-1*s*y,s^-1*z^-1*s*z, t^-1*u^-1*t*u,t^-1*v^-1*t*v, t^-1*w^-1*t*w,t^-1*x^-1*t*x, t^-1*y^-1*t*y,t^-1*z^-1*t*z, u^-1*v^-1*u*v,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*s*a*t^-1, a^-1*t*a*s^-1, a^-1*u*a*(s*u*v*w*x)^-1, a^-1*v*a*(s*t*v*x*z)^-1, a^-1*w*a*(s*t*u*w*y*z)^-1, a^-1*x*a*(s*t*u*y)^-1, a^-1*y*a*(t*u*v*w)^-1, a^-1*z*a*(s*t*u*x*y*z)^-1, b^-1*s*b*t^-1,b^-1*t*b*(s*v)^-1, b^-1*u*b*(w*x)^-1,b^-1*v*b*(u*z)^-1, b^-1*w*b*x^-1,b^-1*x*b*(y*z)^-1, b^-1*y*b*(t*u*v*y*z)^-1, b^-1*z*b*(t*u*v*y)^-1, c^-1*s*c*(s*u)^-1, c^-1*t*c*(t*u*w)^-1, c^-1*u*c*(s*t*w*x*y)^-1, c^-1*v*c*(s*t*u*w*x)^-1, c^-1*w*c*(w*y*z)^-1, c^-1*x*c*(s*u*z)^-1, c^-1*y*c*(u*v*w*y*z)^-1, c^-1*z*c*(u*v*w*x*y)^-1],[[a,b,c]]]; end, [256]], "L2(17) 2^8",[21,8,1],1, 7,256] ]; PERFGRP[268]:=[# 633600.1 [[2,960,1,660,1], "( A5 x L2(11) ) # 2^4 [1]",[36,4,1],1, [1,5],[16,11]], # 633600.2 [[2,960,2,660,1], "( A5 x L2(11) ) # 2^4 [2]",[36,4,2],1, [1,5],[10,11]] ]; PERFGRP[269]:=[# 645120.1 [[1,"abduvwxyze", function(a,b,d,u,v,w,x,y,z,e) return [[a^2*d^-1,b^4*d^-1,(a*b)^7,(a*b)^2*a*b^2*( a*b*a*b^-1)^2*(a*b)^2 *(a*b^-1)^2*a*b*a*b^-1,d^2,e^2, e^-1*d^-1*e*d,a^-1*d*a*d^-1, b^-1*d*b*d^-1,u^-1*e*u*e^-1, u^-1*d*u*d^-1,v^-1*e*v*e^-1, v^-1*d*v*d^-1,w^-1*e*w*e^-1, w^-1*d*w*d^-1,x^-1*e*x*e^-1, x^-1*d*x*d^-1,y^-1*e*y*e^-1, y^-1*d*y*d^-1,z^-1*e*z*e^-1, z^-1*d*z*d^-1,u^2*e^-1,v^2*e^-1, w^2*e^-1,x^2*e^-1,y^2*e^-1, z^2*e^-1,u^-1*v^-1*u*v*e^-1, u^-1*w^-1*u*w*e^-1, u^-1*x^-1*u*x*e^-1, u^-1*y^-1*u*y*e^-1, u^-1*z^-1*u*z*e^-1, v^-1*w^-1*v*w*e^-1, v^-1*x^-1*v*x*e^-1, v^-1*y^-1*v*y*e^-1, v^-1*z^-1*v*z*e^-1, w^-1*x^-1*w*x*e^-1, w^-1*y^-1*w*y*e^-1, w^-1*z^-1*w*z*e^-1, x^-1*y^-1*x*y*e^-1, x^-1*z^-1*x*z*e^-1, y^-1*z^-1*y*z*e^-1, a^-1*u*a*u^-1,a^-1*v*a*v^-1, a^-1*w*a*(y*e)^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*e)^-1, a^-1*z*a*(u*v*w*x*y*z*e)^-1, a^-1*e*a*e^-1,b^-1*u*b*w^-1, b^-1*v*b*z^-1,b^-1*w*b*v^-1, b^-1*x*b*(y*e)^-1,b^-1*y*b*(x*e)^-1, b^-1*z*b*u^-1,b^-1*e*b*e^-1], [[a,b], [a*b,b*a*b*a*b^2*a*b^-1*a*b*a*b^-1*a*b *a*b^2*d,u]]]; end, [128,240]], "A7 2^1 x ( 2^6 C 2^1 )",[23,8,1],4, 8,[128,240]], # 645120.2 [[1,"abwxyzWXYZ", function(a,b,w,x,y,z,W,X,Y,Z) return [[a^2,b^4,(a*b)^7,(a*b)^2*a*b^2*(a*b*a*b^-1)^2 *(a*b)^2*(a*b^-1)^2*a*b*a*b^-1,w^2, x^2,y^2,z^2,W^2,X^2,Y^2,Z^2,w*x*w*x,w*y*w*y, w*z*w*z,x*y*x*y,x*z*x*z,y*z*y*z,w*W*w*W, w*X*w*X,w*Y*w*Y,w*Z*w*Z,W*X*W*X,W*Y*W*Y, W*Z*W*Z,X*Y*X*Y,X*Z*X*Z,Y*Z*Y*Z, a^-1*w*a*y^-1,a^-1*x*a*z^-1, a^-1*y*a*w^-1,a^-1*z*a*x^-1, b^-1*w*b*(w*x*y*z)^-1,b^-1*x*b*y^-1 ,b^-1*y*b*(w*x)^-1, b^-1*z*b*(w*z)^-1,a^-1*W*a*Y^-1, a^-1*X*a*Z^-1,a^-1*Y*a*W^-1, a^-1*Z*a*X^-1,b^-1*W*b*(W*X*Y*Z)^-1 ,b^-1*X*b*Y^-1,b^-1*Y*b*(W*X)^-1, b^-1*Z*b*(W*Z)^-1],[[a,b,w],[a,b,W]]]; end, [16,16]], "A7 2^4 x 2^4",[23,8,2],1, 8,[16,16]], # 645120.3 [[1,"abwxyzWXYZ", function(a,b,w,x,y,z,W,X,Y,Z) return [[a^2,b^4,(a*b)^7,(a*b)^2*a*b^2*(a*b*a*b^-1)^2 *(a*b)^2*(a*b^-1)^2*a*b*a*b^-1,w^2, x^2,y^2,z^2,W^2,X^2,Y^2,Z^2,w*x*w*x,w*y*w*y, w*z*w*z,x*y*x*y,x*z*x*z,y*z*y*z,w*W*w*W, w*X*w*X,w*Y*w*Y,w*Z*w*Z,W*X*W*X,W*Y*W*Y, W*Z*W*Z,X*Y*X*Y,X*Z*X*Z,Y*Z*Y*Z, a^-1*w*a*y^-1,a^-1*x*a*z^-1, a^-1*y*a*w^-1,a^-1*z*a*x^-1, b^-1*w*b*(w*x*y*z)^-1,b^-1*x*b*y^-1 ,b^-1*y*b*(w*x)^-1, b^-1*z*b*(w*z)^-1,a^-1*W*a*Y^-1, a^-1*X*a*Z^-1,a^-1*Y*a*W^-1, a^-1*Z*a*X^-1,b^-1*W*b*(W*X*Y*Z)^-1 ,b^-1*X*b*(W*X*Z)^-1,b^-1*Y*b*X^-1 ,b^-1*Z*b*(W*X*Y)^-1],[[a,b,w],[a,b,W]]]; end, [16,16]], "A7 2^4 x 2^4'",[23,8,3],1, 8,[16,16]], # 645120.4 [[1,"abdwxyz", function(a,b,d,w,x,y,z) return [[a^2*d,b^4,(a*b)^15,(a*b^2)^6,(a*b)^2*(a*b^-1*a *b^2)^2*a*b^-1*(a*b)^2*(a*b^-1)^7, a*b*a*b^-1*a*b*a*b^2*(a*b^-1)^5*a*b^2 *(a*b^-1)^5*a*b^2,d^2,d^-1*a^-1*d*a ,d^-1*b^-1*d*b,d^-1*w^-1*d*w, d^-1*x^-1*d*x,d^-1*y^-1*d*y, d^-1*z^-1*d*z,w^2,x^2,y^2,z^2, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*y^-1,a^-1*x*a*z^-1, a^-1*y*a*w^-1,a^-1*z*a*x^-1, b^-1*w*b*(w*x)^-1,b^-1*x*b*(w*z)^-1, b^-1*y*b*(w*x*y*z)^-1, b^-1*z*b*w^-1],[[a,b],[b,a*b^2*a,w]]]; end, [16,240],[[1,2],[8,8,8]]], "A8 ( 2^1 x 2^4 )",[26,5,1],2, 19,[16,240]], # 645120.5 [[1,"abdwxyz", function(a,b,d,w,x,y,z) return [[a^2*(d*x*z)^-1,b^4*(w*x*z)^-1,(a*b)^15,(a*b^2) ^6, (a*b)^2*(a*b^-1*a*b^2)^2*a*b^-1*(a*b)^2 *(a*b^-1)^7*(y*z)^-1, a*b*a*b^-1*a*b*a*b^2*(a*b^-1)^5*a*b^2 *(a*b^-1)^5*a*b^2*y^-1,d^2, d^-1*a^-1*d*a,d^-1*b^-1*d*b, d^-1*w^-1*d*w,d^-1*x^-1*d*x, d^-1*y^-1*d*y,d^-1*z^-1*d*z,w^2, x^2,y^2,z^2,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*w*a*y^-1, a^-1*x*a*z^-1,a^-1*y*a*w^-1, a^-1*z*a*x^-1,b^-1*w*b*(w*x)^-1, b^-1*x*b*(w*z)^-1, b^-1*y*b*(w*x*y*z)^-1, b^-1*z*b*w^-1], [[b*z,(a*b)^2*(a*b^-1)^2*a*z,y*z],[b,a*b*b*a,w] ]]; end, [30,240],[[1,2],[8,8,8]]], "A8 ( 2^1 x N 2^4 )",[26,5,2],2, 19,[30,240]], # 645120.6 [[2,60,1,10752,1], "( A5 x L3(2) ) # 2^6 [1]",[31,6,1],1, [1,2],[5,8,8]], # 645120.7 [[2,60,1,10752,2], "( A5 x L3(2) ) # 2^6 [2]",[31,6,2],1, [1,2],[5,8,14]], # 645120.8 [[2,60,1,10752,3], "( A5 x L3(2) ) # 2^6 [3]",[31,6,3],1, [1,2],[5,28]], # 645120.9 [[2,60,1,10752,4], "( A5 x L3(2) ) # 2^6 [4]",[31,6,4],1, [1,2],[5,112]], # 645120.10 [[2,60,1,10752,5], "( A5 x L3(2) ) # 2^6 [5]",[31,6,5],1, [1,2],[5,8,8]], # 645120.11 [[2,60,1,10752,6], "( A5 x L3(2) ) # 2^6 [6]",[31,6,6],1, [1,2],[5,8,14]], # 645120.12 [[2,60,1,10752,7], "( A5 x L3(2) ) # 2^6 [7]",[31,6,7],1, [1,2],[5,14,14]], # 645120.13 [[2,60,1,10752,8], "( A5 x L3(2) ) # 2^6 [8]",[31,6,8],1, [1,2],[5,56]], # 645120.14 [[2,60,1,10752,9], "( A5 x L3(2) ) # 2^6 [9]",[31,6,9],1, [1,2],[5,64]], # 645120.15 [[2,120,1,5376,1], "( A5 x L3(2) ) # 2^6 [10]",[31,6,10],8, [1,2],[24,16,16]], # 645120.16 [[2,3840,1,168,1], "( A5 x L3(2) ) # 2^6 [11]",[31,6,11],4, [1,2],[64,7]], # 645120.17 [[2,3840,2,168,1], "( A5 x L3(2) ) # 2^6 [12]",[31,6,12],4, [1,2],[64,7]], # 645120.18 [[2,3840,3,168,1], "( A5 x L3(2) ) # 2^6 [13]",[31,6,13],4, [1,2],[24,7]], # 645120.19 [[2,3840,4,168,1], "( A5 x L3(2) ) # 2^6 [14]",[31,6,14],4, [1,2],[48,7]], # 645120.20 [[2,3840,5,168,1], "( A5 x L3(2) ) # 2^6 [15]",[31,6,15],4, [1,2],[24,12,7]], # 645120.21 [[2,3840,6,168,1], "( A5 x L3(2) ) # 2^6 [16]",[31,6,16],2, [1,2],[48,7]], # 645120.22 [[2,3840,7,168,1], "( A5 x L3(2) ) # 2^6 [17]",[31,6,17],4, [1,2],[32,24,7]], # 645120.23 [[2,1920,1,336,1], "( A5 x L3(2) ) # 2^6 [18]",[31,6,18],4, [1,2],[12,16]], # 645120.24 [[2,1920,2,336,1], "( A5 x L3(2) ) # 2^6 [19]",[31,6,19],4, [1,2],[24,16]], # 645120.25 [[2,1920,3,336,1], "( A5 x L3(2) ) # 2^6 [20]",[31,6,20],4, [1,2],[16,24,16]], # 645120.26 [[2,1920,4,336,1], "( A5 x L3(2) ) # 2^6 [21]",[31,6,21],2, [1,2],[80,16]], # 645120.27 [[2,1920,5,336,1], "( A5 x L3(2) ) # 2^6 [22]",[31,6,22],4, [1,2],[10,24,16]], # 645120.28 [[2,1920,6,336,1], "( A5 x L3(2) ) # 2^6 [23]",[31,6,23],4, [1,2],[80,16]], # 645120.29 [[2,1920,7,336,1], "( A5 x L3(2) ) # 2^6 [24]",[31,6,24],4, [1,2],[32,16]], # 645120.30 [[3,3840,1,336,1,"e1","e1","d2"], "( A5 x L3(2) ) # 2^6 [25]",[31,6,25],4, [1,2],512], # 645120.31 [[3,3840,2,336,1,"e1","e1","d2"], "( A5 x L3(2) ) # 2^6 [26]",[31,6,26],4, [1,2],512], # 645120.32 [[3,3840,3,336,1,"e1","d2"], "( A5 x L3(2) ) # 2^6 [27]",[31,6,27],4, [1,2],192], # 645120.33 [[3,3840,4,336,1,"e1","d2"], "( A5 x L3(2) ) # 2^6 [28]",[31,6,28],4, [1,2],384], # 645120.34 [[3,3840,4,336,1,"d1","d2"], "( A5 x L3(2) ) # 2^6 [29]",[31,6,29],4, [1,2],384], # 645120.35 [[3,3840,5,336,1,"d1","d2"], "( A5 x L3(2) ) # 2^6 [30]",[31,6,30],4, [1,2],[192,96]], # 645120.36 [[3,3840,5,336,1,"e1","d2"], "( A5 x L3(2) ) # 2^6 [31]",[31,6,31],4, [1,2],[192,96]], # 645120.37 [[3,3840,5,336,1,"d1","e1","d2"], "( A5 x L3(2) ) # 2^6 [32]",[31,6,32],4, [1,2],[192,96]], # 645120.38 [[3,3840,6,336,1,"e1","d2"], "( A5 x L3(2) ) # 2^6 [33]",[31,6,33],2, [1,2],384], # 645120.39 [[3,3840,7,336,1,"d1","d2"], "( A5 x L3(2) ) # 2^6 [34]",[31,6,34],4, [1,2],[256,192]], # 645120.40 [[3,3840,7,336,1,"e1","d2"], "( A5 x L3(2) ) # 2^6 [35]",[31,6,35],4, [1,2],[256,192]], # 645120.41 [[3,3840,7,336,1,"d1","e1","d2"], "( A5 x L3(2) ) # 2^6 [36]",[31,6,36],4, [1,2],[256,192]] ]; PERFGRP[270]:=[# 647460.1 [[1,"abc", function(a,b,c) return [[c^54,c*b^12*c^-1*b^-1,b^109,a^2,c*a*c*a^(-1 *1),(b*a)^3, c^(-1*14)*b*c*b^2*c^2*b*a*b^2*a*c^3*b*c*b*a], [[b,c]]]; end, [110],[0,2,2]], "L2(109)",22,-1, 52,110] ]; PERFGRP[271]:=[# 665280.1 [[2,504,1,1320,1], "L2(8) x L2(11) 2^1",40,2, [4,5],[9,24]] ]; PERFGRP[272]:=[# 673920.1 [[2,120,1,5616,1], "A5 2^1 x L3(3)",40,2, [1,11],[24,13]] ]; PERFGRP[273]:=[# 675840.1 [[1,"abqrstuvwxyz", function(a,b,q,r,s,t,u,v,w,x,y,z) return [[a^2,b^3,(a*b)^11,(a*b)^4*(a*b^-1)^5*(a*b)^4*(a *b^-1)^5,q^2,r^2,s^2,t^2,u^2,v^2,w^2,x^2, y^2,z^2,q^-1*r^-1*q*r,q^-1*s^-1*q*s ,q^-1*t^-1*q*t,q^-1*u^-1*q*u, q^-1*v^-1*q*v,q^-1*w^-1*q*w, q^-1*x^-1*q*x,q^-1*y^-1*q*y, q^-1*z^-1*q*z,r^-1*s^-1*r*s, r^-1*t^-1*r*t,r^-1*u^-1*r*u, r^-1*v^-1*r*v,r^-1*w^-1*r*w, r^-1*x^-1*r*x,r^-1*y^-1*r*y, r^-1*z^-1*r*z,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, s^-1*w^-1*s*w,s^-1*x^-1*s*x, s^-1*y^-1*s*y,s^-1*z^-1*s*z, t^-1*u^-1*t*u,t^-1*v^-1*t*v, t^-1*w^-1*t*w,t^-1*x^-1*t*x, t^-1*y^-1*t*y,t^-1*z^-1*t*z, u^-1*v^-1*u*v,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*q*a*y^-1, a^-1*r*a*v^-1,a^-1*s*a*s^-1, a^-1*t*a*u^-1,a^-1*u*a*t^-1, a^-1*v*a*r^-1,a^-1*w*a*x^-1, a^-1*x*a*w^-1,a^-1*y*a*q^-1, a^-1*z*a*z^-1,b^-1*q*b*x^-1, b^-1*r*b*u^-1,b^-1*s*b*r^-1, b^-1*t*b*t^-1,b^-1*u*b*s^-1, b^-1*v*b*q^-1,b^-1*w*b*w^-1, b^-1*x*b*v^-1, b^-1*y*b*(q*r*s*t*u*v*w*x*y*z)^-1, b^-1*z*b*y^-1],[[b,a*b*a*b^-1*a,y*z]] ]; end, [22]], "L2(11) 2^10",[17,10,1],1, 5,22], # 675840.2 [[1,"abqrstuvwxyz", function(a,b,q,r,s,t,u,v,w,x,y,z) return [[a^2,b^3,(a*b)^11,(a*b)^4*(a*b^-1)^5*(a*b)^4*(a *b^-1)^5,q^2,r^2,s^2,t^2,u^2,v^2,w^2,x^2, y^2,z^2,q^-1*r^-1*q*r,q^-1*s^-1*q*s ,q^-1*t^-1*q*t,q^-1*u^-1*q*u, q^-1*v^-1*q*v,q^-1*w^-1*q*w, q^-1*x^-1*q*x,q^-1*y^-1*q*y, q^-1*z^-1*q*z,r^-1*s^-1*r*s, r^-1*t^-1*r*t,r^-1*u^-1*r*u, r^-1*v^-1*r*v,r^-1*w^-1*r*w, r^-1*x^-1*r*x,r^-1*y^-1*r*y, r^-1*z^-1*r*z,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, s^-1*w^-1*s*w,s^-1*x^-1*s*x, s^-1*y^-1*s*y,s^-1*z^-1*s*z, t^-1*u^-1*t*u,t^-1*v^-1*t*v, t^-1*w^-1*t*w,t^-1*x^-1*t*x, t^-1*y^-1*t*y,t^-1*z^-1*t*z, u^-1*v^-1*u*v,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*q*a*q^-1, a^-1*r*a*r^-1,a^-1*s*a*(s*u*w*z)^-1 ,a^-1*t*a*(t*v*x*y*z)^-1, a^-1*u*a*(t*u*x*y)^-1, a^-1*v*a*(s*t*v*w*x*z)^-1, a^-1*w*a*(s*v*x)^-1, a^-1*x*a*(t*u*v*w*x)^-1, a^-1*y*a*(t*u*w*x*z)^-1, a^-1*z*a*(s*t*v*w*y*z)^-1, b^-1*q*b*(s*t*u*v*w*x*y)^-1, b^-1*r*b*(s*u*w*z)^-1, b^-1*s*b*(q*r*s*t*u*y*z)^-1, b^-1*t*b*(q*s*v*y)^-1, b^-1*u*b*(r*z)^-1, b^-1*v*b*(q*r*y*z)^-1, b^-1*w*b*(q*r*u*v*x*y*z)^-1, b^-1*x*b*(q*u*w*x*y)^-1, b^-1*y*b*(s*v*x)^-1, b^-1*z*b*(t*u*v*w*x)^-1], [[a,b^-1*a*b*a*b^-1*a*b,x]]]; end, [132],[[1,-2]]], "L2(11) 2^10'",[17,10,2],1, 5,132], # 675840.3 [[1,"abqrstuvwxyz", function(a,b,q,r,s,t,u,v,w,x,y,z) return [[a^2*q^-1,b^3,(a*b)^11,(a*b)^4*(a*b^-1)^5*(a*b) ^4*(a*b^-1)^5*(q*r*s*t*x*z)^-1,q^2, r^2,s^2,t^2,u^2,v^2,w^2,x^2,y^2,z^2, q^-1*r^-1*q*r,q^-1*s^-1*q*s, q^-1*t^-1*q*t,q^-1*u^-1*q*u, q^-1*v^-1*q*v,q^-1*w^-1*q*w, q^-1*x^-1*q*x,q^-1*y^-1*q*y, q^-1*z^-1*q*z,r^-1*s^-1*r*s, r^-1*t^-1*r*t,r^-1*u^-1*r*u, r^-1*v^-1*r*v,r^-1*w^-1*r*w, r^-1*x^-1*r*x,r^-1*y^-1*r*y, r^-1*z^-1*r*z,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, s^-1*w^-1*s*w,s^-1*x^-1*s*x, s^-1*y^-1*s*y,s^-1*z^-1*s*z, t^-1*u^-1*t*u,t^-1*v^-1*t*v, t^-1*w^-1*t*w,t^-1*x^-1*t*x, t^-1*y^-1*t*y,t^-1*z^-1*t*z, u^-1*v^-1*u*v,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*q*a*q^-1, a^-1*r*a*r^-1,a^-1*s*a*(s*u*w*z)^-1 ,a^-1*t*a*(t*v*x*y*z)^-1, a^-1*u*a*(t*u*x*y)^-1, a^-1*v*a*(s*t*v*w*x*z)^-1, a^-1*w*a*(s*v*x)^-1, a^-1*x*a*(t*u*v*w*x)^-1, a^-1*y*a*(t*u*w*x*z)^-1, a^-1*z*a*(s*t*v*w*y*z)^-1, b^-1*q*b*(s*t*u*v*w*x*y)^-1, b^-1*r*b*(s*u*w*z)^-1, b^-1*s*b*(q*r*s*t*u*y*z)^-1, b^-1*t*b*(q*s*v*y)^-1, b^-1*u*b*(r*z)^-1, b^-1*v*b*(q*r*y*z)^-1, b^-1*w*b*(q*r*u*v*x*y*z)^-1, b^-1*x*b*(q*u*w*x*y)^-1, b^-1*y*b*(s*v*x)^-1, b^-1*z*b*(t*u*v*w*x)^-1], [[a,b^-1*a*b*a*b^-1*a*b]]]; end, [132],[[1,-2],[1,2]]], "L2(11) N 2^10'",[17,10,3],1, 5,132] ]; PERFGRP[274]:=[# 677376.1 [[2,1344,1,504,1], "( L3(2) x L2(8) ) # 2^3 [1]",[38,3,1],1, [2,4],[8,9]], # 677376.2 [[2,1344,2,504,1], "( L3(2) x L2(8) ) # 2^3 [2]",[38,3,2],1, [2,4],[14,9]] ]; PERFGRP[275]:=[# 685440.1 [[2,168,1,4080,1], "L3(2) x L2(16)",40,1, [2,10],[7,17]] ]; PERFGRP[276]:=fail; PERFGRP[277]:=[# 691200.1 [[2,60,1,11520,1], "( A5 x A6 ) # 2^5 [1]",[33,5,1],2, [1,3],[5,12]], # 691200.2 [[2,60,1,11520,2], "( A5 x A6 ) # 2^5 [2]",[33,5,2],2, [1,3],[5,80]], # 691200.3 [[2,60,1,11520,3], "( A5 x A6 ) # 2^5 [3]",[33,5,3],2, [1,3],[5,16,80]], # 691200.4 [[2,60,1,11520,4], "( A5 x A6 ) # 2^5 [4]",[33,5,4],1, [1,3],[5,80]], # 691200.5 [[2,120,1,5760,1], "( A5 x A6 ) # 2^5 [5]",[33,5,5],2, [1,3],[24,16]], # 691200.6 [[3,120,1,11520,1,"d1","e2"], "( A5 x A6 ) # 2^5 [6]",[33,5,6],2, [1,3],144], # 691200.7 [[3,120,1,11520,2,"d1","e2"], "( A5 x A6 ) # 2^5 [7]",[33,5,7],2, [1,3],960], # 691200.8 [[3,120,1,11520,3,"d1","d2"], "( A5 x A6 ) # 2^5 [8]",[33,5,8],2, [1,3],[192,960]], # 691200.9 [[2,1920,1,360,1], "( A5 x A6 ) # 2^5 [9]",[33,5,9],2, [1,3],[12,6]], # 691200.10 [[2,1920,2,360,1], "( A5 x A6 ) # 2^5 [10]",[33,5,10],2, [1,3],[24,6]], # 691200.11 [[2,1920,3,360,1], "( A5 x A6 ) # 2^5 [11]",[33,5,11],2, [1,3],[16,24,6]], # 691200.12 [[2,1920,4,360,1], "( A5 x A6 ) # 2^5 [12]",[33,5,12],1, [1,3],[80,6]], # 691200.13 [[2,1920,5,360,1], "( A5 x A6 ) # 2^5 [13]",[33,5,13],2, [1,3],[10,24,6]], # 691200.14 [[2,1920,6,360,1], "( A5 x A6 ) # 2^5 [14]",[33,5,14],2, [1,3],[80,6]], # 691200.15 [[2,1920,7,360,1], "( A5 x A6 ) # 2^5 [15]",[33,5,15],2, [1,3],[32,6]], # 691200.16 [[2,960,1,720,1], "( A5 x A6 ) # 2^5 [16]",[33,5,16],2, [1,3],[16,80]], # 691200.17 [[2,960,2,720,1], "( A5 x A6 ) # 2^5 [17]",[33,5,17],2, [1,3],[10,80]], # 691200.18 [[3,1920,1,720,1,"e1","d2"], "( A5 x A6 ) # 2^5 [18]",[33,5,18],2, [1,3],480], # 691200.19 [[3,1920,2,720,1,"d1","d2"], "( A5 x A6 ) # 2^5 [19]",[33,5,19],2, [1,3],960], # 691200.20 [[3,1920,3,720,1,"d1","d2"], "( A5 x A6 ) # 2^5 [20]",[33,5,20],2, [1,3],[640,960]], # 691200.21 [[3,1920,5,720,1,"d1","d2"], "( A5 x A6 ) # 2^5 [21]",[33,5,21],2, [1,3],[400,960]], # 691200.22 [[3,1920,6,720,1,"d1","d2"], "( A5 x A6 ) # 2^5 [22]",[33,5,22],2, [1,3],3200], # 691200.23 [[3,1920,7,720,1,"e1","d2"], "( A5 x A6 ) # 2^5 [23]",[33,5,23],2, [1,3],1280] ]; PERFGRP[278]:=[# 693120.1 [[4,1920,3,43320,2,120,3,1], "A5 # 2^5 19^2 [1]",6,1, 1,[16,24,361]], # 693120.2 [[4,1920,4,43320,2,120,4,1], "A5 # 2^5 19^2 [2]",6,1, 1,[80,361]], # 693120.3 [[4,1920,5,43320,2,120,5,1], "A5 # 2^5 19^2 [3]",6,1, 1,[10,24,361]] ]; PERFGRP[279]:=[# 699840.1 [[4,960,1,43740,1,60], "A5 # 2^4 3^6 [1]",6,1, 1,[16,18]], # 699840.2 [[4,960,2,43740,1,60], "A5 # 2^4 3^6 [2]",6,1, 1,[10,18]] ]; PERFGRP[280]:=[# 704880.1 [[1,"abc", function(a,b,c) return [[c^44*a^2,c*b^9*c^-1*b^-1,b^89,a^4,a^2*b^(-1 *1)*a^2*b,a^2*c^-1*a^2*c, c*a*c*a^-1,(b*a)^3, c^-1*b^3*c*b^3*a*b^3*a*c*b^3*a],[[b,c^8]]] ; end, [720],[0,3,3]], "L2(89) 2^1 = SL(2,89)",22,-2, 44,720] ]; PERFGRP[281]:=[# 712800.1 [[2,1080,1,660,1], "A6 3^1 x L2(11)",40,3, [3,5],[18,11]] ]; PERFGRP[282]:=[# 720720.1 [[2,660,1,1092,1], "L2(11) x L2(13)",40,1, [5,6],[11,14]] ]; PERFGRP[283]:=[# 721392.1 [[1,"abc", function(a,b,c) return [[c^56,c*b^9*c^-1*b^-1,b^113,a^2,c*a*c*a^-1 ,(b*a)^3,c^(-1*3)*b^2*c*b^2*c^2*a*b^3*a*c*b^3 *a],[[b,c]]]; end, [114],[0,3,3]], "L2(113)",22,-1, 53,114] ]; PERFGRP[284]:=[# 725760.1 [[2,336,1,2160,1], "( L3(2) x A6 3^1 ) 2^2",[37,2,1],12, [2,3],[16,18,80]], # 725760.2 [[2,120,1,6048,1], "A5 2^1 x U3(3)",40,2, [1,12],[24,28]] ]; PERFGRP[285]:=[# 728640.1 [[2,60,1,12144,1], "( A5 x L2(23) ) 2^1 [1]",40,2, [1,13],[5,48]], # 728640.2 [[2,120,1,6072,1], "( A5 x L2(23) ) 2^1 [2]",40,2, [1,13],[24,24]], # 728640.3 [[3,120,1,12144,1,"d1","a2","a2"], "( A5 x L2(23) ) 2^1 [3]",40,2, [1,13],576] ]; PERFGRP[286]:=[# 729000.1 [[4,29160,5,3000,2,120,2,1], "A5 2^1 # 3^5 5^2 [1]",6,3, 1,[243,25]], # 729000.2 [[4,29160,6,3000,2,120,3,1], "A5 2^1 # 3^5 5^2 [2]",6,3, 1,[243,25]] ]; PERFGRP[287]:=[# 730800.1 [[2,60,1,12180,1], "A5 x L2(29)",40,1, [1,17],[5,30]] ]; PERFGRP[288]:=[# 733824.1 [[2,336,1,2184,1], "( L3(2) x L2(13) ) 2^2",40,4, [2,6],[16,56]] ]; PERFGRP[289]:=[# 734832.1 [[1,"abuvwxyzd", function(a,b,u,v,w,x,y,z,d) return [[a^4,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4*a^2,a^2*b *a^2*b^-1,d^3,a^-1*d*a*d^-1, b^-1*d*b*d^-1,u^-1*d*u*d^-1, v^-1*d*v*d^-1,w^-1*d*w*d^-1, x^-1*d*x*d^-1,y^-1*d*y*d^-1, z^-1*d*z*d^-1,u^3,v^3,w^3,x^3,y^3,z^3, u^-1*v^-1*u*v*d,u^-1*w^-1*u*w *d^-1,u^-1*x^-1*u*x*d^-1, u^-1*y^-1*u*y*d^-1,u^-1*z^-1*u *z,v^-1*w^-1*v*w*d^-1, v^-1*x^-1*v*x*d,v^-1*y^-1*v*y*d, v^-1*z^-1*v*z*d,w^-1*x^-1*w*x, w^-1*y^-1*w*y*d^-1, w^-1*z^-1*w*z*d^-1, x^-1*y^-1*x*y*d^-1, x^-1*z^-1*x*z*d,y^-1*z^-1*y*z*d, a^-1*u*a*(x*y^-1*z^-1*d)^-1, a^-1*v*a*(w*x^-1*y^-1*d)^-1, a^-1*w*a*(u*w^-1*x*y^-1*z^-1)^-1 ,a^-1*x*a*(v*w*x*y^-1)^-1, a^-1*y*a*(u*v*w*z^-1*d)^-1, a^-1*z*a*(u*x*y^-1*z*d^-1)^-1, b^-1*u*b*(v*w^-1*x^-1)^-1, b^-1*v*b*(u*v^-1*w^-1*d^-1)^-1, b^-1*w*b*(u^-1*v*w^-1*x^-1*z^-1) ^-1,b^-1*x*b*(u*v*w^-1*y^-1*z*d) ^-1,b^-1*y*b*(u*x^-1*y*d)^-1, b^-1*z*b*(v*w^-1*x*z)^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,u], [a,b]]]; end, [16,2187]], "L3(2) 2^1 x 3^6 C 3^1",[9,7,1],6, 2,[16,2187]], # 734832.2 [[1,"abtuvwxyz", function(a,b,t,u,v,w,x,y,z) return [[a^4,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4*a^2,a^2*b *a^2*b^-1,t^3,u^3,v^3,w^3,x^3,y^3,z^3, t^-1*u^-1*t*u,t^-1*v^-1*t*v, t^-1*w^-1*t*w,t^-1*x^-1*t*x, t^-1*y^-1*t*y,t^-1*z^-1*t*z, u^-1*v^-1*u*v,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*t*a*t^-1, a^-1*u*a*w^-1,a^-1*v*a*v, a^-1*w*a*u^-1,a^-1*x*a*z^-1, a^-1*y*a*y,a^-1*z*a*x^-1, b^-1*t*b*u^-1,b^-1*u*b*v^-1, b^-1*v*b*t^-1,b^-1*w*b*x^-1, b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,t], [a*b,a^2,t*u^-1]]]; end, [16,72]], "L3(2) 2^1 x 3^7",[9,7,2],2, 2,[16,72]], # 734832.3 [[1,"abtuvwxyz", function(a,b,t,u,v,w,x,y,z) return [[a^4,b^3/(t*u*v*z^-1),(a*b)^7,(a^-1*b^-1*a*b)^4*a^2,a^2*b *a^2*b^-1,t^3,u^3,v^3,w^3,x^3,y^3,z^3, t^-1*u^-1*t*u,t^-1*v^-1*t*v, t^-1*w^-1*t*w,t^-1*x^-1*t*x, t^-1*y^-1*t*y,t^-1*z^-1*t*z, u^-1*v^-1*u*v,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*t*a*t^-1, a^-1*u*a*w^-1,a^-1*v*a*v, a^-1*w*a*u^-1,a^-1*x*a*z^-1, a^-1*y*a*y,a^-1*z*a*x^-1, b^-1*t*b*u^-1,b^-1*u*b*v^-1, b^-1*v*b*t^-1,b^-1*w*b*x^-1, b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,t], [a*b,a^2,t*u^-1]]]; end, [16,72]], "L3(2) 2^1 x N 3^7",[9,7,3],2, 2,[16,72]] ]; PERFGRP[290]:=[fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail]; PERFGRP[291]:=[# 748920.1 [[1,"abyz", function(a,b,y,z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,y^79,z^79,y^-1 *z^-1*y*z,a^-1*y*a*z^-1, a^-1*z*a*y,b^-1*y*b*(y^(-1*21)*z^4)^-1, b^-1*z*b*(y^33*z^20)^-1], [[b,a^2,y*z^(-1*36)]]]; end, [1580],[0,0,3,3,3,3]], "A5 2^1 79^2",[5,2,1],1, 1,1580] ]; PERFGRP[292]:=[# 768000.1 [[4,30720,1,3000,2,120,1,1], "A5 # 2^9 5^2 [1]",6,16, 1,[24,64,64,25]], # 768000.2 [[4,30720,4,3000,2,120,4,1], "A5 # 2^9 5^2 [2]",6,1, 1,[240,25]], # 768000.3 [[4,30720,9,3000,2,120,9,1], "A5 # 2^9 5^2 [3]",6,1, 1,[16,16,24,25]], # 768000.4 [[4,30720,10,3000,2,120,10,1], "A5 # 2^9 5^2 [4]",6,1, 1,[16,80,25]], # 768000.5 [[4,30720,11,3000,2,120,11,1], "A5 # 2^9 5^2 [5]",6,1, 1,[240,25]], # 768000.6 [[4,30720,14,3000,2,120,14,1], "A5 # 2^9 5^2 [6]",6,1, 1,[40,24,25]], # 768000.7 [[4,30720,18,3000,2,120,18,1], "A5 # 2^9 5^2 [7]",6,1, 1,[10,16,24,25]], # 768000.8 [[4,30720,22,3000,2,120,22,1], "A5 # 2^9 5^2 [8]",6,1, 1,[160,25]], # 768000.9 [[4,30720,23,3000,2,120,23,1], "A5 # 2^9 5^2 [9]",6,1, 1,[10,80,25]], # 768000.10 [[4,30720,26,3000,2,120,26,1], "A5 # 2^9 5^2 [10]",6,1, 1,[10,10,24,25]], # 768000.11 [[4,30720,33,3000,2,120,33,1], "A5 # 2^9 5^2 [11]",6,1, 1,[24,20,25]], # 768000.12 [[4,30720,36,3000,2,120,36,1], "A5 # 2^9 5^2 [12]",6,1, 1,[80,25]], # 768000.13 [[4,30720,37,3000,2,120,37,1], "A5 # 2^9 5^2 [13]",6,1, 1,[80,25]] ]; PERFGRP[293]:=[# 774144.1 [[1,"abuvwxyzd", function(a,b,u,v,w,x,y,z,d) return [[a^2,b^6,(a*b)^7,(a*b^2)^3*(a*b^(-1*2))^3,(a*b*a*b ^(-1*2))^3*a*b*(a*b^-1)^2,u^2,v^2,w^2, x^2,y^2,z^2,d^2,u^-1*d*u*d^-1, v^-1*d*v*d^-1,w^-1*d*w*d^-1, x^-1*d*x*d^-1,y^-1*d*y*d^-1, z^-1*d*z*d^-1,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*u*a*(u*z)^-1, a^-1*v*a*(u*v*x*z*d)^-1, a^-1*w*a*(u*w*x*z*d)^-1, a^-1*x*a*(x*z)^-1, a^-1*y*a*(u*x*y*d)^-1,a^-1*z*a*z^-1 ,a^-1*d*a*d^-1, b^-1*u*b*(u*w*x*y*z*d)^-1, b^-1*v*b*(u*x*z*d)^-1, b^-1*w*b*(u*w*z)^-1, b^-1*x*b*(u*v*w*x*z)^-1, b^-1*y*b*(v*y*z*d)^-1, b^-1*z*b*(u*v*w*x*y*z)^-1, b^-1*d*b*d^-1],[[a,b]]]; end, [128]], "U3(3) ( 2^6 E 2^1 )",[25,7,1],2, 12,128], # 774144.2 [[1,"abuvwxyzd", function(a,b,u,v,w,x,y,z,d) return [[a^2*(u*x*z)^-1,b^6*d^-1,(a*b)^7*d^-1,(a *b^2)^3*(a*b^(-1*2))^3*(w*y*z)^-1, (a*b*a*b^(-1*2))^3*a*b*(a*b^-1)^2 *(w*x*y)^-1*d^-1,u^2,v^2,w^2,x^2,y^2, z^2,d^2,u^-1*d*u*d^-1,v^-1*d*v*d^-1 ,w^-1*d*w*d^-1,x^-1*d*x*d^-1, y^-1*d*y*d^-1,z^-1*d*z*d^-1, u^-1*v^-1*u*v,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*u*a*(u*z*d)^-1, a^-1*v*a*(u*v*x*z*d)^-1, a^-1*w*a*(u*w*x*z*d)^-1, a^-1*x*a*(x*z*d)^-1, a^-1*y*a*(u*x*y)^-1,a^-1*z*a*z^-1, a^-1*d*a*d^-1, b^-1*u*b*(u*w*x*y*z)^-1, b^-1*v*b*(u*x*z*d)^-1, b^-1*w*b*(u*w*z)^-1, b^-1*x*b*(u*v*w*x*z*d)^-1, b^-1*y*b*(v*y*z)^-1, b^-1*z*b*(u*v*w*x*y*z*d)^-1, b^-1*d*b*d^-1], [[(b^-1*a*b)^-1*(a*b*a*b*a*b^(-1*2))^-1 *b^-1*a*b*a*b*a*b*a*b^(-1*2), a*b*a*b*a*b^(-1*2)*(b^-1*a*b)^-1 *(a*b*a*b*a*b^(-1*2))^-1*b^-1*a*b,u ]]]; end, [448],[[1,2],[10,10,10],[2,2],[1,-12]]], "U3(3) ( N 2^6 E 2^1 )",[25,7,2],2, 12,448] ]; PERFGRP[294]:=[# 777600.1 [[2,360,1,2160,1], "( A6 x A6 ) 3^1 2^1 [1]",40,6, [3,3],[6,18,80]], # 777600.2 [[2,720,1,1080,1], "( A6 x A6 ) 3^1 2^1 [2]",40,6, [3,3],[80,18]], # 777600.3 [[3,720,1,2160,1,"d1","d2"], "( A6 x A6 ) 3^1 2^1 [3]",40,6, [3,3],[720,3200]], # 777600.4 [[3,1080,1,2160,1,"a1","a1","a2","a2","a2","a2"], "( A6 x A6 ) 3^1 2^1 [4]",40,6, [3,3],[108,480]], # 777600.5 [[3,2160,1,2160,1,"a1","a1","a2","a2"], "( A6 x A6 ) 3^1 2^1 [5]",40,6, [3,3],[108,240,240,3200]] ]; PERFGRP[295]:=[# 786240.1 [[2,360,1,2184,1], "( A6 x L2(13) ) 2^1 [1]",40,2, [3,6],[6,56]], # 786240.2 [[2,720,1,1092,1], "( A6 x L2(13) ) 2^1 [2]",40,2, [3,6],[80,14]], # 786240.3 [[3,720,1,2184,1,"d1","a2","a2"], "( A6 x L2(13) ) 2^1 [3]",40,2, [3,6],2240] ]; ############################################################################# ## #E perf11.grp . . . . . . . . . . . . . . . . . . . . . . . . . ends here ## gap-4r6p5/grp/perf7.grp0000644000175000017500000010564212172557252013476 0ustar billbill############################################################################# ## #W perf7.grp GAP Groups Library Volkmar Felsch ## Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains the perfect groups of sizes 92160-174960 ## All data is based on Holt/Plesken: Perfect Groups, OUP 1989 ## PERFGRP[114]:=[# 92160.1 [[1,"abcstuvSTUV", function(a,b,c,s,t,u,v,S,T,U,V) return [[a^2,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1*b^-1*c *b*c*b^-1*c*b*c^-1,s^2,t^2,u^2, v^2,S^2,T^2,U^2,V^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,S^-1*T^-1*S*T, S^-1*U^-1*S*U,S^-1*V^-1*S*V, T^-1*U^-1*T*U,T^-1*V^-1*T*V, U^-1*V^-1*U*V,s^-1*S^-1*s*S, s^-1*T^-1*s*T,s^-1*U^-1*s*U, s^-1*V^-1*s*V,t^-1*S^-1*t*S, t^-1*T^-1*t*T,t^-1*U^-1*t*U, t^-1*V^-1*t*V,u^-1*S^-1*u*S, u^-1*T^-1*u*T,u^-1*U^-1*u*U, u^-1*V^-1*u*V,v^-1*S^-1*v*S, v^-1*T^-1*v*T,v^-1*U^-1*v*U, v^-1*V^-1*v*V,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,a^-1*S*a*U^-1, a^-1*T*a*V^-1,a^-1*U*a*S^-1, a^-1*V*a*T^-1,b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*S*b*(T*V)^-1, b^-1*T*b*(S*T*U*V)^-1, b^-1*U*b*(U*V)^-1,b^-1*V*b*U^-1, c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u)^-1, c^-1*v*c*(s*t*u*v)^-1, c^-1*S*c*(T*U)^-1,c^-1*T*c*T^-1, c^-1*U*c*(S*U)^-1, c^-1*V*c*(S*T*U*V)^-1],[[b,c,S],[b,c,s]]]; end, [16,16]], "A6 2^4 x 2^4",[13,8,1],1, 3,[16,16]], # 92160.2 [[1,"abcstuvwxyz", function(a,b,c,s,t,u,v,w,x,y,z) return [[a^2,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1*b^-1*c *b*c*b^-1*c*b*c^-1,s^2,t^2,u^2, v^2,w^2,x^2,y^2,z^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,s^-1*w^-1*s*w, s^-1*x^-1*s*x,s^-1*y^-1*s*y, s^-1*z^-1*s*z,t^-1*w^-1*t*w, t^-1*x^-1*t*x,t^-1*y^-1*t*y, t^-1*z^-1*t*z,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,a^-1*w*a*y^-1, a^-1*x*a*z^-1,a^-1*y*a*w^-1, a^-1*z*a*x^-1,b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*(x*y)^-1,b^-1*x*b*x^-1, b^-1*y*b*(w*y)^-1, b^-1*z*b*(w*x*y*z)^-1, c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u)^-1, c^-1*v*c*(s*t*u*v)^-1, c^-1*w*c*(x*z)^-1, c^-1*x*c*(w*x*y*z)^-1, c^-1*y*c*(y*z)^-1,c^-1*z*c*y^-1], [[b,c,s],[b,c,w]]]; end, [16,16]], "A6 2^4 x 2^4'",[13,8,2],1, 3,[16,16]] ]; PERFGRP[115]:=[# 95040.1 [[1,"ab", function(a,b) return [[a^2,b^3,(a*b)^11,(a^-1*b^-1*a*b)^6,(a*b*a*b*a *b^-1)^6,(a*b*a*b*a*b^-1*a*b^-1)^5], [[a,b*a*b^-1*a*(b^-1*a*b*a)^2]]]; end, [12]], "M12",28,-1, 31,12] ]; PERFGRP[116]:=[# 96000.1 [[4,3840,5,3000,2,120,5,1], "A5 # 2^6 5^2 [1]",6,2, 1,[24,12,25]], # 96000.2 [[4,3840,6,3000,2,120,6,1], "A5 # 2^6 5^2 [2]",6,2, 1,[48,25]], # 96000.3 [[4,3840,7,3000,2,120,7,1], "A5 # 2^6 5^2 [3]",6,2, 1,[32,24,25]] ]; PERFGRP[117]:=[# 100920.1 [[1,"abyz", function(a,b,y,z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,y^29,z^29,y^-1 *z^-1*y*z,a^-1*y*a*z^-1, a^-1*z*a*y,b^-1*y*b*(y^14*z^4)^-1, b^-1*z*b*(y^(-1*2)*z^14)^-1],[[a,b]]]; end, [841],[0,0,2,2,2,2]], "A5 2^1 29^2",[5,2,1],1, 1,841] ]; PERFGRP[118]:=[# 102660.1 [[1,"abc", function(a,b,c) return [[c^29,c*b^4*c^-1*b^-1,b^59,a^2,c*a*c*a^-1, (b*a)^3],[[b,c]]]; end, [60]], "L2(59)",22,-1, 32,60] ]; PERFGRP[119]:=[# 103776.1 [[1,"abc", function(a,b,c) return [[c^23*a^2,c*b^(-1*22)*c^-1*b^-1,b^47,a^4,a^2 *b^-1*a^2*b,a^2*c^-1*a^2*c, c*a*c*a^-1,(b*a)^3],[[b,c^2]]]; end, [96],[0,2,2,2]], "L2(47) 2^1 = SL(2,47)",22,-2, 27,96] ]; PERFGRP[120]:=[# 110880.1 [[2,168,1,660,1], "L3(2) x L2(11)",[39,0,1],1, [2,5],[7,11]] ]; PERFGRP[121]:=[# 112896.1 [[2,336,1,336,1], "( L3(2) x L3(2) ) 2^2",[34,2,1],4, [2,2],[16,16]] ]; PERFGRP[122]:=[# 113460.1 [[1,"abc", function(a,b,c) return [[c^30,c*b^4*c^-1*b^-1,b^61,a^2,c*a*c*a^-1, (b*a)^3,c^(-1*4)*(b*c)^3*c*a*b^2*a*c*b^2*a], [[b,c]]]; end, [62]], "L2(61)",22,-1, 33,62] ]; PERFGRP[123]:=[# 115200.1 [[2,960,1,120,1], "( A5 x A5 ) # 2^5 [1]",[29,5,1],2, [1,1],[16,24]], # 115200.2 [[2,960,2,120,1], "( A5 x A5 ) # 2^5 [2]",[29,5,2],2, [1,1],[10,24]], # 115200.3 [[2,1920,1,60,1], "( A5 x A5 ) # 2^5 [3]",[29,5,3],2, [1,1],[12,5]], # 115200.4 [[2,1920,2,60,1], "( A5 x A5 ) # 2^5 [4]",[29,5,4],2, [1,1],[24,5]], # 115200.5 [[2,1920,3,60,1], "( A5 x A5 ) # 2^5 [5]",[29,5,5],2, [1,1],[16,24,5]], # 115200.6 [[2,1920,4,60,1], "( A5 x A5 ) # 2^5 [6]",[29,5,6],1, [1,1],[80,5]], # 115200.7 [[2,1920,5,60,1], "( A5 x A5 ) # 2^5 [7]",[29,5,7],2, [1,1],[10,24,5]], # 115200.8 [[2,1920,6,60,1], "( A5 x A5 ) # 2^5 [8]",[29,5,8],2, [1,1],[80,5]], # 115200.9 [[2,1920,7,60,1], "( A5 x A5 ) # 2^5 [9]",[29,5,9],2, [1,1],[32,5]], # 115200.10 [[3,1920,1,120,1,"e1","d2"], "( A5 x A5 ) # 2^5 [10]",[29,5,10],2, [1,1],144], # 115200.11 [[3,1920,2,120,1,"d1","d2"], "( A5 x A5 ) # 2^5 [11]",[29,5,11],2, [1,1],288], # 115200.12 [[3,1920,3,120,1,"d1","d2"], "( A5 x A5 ) # 2^5 [12]",[29,5,12],2, [1,1],[192,288]], # 115200.13 [[3,1920,5,120,1,"d1","d2"], "( A5 x A5 ) # 2^5 [13]",[29,5,13],2, [1,1],[120,288]], # 115200.14 [[3,1920,6,120,1,"d1","d2"], "( A5 x A5 ) # 2^5 [14]",[29,5,14],2, [1,1],960], # 115200.15 [[3,1920,7,120,1,"e1","d2"], "( A5 x A5 ) # 2^5 [15]",[29,5,15],2, [1,1],384] ]; PERFGRP[124]:=[# 115248.1 [[1,"abxyz", function(a,b,x,y,z) return [[a^4,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4*a^2,a^2*b *a^2*b^-1,x^7,y^7,z^7,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*x*a*z^-1,a^-1*y*a*y, a^-1*z*a*x^-1,b^-1*x*b*z^-1, b^-1*y*b*(y^-1*z^-1)^-1, b^-1*z*b*(x*y^2*z)^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,x], [a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,a^2,y ]]]; end, [16,56]], "L3(2) 2^1 x 7^3",[10,3,1],2, 2,[16,56]], # 115248.2 [[1,"abxyz", function(a,b,x,y,z) return [[a^4,b^3,(a*b)^7*z^-1,(a^-1*b^-1*a*b)^4 *a^2,a^2*b*a^2*b^-1,x^7,y^7,z^7, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*x*a*z^-1, a^-1*y*a*y,a^-1*z*a*x^-1, b^-1*x*b*z^-1, b^-1*y*b*(y^-1*z^-1)^-1, b^-1*z*b*(x*y^2*z)^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,x], [a*b*x^2,b*a*b^-1*a*b^-1*a*b*a*b^-1, a^2,y]]]; end, [16,56]], "L3(2) 2^1 x N 7^3",[10,3,2],2, 2,[16,56]], # 115248.3 [[1,"abyzd", function(a,b,y,z,d) return [[a^4,b^3,(a*b)^7,a^2*b^-1*a^2*b,(a^-1*b^-1 *a*b)^4*a^2,d^7,a^-1*d*a*d^-1, b^-1*d*b*d^-1,y^-1*d*y*d^-1, z^-1*d*z*d^-1,y^7,z^7, y^-1*z^-1*y*z*d^-1, a^-1*y*a*(z^-1*d^(-1*2))^-1, a^-1*z*a*(y*d^2)^-1, b^-1*y*b*(z*d^(-1*2))^-1, b^-1*z*b*(y^-1*z^-1*d)^-1],[[a,b]]]; end, [343]], "L3(2) 2^1 7^2 C 7^1",[10,3,3],7, 2,343], # 115248.4 (otherpres.) [[1,"abDyzd", function(a,b,D,y,z,d) return [[a^2*D^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *D^-1,D^2,D^-1*b^-1*D*b,d^7, a^-1*d*a*d^-1,b^-1*d*b*d^-1, y^-1*d*y*d^-1,z^-1*d*z*d^-1,y^7, z^7,y^-1*z^-1*y*z*d^-1, a^-1*y*a*(z^-1*d^(-1*2))^-1, a^-1*z*a*(y*d^2)^-1, b^-1*y*b*(z*d^(-1*2))^-1, b^-1*z*b*(y^-1*z^-1*d)^-1],[[a,b]]]; end, [343]]] ]; PERFGRP[125]:=[# 115320.1 [[1,"abyz", function(a,b,y,z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,y^31,z^31,y^-1 *z^-1*y*z,a^-1*y*a*z^-1, a^-1*z*a*y,b^-1*y*b*(y^-1*z^15)^-1, b^-1*z*b*y^(-1*2)],[[a*b,a^2,y]]]; end, [372]], "A5 2^1 31^2",[5,2,1],1, 1,372] ]; PERFGRP[126]:=[# 116480.1 [[1,"abde", function(a,b,d,e) return [[a^2,b^4,(a*b)^5,(a^-1*b^-1*a*b)^7*(d*e)^-1 ,(a*b^2)^13, a*b^-1*a*b^2*a*b^2*(a*b^-1*a*b*a*b^2)^2 *a*b^2*a*b*(a*b^2)^4*e^-1,d^2,e^2, d^-1*e^-1*d*e,a^-1*d*a*d^-1, a^-1*e*a*e^-1,b^-1*d*b*d^-1, b^-1*e*b*e^-1], [[a*b^2,(a*b*a*b^2)^2*a*b^2*a*b^-1 *(a*b^2*a*b*a*b^2)^2]]]; end, [2240],[[1,2]]], "Sz(8) 2^1 x 2^1",28,-4, 23,2240] ]; PERFGRP[127]:=[# 117600.1 [[1,"abc", function(a,b,c) return [[c^24*a^2,b^7,c^(-1*8)*b^2*c^8*b^-1,c*b^3*c*b^2 *c^(-1*2)*b^(-1*3),a^4,a^2*b^-1*a^2*b, a^2*c^-1*a^2*c,c*a*c*a^-1,(b*a)^3, c^2*b*c*b^2*a*b*a*c*a*b^2*a*b^-1*c^(-1*3) *b^-1*a],[[b,c^-1*b*c,c^16]]]; end, [800],[0,2,2,0,2,2]], "L2(49) 2^1 = SL(2,49)",22,-2, 28,800] ]; PERFGRP[128]:=[# 120000.1 [[4,960,1,7500,1,60], "A5 # 2^4 5^3 [1]",6,1, 1,[16,30]], # 120000.2 [[4,960,2,7500,1,60], "A5 # 2^4 5^3 [2]",6,1, 1,[10,30]], # 120000.3 [[4,960,1,7500,2,60], "A5 # 2^4 5^3 [3]",6,1, 1,[16,30]], # 120000.4 [[4,960,2,7500,2,60], "A5 # 2^4 5^3 [4]",6,1, 1,[10,30]] ]; PERFGRP[129]:=[# 120960.1 [[1,"abwxyz", function(a,b,w,x,y,z) return [[a^6,b^4,(a*b)^7,(a*b)^2*a*b^2*(a*b*a*b^-1)^2 *(a*b)^2*(a*b^-1)^2*a*b*a*b^-1 *a^2,a^2*b*a^(-1*2)*b^-1,w^2,x^2,y^2,z^2, w*x*w*x,w*y*w*y,w*z*w*z,x*y*x*y,x*z*x*z, y*z*y*z,a^-1*w*a*y^-1, a^-1*x*a*z^-1,a^-1*y*a*w^-1, a^-1*z*a*x^-1,b^-1*w*b*(w*x*y*z)^-1 ,b^-1*x*b*y^-1,b^-1*y*b*(w*x)^-1, b^-1*z*b*(w*z)^-1], [[a^3,(b^-1*a)^2*(b*a)^2*b^2*a*b*a,w],[a,b]]]; end, [45,16]], "A7 3^1 x 2^4",[23,4,1],3, 8,[45,16]], # 120960.2 [[1,"abde", function(a,b,d,e) return [[a^2,b^4,(a*b)^7*e*d^-1,(a^-1*b^-1*a*b)^5, (a*b^2)^5*e^-1,(a*b*a*b*a*b^3)^5, (a*b*a*b*a*b^2*a*b^-1)^5*d^(-1*2),d^3, a^-1*d*a*d^-1,b^-1*d*b*d^-1,e^2, a^-1*e*a*e^-1,b^-1*e*b*e^-1], [[a*b*a,b^2*a*b^-1*a*b*a*b^2*a*b*d], [a*e,b*a*b*a*b^-1*a*b^2]]]; end, [63,112]], "L3(4) 3^1 x 2^1",[27,1,1],-6, 20,[63,112]], # 120960.3 [[2,168,1,720,1], "( L3(2) x A6 ) 2^1 [1]",[37,1,1],2, [2,3],[7,80]], # 120960.4 [[2,336,1,360,1], "( L3(2) x A6 ) 2^1 [2]",[37,1,2],2, [2,3],[16,6]], # 120960.5 [[3,336,1,720,1,"d1","d2"], "( L3(2) x A6 ) 2^1 [3]",[37,1,3],2, [2,3],640] ]; PERFGRP[130]:=[# 122472.1 [[1,"abuvwxyz", function(a,b,u,v,w,x,y,z) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,u^3,v^3, w^3,x^3,y^3,z^3,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*u*a*(x*y^-1*z^-1)^-1, a^-1*v*a*(w*x^-1*y^-1)^-1, a^-1*w*a*(u*w^-1*x*y^-1*z^-1)^-1 ,a^-1*x*a*(v*w*x*y^-1)^-1, a^-1*y*a*(u*v*w*z^-1)^-1, a^-1*z*a*(u*x*y^-1*z)^-1, b^-1*u*b*(v*w^-1*x^-1)^-1, b^-1*v*b*(u*v^-1*w^-1)^-1, b^-1*w*b*(u^-1*v*w^-1*x^-1*z^-1) ^-1,b^-1*x*b*(u*v*w^-1*y^-1*z) ^-1,b^-1*y*b*(u*x^-1*y)^-1, b^-1*z*b*(v*w^-1*x*z)^-1], [[a,b^-1*a*b,z]]]; end, [63]], "L3(2) 3^6",[9,6,1],1, 2,63], # 122472.2 [[1,"abuvwxyz", function(a,b,u,v,w,x,y,z) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,u^3,v^3, w^3,x^3,y^3,z^3,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*u*a*w^-1,a^-1*v*a*v^-1, a^-1*w*a*u^-1,a^-1*x*a*z^-1, a^-1*y*a*y^-1,a^-1*z*a*x^-1, b^-1*u*b*v^-1, b^-1*v*b*(u^-1*v^-1*w^-1*x^-1 *y^-1*z^-1)^-1,b^-1*w*b*x^-1 ,b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1], [[b,a*b^-1*a*b*a,x*y^-1*z]]]; end, [21]], "L3(2) 3^6'",[9,6,2],1, 2,21] ]; PERFGRP[131]:=fail; PERFGRP[132]:=[# 126000.1 [[1,"ab", function(a,b) return [[a^2,b^4,(a*b)^10,(a*b*a*b^2)^7,a*b^-1*a*b^-1 *a*b*a*b^(-1*2)*a*b *a*b^-1*a*b^-1*a*b *a*b*a*b^-1*a*b*b*a*b^-1 *a*b*a*b, (a*b^-1*a*b^-1*a*b*a*b*a*b)^2*b*a *b^-1*a*b^-1*a*b*a*b*a *b^-1],[[b,a*b*a*b^-1*a]]]; end, [50],[[1,2],0,2]], "U3(5)",28,-1, 34,50] ]; PERFGRP[133]:=[# 129024.1 [[1,"abcuvwxyzde", function(a,b,c,u,v,w,x,y,z,d,e) return [[a^2,b^3,(a*b)^7,b^-1*(a*b)^3*c^-1,c*b^-1 *c*b*a^-1*b^-1*c^-1*b *c^-1*a,u^2,v^2,w^2,x^2,y^2,z^2,d^2,e^2, u^-1*v^-1*u*v,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,u^-1*d^-1*u*d, u^-1*e^-1*u*e,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,v^-1*d^-1*v*d, v^-1*e^-1*v*e,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, w^-1*d^-1*w*d,w^-1*e^-1*w*e, x^-1*y^-1*x*y,x^-1*z^-1*x*z, x^-1*d^-1*x*d,x^-1*e^-1*x*e, y^-1*z^-1*y*z,y^-1*d^-1*y*d, y^-1*e^-1*y*e,z^-1*d^-1*z*d, z^-1*e^-1*z*e,d^-1*e^-1*d*e, a^-1*u*a*(u*x)^-1,a^-1*v*a*(v*y)^-1, a^-1*w*a*(w*z)^-1,a^-1*x*a*x^-1, a^-1*y*a*y^-1,a^-1*z*a*z^-1, a^-1*d*a*d^-1,a^-1*e*a*e^-1, b^-1*u*b*(x*y*d)^-1, b^-1*v*b*(y*z*e)^-1, b^-1*w*b*(x*y*z)^-1, b^-1*x*b*(v*w*x)^-1, b^-1*y*b*(u*v*w*y)^-1, b^-1*z*b*(u*w*z)^-1,b^-1*d*b*d^-1, b^-1*e*b*e^-1,c^-1*u*c*(v*d)^-1, c^-1*v*c*(w*d)^-1, c^-1*w*c*(u*v*e)^-1, c^-1*x*c*(x*z*d)^-1, c^-1*y*c*(x*e)^-1,c^-1*z*c*y^-1, c^-1*d*c*d^-1,c^-1*e*c*e^-1], [[b^-1*c,u*d,e],[b^-1*c,u*e,d]]]; end, [112,112]], "L2(8) 2^6 E ( 2^1 x 2^1 )",[16,8,1],4, 4,[112,112]], # 129024.2 [[1,"abcuvwxyzf", function(a,b,c,u,v,w,x,y,z,f) return [[a^2*f,b^3,(a*b)^7,b^-1*(a*b)^3*c^-1,b^-1 *c^-1*b*c^-1*a^-1*c *b^-1*c*b*a*(y*z*f^2)^-1,f^4,u^2, v^2*f^2,w^2,x^2*f^2,y^2,z^2*f^2, u^-1*v^-1*u*v,u^-1*w^-1*u*w, u^-1*x^-1*u*x*f^2,u^-1*y^-1*u*y *f^2,u^-1*z^-1*u*z,u^-1*f^-1*u*f, v^-1*w^-1*v*w,v^-1*x^-1*v*x*f^2, v^-1*y^-1*v*y,v^-1*z^-1*v*z, v^-1*f^-1*v*f,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z*f^2, w^-1*f^-1*w*f,x^-1*y^-1*x*y, x^-1*z^-1*x*z,x^-1*f^-1*x*f, y^-1*z^-1*y*z,y^-1*f^-1*y*f, z^-1*f^-1*z*f,a^-1*u*a*(u*x)^-1, a^-1*v*a*(v*y*f^2)^-1, a^-1*w*a*(w*z)^-1, a^-1*x*a*(x*f^2)^-1,a^-1*y*a*y^-1, a^-1*z*a*(z*f^2)^-1,a^-1*f*a*f^-1, b^-1*u*b*(x*y*f^-1)^-1, b^-1*v*b*(y*z*f^2)^-1, b^-1*w*b*(x*y*z*f^2)^-1, b^-1*x*b*(v*w*x)^-1, b^-1*y*b*(u*v*w*y*f^2)^-1, b^-1*z*b*(u*w*z*f^-1)^-1, b^-1*f*b*f^-1, c^-1*u*c*(v*f^-1)^-1, c^-1*v*c*(w*f^-1)^-1, c^-1*w*c*(u*v*f)^-1, c^-1*x*c*(x*z*f)^-1, c^-1*y*c*(x*f)^-1, c^-1*z*c*(y*f^-1)^-1, c^-1*f*c*f^-1],[[c^-1*v^-1*a, w*c]]]; end, [288],[[1,2],[11,11,11]]], "L2(8) N ( 2^6 E 2^1 A ) C 2^1",[16,8,2],4, 4,288], # 129024.3 [[1,"abcuvwxyzdf", function(a,b,c,u,v,w,x,y,z,d,f) return [[a^2*f,b^3,(a*b)^7,b^-1*(a*b)^3*c^-1,b^-1 *c^-1*b*c^-1*a^-1*c *b^-1*c*b*a*(y*z*d)^-1,d^2,f^2,u^2, v^2,w^2,x^2,y^2,z^2,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, u^-1*d^-1*u*d,u^-1*f^-1*u*f, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, v^-1*d^-1*v*d,v^-1*f^-1*v*f, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,w^-1*d^-1*w*d, w^-1*f^-1*w*f,x^-1*y^-1*x*y, x^-1*z^-1*x*z,x^-1*d^-1*x*d, x^-1*f^-1*x*f,y^-1*z^-1*y*z, y^-1*d^-1*y*d,y^-1*f^-1*y*f, z^-1*d^-1*z*d,z^-1*f^-1*z*f, a^-1*u*a*(u*x)^-1,a^-1*v*a*(v*y)^-1, a^-1*w*a*(w*z)^-1,a^-1*x*a*x^-1, a^-1*y*a*y^-1,a^-1*z*a*z^-1, a^-1*d*a*d^-1,a^-1*f*a*f^-1, b^-1*u*b*(x*y*f^-1)^-1, b^-1*v*b*(y*z)^-1, b^-1*w*b*(x*y*z*d)^-1, b^-1*x*b*(v*w*x)^-1, b^-1*y*b*(u*v*w*y*d)^-1, b^-1*z*b*(u*w*z*f^-1)^-1, b^-1*d*b*d^-1,b^-1*f*b*f^-1, c^-1*u*c*(v*d*f^-1)^-1, c^-1*v*c*(w*d*f^-1)^-1, c^-1*w*c*(u*v*f)^-1, c^-1*x*c*(x*z*d*f)^-1, c^-1*y*c*(x*d*f)^-1, c^-1*z*c*(y*f^-1)^-1, c^-1*d*c*d^-1,c^-1*f*c*f^-1], [[b^-1*c,u*f,d],[b^-1*c*d,u*d,f]]]; end, [112,112],[[1,2]]], "L2(8) N 2^6 E ( 2^1 x 2^1 ) I",[16,8,3],4, 4,[112,112]], # 129024.4 [[1,"abcuvwxyzde", function(a,b,c,u,v,w,x,y,z,d,e) return [[a^2,b^3,(a*b)^7,b^-1*(a*b)^3*c^-1,b^-1*c ^-1*b*c^-1*a^-1*c*b^-1 *c*b*a*(y*z*d)^-1,d^2,e^2,u^2,v^2,w^2, x^2,y^2,z^2,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, u^-1*d^-1*u*d,u^-1*e^-1*u*e, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, v^-1*d^-1*v*d,v^-1*e^-1*v*e, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,w^-1*d^-1*w*d, w^-1*e^-1*w*e,x^-1*y^-1*x*y, x^-1*z^-1*x*z,x^-1*d^-1*x*d, x^-1*e^-1*x*e,y^-1*z^-1*y*z, y^-1*d^-1*y*d,y^-1*e^-1*y*e, z^-1*d^-1*z*d,z^-1*e^-1*z*e, a^-1*u*a*(u*x)^-1,a^-1*v*a*(v*y)^-1, a^-1*w*a*(w*z)^-1,a^-1*x*a*x^-1, a^-1*y*a*y^-1,a^-1*z*a*z^-1, a^-1*d*a*d^-1,a^-1*e*a*e^-1, b^-1*u*b*(x*y)^-1, b^-1*v*b*(y*z*e)^-1, b^-1*w*b*(x*y*z*d*e)^-1, b^-1*x*b*(v*w*x*e)^-1, b^-1*y*b*(u*v*w*y*d*e)^-1, b^-1*z*b*(u*w*z*e)^-1,b^-1*d*b*d^-1 ,b^-1*e*b*e^-1,c^-1*u*c*(v*d)^-1, c^-1*v*c*(w*d*e)^-1, c^-1*w*c*(u*v)^-1, c^-1*x*c*(x*z*d)^-1, c^-1*y*c*(x*d*e)^-1,c^-1*z*c*y^-1, c^-1*d*c*d^-1,c^-1*e*c*e^-1], [[b^-1*c*d,u*d,e],[b^-1*c*e,u*e,d]]]; end, [112,112]], "L2(8) N 2^6 E ( 2^1 x 2^1 ) II",[16,8,4],4, 4,[112,112]], # 129024.5 [[1,"abcuvwxyzde", function(a,b,c,u,v,w,x,y,z,d,e) return [[a^2*e^-1,b^3,(a*b)^7,b^-1*(a*b)^3*c^-1, b^-1*c^-1*b*c^-1*a^-1*c*b^-1*c *b*a*(y*z*d)^-1,d^2,e^2,u^2,v^2,w^2,x^2, y^2,z^2,u^-1*v^-1*u*v,u^-1*w^-1*u*w ,u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,u^-1*d^-1*u*d, u^-1*e^-1*u*e,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,v^-1*d^-1*v*d, v^-1*e^-1*v*e,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, w^-1*d^-1*w*d,w^-1*e^-1*w*e, x^-1*y^-1*x*y,x^-1*z^-1*x*z, x^-1*d^-1*x*d,x^-1*e^-1*x*e, y^-1*z^-1*y*z,y^-1*d^-1*y*d, y^-1*e^-1*y*e,z^-1*d^-1*z*d, z^-1*e^-1*z*e,a^-1*u*a*(u*x)^-1, a^-1*v*a*(v*y)^-1,a^-1*w*a*(w*z)^-1, a^-1*x*a*x^-1,a^-1*y*a*y^-1, a^-1*z*a*z^-1,a^-1*d*a*d^-1, a^-1*e*a*e^-1,b^-1*u*b*(x*y*e)^-1, b^-1*v*b*(y*z*e)^-1, b^-1*w*b*(x*y*z*d*e)^-1, b^-1*x*b*(v*w*x*e)^-1, b^-1*y*b*(u*v*w*y*d*e)^-1, b^-1*z*b*(u*w*z)^-1,b^-1*d*b*d^-1, b^-1*e*b*e^-1,c^-1*u*c*(v*d*e)^-1, c^-1*v*c*(w*d)^-1, c^-1*w*c*(u*v*e)^-1, c^-1*x*c*(x*z*d*e)^-1, c^-1*y*c*(x*d)^-1,c^-1*z*c*(y*e)^-1, c^-1*d*c*d^-1,c^-1*e*c*e^-1], [[b^-1*c*d,u*d,e],[b^-1*c*e,u,d]]]; end, [112,112],[[1,2]]], "L2(8) N 2^6 E ( 2^1 x 2^1 ) III",[16,8,5],4, 4,[112,112]], # 129024.6 [[1,"abcstuvwxyz", function(a,b,c,s,t,u,v,w,x,y,z) return [[a^2,b^3,(a*b)^7,b^-1*(a*b)^3*c^-1,b^-1*c ^-1*b*c^-1*a^-1*c*b^-1 *c*b*a,s^2,t^2,u^2,v^2,w^2,x^2,y^2,z^2, s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,s^-1*w^-1*s*w, s^-1*x^-1*s*x,s^-1*y^-1*s*y, s^-1*z^-1*s*z,t^-1*u^-1*t*u, t^-1*v^-1*t*v,t^-1*w^-1*t*w, t^-1*x^-1*t*x,t^-1*y^-1*t*y, t^-1*z^-1*t*z,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*s*a*s^-1,a^-1*t*a*v^-1, a^-1*u*a*y^-1,a^-1*v*a*t^-1, a^-1*w*a*x^-1,a^-1*x*a*w^-1, a^-1*y*a*u^-1, a^-1*z*a*(s*t*u*v*w*x*y*z)^-1, b^-1*s*b*u^-1,b^-1*t*b*s^-1, b^-1*u*b*t^-1,b^-1*v*b*x^-1, b^-1*w*b*v^-1,b^-1*x*b*w^-1, b^-1*y*b*z^-1, b^-1*z*b*(s*t*u*v*w*x*y*z)^-1, c^-1*s*c*s^-1,c^-1*t*c*t^-1, c^-1*u*c*y^-1,c^-1*v*c*w^-1, c^-1*w*c*u^-1,c^-1*x*c*z^-1, c^-1*y*c*(s*t*u*v*w*x*y*z)^-1, c^-1*z*c*v^-1],[[a,c,t*z]]]; end, [18]], "L2(8) 2^8",[16,8,6],1, 4,18] ]; PERFGRP[134]:=[# 129600.1 [[2,60,1,2160,1], "( A5 x A6 3^1 ) 2^1 [1]",[33,1,1],6, [1,3],[5,18,80]], # 129600.2 [[2,120,1,1080,1], "( A5 x A6 3^1 ) 2^1 [2]",[33,1,2],6, [1,3],[24,18]], # 129600.3 [[3,120,1,2160,1,"d1","d2"], "( A5 x A6 3^1 ) 2^1 [3]",[33,1,3],6, [1,3],[216,960]], # 129600.4 [[2,360,1,360,1], "A6 x A6",40,1, [3,3],[6,6]] ]; PERFGRP[135]:=[# 131040.1 [[2,60,1,2184,1], "( A5 x L2(13) ) 2^1 [1]",40,2, [1,6],[5,56]], # 131040.2 [[2,120,1,1092,1], "( A5 x L2(13) ) 2^1 [2]",40,2, [1,6],[24,14]], # 131040.3 [[3,120,1,2184,1,"d1","a2","a2"], "( A5 x L2(13) ) 2^1 [3]",40,2, [1,6],672] ]; PERFGRP[136]:=[# 131712.1 [[4,2688,1,16464,2,336,1,1], "L3(2) # 2^4 7^2 [1]",12,1, 2,[8,16,49]], # 131712.2 [[4,2688,3,16464,2,336,3,1], "L3(2) # 2^4 7^2 [2]",12,1, 2,[16,14,49]] ]; PERFGRP[137]:=[# 138240.1 [[4,46080,1,1080,2,360,1,1], "A6 3^1 x 2^1 x ( 2^4 E 2^1 A ) C 2^1",[13,7,1],24, 3,[64,80,18]], # 138240.2 [[1,"abcduvwxyz", function(a,b,c,d,u,v,w,x,y,z) return [[a^6*d^-1,b^3,c^3,(b*c)^4*d^-1,(b*c^-1)^5, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,d^2, d^-1*b^-1*d*b,d^-1*c^-1*d*c,u^2, v^2,w^2,x^2,y^2,z^2,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*u*a*(v*x)^-1, a^-1*v*a*(u*v*w*x)^-1,a^-1*w*a*x^-1 ,a^-1*x*a*(w*x)^-1, a^-1*y*a*(x*z)^-1, a^-1*z*a*(w*x*y*z)^-1,b^-1*u*b*u^-1 ,b^-1*v*b*v^-1,b^-1*w*b*(u*x)^-1, b^-1*x*b*(v*w*x)^-1, b^-1*y*b*(u*y*z)^-1, b^-1*z*b*(v*y)^-1,c^-1*u*c*w^-1, c^-1*v*c*x^-1,c^-1*w*c*(y*z)^-1, c^-1*x*c*y^-1,c^-1*y*c*v^-1, c^-1*z*c*(u*v)^-1],[[b,c],[c*b*a*d,b,u]]]; end, [64,80]], "A6 ( ( 3^1 2^6 ) x 2^1 )",[13,7,2],2, 3,[64,80]] ]; PERFGRP[138]:=[# 144060.1 [[1,"abwxyz", function(a,b,w,x,y,z) return [[a^2,b^3,(a*b)^5,w^7,x^7,y^7,z^7,w^-1*x^-1*w *x,w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*w*a*z^-1, a^-1*x*a*x^-1,a^-1*y*a*w*x*y*z, a^-1*z*a*w^-1,b^-1*w*b*x^-1, b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1], [[b,a*b*a*b^-1*a,w*x^-1]]]; end, [35]], "A5 7^4",[4,4,1],1, 1,35] ]; PERFGRP[139]:=[# 146880.1 [[2,60,1,2448,1], "A5 x L2(17)",40,1, [1,7],[5,18]] ]; PERFGRP[140]:=[# 148824.1 [[1,"abc", function(a,b,c) return [[c^26*a^2,c*b^4*c^-1*b^-1,b^53,a^4,a^2*b^(-1 *1)*a^2*b,a^2*c^-1*a^2*c, c*a*c*a^-1,(b*a)^3, c^(-1*3)*b*c*b*c^2*a*b^2*a*c*b^2*a],[[b,c^4]]] ; end, [216]], "L2(53) 2^1 = SL(2,53)",22,-2, 30,216] ]; PERFGRP[141]:=[# 150348.1 [[1,"abc", function(a,b,c) return [[c^33,c*b^4*c^-1*b^-1,b^67,a^2,c*a*c*a^-1, (b*a)^3],[[b,c]]]; end, [68]], "L2(67)",22,-1, 35,68] ]; PERFGRP[142]:=[# 151200.1 [[2,60,1,2520,1], "A5 x A7",40,1, [1,8],[5,7]] ]; PERFGRP[143]:=[# 151632.1 [[1,"abxyz", function(a,b,x,y,z) return [[a^2,b^3,(a*b)^13,(a^-1*b^-1*a*b)^4,(a*b)^4*a *b^-1*(a*b)^4*a*b^-1*(a*b)^2 *(a*b^-1)^2*a*b*(a*b^-1)^2*(a*b)^2 *a*b^-1,x^3,y^3,z^3,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*x*a*(x*z)^-1,a^-1*y*a*y, a^-1*z*a*z,b^-1*x*b*x*y, b^-1*y*b*x^-1,b^-1*z*b*(x*y*z)^-1], [[a,b]]]; end, [27]], "L3(3) 3^3",[24,3,1],1, 11,27] ]; PERFGRP[144]:=[# 155520.1 [[1,"abdwxyzstuv", function(a,b,d,w,x,y,z,s,t,u,v) return [[a^2*d^-1,b^3,(a*b)^5,d^2,a^-1*d^-1*a*d, b^-1*d^-1*b*d,d^-1*w^-1*d*w, d^-1*x^-1*d*x,d^-1*y^-1*d*y, d^-1*z^-1*d*z,w^2,x^2,y^2,z^2,(w*x)^2*d, (w*y)^2*d,(w*z)^2*d,(x*y)^2*d,(x*z)^2*d,(y*z)^2*d, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*x*y*z)^-1,a^-1*z*a*w^-1 ,b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1,s^3, t^3,u^3,v^3,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^-1*s*a*(s*t*u*v)^-1 ,a^-1*t*a*(s^-1*t*u*v^-1)^-1, a^-1*u*a*(s^-1*u^-1*v)^-1, a^-1*v*a*(t*u^-1*v^-1)^-1, b^-1*s*b*(s^-1*t^-1*u*v^-1)^-1, b^-1*t*b*(s^-1*v^-1)^-1, b^-1*u*b*(s*t^-1*u^-1*v^-1)^-1, b^-1*v*b*(t^-1*u^-1)^-1, d^-1*s*d*s,d^-1*t*d*t,d^-1*u*d*u, d^-1*v*d*v,w^-1*s*w*s^-1, w^-1*t*w*(s^-1*t*v)^-1, w^-1*u*w*(s*t*u^-1*v^-1)^-1, w^-1*v*w*(s^-1*v^-1)^-1, x^-1*s*x*(s*t*u*v^-1)^-1, x^-1*t*x*t^-1, x^-1*u*x*(s^-1*v^-1)^-1, x^-1*v*x*(s^-1*t^-1*u*v)^-1, y^-1*s*y*(s*v^-1)^-1, y^-1*t*y*(t*u*v^-1)^-1,y^-1*u*y*u, y^-1*v*y*v, z^-1*s*z*(s*t^-1*u^-1*v^-1)^-1, z^-1*t*z*(s*u*v)^-1, z^-1*u*z*(t*u^-1*v)^-1, z^-1*v*z*(s^-1*t*u^-1)^-1], [[a,b,w]]]; end, [81]], "A5 2^4' C N 2^1 3^4",[7,4,1],1, 1,81], # 155520.2 [[4,1920,1,4860,1,60], "A5 # 2^5 3^4 [1]",6,2, 1,[12,15]], # 155520.3 [[4,1920,2,4860,1,60], "A5 # 2^5 3^4 [2]",6,2, 1,[24,15]], # 155520.4 [[4,1920,3,4860,1,60], "A5 # 2^5 3^4 [3]",6,2, 1,[16,24,15]], # 155520.5 [[4,1920,4,4860,1,60], "A5 # 2^5 3^4 [4]",6,1, 1,[80,15]], # 155520.6 [[4,1920,5,4860,1,60], "A5 # 2^5 3^4 [5]",6,2, 1,[10,24,15]], # 155520.7 [[4,1920,6,4860,1,60], "A5 # 2^5 3^4 [6]",6,2, 1,[80,15]], # 155520.8 [[4,1920,7,4860,1,60], "A5 # 2^5 3^4 [7]",6,2, 1,[32,15]], # 155520.9 [[4,1920,1,4860,2,60], "A5 # 2^5 3^4 [8]",6,2, 1,[12,60]], # 155520.10 [[4,1920,2,4860,2,60], "A5 # 2^5 3^4 [9]",6,2, 1,[24,60]], # 155520.11 [[4,1920,3,4860,2,60], "A5 # 2^5 3^4 [10]",6,2, 1,[16,24,60]], # 155520.12 [[4,1920,4,4860,2,60], "A5 # 2^5 3^4 [11]",6,1, 1,[80,60]], # 155520.13 [[4,1920,5,4860,2,60], "A5 # 2^5 3^4 [12]",6,2, 1,[10,24,60]], # 155520.14 [[4,1920,6,4860,2,60], "A5 # 2^5 3^4 [13]",6,2, 1,[80,60]], # 155520.15 [[4,1920,7,4860,2,60], "A5 # 2^5 3^4 [14]",6,2, 1,[32,60]], # 155520.16 [[4,1920,3,9720,4,120,3,3], "A5 # 2^5 3^4 [15]",6,1, 1,[16,24,45]], # 155520.17 [[4,1920,4,9720,4,120,4,3], "A5 # 2^5 3^4 [16]",6,1, 1,[80,45]], # 155520.18 [[4,1920,5,9720,4,120,5,3], "A5 # 2^5 3^4 [17]",6,1, 1,[10,24,45]] ]; PERFGRP[145]:=[# 158400.1 [[2,120,1,1320,1], "( A5 x L2(11) ) 2^2",[36,2,1],4, [1,5],[24,24]] ]; PERFGRP[146]:=[# 159720.1 [[1,"abxyz", function(a,b,x,y,z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,x^11,y^11,z^11, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*x*a*z^-1, a^-1*y*a*y,a^-1*z*a*x^-1, b^-1*x*b*(x*y^(-1*5)*z^(-1*2))^-1, b^-1*y*b*(x^(-1*4)*y^-1)^-1, b^-1*z*b*x^(-1*5)], [[a*b,z],[a*b,b*a*b*a*b^-1*a*b^-1,y*z^5]]]; end, [24,66]], "A5 2^1 11^3",[5,3,1],2, 1,[24,66]], # 159720.2 [[1,"abyzd", function(a,b,y,z,d) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,d^11,d^-1*y ^-1*d*y,d^-1*z^-1*d*z,y^11,z^11, y^-1*z^-1*y*z*d^-1, a^-1*y*a*z^-1,a^-1*z*a*y, a^-1*d*a*d^-1, b^-1*y*b*(y^-1*z^(-1*3)*d^4)^-1, b^-1*z*b*y^(-1*4)],[[a,b]]]; end, [1331]], "A5 2^1 11^2 C 11^1",[5,3,2],11, 1,1331], # 159720.3 [[1,"abyz", function(a,b,y,z) return [[a^4,b^3,(a*b)^11,a^2*b^-1*a^2*b,(a*b*a*b*a*b*a *b*a*b^-1*a*b^-1*a*b^-1 *a*b^-1*a*b^-1)^2*a^2,y^11,z^11, y^-1*z^-1*y*z,a^-1*y*a*z, a^-1*z*a*y^-1,b^-1*y*b*z^-1, b^-1*z*b*(y^-1*z^-1)^-1],[[a,b]]]; end, [121]], "L2(11) 2^1 11^2",[19,2,1],1, 5,121] ]; PERFGRP[147]:=[# 160380.1 [[1,"abvwxyz", function(a,b,v,w,x,y,z) return [[a^2,b^3,(a*b)^11,(a*b)^4*(a*b^-1)^5*(a*b)^4*(a *b^-1)^5,v^3,w^3,x^3,y^3,z^3, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*v*a*v^-1,a^-1*w*a*w^-1, a^-1*x*a*(v^2*x^2*y)^-1, a^-1*y*a*y^-1,a^-1*z*a*(w*y*z^2)^-1 ,b^-1*v*b*w^-1,b^-1*w*b*x^-1, b^-1*x*b*v^-1,b^-1*y*b*(y^2*z)^-1, b^-1*z*b*y^(-1*2)],[[b,a*b*a*b^-1*a,y*z]] ]; end, [33]], "L2(11) 3^5",[18,5,1],1, 5,33] ]; PERFGRP[148]:=[# 161280.1 [[1,"abuvwxyz", function(a,b,u,v,w,x,y,z) return [[a^2,b^4,(a*b)^7,(a*b)^2*a*b^2*(a*b*a*b^-1)^2 *(a*b)^2*(a*b^-1)^2*a*b*a*b^-1,u^2, v^2,w^2,x^2,y^2,z^2,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*u*a*u^-1,a^-1*v*a*v^-1, a^-1*w*a*y^-1,a^-1*x*a*x^-1, a^-1*y*a*w^-1, a^-1*z*a*(u*v*w*x*y*z)^-1, b^-1*u*b*w^-1,b^-1*v*b*z^-1, b^-1*w*b*v^-1,b^-1*x*b*y^-1, b^-1*y*b*x^-1,b^-1*z*b*u^-1], [[a,b^2*a*b^-1*(a*b*a*b*b)^2*(a*b)^2, b*(a*b^-1)^2*a*b^2*(a*b)^2,y*z]]]; end, [14]], "A7 2^6",[23,6,1],1, 8,14], # 161280.2 [[1,"abef", function(a,b,e,f) return [[a^2,b^4*f^(-1*2),(a*b)^7*e,(a*b^2)^5*(e*f)^-1, (a^-1*b^-1*a*b)^5*f^(-1*2), (a*b*a*b*a*b^3)^5*f,(a*b*a*b*a*b^2*a*b^-1) ^5,e^2,f^4,e^-1*f^-1*e*f, a^-1*e*a*e^-1,a^-1*f*a*f^-1, b^-1*e*b*e^-1,b^-1*f*b*f^-1], [[a,b*a*b*a*b^-1*a*b^2*f^-1], [a*e^2,b^-1*a*b^-1*a*b*a*b^2]]]; end, [224,112]], "L3(4) 2^1 x ( 2^1 A 2^1 )",[27,3,1],-8, 20,[224,112]], # 161280.3 [[2,60,1,2688,1], "( A5 x L3(2) ) # 2^4 [1]",[31,4,1],2, [1,2],[5,8,16]], # 161280.4 [[2,60,1,2688,2], "( A5 x L3(2) ) # 2^4 [2]",[31,4,2],2, [1,2],[5,16]], # 161280.5 [[2,60,1,2688,3], "( A5 x L3(2) ) # 2^4 [3]",[31,4,3],2, [1,2],[5,16,14]], # 161280.6 [[2,120,1,1344,1], "( A5 x L3(2) ) # 2^4 [4]",[31,4,4],2, [1,2],[24,8]], # 161280.7 [[2,120,1,1344,2], "( A5 x L3(2) ) # 2^4 [5]",[31,4,5],2, [1,2],[24,14]], # 161280.8 [[3,120,1,2688,1,"d1","d2"], "( A5 x L3(2) ) # 2^4 [6]",[31,4,6],2, [1,2],[96,192]], # 161280.9 [[3,120,1,2688,2,"d1","e2"], "( A5 x L3(2) ) # 2^4 [7]",[31,4,7],2, [1,2],192], # 161280.10 [[3,120,1,2688,3,"d1","d2"], "( A5 x L3(2) ) # 2^4 [8]",[31,4,8],2, [1,2],[192,168]], # 161280.11 [[2,960,1,168,1], "( A5 x L3(2) ) # 2^4 [9]",[31,4,9],1, [1,2],[16,7]], # 161280.12 [[2,960,2,168,1], "( A5 x L3(2) ) # 2^4 [10]",[31,4,10],1, [1,2],[10,7]] ]; PERFGRP[149]:=[# 169344.1 [[2,336,1,504,1], "L3(2) 2^1 x L2(8)",[38,1,1],2, [2,4],[16,9]] ]; PERFGRP[150]:=fail; PERFGRP[151]:=[# 174960.1 [[1,"abcdwxyz", function(a,b,c,d,w,x,y,z) return [[a^4*d,b^3,c^3*(w*x*y^-1)^-1,(b*c)^4*(a^2*d ^-1)^-1,(b*c^-1)^5, a^2*d^-1*b*(a^2*d^-1)^-1*b^-1, a^2*d^-1*c*(a^2*d^-1)^-1*c^-1, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,d^3, w^3,x^3,y^3,z^3,d^-1*w^-1*d*w, d^-1*x^-1*d*x,d^-1*y^-1*d*y, d^-1*z^-1*d*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*d*a*d^-1, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*d*b*(d*w*y^-1*z)^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1, c^-1*d*c*(d*x^-1*z^-1)^-1, c^-1*w*c*(w^-1*x*y^-1*z^-1)^-1, c^-1*x*c*(x^-1*z)^-1, c^-1*y*c*(w*x^-1)^-1,c^-1*z*c*x], [[c*b*a^-1,b,w],[b,c*a*b*c,d*y^-1*z]]]; end, [80,30]], "A6 2^1 x 3^1 E 3^4' I",[14,5,1],2, 3,[80,30]], # 174960.2 [[1,"abcdwxyz", function(a,b,c,d,w,x,y,z) return [[a^4*d,b^3*(w*x*y*z^-1)^-1,c^3*(w*y^-1 *z^-1)^-1,(b*c)^4*(a^2*d^-1)^-1, (b*c^-1)^5,a^2*d^-1*b*(a^2*d^-1)^-1 *b^-1,a^2*d^-1*c*(a^2*d^-1)^-1 *c^-1,a^-1*b^-1*c*b*c*b^-1*c*b *c^-1,d^3,w^3,x^3,y^3,z^3,d^-1*w^-1*d *w,d^-1*x^-1*d*x,d^-1*y^-1*d*y, d^-1*z^-1*d*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*d*a*d^-1, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*d*b*(d*w*x^-1*z)^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1, c^-1*d*c*(d*x)^-1, c^-1*w*c*(w^-1*x*y^-1*z^-1)^-1, c^-1*x*c*(x^-1*z)^-1, c^-1*y*c*(w*x^-1)^-1,c^-1*z*c*x], [[c*b*a^-1,b,w],[b*w^-1,c*a*b*c]]]; end, [80,30]], "A6 2^1 x 3^1 E 3^4' II",[14,5,2],2, 3,[80,30]], # 174960.3 [[1,"abcwxyzf", function(a,b,c,w,x,y,z,f) return [[a^4,b^3,c^3,(b*c)^4*a^2,(b*c^-1)^5,a^2*b*a^2 *b^-1,a^2*c*a^2*c^-1, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,w^3, x^3,y^3,z^3,f^3,w^-1*f^-1*w*f, x^-1*f^-1*x*f,y^-1*f^-1*y*f, z^-1*f^-1*z*f,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*w*a*z^-1, a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, a^-1*f*a*f^-1,b^-1*w*b*x^-1, b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1,b^-1*f*b*f^-1, c^-1*w*c*(w^-1*x*y^-1*z^-1*f)^-1 ,c^-1*x*c*(x^-1*z*f)^-1, c^-1*y*c*(w*x^-1*f)^-1, c^-1*z*c*(x^-1*f^-1)^-1, c^-1*f*c*f^-1], [[c*b*a^-1,b,w],[a,b,w]]]; end, [80,18]], "A6 2^1 x 3^4' E 3^1 I",[14,5,3],6, 3,[80,18]], # 174960.4 [[1,"abcwxyze", function(a,b,c,w,x,y,z,e) return [[a^4,b^3,c^3,(b*c)^4*a^2,(b*c^-1)^5,a^2*b*a^2 *b^-1,a^2*c*a^2*c^-1, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,w^3, x^3,y^3,z^3,e^3,w^-1*e^-1*w*e, x^-1*e^-1*x*e,y^-1*e^-1*y*e, z^-1*e^-1*z*e,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*w*a*z^-1, a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, a^-1*e*a*e^-1,b^-1*w*b*x^-1, b^-1*x*b*(y*e^-1)^-1, b^-1*y*b*(w*e)^-1,b^-1*z*b*(z*e)^-1, b^-1*e*b*e^-1, c^-1*w*c*(w^-1*x*y^-1*z^-1*e^-1) ^-1,c^-1*x*c*(x^-1*z*e^-1)^-1, c^-1*y*c*(w*x^-1*e^-1)^-1, c^-1*z*c*(x^-1*e)^-1, c^-1*e*c*e^-1], [[c*b*a^-1,b,w],[a*b,b*a*b*a*b^-1*a*b^-1 ,w*e]]]; end, [80,108]], "A6 2^1 x 3^4' E 3^1 II",[14,5,4],6, 3,[80,108]], # 174960.5 [[1,"abcwxyzd", function(a,b,c,w,x,y,z,d) return [[a^4*d,b^3,c^3,(b*c)^4*(a^2*d^-1)^-1,(b*c^(-1 *1))^5,a^2*d^-1*b*(a^2*d^-1)^-1 *b^-1,a^2*d^-1*c*(a^2*d^-1)^-1 *c^-1,a^-1*b^-1*c*b*c*b^-1*c*b *c^-1,d^3,b^-1*d*b*d^-1, c^-1*d*c*d^-1,w^3,x^3,y^3,z^3, w^-1*d^-1*w*d,x^-1*d^-1*x*d, y^-1*d^-1*y*d,z^-1*d^-1*z*d, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1, c^-1*w*c*(w^-1*x*y^-1*z^-1)^-1, c^-1*x*c*(x^-1*z)^-1, c^-1*y*c*(w*x^-1)^-1, c^-1*z*c*x], [[c*b*a^-1,b,w],[a*d,c*d,w],[b,c*a*b*c,z]]]; end, [80,18,30]], "A6 2^1 x 3^1 x 3^4'",[14,5,5],6, 3,[80,18,30]], # 174960.6 [[1,"abcdstuv", function(a,b,c,d,s,t,u,v) return [[a^4*d,b^3,c^3,(b*c)^4*a^(-1*2)*d,(b*c^-1)^5,a^(-1 *1)*b^-1*c*b*c*b^-1*c*b *c^-1,a^(-1*2)*b^-1*a^2*b, a^(-1*2)*c^-1*a^2*c,d^3,b^-1*d^-1*b*d, c^-1*d^-1*c*d,s^3,t^3,u^3,v^3, s^-1*d^-1*s*d,t^-1*d^-1*t*d, u^-1*d^-1*u*d,v^-1*d^-1*v*d, s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s,a^-1*v*a*t, b^-1*s*b*(s*v^-1)^-1, b^-1*t*b*(t*u^-1*v)^-1, b^-1*u*b*u^-1,b^-1*v*b*v^-1, c^-1*s*c*(s^-1*t*u^-1*v)^-1, c^-1*t*c*(s*t*u*v)^-1, c^-1*u*c*(s^-1*v^-1)^-1, c^-1*v*c*(t^-1*u^-1*v)^-1], [[a*d,c*d,s],[a,b,c]]]; end, [18,81]], "A6 2^1 x 3^1 x 3^4",[14,5,6],3, 3,[18,81]], # 174960.7 [[1,"abcstuvd", function(a,b,c,s,t,u,v,d) return [[a^4*d,b^3,c^3,(b*c)^4*a^(-1*2)*d,(b*c^-1)^5,a^(-1 *1)*b^-1*c*b*c*b^-1*c*b *c^-1,a^(-1*2)*b^-1*a^2*b, a^(-1*2)*c^-1*a^2*c,s^3,t^3,u^3,v^3,d^3, d^-1*s^-1*d*s,d^-1*t^-1*d*t, d^-1*u^-1*d*u,d^-1*v^-1*d*v, s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v*d,t^-1*u^-1*t*u*d, t^-1*v^-1*t*v*d^-1,u^-1*v^-1*u *v,a^-1*s*a*(u*d)^-1, a^-1*t*a*(v*d^-1)^-1,a^-1*u*a*s, a^-1*v*a*t,a^-1*d*a*d^-1, b^-1*s*b*(s*v^-1)^-1, b^-1*t*b*(t*u^-1*v*d)^-1, b^-1*u*b*u^-1,b^-1*v*b*v^-1, b^-1*d*b*d^-1, c^-1*s*c*(s^-1*t*u^-1*v*d^-1)^-1 ,c^-1*t*c*(s*t*u*v)^-1, c^-1*u*c*(s^-1*v^-1*d)^-1, c^-1*v*c*(t^-1*u^-1*v)^-1, c^-1*d*c*d^-1],[[a*d,b*d^-1]]]; end, [1458]], "A6 2^1 3^4 C N 3^1",[14,5,7],3, 3,1458], # 174960.8 [[1,"abcstuve", function(a,b,c,s,t,u,v,e) return [[a^4,b^3,c^3,(b*c)^4*a^(-1*2),(b*c^-1)^5,a^-1 *b^-1*c*b*c*b^-1*c*b*c^-1, a^(-1*2)*b^-1*a^2*b,a^(-1*2)*c^-1*a^2*c, s^3,t^3,u^3,v^3,e^3,e^-1*s^-1*e*s, e^-1*t^-1*e*t,e^-1*u^-1*e*u, e^-1*v^-1*e*v,s^-1*t^-1*s*t, s^-1*u^-1*s*u*e^-1,s^-1*v^-1*s *v,t^-1*u^-1*t*u,t^-1*v^-1*t*v *e^-1,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*(s^-1*e)^-1, a^-1*v*a*(t^-1*e)^-1, a^-1*e*a*e^-1, b^-1*s*b*(s*v^-1*e^-1)^-1, b^-1*t*b*(t*u^-1*v*e)^-1, b^-1*u*b*u^-1,b^-1*v*b*v^-1, b^-1*e*b*e^-1, c^-1*s*c*(s^-1*t*u^-1*v*e)^-1, c^-1*t*c*(s*t*u*v*e^-1)^-1, c^-1*u*c*(s^-1*v^-1)^-1, c^-1*v*c*(t^-1*u^-1*v)^-1, c^-1*e*c*e^-1],[[a,b,c]]]; end, [243]], "A6 2^1 3^4 C 3^1",[14,5,8],3, 3,243] ]; ############################################################################# ## #E perf7.grp . . . . . . . . . . . . . . . . . . . . . . . . . ends here ## gap-4r6p5/grp/ree.gd0000644000175000017500000000337312172557252013026 0ustar billbill############################################################################# # #W ree.gd GAP library Alexander Hulpke ## ## #Y (C) 2001 School Math. Sci., University of St Andrews, Scotland ## ############################################################################# ## #O ReeGroupCons( , ) ## ## ## ## ## ## ## ## DeclareConstructor( "ReeGroupCons", [ IsGroup, IsInt ] ); ############################################################################# ## #F ReeGroup( [, ] ) . . . . . . . . . . . . . . . Ree group #F Ree( [, ] ) ## ## <#GAPDoc Label="ReeGroup"> ## ## ## ## ## ## Constructs a group isomorphic to the Ree group ^2G_2(q) where ## q = 3^{{1+2m}} for m a non-negative integer. ##

## If filt is not given it defaults to ## and the generating matrices are based on . ## (No particular choice of a generating set is guaranteed.) ##

## ReeGroup( 27 ); ## Ree(27) ## ]]> ## ## ## <#/GAPDoc> ## BindGlobal( "ReeGroup", function ( arg ) if Length(arg) = 1 then return ReeGroupCons( IsMatrixGroup, arg[1] ); elif IsOperation(arg[1]) then if Length(arg) = 2 then return ReeGroupCons( arg[1], arg[2] ); fi; fi; Error( "usage: ReeGroup( [, ] )" ); end ); DeclareSynonym( "Ree", ReeGroup ); ############################################################################# ## #E gap-4r6p5/grp/imf13.grp0000644000175000017500000005110012172557252013357 0ustar billbill############################################################################# ## #A imf13.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Z-class representative of the irreducible ## maximal finite integral matrix groups of dimension 13, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Z-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 13. ## IMFList[13].matrices := [ [ # Z-class [13][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1]], [[[0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1,0]]]], [ # Z-class [13][02] [[2], [0,2], [1,0,2], [0,1,0,2], [0,0,1,0,2], [0,0,0,1,0,2], [0,0,0,0,1,0,2], [0,0,0,0,0,1,0,2], [0,0,0,0,0,0,1,0,2], [0,0,0,0,0,0,0,1,0,2], [0,0,0,0,0,0,0,0,1,0,2], [1,0,0,0,0,0,0,0,0,1,0,2], [0,1,0,0,0,0,0,0,0,0,1,0,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,1,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,-1,0,1,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,-1,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,0,0,0,0,0,0,0,1], [-1,0,0,1,0,-1,0,1,0,-1,0,1,0]], [[-1,0,1,0,-1,-1,1,1,-1,-1,1,1,0], [0,1,1,0,-1,0,1,0,-1,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,1,1,-1,-1,1,1,0,-1,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,1,0,-1,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,-1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,1,0,0,0,0,0], [0,1,0,0,-1,0,1,0,-1,0,1,0,-1]]]], [ # Z-class [13][03] [[13], [-11,13], [9,-11,13], [-7,9,-11,13], [5,-7,9,-11,13], [-3,5,-7,9,-11,13], [1,-3,5,-7,9,-11,13], [1,1,-3,5,-7,9,-11,13], [-3,1,1,-3,5,-7,9,-11,13], [5,-3,1,1,-3,5,-7,9,-11,13], [-7,5,-3,1,1,-3,5,-7,9,-11,13], [9,-7,5,-3,1,1,-3,5,-7,9,-11,13], [-11,9,-7,5,-3,1,1,-3,5,-7,9,-11,13]], [[[1,1,1,1,1,1,1,1,1,1,1,1,1], [-1,0,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1], [1,0,0,0,0,1,1,1,1,1,1,1,1], [-1,0,0,0,0,0,0,-1,-1,-1,-1,-1,-1], [1,0,0,0,0,0,0,0,0,1,1,1,1], [-1,0,0,0,0,0,0,0,0,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,-1,-1,-1,0,0], [0,0,0,0,0,0,1,1,1,1,1,0,0], [0,0,0,0,-1,-1,-1,-1,-1,-1,-1,0,0], [0,0,1,1,1,1,1,1,1,1,1,0,0], [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,0]], [[0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1], [-1,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Z-class [13][04] [[13], [-1,13], [-1,-1,13], [-1,-1,-1,13], [-1,-1,-1,-1,13], [-1,-1,-1,-1,-1,13], [-1,-1,-1,-1,-1,-1,13], [-1,-1,-1,-1,-1,-1,-1,13], [-1,-1,-1,-1,-1,-1,-1,-1,13], [-1,-1,-1,-1,-1,-1,-1,-1,-1,13], [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,13], [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,13], [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,13]], [[[0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1], [1,1,1,1,1,1,1,1,1,1,1,1,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0]]]], [ # Z-class [13][05] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,1,0], [-1,0,0,0,0,0,0,0,0,0,0,1,0]], [[-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,1,0]]]], [ # Z-class [13][06] [[12], [5,12], [-2,5,12], [-2,-2,5,12], [-2,-2,-2,5,12], [-2,-2,-2,-2,5,12], [-2,-2,-2,-2,-2,5,12], [-2,-2,-2,-2,-2,-2,5,12], [-2,-2,-2,-2,-2,-2,-2,5,12], [-2,-2,-2,-2,-2,-2,-2,-2,5,12], [-2,-2,-2,-2,-2,-2,-2,-2,-2,5,12], [-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,5,12], [5,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,5,12]], [[[0,-1,0,-1,0,-1,0,-1,0,-1,0,-1,0], [0,-1,0,-1,0,-1,0,-1,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,1,0,1,0,1,0,1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,-1,1,-1,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,-1,1,-1,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,-1,1,-1,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,-1,1,-1,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,1,0,1,0,1,0,1,0,1]]]], [ # Z-class [13][07] [[7], [5,7], [3,5,7], [1,3,5,7], [-1,1,3,5,7], [-3,-1,1,3,5,7], [-5,-3,-1,1,3,5,7], [-5,-5,-3,-1,1,3,5,7], [-3,-5,-5,-3,-1,1,3,5,7], [-1,-3,-5,-5,-3,-1,1,3,5,7], [1,-1,-3,-5,-5,-3,-1,1,3,5,7], [3,1,-1,-3,-5,-5,-3,-1,1,3,5,7], [5,3,1,-1,-3,-5,-5,-3,-1,1,3,5,7]], [[[0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,-1,1,0,0,0,0,-1,0], [0,0,0,0,-1,0,1,0,0,0,-1,-1,1], [0,0,0,-1,0,0,1,0,0,-1,-1,0,1], [0,0,-1,0,0,0,1,0,-1,-1,0,0,1], [0,-1,0,0,0,0,1,-1,-1,0,0,0,1], [-1,0,0,0,0,0,0,-1,0,0,0,0,1]], [[-1,-1,-1,0,1,1,0,-1,-1,0,0,1,1], [0,-1,-1,0,1,1,1,-1,-1,0,0,1,1], [0,0,-1,-1,1,1,1,0,-1,-1,0,1,1], [0,0,0,-1,0,1,1,0,0,-1,-1,1,1], [0,0,0,0,-1,1,1,0,0,-1,0,0,1], [0,0,1,0,-1,1,0,0,0,0,0,0,0], [0,1,1,0,-1,0,0,0,1,0,0,0,-1], [0,1,1,0,-1,-1,0,0,1,0,0,-1,-1], [-1,1,1,1,-1,-1,-1,0,1,1,0,-1,-1], [-1,0,1,1,0,-1,-1,-1,1,1,1,-1,-1], [-1,0,0,1,1,-1,-1,-1,0,1,1,0,-1], [-1,0,0,0,1,-1,0,-1,0,1,0,0,0], [-1,0,-1,0,1,0,0,-1,0,0,0,0,1]]]], [ # Z-class [13][08] [[5], [3,5], [2,3,5], [1,2,3,5], [-1,1,2,3,5], [-3,-1,1,2,3,5], [-3,-3,-1,1,2,3,5], [-3,-3,-3,-1,1,2,3,5], [-3,-3,-3,-3,-1,1,2,3,5], [-1,-3,-3,-3,-3,-1,1,2,3,5], [1,-1,-3,-3,-3,-3,-1,1,2,3,5], [2,1,-1,-3,-3,-3,-3,-1,1,2,3,5], [3,2,1,-1,-3,-3,-3,-3,-1,1,2,3,5]], [[[0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,1,0,-1,0,0,1,0,-1,1,0], [0,0,0,1,0,0,0,-1,0,1,0,1,-1], [0,0,-1,1,0,0,0,-1,0,0,0,1,-1], [0,0,0,1,0,0,0,0,0,0,0,1,-1], [0,0,0,1,-1,0,0,0,0,0,0,0,-1], [0,0,-1,0,0,1,0,0,-1,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,-1,0], [0,0,0,0,0,0,0,1,0,0,0,-1,1], [0,0,0,-1,0,0,0,1,-1,0,0,-1,1], [0,1,0,-1,0,0,0,1,0,0,0,-1,1], [-1,0,1,0,0,-1,0,1,0,0,0,0,1]], [[-1,-1,0,0,0,0,0,1,-1,-1,0,1,1], [0,0,0,-1,0,1,0,1,-1,0,0,0,1], [0,0,-1,0,0,1,0,0,0,0,0,0,1], [-1,1,0,0,0,0,0,0,0,1,0,0,0], [0,1,0,0,0,0,-1,0,1,1,0,-1,0], [0,1,0,0,0,0,0,-1,1,1,0,-1,0], [0,1,0,0,0,-1,0,-1,1,1,0,-1,-1], [0,1,1,0,-1,-1,0,0,1,0,0,-1,-1], [1,0,0,0,0,-1,0,0,1,0,-1,-1,0], [0,0,0,0,0,-1,1,0,0,-1,0,0,0], [0,-1,1,0,0,-1,0,1,0,-1,0,0,0], [0,-1,0,0,0,0,0,1,-1,-1,0,0,1], [0,-1,0,0,0,0,1,1,-1,-1,0,1,1]]]], [ # Z-class [13][09] [[3], [1,3], [-1,1,3], [-1,-1,1,3], [0,-1,-1,1,3], [0,0,-1,-1,1,3], [0,0,0,-1,-1,1,3], [0,0,0,0,-1,-1,1,3], [0,0,0,0,0,-1,-1,1,3], [0,0,0,0,0,0,-1,-1,1,3], [-1,0,0,0,0,0,0,-1,-1,1,3], [-1,-1,0,0,0,0,0,0,-1,-1,1,3], [1,-1,-1,0,0,0,0,0,0,-1,-1,1,3]], [[[-1,0,0,-1,1,-1,0,0,-1,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1,-1,1,0], [0,0,0,0,0,0,0,0,0,0,-1,1,-1], [0,-1,1,-1,0,1,-1,1,0,-1,1,-1,0], [0,0,1,-1,1,0,0,1,0,0,1,-1,1], [-1,1,0,0,1,-1,1,0,0,1,0,0,1], [0,0,0,1,0,0,0,0,0,0,0,0,0], [1,-1,0,1,-1,1,0,-1,1,-1,0,0,-1], [1,-1,0,0,-1,0,0,-1,1,-1,0,0,-1], [0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,-1,1,0,0,0], [-1,1,-1,0,1,-1,1,0,-1,1,-1,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1], [1,-1,0,1,-1,1,0,0,1,-1,1,0,-1], [1,-1,1,0,0,1,0,0,1,-1,1,0,0], [0,0,0,0,0,0,0,-1,1,-1,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,-1,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,-1,1,-1,0,0,0,0,0], [-1,1,0,0,1,-1,1,0,0,1,0,0,1], [-1,1,-1,0,1,-1,1,0,0,1,-1,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0]]]], [ # Z-class [13][10] [[4], [2,4], [1,2,4], [-1,1,2,4], [-1,-1,1,2,4], [-1,-1,-1,1,2,4], [0,-1,-1,-1,1,2,4], [0,0,-1,-1,-1,1,2,4], [-1,0,0,-1,-1,-1,1,2,4], [-1,-1,0,0,-1,-1,-1,1,2,4], [-1,-1,-1,0,0,-1,-1,-1,1,2,4], [1,-1,-1,-1,0,0,-1,-1,-1,1,2,4], [2,1,-1,-1,-1,0,0,-1,-1,-1,1,2,4]], [[[0,-1,0,1,0,0,-1,0,1,0,-1,0,1], [-1,0,0,0,0,0,0,0,0,1,-1,0,1], [0,0,0,0,0,0,0,0,0,1,0,-1,1], [0,0,0,-1,1,0,0,0,0,1,0,-1,1], [0,0,0,0,1,-1,0,1,0,0,0,0,1], [0,0,0,0,0,0,0,0,1,-1,0,1,0], [0,0,-1,1,0,-1,0,0,1,-1,-1,1,0], [0,1,-1,0,0,0,0,-1,1,0,-1,1,-1], [0,1,-1,0,0,0,0,0,0,0,0,0,-1], [1,0,0,-1,0,1,-1,0,0,0,1,-1,-1], [0,0,0,-1,1,0,-1,1,-1,0,1,-1,0], [0,-1,1,0,0,0,-1,1,0,-1,1,0,0], [-1,-1,1,0,0,0,-1,1,0,-1,0,0,1]], [[-1,-1,1,0,0,-1,0,1,0,-1,0,0,1], [-1,0,0,0,0,-1,0,1,0,-1,0,1,0], [-1,0,0,0,0,-1,0,1,-1,0,0,0,0], [-1,1,0,0,-1,0,1,0,-1,0,0,1,-1], [0,0,0,0,-1,1,0,-1,0,0,0,0,-1], [0,1,0,-1,0,1,0,-1,0,0,0,0,-1], [1,0,0,-1,0,1,0,-1,0,0,1,-1,-1], [1,0,0,0,0,0,0,0,0,-1,1,0,-1], [1,0,0,0,0,0,0,0,0,0,1,0,-1], [0,0,1,0,0,0,0,1,-1,0,1,0,0], [0,0,1,0,-1,1,0,0,0,0,1,0,0], [-1,0,1,0,0,0,0,0,0,0,0,0,1], [-1,0,1,-1,0,0,0,0,0,0,0,0,1]]]], [ # Z-class [13][11] [[4], [2,4], [2,2,4], [1,2,2,4], [0,1,2,2,4], [0,0,1,2,2,4], [-1,0,0,1,2,2,4], [-1,-1,0,0,1,2,2,4], [0,-1,-1,0,0,1,2,2,4], [0,0,-1,-1,0,0,1,2,2,4], [1,0,0,-1,-1,0,0,1,2,2,4], [2,1,0,0,-1,-1,0,0,1,2,2,4], [2,2,1,0,0,-1,-1,0,0,1,2,2,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,1,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,1,0,-1,1,0,-1,1,0,-1,0,1,-1], [1,0,-1,0,1,-1,0,1,-1,-1,1,0,-1], [0,1,-1,-1,1,0,-1,1,0,-1,0,1,-1], [1,0,-1,0,1,-1,0,1,-1,0,1,0,-1], [0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,1,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,-1,1,0,0], [1,-1,0,1,0,-1,1,0,-1,0,1,-1,0], [0,0,0,1,0,-1,0,0,0,0,1,-1,0], [0,-1,1,1,-1,0,1,-1,0,1,0,-1,1], [0,-1,0,1,0,0,0,-1,0,1,0,-1,1], [0,-1,0,1,-1,0,1,-1,0,1,0,-1,1], [0,-1,0,1,0,0,0,-1,0,1,0,0,0], [0,0,-1,1,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,1,0,-1,0,0,0,1,0], [0,0,-1,0,1,0,0,0,0,-1,0,1,0]]]], [ # Z-class [13][12] [[15], [-5,15], [-5,-5,15], [3,-5,-5,15], [-1,3,-5,-5,15], [7,-1,3,-5,-5,15], [-5,7,-1,3,-5,-5,15], [-5,-5,7,-1,3,-5,-5,15], [7,-5,-5,7,-1,3,-5,-5,15], [-1,7,-5,-5,7,-1,3,-5,-5,15], [3,-1,7,-5,-5,7,-1,3,-5,-5,15], [-5,3,-1,7,-5,-5,7,-1,3,-5,-5,15], [-5,-5,3,-1,7,-5,-5,7,-1,3,-5,-5,15]], [[[0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,-1,0,0,0,0,0,-1], [1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,1,1,0,0,-1,-1,0,0,0,0], [-1,0,-1,0,-1,0,0,1,1,1,1,0,0], [0,0,0,0,0,0,0,0,0,-1,-1,-1,0], [0,0,1,0,1,0,0,0,0,0,0,0,-1], [0,-1,-1,0,0,0,0,0,0,1,1,1,0], [0,1,1,1,0,0,0,0,0,0,-1,-1,0], [-1,0,0,0,0,0,0,0,1,0,1,0,0], [0,-1,-1,-1,0,0,0,0,0,0,0,0,0], [0,0,1,1,1,1,0,0,-1,0,-1,0,-1], [0,0,0,0,-1,-1,0,0,1,1,1,0,0]], [[-1,-1,-1,-1,-1,0,0,0,0,0,0,0,0], [0,0,1,1,1,0,-1,-1,-1,0,0,0,-1], [1,1,0,0,0,0,1,0,0,-1,0,0,1], [0,-1,-1,-1,0,1,1,1,0,0,-1,0,0], [-1,0,0,0,0,-1,-1,0,1,1,1,0,-1], [0,0,0,0,-1,0,0,0,0,0,0,0,0], [1,0,1,0,1,0,0,-1,-1,-1,-1,0,0], [0,1,0,0,0,0,1,1,1,0,0,-1,0], [0,-1,-1,-1,-1,0,0,1,0,1,0,1,0], [-1,0,1,1,1,0,-1,-1,0,0,0,0,-1], [0,0,0,0,0,0,1,0,0,-1,0,-1,0], [1,0,0,0,0,0,0,0,-1,0,-1,0,0], [0,1,0,0,0,0,0,1,1,0,0,0,0]]]], [ # Z-class [13][13] [[13], [-3,13], [-7,-3,13], [5,-7,-3,13], [1,5,-7,-3,13], [-7,1,5,-7,-3,13], [5,-7,1,5,-7,-3,13], [5,5,-7,1,5,-7,-3,13], [-7,5,5,-7,1,5,-7,-3,13], [1,-7,5,5,-7,1,5,-7,-3,13], [5,1,-7,5,5,-7,1,5,-7,-3,13], [-7,5,1,-7,5,5,-7,1,5,-7,-3,13], [-3,-7,5,1,-7,5,5,-7,1,5,-7,-3,13]], [[[0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,1,1,1,1,1,1,0,0,0,0,0,0], [0,0,0,0,-1,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,1,1,1,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,-1,0,0,0,0,0,1], [0,0,0,0,1,1,1,1,1,1,1,0,0], [0,0,0,0,0,0,1,0,0,0,-1,0,-1], [0,0,0,0,-1,-1,-1,-1,0,-1,0,0,0], [0,0,0,1,1,1,0,0,0,0,0,0,0], [0,0,0,0,0,1,1,1,0,0,0,0,0], [0,-1,0,-1,-1,-1,-1,0,0,0,0,0,0], [-1,0,0,0,1,0,0,0,0,0,0,-1,0]]]], [ # Z-class [13][14] [[5], [-1,5], [-1,-1,5], [-1,-1,-1,5], [1,-1,-1,-1,5], [-1,1,-1,-1,-1,5], [1,-1,1,-1,-1,-1,5], [1,1,-1,1,-1,-1,-1,5], [-1,1,1,-1,1,-1,-1,-1,5], [1,-1,1,1,-1,1,-1,-1,-1,5], [-1,1,-1,1,1,-1,1,-1,-1,-1,5], [-1,-1,1,-1,1,1,-1,1,-1,-1,-1,5], [-1,-1,-1,1,-1,1,1,-1,1,-1,-1,-1,5]], [[[-1,0,-1,-1,0,-1,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,1,0,0,0,-1,0,-1,-1], [0,1,0,0,0,-1,0,-1,-1,0,-1,0,0], [1,0,1,0,0,0,-1,0,0,0,1,0,1], [-1,0,0,0,1,0,1,1,0,1,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,-1,0,-1,-1,0,-1,0,0,0,1,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0], [1,1,0,1,0,0,0,-1,0,0,0,1,0], [0,0,1,0,1,1,0,1,0,0,0,-1,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,1,0,0,0,-1,0,-1,-1], [0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,1,0,1,1,0,1], [0,0,0,1,0,1,1,0,1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,-1,0,-1,-1,0,-1,0,0,0,1,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0]]]], [ # Z-class [13][15] [[4], [-2,4], [0,-2,4], [1,0,-2,4], [0,1,0,-2,4], [-1,0,1,0,-2,4], [1,-1,0,1,0,-2,4], [1,1,-1,0,1,0,-2,4], [-1,1,1,-1,0,1,0,-2,4], [0,-1,1,1,-1,0,1,0,-2,4], [1,0,-1,1,1,-1,0,1,0,-2,4], [0,1,0,-1,1,1,-1,0,1,0,-2,4], [-2,0,1,0,-1,1,1,-1,0,1,0,-2,4]], [[[0,-1,-1,1,1,0,-1,0,1,0,-1,0,1], [0,1,1,-1,-1,0,0,-1,-1,0,1,0,-1], [0,0,0,0,0,1,1,1,0,0,0,0,0], [1,0,0,1,1,-1,-2,-1,0,0,-1,0,1], [-1,0,1,0,-1,0,1,0,-1,-1,1,1,0], [0,-1,-1,-1,0,0,0,1,1,1,0,0,0], [0,0,1,2,1,0,0,0,0,-1,-1,0,0], [1,0,-1,-1,0,0,-1,-1,0,0,0,0,1], [-1,0,1,0,-1,0,1,1,0,0,0,0,-1], [1,1,0,0,1,1,0,-1,-1,0,0,0,0], [0,-1,0,1,0,-1,-1,0,0,-1,-1,0,1], [-1,0,0,-1,0,1,1,0,0,1,1,0,-1], [1,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,1,0,-1,-1,0,0,-1,-1,0], [0,1,0,-1,-1,1,1,0,0,1,1,0,-1], [-1,-1,0,0,0,-1,0,1,1,0,0,0,0], [0,1,1,0,0,1,1,-1,-2,-1,0,0,-1], [1,0,-1,-1,-1,-1,-1,0,1,1,1,1,1], [-1,0,1,1,1,1,1,1,0,-1,-1,-1,-1], [1,1,0,-1,0,0,-1,-2,-1,1,1,0,0], [0,-1,-1,0,0,0,0,1,1,0,-1,0,0], [0,1,0,-1,0,1,1,0,0,1,1,-1,-1], [-1,0,1,0,-1,-1,0,0,-1,-1,0,1,0]]]], [ # Z-class [13][16] [[13], [-7,13], [1,-7,13], [1,1,-7,13], [-1,1,1,-7,13], [3,-1,1,1,-7,13], [-1,3,-1,1,1,-7,13], [-1,-1,3,-1,1,1,-7,13], [3,-1,-1,3,-1,1,1,-7,13], [-1,3,-1,-1,3,-1,1,1,-7,13], [1,-1,3,-1,-1,3,-1,1,1,-7,13], [1,1,-1,3,-1,-1,3,-1,1,1,-7,13], [-7,1,1,-1,3,-1,-1,3,-1,1,1,-7,13]], [[[2,2,1,0,-1,-2,-3,-2,-1,0,1,2,2], [-1,0,1,2,2,2,2,1,0,-1,-2,-3,-2], [1,0,-1,-1,-1,-1,-1,-1,-1,0,1,2,2], [1,1,1,0,0,0,0,0,0,0,0,0,0], [-2,-2,-2,-1,-1,0,1,2,2,2,1,0,-1], [2,2,2,1,0,-1,-2,-3,-2,-1,0,1,2], [0,0,0,1,1,1,1,1,0,-1,-1,-1,-1], [-1,-1,-1,-1,0,1,1,1,1,1,0,0,0], [2,1,0,-1,-2,-3,-2,-1,0,1,2,2,2], [-1,0,1,2,2,2,1,0,-1,-1,-2,-2,-2], [0,0,0,0,0,0,0,0,0,0,1,1,1], [2,2,1,0,-1,-1,-1,-1,-1,-1,-1,0,1], [-2,-3,-2,-1,0,1,2,2,2,2,1,0,-1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0], [-1,-1,-1,0,1,1,1,1,1,0,-1,-1,-1], [1,1,1,1,0,-1,-1,-1,-1,0,1,1,1], [-1,-1,-1,-1,0,1,1,1,1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,1,0,0,0], [1,0,-1,-2,-2,-2,-1,0,1,1,2,2,2], [-1,0,1,2,2,2,1,1,0,-1,-2,-2,-2], [0,0,0,0,0,0,1,0,0,0,0,0,0], [-1,-1,-1,-1,0,0,0,1,1,1,1,0,-1], [1,1,1,1,1,1,0,-1,-1,-1,-1,0,1], [-1,-1,-1,-1,-1,-1,0,1,1,1,1,1,0]]]], [ # Z-class [13][17] [[6], [1,6], [2,1,6], [2,2,1,6], [-2,2,2,1,6], [1,-2,2,2,1,6], [-2,1,-2,2,2,1,6], [-2,-2,1,-2,2,2,1,6], [1,-2,-2,1,-2,2,2,1,6], [-2,1,-2,-2,1,-2,2,2,1,6], [2,-2,1,-2,-2,1,-2,2,2,1,6], [2,2,-2,1,-2,-2,1,-2,2,2,1,6], [1,2,2,-2,1,-2,-2,1,-2,2,2,1,6]], [[[0,0,-1,0,1,0,-1,0,0,0,0,0,0], [0,0,0,0,1,-1,0,0,1,-1,0,0,0], [-1,1,0,0,0,0,-1,0,1,0,0,0,0], [0,0,0,0,1,-1,0,0,0,0,1,0,-1], [0,0,1,0,0,-1,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0], [0,-1,1,0,0,-1,1,0,0,0,0,0,0], [0,0,1,0,-1,0,0,0,0,1,-1,0,0], [0,-1,0,1,0,0,0,0,-1,1,0,0,0], [0,-1,1,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,1,-1,0,0,1,-1,0,0], [0,-1,0,0,1,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,-1,0,1,0,-1,0,0]], [[1,0,0,0,0,0,0,1,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,1,-1,0,0,0,0,1,0,-1,0,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,1,0,0,0,0,-1,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0], [1,0,0,-1,0,0,1,0,0,0,0,0,0], [0,1,-1,0,0,0,0,0,0,0,1,-1,0], [1,0,-1,0,1,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,1,0,-1,0], [0,0,-1,1,0,0,0,0,0,0,0,-1,1]]]] ]; MakeImmutable( IMFList[13].matrices ); gap-4r6p5/grp/perf8.grp0000644000175000017500000006323312172557252013476 0ustar billbill############################################################################# ## #W perf8.grp GAP Groups Library Volkmar Felsch ## Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains the perfect groups of sizes 175560-187500 ## All data is based on Holt/Plesken: Perfect Groups, OUP 1989 ## PERFGRP[152]:=[# 175560.1 [[1,"ab", function(a,b) return [[a^2,b^3,(a*b)^7,(a*b*a*b*a*b^-1)^11,(a*b*a*b*a *b^-1*a*b*a*b^-1*a*b^-1)^5], [[b,a*b^-1*a*b*a]]]; end, [266]], "J1",28,-1, 36,266] ]; PERFGRP[153]:=[# 178920.1 [[1,"abc", function(a,b,c) return [[c^35,c*b^(-1*22)*c^-1*b^-1,b^71,a^2,c*a*c*a ^-1,(b*a)^3],[[b,c]]]; end, [72],[0,3,5,3]], "L2(71)",22,-1, 37,72] ]; PERFGRP[154]:=[# 180000.1 [[2,60,1,3000,1], "( A5 x A5 ) 2^1 # 5^2",[30,2,1],1, [1,1],[5,25]] ]; PERFGRP[155]:=[# 181440.1 [[1,"ab", function(a,b) return [[a^2,b^4,(a*b)^9,(a^-1*b^-1*a*b)^4,(a*b^(-1*2) *a*b^-1*a*b*a*b^2)^3, (a*b^-1*a*b^-1*a*b^2*a*b^2*a*b*a*b)^2, (a*b*a*b*b*a*b*a*b*a*b^-1)^3, (a*b*a*b*a*b^2)^6],[[b,a*b*a*b^-1*a]]]; end, [9],[[1,2],2]], "A9",28,-1, 38,9], # 181440.2 [[2,168,1,1080,1], "L3(2) x A6 3^1",[37,0,1],3, [2,3],[7,18]], # 181440.3 [[2,360,1,504,1], "A6 x L2(8)",40,1, [3,4],[6,9]] ]; PERFGRP[156]:=[# 183456.1 [[2,168,1,1092,1], "L3(2) x L2(13)",40,1, [2,6],[7,14]] ]; PERFGRP[157]:=[# 184320.1 [[1,"abcstuvSTUVf", function(a,b,c,s,t,u,v,S,T,U,V,f) return [[a^2,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1*b^-1*c *b*c*b^-1*c*b*c^-1,f^2, f^-1*s^-1*f*s,f^-1*t^-1*f*t, f^-1*u^-1*f*u,f^-1*v^-1*f*v, f^-1*S^-1*f*S,f^-1*T^-1*f*T, f^-1*U^-1*f*U,f^-1*V^-1*f*V,s^2, t^2,u^2,v^2,S^2,T^2,U^2,V^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,S^-1*T^-1*S*T, S^-1*U^-1*S*U,S^-1*V^-1*S*V, T^-1*U^-1*T*U,T^-1*V^-1*T*V, U^-1*V^-1*U*V,s^-1*S^-1*s*S, s^-1*T^-1*s*T,s^-1*U^-1*s*U, s^-1*V^-1*s*V,t^-1*S^-1*t*S, t^-1*T^-1*t*T,t^-1*U^-1*t*U, t^-1*V^-1*t*V,u^-1*S^-1*u*S, u^-1*T^-1*u*T,u^-1*U^-1*u*U, u^-1*V^-1*u*V,v^-1*S^-1*v*S, v^-1*T^-1*v*T,v^-1*U^-1*v*U, v^-1*V^-1*v*V,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,a^-1*S*a*U^-1, a^-1*T*a*V^-1,a^-1*U*a*S^-1, a^-1*V*a*T^-1,a^-1*f*a*f^-1, b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*S*b*(T*V*f)^-1, b^-1*T*b*(S*T*U*V)^-1, b^-1*U*b*(U*V)^-1,b^-1*V*b*U^-1, b^-1*f*b*f^-1,c^-1*s*c*(t*u)^-1, c^-1*t*c*t^-1,c^-1*u*c*(s*u)^-1, c^-1*v*c*(s*t*u*v)^-1, c^-1*S*c*(T*U)^-1,c^-1*T*c*T^-1, c^-1*U*c*(S*U*f)^-1, c^-1*V*c*(S*T*U*V)^-1, c^-1*f*c*f^-1],[[b,c,S],[a,c,V,s]]]; end, [16,12]], "A6 ( 2^4 x 2^4 ) 2^1 I",[13,9,1],2, 3,[16,12]], # 184320.2 [[1,"abcstuvSTUVf", function(a,b,c,s,t,u,v,S,T,U,V,f) return [[a^2*f^-1,b^3,c^3,(b*c)^4*f^-1,(b*c^-1)^5, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,f^2, f^-1*s^-1*f*s,f^-1*t^-1*f*t, f^-1*u^-1*f*u,f^-1*v^-1*f*v, f^-1*S^-1*f*S,f^-1*T^-1*f*T, f^-1*U^-1*f*U,f^-1*V^-1*f*V,s^2, t^2,u^2,v^2,S^2,T^2,U^2,V^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,S^-1*T^-1*S*T, S^-1*U^-1*S*U,S^-1*V^-1*S*V, T^-1*U^-1*T*U,T^-1*V^-1*T*V, U^-1*V^-1*U*V,s^-1*S^-1*s*S, s^-1*T^-1*s*T,s^-1*U^-1*s*U, s^-1*V^-1*s*V,t^-1*S^-1*t*S, t^-1*T^-1*t*T,t^-1*U^-1*t*U, t^-1*V^-1*t*V,u^-1*S^-1*u*S, u^-1*T^-1*u*T,u^-1*U^-1*u*U, u^-1*V^-1*u*V,v^-1*S^-1*v*S, v^-1*T^-1*v*T,v^-1*U^-1*v*U, v^-1*V^-1*v*V,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,a^-1*S*a*U^-1, a^-1*T*a*V^-1,a^-1*U*a*S^-1, a^-1*V*a*T^-1,a^-1*f*a*f^-1, b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*S*b*(T*V*f)^-1, b^-1*T*b*(S*T*U*V)^-1, b^-1*U*b*(U*V)^-1,b^-1*V*b*U^-1, b^-1*f*b*f^-1,c^-1*s*c*(t*u)^-1, c^-1*t*c*t^-1,c^-1*u*c*(s*u)^-1, c^-1*v*c*(s*t*u*v)^-1, c^-1*S*c*(T*U)^-1,c^-1*T*c*T^-1, c^-1*U*c*(S*U*f)^-1, c^-1*V*c*(S*T*U*V)^-1, c^-1*f*c*f^-1],[[b,c,S],[c*b*a*f,b,S,s]]]; end, [16,80]], "A6 ( 2^4 x 2^4 ) 2^1 II",[13,9,2],2, 3,[16,80]], # 184320.3 [[1,"abcdstuvSTUV", function(a,b,c,d,s,t,u,v,S,T,U,V) return [[a^2*d^-1,b^3,c^3,(b*c)^4*d^-1,(b*c^-1)^5, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,d^2, b^-1*d^-1*b*d,c^-1*d^-1*c*d,s^2, t^2,u^2,v^2,S^2,T^2,U^2,V^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,S^-1*T^-1*S*T, S^-1*U^-1*S*U,S^-1*V^-1*S*V, T^-1*U^-1*T*U,T^-1*V^-1*T*V, U^-1*V^-1*U*V,s^-1*S^-1*s*S, s^-1*T^-1*s*T,s^-1*U^-1*s*U, s^-1*V^-1*s*V,t^-1*S^-1*t*S, t^-1*T^-1*t*T,t^-1*U^-1*t*U, t^-1*V^-1*t*V,u^-1*S^-1*u*S, u^-1*T^-1*u*T,u^-1*U^-1*u*U, u^-1*V^-1*u*V,v^-1*S^-1*v*S, v^-1*T^-1*v*T,v^-1*U^-1*v*U, v^-1*V^-1*v*V,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,a^-1*S*a*U^-1, a^-1*T*a*V^-1,a^-1*U*a*S^-1, a^-1*V*a*T^-1,b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*S*b*(T*V)^-1, b^-1*T*b*(S*T*U*V)^-1, b^-1*U*b*(U*V)^-1,b^-1*V*b*U^-1, c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u)^-1, c^-1*v*c*(s*t*u*v)^-1, c^-1*S*c*(T*U)^-1,c^-1*T*c*T^-1, c^-1*U*c*(S*U)^-1, c^-1*V*c*(S*T*U*V)^-1], [[b,c,S],[b,c,s],[c*b*a*d,b,s,S]]]; end, [16,16,80]], "A6 ( 2^4 x 2^4 ) 2^1 III",[13,9,3],2, 3,[16,16,80]], # 184320.4 [[1,"abcstuvSTUVg", function(a,b,c,s,t,u,v,S,T,U,V,g) return [[a^2,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1*b^-1*c *b*c*b^-1*c*b*c^-1,g^2, g^-1*s^-1*g*s,g^-1*t^-1*g*t, g^-1*u^-1*g*u,g^-1*v^-1*g*v, g^-1*S^-1*g*S,g^-1*T^-1*g*T, g^-1*U^-1*g*U,g^-1*V^-1*g*V,s^2, t^2,u^2,v^2,S^2,T^2,U^2,V^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,S^-1*T^-1*S*T, S^-1*U^-1*S*U,S^-1*V^-1*S*V, T^-1*U^-1*T*U,T^-1*V^-1*T*V, U^-1*V^-1*U*V,s^-1*S^-1*s*S, s^-1*T^-1*s*T,s^-1*U^-1*s*U *g^-1,s^-1*V^-1*s*V, t^-1*S^-1*t*S,t^-1*T^-1*t*T, t^-1*U^-1*t*U,t^-1*V^-1*t*V *g^-1,u^-1*S^-1*u*S*g^-1, u^-1*T^-1*u*T,u^-1*U^-1*u*U, u^-1*V^-1*u*V,v^-1*S^-1*v*S, v^-1*T^-1*v*T*g^-1,v^-1*U^-1*v *U,v^-1*V^-1*v*V,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,a^-1*S*a*U^-1, a^-1*T*a*V^-1,a^-1*U*a*S^-1, a^-1*V*a*T^-1,a^-1*g*a*g^-1, b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*S*b*(T*V)^-1, b^-1*T*b*(S*T*U*V)^-1, b^-1*U*b*(U*V)^-1,b^-1*V*b*U^-1, b^-1*g*b*g^-1,c^-1*s*c*(t*u)^-1, c^-1*t*c*t^-1,c^-1*u*c*(s*u)^-1, c^-1*v*c*(s*t*u*v)^-1, c^-1*S*c*(T*U)^-1,c^-1*T*c*T^-1, c^-1*U*c*(S*U)^-1, c^-1*V*c*(S*T*U*V)^-1, c^-1*g*c*g^-1],[[b,c,s]]]; end, [32]], "A6 ( 2^4 x 2^4 ) 2^1 IV",[13,9,4],2, 3,32], # 184320.5 [[1,"abcstuvSTUVg", function(a,b,c,s,t,u,v,S,T,U,V,g) return [[a^2*g^-1,b^3,c^3,(b*c)^4*g^-1,(b*c^-1)^5, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,g^2, g^-1*s^-1*g*s,g^-1*t^-1*g*t, g^-1*u^-1*g*u,g^-1*v^-1*g*v, g^-1*S^-1*g*S,g^-1*T^-1*g*T, g^-1*U^-1*g*U,g^-1*V^-1*g*V,s^2, t^2,u^2,v^2,S^2,T^2,U^2,V^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,S^-1*T^-1*S*T, S^-1*U^-1*S*U,S^-1*V^-1*S*V, T^-1*U^-1*T*U,T^-1*V^-1*T*V, U^-1*V^-1*U*V,s^-1*S^-1*s*S, s^-1*T^-1*s*T,s^-1*U^-1*s*U *g^-1,s^-1*V^-1*s*V, t^-1*S^-1*t*S,t^-1*T^-1*t*T, t^-1*U^-1*t*U,t^-1*V^-1*t*V *g^-1,u^-1*S^-1*u*S*g^-1, u^-1*T^-1*u*T,u^-1*U^-1*u*U, u^-1*V^-1*u*V,v^-1*S^-1*v*S, v^-1*T^-1*v*T*g^-1,v^-1*U^-1*v *U,v^-1*V^-1*v*V,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,a^-1*S*a*U^-1, a^-1*T*a*V^-1,a^-1*U*a*S^-1, a^-1*V*a*T^-1,a^-1*g*a*g^-1, b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*S*b*(T*V)^-1, b^-1*T*b*(S*T*U*V)^-1, b^-1*U*b*(U*V)^-1,b^-1*V*b*U^-1, b^-1*g*b*g^-1,c^-1*s*c*(t*u)^-1, c^-1*t*c*t^-1,c^-1*u*c*(s*u)^-1, c^-1*v*c*(s*t*u*v)^-1, c^-1*S*c*(T*U)^-1,c^-1*T*c*T^-1, c^-1*U*c*(S*U)^-1, c^-1*V*c*(S*T*U*V)^-1, c^-1*g*c*g^-1],[[c*b*a*g,b,s]]]; end, [1280]], "A6 ( 2^4 x 2^4 ) 2^1 V",[13,9,5],2, 3,1280], # 184320.6 [[1,"abcstuveSTUV", function(a,b,c,s,t,u,v,e,S,T,U,V) return [[a^2,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1*b^-1*c *b*c*b^-1*c*b*c^-1,e^2, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v, e^-1*S^-1*e*S,e^-1*T^-1*e*T, e^-1*U^-1*e*U,e^-1*V^-1*e*V, s^2*S^-1,t^2*T^-1,u^2*U^-1, v^2*V^-1,S^2,T^2,U^2,V^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,a^-1*e*a*e^-1, a^-1*S*a*U^-1,a^-1*T*a*V^-1, a^-1*U*a*S^-1,a^-1*V*a*T^-1, b^-1*s*b*(t*v*e*S*U)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v*U*V)^-1,b^-1*v*b*u^-1 ,b^-1*e*b*(e*U*V)^-1, b^-1*S*b*(T*V)^-1, b^-1*T*b*(S*T*U*V)^-1, b^-1*U*b*(U*V)^-1,b^-1*V*b*U^-1, c^-1*s*c*(t*u*S*T*U*V)^-1, c^-1*t*c*(t*S*T*U)^-1, c^-1*u*c*(s*u*e*S*T*U*V)^-1, c^-1*v*c*(s*t*u*v*S*T*U*V)^-1, c^-1*e*c*(e*T*U)^-1, c^-1*S*c*(T*U)^-1,c^-1*T*c*T^-1, c^-1*U*c*(S*U)^-1, c^-1*V*c*(S*T*U*V)^-1],[[c,v,e]]]; end, [480]], "A6 ( 2^4 E 2^1 E 2^4 ) A",[13,9,6],1, 3,480], # 184320.7 [[1,"abcstuvewxyz", function(a,b,c,s,t,u,v,e,w,x,y,z) return [[a^2,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1*b^-1*c *b*c*b^-1*c*b*c^-1,e^2, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v, e^-1*w^-1*e*w,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z,s^2, t^2,u^2,v^2,w^2,x^2,y^2,z^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,s^-1*w^-1*s*w, s^-1*x^-1*s*x,s^-1*y^-1*s*y, s^-1*z^-1*s*z,t^-1*w^-1*t*w, t^-1*x^-1*t*x,t^-1*y^-1*t*y, t^-1*z^-1*t*z,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,a^-1*s*a*(u*w*x)^-1, a^-1*t*a*(v*w*x)^-1, a^-1*u*a*(s*y*z)^-1, a^-1*v*a*(t*y*z)^-1,a^-1*e*a*e^-1, a^-1*w*a*y^-1,a^-1*x*a*z^-1, a^-1*y*a*w^-1,a^-1*z*a*x^-1, b^-1*s*b*(t*v*e*w*z)^-1, b^-1*t*b*(s*t*u*v*w*x*y*z)^-1, b^-1*u*b*(u*v*x)^-1, b^-1*v*b*(u*x)^-1, b^-1*e*b*(e*x*y)^-1, b^-1*w*b*(x*y)^-1,b^-1*x*b*x^-1, b^-1*y*b*(w*y)^-1, b^-1*z*b*(w*x*y*z)^-1, c^-1*s*c*(t*u*x*y)^-1, c^-1*t*c*(t*y)^-1, c^-1*u*c*(s*u*e*w*z)^-1, c^-1*v*c*(s*t*u*v*w*y)^-1, c^-1*e*c*(e*y*z)^-1, c^-1*w*c*(x*z)^-1, c^-1*x*c*(w*x*y*z)^-1, c^-1*y*c*(y*z)^-1,c^-1*z*c*y^-1], [[b,s*y*z,u,e,x*z]]]; end, [240]], "A6 2^4 E 2^1 E 2^4'",[13,9,7],1, 3,240], # 184320.8 [[1,"abcstuveSTUV", function(a,b,c,s,t,u,v,e,S,T,U,V) return [[a^2*e^-1,b^3,c^3*(S*V)^-1,(b*c)^4*(e*S)^-1 ,(b*c^-1)^5, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,e^2, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v, e^-1*S^-1*e*S,e^-1*T^-1*e*T, e^-1*U^-1*e*U,e^-1*V^-1*e*V, s^2*S^-1,t^2*T^-1,u^2*U^-1, v^2*V^-1,S^2,T^2,U^2,V^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,a^-1*e*a*e^-1, a^-1*S*a*U^-1,a^-1*T*a*V^-1, a^-1*U*a*S^-1,a^-1*V*a*T^-1, b^-1*s*b*(t*v*e*S*U)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v*U*V)^-1,b^-1*v*b*u^-1 ,b^-1*e*b*(e*U*V)^-1, b^-1*S*b*(T*V)^-1, b^-1*T*b*(S*T*U*V)^-1, b^-1*U*b*(U*V)^-1,b^-1*V*b*U^-1, c^-1*s*c*(t*u*S*T*U*V)^-1, c^-1*t*c*(t*S*T*U)^-1, c^-1*u*c*(s*u*e*S*T*U*V)^-1, c^-1*v*c*(s*t*u*v*S*T*U*V)^-1, c^-1*e*c*(e*T*U)^-1, c^-1*S*c*(T*U)^-1,c^-1*T*c*T^-1, c^-1*U*c*(S*U)^-1, c^-1*V*c*(S*T*U*V)^-1],[[c,v,e]]]; end, [480]], "A6 ( 2^4 E N 2^1 E 2^4 ) A",[13,9,8],1, 3,480], # 184320.9 [[1,"abcstuvewxyz", function(a,b,c,s,t,u,v,e,w,x,y,z) return [[a^2*e^-1,b^3*(w*x*z)^-1,c^3,(b*c)^4*(e*x*y) ^-1,(b*c^-1)^5, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,e^2, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v, e^-1*w^-1*e*w,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z,s^2, t^2,u^2,v^2,w^2,x^2,y^2,z^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,s^-1*w^-1*s*w, s^-1*x^-1*s*x,s^-1*y^-1*s*y, s^-1*z^-1*s*z,t^-1*w^-1*t*w, t^-1*x^-1*t*x,t^-1*y^-1*t*y, t^-1*z^-1*t*z,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,a^-1*s*a*(u*w*x)^-1, a^-1*t*a*(v*w*x)^-1, a^-1*u*a*(s*y*z)^-1, a^-1*v*a*(t*y*z)^-1,a^-1*e*a*e^-1, a^-1*w*a*y^-1,a^-1*x*a*z^-1, a^-1*y*a*w^-1,a^-1*z*a*x^-1, b^-1*s*b*(t*v*e*w*z)^-1, b^-1*t*b*(s*t*u*v*w*x*y*z)^-1, b^-1*u*b*(u*v*x)^-1, b^-1*v*b*(u*x)^-1, b^-1*e*b*(e*x*y)^-1, b^-1*w*b*(x*y)^-1,b^-1*x*b*x^-1, b^-1*y*b*(w*y)^-1, b^-1*z*b*(w*x*y*z)^-1, c^-1*s*c*(t*u*x*y)^-1, c^-1*t*c*(t*y)^-1, c^-1*u*c*(s*u*e*w*z)^-1, c^-1*v*c*(s*t*u*v*w*y)^-1, c^-1*e*c*(e*y*z)^-1, c^-1*w*c*(x*z)^-1, c^-1*x*c*(w*x*y*z)^-1, c^-1*y*c*(y*z)^-1,c^-1*z*c*y^-1], [[b,s*y*z,u,e,x*z]]]; end, [240]], "A6 2^4 E N 2^1 E 2^4'",[13,9,9],1, 3,240], # 184320.10 [[1,"abcstuvewxyz", function(a,b,c,s,t,u,v,e,w,x,y,z) return [[a^2,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1*b^-1*c *b*c*b^-1*c*b*c^-1,e^2, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v, e^-1*w^-1*e*w,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z,s^2, t^2,u^2,v^2,w^2,x^2,y^2,z^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,s^-1*w^-1*s*w, s^-1*x^-1*s*x,s^-1*y^-1*s*y, s^-1*z^-1*s*z,t^-1*w^-1*t*w, t^-1*x^-1*t*x,t^-1*y^-1*t*y, t^-1*z^-1*t*z,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,a^-1*w*a*y^-1, a^-1*x*a*z^-1,a^-1*y*a*w^-1, a^-1*z*a*x^-1,a^-1*e*a*e^-1, b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*(x*y)^-1,b^-1*x*b*x^-1, b^-1*y*b*(w*y)^-1, b^-1*z*b*(w*x*y*z)^-1,b^-1*e*b*e^-1 ,c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u*e)^-1, c^-1*v*c*(s*t*u*v)^-1, c^-1*w*c*(x*z)^-1, c^-1*x*c*(w*x*y*z)^-1, c^-1*y*c*(y*z)^-1,c^-1*z*c*y^-1, c^-1*e*c*e^-1],[[b,c,s],[a,c,v,w]]]; end, [16,12]], "A6 ( 2^4 x 2^4' ) 2^1 I",[13,9,10],2, 3,[16,12]], # 184320.11 [[1,"abcstuvewxyz", function(a,b,c,s,t,u,v,e,w,x,y,z) return [[a^2*e^-1,b^3,c^3,(b*c)^4*e^-1,(b*c^-1)^5, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,e^2, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v, e^-1*w^-1*e*w,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z,s^2, t^2,u^2,v^2,w^2,x^2,y^2,z^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,s^-1*w^-1*s*w, s^-1*x^-1*s*x,s^-1*y^-1*s*y, s^-1*z^-1*s*z,t^-1*w^-1*t*w, t^-1*x^-1*t*x,t^-1*y^-1*t*y, t^-1*z^-1*t*z,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,a^-1*w*a*y^-1, a^-1*x*a*z^-1,a^-1*y*a*w^-1, a^-1*z*a*x^-1,a^-1*e*a*e^-1, b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*(x*y)^-1,b^-1*x*b*x^-1, b^-1*y*b*(w*y)^-1, b^-1*z*b*(w*x*y*z)^-1,b^-1*e*b*e^-1 ,c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u*e)^-1, c^-1*v*c*(s*t*u*v)^-1, c^-1*w*c*(x*z)^-1, c^-1*x*c*(w*x*y*z)^-1, c^-1*y*c*(y*z)^-1,c^-1*z*c*y^-1, c^-1*e*c*e^-1],[[b,c,s],[c*b*a*e,b,s,z]]]; end, [16,80]], "A6 ( 2^4 x 2^4' ) 2^1 II",[13,9,11],2, 3,[16,80]], # 184320.12 [[1,"abcdstuvwxyz", function(a,b,c,d,s,t,u,v,w,x,y,z) return [[a^2*d^-1,b^3,c^3,(b*c)^4*d^-1,(b*c^-1)^5, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,d^2, b^-1*d^-1*b*d,c^-1*d^-1*c*d,s^2, t^2,u^2,v^2,w^2,x^2,y^2,z^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,s^-1*w^-1*s*w, s^-1*x^-1*s*x,s^-1*y^-1*s*y, s^-1*z^-1*s*z,t^-1*w^-1*t*w, t^-1*x^-1*t*x,t^-1*y^-1*t*y, t^-1*z^-1*t*z,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,a^-1*w*a*y^-1, a^-1*x*a*z^-1,a^-1*y*a*w^-1, a^-1*z*a*x^-1,b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*(x*y)^-1,b^-1*x*b*x^-1, b^-1*y*b*(w*y)^-1, b^-1*z*b*(w*x*y*z)^-1, c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u)^-1, c^-1*v*c*(s*t*u*v)^-1, c^-1*w*c*(x*z)^-1, c^-1*x*c*(w*x*y*z)^-1, c^-1*y*c*(y*z)^-1,c^-1*z*c*y^-1], [[b,c,s],[b,c,w],[c*b*a*d,b,s,z]]]; end, [16,16,80]], "A6 ( 2^4 x 2^4' ) 2^1 III",[13,9,12],2, 3,[16,16,80]], # 184320.13 [[1,"abcstuvewxyz", function(a,b,c,s,t,u,v,e,w,x,y,z) return [[a^2,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1*b^-1*c *b*c*b^-1*c*b*c^-1,e^2, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v, e^-1*w^-1*e*w,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z,s^2, t^2,u^2,v^2,w^2,x^2,y^2,z^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,s^-1*w^-1*s*w, s^-1*x^-1*s*x,s^-1*y^-1*s*y, s^-1*z^-1*s*z,t^-1*w^-1*t*w, t^-1*x^-1*t*x,t^-1*y^-1*t*y, t^-1*z^-1*t*z,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,a^-1*w*a*y^-1, a^-1*x*a*z^-1,a^-1*y*a*w^-1, a^-1*z*a*x^-1,a^-1*e*a*e^-1, b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*(x*y)^-1,b^-1*x*b*x^-1, b^-1*y*b*(w*y*e)^-1, b^-1*z*b*(w*x*y*z)^-1,b^-1*e*b*e^-1 ,c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u*e)^-1, c^-1*v*c*(s*t*u*v)^-1, c^-1*w*c*(x*z*e)^-1, c^-1*x*c*(w*x*y*z)^-1, c^-1*y*c*(y*z)^-1,c^-1*z*c*y^-1, c^-1*e*c*e^-1],[[c*a*b*c,b,s,w*e]]]; end, [20]], "A6 ( 2^4 x 2^4' ) 2^1 IV",[13,9,13],2, 3,20], # 184320.14 [[1,"abcstuvewxyz", function(a,b,c,s,t,u,v,e,w,x,y,z) return [[a^2*e^-1,b^3,c^3,(b*c)^4*e^-1,(b*c^-1)^5, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,e^2, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v, e^-1*w^-1*e*w,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z,s^2, t^2,u^2,v^2,w^2,x^2,y^2,z^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,s^-1*w^-1*s*w, s^-1*x^-1*s*x,s^-1*y^-1*s*y, s^-1*z^-1*s*z,t^-1*w^-1*t*w, t^-1*x^-1*t*x,t^-1*y^-1*t*y, t^-1*z^-1*t*z,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,a^-1*w*a*y^-1, a^-1*x*a*z^-1,a^-1*y*a*w^-1, a^-1*z*a*x^-1,a^-1*e*a*e^-1, b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*(x*y)^-1,b^-1*x*b*x^-1, b^-1*y*b*(w*y*e)^-1, b^-1*z*b*(w*x*y*z)^-1,b^-1*e*b*e^-1 ,c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u*e)^-1, c^-1*v*c*(s*t*u*v)^-1, c^-1*w*c*(x*z*e)^-1, c^-1*x*c*(w*x*y*z)^-1, c^-1*y*c*(y*z)^-1,c^-1*z*c*y^-1, c^-1*e*c*e^-1],[[c*b*a*e,b,s,z]]]; end, [80]], "A6 ( 2^4 x 2^4' ) 2^1 V",[13,9,14],2, 3,80], # 184320.15 [[1,"abcdstuvSTUV", function(a,b,c,d,s,t,u,v,S,T,U,V) return [[a^2*d^-1,b^3,c^3,(b*c)^4*d^-1,(b*c^-1)^5, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,d^2, b^-1*d^-1*b*d,c^-1*d^-1*c*d, s^2*S^-1,t^2*T^-1,u^2*U^-1, v^2*V^-1,S^2,T^2,U^2,V^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,d^-1*s*d*s, d^-1*t*d*t,d^-1*u*d*u,d^-1*v*d*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s,a^-1*v*a*t, a^-1*S*a*U^-1,a^-1*T*a*V^-1, a^-1*U*a*S^-1,a^-1*V*a*T^-1, b^-1*s*b*(t*v*T*U)^-1, b^-1*t*b*(s*t*u*v*T*U*V)^-1, b^-1*u*b*(u*v*U)^-1, b^-1*v*b*(u*U)^-1,b^-1*S*b*(T*V)^-1, b^-1*T*b*(S*T*U*V)^-1, b^-1*U*b*(U*V)^-1,b^-1*V*b*U^-1, c^-1*s*c*(t*u*S*T*U)^-1, c^-1*t*c*(t*S)^-1, c^-1*u*c*(s*u*S*V)^-1, c^-1*v*c*(s*t*u*v)^-1, c^-1*S*c*(T*U)^-1,c^-1*T*c*T^-1, c^-1*U*c*(S*U)^-1, c^-1*V*c*(S*T*U*V)^-1],[[b,c]]]; end, [256]], "A6 2^1 ( 2^4 x 2^4 )",[13,9,15],1, 3,256], # 184320.16 [[1,"abcdstuvSTUV", function(a,b,c,d,s,t,u,v,S,T,U,V) return [[a^2*d^-1,b^3,c^3*(S*V)^-1,(b*c)^4*(d*S)^-1 ,(b*c^-1)^5, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,d^2, b^-1*d*b*(d*U*V)^-1, c^-1*d*c*(d*T*U)^-1,s^2,t^2,u^2,v^2,S^2, T^2,U^2,V^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,S^-1*T^-1*S*T, S^-1*U^-1*S*U,S^-1*V^-1*S*V, T^-1*U^-1*T*U,T^-1*V^-1*T*V, U^-1*V^-1*U*V,s^-1*S^-1*s*S, s^-1*T^-1*s*T,s^-1*U^-1*s*U, s^-1*V^-1*s*V,t^-1*S^-1*t*S, t^-1*T^-1*t*T,t^-1*U^-1*t*U, t^-1*V^-1*t*V,u^-1*S^-1*u*S, u^-1*T^-1*u*T,u^-1*U^-1*u*U, u^-1*V^-1*u*V,v^-1*S^-1*v*S, v^-1*T^-1*v*T,v^-1*U^-1*v*U, v^-1*V^-1*v*V,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,a^-1*S*a*U^-1, a^-1*T*a*V^-1,a^-1*U*a*S^-1, a^-1*V*a*T^-1,b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*S*b*(T*V)^-1, b^-1*T*b*(S*T*U*V)^-1, b^-1*U*b*(U*V)^-1,b^-1*V*b*U^-1, c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u)^-1, c^-1*v*c*(s*t*u*v)^-1, c^-1*S*c*(T*U)^-1,c^-1*T*c*T^-1, c^-1*U*c*(S*U)^-1, c^-1*V*c*(S*T*U*V)^-1], [[b,c,S],[c*b*a*U,b,c^-1*a*c*U,T,s]]]; end, [16,80]], "A6 2^4 x ( 2^1 E 2^4 )",[13,9,16],1, 3,[16,80]], # 184320.17 [[1,"abcdstuvwxyz", function(a,b,c,d,s,t,u,v,w,x,y,z) return [[a^2*d^-1,b^3*(w*x*z)^-1,c^3,(b*c)^4*(d*x*y) ^-1,(b*c^-1)^5, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,d^2, b^-1*d*b*(d*x*y)^-1, c^-1*d*c*(d*y*z)^-1,s^2,t^2,u^2,v^2,w^2, x^2,y^2,z^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,s^-1*w^-1*s*w, s^-1*x^-1*s*x,s^-1*y^-1*s*y, s^-1*z^-1*s*z,t^-1*w^-1*t*w, t^-1*x^-1*t*x,t^-1*y^-1*t*y, t^-1*z^-1*t*z,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,a^-1*w*a*y^-1, a^-1*x*a*z^-1,a^-1*y*a*w^-1, a^-1*z*a*x^-1,b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*(x*y)^-1,b^-1*x*b*x^-1, b^-1*y*b*(w*y)^-1, b^-1*z*b*(w*x*y*z)^-1, c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u)^-1, c^-1*v*c*(s*t*u*v)^-1, c^-1*w*c*(x*z)^-1, c^-1*x*c*(w*x*y*z)^-1, c^-1*y*c*(y*z)^-1,c^-1*z*c*y^-1], [[b,c,w],[b*c*a*y,c,b^-1*a*b*z,d*z,v]]]; end, [16,80]], "A6 2^4 x ( 2^1 E 2^4' )",[13,9,17],1, 3,[16,80]], # 184320.18 [[1,"abcdstuvSTUV", function(a,b,c,d,s,t,u,v,S,T,U,V) return [[a^2*d^-1,b^3,c^3*(s*v*S*U*V)^-1,(b*c)^4*( d*s*S*T)^-1,(b*c^-1)^5, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,d^2, b^-1*d*b*(d*u*v*T*U)^-1, c^-1*d*c*(d*t*u*S)^-1,d^-1*s*d*s, d^-1*t*d*t,d^-1*u*d*u,d^-1*v*d*v, s^2*S^-1,t^2*T^-1,u^2*U^-1, v^2*V^-1,S^2,T^2,U^2,V^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s, a^-1*v*a*t,a^-1*S*a*U^-1, a^-1*T*a*V^-1,a^-1*U*a*S^-1, a^-1*V*a*T^-1,b^-1*s*b*(t*v*T*U)^-1 ,b^-1*t*b*(s*t*u*v*T*U*V)^-1, b^-1*u*b*(u*v*U)^-1, b^-1*v*b*(u*U)^-1,b^-1*S*b*(T*V)^-1, b^-1*T*b*(S*T*U*V)^-1, b^-1*U*b*(U*V)^-1,b^-1*V*b*U^-1, c^-1*s*c*(t*u*S*T*U)^-1, c^-1*t*c*(t*S)^-1, c^-1*u*c*(s*u*S*V)^-1, c^-1*v*c*(s*t*u*v)^-1, c^-1*S*c*(T*U)^-1,c^-1*T*c*T^-1, c^-1*U*c*(S*U)^-1, c^-1*V*c*(S*T*U*V)^-1],[[d,c*s*S*U,v]]]; end, [480]], "A6 2^1 E 2^4 A 2^4",[13,9,18],1, 3,480], # 184320.19 [[1,"abcdstuvwxyz", function(a,b,c,d,s,t,u,v,w,x,y,z) return [[a^2*d^-1,b^3*(w*x*z)^-1,c^3*(s*v)^-1,(b*c) ^4*(d*s*x*y)^-1,(b*c^-1)^5, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,d^2, b^-1*d*b*(d*u*v*x*y)^-1, c^-1*d*c*(d*t*u*y*z)^-1,s^2,t^2,u^2,v^2, w^2,x^2,y^2,z^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,s^-1*w^-1*s*w, s^-1*x^-1*s*x,s^-1*y^-1*s*y, s^-1*z^-1*s*z,t^-1*w^-1*t*w, t^-1*x^-1*t*x,t^-1*y^-1*t*y, t^-1*z^-1*t*z,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,a^-1*w*a*y^-1, a^-1*x*a*z^-1,a^-1*y*a*w^-1, a^-1*z*a*x^-1,b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*(x*y)^-1,b^-1*x*b*x^-1, b^-1*y*b*(w*y)^-1, b^-1*z*b*(w*x*y*z)^-1, c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u)^-1, c^-1*v*c*(s*t*u*v)^-1, c^-1*w*c*(x*z)^-1, c^-1*x*c*(w*x*y*z)^-1, c^-1*y*c*(y*z)^-1,c^-1*z*c*y^-1], [[c*b*a*u,b,c^-1*a*c*u,t,w], [b*c*a*y,c,b^-1*a*b*z,d*z,v]]]; end, [80,80]], "A6 2^1 E ( 2^4 x 2^4' )",[13,9,19],1, 3,[80,80]] ]; PERFGRP[158]:=[# 187500.1 [[1,"abvwxyz", function(a,b,v,w,x,y,z) return [[a^2,b^3,(a*b)^5,v^5,w^5,x^5,y^5,z^5,v^-1*w^-1 *v*w,v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*v*a*z^-1, a^-1*w*a*y,a^-1*x*a*x^-1, a^-1*y*a*w,a^-1*z*a*v^-1, b^-1*v*b*z^-1, b^-1*w*b*(y^-1*z)^-1, b^-1*x*b*(x*y^(-1*2)*z)^-1, b^-1*y*b*(w^-1*x^(-1*2)*y^2*z)^-1, b^-1*z*b*(v*w*x*y*z)^-1], [[a*b,b*a*b*a*b^-1*a*b^-1,w]]]; end, [30]], "A5 5^5",[3,5,1],1, 1,30] ]; ############################################################################# ## #E perf8.grp . . . . . . . . . . . . . . . . . . . . . . . . . ends here ## gap-4r6p5/grp/perf2.grp0000644000175000017500000005714712172557252013477 0ustar billbill############################################################################# ## #W perf2.grp GAP Groups Library Volkmar Felsch ## Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains the perfect groups of sizes 7800-20160 ## All data is based on Holt/Plesken: Perfect Groups, OUP 1989 ## PERFGRP[39]:=[# 7800.1 [[1,"bca", function(b,c,a) return [[b^5,c^12,c^(-1*2)*b*c^2*(b*c^-1*b^2*c)^-1, c^-1*b^2*c*b*(b*c^-1*b^2*c)^-1,a^2, c*a*c*a^-1,(b*a)^3,(c^4*b*c*b*a)^3],[[b,c]]]; end, [26]], "L2(25)",22,-1, 14,26] ]; PERFGRP[40]:=[# 7920.1 [[1,"ab", function(a,b) return [[a^2,b^4,(a*b)^11,(a*b^2)^6,a*b^-1*a*b^-1*a*b *a*b*a*b^-1*a*b*a*b^2*a *b^-1*a*b], [[a*b^-1*a*b^-1*a*b*a*b*a,b]]]; end, [11]], "M11",28,-1, 15,11] ]; PERFGRP[41]:=[# 9720.1 [[1,"abwxyz", function(a,b,w,x,y,z) return [[a^4,b^3,(a*b)^5,a^2*b*a^2*b^-1,w^3,x^3,y^3,z^3, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1], [[a*b,w],[b,a*b*a*b^-1*a,w*x^-1]]]; end, [24,15]], "A5 2^1 x 3^4'",[2,4,1],2, 1,[24,15]], # 9720.2 [[1,"abwxyz", function(a,b,w,x,y,z) return [[a^4,b^3*z^-1,(a*b)^5,a^2*b*a^2*b^-1,w^3,x^3, y^3,z^3,w^-1*x^-1*w*x,w^-1*y^-1*w*y ,w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1], [[a*b,w],[a^2,b,w*x^-1]]]; end, [24,60]], "A5 2^1 x N 3^4'",[2,4,2],2, 1,[24,60]], # 9720.3 [[1,"abstuv", function(a,b,s,t,u,v) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,s^3,t^3,u^3,v^3, s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s,a^-1*v*a*t, b^-1*s*b*(s*v^-1)^-1, b^-1*t*b*(t*u^-1*v)^-1, b^-1*u*b*u^-1,b^-1*v*b*v^-1], [[b,a*b*a*b^-1*a,u]]]; end, [45]], "A5 2^1 3^4",[2,4,3],1, 1,45], # 9720.4 (otherpres.) [[1,"abdstuv", function(a,b,d,s,t,u,v) return [[a^2*d^-1,b^3,(a*b)^5,d^2,d^-1*b^-1*d*b, s^3,t^3,u^3,v^3,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s, a^-1*v*a*t,b^-1*s*b*(s*v^-1)^-1, b^-1*t*b*(t*u^-1*v)^-1, b^-1*u*b*u^-1,b^-1*v*b*v^-1], [[b,a*b*a*b^-1*a,u]]]; end, [45]]] ]; PERFGRP[42]:=[# 9828.1 [[1,"abc", function(a,b,c) return [[c^13,b^3,(c*b)^3*c^(-1*3)*b^-1,c^(-1*4)*b*c^2*b *c*b*c*b^-1,a^2,c*a*c*a^-1,(b*a)^3], [[b,c]]]; end, [28]], "L2(27)",22,-1, 16,28] ]; PERFGRP[43]:=[# 10080.1 [[1,"abcd", function(a,b,c,d) return [[a^2,b^3,(a*b)^5,c^2,d^3,(c*d)^7,(c^-1*d^-1*c *d)^4,a^-1*c^-1*a*c,a^-1*d^-1*a*d ,b^-1*c^-1*b*c,b^-1*d^-1*b*d], [[b,a*b*a*b^-1*a,c,d],[a,b,d,c*d*c*d^-1*c]]] ; end, [5,7]], "A5 x L3(2)",[31,0,1,32],1, [1,2],[5,7]] ]; PERFGRP[44]:=[# 10752.1 [[1,"abxyzXYZ", function(a,b,x,y,z,X,Y,Z) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,x^2,y^2, z^2,x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,X^2,Y^2,Z^2, X^-1*Y^-1*X*Y,X^-1*Z^-1*X*Z, Y^-1*Z^-1*Y*Z,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,a^-1*X*a*Z^-1, a^-1*Y*a*(X*Y*Z)^-1,a^-1*Z*a*X^-1, b^-1*X*b*Y^-1,b^-1*Y*b*(X*Y)^-1, b^-1*Z*b*Z^-1,x^-1*X*x*X^-1, x^-1*Y*x*Y^-1,x^-1*Z*x*Z^-1, y^-1*X*y*X^-1,y^-1*Y*y*Y^-1, y^-1*Z*y*Z^-1,z^-1*X*z*X^-1, z^-1*Y*z*Y^-1,z^-1*Z*z*Z^-1], [[a,b,X],[a,b,x]]]; end, [8,8]], "L3(2) 2^3 x 2^3",[8,6,1],1, 2,[8,8]], # 10752.2 [[1,"abxyzXYZ", function(a,b,x,y,z,X,Y,Z) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4*(Y*Z)^-1 ,x^2,y^2,z^2,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z,X^2, Y^2,Z^2,X^-1*Y^-1*X*Y,X^-1*Z^-1*X*Z ,Y^-1*Z^-1*Y*Z,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,a^-1*X*a*Z^-1, a^-1*Y*a*(X*Y*Z)^-1,a^-1*Z*a*X^-1, b^-1*X*b*Y^-1,b^-1*Y*b*(X*Y)^-1, b^-1*Z*b*Z^-1,x^-1*X*x*X^-1, x^-1*Y*x*Y^-1,x^-1*Z*x*Z^-1, y^-1*X*y*X^-1,y^-1*Y*y*Y^-1, y^-1*Z*y*Z^-1,z^-1*X*z*X^-1, z^-1*Y*z*Y^-1,z^-1*Z*z*Z^-1], [[a,b,X],[b,a*b*a*b^-1*a,x,z,X]]]; end, [8,14]], "L3(2) 2^3 x N 2^3",[8,6,2],1, 2,[8,14]], # 10752.3 [[1,"abxyzXYZ", function(a,b,x,y,z,X,Y,Z) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,x^2*X^(-1 *1),y^2*Y^-1,z^2*Z^-1, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*x*a*(z*Y)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*X*Y*Z)^-1, b^-1*x*b*(y*X)^-1, b^-1*y*b*(x*y*Z)^-1, b^-1*z*b*(z*X*Y)^-1,a^-1*X*a*Z^-1, a^-1*Y*a*(X*Y*Z)^-1,a^-1*Z*a*X^-1, b^-1*X*b*Y^-1,b^-1*Y*b*(X*Y)^-1, b^-1*Z*b*Z^-1],[[b,a*b*a*b^-1*a,x*Z]] ]; end, [28]], "L3(2) 2^3 A 2^3",[8,6,3],1, 2,28], # 10752.4 [[1,"abxyzXYZ", function(a,b,x,y,z,X,Y,Z) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4*(y*z*X*Z) ^-1,x^2*X^-1,y^2*Y^-1,z^2*Z^-1, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*x*a*(z*Y)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*X*Y*Z)^-1, b^-1*x*b*(y*X)^-1, b^-1*y*b*(x*y*Z)^-1, b^-1*z*b*(z*X*Y)^-1,a^-1*X*a*Z^-1, a^-1*Y*a*(X*Y*Z)^-1,a^-1*Z*a*X^-1, b^-1*X*b*Y^-1,b^-1*Y*b*(X*Y)^-1, b^-1*Z*b*Z^-1], [[b,a*b*a*b*a*b^-1*a*b*a*b*a,x*Z]]]; end, [112]], "L3(2) N 2^3 A 2^3",[8,6,4],1, 2,112], # 10752.5 [[1,"abxyzuvw", function(a,b,x,y,z,u,v,w) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,u^2,v^2, w^2,u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*u*a*(v*w)^-1, a^-1*v*a*v^-1,a^-1*w*a*(u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,u^-1*x*u*x^-1, u^-1*y*u*y^-1,u^-1*z*u*z^-1, v^-1*x*v*x^-1,v^-1*y*v*y^-1, v^-1*z*v*z^-1,w^-1*x*w*x^-1, w^-1*y*w*y^-1,w^-1*z*w*z^-1], [[a,b,u],[a,b,x]]]; end, [8,8]], "L3(2) 2^3 x 2^3'",[8,6,5],1, 2,[8,8]], # 10752.6 [[1,"abxyzuvw", function(a,b,x,y,z,u,v,w) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4*(u*v*w)^(-1 *1),u^2,v^2,w^2,u^-1*v^-1*u*v, u^-1*w^-1*u*w,v^-1*w^-1*v*w,x^2, y^2,z^2,x^-1*y^-1*x*y,x^-1*z^-1*x*z ,y^-1*z^-1*y*z,a^-1*u*a*(v*w)^-1, a^-1*v*a*v^-1,a^-1*w*a*(u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,u^-1*x*u*x^-1, u^-1*y*u*y^-1,u^-1*z*u*z^-1, v^-1*x*v*x^-1,v^-1*y*v*y^-1, v^-1*z*v*z^-1,w^-1*x*w*x^-1, w^-1*y*w*y^-1,w^-1*z*w*z^-1], [[a,b,u],[b,a*b^-1*a*b*a,x,z,u]]]; end, [8,14]], "L3(2) 2^3 x N 2^3'",[8,6,6],1, 2,[8,14]], # 10752.7 [[1,"abxyzuvw", function(a,b,x,y,z,u,v,w) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4*(y*z*u*v *w)^-1,u^2,v^2,w^2,u^-1*v^-1*u*v, u^-1*w^-1*u*w,v^-1*w^-1*v*w,x^2, y^2,z^2,x^-1*y^-1*x*y,x^-1*z^-1*x*z ,y^-1*z^-1*y*z,a^-1*u*a*(v*w)^-1, a^-1*v*a*v^-1,a^-1*w*a*(u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,u^-1*x*u*x^-1, u^-1*y*u*y^-1,u^-1*z*u*z^-1, v^-1*x*v*x^-1,v^-1*y*v*y^-1, v^-1*z*v*z^-1,w^-1*x*w*x^-1, w^-1*y*w*y^-1,w^-1*z*w*z^-1], [[b,a*b*a*b^-1*a,x,u,w], [b,a*b^-1*a*b*a,x,z,u]]]; end, [14,14]], "L3(2) N 2^3 x N 2^3'",[8,6,7],1, 2,[14,14]], # 10752.8 [[1,"abxyzuvw", function(a,b,x,y,z,u,v,w) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,u^2,v^2, w^2,u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, b^-1*x*b*(y*w)^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*(z*u)^-1,a^-1*u*a*(v*w)^-1, a^-1*v*a*v^-1,a^-1*w*a*(u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,u^-1*x*u*x^-1, u^-1*y*u*y^-1,u^-1*z*u*z^-1, v^-1*x*v*x^-1,v^-1*y*v*y^-1, v^-1*z*v*z^-1,w^-1*x*w*x^-1, w^-1*y*w*y^-1,w^-1*z*w*z^-1], [[b,a*b*a*b^-1*a,x,w]]]; end, [56]], "L3(2) 2^3 E 2^3'",[8,6,8],1, 2,56], # 10752.9 [[1,"abxyzuvw", function(a,b,x,y,z,u,v,w) return [[a^2*(u*w)^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *(y*z*v)^-1,u^2,v^2,w^2,u^-1*v^-1*u*v, u^-1*w^-1*u*w,v^-1*w^-1*v*w,x^2, y^2,z^2,x^-1*y^-1*x*y,x^-1*z^-1*x*z ,y^-1*z^-1*y*z,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, b^-1*x*b*(y*w)^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*(z*u)^-1,a^-1*u*a*(v*w)^-1, a^-1*v*a*v^-1,a^-1*w*a*(u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,u^-1*x*u*x^-1, u^-1*y*u*y^-1,u^-1*z*u*z^-1, v^-1*x*v*x^-1,v^-1*y*v*y^-1, v^-1*z*v*z^-1,w^-1*x*w*x^-1, w^-1*y*w*y^-1,w^-1*z*w*z^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1*x*y*u, x*u*w]]]; end, [64]], "L3(2) N 2^3 E 2^3'",[8,6,9],1, 2,64] ]; PERFGRP[45]:=[# 11520.1 [[1,"abcstuve", function(a,b,c,s,t,u,v,e) return [[a^2,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1*b^-1*c *b*c*b^-1*c*b*c^-1,e^2, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v,s^2, t^2,u^2,v^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u*e)^-1, c^-1*v*c*(s*t*u*v)^-1],[[a,c,v]]]; end, [12]], "A6 2^4 E 2^1",[13,5,1],2, 3,12], # 11520.2 [[1,"abcstuve", function(a,b,c,s,t,u,v,e) return [[a^2*e^-1,b^3,c^3,(b*c)^4*e^-1,(b*c^-1)^5, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,e^2, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v,s^2, t^2,u^2,v^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u*e)^-1, c^-1*v*c*(s*t*u*v)^-1],[[c*b*a*e,b,s]]]; end, [80]], "A6 2^4 E N 2^1",[13,5,2],2, 3,80], # 11520.3 [[1,"abcdstuv", function(a,b,c,d,s,t,u,v) return [[a^2*d^-1,b^3,c^3,(b*c)^4*d^-1,(b*c^-1)^5, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,d^2, d^-1*b^-1*d*b,d^-1*c^-1*d*c,s^2, t^2,u^2,v^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u)^-1, c^-1*v*c*(s*t*u*v)^-1], [[b,c],[c*b*a*d,b,s]]]; end, [16,80]], "A6 2^1 x 2^4",[13,5,3],2, 3,[16,80]], # 11520.4 [[1,"abcdstuv", function(a,b,c,d,s,t,u,v) return [[a^2*d^-1,b^3,c^3*(s*v)^-1,(b*c)^4*(d*s)^-1 ,(b*c^-1)^5, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,d^2, b^-1*d*b*(d*u*v)^-1, c^-1*d*c*(d*t*u)^-1,s^2,t^2,u^2,v^2, s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u)^-1, c^-1*v*c*(s*t*u*v)^-1], [[c*b*a*u,b,c^-1*a*c*u,t]]]; end, [80]], "A6 2^1 E 2^4",[13,5,4],1, 3,80] ]; PERFGRP[46]:=[# 12144.1 [[1,"abc", function(a,b,c) return [[c^11*a^2,c*b^3*c^-1*b^-1,b^23,a^2*b^-1 *a^2*b,a^2*c^-1*a^2*c,a^4,c*a*c*a^-1, (b*a)^3],[[b,c^2]]]; end, [48]], "L2(23) 2^1 = SL(2,23)",22,-2, 13,48] ]; PERFGRP[47]:=[# 12180.1 [[1,"abc", function(a,b,c) return [[c^14,c*b^4*c^-1*b^-1,b^29,a^2,c*a*c*a^-1, (b*a)^3,c^(-1*5)*b*c^2*b*c^3*a*b^2*a*c*b^2*a], [[b,c]]]; end, [30]], "L2(29)",22,-1, 17,30] ]; PERFGRP[48]:=[# 14400.1 [[1,"abcd", function(a,b,c,d) return [[a^4,b^3,(a*b)^5,a^2*b*a^2*b^-1,c^4,d^3,(c*d)^5, c^2*d*c^2*d^-1,a^-1*c^-1*a*c, a^-1*d^-1*a*d,b^-1*c^-1*b*c, b^-1*d^-1*b*d],[[a*b,c,d],[a,b,c*d]]]; end, [24,24]], "A5 2^1 x A5 2^1",[29,2,1,30],4, [1,1],[24,24]] ]; PERFGRP[49]:=[# 14520.1 [[1,"abyz", function(a,b,y,z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,y^11,z^11,y^-1 *z^-1*y*z,a^-1*y*a*z^-1, a^-1*z*a*y, b^-1*y*b*(y^-1*z^(-1*3))^-1, b^-1*z*b*y^(-1*4)],[[a,b]]]; end, [121]], "A5 2^1 11^2",[5,2,1],1, 1,121], # 14520.2 (otherpres.) [[1,"abdyz", function(a,b,d,y,z) return [[a^2*d^-1,b^3,(a*b)^5,d^2,d^-1*b^-1*d*b, y^11,z^11,y^-1*z^-1*y*z, a^-1*y*a*z^-1,a^-1*z*a*y, b^-1*y*b*(y^-1*z^(-1*3))^-1, b^-1*z*b*y^(-1*4)],[[a,b]]]; end, [121]]] ]; PERFGRP[50]:=[# 14580.1 [[1,"abwxyzd", function(a,b,w,x,y,z,d) return [[a^2,b^3,(a*b)^5,w^3,x^3,y^3,z^3,d^3,a^-1*d*a*d ^-1,b^-1*d*b*d^-1,w^-1*d^-1*w *d,x^-1*d^-1*x*d,y^-1*d^-1*y*d, z^-1*d^-1*z*d,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*w*a*z^-1, a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1*d, b^-1*y*b*w^-1*d^-1, b^-1*z*b*z^-1*d^-1], [[a*b,b*a*b*a*b^-1*a*b^-1,w*d]]]; end, [18]], "A5 3^4' E 3^1",[2,5,1],3, 1,18] ]; PERFGRP[51]:=[# 14880.1 [[1,"abc", function(a,b,c) return [[c^15,c*b^9*c^-1*b^-1,b^31,a^2,c*a*c*a^-1, (b*a)^3],[[b,c]]]; end, [32]], "L2(31)",22,-1, 18,32] ]; PERFGRP[52]:=[# 15000.1 [[1,"abxyz", function(a,b,x,y,z) return [[a^4,b^3,(a*b)^5,a^2*b*a^2*b^-1,x^5,y^5,z^5,x ^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*x*a*z^-1, a^-1*y*a*y,a^-1*z*a*x^-1, b^-1*x*b*z^-1, b^-1*y*b*(y^-1*z)^-1, b^-1*z*b*(x*y^(-1*2)*z)^-1], [[a*b,x],[a*b,b*a*b*a*b^-1*a*b^-1,y]]]; end, [24,30]], "A5 2^1 x 5^3",[3,3,1],2, 1,[24,30]], # 15000.2 [[1,"abxyz", function(a,b,x,y,z) return [[a^4,b^3,a^2*b*a^2*b^-1,(a*b)^5*z^-1,x^5,y^5, z^5,x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*x*a*z^-1, a^-1*y*a*y,a^-1*z*a*x^-1, b^-1*x*b*z^-1, b^-1*y*b*(y^-1*z)^-1, b^-1*z*b*(x*y^(-1*2)*z)^-1], [[a*b,x],[a*b,b*a*b*a*b^-1*a*b^-1,y]]]; end, [24,30]], "A5 2^1 x N 5^3",[3,3,2],2, 1,[24,30]], # 15000.3 [[1,"abyzd", function(a,b,y,z,d) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,y^5,z^5,d^5,y ^-1*d^-1*y*d,z^-1*d^-1*z*d, y^-1*z^-1*y*z*d^-1, a^-1*y*a*z^-1*d^(-1*2),a^-1*z*a*y, a^-1*d*a*d^-1,b^-1*y*b*z, b^-1*z*b*(y*z^-1)^-1, b^-1*d*b*d^-1],[[a,b]]]; end, [125]], "A5 2^1 5^2 C 5^1",[3,3,3],5, 1,125], # 15000.4 (otherpres.) [[1,"abDyzd", function(a,b,D,y,z,d) return [[a^2*D^-1,b^3,(a*b)^5,D^2,D^-1*b^-1*D*b, y^5,z^5,d^5,y^-1*d^-1*y*d, z^-1*d^-1*z*d,y^-1*z^-1*y*z *d^-1,a^-1*y*a*z^-1*d^(-1*2), a^-1*z*a*y,a^-1*d*a*d^-1, b^-1*y*b*z,b^-1*z*b*(y*z^-1)^-1, b^-1*d*b*d^-1],[[a,b]]]; end, [125]]] ]; PERFGRP[53]:=[# 15120.1 [[1,"abd", function(a,b,d) return [[a^6*d,b^4*d,(a*b)^7,(a*b)^2*a*b^2*(a*b*a*b^-1) ^2*(a*b)^2*(a*b^-1)^2*a*b*a *b^-1*a^2*d,a^2*d*b*a^(-1*2)*d*b^-1, d^2,d*a*d*a^-1,d*b*d*b^-1], [[a^3,(b^-1*a)^2*(b*a)^2*b^2*a*b*a^4,d], [a*b,b*a*b*a*b^2*a*b^-1*a*b*a*b^-1*a*b *a*b^2*d,a^2*d]]]; end, [45,240]], "A7 3^1 x 2^1",[23,1,1],-6, 8,[45,240]] ]; PERFGRP[54]:=[# 15360.1 [[1,"abstuvef", function(a,b,s,t,u,v,e,f) return [[a^2,b^3,(a*b)^5,e^4,f^4,e^-1*a^-1*e*a,e^(-1 *1)*b^-1*e*b,e^-1*s^-1*e*s, e^-1*t^-1*e*t,e^-1*u^-1*e*u, e^-1*v^-1*e*v,e^-1*f^-1*e*f, f^-1*a^-1*f*a,f^-1*b^-1*f*b, f^-1*s^-1*f*s,f^-1*t^-1*f*t, f^-1*u^-1*f*u,f^-1*v^-1*f*v,s^2, t^2,u^2,v^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u*e^2,s^-1*v^-1*s*v *f^2,t^-1*u^-1*t*u*f^2, t^-1*v^-1*t*v*e^2*f^2,u^-1*v^-1*u *v,a^-1*s*a*u^-1*f^2, a^-1*t*a*v^-1,a^-1*u*a*s^-1*f^2, a^-1*v*a*t^-1, b^-1*s*b*(t*v*e*f^-1)^-1, b^-1*t*b*(s*t*u*v*f)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1 *f^2],[[a,b,e],[a,b,f]]]; end, [64,64]], "A5 ( 2^4 E ( 2^1 A x 2^1 A ) ) C ( 2^1 x 2^1 )",[1,8,1],16, 1,[64,64]], # 15360.2 [[1,"abdstuvef", function(a,b,d,s,t,u,v,e,f) return [[a^2*d,b^3,(a*b)^5,d^2,d^-1*b^-1*d*b,e^4,f^2, d^-1*a^-1*d*a,d^-1*s^-1*d*s, d^-1*t^-1*d*t,d^-1*u^-1*d*u, d^-1*v^-1*d*v,d^-1*e^-1*d*e, d^-1*f^-1*d*f,e^-1*a^-1*e*a, e^-1*b^-1*e*b,e^-1*s^-1*e*s, e^-1*t^-1*e*t,e^-1*u^-1*e*u, e^-1*v^-1*e*v,e^-1*f^-1*e*f, f^-1*a^-1*f*a,f^-1*b^-1*f*b, f^-1*s^-1*f*s,f^-1*t^-1*f*t, f^-1*u^-1*f*u,f^-1*v^-1*f*v,s^2, t^2,u^2,v^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u*e^2,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v*e^2, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1, b^-1*s*b*(t*v*e*f^-1)^-1, b^-1*t*b*(s*t*u*v*f)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1], [[a*b,s,e,f],[a*b,b*a*b*a*b^-1*a*b^-1,s*f,e] ,[a,b,f]]]; end, [24,12,64]], "A5 2^1 x ( 2^4 E ( 2^1 A x 2^1 ) ) C 2^1",[1,8,2],16, 1,[24,12,64]], # 15360.3 [[1,"abstuvSTUV", function(a,b,s,t,u,v,S,T,U,V) return [[a^2,b^3,(a*b)^5,s^2,t^2,u^2,v^2,s^-1*t^-1*s *t,u^-1*v^-1*u*v,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, S^2,T^2,U^2,V^2,S^-1*T^-1*S*T, S^-1*U^-1*S*U,S^-1*V^-1*S*V, T^-1*U^-1*T*U,T^-1*V^-1*T*V, U^-1*V^-1*U*V,a^-1*S*a*U^-1, a^-1*T*a*V^-1,a^-1*U*a*S^-1, a^-1*V*a*T^-1,b^-1*S*b*(T*V)^-1, b^-1*T*b*(S*T*U*V)^-1, b^-1*U*b*(U*V)^-1,b^-1*V*b*U^-1, s^-1*S*s*S^-1,s^-1*T*s*T^-1, s^-1*U*s*U^-1,s^-1*V*s*V^-1, t^-1*S*t*S^-1,t^-1*T*t*T^-1, t^-1*U*t*U^-1,t^-1*V*t*V^-1, u^-1*S*u*S^-1,u^-1*T*u*T^-1, u^-1*U*u*U^-1,u^-1*V*u*V^-1, v^-1*S*v*S^-1,v^-1*T*v*T^-1, v^-1*U*v*U^-1,v^-1*V*v*V^-1], [[a,b,S],[a,b,s]]]; end, [16,16]], "A5 2^4 x 2^4",[1,8,3],1, 1,[16,16]], # 15360.4 [[1,"abstuvwxyz", function(a,b,s,t,u,v,w,x,y,z) return [[a^2,b^3,(a*b)^5,w^2,w*s^-1*w*s,w*t^-1*w*t, w*u^-1*w*u,w*v^-1*w*v,s^2*w,t^2*w,u^2*z, v^2*z,s^-1*t^-1*s*t*w, s^-1*u^-1*s*u*w*x*z, s^-1*v^-1*s*v*x*y, t^-1*u^-1*t*u*w*y*z, t^-1*v^-1*t*v*w*x*z,u^-1*v^-1*u*v *z,a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, a^-1*w*a*z,a^-1*x*a*x,a^-1*y*a*w*x*y *z,a^-1*z*a*w,b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v*y*z)^-1, b^-1*u*b*(u*v*w*x*y)^-1, b^-1*v*b*u^-1,b^-1*w*b*x, b^-1*x*b*y,b^-1*y*b*w,b^-1*z*b*z], [[b,a*b*a*b^-1*a,v*w,w*x]]]; end, [40]], "A5 2^4 C 2^4'",[1,8,4],1, 1,40], # 15360.5 [[1,"abstuvwxyz", function(a,b,s,t,u,v,w,x,y,z) return [[a^2,b^3,(a*b)^5,w^2,x^2,y^2,z^2,w^-1*x^-1*w *x,w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*w*a*z^-1, a^-1*x*a*x^-1,a^-1*y*a*(w*x*y*z)^-1 ,a^-1*z*a*w^-1,b^-1*w*b*x^-1, b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1,s^2,t^2,u^2,v^2, s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, w^-1*s*w*s^-1,w^-1*t*w*t^-1, w^-1*u*w*u^-1,w^-1*v*w*v^-1, x^-1*s*x*s^-1,x^-1*t*x*t^-1, x^-1*u*x*u^-1,x^-1*v*x*v^-1, y^-1*s*y*s^-1,y^-1*t*y*t^-1, y^-1*u*y*u^-1,y^-1*v*y*v^-1, z^-1*s*z*s^-1,z^-1*t*z*t^-1, z^-1*u*z*u^-1,z^-1*v*z*v^-1], [[a,b,w],[a*b*a*b^-1*a,b,w*x,s]]]; end, [16,10]], "A5 2^4 x 2^4'",[1,8,5],1, 1,[16,10]], # 15360.6 [[1,"abwxyzWXYZ", function(a,b,w,x,y,z,W,X,Y,Z) return [[a^2,b^3,(a*b)^5,w^2,x^2,y^2,z^2,w^-1*x^-1*w *x,w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*w*a*z^-1, a^-1*x*a*x^-1,a^-1*y*a*(w*x*y*z)^-1 ,a^-1*z*a*w^-1,b^-1*w*b*x^-1, b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1,W^2,X^2,Y^2,Z^2, W^-1*X^-1*W*X,W^-1*Y^-1*W*Y, W^-1*Z^-1*W*Z,X^-1*Y^-1*X*Y, X^-1*Z^-1*X*Z,Y^-1*Z^-1*Y*Z, a^-1*W*a*Z^-1,a^-1*X*a*X^-1, a^-1*Y*a*(W*X*Y*Z)^-1,a^-1*Z*a*W^-1 ,b^-1*W*b*X^-1,b^-1*X*b*Y^-1, b^-1*Y*b*W^-1,b^-1*Z*b*Z^-1, w^-1*W*w*W^-1,w^-1*X*w*X^-1, w^-1*Y*w*Y^-1,w^-1*Z*w*Z^-1, x^-1*W*x*W^-1,x^-1*X*x*X^-1, x^-1*Y*x*Y^-1,x^-1*Z*x*Z^-1, y^-1*W*y*W^-1,y^-1*X*y*X^-1, y^-1*Y*y*Y^-1,y^-1*Z*y*Z^-1, z^-1*W*z*W^-1,z^-1*X*z*X^-1, z^-1*Y*z*Y^-1,z^-1*Z*z*Z^-1], [[a*b*a*b^-1*a,b,w*x,W], [a*b*a*b^-1*a,b,W*X,w]]]; end, [10,10]], "A5 2^4' x 2^4'",[1,8,6],1, 1,[10,10]], # 15360.7 [[1,"abwxyzWXYZ", function(a,b,w,x,y,z,W,X,Y,Z) return [[a^2,b^3,(a*b)^5,w^2*W^-1,x^2*X^-1,y^2*Y^(-1 *1),z^2*Z^-1,W^2,X^2,Y^2,Z^2, w*x*w^-1*x^-1,w*y*w^-1*y^-1, w*z*w^-1*z^-1,x*y*x^-1*y^-1, x*z*x^-1*z^-1,y*z*y^-1*z^-1, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*x*y*z*W*X*Y*Z)^-1, a^-1*z*a*w^-1,b^-1*w*b*x^-1, b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1], [[a*b*a*b^-1*a,b,w*x^-1]]]; end, [20]], "A5 2^4' A 2^4'",[1,8,7],1, 1,20] ]; PERFGRP[55]:=[# 15600.1 [[1,"bca", function(b,c,a) return [[b^5,c^12*a^2,a^4,a^2*b^-1*a^2*b,a^2*c^-1 *a^2*c,c*a*c*a^-1,(b*a)^3,(c^4*b*c*b*a)^3, c^(-1*2)*b*c^2*(b*c^-1*b^2*c)^-1, c^-1*b^2*c*b*(b*c^-1*b^2*c)^-1], [[b,c^8]]]; end, [208]], "L2(25) 2^1 = SL(2,25)",22,-2, 14,208] ]; PERFGRP[56]:=[# 16464.1 [[1,"abyz", function(a,b,y,z) return [[a^4,b^3,(a*b)^7,a^2*b^-1*a^2*b,(a^-1*b^-1 *a*b)^4*a^2,y^7,z^7,y^-1*z^-1*y*z, a^-1*y*a*z,a^-1*z*a*y^-1, b^-1*y*b*z^-1, b^-1*z*b*(y^-1*z^-1)^-1],[[a,b]]]; end, [49]], "L3(2) 2^1 7^2",[10,2,1],1, 2,49], # 16464.2 (otherpres.) [[1,"abdyz", function(a,b,d,y,z) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *d^-1,d^2,d^-1*b^-1*d*b,y^7,z^7, y^-1*z^-1*y*z,a^-1*y*a*z, a^-1*z*a*y^-1,b^-1*y*b*z^-1, b^-1*z*b*(y^-1*z^-1)^-1],[[a,b]]]; end, [49]]] ]; PERFGRP[57]:=[# 17280.1 [[1,"abcstuv", function(a,b,c,s,t,u,v) return [[b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1*b^-1*c*b *c*b^-1*c*b*c^-1,s^2,t^2,u^2,v^2, s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u)^-1, c^-1*v*c*(s*t*u*v)^-1], [[a^3,c*a^2,s],[b,c]]]; end, [18,16]], "A6 3^1 x 2^4",[13,4,1],3, 3,[18,16]] ]; PERFGRP[58]:=[# 19656.1 [[1,"abc", function(a,b,c) return [[c^13*a^2,b^3,(c*b)^3*c^(-1*3)*b^-1,c^(-1*4)*b*c ^2*b*c*b*c*b^-1,a^4, a^2*b^-1*a^2*b,a^2*c^-1*a^2*c, c*a*c*a^-1,(b*a)^3],[[b,c^2]]]; end, [56]], "L2(27) 2^1 = SL(2,27)",22,-2, 16,56] ]; PERFGRP[59]:=[# 20160.1 [[1,"abcd", function(a,b,c,d) return [[a^2,b^3,(a*b)^5,c^4,d^3,(c*d)^7,(c^-1*d^-1*c *d)^4*c^2,c^2*d*c^2*d^-1, a^-1*c^-1*a*c,a^-1*d^-1*a*d, b^-1*c^-1*b*c,b^-1*d^-1*b*d], [[b,a*b*a*b^-1*a,c,d], [a,b,c*d,d*c*d^-1*c*d^-1*c*d*c*d^-1]] ]; end, [5,16]], "A5 x L3(2) 2^1",[31,1,1,32],2, [1,2],[5,16]], # 20160.2 [[1,"abcd", function(a,b,c,d) return [[a^4,b^3,(a*b)^5,a^2*b*a^2*b^-1,c^2,d^3,(c*d)^7, (c^-1*d^-1*c*d)^4,a^-1*c^-1*a*c, a^-1*d^-1*a*d,b^-1*c^-1*b*c, b^-1*d^-1*b*d], [[a*b,c,d],[a,b,d,c*d*c*d^-1*c]]]; end, [24,7]], "A5 2^1 x L3(2)",[31,1,2,32],2, [1,2],[24,7]], # 20160.3 [[1,"abcd", function(a,b,c,d) return [[a^4,b^3,(a*b)^5,c^2*a^2,d^3,(c*d)^7,(c^-1*d^(-1 *1)*c*d)^4*c^2,a^-1*c^-1*a*c, a^-1*d^-1*a*d,b^-1*c^-1*b*c, b^-1*d^-1*b*d], [[a*b,c*d,d*c*d^-1*c*d^-1*c*d*c*d^-1]]] ; end, [192]], "( A5 x L3(2) ) 2^1",[31,1,3],2, [1,2],192], # 20160.4 [[1,"ab", function(a,b) return [[a^2,b^4,(a*b)^15,(a*b^2)^6,(a*b)^2*(a*b^-1*a*b^2) ^2*a*b^-1*(a*b)^2*(a*b^-1)^7, a*b*a*b^-1*a*b*a*b^2*(a*b^-1)^5*a*b^2 *(a*b^-1)^5*a*b^2], [[a,b^-1*(a*b*b)^2]]]; end, [8]], "A8",[26,0,1],-1, 19,8], # 20160.5 [[1,"ab", function(a,b) return [[a^2,b^4,(a*b)^7,(a*b^2)^5,(a^-1*b^-1*a*b)^5, (a*b*a*b*a*b^3)^5,(a*b*a*b*a*b^2*a*b^-1)^5], [[a*b*a,b^2*a*b^-1*a*b*a*b^2*a*b]]]; end, [21]], "L3(4)",[27,0,1],-1, 20,21] ]; ############################################################################# ## #E perf2.grp . . . . . . . . . . . . . . . . . . . . . . . . . ends here ## gap-4r6p5/grp/basic.gd0000644000175000017500000004461412172557252013337 0ustar billbill############################################################################# ## #W basic.gd GAP Library Frank Celler ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains the operations for the construction of the basic group ## types. ## ############################################################################# ## ## <#GAPDoc Label="[1]{basic}"> ## There are several infinite families of groups which are parametrized by ## numbers. ## &GAP; provides various functions to construct these groups. ## The functions always permit (but do not require) one to indicate ## a filter (see ), ## for example , or ## , in which the group shall be constructed. ## There always is a default filter corresponding to a natural way ## to describe the group in question. ## Note that not every group can be constructed in every filter, ## there may be theoretical restrictions ( only works ## for solvable groups) or methods may be available only for a few filters. ##

## Certain filters may admit additional hints. ## For example, groups constructed in may be ## constructed over a specified field, which can be given as second argument ## of the function that constructs the group; ## The default field is . ## <#/GAPDoc> ############################################################################# ## #O TrivialGroupCons( ) ## ## ## ## ## ## ## ## DeclareConstructor( "TrivialGroupCons", [ IsGroup ] ); ############################################################################# ## #F TrivialGroup( [] ) . . . . . . . . . . . . . . . . trivial group ## ## <#GAPDoc Label="TrivialGroup"> ## ## ## ## ## constructs a trivial group in the category given by the filter ## filter. ## If filter is not given it defaults to . ##

## TrivialGroup(); ## ## gap> TrivialGroup( IsPermGroup ); ## Group(()) ## ]]> ## ## ## <#/GAPDoc> ## BindGlobal( "TrivialGroup", function( arg ) if Length( arg ) = 0 then return TrivialGroupCons( IsPcGroup ); elif IsFilter( arg[1] ) and Length( arg ) = 1 then return TrivialGroupCons( arg[1] ); fi; Error( "usage: TrivialGroup( [] )" ); end ); ############################################################################# ## #O AbelianGroupCons( , ) ## ## ## ## ## ## ## ## DeclareConstructor( "AbelianGroupCons", [ IsGroup, IsList ] ); ############################################################################# ## #F AbelianGroup( [, ] ) . . . . . . . . . . . . . abelian group ## ## <#GAPDoc Label="AbelianGroup"> ## ## ## ## ## constructs an abelian group in the category given by the filter ## filt which is of isomorphism type ## C_{{ints[1]}} \times C_{{ints[2]}} \times \ldots ## \times C_{{ints[n]}}, ## where ints must be a list of positive integers. ## If filt is not given it defaults to . ## The generators of the group returned are the elements corresponding to ## the integers in ints. ##

## AbelianGroup([1,2,3]); ## ## ]]> ## ## ## <#/GAPDoc> ## BindGlobal( "AbelianGroup", function ( arg ) if Length(arg) = 1 then if ForAny(arg[1],x->x=0) then return AbelianGroupCons( IsFpGroup, arg[1] ); fi; return AbelianGroupCons( IsPcGroup, arg[1] ); elif IsOperation(arg[1]) then if Length(arg) = 2 then return AbelianGroupCons( arg[1], arg[2] ); elif Length(arg) = 3 then return AbelianGroupCons( arg[1], arg[2], arg[3] ); fi; fi; Error( "usage: AbelianGroup( [, ] )" ); end ); ############################################################################# ## #O AlternatingGroupCons( , ) ## ## ## ## ## ## ## ## DeclareConstructor( "AlternatingGroupCons", [ IsGroup, IsInt ] ); ############################################################################# ## #F AlternatingGroup( [, ] ) . . . . . . . . . . alternating group #F AlternatingGroup( [, ] ) . . . . . . . . . . alternating group ## ## <#GAPDoc Label="AlternatingGroup"> ## ## AlternatingGroup ## ## ## ## ## constructs the alternating group of degree deg in the category given ## by the filter filt. ## If filt is not given it defaults to . ## In the second version, the function constructs the alternating group on ## the points given in the set dom which must be a set of positive ## integers. ## AlternatingGroup(5); ## Alt( [ 1 .. 5 ] ) ## ]]> ## ## ## <#/GAPDoc> ## BindGlobal( "AlternatingGroup", function ( arg ) if Length(arg) = 1 then return AlternatingGroupCons( IsPermGroup, arg[1] ); elif IsOperation(arg[1]) then if Length(arg) = 2 then return AlternatingGroupCons( arg[1], arg[2] ); fi; fi; Error( "usage: AlternatingGroup( [, ] )" ); end ); ############################################################################# ## #O CyclicGroupCons( , ) ## ## ## ## ## ## ## ## DeclareConstructor( "CyclicGroupCons", [ IsGroup, IsInt ] ); ############################################################################# ## #F CyclicGroup( [, ] ) . . . . . . . . . . . . . . . cyclic group ## ## <#GAPDoc Label="CyclicGroup"> ## ## ## ## ## constructs the cyclic group of size n in the category given by the ## filter filt. ## If filt is not given it defaults to . ##

## CyclicGroup(12); ## ## gap> CyclicGroup(IsPermGroup,12); ## Group([ (1,2,3,4,5,6,7,8,9,10,11,12) ]) ## gap> matgrp1:= CyclicGroup( IsMatrixGroup, 12 ); ## ## gap> FieldOfMatrixGroup( matgrp1 ); ## Rationals ## gap> matgrp2:= CyclicGroup( IsMatrixGroup, GF(2), 12 ); ## ## gap> FieldOfMatrixGroup( matgrp2 ); ## GF(2) ## ]]> ## ## ## <#/GAPDoc> ## BindGlobal( "CyclicGroup", function ( arg ) if Length(arg) = 1 then if arg[1]=infinity then return CyclicGroupCons(IsFpGroup,arg[1]); fi; return CyclicGroupCons( IsPcGroup, arg[1] ); elif IsOperation(arg[1]) then if Length(arg) = 2 then return CyclicGroupCons( arg[1], arg[2] ); elif Length(arg) = 3 then return CyclicGroupCons( arg[1], arg[2], arg[3] ); fi; fi; Error( "usage: CyclicGroup( [, ] )" ); end ); ############################################################################# ## #O DihedralGroupCons( , ) ## ## ## ## ## ## ## ## DeclareConstructor( "DihedralGroupCons", [ IsGroup, IsInt ] ); ############################################################################# ## #F DihedralGroup( [, ] ) . . . . . . . dihedral group of order ## ## <#GAPDoc Label="DihedralGroup"> ## ## ## ## ## constructs the dihedral group of size n in the category given by the ## filter filt. ## If filt is not given it defaults to . ##

## DihedralGroup(10); ## ## ]]> ## ## ## <#/GAPDoc> ## BindGlobal( "DihedralGroup", function ( arg ) if Length(arg) = 1 then return DihedralGroupCons( IsPcGroup, arg[1] ); elif IsOperation(arg[1]) then if Length(arg) = 2 then return DihedralGroupCons( arg[1], arg[2] ); elif Length(arg) = 3 then return DihedralGroupCons( arg[1], arg[2], arg[3] ); fi; fi; Error( "usage: DihedralGroup( [, ] )" ); end ); ############################################################################# ## #O QuaternionGroupCons( , ) ## ## ## ## ## ## ## ## DeclareConstructor( "QuaternionGroupCons", [ IsGroup, IsInt ] ); ############################################################################# ## #F QuaternionGroup( [, ] ) . . . . . . . quaternion group of order ## ## <#GAPDoc Label="QuaternionGroup"> ## ## ## ## ## ## constructs the generalized quaternion group (or dicyclic group) of size ## n in the category given by the filter filt. Here, n ## is a multiple of 4. ## If filt is not given it defaults to . ## Methods are also available for permutation and matrix groups (of minimal ## degree and minimal dimension in coprime characteristic). ##

## QuaternionGroup(32); ## ## gap> g:=QuaternionGroup(IsMatrixGroup,CF(16),32); ## Group([ [ [ 0, 1 ], [ -1, 0 ] ], [ [ E(16), 0 ], [ 0, -E(16)^7 ] ] ]) ## ]]> ## ## ## <#/GAPDoc> ## BindGlobal( "QuaternionGroup", function ( arg ) if Length(arg) = 1 then return QuaternionGroupCons( IsPcGroup, arg[1] ); elif IsOperation(arg[1]) then if Length(arg) = 2 then return QuaternionGroupCons( arg[1], arg[2] ); elif Length(arg) = 3 then return QuaternionGroupCons( arg[1], arg[2], arg[3] ); fi; fi; Error( "usage: QuaternionGroup( [, ] )" ); end ); DeclareSynonym( "DicyclicGroup", QuaternionGroup ); ############################################################################# ## #O ElementaryAbelianGroupCons( , ) ## ## ## ## ## ## ## ## DeclareConstructor( "ElementaryAbelianGroupCons", [ IsGroup, IsInt ] ); ############################################################################# ## #F ElementaryAbelianGroup( [, ] ) . . . . elementary abelian group ## ## <#GAPDoc Label="ElementaryAbelianGroup"> ## ## ## ## ## constructs the elementary abelian group of size n in the category ## given by the filter filt. ## If filt is not given it defaults to . ##

## ElementaryAbelianGroup(8192); ## ## ]]> ## ## ## <#/GAPDoc> ## BindGlobal( "ElementaryAbelianGroup", function ( arg ) if Length(arg) = 1 then return ElementaryAbelianGroupCons( IsPcGroup, arg[1] ); elif IsOperation(arg[1]) then if Length(arg) = 2 then return ElementaryAbelianGroupCons( arg[1], arg[2] ); elif Length(arg) = 3 then return ElementaryAbelianGroupCons( arg[1], arg[2], arg[3] ); fi; fi; Error( "usage: ElementaryAbelianGroup( [, ] )" ); end ); ############################################################################# ## #O ExtraspecialGroupCons( , , ) ## ## ## ## ## ## ## ## DeclareConstructor( "ExtraspecialGroupCons", [ IsGroup, IsInt, IsObject ] ); ############################################################################# ## #F ExtraspecialGroup( [, ], ) . . . . extraspecial group ## ## <#GAPDoc Label="ExtraspecialGroup"> ## ## ## ## ## Let order be of the form p^{{2n+1}}, for a prime integer ## p and a positive integer n. ## returns the extraspecial group of order ## order that is determined by exp, ## in the category given by the filter filt. ##

## If p is odd then admissible values of exp are the exponent ## of the group (either p or p^2) or one of '+', ## "+", '-', "-". ## For p = 2, only the above plus or minus signs are admissible. ##

## If filt is not given it defaults to . ##

## ExtraspecialGroup( 27, 3 ); ## ## gap> ExtraspecialGroup( 27, '+' ); ## ## gap> ExtraspecialGroup( 8, "-" ); ## ## ]]> ## ## ## <#/GAPDoc> ## BindGlobal( "ExtraspecialGroup", function ( arg ) if Length(arg) = 2 then return ExtraspecialGroupCons( IsPcGroup, arg[1], arg[2] ); elif IsOperation(arg[1]) then if Length(arg) = 3 then return ExtraspecialGroupCons( arg[1], arg[2], arg[3] ); elif Length(arg) = 4 then return ExtraspecialGroupCons( arg[1], arg[2], arg[3], arg[4] ); fi; fi; Error( "usage: ExtraspecialGroup( [, ], )" ); end ); ############################################################################# ## #O MathieuGroupCons( , ) ## ## ## ## ## ## ## ## DeclareConstructor( "MathieuGroupCons", [ IsGroup, IsInt ] ); ############################################################################# ## #F MathieuGroup( [, ] ) . . . . . . . . . . . . Mathieu group ## ## <#GAPDoc Label="MathieuGroup"> ## ## ## ## ## constructs the Mathieu group of degree degree in the category ## given by the filter filt, where degree must be in the set ## \{ 9, 10, 11, 12, 21, 22, 23, 24 \}. ## If filt is not given it defaults to . ##

## MathieuGroup( 11 ); ## Group([ (1,2,3,4,5,6,7,8,9,10,11), (3,7,11,8)(4,10,5,6) ]) ## ]]> ## ## ## <#/GAPDoc> ## BindGlobal( "MathieuGroup", function( arg ) if Length( arg ) = 1 then return MathieuGroupCons( IsPermGroup, arg[1] ); elif IsOperation( arg[1] ) then if Length( arg ) = 2 then return MathieuGroupCons( arg[1], arg[2] ); elif Length( arg ) = 3 then return MathieuGroupCons( arg[1], arg[2], arg[3] ); fi; fi; Error( "usage: MathieuGroup( [, ] )" ); end ); ############################################################################# ## #O SymmetricGroupCons( , ) ## ## ## ## ## ## ## ## DeclareConstructor( "SymmetricGroupCons", [ IsGroup, IsInt ] ); ############################################################################# ## #F SymmetricGroup( [, ] ) #F SymmetricGroup( [, ] ) ## ## <#GAPDoc Label="SymmetricGroup"> ## ## SymmetricGroup ## ## ## ## ## constructs the symmetric group of degree deg in the category ## given by the filter filt. ## If filt is not given it defaults to . ## In the second version, the function constructs the symmetric group on ## the points given in the set dom which must be a set of positive ## integers. ##

## SymmetricGroup(10); ## Sym( [ 1 .. 10 ] ) ## ]]> ##

## Note that permutation groups provide special treatment of symmetric and ## alternating groups, ## see . ## ## ## <#/GAPDoc> ## BindGlobal( "SymmetricGroup", function ( arg ) if Length(arg) = 1 then return SymmetricGroupCons( IsPermGroup, arg[1] ); elif IsOperation(arg[1]) then if Length(arg) = 2 then return SymmetricGroupCons( arg[1], arg[2] ); fi; fi; Error( "usage: SymmetricGroup( [, ] )" ); end ); BIND_GLOBAL("PermConstructor",function(oper,filter,use) local val, i; val:=0; # force value 0 (unless offset). for i in filter do # when completing, `RankFilter' is redefined. Thus we must use # SIZE_FLAGS. val:=val-SIZE_FLAGS(WITH_HIDDEN_IMPS_FLAGS(FLAGS_FILTER(i))); od; InstallOtherMethod( oper, "convert to permgroup", filter, val, function(arg) local argc,g,h; argc:=ShallowCopy(arg); argc[1]:=use; g:=CallFuncList(oper,argc); h:=Image(IsomorphismPermGroup(g),g); if HasName(g) then SetName(h,Concatenation("Perm_",Name(g))); fi; if HasSize(g) then SetSize(h,Size(g)); fi; return h; end); end); ############################################################################# ## #E gap-4r6p5/grp/simple.gd0000644000175000017500000000704312172557252013542 0ustar billbill############################################################################# ## #W simple.gd GAP Library Alexander Hulpke ## ## #Y Copyright (C) 2011 The GAP Group ## ## This file contains basic constructions for simple groups of bounded size, ## if necessary by calling the `atlasrep' package. ## ############################################################################# ## #F SimpleGroup( [,[,[] ) ## ## <#GAPDoc Label="SimpleGroup"> ## ## ## ## ## This function will construct an instance of the specified simple group. ## Groups are specified via their name in ATLAS style notation, with parameters added ## if necessary. The intelligence applied to parsing the name is limited, and at the ## moment no proper extensions can be constructed. ## For groups who do not have a permutation representation of small degree the ## ATLASREP package might need to be installed to construct theses groups. ## g:=SimpleGroup("M(23)"); ## M23 ## gap> Size(g); ## 10200960 ## gap> g:=SimpleGroup("PSL",3,5); ## PSL(3,5) ## gap> Size(g); ## 372000 ## gap> g:=SimpleGroup("PSp6",2); ## PSp(6,2) ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("SimpleGroup"); ############################################################################# ## #F SimpleGroupsIterator( [,] ) ## ## <#GAPDoc Label="SimpleGroupsIterator"> ## ## ## ## ## This function returns an iterator that will run over all simple groups, starting ## at order start if specified, up to order 10^{18} (or -- if specified ## -- order end). If the option NOPSL2 is given, groups of type ## PSL_2(q) are omitted. ## it:=SimpleGroupsIterator(20000); ## ## gap> List([1..8],x->NextIterator(it)); ## [ A8, PSL(3,4), PSL(2,37), PSp(4,3), Sz(8), PSL(2,32), PSL(2,41), ## PSL(2,43) ] ## gap> it:=SimpleGroupsIterator(1,2000);; ## gap> l:=[];;for i in it do Add(l,i);od;l; ## [ A5, PSL(2,7), A6, PSL(2,8), PSL(2,11), PSL(2,13) ] ## gap> it:=SimpleGroupsIterator(20000,100000:NOPSL2);; ## gap> l:=[];;for i in it do Add(l,i);od;l; ## [ A8, PSL(3,4), PSp(4,3), Sz(8), PSU(3,4), M12 ] ## ]]> ## ## ## <#/GAPDoc> DeclareGlobalFunction("SimpleGroupsIterator"); ############################################################################# ## #F ClassicalIsomorphismTypeFiniteSimpleGroup(] ) ## ## <#GAPDoc Label="ClassicalIsomorphismTypeFiniteSimpleGroup"> ## ## ## This function returns a result equivalent to (and based on) ## , but returns a ## classically names series (consistent with ## ) and the parameter always in a list. This makes it ## easier to parse the result. ## ## ClassicalIsomorphismTypeFiniteSimpleGroup(SimpleGroup("O+",8,2)); ## rec( parameter := [ 8, 2 ], series := "O+" ) ## gap> IsomorphismTypeInfoFiniteSimpleGroup(SimpleGroup("O+",8,2)); ## rec( name := "D(4,2) = O+(8,2)", parameter := [ 4, 2 ], series := "D" ) ## ]]> ## ## ## <#/GAPDoc> DeclareGlobalFunction("ClassicalIsomorphismTypeFiniteSimpleGroup"); gap-4r6p5/grp/imf22.grp0000644000175000017500000011717712172557252013400 0ustar billbill############################################################################# ## #A imf22.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Q-class representative of the irreducible ## maximal finite integral matrix groups of dimension 22, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Q-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 22. ## IMFList[22].matrices := [ [ # Q-class [22][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[[0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [22][02] [[8], [4,8], [2,4,8], [4,2,4,8], [2,4,2,4,8], [2,4,2,1,2,8], [2,4,2,1,2,2,8], [1,2,4,2,1,1,4,8], [2,1,2,1,-1,2,2,4,8], [4,2,1,2,1,1,4,2,4,8], [2,4,2,-2,2,2,2,1,2,1,8], [2,1,2,4,2,-1,2,4,2,4,-1,8], [2,1,2,1,2,2,2,1,2,4,2,2,8], [2,1,2,4,2,-1,2,1,-1,1,-1,2,2,8], [1,2,4,2,1,4,1,2,1,2,1,1,4,1,8], [2,1,2,4,2,2,2,4,2,1,-1,2,2,2,1,8], [4,2,1,2,1,4,1,2,1,2,1,1,1,1,2,4,8], [1,2,1,2,1,4,1,-1,1,2,1,1,1,1,2,1,2,8], [2,1,2,1,-1,2,2,1,2,1,2,-1,2,2,1,2,1,4,8], [1,2,1,2,1,1,1,2,1,-1,1,1,1,4,-1,4,2,2,4,8], [2,4,2,1,2,2,2,1,2,1,2,-1,2,2,1,2,1,1,2,4,8], [2,4,2,1,2,2,2,4,2,1,2,2,2,2,1,2,1,1,2,4,2,8]], [[[0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-3,2,-2,3,-2,1,-1,1,-1,0,2,1,1,1,-2,0,1,-1,2,-3,1,0] , [-2,3,-2,2,-2,1,-2,3,-1,0,1,0,2,1,-2,0,0,0,1,-2,0,-1], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,0,-1,3,-2,1,0,0,-1,0,2,1,0,0,-1,0,1,-1,1,-2,1,1], [-4,4,-4,5,-3,1,-2,3,-1,0,2,0,2,1,-2,-1,1,-1,2,-3,1,-1], [-1,0,0,0,0,1,0,-1,0,0,1,1,-1,1,0,1,0,-1,1,-1,0,0], [2,-2,2,-4,2,0,1,-2,1,0,-1,1,-2,0,2,1,-1,0,0,2,-1,0], [2,-2,2,-4,2,0,1,-2,1,0,-1,1,-2,0,2,1,-1,0,0,1,0,0], [1,-2,2,-2,1,1,1,-2,0,1,0,1,-2,0,1,1,-1,-1,0,1,0,0], [-3,3,-3,4,-3,1,-1,1,-1,-1,2,1,2,1,-2,0,1,-1,2,-4,1,0], [1,-3,2,-2,1,1,1,-2,0,1,0,1,-2,0,1,1,-1,-1,0,1,0,1], [-1,0,0,1,-1,1,0,0,-1,1,1,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,3,-2,2,-2,1,-2,2,-1,1,1,0,1,1,-1,0,0,-1,1,-1,0,-1], [1,-1,1,-2,2,-1,1,-1,1,0,-1,0,-1,-1,2,0,0,0,0,2,-1,0], [-2,3,-3,4,-2,0,-1,3,-1,0,1,-1,2,0,-1,-1,0,0,1,-1,0,-1], [-3,3,-3,4,-2,1,-2,3,-1,0,1,0,2,1,-2,-1,1,-1,2,-3,1,-1], [-2,3,-2,2,-1,0,-1,2,0,-1,0,0,2,1,-1,-1,1,0,1,-2,0,-1], [-1,1,-1,1,0,-1,0,1,0,-1,0,0,1,0,0,-1,1,0,1,-1,0,0], [-1,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0,1,-1,0,0], [1,-2,1,-2,1,0,1,-1,0,0,0,1,-1,0,1,0,0,0,0,1,0,0]], [[-5,5,-5,7,-4,1,-3,4,-2,0,3,0,3,1,-3,-1,1,-1,2,-4,1,-1], [0,0,0,-1,1,0,0,-1,0,0,0,1,-1,0,1,0,0,-1,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [-1,1,-1,2,-1,0,-1,2,-1,1,1,-1,1,0,-1,-1,0,0,0,0,0,-1], [0,-1,1,-1,1,0,0,-1,0,1,0,0,-1,0,1,0,0,-1,0,1,0,0], [0,1,-1,1,0,0,0,1,0,-1,0,0,1,0,0,-1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [-1,1,-1,2,-1,0,-1,1,-1,0,1,0,1,0,-1,0,0,0,0,-1,0,0], [-1,1,-1,0,0,1,-1,0,0,0,0,1,0,1,0,0,0,-1,1,-1,0,0], [-1,1,-1,2,-1,0,-1,1,-1,1,1,-1,1,0,-1,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [-1,0,0,1,-1,1,0,0,-1,1,1,0,0,0,-1,0,0,-1,0,0,0,0], [1,1,0,-1,1,-1,0,1,1,-1,-1,-1,1,0,0,-1,0,1,-1,1,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [-4,4,-4,6,-3,1,-2,3,-1,-1,2,0,3,1,-3,-1,1,-1,2,-4,1,-1], [0,1,-1,1,-1,1,-1,2,-1,0,1,0,1,1,-1,0,-1,0,0,-1,0,-1], [-1,2,-2,2,-2,1,-1,2,-1,0,1,0,1,1,-1,0,-1,0,0,-1,0,-1], [1,-2,1,-2,1,1,1,-2,0,1,0,1,-2,0,1,1,-1,-1,0,1,0,0], [1,-3,2,-3,2,0,2,-4,1,0,0,2,-3,0,2,1,0,-1,0,1,0,1], [1,-1,1,-2,1,1,0,-2,0,1,0,1,-2,0,1,1,-1,-1,0,1,0,0]]]], [ # Q-class [22][03] [[2], [1,2], [0,0,2], [0,0,1,2], [0,0,0,0,2], [0,0,0,0,1,2], [0,0,0,0,0,0,2], [0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0]], [[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [22][04] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [22][05] [[4], [1,4], [2,0,4], [1,-1,-1,4], [2,0,2,0,4], [1,0,1,0,1,4], [2,0,2,0,2,1,4], [1,0,1,0,1,2,1,4], [2,0,2,0,2,1,2,1,4], [1,0,1,0,2,2,1,2,1,4], [2,-1,2,0,2,1,2,1,2,1,4], [1,0,1,0,1,2,1,2,1,2,1,4], [2,1,0,1,0,0,0,0,0,0,0,-1,4], [1,0,1,0,1,2,2,2,1,2,1,2,0,4], [1,0,1,0,1,2,1,2,1,2,1,2,0,2,4], [2,1,0,1,0,0,0,0,0,0,0,0,2,0,0,4], [1,0,1,0,1,2,1,2,2,2,1,2,0,2,2,0,4], [2,1,0,1,0,0,0,0,0,0,0,0,2,0,-1,2,0,4], [1,1,1,0,1,2,1,2,1,2,2,2,0,2,2,0,2,0,4], [2,0,2,0,2,1,2,2,2,1,2,1,0,1,1,0,1,0,1,4], [1,0,1,0,1,2,1,2,1,2,1,2,0,2,2,-1,2,0,2,1,4], [2,1,0,1,0,-1,0,0,0,0,0,0,2,0,0,2,0,2,0,0,0,4]], [[[-1,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [-1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,1], [-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-2,1,1,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,1], [-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,1], [-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [-1,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,1,0,1,0,0], [-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,-1,0,0,0,1,1,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,1,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [-1,0,0,0,0,1,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,1,0,0]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,1,1,0,0], [-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,1], [-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1], [-2,1,1,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,1], [-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,1,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,-1,0,0,0,1], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0], [-1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,1], [-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0], [-1,0,0,0,0,1,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,1], [-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,1,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1]]]], [ # Q-class [22][06] [[3], [0,3], [0,0,3], [1,-1,0,3], [0,0,-1,0,3], [0,-1,0,0,-1,3], [0,-1,-1,1,1,1,3], [-1,1,0,-1,0,0,-1,3], [1,0,-1,0,1,0,1,-1,3], [0,0,0,-1,1,-1,-1,1,0,3], [1,-1,0,0,-1,1,0,-1,1,-1,3], [-1,1,1,-1,-1,1,0,1,-1,0,-1,3], [0,-1,1,0,1,-1,0,-1,1,1,0,-1,3], [0,1,1,-1,-1,-1,-1,1,-1,1,-1,1,0,3], [1,1,0,1,-1,0,-1,0,0,-1,0,0,-1,0,3], [-1,1,1,-1,1,-1,0,1,0,1,-1,1,1,1,-1,3], [0,0,0,1,-1,1,0,1,0,-1,0,0,-1,0,1,-1,3], [-1,-1,-1,-1,1,1,1,0,0,0,0,0,0,-1,-1,0,-1,3], [-1,1,0,-1,-1,1,-1,1,0,0,0,1,-1,0,1,0,1,0,3], [-1,0,-1,-1,-1,1,0,0,0,0,0,1,-1,0,0,-1,0,1,1,3], [1,1,-1,0,0,0,0,0,0,0,0,0,-1,0,1,0,-1,0,0,0,3], [0,-1,0,1,0,0,0,0,0,1,0,-1,1,0,0,0,0,0,0,0,0,3]], [[[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,1,0,0,0,2,1,-1,1,1,-1,1,0,1,0,0,0,0,1,0,-1], [1,1,-1,0,-1,0,0,0,-1,0,0,0,1,-1,0,1,0,0,0,0,-1,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,1,1,2,0,-2,0,2,-1,0,1,-1,1,-1,-1,0,0,0,0,1,0], [0,0,-1,-1,0,0,0,-1,0,0,0,1,0,0,0,0,1,0,0,-1,0,1], [-1,0,0,1,1,1,-1,-1,1,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,1,0,0,1,0,-1,-1,-1,0,0,0,-1,0,0,0,0,0], [0,0,0,1,-1,1,-1,1,1,0,-1,-1,0,0,-1,0,-1,0,0,0,0,-1], [0,0,0,-1,0,0,0,-1,0,0,0,0,-1,0,0,0,0,0,0,-1,0,1], [0,1,-1,0,-1,1,1,0,-1,1,0,-1,1,0,1,1,0,0,0,0,-1,-1], [0,0,0,1,0,1,-2,0,1,-1,-1,0,0,0,-1,0,-1,0,0,0,0,0], [1,1,-1,1,-1,1,0,1,-1,0,0,-1,1,0,0,1,-1,0,0,1,-1,-1], [1,0,0,-1,-1,-1,2,1,-1,0,0,0,1,-1,1,0,0,0,0,0,0,0], [-1,1,0,2,0,2,-1,1,1,0,0,-1,0,1,0,0,-2,0,0,0,-1,-1], [1,0,0,-1,0,-1,1,0,-1,0,0,1,0,-1,0,0,1,0,0,0,0,1], [-1,-1,0,0,1,-1,-2,-1,2,-1,0,2,-1,1,-1,-1,1,1,0,-1,1,1], [1,0,0,-1,-1,-1,2,1,-1,0,0,0,1,-1,0,0,0,0,1,0,0,0], [0,0,0,-1,-1,0,1,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0], [-1,1,0,1,0,1,1,1,0,1,1,-1,1,1,1,-1,-1,0,0,0,0,-1], [0,0,0,1,-1,1,-1,1,1,-1,-1,-1,0,0,-1,0,-1,0,0,0,0,0]], [[1,-1,0,0,1,-2,-1,-1,0,-1,0,2,0,0,-1,0,2,1,1,0,1,1], [-1,1,0,0,1,1,0,-1,0,1,1,0,0,1,1,0,1,0,-1,0,0,0], [0,-1,0,-1,0,0,-1,0,1,-1,-1,0,-1,0,0,0,0,0,-1,0,0,1], [1,-2,0,-1,1,-2,-1,0,0,-2,0,2,0,0,-1,0,1,0,1,0,1,1], [1,0,0,-1,-1,0,3,1,-2,1,0,-2,1,-1,2,1,-1,-1,1,1,-1,-1], [0,1,0,1,-1,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0], [0,0,0,0,0,-1,1,0,-1,0,1,0,0,0,0,0,0,0,1,0,0,0], [-1,1,0,1,0,2,0,0,0,1,0,-1,0,1,1,0,-1,0,-1,0,-1,-1], [0,0,0,0,1,-1,1,0,-1,0,1,1,1,0,0,-1,1,0,1,0,1,0], [0,0,0,1,0,2,0,1,0,0,-1,-2,0,0,1,1,-2,-1,0,1,-1,-1], [0,0,0,-1,0,-2,0,-1,0,0,0,2,0,-1,-1,-1,2,1,0,-1,1,1], [-1,1,0,1,0,2,-1,0,1,0,0,-1,-1,1,0,0,-1,0,-1,0,-1,0], [0,-1,0,-1,-1,0,1,1,0,0,-1,-1,0,-1,1,0,-1,-1,0,0,0,0], [-1,0,0,1,1,1,-2,-1,1,0,0,0,-1,1,0,0,0,0,-1,0,0,0], [1,-1,0,-1,1,-1,-1,-1,0,-1,0,2,0,0,-1,0,2,0,0,0,1,1], [-1,0,0,-1,0,1,1,0,0,1,0,-1,-1,0,2,0,-1,-1,-1,0,-1,0], [0,0,0,1,1,-1,-1,0,0,-1,1,2,1,1,-1,-1,1,1,0,0,1,0], [0,1,0,0,-2,1,2,0,-1,2,0,-2,0,-1,1,1,-1,0,0,0,-1,-1], [0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [-1,1,0,2,0,2,-1,0,1,0,0,-1,0,1,-1,0,-1,0,0,0,0,-1], [0,0,0,0,0,0,0,-1,0,1,0,0,-1,0,0,1,1,0,0,0,0,0], [0,-1,-1,0,0,1,-1,0,0,-1,-1,0,0,0,0,1,-1,-1,0,0,0,0]]]], [ # Q-class [22][07] [[12], [2,12], [2,-3,12], [-3,2,-3,12], [2,-3,2,2,12], [2,2,-3,2,2,12], [-3,2,2,2,2,-3,12], [-3,-3,2,2,-3,-3,-3,12], [-3,-3,-3,2,2,2,-3,2,12], [2,2,-3,-3,2,2,2,-3,-3,12], [2,2,2,2,-3,2,-3,2,2,-3,12], [2,2,-3,-3,-3,2,-3,-3,2,2,-3,12], [2,2,2,2,-3,-3,2,-3,-3,-3,2,2,12], [2,2,-3,2,2,-3,2,2,-3,2,-3,-3,-3,12], [2,2,2,2,2,2,-3,-3,-3,-3,2,-3,2,-3,12], [2,-3,2,2,2,2,-3,2,2,-3,2,-3,2,-3,2,12], [-3,2,-3,2,-3,-3,-3,2,2,-3,2,-3,2,2,2,2,12], [-3,-3,2,-3,2,2,2,-3,2,2,-3,2,-3,-3,-3,-3,-3,12], [2,2,2,2,-3,2,-3,2,-3,-3,2,2,2,2,2,2,2,-3,12], [-3,2,-3,2,-3,2,2,-3,-3,2,-3,2,2,-3,2,-3,-3,2,-3,12], [2,-3,2,-3,2,2,-3,2,2,2,-3,2,-3,-3,2,2,-3,2,-3,2,12], [2,-3,2,2,2,-3,2,2,2,2,2,-3,2,2,-3,2,2,2,-3,-3,2,12]], [[[1,0,-1,0,0,-1,0,0,0,0,0,-1,0,-1,0,0,0,1,1,0,0,0], [0,0,0,-1,1,0,0,0,0,0,0,0,-1,-1,0,0,0,-1,1,1,-1,1], [1,-1,0,1,-1,0,1,1,0,1,0,1,0,0,1,0,1,1,-1,-1,0,-1], [0,0,1,1,0,0,-1,-1,0,0,-1,-1,0,-1,-1,-1,0,-1,0,0,0,0], [1,-1,0,1,0,0,1,1,-1,0,1,1,0,0,0,0,1,1,-1,0,0,-1], [0,-1,1,1,-1,0,0,0,0,1,1,1,1,2,1,1,0,1,-2,-1,0,-2], [0,-1,2,1,-1,1,0,0,0,1,0,1,0,1,0,0,1,0,-1,0,0,-1], [0,1,-1,-1,1,0,0,0,0,-1,-1,-1,0,-2,-1,-1,0,-1,1,0,0,1], [-1,0,0,0,-1,1,0,0,0,0,0,0,1,1,1,0,-1,0,-1,-1,0,0], [0,-1,1,-1,0,1,1,1,0,0,1,2,0,2,1,1,1,0,-1,1,-1,0], [0,-1,1,1,-2,0,0,-1,1,1,0,0,0,1,1,0,0,0,-1,-1,0,-1], [-1,1,-1,-1,1,0,-1,0,0,0,0,-1,1,0,0,0,-1,0,1,0,0,1], [0,0,1,1,-1,0,-1,-1,1,1,-1,-1,0,0,0,0,0,0,0,0,0,0], [0,1,-2,-2,3,-1,0,0,-1,-2,0,-1,-1,-3,-2,-1,0,-1,3,2,0,2], [1,0,0,1,0,-1,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0], [1,-1,1,2,-2,0,1,0,0,1,0,1,0,1,1,1,1,1,-2,-1,0,-2], [0,0,-1,-1,1,0,1,0,0,-1,0,0,-1,-1,0,0,0,-1,1,1,0,1], [-1,-1,1,0,-1,1,1,1,0,1,1,2,1,3,2,1,0,1,-2,-1,0,-1], [0,0,-1,0,1,-1,0,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0], [-1,1,1,0,0,0,-2,-1,0,0,-1,-1,0,0,-1,0,-1,-1,0,0,0,1], [0,1,-1,-1,1,0,0,1,-1,-1,0,0,0,-1,0,0,0,0,0,0,0,1], [0,-1,1,0,-1,1,1,0,0,0,0,1,0,1,1,0,1,0,-1,0,0,0]], [[1,0,-1,-1,1,0,1,1,-1,-1,0,1,-1,-1,0,0,1,0,0,1,-1,1], [1,-1,-1,0,0,0,2,1,0,0,1,1,0,0,1,0,1,1,0,0,0,-1], [0,1,0,-1,1,0,-1,0,0,-1,-1,-1,0,-1,-1,-1,0,-1,1,1,0,1], [0,0,0,0,0,0,0,0,1,1,0,-1,1,0,0,0,0,0,0,0,0,-1], [0,1,-1,-1,2,-1,0,0,-1,-1,0,0,-1,-2,-1,0,0,-1,1,1,0,1], [1,0,-1,0,0,0,1,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,1,1,0,0,0,-1,0,0,0,0,0,0,-1,0,1,0,0,0,1,-1], [0,0,1,0,-1,0,-1,0,2,1,-1,-1,1,1,1,0,-1,0,0,0,-1,0], [0,1,-1,0,1,-1,-1,0,0,0,0,-1,0,-1,-1,0,-1,0,1,0,0,0], [1,-1,0,1,0,0,1,0,-1,0,0,1,-1,-1,0,0,1,0,0,0,0,0], [1,-1,1,0,-1,1,1,1,1,1,0,1,0,1,1,0,1,0,-1,0,-1,-1], [0,1,-2,0,1,-1,-1,-1,-1,-1,0,-2,0,-2,-2,-1,-1,0,2,0,1,1], [-1,0,0,-1,0,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0], [0,-1,1,0,0,0,1,0,0,0,1,2,-1,1,1,1,1,0,-1,1,-1,0], [0,0,-1,-1,0,0,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,-1,-1,1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [-1,-1,0,-1,0,1,1,1,0,0,1,2,0,2,2,1,0,0,-1,0,-1,0], [0,0,1,2,-1,0,-1,-1,-1,0,0,0,0,0,-1,0,0,0,-1,-1,1,-1], [0,0,-1,-1,1,0,0,0,0,-1,0,-1,0,-1,-1,-1,0,-1,1,1,0,1], [0,0,0,1,-1,0,0,0,0,1,0,-1,1,0,0,0,0,1,0,-1,1,-1], [0,1,-1,0,0,-1,-1,0,0,0,-1,-1,0,-1,0,0,-1,0,1,0,0,1], [0,-1,2,1,-1,1,0,0,0,1,0,2,0,2,1,1,1,0,-2,0,-1,-1]]]], [ # Q-class [22][08] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]]]], [ # Q-class [22][09] [[4], [2,4], [1,2,4], [2,2,2,4], [2,2,1,2,4], [1,1,2,1,1,4], [1,2,1,1,2,1,4], [1,1,1,1,1,0,2,4], [1,1,1,2,1,0,1,1,4], [2,1,0,1,1,0,1,2,1,4], [1,1,2,2,1,2,1,2,0,1,4], [1,1,1,1,2,1,1,1,1,0,0,4], [2,1,1,2,2,0,1,2,0,2,2,1,4], [1,1,1,1,1,1,1,1,1,1,1,1,1,4], [0,1,1,1,1,1,1,1,1,1,1,2,1,0,4], [1,1,0,0,1,1,2,2,0,1,1,2,1,1,2,4], [0,1,2,1,1,1,1,1,1,0,1,1,1,0,2,1,4], [1,1,2,2,2,1,1,1,2,1,1,1,1,0,1,0,2,4], [2,1,0,1,1,0,1,1,1,2,0,1,1,1,1,1,0,1,4], [1,1,0,1,1,1,1,1,1,1,0,2,1,2,1,2,1,0,0,4], [2,1,1,2,2,0,0,1,1,2,1,1,2,1,1,1,1,2,1,1,4], [1,1,0,1,1,1,1,1,1,1,1,1,0,-1,2,2,1,1,1,0,1,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,1], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-2,2,-1,1,0,0,0,1,-1,1,0,0,0,1,1,0,-1,-2,0,-1], [0,0,-1,2,0,1,0,0,0,2,-1,1,-1,0,0,1,1,-1,-1,-2,0,-1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,2,0,1,0,0,0,2,-1,1,-1,0,-1,1,2,-1,-1,-2,0,-1], [0,0,1,-1,0,-1,1,-1,0,0,1,0,0,0,0,-1,0,0,0,1,0,1], [1,0,-2,3,-1,0,0,0,-1,2,-1,2,-1,1,0,1,2,0,-2,-3,-1,-1], [0,0,1,-1,0,-1,0,-1,0,0,1,0,0,0,0,0,0,0,0,1,0,1], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,2,-1,0,-1,1,-1,0,0,1,0,0,-1,0,-1,-1,0,1,2,0,1], [-1,0,2,-1,1,-1,0,-1,0,0,1,-1,0,-1,0,0,-1,0,1,2,0,1], [0,0,1,-1,0,-1,0,-1,0,0,1,0,0,0,0,-1,0,0,1,1,0,1], [0,-1,3,-1,1,-2,0,-1,0,0,1,-1,0,-1,0,0,-1,0,1,3,-1,1], [0,-1,3,-3,1,-2,1,-1,0,-1,2,-1,0,-1,0,-2,-1,0,2,4,0,2], [1,-1,1,1,1,-1,0,0,-1,0,0,-1,-1,0,1,0,0,0,0,1,-1,0], [0,0,-1,2,0,1,0,0,0,1,-1,1,0,0,0,1,1,-1,-1,-2,0,-1], [-1,0,1,-1,0,0,0,-1,1,0,1,0,1,-1,-1,0,0,-1,1,1,0,1], [1,-1,2,-2,0,-2,1,-1,-1,-1,1,-1,0,0,1,-2,-1,1,1,3,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [1,0,-1,1,0,0,0,0,0,1,0,1,-1,0,0,1,1,0,-1,-1,-1,-1]], [[1,1,-4,2,-2,2,0,1,0,1,-1,2,0,1,0,1,2,0,-2,-4,0,-2], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0], [1,1,-3,3,-1,2,-1,1,0,1,-2,1,0,1,0,2,2,0,-2,-4,-1,-2], [0,1,-3,3,-1,2,-1,1,0,2,-2,2,0,1,-1,2,2,0,-2,-4,-1,-2], [0,0,0,-1,0,0,0,0,0,-1,0,0,1,1,0,-1,0,0,0,0,0,1], [0,0,0,0,0,-1,0,-1,0,1,1,1,0,0,-1,0,1,0,0,0,-1,0], [1,0,-2,3,-1,0,0,0,-1,2,-1,2,-1,1,0,1,2,0,-2,-3,-1,-1], [0,0,-1,3,0,1,-1,0,0,2,-1,1,-1,0,-1,3,2,-1,-1,-3,-1,-2], [1,0,-3,3,-1,1,0,0,0,2,-1,2,-1,1,0,2,2,0,-2,-4,-1,-2], [0,1,-2,1,-1,1,0,0,0,0,-1,1,1,1,0,0,1,0,-1,-2,0,0], [1,0,-1,2,0,0,-1,1,-1,1,-1,1,-1,1,0,1,1,0,-1,-2,-1,-1], [1,1,-4,3,-2,2,0,1,0,1,-2,2,0,1,0,1,2,0,-2,-4,0,-2], [0,0,-1,2,0,0,-1,0,0,1,-1,0,0,1,0,2,1,0,-1,-2,-1,-1], [1,0,-1,2,0,0,0,0,-1,1,-1,1,-1,1,0,1,1,0,-1,-2,-1,-1], [1,0,-1,1,0,-1,0,0,-1,1,0,1,-1,1,0,0,1,0,-1,-1,-1,0], [0,0,-1,2,0,1,0,0,0,1,-1,1,0,0,-1,1,1,-1,-1,-2,0,-1], [0,0,-1,2,0,1,-1,0,0,1,-1,1,0,0,-1,2,1,0,-1,-2,-1,-1], [1,0,-2,2,-1,0,0,0,-1,1,0,1,-1,1,0,1,1,1,-1,-2,-1,-1], [1,0,-2,3,0,1,-1,1,0,2,-2,1,-1,1,0,2,2,-1,-2,-4,-1,-2], [1,1,-4,4,-1,2,-1,1,0,2,-2,2,-1,1,0,3,2,0,-3,-5,-1,-3], [1,0,-1,1,0,0,0,0,-1,1,0,1,-1,1,0,0,1,0,-1,-1,-1,0]]]], [ # Q-class [22][10] [[6], [2,6], [2,1,6], [1,1,3,6], [1,1,3,3,6], [2,0,2,2,2,6], [2,2,3,2,3,2,6], [1,1,2,3,2,3,2,6], [3,0,2,2,1,1,1,3,6], [1,0,3,3,1,2,2,2,3,6], [0,1,2,3,2,1,3,3,0,2,6], [1,1,1,1,2,3,1,1,1,3,0,6], [2,0,2,2,3,2,3,3,2,1,2,1,6], [0,1,1,2,2,3,3,2,0,2,3,3,2,6], [1,0,3,2,3,2,3,3,2,3,3,1,2,2,6], [1,1,2,0,2,2,3,2,2,2,0,2,2,2,2,6], [1,3,2,2,3,1,1,2,1,0,2,0,1,1,2,2,6], [2,0,1,2,1,2,2,2,2,3,2,0,3,2,2,2,1,6], [0,2,1,2,3,1,2,2,1,2,2,3,2,2,1,2,2,1,6], [1,1,2,2,3,2,2,1,1,2,1,3,0,2,3,2,2,0,3,6], [2,1,2,3,1,2,1,3,3,2,1,0,1,0,2,1,3,2,0,1,6], [2,1,3,3,2,3,1,2,3,3,0,3,1,1,2,2,2,0,2,3,2,6]], [[[1,2,-1,0,1,2,-4,-2,0,3,1,-4,2,1,0,2,-2,-3,1,1,1,-1], [1,2,-1,-1,2,2,-4,-2,0,3,1,-5,2,2,0,2,-3,-3,1,1,2,-1], [0,3,-1,-1,2,2,-4,-3,1,2,2,-4,2,1,0,2,-3,-2,0,1,1,0], [0,2,0,0,1,2,-3,-3,1,-1,2,-2,1,0,1,2,-3,-1,1,0,1,0], [0,2,-1,0,1,2,-2,-2,1,2,1,-3,2,0,0,1,-1,-2,0,1,0,-1], [0,1,0,0,0,1,-1,-1,0,1,0,-1,1,0,0,0,0,-1,0,1,0,-1], [0,3,-1,-1,2,3,-4,-3,1,3,2,-5,2,1,0,2,-3,-3,1,1,1,-1], [1,0,0,-1,1,0,-1,0,-1,2,0,-2,1,1,-1,0,0,-1,0,1,0,0], [0,1,0,-1,1,0,-2,-1,0,0,2,-1,1,0,-1,1,-2,0,0,1,1,1], [-1,2,0,-1,1,1,-2,-2,1,-1,2,-1,1,0,0,1,-3,0,0,1,1,1], [0,2,0,0,1,2,-3,-3,1,0,2,-3,1,1,1,2,-3,-2,1,0,1,0], [0,1,-1,-1,1,1,-1,0,0,3,0,-2,2,0,-1,0,0,-2,-1,2,0,-1], [1,2,-1,-1,2,2,-3,-1,0,4,1,-4,2,1,-1,1,-1,-3,0,1,0,-1], [-1,2,0,-1,1,2,-2,-2,1,0,2,-2,1,0,0,1,-2,-1,0,1,1,0], [0,1,-1,-1,1,1,-1,-1,0,3,0,-3,2,1,-1,0,0,-2,0,1,0,0], [-1,2,0,-1,1,1,-2,-2,1,0,2,-1,1,0,0,1,-2,0,0,1,1,0], [0,2,0,0,1,1,-3,-3,1,-1,2,-2,1,1,1,2,-3,-1,1,0,2,0], [-1,2,1,0,0,1,-2,-2,1,-3,2,0,0,0,1,1,-3,1,1,0,1,1], [0,1,0,0,0,1,-1,-1,1,0,1,-1,1,0,0,1,-1,-1,0,1,0,-1], [0,1,-1,0,0,1,-1,-1,0,2,0,-2,2,0,0,1,0,-2,0,1,0,-1], [1,0,0,-1,1,-1,-1,0,-1,0,0,-1,0,1,0,0,-1,0,1,0,1,1], [0,2,-1,0,1,2,-3,-3,1,1,2,-2,2,0,0,2,-2,-2,0,1,1,-1]], [[1,2,-1,-1,2,2,-4,-2,0,3,1,-5,2,2,0,2,-3,-3,1,1,2,-1], [1,2,-1,0,1,2,-4,-2,0,3,1,-4,2,1,0,2,-2,-3,1,1,1,-1], [0,2,-1,-2,2,2,-3,-2,1,3,2,-4,2,1,-1,1,-2,-2,0,1,1,0], [1,1,-1,-1,2,2,-3,-1,0,4,1,-4,2,1,-1,1,-1,-3,0,1,0,-1], [0,2,-1,0,1,2,-3,-2,1,2,2,-3,2,0,0,2,-2,-2,0,1,0,-1], [0,1,0,-1,1,1,-2,-1,0,1,1,-2,1,1,0,1,-2,-1,1,0,1,0], [0,3,-1,-1,2,3,-4,-3,1,3,2,-5,2,1,0,2,-3,-3,1,1,1,-1], [0,1,0,0,0,2,-2,-2,1,0,1,-1,1,0,1,1,-1,-1,1,0,0,-1], [0,2,-1,-1,2,2,-3,-2,1,2,1,-3,2,1,0,1,-2,-2,0,1,1,-1], [0,1,-1,-2,2,1,-2,-1,0,3,1,-3,2,1,-1,0,-1,-2,0,1,1,0], [0,1,0,0,0,2,-2,-2,1,1,1,-2,1,0,1,1,-1,-2,1,0,0,-1], [-1,2,0,0,1,1,-3,-3,1,-2,3,-1,1,0,1,2,-4,0,1,0,2,1], [0,2,0,0,1,2,-3,-3,1,0,2,-2,1,0,1,2,-3,-1,1,0,1,-1], [-1,2,0,0,1,2,-3,-3,1,0,2,-2,1,0,1,2,-3,-1,1,0,1,0], [-1,1,0,-1,0,1,-1,-1,1,0,1,-1,1,0,0,0,-1,0,0,1,0,0], [-1,2,0,-1,1,1,-2,-2,1,0,2,-1,1,0,0,1,-2,0,0,1,1,0], [0,1,0,0,0,1,-2,-1,1,1,1,-1,1,0,0,1,-1,-1,0,1,0,-1], [1,0,-1,-1,1,1,-1,0,-1,5,-1,-3,2,1,-1,0,1,-3,0,1,0,-2], [0,1,0,1,0,1,-2,-2,1,0,1,-1,1,0,1,1,-1,-1,1,0,0,-1], [-1,1,0,0,0,1,-1,-1,1,0,1,-1,1,0,0,0,-1,0,0,1,0,0], [1,0,-1,-1,1,1,-1,0,0,3,0,-2,1,1,-1,0,0,-2,0,1,0,-1], [0,1,0,-2,2,0,-2,0,0,1,1,-2,1,1,-1,0,-2,0,0,1,1,1]]]], [ # Q-class [22][11] [[8], [2,8], [0,4,8], [4,4,4,8], [0,-2,-2,-3,8], [1,1,-3,0,3,8], [-1,-3,-1,-2,1,0,8], [-3,1,-1,-2,3,3,-2,8], [-1,1,-2,-2,1,4,1,1,8], [-2,-4,-3,-2,-1,1,2,1,1,8], [-3,0,-1,-2,-3,-1,1,-1,2,3,8], [-2,2,-2,-2,1,3,-1,3,2,-2,0,8], [-3,-1,-1,0,-3,1,0,0,-1,3,3,2,8], [1,1,1,2,1,1,-2,1,-1,1,0,1,1,8], [-2,0,-2,-4,1,3,1,3,3,1,2,4,0,0,8], [-1,1,-1,-2,-1,2,0,1,2,0,1,2,2,1,4,8], [-1,0,-4,-4,0,2,-2,2,1,1,4,3,2,1,4,4,8], [-2,-1,-2,-4,3,-1,0,2,1,-1,1,2,-1,0,3,1,2,8], [-1,-1,-1,-1,0,1,4,-2,2,0,2,1,2,-1,3,4,1,1,8], [0,-2,-4,-3,3,1,3,-1,1,-1,2,2,1,0,1,2,3,2,4,8], [-1,-1,-1,-1,-1,0,2,-1,3,3,4,-2,0,0,2,2,1,0,2,2,8], [-1,2,1,-1,0,0,1,0,2,-1,1,2,-1,4,1,2,1,0,0,1,0,8]], [[[0,0,0,-2,-1,1,0,0,0,-1,0,0,0,1,0,0,-1,0,0,0,0,-1], [0,1,0,-4,-3,2,0,0,-1,-1,-1,0,-1,2,-1,-1,-1,0,1,0,1,-1], [0,1,1,-3,-3,2,-1,0,-1,1,-2,0,-1,1,-1,-2,0,1,2,1,1,0], [0,0,1,-3,-3,3,-1,0,-1,0,-1,0,-1,1,-1,-1,-1,1,1,1,1,0], [-1,0,1,2,1,-1,0,-1,1,2,-1,0,0,-1,1,0,1,0,-1,1,-1,0], [-1,-1,1,2,1,0,0,-1,0,1,0,1,-1,-1,0,1,1,0,-1,0,0,0], [-1,0,-1,3,2,-3,1,0,2,0,-1,-1,1,0,2,0,2,-1,-1,0,-1,0], [0,0,1,2,2,-1,0,-1,0,2,0,1,0,-2,0,1,1,0,-1,0,0,1], [-1,0,0,0,-1,1,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,-1,0,3,2,-1,0,0,0,1,1,1,0,-2,0,1,1,0,-1,0,0,1], [0,0,-2,2,2,-2,1,0,0,-1,1,0,1,0,1,1,0,-1,-1,-1,0,0], [0,0,-1,0,1,-1,0,0,0,-1,1,0,0,0,0,1,-1,-1,0,-1,0,0], [0,-1,0,1,0,0,0,0,0,0,1,1,-1,0,-1,1,0,0,0,0,0,0], [1,-1,0,-1,0,1,-1,0,-1,0,1,1,0,-1,-1,0,-1,0,1,-1,1,1], [1,-1,-1,3,4,-3,0,0,0,0,2,1,1,-2,1,2,0,-1,-1,-2,0,1], [2,-2,0,0,1,0,0,1,-1,-1,2,2,0,-1,-2,1,0,0,1,-3,1,1], [1,-1,-1,2,3,-2,1,0,0,-1,2,1,1,-1,0,2,0,-1,-1,-2,0,0], [0,1,-2,0,1,-2,1,0,1,-1,1,-1,1,1,1,1,-1,-1,-1,-1,-1,-1], [1,-2,0,2,1,-1,0,1,0,0,1,1,0,-1,0,1,0,0,0,-1,0,1], [0,-1,-1,2,2,-2,1,0,1,-1,1,0,1,0,1,1,0,-1,-1,-1,-1,0], [0,-1,0,2,1,-1,0,0,0,0,0,0,1,-1,1,0,1,0,-1,0,0,1], [1,0,-1,-3,-1,1,0,1,-1,-2,1,0,0,1,-1,-1,-1,-1,2,-2,1,0]], [[0,0,1,-3,-4,3,-1,1,-1,0,0,0,-2,1,-2,-1,-1,1,2,1,0,0], [1,0,0,-5,-3,4,-1,1,-3,-1,2,1,-2,1,-3,0,-3,1,2,-1,1,0], [0,0,-1,-2,0,1,0,0,-1,-2,1,0,0,1,-1,0,-1,0,1,-2,1,0], [1,-1,1,-4,-3,4,-1,1,-2,-1,2,1,-2,1,-3,0,-2,1,2,-1,1,0], [-1,1,-1,0,0,-1,0,0,1,0,-1,-1,0,1,1,0,0,-1,0,1,-1,-1], [0,0,0,-2,-2,2,0,1,-1,0,1,1,-2,1,-2,0,-1,0,1,0,0,-1], [-1,-1,1,3,1,-1,0,-1,1,1,-1,0,0,-1,1,0,2,0,-1,1,-1,0], [0,1,-1,-1,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,-1], [0,0,0,1,1,0,0,0,-1,1,1,1,-1,-1,-1,1,0,0,0,0,0,0], [-1,0,0,4,2,-2,1,-1,2,1,-1,-1,1,-1,2,0,2,0,-2,1,-1,0], [0,0,0,2,2,-1,0,-1,0,1,0,0,1,-2,1,0,1,0,-1,0,0,1], [0,0,0,1,1,-1,0,0,0,1,0,1,0,-1,0,1,0,0,-1,0,0,0], [0,-1,0,4,3,-2,1,-1,1,1,0,1,1,-2,1,1,2,0,-2,-1,0,1], [-2,1,0,0,-1,0,0,-1,1,1,-1,-1,-1,1,1,0,0,0,-1,2,-1,-1], [0,0,0,1,1,-1,0,0,0,1,0,1,0,-1,0,0,0,0,0,0,0,0], [0,0,0,-1,-1,0,1,0,0,0,0,1,-1,1,-1,0,0,0,0,0,0,-1], [0,1,0,-1,-1,0,0,0,0,1,-1,0,0,0,0,-1,0,0,0,1,0,0], [0,1,-1,2,3,-3,0,-1,1,1,0,0,1,-1,2,1,0,-1,-1,0,-1,0], [1,-2,1,2,2,-1,0,0,0,1,1,2,0,-2,-1,1,1,0,0,-1,0,1], [-1,0,1,2,0,-1,0,-1,1,2,-2,0,0,-1,1,0,2,0,-1,2,-1,0], [-1,0,2,1,-1,1,0,-1,0,2,-2,0,-1,-1,0,-1,2,1,0,2,0,0], [-2,1,0,0,-1,0,0,-1,0,1,-1,-1,-1,1,1,0,0,0,-1,2,-1,-1]]]], [ # Q-class [22][12] [[12], [3,12], [-4,-1,12], [4,4,-3,12], [4,3,2,4,12], [0,2,0,-2,0,12], [1,4,-1,2,4,-3,12], [3,4,-4,2,3,-4,4,12], [0,0,0,-2,-4,4,-4,-2,12], [4,1,2,2,4,-2,0,0,0,12], [-2,2,3,-4,1,4,-4,-2,2,-1,12], [-3,1,3,3,0,0,2,1,1,-2,0,12], [3,-1,-2,0,2,0,0,0,4,1,2,0,12], [-2,4,4,2,3,-4,1,2,-1,4,2,0,0,12], [-3,-1,2,-2,-2,1,0,0,3,-2,2,4,-2,-2,12], [3,-3,-3,3,4,0,-2,-2,0,4,2,-2,4,0,-2,12], [-4,-1,4,-1,-3,3,-3,-3,1,-2,0,1,-2,1,-2,-2,12], [-4,0,-1,-2,-2,4,0,-3,0,-4,2,2,0,-3,-2,0,2,12], [0,-3,2,1,-4,-2,0,-3,-2,2,-2,3,0,-1,2,0,2,-4,12], [4,3,-4,2,0,-2,3,0,-4,3,0,-2,0,0,-4,1,-4,-2,4,12], [2,4,0,3,2,4,0,-2,-2,4,0,-4,-3,0,0,2,2,-2,0,0,12], [4,0,-2,4,2,2,-1,4,-4,3,-4,0,-2,0,0,0,0,-4,3,1,4,12]], [[[-3,7,-2,-2,1,-8,4,-7,4,0,5,-1,-2,-5,-3,2,1,-1,0,-4,-4,9], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,1,1,-2,3,0,1,-3,1,-1,0,1,1,1,0,0,-1,-1,0,-1,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [-1,3,0,0,-1,-1,1,-2,-1,1,1,-1,0,-2,0,1,1,-1,-1,-1,-3,2], [1,-2,-1,0,0,2,-1,1,-1,0,-1,1,0,2,1,-1,0,0,0,1,1,-2], [-2,3,0,0,0,-3,2,-3,1,0,2,-1,0,-3,-1,1,1,-1,-1,-1,-2,4], [-2,5,-1,-2,2,-7,2,-5,4,-1,3,-1,-1,-4,-2,1,1,0,0,-2,-2,7], [1,-1,-1,0,0,0,0,0,0,0,0,1,0,1,0,-1,0,0,0,0,1,-1], [-1,3,0,0,-1,-3,3,-3,1,1,3,-1,-1,-3,-1,1,1,-1,-1,-2,-3,4], [2,-4,1,0,0,5,-3,5,-2,-1,-4,1,1,4,2,-1,-1,1,1,3,3,-6], [1,-1,1,0,-1,2,-1,1,-2,0,-2,1,1,1,1,0,0,0,-1,1,1,-2], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,-1,1,-1,0,0,1,-1,0,-1,0,0,0,0,0,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,0,1,-1,1,0,0,0,0,0,0,0,0,0,0,0,-1], [3,-6,1,1,0,5,-3,5,-2,-1,-3,1,1,5,2,-2,-1,2,1,3,4,-6], [1,-3,1,1,-1,4,-2,3,-2,0,-2,1,1,2,1,-1,-1,0,0,2,2,-4], [0,0,1,0,-1,0,1,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,1], [-1,1,0,-1,1,-2,1,-1,2,-1,1,0,-1,-1,-1,1,0,0,0,0,0,2], [1,-3,0,1,0,3,-1,3,-1,0,-1,0,0,2,1,-1,0,1,1,1,1,-3], [-2,5,-2,-2,2,-7,3,-6,4,0,4,-1,-2,-4,-2,1,1,0,0,-3,-3,8]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,0,0,-1,1,-2,0,1,1,0,0,-1,0,0,1,-1,-1,-1,-1,1], [1,-3,2,1,0,3,-2,4,-1,-1,-3,0,1,2,2,0,0,1,0,3,2,-4], [-2,5,-1,-1,-1,-5,4,-6,2,1,4,-1,-1,-4,-2,2,1,-2,-2,-3,-4,7], [-1,2,-2,-1,1,-4,2,-4,2,0,3,0,-1,-2,-2,0,0,-1,0,-2,-1,4], [1,-3,1,1,1,2,-2,3,0,-1,-2,0,0,2,1,-1,-1,2,1,2,2,-3], [1,0,0,0,0,1,-1,0,-1,0,-1,0,0,1,1,0,0,0,0,0,0,-1], [0,0,0,0,1,-1,0,0,1,-1,0,0,0,0,0,0,0,1,1,0,1,0], [-2,3,0,0,-1,-3,2,-3,1,1,2,-1,0,-3,-1,1,0,-1,-1,-2,-2,4], [1,-2,0,1,0,1,0,1,0,0,0,0,0,1,1,-1,0,1,0,1,1,-1], [-1,2,-2,-1,2,-3,1,-3,2,0,2,0,-1,-1,-1,0,0,0,1,-2,-1,3], [-2,3,0,0,0,-3,2,-3,2,0,2,-1,-1,-3,-2,1,0,-1,0,-2,-2,4], [1,-1,0,0,1,1,-1,1,0,0,-1,0,0,1,1,-1,0,1,1,1,1,-2], [2,-6,1,0,2,4,-4,6,0,-2,-4,1,1,5,2,-2,-1,3,2,4,5,-6], [-1,2,0,-1,0,-3,1,-2,1,0,1,0,0,-2,0,1,1,0,-1,0,-1,3], [1,-2,2,1,-2,4,-1,3,-2,0,-2,0,1,2,1,0,-1,0,0,1,1,-3], [1,0,1,1,-3,3,0,1,-3,1,-1,0,1,1,1,1,0,-1,-1,0,-1,-2], [1,-2,1,0,1,2,-2,3,0,-1,-2,0,0,2,1,0,0,1,1,2,2,-3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0]]]] ]; MakeImmutable( IMFList[22].matrices ); gap-4r6p5/grp/imf31.grp0000644000175000017500000005575512172557252013403 0ustar billbill############################################################################# ## #A imf31.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Q-class representative of the irreducible ## maximal finite integral matrix groups of dimension 31, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Q-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 31. ## IMFList[31].matrices := [ [ # Q-class [31][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [31][02] [[4], [1,4], [0,1,4], [1,1,0,4], [1,1,1,1,4], [1,1,1,1,1,4], [1,1,1,1,1,0,4], [1,0,1,0,1,1,1,4], [1,1,1,1,0,1,1,1,4], [1,1,1,1,0,1,1,1,1,4], [1,1,1,1,1,1,1,1,1,1,4], [0,0,1,1,1,1,1,1,1,1,1,4], [1,1,1,1,1,1,0,1,1,0,1,1,4], [0,1,1,1,1,1,1,0,0,0,1,0,0,4], [1,1,1,1,1,1,1,1,0,1,0,1,1,1,4], [1,1,0,0,0,1,1,1,1,1,0,0,0,1,0,4], [0,1,0,1,0,0,1,1,1,1,-1,0,1,0,1,1,4], [1,0,0,1,1,0,1,1,0,1,0,1,0,-1,0,1,1,4], [0,0,1,1,0,1,1,0,1,1,1,1,1,1,0,1,1,0,4], [1,1,1,0,1,1,0,1,0,1,1,0,0,1,0,1,0,1,0,4], [1,1,-1,1,1,1,1,1,1,0,1,0,0,0,0,0,1,0,0,0,4], [0,1,1,1,1,1,1,0,-1,0,1,1,1,1,0,0,0,0,1,0,1,4], [0,1,1,0,1,1,0,0,1,0,1,1,1,0,-1,1,0,1,1,1,0,0,4], [1,1,-1,1,1,1,1,0,0,0,0,1,0,0,1,0,0,1,-1,0,1,0,0,4], [0,1,0,1,1,1,1,0,0,0,-1,1,1,1,1,1,1,1,0,1,0,1,1,1,4], [1,1,0,0,1,0,1,1,1,-1,1,1,1,0,-1,1,0,0,0,1,1,1,1,1,1,4], [0,1,1,0,1,1,1,1,1,0,1,0,0,1,0,1,1,1,0,0,1,0,1,0,0,0,4], [1,1,0,0,1,0,1,1,0,0,1,0,1,0,0,1,1,0,0,0,1,1,1,-1,0,1,1,4], [0,1,1,0,1,1,1,1,0,0,0,1,0,0,1,1,1,0,1,1,1,1,0,0,0,1,0,1,4], [1,1,1,0,0,1,0,1,0,1,1,0,1,1,0,0,1,0,1,1,1,1,1,-1,0,0,1,1,0,4], [1,1,1,0,1,1,0,0,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,0,0,0,1,0,0,1,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [10,2,11,-2,8,-16,-14,5,9,-14,15,7,-14,-18,-10,10,5,-15,12,6,-3,7,-11,18,19,-25,3,4,-2,6,-9], [3,2,5,-1,4,-4,-4,1,2,-7,5,4,-6,-8,-3,5,3,-5,5,3,0,2,-5,5,5,-8,0,1,-4,2,-4], [2,0,0,-1,0,-2,-2,1,2,0,1,0,-1,0,-1,-1,0,-1,1,0,-1,2,0,2,2,-2,1,0,1,0,-1], [-1,0,-2,0,-1,3,2,-1,-1,2,-2,-1,1,2,2,-2,0,2,-2,-1,0,0,2,-3,-3,4,0,-1,0,-1,1], [-3,-1,-4,1,-2,4,4,-1,-2,5,-5,-3,4,5,4,-3,-2,4,-4,-2,0,-1,4,-5,-6,8,0,-2,1,-1,3], [3,0,3,-1,1,-4,-4,1,2,-2,3,1,-3,-3,-2,1,1,-3,3,1,0,2,-2,4,5,-5,1,1,0,0,-2], [0,-1,0,0,0,-1,-1,0,1,1,0,-1,0,0,0,0,-1,0,0,0,0,1,0,1,1,0,1,0,1,0,0], [2,-1,1,-1,1,-5,-4,1,4,0,2,-1,-2,-2,-1,0,-1,-2,3,1,-1,3,-1,5,4,-4,2,1,2,1,-2], [-2,-1,-4,1,-2,4,4,-1,-2,4,-5,-2,4,5,3,-3,-1,3,-4,-1,0,-1,4,-5,-6,7,0,-2,1,-2,3], [2,-1,-1,-1,0,-3,-2,1,3,1,0,-1,-1,0,0,-1,-1,-1,1,0,-1,3,1,2,2,-2,2,0,2,0,-1], [-2,-1,-4,0,-2,3,2,-1,0,5,-5,-3,3,5,4,-4,-2,4,-2,-1,0,1,4,-4,-5,7,1,-1,1,-2,1], [5,-1,4,-1,3,-9,-8,3,6,-4,8,0,-6,-6,-5,3,1,-6,5,0,-3,4,-4,10,11,-11,2,2,3,3,-3], [-1,0,-1,0,-2,4,3,-1,-3,3,-3,-1,3,4,1,-2,0,3,-3,-2,1,-2,2,-4,-4,5,-1,-1,0,-2,2], [-2,0,-3,1,-3,6,5,-1,-5,4,-4,-2,5,6,2,-3,0,4,-5,-3,1,-3,4,-7,-6,8,-1,-3,1,-3,4], [2,-1,3,-1,2,-5,-5,1,4,-2,4,0,-3,-4,-2,2,0,-3,3,1,-1,2,-3,6,6,-6,1,2,1,2,-2], [0,-1,0,1,-1,1,1,0,-2,2,0,-1,2,2,-1,-1,0,0,-2,-2,0,-2,1,-1,0,2,0,-1,2,-1,2], [-1,-1,-2,0,0,0,0,0,2,1,-1,-1,0,0,2,-1,-1,0,0,1,-1,2,1,0,-1,1,1,0,0,0,0], [-5,-2,-7,1,-5,9,8,-3,-5,10,-9,-5,9,12,6,-7,-3,9,-8,-5,1,-4,7,-11,-11,16,-1,-3,3,-4,6], [-4,-1,-4,1,-3,7,6,-2,-4,5,-6,-2,5,6,4,-3,-1,5,-5,-2,1,-3,4,-7,-8,10,-1,-2,0,-2,4], [1,0,1,0,1,-2,-1,0,1,-1,1,1,-1,-2,-1,1,0,-2,1,1,0,1,-1,2,2,-3,1,0,0,1,-1], [5,1,6,-1,5,-8,-7,2,5,-8,8,4,-8,-10,-5,6,3,-8,6,3,-2,4,-6,9,10,-13,1,2,-2,4,-5], [9,1,9,-3,8,-17,-15,5,12,-12,14,5,-14,-17,-8,8,3,-13,13,6,-4,9,-10,19,19,-24,4,5,-1,6,-10], [0,-1,-1,0,-1,-2,-2,1,2,2,-1,-2,0,1,1,-2,-2,0,1,0,-1,2,1,2,1,0,2,1,2,0,0], [5,0,6,-1,4,-10,-9,3,7,-7,9,2,-8,-10,-5,5,2,-8,7,3,-3,5,-6,12,12,-14,2,3,0,4,-5], [6,0,8,-2,5,-13,-12,3,9,-8,10,3,-10,-12,-6,6,1,-9,10,4,-2,6,-8,15,15,-17,3,5,0,5,-7], [0,1,1,0,1,0,0,0,0,-1,0,1,-1,-2,0,1,0,-1,1,1,1,0,-1,0,0,-1,0,0,-2,0,-1], [9,1,9,-2,6,-13,-12,4,7,-10,13,5,-11,-13,-9,7,4,-11,9,3,-2,5,-8,14,17,-20,2,3,0,4,-7], [-4,0,-3,1,-3,9,7,-3,-7,5,-6,-1,6,7,4,-3,0,6,-6,-3,3,-5,4,-10,-9,12,-2,-3,-1,-3,4], [3,2,5,0,4,-4,-3,1,1,-7,5,5,-5,-8,-4,6,3,-6,4,3,0,1,-5,5,5,-9,0,1,-4,2,-3], [-3,0,-4,1,-1,5,5,-2,-2,3,-5,-1,3,3,4,-2,-1,3,-3,0,0,-1,3,-6,-7,7,0,-2,-1,-1,2]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,-1,0,-1,2,1,-1,-1,2,-2,-1,2,2,1,-1,-1,2,-1,-1,1,-1,1,-2,-2,3,0,0,0,-1,1], [1,-1,2,0,1,-4,-4,1,3,-1,3,-1,-2,-2,-2,1,-1,-2,2,0,-1,1,-2,5,5,-4,1,2,2,2,-1], [-6,-2,-9,2,-6,11,10,-3,-6,11,-11,-6,10,13,7,-8,-4,10,-9,-5,1,-4,9,-13,-13,18,-1,-4,3,-4,7], [3,-1,2,-1,2,-7,-6,2,6,-2,4,-1,-4,-4,-2,1,-1,-3,4,1,-2,4,-2,7,7,-7,2,2,2,2,-3], [-2,0,-3,0,-1,3,2,-1,0,3,-4,-2,2,3,3,-3,-2,3,-1,0,0,0,2,-3,-4,5,0,0,0,-1,1], [3,-1,2,0,2,-6,-5,2,4,-2,4,0,-3,-4,-3,2,0,-4,3,1,-2,3,-2,6,6,-7,2,1,2,2,-2], [0,2,1,0,1,1,0,0,-1,-2,0,2,-1,-1,0,1,1,0,1,1,1,-1,-1,-1,-1,0,-1,0,-3,0,-1], [5,1,6,-1,3,-7,-7,2,3,-6,7,3,-6,-7,-5,4,2,-6,6,2,0,2,-5,8,9,-11,1,2,-1,2,-4], [-5,1,-4,2,-3,10,9,-3,-8,5,-8,-1,7,7,4,-3,-1,6,-6,-2,3,-6,4,-11,-11,13,-2,-3,-2,-3,5], [-1,0,-1,1,-1,1,1,0,0,1,-2,-1,1,1,1,-1,-1,1,-1,0,0,0,1,-1,-2,2,0,0,0,0,1], [0,0,1,0,1,-1,-1,0,1,-1,1,0,-1,-2,0,1,0,-1,1,1,0,1,-1,1,1,-1,0,0,-1,1,-1], [-8,-2,-10,2,-8,14,12,-4,-8,14,-14,-7,13,17,9,-10,-5,13,-11,-6,3,-6,11,-16,-17,23,-2,-4,3,-6,8], [-1,-2,-4,0,-2,1,1,0,1,5,-3,-4,3,5,2,-4,-2,3,-3,-2,-1,1,4,-2,-2,4,1,-1,4,-1,2], [-4,-2,-7,1,-5,8,7,-2,-5,10,-8,-5,9,12,4,-7,-3,8,-8,-5,1,-4,7,-10,-9,14,-1,-3,4,-4,6], [-3,0,-4,0,-3,7,5,-2,-4,5,-6,-2,5,7,4,-4,-1,6,-4,-2,2,-3,4,-8,-8,10,-1,-2,0,-3,3], [-5,0,-6,1,-5,11,9,-3,-8,9,-9,-3,9,12,5,-6,-2,9,-8,-5,3,-6,7,-13,-12,16,-2,-4,1,-5,6], [-5,0,-4,1,-3,8,7,-3,-5,5,-7,-2,6,7,5,-3,-2,7,-5,-2,2,-4,4,-9,-10,12,-2,-2,-1,-2,4], [0,0,-2,0,-1,1,1,0,0,2,-2,-1,1,2,1,-2,-1,1,-1,0,0,1,2,-2,-2,2,1,-1,1,-1,0], [3,2,5,-1,4,-5,-5,1,3,-7,5,4,-6,-8,-3,5,2,-5,5,3,0,2,-5,6,6,-9,0,2,-3,3,-4], [5,1,4,-1,3,-8,-7,3,5,-5,6,2,-6,-7,-4,3,1,-6,6,2,-2,4,-4,8,9,-11,2,2,0,2,-4], [-4,-2,-6,1,-3,4,4,-1,0,7,-6,-5,5,6,5,-5,-4,5,-4,-2,-1,0,5,-5,-6,9,1,-1,3,-1,3], [-1,0,0,0,-1,2,1,-1,-1,1,-1,-1,1,2,1,-1,0,2,-1,-1,1,-1,1,-2,-2,3,-1,0,0,-1,1], [-4,-1,-5,1,-3,7,6,-2,-4,6,-7,-3,6,7,5,-4,-2,6,-5,-2,1,-2,5,-8,-9,11,-1,-2,0,-3,4], [-5,-2,-7,1,-4,8,7,-3,-4,9,-8,-5,8,10,6,-6,-3,8,-7,-4,1,-3,7,-10,-10,14,-1,-3,3,-3,5], [4,1,5,-1,4,-7,-7,2,5,-7,7,3,-7,-9,-3,5,2,-6,6,3,-1,4,-5,8,8,-11,1,2,-2,3,-5], [-2,-1,-2,0,-2,2,1,-1,0,4,-3,-3,3,5,2,-3,-2,4,-2,-2,0,-1,2,-2,-3,5,0,0,2,-1,2], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [9,2,10,-3,8,-16,-15,5,11,-13,14,6,-14,-17,-9,9,3,-13,13,6,-3,8,-11,18,19,-24,3,5,-2,6,-10], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [3,0,3,-1,2,-6,-5,1,4,-3,4,1,-4,-5,-2,2,0,-4,4,2,-1,3,-3,6,6,-7,2,2,0,2,-3]]]], [ # Q-class [31][03] [[5], [1,5], [1,0,5], [0,1,1,5], [-1,1,0,1,5], [-1,-1,1,1,1,5], [1,0,-2,0,0,-1,6], [1,1,2,-2,0,-2,-2,6], [2,0,0,-2,-1,-2,0,2,6], [2,2,0,2,2,0,0,-1,-1,6], [0,2,1,2,2,-2,0,1,0,1,6], [2,0,2,0,0,2,1,-1,1,1,-1,6], [-2,-2,2,2,0,2,-2,-1,-2,-2,1,0,6], [0,0,-2,0,-2,-2,1,-2,1,0,1,-1,0,6], [0,-1,-1,0,0,2,-1,-2,-1,2,-3,1,-1,-2,6], [-1,2,1,2,2,0,0,0,1,-1,2,-1,1,-1,-2,6], [-1,-2,-2,0,0,-2,3,-1,1,-2,1,-2,0,2,-2,1,6], [-2,2,-1,1,2,0,-1,-1,1,1,1,-1,0,2,-1,3,0,6], [2,1,0,2,0,2,-1,-2,-1,3,-1,2,0,-1,3,-1,-3,0,6], [0,-2,2,0,0,2,-3,0,2,-1,-1,1,2,-1,1,1,-1,1,1,6], [-1,1,-1,2,1,-2,1,-1,-2,2,2,-3,-1,1,0,1,2,1,-1,-2,6], [-2,0,0,2,0,2,-3,-1,-1,-1,0,-1,3,1,0,1,-1,2,1,2,-1,6], [2,0,0,0,0,-2,2,2,-1,1,1,0,-1,-1,-1,-2,1,-3,0,-3,1,-3,6], [0,-2,0,0,0,-2,0,0,2,-1,2,-1,1,3,-2,0,3,1,-2,1,1,0,0,6], [-2,2,-2,1,0,-2,1,0,-1,1,2,-2,-1,2,-1,0,1,2,-1,-3,3,0,1,0,6], [0,0,-2,0,-1,0,3,-3,0,1,0,2,-1,3,0,-2,1,0,0,-2,0,-1,0,0,2,6], [-2,0,0,1,-1,-1,0,0,0,-1,2,0,2,2,-2,0,1,1,-1,-1,0,1,1,1,3,2,6], [-1,1,-2,1,0,2,1,-3,-2,0,-1,1,1,1,1,0,-1,1,2,-2,-1,2,-1,-2,1,2,1,6], [-2,2,-1,2,2,2,0,-2,-3,1,1,0,1,0,0,1,-1,2,1,-1,1,2,-1,-2,2,2,1,3,6], [2,2,1,1,0,2,-1,-1,-1,1,0,2,1,0,0,0,-3,0,3,1,-2,2,-1,-2,-2,0,-1,2,2,6], [2,1,2,0,-1,0,-2,3,0,1,-1,-1,-1,-2,0,0,-2,-1,1,1,0,0,1,-2,-1,-3,-2,-2,-1,1,6]], [[[0,0,0,0,0,1,0,-1,1,0,0,-1,0,0,0,0,-1,0,-1,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,1,-1,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,-1,0,0], [0,0,0,0,1,0,-1,-1,0,-1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,-1,0,1], [-1,-1,-1,0,1,-1,0,0,0,0,0,1,0,1,0,1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,-1,1,0,0,0,1,0,0,0,1,0,1,0,0,0,-1,0,0,0,-1,-1,0,0,-1,0,0,0,0,0], [1,-1,-1,0,0,0,-1,0,0,0,0,1,0,-1,-1,0,0,0,0,-1,1,0,-1,0,0,0,0,0,0,0,0], [0,-1,0,-1,-1,1,1,1,0,1,1,0,0,1,1,1,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0], [0,1,1,0,0,0,0,-1,0,-1,0,-1,0,-1,0,-1,0,1,0,0,0,0,0,0,0,1,0,0,-1,0,0], [-1,1,1,0,0,1,0,-1,2,0,0,-1,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [-1,0,-1,1,1,0,0,1,0,0,-1,0,0,2,0,1,-1,-2,0,1,0,-1,0,0,0,0,0,0,0,0,0], [-1,0,0,1,1,-1,0,0,0,-1,0,0,0,1,1,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,1], [1,-1,0,0,1,1,-1,0,1,-1,0,0,0,1,0,0,0,0,0,-1,1,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,1,-1,-1,-1,0,-1,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,-1,0,1,0,0,0,0,-1,1,0,0], [0,0,0,0,0,0,0,1,0,1,-1,0,0,0,-1,0,0,-1,0,1,1,0,0,0,0,0,0,1,0,0,-1], [-1,0,-1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [-2,0,1,0,-1,0,1,0,1,1,1,0,0,1,1,0,0,0,0,0,-1,0,1,0,0,-1,-1,0,1,0,0], [-1,0,-1,0,0,0,0,1,0,0,0,1,0,1,0,1,0,-1,1,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,-1,0,1,0,0,0,1,0,-1,0,1,0,-1,0,-1,-1,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,-1,1,0,0,0,0,-1,-1,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,-1,1,1,-1,1,0,0,0,1,1,1,0,-1,0,1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,-1,-1,-1,0,0,0,1,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,1,0,1,0,0,-1,0,-1,0,1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,0,0,0,-1,1,0,0,0,0,1,1,0,0,0,0,-1,-1,0,1,0,0,-1,0,-1,1,0,0], [-1,0,0,0,0,-1,1,2,-1,0,0,0,0,1,1,1,0,0,1,1,0,0,0,0,-1,1,0,0,0,0,0], [1,-1,0,0,0,0,0,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,1,0,2,-1,0,0,0,-2,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1], [0,-1,-1,0,0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0], [1,-1,-1,0,0,-1,0,1,-1,0,0,1,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [1,0,-1,0,0,0,-1,-1,0,0,0,0,0,-1,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,-1,0,-1,-1,0,-1,0,0,0,0,0,0,0,0,1,0,0,-1,0,0]], [[-2,0,0,0,-1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,1,0], [0,1,0,0,0,0,0,-1,1,0,-1,0,1,-1,-1,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,-1,0,0,1,0,0], [-1,-1,0,0,-1,0,1,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,1,1,0,1,0,0,-1,1,0,-1,-1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0], [1,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,0,0,1,0,0,0,1], [-2,0,0,0,0,0,1,1,1,0,0,0,0,1,0,0,-1,-1,1,0,1,0,0,0,-1,0,0,0,0,0,0], [1,1,0,0,0,0,-1,-1,0,-1,0,0,0,-1,0,-1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,1,0,0,0,1,1,1,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0], [-1,0,0,0,-1,0,0,-1,1,1,0,0,0,-1,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,1,0], [-1,1,0,0,0,0,0,0,0,0,-1,0,0,1,0,1,0,-1,0,1,0,0,1,0,0,0,0,0,0,0,0], [0,-1,0,0,-1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,-1,0,0,1,0,0], [0,-1,0,1,0,0,0,1,-1,0,0,0,-1,1,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [-2,0,-1,1,0,0,0,1,0,0,0,1,0,2,0,1,-1,-1,0,1,0,-1,1,0,0,0,-1,0,0,0,0], [1,-1,0,-1,-1,0,0,-1,0,1,1,0,0,-2,0,0,0,1,-1,-1,0,1,0,0,0,0,0,0,0,0,0], [-1,1,1,0,1,0,1,0,1,0,-1,-1,1,1,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,1,0,1,1,0,-1,0,0,0,2,1,1,-1,-1,1,0,0,0,0,0,0,0,0,-1,0,0,0], [-1,1,0,1,1,0,0,0,1,0,-1,0,1,1,0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,-1,0,0,-1,0,0,0,0,1,0,0,0,-1,0,0,0,1,-1,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1,-1,1,0,0,0,1,1,1,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,0,0,0,1,-1,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0], [-1,0,0,0,-1,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0], [-2,1,0,1,0,0,0,1,0,0,0,0,0,2,1,1,0,-1,0,1,-1,-1,1,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,-1,-1,0,0,0,0,1,0,0,0,1,0,1,0,1,-1,-1,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,-1,0,0,1,-1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,-1,0,0,0,1,0,0,1,0,0,0,0,0,-1,0,-1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,1,0,0,0,0,0,-1,0,0,0,-1,0,0,-1,0,0,1,0,-1,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,1,1,0,0,0,0,0,0,0,0,0,0,0,1,0]]]], [ # Q-class [31][04] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]] ]; MakeImmutable( IMFList[31].matrices ); gap-4r6p5/grp/ree.gi0000644000175000017500000000473612172557252013037 0ustar billbill############################################################################# ## #W ree.gi GAP library ## ## #Y (C) 2001 School Math. Sci., University of St Andrews, Scotland ## ############################################################################# ## #M ReeGroupCons( , ) ## InstallMethod(ReeGroupCons,"matrix",true, [IsMatrixGroup,IsPosInt],0, function ( filter, q ) local theta, m, f, bas, one, zero, x, h, r, gens, G, i; m:=Int((LogInt(q,3)-1)/2); if m<0 or q<>3^(1+2*m) then Error("Usage: ReeGroup(,3^(1+2m))"); fi; theta:=3^m; f:=GF(q); bas:=BasisVectors(Basis(f)); one:=One(f); zero:=Zero(f); x:=function(t,u,v) return [[1,t^theta,-u^theta,(t*u)^theta-v^theta,-u-t^(3*theta+1)-(t*v)^theta, -v-(u*v)^theta-t^(3*theta+2)-t^theta*u^(2*theta), t^theta*v-u^(theta+1)+t^(4*theta+2)-v^(2*theta) -t^(3*theta+1)*u^theta-(t*u*v)^theta], [0,1,t,u^theta+t^(theta+1), -t^(2*theta+1)-v^theta,-u^(2*theta)+t^(theta+1)*u^theta+t*v^theta, v+t*u-t^(2*theta+1)*u^theta-(u*v)^theta-t^(3*theta+2)-t^(theta+1)*v^theta], [0,0,1,t^theta,-t^(2*theta),v^theta+(t*u)^theta, u+t^(3*theta+1)-(t*v)^theta-t^(2*theta)*u^theta], [0,0,0,1,t^theta,u^theta,(t*u)^theta-v^theta], [0,0,0,0,1,-t,u^theta+t^(theta+1)], [0,0,0,0,0,1,-t^theta], [0,0,0,0,0,0,1]]*one; end; h:=function(t) return [[t^theta,0,0,0,0,0,0], [0,t^(1-theta),0,0,0,0,0], [0,0,t^(2*theta-1),0,0,0,0], [0,0,0,1,0,0,0], [0,0,0,0,t^(1-2*theta),0,0], [0,0,0,0,0,t^(theta-1),0], [0,0,0,0,0,0,t^(-theta)]]*one; end; r:=[[0,0,0,0,0,0,-1], [0,0,0,0,0,-1,0], [0,0,0,0,-1,0,0], [0,0,0,-1,0,0,0], [0,0,-1,0,0,0,0], [0,-1,0,0,0,0,0], [-1,0,0,0,0,0,0]]*one; # this generating set is not very good -- there is a 2-generator set. AH gens:=[]; for i in bas do Add(gens,x(i,zero,zero)); Add(gens,x(zero,i,zero)); Add(gens,x(zero,zero,i)); od; Add(gens,h(PrimitiveRoot(f))); Add(gens,r); G:=Group(gens,One(gens[1])); SetName(G,Concatenation("Ree(",String(q),")")); SetDimensionOfMatrixGroup(G,7); SetFieldOfMatrixGroup(G,f); SetIsFinite(G,true); SetSize(G,q^3*(q-1)*(q^3+1)); if q > 3 then SetIsSimpleGroup(G,true); fi; return G; end ); PermConstructor(ReeGroupCons,[IsPermGroup,IsObject], IsMatrixGroup); ############################################################################# ## #E ree.gi . . . . . . . . . . . . . . . . . . . . . . . . . . . . ends here gap-4r6p5/grp/perf10.grp0000644000175000017500000011167712172557252013555 0ustar billbill############################################################################# ## #W perf10.grp GAP Groups Library Volkmar Felsch ## Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains the perfect groups of sizes 352440-518400 ## All data is based on Holt/Plesken: Perfect Groups, OUP 1989 ## PERFGRP[202]:=[# 352440.1 [[1,"abc", function(a,b,c) return [[c^44,c*b^9*c^-1*b^-1,b^89,a^2,c*a*c*a^-1, (b*a)^3,c^-1*b^3*c*b^3*a*b^3*a*c*b^3*a], [[b,c]]]; end, [90]], "L2(89)",22,-1, 44,90] ]; PERFGRP[203]:=[# 357840.1 [[1,"abc", function(a,b,c) return [[c^35*a^2,c*b^(-1*22)*c^-1*b^-1,b^71,a^4,a^2 *b^-1*a^2*b,a^2*c^-1*a^2*c, c*a*c*a^-1,(b*a)^3],[[b,c^2]]]; end, [144],[0,3,5,3]], "L2(71) 2^1 = SL(2,71)",22,-2, 37,144] ]; PERFGRP[204]:=[# 360000.1 [[2,120,1,3000,1], "( A5 x A5 ) 2^2 # 5^2",[30,2,1],2, [1,1],[24,25]] ]; PERFGRP[205]:=[# 362880.1 [[1,"abd", function(a,b,d) return [[a^2*d^-1,b^4,(a*b)^9,(a^-1*b^-1*a*b)^4 *d^-1,(a*b^(-1*2)*a*b^-1*a*b*a*b^2)^3, (a*b^-1*a*b^-1*a*b^2*a*b^2*a*b*a*b)^2 *d^-1,(a*b*a*b*b*a*b*a*b*a*b^-1)^3, (a*b*a*b*a*b^2)^6,d^2,a^-1*d*a*d^-1, b^-1*d*b*d^-1], [[(a*b*a*b*a*b^2)^2,(a*b*a*b*a*b*a*b^2)^3*d]]]; end, [240],[[1,2]]], "A9 2^1",28,-2, 38,240], # 362880.2 [[2,168,1,2160,1], "( L3(2) x A6 3^1 ) 2^1 [1]",[37,1,1],6, [2,3],[7,18,80]], # 362880.3 [[2,336,1,1080,1], "( L3(2) x A6 3^1 ) 2^1 [2]",[37,1,2],6, [2,3],[16,18]], # 362880.4 [[3,336,1,2160,1,"d1","d2"], "( L3(2) x A6 3^1 ) 2^1 [3]",[37,1,3],6, [2,3],[144,640]], # 362880.5 [[2,720,1,504,1], "A6 2^1 x L2(8)",40,2, [3,4],[80,9]], # 362880.6 [[2,60,1,6048,1], "A5 x U3(3)",40,1, [1,12],[5,28]] ]; PERFGRP[206]:=[# 363000.1 [[4,3000,2,14520,2,120,1,1], "A5 2^1 # 5^2 11^2",6,1, 1,[25,121]] ]; PERFGRP[207]:=[# 364320.1 [[2,60,1,6072,1], "A5 x L2(23)",40,1, [1,13],[5,24]] ]; PERFGRP[208]:=[# 366912.1 [[2,168,1,2184,1], "( L3(2) x L2(13) ) 2^1 [1]",40,2, [2,6],[7,56]], # 366912.2 [[2,336,1,1092,1], "( L3(2) x L2(13) ) 2^1 [2]",40,2, [2,6],[16,14]], # 366912.3 [[3,336,1,2184,1,"d1","a2","a2"], "( L3(2) x L2(13) ) 2^1 [3]",40,2, [2,6],448] ]; PERFGRP[209]:=[# 367416.1 [[1,"abuvwxyzd", function(a,b,u,v,w,x,y,z,d) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,d^3,a^-1 *d*a*d^-1,b^-1*d*b*d^-1, u^-1*d*u*d^-1,v^-1*d*v*d^-1, w^-1*d*w*d^-1,x^-1*d*x*d^-1, y^-1*d*y*d^-1,z^-1*d*z*d^-1,u^3, v^3,w^3,x^3,y^3,z^3,u^-1*v^-1*u*v*d, u^-1*w^-1*u*w*d^-1, u^-1*x^-1*u*x*d^-1, u^-1*y^-1*u*y*d^-1,u^-1*z^-1*u *z,v^-1*w^-1*v*w*d^-1, v^-1*x^-1*v*x*d,v^-1*y^-1*v*y*d, v^-1*z^-1*v*z*d,w^-1*x^-1*w*x, w^-1*y^-1*w*y*d^-1, w^-1*z^-1*w*z*d^-1, x^-1*y^-1*x*y*d^-1, x^-1*z^-1*x*z*d,y^-1*z^-1*y*z*d, a^-1*u*a*(x*y^-1*z^-1*d)^-1, a^-1*v*a*(w*x^-1*y^-1*d)^-1, a^-1*w*a*(u*w^-1*x*y^-1*z^-1)^-1 ,a^-1*x*a*(v*w*x*y^-1)^-1, a^-1*y*a*(u*v*w*z^-1*d)^-1, a^-1*z*a*(u*x*y^-1*z*d^-1)^-1, b^-1*u*b*(v*w^-1*x^-1)^-1, b^-1*v*b*(u*v^-1*w^-1*d^-1)^-1, b^-1*w*b*(u^-1*v*w^-1*x^-1*z^-1) ^-1,b^-1*x*b*(u*v*w^-1*y^-1*z*d) ^-1,b^-1*y*b*(u*x^-1*y*d)^-1, b^-1*z*b*(v*w^-1*x*z)^-1],[[a,b]]]; end, [2187]], "L3(2) 3^6 C 3^1",[9,7,1],3, 2,2187], # 367416.2 [[1,"abtuvwxyz", function(a,b,t,u,v,w,x,y,z) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,t^3,u^3, v^3,w^3,x^3,y^3,z^3,t^-1*u^-1*t*u, t^-1*v^-1*t*v,t^-1*w^-1*t*w, t^-1*x^-1*t*x,t^-1*y^-1*t*y, t^-1*z^-1*t*z,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*t*a*t^-1,a^-1*u*a*w^-1, a^-1*v*a*v,a^-1*w*a*u^-1, a^-1*x*a*z^-1,a^-1*y*a*y, a^-1*z*a*x^-1,b^-1*t*b*u^-1, b^-1*u*b*v^-1,b^-1*v*b*t^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1], [[a*b,t*u^-1]]]; end, [72]], "L3(2) 3^7",[9,7,2],1, 2,72], # 367416.3 [[1,"abtuvwxyz", function(a,b,t,u,v,w,x,y,z) return [[a^2,b^3*(t*u*v*z^-1)^-1,(a*b)^7,(a^-1*b ^-1*a*b)^4,t^3,u^3,v^3,w^3,x^3,y^3,z^3, t^-1*u^-1*t*u,t^-1*v^-1*t*v, t^-1*w^-1*t*w,t^-1*x^-1*t*x, t^-1*y^-1*t*y,t^-1*z^-1*t*z, u^-1*v^-1*u*v,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*t*a*t^-1, a^-1*u*a*w^-1,a^-1*v*a*v, a^-1*w*a*u^-1,a^-1*x*a*z^-1, a^-1*y*a*y,a^-1*z*a*x^-1, b^-1*t*b*u^-1,b^-1*u*b*v^-1, b^-1*v*b*t^-1,b^-1*w*b*x^-1, b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1],[[a*b,t*u^-1]]]; end, [72]], "L3(2) N 3^7",[9,7,3],1, 2,72] ]; PERFGRP[210]:=[fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail]; PERFGRP[211]:=[# 369096.1 [[1,"abcyz", function(a,b,c,y,z) return [[a^4,b^13,(a*b)^3,c^6*a^2,(a*c)^2*a^2,a^2*b^-1 *a^2*b,c^-1*b*c*b^(-1*4), b^6*a*b^-1*a*b*a*b^7*a*c^-1,y^13,z^13, y^-1*z^-1*y*z,a^-1*y*a*z, a^-1*z*a*y^-1,b^-1*y*b*y^-1, b^-1*z*b*(y*z)^-1,c^-1*y*c*y^(-1*2), c^-1*z*c*z^(-1*7)],[[a,b]]]; end, [169]], "L2(13) 2^1 13^2",[20,2,1],1, 6,169] ]; PERFGRP[212]:=[# 372000.1 [[1,"ab", function(a,b) return [[a^2,b^3,(a*b)^31,(a^-1*b^-1*a*b)^4,(a*b*a*b*a *b*a*b*a*b^-1)^4, (a*b^-1*a*b^-1*a*b^-1*a*b^-1*a *b^-1*a*b*a*b*a*b*a*b*a*b)^3], [[a,(b^-1*a)^3*b*(a*b*a*b^-1)^2]]]; end, [31]], "L3(5)",28,-1, 45,31] ]; PERFGRP[213]:=[# 375000.1 [[1,"abvwxyz", function(a,b,v,w,x,y,z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,v^5,w^5,x^5,y^5, z^5,v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*v*a*z^-1,a^-1*w*a*y, a^-1*x*a*x^-1,a^-1*y*a*w, a^-1*z*a*v^-1,b^-1*v*b*z^-1, b^-1*w*b*(y^-1*z)^-1, b^-1*x*b*(x*y^(-1*2)*z)^-1, b^-1*y*b*(w^-1*x^(-1*2)*y^2*z)^-1, b^-1*z*b*(v*w*x*y*z)^-1], [[a*b,v],[a*b,b*a*b*a*b^-1*a*b^-1,w]]]; end, [24,30]], "A5 2^1 x 5^5",[3,5,1],2, 1,[24,30]], # 375000.2 [[1,"abwxyzd", function(a,b,w,x,y,z,d) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,w^5,x^5,y^5,z^5, d^5,d^-1*a*d*a^-1,d^-1*b*d*b^-1, d^-1*w*d*w^-1,d^-1*x*d*x^-1, d^-1*y*d*y^-1,d^-1*z*d*z^-1, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z*d,x^-1*y^-1*x*y *d^(-1*2),x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*w*a*z^-1, a^-1*x*a*y,a^-1*y*a*(x*d)^-1, a^-1*z*a*w,b^-1*w*b*z, b^-1*x*b*(y*z^-1*d^-1)^-1, b^-1*y*b*(x^-1*y^2*z^-1*d)^-1, b^-1*z*b*(w*x^2*y^(-1*2)*z^-1*d^(-1*2)) ^-1], [[a*b,b*a*b*a*b^-1*a*b^-1,y*d^2]]]; end, [750]], "A5 2^1 5^4 C 5^1",[3,5,2],5, 1,750], # 375000.3 [[1,"abyzXYZ", function(a,b,y,z,X,Y,Z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,y^5,z^5,X^5,Y^5, Z^5,y^-1*z^-1*y*z,y^-1*X^-1*y*X, y^-1*Y^-1*y*Y,y^-1*Z^-1*y*Z, z^-1*X^-1*z*X,z^-1*Y^-1*z*Y, z^-1*Z^-1*z*Z,X^-1*Y^-1*X*Y, X^-1*Z^-1*X*Z,Y^-1*Z^-1*Y*Z, a^-1*y*a*z^-1,a^-1*z*a*y, a^-1*X*a*Z^-1,a^-1*Y*a*Y, a^-1*Z*a*X^-1,b^-1*y*b*z, b^-1*z*b*(y*z^-1)^-1, b^-1*X*b*Z^-1, b^-1*Y*b*(Y^-1*Z)^-1, b^-1*Z*b*(X*Y^(-1*2)*Z)^-1], [[a*b,b*a*b*a*b^-1*a*b^-1,Y,y],[a,b,X]]]; end, [30,25]], "A5 2^1 5^2 x 5^3",[3,5,3],1, 1,[30,25]], # 375000.4 [[1,"abyzXYZ", function(a,b,y,z,X,Y,Z) return [[a^4,b^3,(a*b)^5*Z^-1,a^2*b^-1*a^2*b,y^5,z^5, X^5,Y^5,Z^5,y^-1*z^-1*y*z, y^-1*X^-1*y*X,y^-1*Y^-1*y*Y, y^-1*Z^-1*y*Z,z^-1*X^-1*z*X, z^-1*Y^-1*z*Y,z^-1*Z^-1*z*Z, X^-1*Y^-1*X*Y,X^-1*Z^-1*X*Z, Y^-1*Z^-1*Y*Z,a^-1*y*a*z^-1, a^-1*z*a*y,a^-1*X*a*Z^-1, a^-1*Y*a*Y,a^-1*Z*a*X^-1, b^-1*y*b*z,b^-1*z*b*(y*z^-1)^-1, b^-1*X*b*Z^-1, b^-1*Y*b*(Y^-1*Z)^-1, b^-1*Z*b*(X*Y^(-1*2)*Z)^-1], [[a*b,b*a*b*a*b^-1*a*b^-1,Y,y],[a,b,X]]]; end, [30,25]], "A5 2^1 5^2 x N 5^3",[3,5,4],1, 1,[30,25]], # 375000.5 [[1,"abyzYZf", function(a,b,y,z,Y,Z,f) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,y^5,z^5,Y^5,Z^5, f^5,y^-1*f^-1*y*f,Y^-1*f^-1*Y*f, y^-1*z^-1*y*z,y^-1*Y^-1*y*Y, y^-1*Z^-1*y*Z*f^-1, z^-1*Y^-1*z*Y*f,z^-1*Z^-1*z*Z, Y^-1*Z^-1*Y*Z,a^-1*y*a*z^-1, a^-1*z*a*y,a^-1*Y*a*Z^-1, a^-1*Z*a*Y,a^-1*f*a*f^-1, b^-1*y*b*z,b^-1*z*b*(y*z^-1)^-1, b^-1*Y*b*Z,b^-1*Z*b*(Y*Z^-1)^-1, b^-1*f*b*f^-1],[[a,b,y]]]; end, [125]], "A5 2^1 ( 5^2 x 5^2 ) C 5^1",[3,5,5],5, 1,125], # 375000.6 [[1,"abyzYZd", function(a,b,y,z,Y,Z,d) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,y^5,z^5,Y^5,Z^5, d^5,y^-1*d^-1*y*d,Y^-1*d^-1*Y*d, y^-1*z^-1*y*z*d^-1,y^-1*Y^-1*y *Y,y^-1*Z^-1*y*Z,z^-1*Y^-1*z*Y, z^-1*Z^-1*z*Z,Y^-1*Z^-1*Y*Z *d^(-1*2),a^-1*y*a*(z*d^2)^-1, a^-1*z*a*y,a^-1*Y*a*(Z*d^-1)^-1, a^-1*Z*a*Y,a^-1*d*a*d^-1, b^-1*y*b*z,b^-1*z*b*(y*z^-1)^-1, b^-1*Y*b*Z,b^-1*Z*b*(Y*Z^-1)^-1, b^-1*d*b*d^-1], [[a*b,b*a*b*a*b^-1*a*b^-1,z*d,Z*d^2]]]; end, [750]], "A5 2^1 ( 5^2 C x 5^2 C ) 5^1",[3,5,6],5, 1,750], # 375000.7 [[1,"abyzdYZ", function(a,b,y,z,d,Y,Z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,Y^5,Z^5,Y^-1 *Z^-1*Y*Z,y^-1*Y*y*Y^-1, y^-1*Z*y*Z^-1,z^-1*Y*z*Y^-1, z^-1*Z*z*Z^-1,d^-1*Y*d*Y^-1, d^-1*Z*d*Z^-1,y^5,z^5,d^5, y^-1*d^-1*y*d,z^-1*d^-1*z*d, y^-1*z^-1*y*z*d^-1, a^-1*y*a*z^-1*d^(-1*2),a^-1*z*a*y, a^-1*d*a*d^-1,a^-1*Y*a*Z^-1, a^-1*Z*a*Y,b^-1*y*b*z, b^-1*z*b*(y*z^-1)^-1,b^-1*Y*b*Z, b^-1*Z*b*(Y*Z^-1)^-1, b^-1*d*b*d^-1],[[a,b,y],[a,b,Y]]]; end, [25,125]], "A5 2^1 ( 5^2 C 5^1 ) x 5^2",[3,5,7],5, 1,[25,125]], # 375000.8 [[1,"abyzdYZ", function(a,b,y,z,d,Y,Z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,y^5,z^5,d^5,Y^5, Z^5,y^-1*d^-1*y*d*Y^-1, z^-1*d^-1*z*d*Z^-1, y^-1*z^-1*y*z*(d*Y*Z)^-1, y^-1*Y^-1*y*Y,z^-1*Y^-1*z*Y, d^-1*Y^-1*d*Y,y^-1*Z^-1*y*Z, z^-1*Z^-1*z*Z,d^-1*Z^-1*d*Z, a^-1*y*a*(z*d^2*Z^-1)^-1, a^-1*z*a*y,a^-1*d*a*d^-1, a^-1*Y*a*Z^-1,a^-1*Z*a*Y, b^-1*y*b*(z^-1*Z)^-1, b^-1*z*b*(y*z^-1*Y)^-1, b^-1*d*b*d^-1,b^-1*Y*b*Z, b^-1*Z*b*(Y*Z^-1)^-1], [[a*b,b*a*b*a*b^-1*a*b^-1,d,z*Y^-1]]]; end, [150]], "A5 2^1 5^2 C 5^1 C 5^2",[3,5,8],1, 1,150], # 375000.9 [[1,"abyzdYZ", function(a,b,y,z,d,Y,Z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,y^5,z^5,d^5,Y^5, Z^5,y^-1*d^-1*y*d*Y^-1, z^-1*d^-1*z*d*Z^-1, y^-1*z^-1*y*z*(d*Y*Z)^-1, y^-1*Y^-1*y*Y,z^-1*Y^-1*z*Y, d^-1*Y^-1*d*Y,y^-1*Z^-1*y*Z, z^-1*Z^-1*z*Z,d^-1*Z^-1*d*Z, a^-1*y*a*(z*d^2*Y^-1*Z^-1)^-1, a^-1*z*a*(y^-1*Z)^-1, a^-1*d*a*d^-1,a^-1*Y*a*Z^-1, a^-1*Z*a*Y, b^-1*y*b*(z^-1*Y^-1*Z^2)^-1, b^-1*z*b*(y*z^-1*Y*Z)^-1, b^-1*d*b*d^-1,b^-1*Y*b*Z, b^-1*Z*b*(Y*Z^-1)^-1], [[b*a*b*a*b^-1*a*b^-1,d,z*Y]]]; end, [750]], "A5 2^1 5^2 C 5^1 C E 5^2",[3,5,9],1, 1,750], # 375000.10 [[1,"abyzdYZ", function(a,b,y,z,d,Y,Z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,d^5,y^5,z^5,Y^5, Z^5,d^-1*y^-1*d*y,d^-1*z^-1*d*z, d^-1*Y^-1*d*Y,d^-1*Z^-1*d*Z, y^-1*z^-1*y*z*d^-1,y^-1*Y^-1*y *Y,y^-1*Z^-1*y*Z,z^-1*Y^-1*z*Y, z^-1*Z^-1*z*Z,Y^-1*Z^-1*Y*Z, a^-1*y*a*(z*d^2*Y^-1)^-1, a^-1*z*a*(y^-1*Z)^-1, a^-1*d*a*d^-1,a^-1*Y*a*Z^-1, a^-1*Z*a*Y, b^-1*y*b*(z^-1*Y^-1*Z)^-1, b^-1*z*b*(y*z^-1*Z)^-1, b^-1*d*b*d^-1,b^-1*Y*b*Z, b^-1*Z*b*(Y*Z^-1)^-1], [[a,b,Y],[b,a*b*a*b^-1*a,y*Y^-1*Z^-1]]]; end, [125,125]], "A5 2^1 5^2 ( C 5^1 x E 5^2 )",[3,5,10],5, 1,[125,125]], # 375000.11 [[1,"abyzYZe", function(a,b,y,z,Y,Z,e) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,e^5,y^-1*e*y *e^-1,z^-1*e*z*e^-1, Y^-1*e*Y*e^-1,Z^-1*e*Z*e^-1,y^5, z^5,Y^5,Z^5,y^-1*z^-1*y*z, y^-1*Y^-1*y*Y,y^-1*Z^-1*y*Z *e^-1,z^-1*Y^-1*z*Y*e, z^-1*Z^-1*z*Z,Y^-1*Z^-1*Y*Z, a^-1*y*a*(z*Y^-1*e^-1)^-1, a^-1*z*a*(y^-1*Z*e^(-1*2))^-1, a^-1*Y*a*Z^-1,a^-1*Z*a*Y, a^-1*e*a*e^-1, b^-1*y*b*(z^-1*Y^-1*Z*e^(-1*2))^-1, b^-1*z*b*(y*z^-1*Z*e^-1)^-1, b^-1*Y*b*Z,b^-1*Z*b*(Y*Z^-1)^-1, b^-1*e*b*e^-1],[[a,b,Y]]]; end, [125]], "A5 2^1 ( 5^2 E 5^2 ) C 5^1",[3,5,11],5, 1,125] ]; PERFGRP[214]:=[# 378000.1 [[1,"abd", function(a,b,d) return [[a^2,b^4,(a*b)^10*d^-1,(a*b*a*b^2)^7,a*b^-1*a *b^-1*a*b*a *b^(-1*2)*a*b*a*b^-1 *a*b^-1*a*b*a*b*a *b^-1*a*b*b*a*b^-1*a*b*a*b, (a*b^-1*a*b^-1*a*b*a*b*a*b)^2*b*a *b^-1*a*b^-1*a*b*a*b*a*b^-1 ,d^3,a^-1*d*a*d^-1,b^-1*d*b*d^-1], [[b*a*b^2*a*b*a*b^-1*a*b^2*a*b^-1, a*b*a*b*a*b^2*d^-1]]]; end, [378],[[1,2]]], "U3(5) 3^1",28,-3, 34,378] ]; PERFGRP[215]:=[# 384000.1 [[4,15360,2,3000,2,120,2,1], "A5 # 2^8 5^2",6,8, 1,[24,12,64,25]] ]; PERFGRP[216]:=[# 387072.1 [[1,"abuvwxyz", function(a,b,u,v,w,x,y,z) return [[a^2,b^6,(a*b)^7,(a*b^2)^3*(a*b^(-1*2))^3,(a*b*a*b ^(-1*2))^3*a*b*(a*b^-1)^2,u^2,v^2,w^2, x^2,y^2,z^2,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*u*a*(u*z)^-1, a^-1*v*a*(u*v*x*z)^-1, a^-1*w*a*(u*w*x*z)^-1, a^-1*x*a*(x*z)^-1, a^-1*y*a*(u*x*y)^-1,a^-1*z*a*z^-1, b^-1*u*b*(u*w*x*y*z)^-1, b^-1*v*b*(u*x*z)^-1, b^-1*w*b*(u*w*z)^-1, b^-1*x*b*(u*v*w*x*z)^-1, b^-1*y*b*(v*y*z)^-1, b^-1*z*b*(u*v*w*x*y*z)^-1],[[a,b]]]; end, [64]], "U3(3) 2^6",[25,6,1],1, 12,64], # 387072.2 [[1,"abuvwxyz", function(a,b,u,v,w,x,y,z) return [[a^2*(u*x*z)^-1,b^6,(a*b)^7,(a*b^2)^3*(a*b^(-1*2)) ^3*(w*y*z)^-1, (a*b*a*b^(-1*2))^3*a*b*(a*b^-1)^2 *(w*x*y)^-1,u^2,v^2,w^2,x^2,y^2,z^2, u^-1*v^-1*u*v,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*u*a*(u*z)^-1, a^-1*v*a*(u*v*x*z)^-1, a^-1*w*a*(u*w*x*z)^-1, a^-1*x*a*(x*z)^-1, a^-1*y*a*(u*x*y)^-1,a^-1*z*a*z^-1, b^-1*u*b*(u*w*x*y*z)^-1, b^-1*v*b*(u*x*z)^-1, b^-1*w*b*(u*w*z)^-1, b^-1*x*b*(u*v*w*x*z)^-1, b^-1*y*b*(v*y*z)^-1, b^-1*z*b*(u*v*w*x*y*z)^-1], [[b^3,a*b^3*a*y, (b*a)^2*(b^-1*a)^2*b^3*(a*b)^2*(a*b^-1) ^2*y]]]; end, [504],[0]], "U3(3) N 2^6",[25,6,2],1, 12,504] ]; PERFGRP[217]:=[# 388800.1 [[2,360,1,1080,1], "( A6 x A6 ) 3^1 [1]",40,3, [3,3],[6,18]], # 388800.2 [[3,1080,1,1080,1,"a1","a1","a2","a2"], "( A6 x A6 ) 3^1 [2]",40,3, [3,3],108] ]; PERFGRP[218]:=[# 388944.1 [[1,"abc", function(a,b,c) return [[c^36*a^2,c*b^25*c^-1*b^-1,b^73,a^4,a^2*b^(-1 *1)*a^2*b,a^2*c^-1*a^2*c, c*a*c*a^-1,(b*a)^3, c^(-1*10)*b^2*c*b*c*a*b*c^2*b*a*b^2*c*b*a], [[b,c^8]]]; end, [592],[0,3,6,3]], "L2(73) 2^1 = SL(2,73)",22,-2, 39,592] ]; PERFGRP[219]:=[# 393120.1 [[2,360,1,1092,1], "A6 x L2(13)",40,1, [3,6],[6,14]] ]; PERFGRP[220]:=[# 393660.1 [[1,"abwxyzWXYZ", function(a,b,w,x,y,z,W,X,Y,Z) return [[a^2,b^3,(a*b)^5,w^3,x^3,y^3,z^3,W^3,X^3,Y^3,Z^3,W ^-1*X^-1*W*X,W^-1*Y^-1*W*Y, W^-1*Z^-1*W*Z,X^-1*Y^-1*X*Y, X^-1*Z^-1*X*Z,Y^-1*Z^-1*Y*Z, w^-1*W*w*W^-1,w^-1*X*w*X^-1, w^-1*Y*w*Y^-1,w^-1*Z*w*Z^-1, x^-1*W*x*W^-1,x^-1*X*x*X^-1, x^-1*Y*x*Y^-1,x^-1*Z*x*Z^-1, y^-1*W*y*W^-1,y^-1*X*y*X^-1, y^-1*Y*y*Y^-1,y^-1*Z*y*Z^-1, z^-1*W*z*W^-1,z^-1*X*z*X^-1, z^-1*Y*z*Y^-1,z^-1*Z*z*Z^-1, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1, a^-1*W*a*Z^-1,a^-1*X*a*X^-1, a^-1*Y*a*(W^2*X^2*Y^2*Z^2)^-1, a^-1*Z*a*W^-1,b^-1*W*b*X^-1, b^-1*X*b*Y^-1,b^-1*Y*b*W^-1, b^-1*Z*b*Z^-1], [[b,a*b*a*b^-1*a,w*x^-1,W], [b,a*b*a*b^-1*a,W*X^-1,w]]]; end, [15,15]], "A5 3^4' x 3^4'",[2,8,1],1, 1,[15,15]], # 393660.2 [[1,"abwxyz", function(a,b,w,x,y,z) return [[a^2,b^3,(a*b)^5,w^9,x^9,y^9,z^9,w^-1*x^-1*w *x,w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*w*a*z^-1, a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1], [[b,a*b*a*b^-1*a,w*x^-1]]]; end, [45]], "A5 3^4' A 3^4'",[2,8,2],1, 1,45], # 393660.3 [[1,"abwxyzWXYZ", function(a,b,w,x,y,z,W,X,Y,Z) return [[a^2,b^3*Z^-1,(a*b)^5,w^3,x^3,y^3,z^3,W^3,X^3, Y^3,Z^3,W^-1*X^-1*W*X,W^-1*Y^-1*W*Y ,W^-1*Z^-1*W*Z,X^-1*Y^-1*X*Y, X^-1*Z^-1*X*Z,Y^-1*Z^-1*Y*Z, w^-1*W*w*W^-1,w^-1*X*w*X^-1, w^-1*Y*w*Y^-1,w^-1*Z*w*Z^-1, x^-1*W*x*W^-1,x^-1*X*x*X^-1, x^-1*Y*x*Y^-1,x^-1*Z*x*Z^-1, y^-1*W*y*W^-1,y^-1*X*y*X^-1, y^-1*Y*y*Y^-1,y^-1*Z*y*Z^-1, z^-1*W*z*W^-1,z^-1*X*z*X^-1, z^-1*Y*z*Y^-1,z^-1*Z*z*Z^-1, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1, a^-1*W*a*Z^-1,a^-1*X*a*X^-1, a^-1*Y*a*(W^2*X^2*Y^2*Z^2)^-1, a^-1*Z*a*W^-1,b^-1*W*b*X^-1, b^-1*X*b*Y^-1,b^-1*Y*b*W^-1, b^-1*Z*b*Z^-1], [[b,a*b*a*b^-1*a,w*x^-1,W],[b,z,W*X^-1,w] ]]; end, [15,60]], "A5 3^4' x N 3^4'",[2,8,3],1, 1,[15,60]], # 393660.4 [[1,"abwxyz", function(a,b,w,x,y,z) return [[a^2,b^3*z^-1,(a*b)^5,w^9,x^9,y^9,z^9,w^-1*x ^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1], [[b,w*x^-1]]]; end, [180]], "A5 N 3^4' A 3^4'",[2,8,4],1, 1,180] ]; PERFGRP[221]:=[# 410400.1 [[2,60,1,6840,1], "( A5 x L2(19) ) 2^1 [1]",40,2, [1,9],[5,40]], # 410400.2 [[2,120,1,3420,1], "( A5 x L2(19) ) 2^1 [2]",40,2, [1,9],[24,20]], # 410400.3 [[3,120,1,6840,1,"d1","a2","a2"], "( A5 x L2(19) ) 2^1 [3]",40,2, [1,9],480] ]; PERFGRP[222]:=[# 411264.1 [[2,168,1,2448,1], "L3(2) x L2(17)",40,1, [2,7],[7,18]] ]; PERFGRP[223]:=[# 411540.1 [[1,"abxyz", function(a,b,x,y,z) return [[a^2,b^3,(a*b)^5,x^19,y^19,z^19,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*x*a*z^-1,a^-1*y*a*y, a^-1*z*a*x^-1, b^-1*x*b*(x^(-1*2)*y^(-1*6)*z^5)^-1, b^-1*y*b*(x^(-1*8)*y^(-1*4)*z^(-1*7))^-1, b^-1*z*b*(x^6*y^7*z^6)^-1], [[a*b,b*a*b*a*b^-1*a*b^-1,y*z^(-1*2)]]]; end, [114],[0,0,2,2,2,3,3,3]], "A5 19^3",[5,3,1],1, 1,114] ]; PERFGRP[224]:=[# 417720.1 [[1,"abyz", function(a,b,y,z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,y^59,z^59,y^-1 *z^-1*y*z,a^-1*y*a*z^-1, a^-1*z*a*y,b^-1*y*b*(y^(-1*29)*z^21)^-1, b^-1*z*b*(y^(-1*5)*z^28)^-1],[[a,b]]]; end, [3481],[0,0,2,2,3,3,2]], "A5 2^1 59^2",[5,2,1],1, 1,3481] ]; PERFGRP[225]:=[# 423360.1 [[2,168,1,2520,1], "L3(2) x A7",40,1, [2,8],[7,7]] ]; PERFGRP[226]:=[# 432000.1 [[2,120,1,3600,1], "( A5 x A5 x A5 ) 2^1 [1]",40,2, [1,1,1],[24,5,5]], # 432000.2 [[2,60,1,7200,2], "( A5 x A5 x A5 ) 2^1 [2]",40,2, [1,1,1],[5,288]], # 432000.3 [[3,120,1,7200,2,"d1","a2","a2"], "( A5 x A5 x A5 ) 2^1 [3]",40,2, [1,1,1],3456] ]; PERFGRP[227]:=[# 435600.1 [[2,660,1,660,1], "L2(11) x L2(11)",40,1, [5,5],[11,11]] ]; PERFGRP[228]:=[# 443520.1 [[1,"ab", function(a,b) return [[a^2,b^4,(a*b)^11,(a*b*a*b^2)^7,(a*b*a*b^-1*a*b ^-1*a*b^2*a*b)^2*b*a*b^-1], [[b,a*b^-1*a*b*a]]]; end, [22]], "M22",28,-1, 46,22], # 443520.2 [[2,336,1,1320,1], "( L3(2) x L2(11) ) 2^2",[39,2,1],4, [2,5],[16,24]] ]; PERFGRP[229]:=[# 446520.1 [[1,"abyz", function(a,b,y,z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,y^61,z^61,y^-1 *z^-1*y*z,a^-1*y*a*z^-1, a^-1*z*a*y,b^-1*y*b*(y^-1*z^27)^-1, b^-1*z*b*y^(-1*9)],[[a*b,a^2,y]]]; end, [732],[0,0,2,2]], "A5 2^1 61^2",[5,2,1],1, 1,732] ]; PERFGRP[230]:=[# 447216.1 [[1,"abxyz", function(a,b,x,y,z) return [[a^4,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4*a^2,a^2*b *a^2*b^-1,x^11,y^11,z^11,x^-1*y^-1*x *y,x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*x*a*z^-1,a^-1*y*a*y, a^-1*z*a*x^-1, b^-1*x*b*(y^4*z^-1)^-1, b^-1*y*b*(x^5*y*z^(-1*5))^-1, b^-1*z*b*(x^(-1*5)*y^3*z^-1)^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,x], [b*a*b^-1,b^-1*a*b,a^2,z]]]; end, [16,231]], "L3(2) 2^1 x 11^3",[11,3,1],2, 2,[16,231]] ]; PERFGRP[231]:=[# 450000.1 [[2,60,1,7500,1], "A5 x A5 # 5^3 [1]",[30,3,1],1, [1,1],[5,30]], # 450000.2 [[2,60,1,7500,2], "A5 x A5 # 5^3 [2]",[30,3,2],1, [1,1],[5,30]], # 450000.3 [[1,"abcdxyzw", function(a,b,c,d,x,y,z,w) return [[ a^4, b^3, c^3, (a*b)^5, (b*c^-1)^5, a^2/d, (b*c)^4/d, Comm(d,b), Comm(d,c), c*(b*c*b)^2/(b*a*c), x^5, y^5, z^5, w^5, Comm(w,x), Comm(w,y), Comm(w,z), Comm(z,x), Comm(z,y), Comm(y,x), x^a/y, y^a*x, z^a*y*w, w^a/(x*z), x^b*y, y^b*y/x, z^b/(x^2*y^3*z^2*w^4), w^b*x*y/(z^2*w^2), x^c*z/(x*y*w), y^c/(x^2*y^3*z), Comm(z,c), Comm(w,c),], [[a,b,x,y]]]; end, [150]], "A6 2^1 # 5^4",[41,4,1],1, [3],[150]] ]; PERFGRP[232]:=[# 451584.1 [[2,168,1,2688,1], "( L3(2) x L3(2) ) # 2^4 [1]",[34,4,1],2, [2,2],[7,8,16]], # 451584.2 [[2,168,1,2688,2], "( L3(2) x L3(2) ) # 2^4 [2]",[34,4,2],2, [2,2],[7,16]], # 451584.3 [[2,168,1,2688,3], "( L3(2) x L3(2) ) # 2^4 [3]",[34,4,3],2, [2,2],[7,16,14]], # 451584.4 [[2,336,1,1344,1], "( L3(2) x L3(2) ) # 2^4 [4]",[34,4,4],2, [2,2],[16,8]], # 451584.5 [[2,336,1,1344,2], "( L3(2) x L3(2) ) # 2^4 [5]",[34,4,5],2, [2,2],[16,14]], # 451584.6 [[3,336,1,2688,1,"d1","d2"], "( L3(2) x L3(2) ) # 2^4 [6]",[34,4,6],2, [2,2],[64,128]], # 451584.7 [[3,336,1,2688,2,"d1","e2"], "( L3(2) x L3(2) ) # 2^4 [7]",[34,4,7],2, [2,2],128], # 451584.8 [[3,336,1,2688,3,"d1","d2"], "( L3(2) x L3(2) ) # 2^4 [8]",[34,4,8],2, [2,2],[128,112]] ]; PERFGRP[233]:=[# 453600.1 [[2,60,1,7560,1], "A5 x A7 3^1",40,3, [1,8],[5,45]] ]; PERFGRP[234]:=[# 456288.1 [[1,"abc", function(a,b,c) return [[c^48,c*b^25*c^-1*b^-1,b^97,a^2,c*a*c*a^-1 ,(b*a)^3,c^10*(b*c)^2*a*b*c^2*a*b*a*b^2*c*b*a ],[[b,c]]]; end, [98],[0,3,5,3]], "L2(97)",22,-1, 47,98] ]; PERFGRP[235]:=[# 460800.1 [[2,3840,1,120,1], "( A5 x A5 ) # 2^7 [1]",[29,7,1],8, [1,1],[64,24]], # 460800.2 [[2,3840,2,120,1], "( A5 x A5 ) # 2^7 [2]",[29,7,2],8, [1,1],[64,24]], # 460800.3 [[2,3840,3,120,1], "( A5 x A5 ) # 2^7 [3]",[29,7,3],8, [1,1],[24,24]], # 460800.4 [[2,3840,4,120,1], "( A5 x A5 ) # 2^7 [4]",[29,7,4],8, [1,1],[48,24]], # 460800.5 [[2,3840,5,120,1], "( A5 x A5 ) # 2^7 [5]",[29,7,5],8, [1,1],[24,12,24]], # 460800.6 [[2,3840,6,120,1], "( A5 x A5 ) # 2^7 [6]",[29,7,6],4, [1,1],[48,24]], # 460800.7 [[2,3840,7,120,1], "( A5 x A5 ) # 2^7 [7]",[29,7,7],8, [1,1],[32,24,24]], # 460800.8 [[2,7680,1,60,1], "( A5 x A5 ) # 2^7 [8]",[29,7,8],8, [1,1],[12,64,5]], # 460800.9 [[2,7680,2,60,1], "( A5 x A5 ) # 2^7 [9]",[29,7,9],8, [1,1],[24,64,5]], # 460800.10 [[2,7680,3,60,1], "( A5 x A5 ) # 2^7 [10]",[29,7,10],8, [1,1],[24,64,5]], # 460800.11 [[2,7680,4,60,1], "( A5 x A5 ) # 2^7 [11]",[29,7,11],8, [1,1],[24,64,5]], # 460800.12 [[2,7680,5,60,1], "( A5 x A5 ) # 2^7 [12]",[29,7,12],8, [1,1],[24,24,5]], # 460800.13 [[3,7680,1,120,1,"f1","d2"], "( A5 x A5 ) # 2^7 [13]",[29,7,13],8, [1,1],[144,768]], # 460800.14 [[3,7680,1,120,1,"e1","e1","d2"], "( A5 x A5 ) # 2^7 [14]",[29,7,14],8, [1,1],[144,768]], # 460800.15 [[3,7680,1,120,1,"f1","e1","e1","d2"], "( A5 x A5 ) # 2^7 [15]",[29,7,15],8, [1,1],[144,768]], # 460800.16 [[3,7680,2,120,1,"d1","d2"], "( A5 x A5 ) # 2^7 [16]",[29,7,16],8, [1,1],[288,768]], # 460800.17 [[3,7680,2,120,1,"e1","e1","d2"], "( A5 x A5 ) # 2^7 [17]",[29,7,17],8, [1,1],[288,768]], # 460800.18 [[3,7680,3,120,1,"d1","d2"], "( A5 x A5 ) # 2^7 [18]",[29,7,18],8, [1,1],[288,768]], # 460800.19 [[3,7680,3,120,1,"e1","e1","d2"], "( A5 x A5 ) # 2^7 [19]",[29,7,19],8, [1,1],[288,768]], # 460800.20 [[3,7680,4,120,1,"d1","d2"], "( A5 x A5 ) # 2^7 [20]",[29,7,20],8, [1,1],[288,768]], # 460800.21 [[3,7680,4,120,1,"e1","e1","d2"], "( A5 x A5 ) # 2^7 [21]",[29,7,21],8, [1,1],[288,768]], # 460800.22 [[3,7680,4,120,1,"d1","e1","e1","d2"], "( A5 x A5 ) # 2^7 [22]",[29,7,22],8, [1,1],[288,768]], # 460800.23 [[3,7680,5,120,1,"d1","d2"], "( A5 x A5 ) # 2^7 [23]",[29,7,23],8, [1,1],[288,288]], # 460800.24 [[3,7680,5,120,1,"e1","d2"], "( A5 x A5 ) # 2^7 [24]",[29,7,24],8, [1,1],[288,288]], # 460800.25 [[3,7680,5,120,1,"d1","e1","d2"], "( A5 x A5 ) # 2^7 [25]",[29,7,25],8, [1,1],[288,288]] ]; PERFGRP[236]:=[# 460992.1 [[4,1344,1,57624,1,168], "L3(2) # 2^3 7^3 [1]",12,1, 2,[8,56]], # 460992.2 [[4,1344,2,57624,1,168], "L3(2) # 2^3 7^3 [2]",12,1, 2,[14,56]], # 460992.3 [[4,1344,1,57624,2,168], "L3(2) # 2^3 7^3 [3]",12,1, 2,[8,56]], # 460992.4 [[4,1344,2,57624,2,168], "L3(2) # 2^3 7^3 [4]",12,1, 2,[14,56]] ]; PERFGRP[237]:=[# 464640.1 [[4,3840,5,14520,2,120,5,1], "A5 # 2^6 11^2 [1]",6,2, 1,[24,12,121]], # 464640.2 [[4,3840,6,14520,2,120,6,1], "A5 # 2^6 11^2 [2]",6,2, 1,[48,121]], # 464640.3 [[4,3840,7,14520,2,120,7,1], "A5 # 2^6 11^2 [3]",6,2, 1,[32,24,121]] ]; PERFGRP[238]:=[# 466560.1 [[1,"abdwxyzstuve", function(a,b,d,w,x,y,z,s,t,u,v,e) return [[a^2*d^-1,b^3,(a*b)^5,d^2,a^-1*d^-1*a*d, b^-1*d^-1*b*d,w^2,x^2,y^2,z^2,(w*x)^2*d, (w*y)^2*d,(w*z)^2*d,(x*y)^2*d,(x*z)^2*d,(y*z)^2*d, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*x*y*z)^-1,a^-1*z*a*w^-1 ,b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1, d^-1*w^-1*d*w,d^-1*x^-1*d*x, d^-1*y^-1*d*y,d^-1*z^-1*d*z,s^3, t^3,u^3,v^3,e^3,s^-1*t^-1*s*t*e^-1, s^-1*u^-1*s*u*e,s^-1*v^-1*s*v, t^-1*u^-1*t*u*e,t^-1*v^-1*t*v*e, u^-1*v^-1*u*v*e,s^-1*e*s*e^-1, t^-1*e*t*e^-1,u^-1*e*u*e^-1, v^-1*e*v*e^-1, a^-1*s*a*(s*t*u*v*e)^-1, a^-1*t*a*(s^-1*t*u*v^-1*e^-1)^-1 ,a^-1*u*a*(s^-1*u^-1*v)^-1, a^-1*v*a*(t*u^-1*v^-1*e)^-1, a^-1*e*a*e^-1, b^-1*s*b*(s^-1*t^-1*u*v^-1)^-1, b^-1*t*b*(s^-1*v^-1*e)^-1, b^-1*u*b*(s*t^-1*u^-1*v^-1)^-1, b^-1*v*b*(t^-1*u^-1*e)^-1, b^-1*e*b*e^-1,d^-1*s*d*s, d^-1*t*d*(t^-1*e)^-1, d^-1*u*d*(u^-1*e^-1)^-1, d^-1*v*d*(v^-1*e)^-1, d^-1*e*d*e^-1,w^-1*s*w*s^-1, w^-1*t*w*(s^-1*t*v*e^-1)^-1, w^-1*u*w*(s*t*u^-1*v^-1*e^-1)^-1 ,w^-1*v*w*(s^-1*v^-1*e)^-1, w^-1*e*w*e^-1, x^-1*s*x*(s*t*u*v^-1)^-1, x^-1*t*x*t^-1, x^-1*u*x*(s^-1*v^-1)^-1, x^-1*v*x*(s^-1*t^-1*u*v*e)^-1, x^-1*e*x*e^-1, y^-1*s*y*(s*v^-1*e^-1)^-1, y^-1*t*y*(t*u*v^-1*e^-1)^-1, y^-1*u*y*(u^-1*e^-1)^-1, y^-1*v*y*(v^-1*e)^-1, y^-1*e*y*e^-1, z^-1*s*z*(s*t^-1*u^-1*v^-1*e^-1) ^-1,z^-1*t*z*(s*u*v)^-1, z^-1*u*z*(t*u^-1*v*e^-1)^-1, z^-1*v*z*(s^-1*t*u^-1)^-1, z^-1*e*z*e^-1],[[a,b,w]]]; end, [243]], "A5 2^4' C N 2^1 3^4 C 3^1",[7,5,1],3, 1,243], # 466560.2 [[1,"abwxyzrstuv", function(a,b,w,x,y,z,r,s,t,u,v) return [[a^4,b^3,(a*b)^5,a^2*b*a^2*b^-1,w^2,x^2,y^2,z^2, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*x*y*z)^-1,a^-1*z*a*w^-1 ,b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1,r^3, s^3,t^3,u^3,v^3,r^-1*s^-1*r*s, r^-1*t^-1*r*t,r^-1*u^-1*r*u, r^-1*v^-1*r*v,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^-1*r*a*u^-1, a^-1*s*a*s^-1,a^-1*t*a*v^-1, a^-1*u*a*r^-1,a^-1*v*a*t^-1, b^-1*r*b*s^-1,b^-1*s*b*t^-1, b^-1*t*b*r^-1,b^-1*u*b*u^-1, b^-1*v*b*v^-1,w^-1*r*w*r^-1, w^-1*s*w*s,w^-1*t*w*t,w^-1*u*w*u, w^-1*v*w*v,x^-1*r*x*r, x^-1*s*x*s^-1,x^-1*t*x*t, x^-1*u*x*u,x^-1*v*x*v,y^-1*r*y*r, y^-1*s*y*s,y^-1*t*y*t^-1, y^-1*u*y*u,y^-1*v*y*v,z^-1*r*z*r, z^-1*s*z*s,z^-1*t*z*t, z^-1*u*z*u^-1,z^-1*v*z*v], [[a*b,w,r],[b,a*b*a*b^-1*a,w,r]]]; end, [24,15]], "A5 2^1 x 2^4' 3^5",[7,5,2],2, 1,[24,15]], # 466560.3 [[1,"abdwxyzrstuv", function(a,b,d,w,x,y,z,r,s,t,u,v) return [[a^2*d^-1,b^3,(a*b)^5,d^2,a^-1*d^-1*a*d, b^-1*d^-1*b*d,w^-1*d^-1*w*d, x^-1*d^-1*x*d,y^-1*d^-1*y*d, z^-1*d^-1*z*d,w^2,x^2,y^2,z^2, w^-1*x^-1*w*x*d,w^-1*y^-1*w*y*d, w^-1*z^-1*w*z*d,x^-1*y^-1*x*y*d, x^-1*z^-1*x*z*d,y^-1*z^-1*y*z*d, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*x*y*z)^-1,a^-1*z*a*w^-1 ,b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1,r^3, s^3,t^3,u^3,v^3,r^-1*s^-1*r*s, r^-1*t^-1*r*t,r^-1*u^-1*r*u, r^-1*v^-1*r*v,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^-1*r*a*u^-1, a^-1*s*a*s^-1,a^-1*t*a*v^-1, a^-1*u*a*r^-1,a^-1*v*a*t^-1, b^-1*r*b*s^-1,b^-1*s*b*t^-1, b^-1*t*b*r^-1,b^-1*u*b*u^-1, b^-1*v*b*v^-1,w^-1*r*w*r^-1, w^-1*s*w*s,w^-1*t*w*t,w^-1*u*w*u, w^-1*v*w*v,x^-1*r*x*r, x^-1*s*x*s^-1,x^-1*t*x*t, x^-1*u*x*u,x^-1*v*x*v,y^-1*r*y*r, y^-1*s*y*s,y^-1*t*y*t^-1, y^-1*u*y*u,y^-1*v*y*v,z^-1*r*z*r, z^-1*s*z*s,z^-1*t*z*t, z^-1*u*z*u^-1,z^-1*v*z*v], [[b,a*b*a*b^-1*a^-1*w*x,u,v], [b,a*b*a*b^-1*a,w,r]]]; end, [80,15]], "A5 2^4' C N 2^1 3^5",[7,5,2],2, 1,[80,15]], # 466560.4 [[1,"abdwxyzrstuv", function(a,b,d,w,x,y,z,r,s,t,u,v) return [[a^2,b^3,(a*b)^5,d^2,a^-1*d^-1*a*d,b^-1 *d^-1*b*d,w^-1*d^-1*w*d, x^-1*d^-1*x*d,y^-1*d^-1*y*d, z^-1*d^-1*z*d,w^2,x^2,y^2,z^2, w^-1*x^-1*w*x*d,w^-1*y^-1*w*y*d, w^-1*z^-1*w*z*d,x^-1*y^-1*x*y*d, x^-1*z^-1*x*z*d,y^-1*z^-1*y*z*d, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*x*y*z)^-1,a^-1*z*a*w^-1 ,b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1,r^3, s^3,t^3,u^3,v^3,r^-1*s^-1*r*s, r^-1*t^-1*r*t,r^-1*u^-1*r*u, r^-1*v^-1*r*v,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^-1*r*a*u^-1, a^-1*s*a*s^-1,a^-1*t*a*v^-1, a^-1*u*a*r^-1,a^-1*v*a*t^-1, b^-1*r*b*s^-1,b^-1*s*b*t^-1, b^-1*t*b*r^-1,b^-1*u*b*u^-1, b^-1*v*b*v^-1,w^-1*r*w*r^-1, w^-1*s*w*s,w^-1*t*w*t,w^-1*u*w*u, w^-1*v*w*v,x^-1*r*x*r, x^-1*s*x*s^-1,x^-1*t*x*t, x^-1*u*x*u,x^-1*v*x*v,y^-1*r*y*r, y^-1*s*y*s,y^-1*t*y*t^-1, y^-1*u*y*u,y^-1*v*y*v,z^-1*r*z*r, z^-1*s*z*s,z^-1*t*z*t, z^-1*u*z*u^-1,z^-1*v*z*v], [[a,b,r],[b,a*b*a*b^-1*a,w,r]]]; end, [32,15]], "A5 2^4' C 2^1 3^5",[7,5,2],2, 1,[32,15]], # 466560.5 [[4,1920,1,14580,1,60], "A5 # 2^5 3^5 [1]",6,6, 1,[12,18]], # 466560.6 [[4,1920,2,14580,1,60], "A5 # 2^5 3^5 [2]",6,6, 1,[24,18]], # 466560.7 [[4,1920,3,14580,1,60], "A5 # 2^5 3^5 [3]",6,6, 1,[16,24,18]], # 466560.8 [[4,1920,4,14580,1,60], "A5 # 2^5 3^5 [4]",6,3, 1,[80,18]], # 466560.9 [[4,1920,5,14580,1,60], "A5 # 2^5 3^5 [5]",6,6, 1,[10,24,18]], # 466560.10 [[4,1920,6,14580,1,60], "A5 # 2^5 3^5 [6]",6,6, 1,[80,18]], # 466560.11 [[4,1920,7,14580,1,60], "A5 # 2^5 3^5 [7]",6,6, 1,[32,18]], # 466560.12 [[4,1920,3,29160,5,120,3,2], "A5 # 2^5 3^5 [8]",6,3, 1,[16,24,243]], # 466560.13 [[4,1920,4,29160,5,120,4,2], "A5 # 2^5 3^5 [9]",6,3, 1,[80,243]], # 466560.14 [[4,1920,5,29160,5,120,5,2], "A5 # 2^5 3^5 [10]",6,3, 1,[10,24,243]], # 466560.15 [[4,1920,3,29160,6,120,3,3], "A5 # 2^5 3^5 [11]",6,3, 1,[16,24,243]], # 466560.16 [[4,1920,4,29160,6,120,4,3], "A5 # 2^5 3^5 [12]",6,3, 1,[80,243]], # 466560.17 [[4,1920,5,29160,6,120,5,3], "A5 # 2^5 3^5 [13]",6,3, 1,[10,24,243]], # 466560.18 [[4,5760,1,29160,4,360,1,4], "A6 # 2^4 3^4",15,1, 3,[16,30]] ]; PERFGRP[239]:=[# 468000.1 [[2,60,1,7800,1], "A5 x L2(25)",40,1, [1,14],[5,26]] ]; PERFGRP[240]:=[# 475200.1 [[2,360,1,1320,1], "( A6 x L2(11) ) 2^1 [1]",40,2, [3,5],[6,24]], # 475200.2 [[2,720,1,660,1], "( A6 x L2(11) ) 2^1 [2]",40,2, [3,5],[80,11]], # 475200.3 [[3,720,1,1320,1,"d1","d2"], "( A6 x L2(11) ) 2^1 [3]",40,2, [3,5],960], # 475200.4 [[2,60,1,7920,1], "A5 x M11",40,1, [1,15],[5,11]] ]; PERFGRP[241]:=[# 480000.1 [[4,3840,1,7500,1,60], "A5 # 2^6 5^3 [1]",6,4, 1,[64,30]], # 480000.2 [[4,3840,2,7500,1,60], "A5 # 2^6 5^3 [2]",6,4, 1,[64,30]], # 480000.3 [[4,3840,3,7500,1,60], "A5 # 2^6 5^3 [3]",6,4, 1,[24,30]], # 480000.4 [[4,3840,4,7500,1,60], "A5 # 2^6 5^3 [4]",6,4, 1,[48,30]], # 480000.5 [[4,3840,5,7500,1,60], "A5 # 2^6 5^3 [5]",6,4, 1,[24,12,30]], # 480000.6 [[4,3840,6,7500,1,60], "A5 # 2^6 5^3 [6]",6,2, 1,[48,30]], # 480000.7 [[4,3840,7,7500,1,60], "A5 # 2^6 5^3 [7]",6,4, 1,[32,24,30]], # 480000.8 [[4,3840,1,7500,2,60], "A5 # 2^6 5^3 [8]",6,4, 1,[64,30]], # 480000.9 [[4,3840,2,7500,2,60], "A5 # 2^6 5^3 [9]",6,4, 1,[64,30]], # 480000.10 [[4,3840,3,7500,2,60], "A5 # 2^6 5^3 [10]",6,4, 1,[24,30]], # 480000.11 [[4,3840,4,7500,2,60], "A5 # 2^6 5^3 [11]",6,4, 1,[48,30]], # 480000.12 [[4,3840,5,7500,2,60], "A5 # 2^6 5^3 [12]",6,4, 1,[24,12,30]], # 480000.13 [[4,3840,6,7500,2,60], "A5 # 2^6 5^3 [13]",6,2, 1,[48,30]], # 480000.14 [[4,3840,7,7500,2,60], "A5 # 2^6 5^3 [14]",6,4, 1,[32,24,30]], # 480000.15 [[4,3840,5,15000,4,120,5,3], "A5 # 2^6 5^3 [15]",6,10, 1,[24,12,125]], # 480000.16 [[4,3840,6,15000,4,120,6,3], "A5 # 2^6 5^3 [16]",6,10, 1,[48,125]], # 480000.17 [[4,3840,7,15000,4,120,7,3], "A5 # 2^6 5^3 [17]",6,10, 1,[32,24,125]] ]; PERFGRP[242]:=[# 483840.1 [[1,"abuvwxyz", function(a,b,u,v,w,x,y,z) return [[a^6,b^4,(a*b)^7,(a*b)^2*a*b^2*(a*b*a*b^-1)^2 *(a*b)^2*(a*b^-1)^2*a*b*a*b^-1 *a^2,a^2*b*a^(-1*2)*b^-1,u^2,v^2,w^2,x^2, y^2,z^2,u^-1*v^-1*u*v,u^-1*w^-1*u*w ,u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*u*a*u^-1, a^-1*v*a*v^-1,a^-1*w*a*y^-1, a^-1*x*a*x^-1,a^-1*y*a*w^-1, a^-1*z*a*(u*v*w*x*y*z)^-1, b^-1*u*b*w^-1,b^-1*v*b*z^-1, b^-1*w*b*v^-1,b^-1*x*b*y^-1, b^-1*y*b*x^-1,b^-1*z*b*u^-1], [[a^3,(b^-1*a)^2*(b*a)^2*b^2*a*b*a,u], [a,b^2*a*b^-1*(a*b*a*b*b)^2*(a*b)^2, b*(a*b^-1)^2*a*b^2*(a*b)^2,y*z]]]; end, [45,14],[[1,2],[1,-2]]], "A7 3^1 x 2^6",[23,6,1],3, 8,[45,14]], # 483840.2 [[1,"abdef", function(a,b,d,e,f) return [[a^2,b^4*f^(-1*2),(a*b)^7*d^-1*e,(a^-1*b^-1 *a*b)^5*f^(-1*2),(a*b^2)^5*(e*f)^-1, (a*b*a*b*a*b^3)^5*f, (a*b*a*b*a*b^2*a*b^-1)^5*d^(-1*2),d^3, a^-1*d*a*d^-1,b^-1*d*b*d^-1,e^2, f^4,e^-1*f^-1*e*f,a^-1*e*a*e^-1, a^-1*f*a*f^-1,b^-1*e*b*e^-1, b^-1*f*b*f^-1], [[a*b*a,b^2*a*b^-1*a*b*a*b^2*a*b*d], [a,b*a*b*a*b^-1*a*b^2*f^-1], [a*e^2,b^-1*a*b^-1*a*b*a*b^2]]]; end, [63,224,112],[[1,2]]], "L3(4) 3^1 x 2^1 x ( 2^1 A 2^1 )",[27,3,1],-24, 20,[63,224,112]], # 483840.3 [[2,960,1,504,1], "( A5 x L2(8) ) # 2^4 [1]",[35,4,1],1, [1,4],[16,9]], # 483840.4 [[2,960,2,504,1], "( A5 x L2(8) ) # 2^4 [2]",[35,4,2],1, [1,4],[10,9]], # 483840.5 [[2,1344,1,360,1], "( L3(2) x A6 ) # 2^3 [1]",[37,3,1],1, [2,3],[8,6]], # 483840.6 [[2,1344,2,360,1], "( L3(2) x A6 ) # 2^3 [2]",[37,3,2],1, [2,3],[14,6]] ]; PERFGRP[243]:=[# 489600.1 [[2,120,1,4080,1], "A5 2^1 x L2(16)",40,2, [1,10],[24,17]] ]; PERFGRP[244]:=fail; PERFGRP[245]:=[# 492960.1 [[1,"abc", function(a,b,c) return [[c^39*a^2,c*b^9*c^-1*b^-1,b^79,a^4,a^2*b^(-1 *1)*a^2*b,a^2*c^-1*a^2*c, c*a*c*a^-1,(b*a)^3],[[b,c^2]]]; end, [160],[0,3,3]], "L2(79) 2^1 = SL(2,79)",22,-2, 40,160] ]; PERFGRP[246]:=[# 504000.1 [[2,3000,1,168,1], "( A5 x L3(2) ) 2^1 # 5^2",[32,2,1],1, [1,2],[25,7]] ]; PERFGRP[247]:=[# 515100.1 [[1,"abc", function(a,b,c) return [[c^50,c*b^4*c^-1*b^-1,b^101,a^2,c*a*c*a^-1 ,(b*a)^3,c^(-1*3)*b^2*c*b*c*b^2*c*a*b^2*a*c *b^2*a],[[b,c]]]; end, [102]], "L2(101)",22,-1, 48,102] ]; PERFGRP[248]:=[# 516096.1 [[1,"abcuvwxyzdef", function(a,b,c,u,v,w,x,y,z,d,e,f) return [[a^2*(e*f^-1)^-1,b^3,(a*b)^7,b^-1*(a*b)^3 *c^-1, b^-1*c^-1*b*c^-1*a^-1*c*b^-1*c *b*a*(y*z*d*f^2)^-1,d^2,e^2,f^4,u^2, v^2*f^2,w^2,x^2*f^2,y^2,z^2*f^2, u^-1*v^-1*u*v,u^-1*w^-1*u*w, u^-1*x^-1*u*x*f^2,u^-1*y^-1*u*y *f^2,u^-1*z^-1*u*z,u^-1*d^-1*u*d, u^-1*e^-1*u*e,u^-1*f^-1*u*f, v^-1*w^-1*v*w,v^-1*x^-1*v*x*f^2, v^-1*y^-1*v*y,v^-1*z^-1*v*z, v^-1*d^-1*v*d,v^-1*e^-1*v*e, v^-1*f^-1*v*f,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z*f^2, w^-1*d^-1*w*d,w^-1*e^-1*w*e, w^-1*f^-1*w*f,x^-1*y^-1*x*y, x^-1*z^-1*x*z,x^-1*d^-1*x*d, x^-1*e^-1*x*e,x^-1*f^-1*x*f, y^-1*z^-1*y*z,y^-1*d^-1*y*d, y^-1*e^-1*y*e,y^-1*f^-1*y*f, z^-1*d^-1*z*d,z^-1*e^-1*z*e, z^-1*f^-1*z*f,a^-1*u*a*(u*x)^-1, a^-1*v*a*(v*y*f^2)^-1, a^-1*w*a*(w*z)^-1, a^-1*x*a*(x*f^2)^-1,a^-1*y*a*y^-1, a^-1*z*a*(z*f^2)^-1,a^-1*d*a*d^-1, a^-1*e*a*e^-1,a^-1*f*a*f^-1, b^-1*u*b*(x*y*e*f^-1)^-1, b^-1*v*b*(y*z*e*f^2)^-1, b^-1*w*b*(x*y*z*d*e*f^2)^-1, b^-1*x*b*(v*w*x*e)^-1, b^-1*y*b*(u*v*w*y*d*e*f^2)^-1, b^-1*z*b*(u*w*z*f^-1)^-1, b^-1*d*b*d^-1,b^-1*e*b*e^-1, b^-1*f*b*f^-1, c^-1*u*c*(v*d*e*f^-1)^-1, c^-1*v*c*(w*d*f^-1)^-1, c^-1*w*c*(u*v*e*f)^-1, c^-1*x*c*(x*z*d*e*f)^-1, c^-1*y*c*(x*d*f)^-1, c^-1*z*c*(y*e*f^-1)^-1, c^-1*d*c*d^-1,c^-1*e*c*e^-1, c^-1*f*c*f^-1], [[c*c*a,y/b*a],[a^b,w*a]]]; #[[w*c*b,v^-1*c^-1*a]]]; corefree index 1152 end, [288,112],[[1,2],[12,12]]], "L2(8) N ( 2^6 E ( 2^1 x 2^1 x 2^1 A ) ) C 2^1",[16,10,1],16, 4,[288,112]] ]; PERFGRP[249]:=[# 518400.1 [[2,720,1,720,1], "( A6 x A6 ) 2^2",40,4, [3,3],[80,80]] ]; ############################################################################# ## #E perf10.grp . . . . . . . . . . . . . . . . . . . . . . . . . ends here ## gap-4r6p5/grp/imf24.grp0000644000175000017500000106640612172557252013401 0ustar billbill############################################################################# ## #A imf24.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Q-class representative of the irreducible ## maximal finite integral matrix groups of dimension 24, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Q-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 24. ## IMFList[24].matrices := [ [ # Q-class [24][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[[0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [24][02] [[2], [-1,2], [0,-1,2], [0,0,-1,2], [0,0,0,-1,2], [0,0,0,0,-1,2], [0,0,0,0,0,-1,2], [0,0,-1,0,0,0,0,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,-1,-2,-2,-2,-1,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,2,3,4,3,2,1,1,2,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,-2,-2,-1,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-2,-4,-6,-5,-4,-3,-1,-3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,2,2,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [24][03] [[4], [-2,4], [-2,0,4], [2,0,0,4], [2,-2,0,0,4], [2,0,-2,0,0,4], [-1,-1,0,-2,-1,0,4], [-1,2,0,-1,-1,0,1,4], [2,0,0,2,1,1,-1,1,4], [2,0,0,2,1,1,-1,1,2,4], [-2,2,2,0,-1,-1,0,2,0,0,4], [2,-1,0,2,1,1,-2,-1,2,1,0,4], [-2,1,0,-2,-1,-1,2,1,-2,-2,1,-2,4], [1,1,-2,1,0,1,0,0,1,0,-1,0,0,4], [-1,-1,1,0,0,-1,0,-1,0,-1,0,1,-1,-1,4], [1,1,-1,2,-1,1,0,1,1,1,1,0,0,1,-1,4], [1,-2,-1,-1,0,1,2,-1,-1,-1,-1,0,1,0,-1,0,4], [2,-2,-1,0,2,0,-1,-1,0,1,-2,1,-1,-1,0,-1,1,4], [0,-1,1,-1,0,1,0,-1,-1,0,0,0,-1,-2,0,-1,1,1,4], [-1,1,-1,0,-2,0,0,-1,-2,-1,0,-1,1,0,0,0,0,-1,0,4], [0,1,-1,1,-2,1,-1,-1,0,-1,0,1,0,0,0,1,0,-1,0,2,4], [-2,2,1,-1,-1,0,1,1,-1,-1,2,-2,2,0,-1,1,0,-2,0,0,0,4], [-2,1,0,-1,-2,-1,2,1,-1,-1,1,-2,2,0,0,0,0,-2,-1,2,1,1,4], [2,-2,-1,0,2,1,-1,-1,0,1,-2,1,-2,0,0,-1,0,2,1,-1,-1,-2,-2,4]], [[[-1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,-1,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,-1,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,-1,0,0,0,0,-1,1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [2,1,1,0,0,0,0,1,-1,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [-2,0,-1,2,1,1,0,1,0,-1,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0], [-4,-2,-1,2,1,1,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [-2,-1,-1,3,1,1,0,2,-1,-1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [3,0,0,-2,-1,-1,0,-1,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0], [2,0,0,-2,-1,-1,0,-1,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [3,1,1,-3,-1,-1,0,-2,0,1,1,0,0,0,0,0,0,0,-1,0,0,0,0,0], [1,1,-1,-1,-1,-1,0,-2,0,1,1,0,0,0,0,0,0,0,0,-1,0,0,0,0], [1,1,-1,-1,-1,-1,0,-2,1,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,1,1,1,1,1,0,1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,-1,-1,-1,-1,0,-1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,-1,0], [-1,-1,0,1,1,1,0,1,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,-1]], [[0,2,1,3,3,0,1,3,-1,-1,-2,0,0,0,1,0,1,0,1,1,1,0,0,0], [2,-1,0,-3,-3,-1,-1,-2,1,1,1,0,0,0,0,0,0,0,-1,0,-1,1,0,0], [0,-1,0,-1,-1,1,0,-2,0,0,2,-1,0,0,-1,0,-1,1,-1,-1,0,-1,0,0], [4,0,1,-2,-2,-1,-1,-1,0,1,1,-1,1,1,1,0,0,0,0,0,0,0,0,0], [-3,0,0,3,3,1,1,2,0,-1,-1,0,0,0,0,0,0,1,1,1,1,0,0,0], [2,3,0,0,1,-1,1,0,0,0,-1,0,0,-1,1,0,1,-1,0,0,0,0,0,0], [1,2,1,0,1,0,1,1,-1,-1,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0], [2,0,2,-3,-1,-1,0,0,0,0,0,1,-1,1,0,1,0,1,-1,1,0,1,0,0], [0,0,2,2,2,1,0,3,-1,-1,-1,-1,0,1,1,0,1,1,0,1,1,0,0,0], [1,1,1,1,1,0,1,1,0,-1,0,0,0,0,0,0,0,1,0,1,0,0,0,0], [11,-1,1,-16,-11,-5,-3,-11,4,6,6,-1,2,2,1,2,-2,0,-3,-1,-1,1,-1,1], [1,2,1,1,1,0,1,0,0,0,0,-1,1,0,1,0,1,0,0,0,1,-1,0,1], [6,2,1,-7,-4,-3,-1,-4,1,2,1,1,0,0,1,1,0,-1,-1,0,-1,1,0,1], [-6,2,1,12,8,4,3,9,-4,-5,-5,1,-2,-1,0,-2,2,1,2,1,1,0,1,-1], [0,-2,-1,-2,-2,0,-1,-2,1,1,2,-1,1,1,0,0,-1,0,0,-1,0,-1,0,0], [2,0,1,-1,0,-1,0,1,-1,0,-1,1,-1,1,0,0,0,0,0,1,0,1,0,-1], [-2,3,1,5,4,2,2,3,-2,-2,-2,0,-1,-1,0,-1,1,0,0,0,1,-1,0,0], [-8,0,-1,9,6,3,2,5,-1,-3,-2,0,-1,-1,-1,-1,1,1,1,1,1,-1,0,0], [-1,0,-2,-1,-1,0,1,-3,1,1,2,-1,0,-1,-1,0,-1,0,-1,-1,0,-1,-1,0], [8,0,-1,-10,-8,-4,-3,-7,3,4,3,0,2,0,1,1,-1,-2,-1,-1,-2,1,0,1], [8,-1,-1,-11,-8,-5,-4,-7,3,6,3,-1,3,1,2,1,0,-3,-1,-1,-1,1,-1,1], [8,-1,0,-12,-8,-4,-3,-8,3,5,4,-1,1,1,1,1,-1,-1,-2,-1,-1,1,-1,0], [12,-2,0,-17,-12,-6,-5,-10,4,7,5,0,3,2,2,2,-2,-2,-2,-1,-2,2,-1,1], [-2,0,-1,2,2,0,1,1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0]]]], [ # Q-class [24][04] [[4], [-1,4], [-1,-1,4], [0,1,0,4], [0,-1,0,0,4], [0,-1,-1,0,0,4], [0,1,0,2,0,0,4], [0,0,1,2,-1,-1,1,4], [-1,2,0,-1,-1,-1,0,0,4], [0,-2,1,0,1,0,0,1,0,4], [-1,0,1,-1,0,0,-1,-1,0,0,4], [0,-1,0,0,1,1,0,-1,-1,1,-1,4], [1,1,-1,1,0,-1,1,1,0,-1,0,-2,4], [0,1,-1,0,1,1,0,-1,0,-1,0,-1,1,4], [-1,0,-1,0,-1,2,-2,-1,0,0,1,0,-1,1,4], [0,-1,1,0,-1,-1,-1,2,0,1,-1,-1,-1,-1,0,4], [-1,0,2,0,-1,0,-1,1,1,0,0,-1,-1,0,1,1,4], [1,0,0,0,1,-1,1,-1,0,0,-1,2,-1,-2,-2,-1,-1,4], [1,0,-1,0,-2,1,1,0,1,0,-2,1,-1,-1,0,0,0,1,4], [-1,-1,1,0,1,2,0,-1,-1,1,1,2,-1,0,1,-1,0,0,-1,4], [0,2,0,-1,-1,0,0,-1,2,-2,1,-1,1,1,0,-2,1,0,0,0,4], [2,-1,-1,-1,1,0,-2,-1,-1,0,0,-1,1,2,1,0,0,-1,-1,-1,0,4], [-1,0,2,0,1,-2,1,1,1,1,1,-1,0,-1,-2,0,1,1,-1,-1,0,-1,4], [-1,0,-1,-2,0,1,-2,-2,1,0,1,1,-2,0,2,0,0,0,0,1,0,0,-1,4]], [[[0,0,-1,1,0,0,0,-1,0,0,0,1,0,-1,-1,1,0,-2,0,1,1,1,1,0], [0,0,1,0,1,0,-1,0,-1,0,-1,-1,0,0,1,0,-1,0,1,0,1,-1,1,0], [0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,-1,0,1,1,0,1,1,1] , [0,0,0,1,-1,1,-1,0,1,0,0,0,-1,0,-2,-1,0,0,-1,0,-1,1,0,0], [0,-1,-2,0,-2,0,0,0,3,-1,1,0,-2,0,-2,-2,1,0,-2,1,-3,1,-1,-2], [0,0,0,0,0,0,1,0,0,1,0,0,-1,0,0,0,0,0,-1,-1,1,0,-1,0], [0,0,1,0,0,1,0,0,1,0,0,0,0,0,-1,-1,0,0,-1,-1,-1,0,-1,0], [0,1,1,0,0,0,-1,1,-1,0,-1,-1,0,0,0,-1,-1,0,1,1,0,1,1,1], [1,0,2,-2,2,-1,0,1,-2,0,-1,-1,1,1,4,0,-1,1,1,-1,1,-3,0,0], [1,0,0,-1,0,-1,0,1,0,0,0,0,0,1,1,-1,0,0,0,0,-1,-1,0,0], [-1,0,-1,0,0,0,0,0,-1,0,1,1,1,1,0,2,0,1,1,0,1,0,1,0], [0,-1,0,0,-1,0,0,0,1,1,1,0,0,1,-1,-1,1,1,-1,-1,-1,-1,-2,0], [0,1,0,0,0,1,-1,-1,0,0,0,1,1,0,0,1,0,0,0,0,0,0,1,-1], [0,0,-1,1,-1,0,0,-1,1,-1,-1,0,-2,-1,-1,0,-1,-2,0,2,0,2,2,-1], [0,0,0,0,0,0,0,0,-1,1,0,0,0,1,1,1,0,1,0,-1,1,-1,0,0], [0,0,0,1,0,-1,0,1,0,-1,-1,-1,-1,-1,0,-1,-1,-1,1,2,0,2,1,1], [1,1,1,-1,1,0,0,1,-2,0,-1,-1,0,0,2,0,-1,0,1,0,1,-1,1,1], [0,-1,0,0,0,0,0,0,1,0,1,0,0,0,-1,-1,1,0,-1,-1,-1,-1,-2,0], [1,0,2,-1,1,0,1,0,-1,1,-1,0,1,0,2,0,0,0,-1,-2,1,-2,-1,1], [0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,0,1,0,-1,0,-1,-1,0], [0,1,1,-1,2,0,0,0,-2,0,0,0,1,0,2,2,-1,0,2,0,2,-1,1,0], [0,0,-2,1,-1,0,0,-1,1,-1,0,1,-1,-1,-1,1,0,-2,0,2,0,2,2,-1], [0,0,0,-1,0,0,0,1,0,-1,0,0,0,0,0,-1,0,0,0,0,-1,0,0,0], [0,-1,0,0,0,-1,0,0,-1,1,0,-1,0,1,1,0,0,1,0,-1,1,-2,-1,0]], [[0,-1,0,0,-1,1,0,0,1,1,1,0,0,1,0,-1,1,2,-2,-2,-1,-1,-2,-1], [-2,0,0,2,0,0,0,0,-1,0,0,0,0,-1,-2,1,-1,-1,2,1,2,3,1,2], [1,1,1,-1,1,-1,0,0,-1,0,-1,0,0,0,2,0,-1,-1,1,0,1,-1,1,0], [0,0,1,0,1,0,-1,0,-2,1,-1,0,2,1,2,1,-1,1,1,-1,2,-2,1,1], [1,0,0,0,-1,1,0,0,1,-1,0,1,0,0,0,0,0,0,-1,0,-1,0,1,0], [1,0,0,-1,1,-1,0,1,-1,0,0,-1,0,1,2,0,0,1,0,0,0,-2,0,0], [0,0,0,1,0,0,0,0,0,0,-1,0,0,-1,0,0,-1,-1,0,0,1,1,1,1], [0,0,1,-1,1,0,0,0,-1,1,0,1,2,1,2,1,0,1,0,-2,1,-2,-1,0], [-1,0,0,1,0,0,1,0,0,0,0,0,-1,-1,-2,0,0,-1,0,0,1,2,-1,1], [1,0,0,-1,0,0,1,0,1,-1,0,1,0,0,1,0,0,0,-1,0,-1,0,0,-1], [0,0,0,0,0,-1,1,0,1,-1,0,0,-1,-1,0,-1,0,-1,0,1,-1,1,0,0], [1,0,0,0,0,0,0,-1,-1,0,-1,0,0,0,1,1,-1,-1,0,0,1,-1,2,0], [-1,0,0,1,-1,1,0,0,1,0,0,1,0,-1,-1,0,0,0,-1,0,0,2,0,0], [0,1,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1], [0,0,0,-1,1,-1,0,1,-1,0,0,-1,0,1,1,0,0,1,1,1,0,-1,0,0], [0,0,0,-1,0,0,-1,0,0,1,1,0,1,2,0,0,1,2,0,-1,-1,-2,-2,-1], [0,0,0,-1,1,-1,0,1,-1,0,0,0,0,1,1,0,0,0,1,0,1,-1,0,0], [0,-1,0,1,-1,1,0,-1,1,0,0,0,0,0,-1,0,0,0,-1,-1,0,0,0,0], [0,0,0,0,1,0,0,0,-1,1,0,-1,0,0,0,0,0,0,0,-1,1,-1,-1,0], [1,0,0,0,0,-1,0,0,0,-1,-1,0,-1,0,1,0,-1,-1,0,1,0,0,2,0], [-1,0,0,1,0,0,1,0,0,0,0,0,-1,-1,-1,0,0,-1,0,0,1,2,0,1], [0,0,0,-1,-1,1,0,1,1,0,1,0,0,1,0,-1,1,2,-1,0,-2,0,-1,-1], [0,0,0,0,0,0,1,0,1,-1,0,1,0,-1,0,0,0,-1,0,0,0,1,0,0], [0,-1,-1,1,-1,-1,0,0,1,-1,0,-1,-2,0,-2,-1,0,-1,0,2,-1,1,0,0]]]], [ # Q-class [24][05] [[2], [0,2], [-1,1,2], [-1,1,1,2], [0,0,0,0,2], [0,0,0,0,0,2], [0,0,0,0,-1,1,2], [0,0,0,0,-1,1,1,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,-1,1,2], [0,0,0,0,0,0,0,0,-1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,2]], [[[0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [24][06] [[4], [0,4], [1,0,4], [-2,2,1,4], [0,1,-2,-1,4], [-2,1,-2,1,2,4], [0,-2,0,-2,0,-1,4], [1,-2,2,-1,-2,-2,2,4], [-2,0,0,2,0,2,-2,-1,4], [1,0,0,0,-2,-2,0,1,-2,4], [0,2,1,2,-1,-1,-2,0,0,2,4], [-2,0,-2,0,2,2,0,-1,2,-2,-1,4], [0,0,1,0,0,0,0,1,0,-1,0,0,4], [0,0,0,0,1,1,0,0,0,0,0,0,0,4], [-1,0,0,1,0,0,0,0,0,0,1,0,1,0,4], [0,0,-1,0,1,1,0,-1,0,0,0,0,-2,2,1,4], [0,-1,0,-1,0,0,0,0,0,0,-1,0,0,1,-2,-1,4], [0,-1,0,-1,0,0,1,0,0,0,-1,0,-2,1,-2,1,2,4], [0,0,0,0,0,-1,0,0,0,0,0,0,0,-2,0,-2,0,-1,4], [-1,0,0,1,0,0,0,0,1,-1,0,1,1,-2,2,-1,-2,-2,2,4], [0,0,0,0,0,0,0,-1,0,0,0,0,-2,0,0,2,0,2,-2,-1,4], [1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,-2,-2,0,1,-2,4], [0,0,-1,0,1,1,0,0,0,0,0,1,0,2,1,2,-1,-1,-2,0,0,2,4], [0,0,0,0,0,0,0,-1,0,0,-1,0,-2,0,-2,0,2,2,0,-1,2,-2,-1,4]], [[[0,0,-1,1,0,-1,0,0,0,-1,0,0,0,0,1,-1,0,1,0,-1,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,1,-1,0,1,0,1,0,0,-1,0,0,1], [0,0,-2,1,0,-1,0,1,0,-1,0,-1,0,1,0,-1,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,1,0,-1,1,0,0,0,1,0,-1,0,0], [-1,0,1,-1,0,0,-1,0,0,0,0,0,1,-1,0,1,-1,1,1,-1,-1,0,1,1], [-1,1,1,-2,0,0,0,0,1,1,0,0,1,-1,0,2,0,0,0,0,-1,0,0,1], [0,0,0,0,-1,1,0,0,-1,-1,0,0,-1,1,0,-1,1,-1,1,0,2,1,0,-1], [1,0,-1,1,-1,0,1,0,0,-1,0,0,-1,1,0,-1,1,-1,0,0,1,0,0,-1], [0,0,0,-1,0,0,0,0,1,1,0,0,1,0,0,1,-1,0,0,0,-1,-1,0,1], [1,0,0,1,0,0,1,-1,0,0,0,0,-1,0,0,-1,1,0,-1,1,0,0,0,-1], [1,-1,0,1,0,0,1,-1,0,0,1,0,0,0,-1,0,0,0,-1,1,-1,-1,0,0], [0,0,1,-1,0,1,0,0,1,1,0,0,1,-1,0,1,-1,0,1,-1,-1,-1,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,1,0,1,0,0,-1,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,-2,0,0,-1,0,1,1,-1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,1,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,1,0,-1,-1,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,0,0,1,0,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,-1,1,0,1,-1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-1,1,0,0,0,0,-1,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,0,-1,1,1,-1,0,0,1,1]], [[0,1,0,-1,0,0,0,0,1,1,0,0,1,-1,1,1,0,1,0,0,-1,0,0,1], [0,-1,0,0,0,0,0,0,0,0,1,0,1,0,-1,1,-1,0,0,0,-1,-1,0,1], [-1,1,0,-1,0,-1,0,0,1,1,-1,0,1,0,0,1,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,-1,-1,0,0,0,-1,0,0], [-1,0,0,0,1,0,-1,1,0,0,0,-1,1,-1,0,0,-1,1,1,-1,0,0,1,1], [0,-1,0,1,1,0,0,0,0,0,0,-1,0,0,-1,-1,-1,0,0,0,0,-1,1,0], [0,0,1,0,-1,1,0,-1,-1,0,0,1,0,0,0,0,1,0,1,0,1,1,0,-1], [0,1,0,-1,-1,0,1,-1,1,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0], [0,0,-1,1,1,-1,0,1,1,0,-1,-1,0,0,0,-1,-1,0,0,-1,0,-1,1,0], [1,0,1,-1,-1,1,1,-1,0,0,1,1,-1,0,0,1,1,-1,-1,1,-1,0,-1,0], [0,0,0,-1,0,0,1,0,1,0,1,0,0,0,0,1,0,-1,-1,0,-1,0,-1,1], [0,0,-1,1,0,0,0,1,0,-1,0,-1,0,0,0,-1,0,0,1,-1,1,0,1,0], [-1,1,-1,-1,0,-1,0,0,1,0,0,-1,0,1,0,-1,0,0,0,0,1,1,0,0], [-1,0,1,-1,1,0,0,0,1,1,0,-1,0,-1,0,0,0,0,0,0,0,0,1,0], [-1,0,0,-1,0,0,0,0,0,0,0,0,-1,1,0,-1,0,-1,0,0,1,1,-1,0], [0,-1,1,0,1,1,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,1,-1,-1,1,0,0,-1,-1,-1,0,0,0,1,0,-1,1,0,0,0,-1], [0,0,1,1,1,0,0,0,0,1,-1,0,0,-1,0,1,1,0,0,0,0,0,0,-1], [0,0,0,0,-1,0,-1,0,-1,-1,0,1,0,0,1,0,-1,1,0,-1,-1,0,0,1], [0,0,-1,0,-1,0,0,0,0,-1,0,0,0,1,0,-1,-1,0,1,-1,1,0,0,0], [0,0,0,1,1,0,0,1,0,1,-1,0,0,0,-1,1,1,-1,0,1,1,0,-1,-1], [1,0,0,-1,-1,1,1,-1,1,0,1,0,1,0,1,-1,-1,1,1,-1,0,0,1,1], [0,0,0,-1,0,1,1,0,1,0,1,-1,0,0,0,-1,0,0,1,0,1,0,1,0], [0,0,0,1,0,0,-1,1,-1,0,-1,0,0,0,-1,1,0,0,0,1,0,-1,0,-1]]]], [ # Q-class [24][07] [[2], [-1,2], [0,-1,2], [0,0,-1,2], [0,0,0,-1,2], [0,0,-1,0,0,2], [0,0,0,0,0,0,2], [0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,-1,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,2]], [[[0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,2,2,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,-2,-2,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,-2,-3,-2,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [24][08] [[4], [-2,4], [-1,1,4], [-1,2,-1,4], [0,0,0,1,4], [-1,1,-1,0,1,4], [0,1,-1,2,0,-1,4], [0,1,-1,2,1,1,0,4], [2,-2,0,-1,1,0,-1,1,4], [-2,2,1,0,-2,1,0,0,-1,4], [-2,2,2,1,1,0,1,1,0,1,4], [-1,1,-1,2,2,2,0,2,0,0,1,4], [-1,0,2,0,2,-1,0,0,0,-1,2,0,4], [0,-1,-1,1,2,0,0,0,1,-1,0,1,1,4], [0,1,-1,1,1,2,1,2,1,1,1,1,0,1,4], [-1,1,-1,2,-1,-1,1,1,-2,0,0,0,0,0,0,4], [-1,2,2,1,-1,-1,0,1,0,2,2,0,0,-1,0,1,4], [-1,1,2,-1,1,0,0,-1,0,1,2,0,2,0,0,-1,1,4], [0,1,-1,0,-1,0,1,1,0,1,0,0,-1,-1,1,0,0,0,4], [2,-1,0,-1,0,-1,-1,1,2,-1,0,0,0,0,0,0,1,0,0,4], [-2,0,0,0,1,0,-1,0,0,0,1,1,1,1,-1,0,0,1,0,0,4], [-1,2,1,0,1,2,-1,0,-1,1,1,1,0,0,1,0,1,1,-1,0,0,4], [0,1,-1,0,0,2,1,1,0,1,0,0,-1,-1,2,-1,-1,0,2,-1,-1,0,4], [-1,1,-1,0,1,1,1,-1,-1,0,0,0,0,1,1,0,-1,1,1,-1,1,1,1,4]], [[[-1,3,0,-3,-1,-2,1,0,1,-2,-2,2,0,0,2,0,0,0,-1,-1,1,0,0,-1], [-1,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,1,-1,0,1,0], [-1,-1,1,1,0,2,1,0,-2,-2,-1,-2,-1,1,1,-1,1,1,1,1,1,0,0,-2], [1,1,0,-2,-1,-1,0,0,1,0,0,2,1,1,-1,1,1,-1,-1,-1,0,0,2,1], [2,1,-2,-1,1,-1,-2,-2,0,1,2,1,1,0,0,1,1,-1,0,-1,0,-1,1,0], [2,1,-3,0,3,0,-2,-2,2,5,3,0,2,-1,-3,2,-1,-2,0,0,-2,-1,0,1], [-1,0,2,-1,-3,-1,1,1,-1,-3,-2,2,-1,1,2,-1,1,1,-1,0,1,0,1,0], [0,3,-2,-4,0,-2,0,0,2,0,0,2,1,1,-1,1,1,-1,-1,-2,-1,0,1,0], [0,3,-3,-3,1,-3,-1,-2,2,0,0,2,1,-1,1,1,1,-1,-1,-2,0,0,1,-1], [-1,-1,0,1,1,1,0,0,0,1,0,-1,0,0,-1,0,0,0,0,1,-1,0,0,0], [0,-1,0,0,0,1,0,-1,-1,-1,0,0,0,1,0,0,2,0,1,0,0,0,1,-1], [3,1,-2,-1,2,0,-2,-2,1,3,2,1,2,0,-2,2,1,-2,0,-1,-1,-1,1,1], [0,-1,1,1,-1,1,0,0,-2,-2,0,-1,-1,1,1,-1,1,1,1,0,1,0,0,-1], [2,0,-2,0,1,-1,-2,-2,1,2,2,1,2,-1,-1,1,1,-2,0,-1,0,0,1,1], [0,2,-2,-2,0,-2,-1,-1,2,1,1,2,1,0,-1,1,0,-1,-1,-1,-1,0,1,0], [0,-1,2,0,-1,0,1,2,0,0,0,0,-1,1,-1,0,-1,0,0,0,0,1,0,1], [-1,0,0,-1,0,0,1,0,0,-1,-1,0,0,1,0,0,1,0,0,0,0,1,1,-1], [0,-1,0,1,2,1,-1,-2,-2,0,1,-1,-1,0,1,0,1,0,1,1,0,-1,0,-1], [-2,1,0,-1,-1,-2,0,1,0,-2,-1,1,-1,0,1,-1,0,1,-1,0,-1,0,0,0], [-1,2,-1,-2,0,-2,0,0,1,-1,-1,1,0,0,1,0,0,0,0,-1,0,1,0,-1], [1,-2,-1,2,2,0,-2,-1,0,2,2,-1,0,-1,-1,1,0,0,1,0,-1,0,0,1], [1,-1,-1,1,2,1,-1,-1,0,3,2,-1,1,0,-2,1,-1,-1,1,1,-1,0,0,0], [-1,2,-1,-2,0,-1,0,0,1,0,0,1,0,0,0,0,0,0,-1,0,-1,-1,0,0], [0,-1,-1,2,0,-1,-2,-1,0,1,2,0,0,-1,0,0,-1,0,0,1,-1,0,0,1]], [[-1,1,1,-2,0,0,1,1,0,-1,-1,0,-1,1,0,0,0,0,0,0,0,0,0,-1], [2,0,-1,0,1,1,-1,-1,0,2,2,0,1,0,-1,1,0,-1,0,0,0,-1,0,1], [1,-3,1,3,0,3,0,0,-1,1,1,-2,0,0,-1,0,0,0,1,1,0,0,-1,1], [2,1,-2,-1,1,-1,-2,-2,0,1,2,1,1,0,0,1,1,-1,0,-1,0,-1,1,0], [1,0,0,0,1,0,-1,-1,-1,0,0,0,0,0,1,0,1,0,0,0,0,-1,0,0], [1,0,-1,0,2,-1,-1,-1,1,3,1,1,1,-1,-1,1,-1,-1,0,0,-1,0,0,1], [1,2,-2,-2,0,-1,-1,-1,0,0,1,1,1,0,0,0,1,-1,-1,-1,0,-1,1,0], [1,1,-1,-2,2,-1,-1,-1,0,1,1,1,0,0,0,1,1,-1,0,-1,0,-1,0,0], [-1,0,0,0,1,-1,-1,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1,0,0,0], [1,-1,-1,1,1,0,-1,0,1,3,2,0,1,-1,-2,1,-1,-1,0,0,-1,0,0,2], [1,-1,0,1,0,1,-1,-1,-1,0,1,0,0,0,0,0,1,0,0,0,0,-1,0,1], [1,1,-1,-2,1,-1,-1,-2,0,0,0,2,1,0,1,1,2,-1,0,-1,0,-1,1,0], [1,-3,2,3,0,3,0,0,-3,-1,0,-2,-1,0,1,-1,1,1,1,1,1,-1,-1,0], [0,-1,1,1,0,-1,-1,0,-1,-1,0,0,-1,0,1,0,0,1,0,0,0,0,1,0], [1,0,-1,0,3,-1,-2,-1,0,3,2,0,0,-1,-1,1,-1,-1,0,0,-1,-1,0,1], [-1,0,0,0,-1,-1,0,0,-1,-2,0,0,-1,0,2,-1,0,1,0,0,1,0,0,-1], [0,-1,0,1,-1,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-2,2,2,-1,2,0,1,-2,-1,0,-1,-1,0,1,-1,0,1,0,1,0,-1,-1,1], [0,3,-1,-3,1,-1,0,0,1,0,0,1,0,0,0,1,0,-1,-1,-1,0,-1,0,0], [-2,0,2,-1,-1,0,1,1,-1,-3,-2,0,-2,1,2,-1,1,1,0,0,1,0,0,-1], [-1,0,0,1,-1,0,0,0,0,-2,-1,0,0,0,1,-1,1,1,0,0,0,0,0,0], [0,-1,1,1,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,1,0,0,0,1], [2,2,-2,-2,3,-1,-1,-1,2,4,2,1,1,-1,-2,2,-1,-2,-1,-1,-1,-1,0,1], [-1,1,0,0,-1,-1,0,1,0,-1,-1,0,0,0,1,-1,-1,1,-1,0,0,0,0,0]]]], [ # Q-class [24][09] [[4], [0,4], [1,0,4], [0,-1,0,4], [1,1,0,-1,4], [0,0,-1,0,1,4], [0,1,0,1,0,1,4], [0,1,1,0,1,1,2,4], [0,1,-1,0,1,2,1,0,4], [1,-1,1,0,-1,-2,-1,0,-2,4], [0,1,-1,-1,-1,-1,0,0,-1,2,4], [1,0,1,-1,2,0,-1,0,0,-1,-2,4], [0,-2,0,1,-1,0,-1,-1,-1,1,-1,0,4], [0,0,0,-1,2,1,0,1,1,-1,-1,2,-1,4], [0,-2,0,1,0,-1,-1,0,-1,1,-1,1,0,1,4], [0,-1,0,-1,-1,-2,-1,0,-2,2,1,0,0,0,2,4], [0,0,1,1,-1,-2,-1,0,-2,2,1,-1,1,-2,0,0,4], [0,0,1,-1,-1,-2,-2,-1,-2,2,1,0,0,-1,1,2,2,4], [-1,0,0,0,-2,-1,-1,-1,0,1,1,-2,0,-2,0,0,1,1,4], [0,1,0,-2,1,1,-1,-1,1,-1,0,0,0,0,-2,-1,-1,0,0,4], [1,-2,2,1,0,-1,0,0,-1,1,-1,1,0,1,2,1,0,0,-1,-1,4], [-1,-1,1,2,-2,0,1,1,-1,0,-1,-1,0,-1,1,0,1,0,1,-2,1,4], [0,1,0,-1,2,1,0,1,2,-1,0,0,-2,2,0,-1,-1,-1,0,1,0,-1,4], [1,2,0,-1,0,0,1,2,-1,1,2,-1,-1,0,-1,1,0,0,0,0,-1,0,0,4]], [[[-1,-1,-1,1,-1,1,2,-1,0,1,-1,3,-1,0,-1,1,2,0,1,1,0,-1,1,1], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,-1,1,-1,0,-1,0,-1,0,0,0,0,0,0,0,0,-1], [0,0,-1,0,0,0,0,1,0,0,-1,0,0,0,-1,0,0,1,1,0,1,0,0,0], [-1,-3,0,2,-1,1,2,-1,0,1,-1,3,-2,0,-1,1,2,0,1,1,-1,-2,1,2], [0,-1,0,0,0,-1,0,0,1,0,0,0,0,0,0,-1,-1,1,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,0,0,0,-1,0,0,1,-1,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,-1,1,0,0,-1,0,-1,0,-1,0,0,1,1,-1,0,0,0,-1,0,-1], [0,1,1,0,0,1,0,-1,0,-1,1,0,0,0,1,1,1,-1,0,0,0,0,0,0], [0,-1,-1,1,-1,0,1,0,-1,2,-1,2,-1,0,-1,0,0,0,0,1,-1,0,1,0], [0,0,-1,-1,-1,-1,-1,1,0,0,-2,-1,0,-1,0,-2,-1,1,-1,-1,1,-1,0,1], [0,-1,0,1,0,0,1,0,0,1,0,1,-1,0,0,0,0,0,0,1,-1,0,0,0], [0,0,0,1,0,1,1,0,-1,1,-1,1,-1,1,-1,2,1,-1,1,1,-1,0,0,-1], [0,1,0,0,0,1,0,0,-1,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,1,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,-1], [1,2,1,-1,1,0,-1,0,0,-1,1,-2,1,1,0,1,0,-1,0,-1,0,1,-1,-2], [-1,-1,0,0,0,-1,-1,0,1,0,0,0,0,-1,0,-2,-1,1,-1,-1,1,-1,0,2], [0,0,-1,1,0,1,1,0,-1,1,-1,1,-1,1,-1,1,1,0,1,1,0,0,0,-1], [1,1,0,-1,1,-1,-1,1,0,-1,1,-2,1,1,0,0,-1,0,0,0,0,2,-1,-2], [0,-1,1,1,1,1,1,-1,1,0,1,1,-1,1,0,2,2,-1,1,1,-1,0,-1,0], [0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,-1,-1,1,-1,0,1,0,0,1,-1,2,0,-1,-1,0,0,1,0,0,0,-1,2,1], [1,1,0,-1,1,-1,-1,1,0,-1,1,-2,1,1,0,0,-1,0,0,-1,0,1,-1,-2], [0,0,-2,1,-1,0,0,1,-1,1,-2,1,-1,0,-2,0,0,1,1,0,1,-1,1,0], [0,0,0,0,0,0,0,0,0,1,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,-1,-1,-1,-1,1,0,0,0,-1,0,-1,1,-2,-1,0,-1,-1,0,-1,0,0], [1,0,1,0,0,0,1,-1,0,0,1,0,0,1,1,1,1,-1,0,1,-2,1,0,-1], [0,0,1,0,0,0,0,-1,0,0,0,0,0,1,0,1,1,-1,0,0,-1,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,-1,0,0,0,-1,0,0,0,-1,0,0,1,-1,0,0,-1,-1,-1,0,0,0], [-1,-1,-1,1,0,0,1,0,0,0,-1,2,0,-1,-1,0,0,1,1,0,1,-1,1,2], [0,0,0,0,1,-1,0,0,0,-1,1,0,1,0,0,0,-1,0,0,0,0,1,0,0], [0,0,-1,0,-1,0,0,1,0,0,0,0,0,0,0,-1,0,1,0,0,1,-1,0,0], [0,0,0,0,0,1,1,0,0,0,0,1,0,0,0,1,1,0,1,1,0,0,0,0], [0,0,0,-1,0,-1,-1,0,1,-1,1,-1,1,-1,1,-2,-1,1,-1,-1,1,0,0,1], [-1,-1,0,1,0,0,0,0,1,0,0,1,0,-1,0,-1,0,1,0,0,1,-1,0,2], [-1,-1,0,1,0,0,0,0,1,-1,0,1,0,-1,0,0,0,1,0,0,1,-1,0,2], [0,1,-1,0,0,0,0,1,-1,1,-1,0,0,0,-1,0,-1,0,1,0,1,0,0,-1], [0,0,-1,1,0,0,0,1,0,0,0,1,0,0,-1,0,-1,1,1,0,1,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1,0,0,0], [-1,-1,-1,1,-1,0,0,0,0,1,-2,1,-1,-1,-1,-1,0,1,0,0,1,-2,1,2], [0,0,0,1,0,1,1,-1,0,1,-1,1,-1,1,-1,2,2,-1,1,1,0,0,0,0], [0,0,0,-1,0,-1,-1,0,0,0,0,-1,0,-1,1,-2,-1,0,-1,-1,0,0,0,0], [0,0,0,0,1,-1,0,0,1,-1,1,0,1,0,0,1,0,0,0,0,0,1,0,0]]]], [ # Q-class [24][10] [[2], [1,2], [0,0,2], [0,0,1,2], [0,0,0,0,2], [0,0,0,0,1,2], [0,0,0,0,0,0,2], [0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2]], [[[0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [24][11] [[4], [0,4], [1,0,4], [-2,2,1,4], [0,1,-2,-1,4], [-2,1,-2,1,2,4], [0,-2,0,-2,0,-1,4], [1,-2,2,-1,-2,-2,2,4], [-2,0,0,2,0,2,-2,-1,4], [1,0,0,0,-2,-2,0,1,-2,4], [0,2,1,2,-1,-1,-2,0,0,2,4], [-2,0,-2,0,2,2,0,-1,2,-2,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,-2,2,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,-2,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,-2,1,-2,1,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,-2,0,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,1,-2,2,-1,-2,-2,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,-2,0,0,2,0,2,-2,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-2,-2,0,1,-2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,2,-1,-1,-2,0,0,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,-2,0,-2,0,2,2,0,-1,2,-2,-1,4]], [[[0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,1,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,-1,0,0,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,1,-1,1,1,-1,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-2,1,0,-1,1,-1,-1,1,1,1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,-1,1,-1,-1,1,1,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-2,1,1,-1,-1,-1,1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,0,-1,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,1,-1,-1,1,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,1,-1,-1,1,1,-1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,1,-1,0,1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,0,1,-1,1,1,2,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,1,0,-1,2,1,-1,-1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [24][12] [[4], [-2,4], [0,-2,4], [0,0,-2,4], [0,0,0,-2,4], [0,0,-2,0,0,4], [0,0,0,0,0,0,4], [0,0,0,0,0,0,-2,4], [0,0,0,0,0,0,0,-2,4], [0,0,0,0,0,0,0,0,-2,4], [0,0,0,0,0,0,0,0,0,-2,4], [0,0,0,0,0,0,0,0,-2,0,0,4], [-2,1,0,0,0,0,2,-1,0,0,0,0,4], [1,-2,1,0,0,0,-1,2,-1,0,0,0,-2,4], [0,1,-2,1,0,1,0,-1,2,-1,0,-1,0,-2,4], [0,0,1,-2,1,0,0,0,-1,2,-1,0,0,0,-2,4], [0,0,0,1,-2,0,0,0,0,-1,2,0,0,0,0,-2,4], [0,0,1,0,0,-2,0,0,-1,0,0,2,0,0,-2,0,0,4], [-2,1,0,0,0,0,2,-1,0,0,0,0,2,-1,0,0,0,0,4], [1,-2,1,0,0,0,-1,2,-1,0,0,0,-1,2,-1,0,0,0,-2,4], [0,1,-2,1,0,1,0,-1,2,-1,0,-1,0,-1,2,-1,0,-1,0,-2,4], [0,0,1,-2,1,0,0,0,-1,2,-1,0,0,0,-1,2,-1,0,0,0,-2,4], [0,0,0,1,-2,0,0,0,0,-1,2,0,0,0,0,-1,2,0,0,0,0,-2,4], [0,0,1,0,0,-2,0,0,-1,0,0,2,0,0,-1,0,0,2,0,0,-2,0,0,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-2,-2,-1,-1,0,0,0,0,0,0], [0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,-1,-1,-1,-1,0,0,0,0,0,0,0,0,1,1,1,1,0], [0,0,0,0,0,0,-1,-1,-2,-2,-1,-1,0,0,0,0,0,0,1,1,2,2,1,1], [0,0,0,0,0,0,1,1,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,-1,-1,-1,0,0,1,1,1,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,-1,-2,-2,-1,-1,1,1,2,2,1,1,0,0,0,0,0,0], [-1,-1,0,0,0,0,1,1,0,0,0,0,-1,-1,0,0,0,0,-1,-1,0,0,0,0], [0,0,-1,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,-1,0,0,0], [0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,-1,0,0], [0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,-1,0], [0,1,1,1,1,0,0,-1,-1,-1,-1,0,0,1,1,1,1,0,0,1,1,1,1,0], [1,1,2,2,1,1,-1,-1,-2,-2,-1,-1,1,1,2,2,1,1,1,1,2,2,1,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-2,-3,-2,-1,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1,2,3,2,1,2,-1,-2,-3,-2,-1,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2,-3,-2,-1,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,1,2,3,2,1,2,0,0,0,0,0,0,-1,-2,-3,-2,-1,-2], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-2,-3,-2,-1,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,-2,-3,-2,-1,-2,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-2,-3,-2,-1,-2,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1], [1,2,3,2,1,2,-1,-2,-3,-2,-1,-2,0,0,0,0,0,0,1,2,3,2,1,2], [0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0]]]], [ # Q-class [24][13] [[4], [2,4], [-1,1,4], [-1,0,0,4], [0,0,0,-1,4], [-1,0,2,1,1,4], [-1,-1,0,0,2,2,4], [1,0,0,1,1,1,0,4], [2,1,1,0,-1,0,-1,1,4], [-1,-1,0,1,0,1,0,1,0,4], [0,-1,-1,2,1,1,1,2,1,2,4], [0,0,0,-1,0,-1,0,-1,1,2,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,2,1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,2,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,1,1,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,2,1,1,0,-1,0,-1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,1,0,1,0,1,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,2,1,1,1,2,1,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,-1,1,2,1,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,0,1,0,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,1,0,1,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,-1,0,1,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,-1,0,0,0,1,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,0,0,0,1,1,-2,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,1,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,-1,0,-2,1,-1,0,2,1,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,1,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,-1,0,-1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,-1,-1,-1,1,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,-1,0,1,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,0,1,-1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,1,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,1,0,-1,-1,1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,1,0,1,0,1,-1,-1,-1,2,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [24][14] [[4], [0,4], [0,0,4], [0,0,0,4], [0,1,0,2,4], [-2,-1,0,0,0,4], [0,-1,0,0,0,0,4], [0,-1,0,0,0,0,2,4], [0,0,1,0,1,-1,1,0,4], [-2,-2,-2,-2,-1,1,-1,1,-2,8], [-2,0,-2,-2,0,0,2,2,0,4,8], [0,1,2,0,0,0,0,0,0,-1,0,4], [-2,-2,-2,-2,-1,1,-1,1,-1,6,2,-1,8], [-2,-2,-2,-2,-2,2,2,0,-1,4,4,-2,2,8], [0,0,0,-1,0,1,0,-1,0,0,0,-1,-1,1,4], [0,0,1,-1,-1,-1,-1,-1,0,1,0,0,0,1,0,4], [1,-2,-1,-1,-1,0,1,0,0,1,0,-1,2,2,0,0,4], [-1,2,1,1,1,0,-1,0,-1,-1,0,1,-2,-2,-1,1,-3,6], [-2,1,-2,1,1,2,-1,0,0,1,0,-2,2,1,-1,0,-1,2,8], [0,2,2,2,1,0,-2,-1,-1,-3,-4,1,-3,-4,-1,1,-3,5,2,8], [1,0,1,-1,0,-1,1,1,2,-1,0,1,-1,-1,0,0,0,0,-1,0,4], [0,-1,0,-2,0,-1,2,2,2,2,4,1,1,1,-1,1,0,1,-1,-2,3,8], [0,1,0,0,0,0,0,0,-1,-1,0,0,-1,0,0,1,-1,1,1,1,0,0,4], [1,0,0,1,0,0,1,0,0,-2,0,1,-2,-1,0,-2,0,0,-1,0,0,0,0,4]], [[[-1,0,0,0,0,0,-1,1,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0], [1,0,1,1,0,0,-1,0,0,-1,1,0,1,1,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,1,0,1,1,0,0,0,0,0,0,0,1,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,1,-1,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,-1,0,-1,0,0,-1,0,0,0,-1,-1,0,0,0,-1,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0], [0,-1,0,-1,0,-1,0,0,0,0,0,1,-1,0,0,-1,0,0,1,0,-1,0,0,-1], [0,1,-1,0,0,1,1,0,1,0,-1,0,1,0,0,1,-1,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,-1,-1,0,0,0,0,0,0], [0,0,0,-1,1,1,1,0,-1,0,0,-1,0,-1,-1,2,-1,0,0,-1,1,-1,-1,1], [-1,0,-1,-1,1,0,0,0,-1,-1,-1,0,0,0,0,1,-1,-1,0,0,0,1,-1,1], [0,0,0,0,-1,0,1,-1,1,1,0,0,0,-1,0,-1,0,0,0,0,0,0,1,0], [-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,1,0,1,-1,1,0,0,3,1,0,0,1,1,0,-1,0,2,-1,0,0,-1,1,0], [-1,-1,-1,-1,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0], [2,1,0,1,0,1,0,0,2,1,0,0,1,1,0,0,0,1,-1,0,0,-1,1,0], [2,1,1,2,-1,0,-1,-1,1,0,1,1,1,1,1,-2,1,0,0,1,-1,1,1,-1], [2,1,0,1,0,1,0,0,2,1,0,0,1,1,0,0,1,2,-1,0,0,-1,1,0], [0,0,-1,-1,0,1,1,0,1,1,0,0,-1,-1,-1,1,0,0,0,0,0,-1,0,0], [0,0,-1,-1,0,1,1,0,1,1,-1,0,-1,-1,-1,1,-1,0,0,-1,0,-1,0,0], [1,1,1,2,-1,1,0,-1,0,0,1,-1,1,0,0,0,0,0,0,0,1,0,0,0], [-2,-1,0,-1,1,-1,0,0,-3,-1,0,0,-1,-1,0,1,0,-1,1,-1,1,0,-1,0]], [[1,1,1,1,-1,1,1,-1,0,1,1,-1,0,-1,0,0,0,0,0,0,0,0,0,0], [1,1,0,1,0,1,0,0,1,0,0,0,1,1,0,0,0,1,-1,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [-2,-1,-1,-2,1,-2,0,0,-1,0,-1,1,-1,0,0,0,0,-1,1,0,0,0,0,0], [-1,0,0,-1,1,-1,-1,1,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,-2,-1,-2,1,-2,-1,0,-1,-1,0,1,-1,0,0,0,0,-1,1,0,0,0,0,0], [-1,0,-1,-1,0,-1,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,1,-1,1,1,0,2,1,0,0,1,0,0,0,0,1,-1,0,0,-1,1,0], [-2,0,-1,-1,1,0,1,0,-2,0,-1,-1,-1,-1,-1,2,-1,-1,0,-1,1,0,-1,1], [-1,-1,0,-1,0,-1,0,0,-1,0,0,0,-1,-1,0,0,0,0,1,-1,0,0,0,0], [-1,1,0,0,1,0,-1,1,-1,-1,-1,0,0,1,0,1,0,-1,0,0,0,1,-1,1], [0,0,0,0,0,0,-1,0,-1,-2,0,0,1,1,0,0,-1,-1,0,0,0,1,-1,0], [0,1,0,1,0,1,0,0,-1,-1,0,0,0,0,0,1,0,-1,0,0,0,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [-3,-1,0,-2,2,-2,-1,1,-3,-1,-1,0,-1,0,0,1,-1,-2,1,0,0,1,-1,1], [0,1,0,0,0,1,0,0,0,0,0,-1,0,0,-1,0,0,0,-1,0,0,0,0,0], [2,1,2,2,-1,0,-1,0,1,0,1,0,1,1,1,-2,1,0,0,1,-1,1,1,-1]], [[0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [-1,-1,-1,-1,1,-1,-1,1,0,0,-1,1,-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,-1,-1,0,0,1,0,0,1,-1,0,-1,-1,0,0,0,0,0,0,0,0,0,0], [-1,-1,-1,-1,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [1,0,1,1,-1,0,0,-1,0,-1,1,-1,1,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0], [-1,-1,-1,-1,1,-1,-1,1,0,-1,-1,1,0,1,0,0,0,0,0,0,0,0,0,0], [1,0,0,1,-1,0,0,-1,0,-1,1,0,1,0,0,0,-1,0,0,0,0,0,0,0], [0,1,1,1,-1,0,1,-1,0,1,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0], [0,1,1,1,0,0,0,0,-1,0,0,-1,0,0,0,0,0,-1,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,-1,-1,0,1,1,0,1,1,0,0,-1,-1,-1,1,0,0,0,0,0,-1,0,0], [1,0,0,1,-1,2,2,-2,0,1,1,-1,0,-2,-1,1,0,1,0,-1,1,-1,0,0], [1,0,-1,0,0,2,1,0,2,1,0,0,0,0,-1,1,0,1,-1,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,-1,-1,-1,0,0,1,0,0,0,0,0,0,-1,0,1,-1,0,0,0,1,-1,0,0], [1,0,0,1,-1,0,0,0,2,1,0,1,0,0,1,-1,1,1,0,0,-1,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1]]]], [ # Q-class [24][15] [[4], [0,4], [-2,2,4], [-2,2,2,4], [2,0,-1,-1,4], [0,2,1,1,0,4], [-1,1,2,1,-2,2,4], [-1,1,1,2,-2,2,2,4], [0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,-2,2,4], [0,0,0,0,0,0,0,0,-2,2,2,4], [0,0,0,0,0,0,0,0,2,0,-1,-1,4], [0,0,0,0,0,0,0,0,0,2,1,1,0,4], [0,0,0,0,0,0,0,0,-1,1,2,1,-2,2,4], [0,0,0,0,0,0,0,0,-1,1,1,2,-2,2,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,2,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,-1,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,1,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,2,1,-2,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,2,-2,2,2,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,0,1,-1,1,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0]], [[-1,0,-1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,1,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [24][16] [[8], [-1,8], [2,1,8], [0,-1,2,8], [2,0,1,-2,8], [2,-4,-1,4,0,8], [0,0,2,1,-1,1,8], [1,1,1,1,-1,-1,-3,8], [0,-3,-1,4,-1,4,2,-1,8], [0,-2,1,2,2,2,0,0,2,8], [1,-1,3,-1,-1,-1,2,0,-2,-2,8], [-1,1,2,4,-2,0,0,3,0,0,2,8], [1,1,4,3,0,1,4,0,1,1,2,0,8], [-1,0,1,1,1,1,2,-2,0,1,2,1,2,8], [-2,2,0,1,-2,-1,-1,3,-1,1,-1,1,-1,-1,8], [3,-1,2,-1,3,-1,0,0,-2,0,2,0,1,-1,-4,8], [0,1,-1,-4,-1,-4,0,1,0,-2,0,-4,-1,-4,1,0,8], [1,2,0,-3,1,-3,0,1,-2,2,0,-3,1,0,3,-2,4,8], [-1,1,-1,-3,2,-3,-4,2,-2,2,-4,-3,-2,-4,2,0,4,4,8], [3,0,2,-2,2,-2,0,2,-4,0,4,1,1,2,0,2,0,4,0,8], [2,-2,-3,-1,3,2,-3,-1,1,0,-2,-2,-3,-4,-1,2,1,-1,2,-2,8], [-1,-3,1,0,0,2,3,-4,1,3,1,-1,2,3,-4,0,-3,-1,-2,0,-3,8], [1,-3,3,3,2,3,4,-3,2,2,2,2,3,2,-4,4,-4,-4,-4,0,0,4,8], [-3,1,1,-2,1,-2,2,-4,-3,-2,3,0,1,2,-3,1,-1,-1,-2,1,-1,3,2,8]], [[[-2,-1,1,-1,1,1,-1,-2,-2,2,-1,1,1,-1,-2,-1,2,-1,-3,1,-1,-2,-1,-2], [1,1,-1,0,0,0,0,0,0,0,0,1,1,1,1,0,2,-2,1,1,1,2,0,0], [0,0,0,-1,-1,0,0,0,1,1,0,-1,0,0,0,0,-1,-1,1,1,-1,-2,1,1], [0,-1,0,0,0,0,1,0,1,0,1,-1,-1,-1,-1,1,-3,1,1,-1,-2,-2,-1,1], [-2,-1,1,-2,0,1,-1,-1,0,0,-1,0,0,-2,-2,0,-2,3,-2,0,-2,-3,1,-1], [-1,-1,1,0,0,0,0,0,0,0,0,-1,-1,-1,-2,0,-2,2,-1,-1,-1,-2,0,0], [0,0,0,0,-1,-1,1,0,0,1,0,-1,1,1,0,-1,0,-3,1,2,2,0,-1,0], [2,0,-1,0,0,0,-1,0,1,-1,0,1,0,1,2,1,1,0,1,-1,-1,1,1,1], [-1,-2,1,0,1,1,0,-1,-1,0,-1,1,0,-1,-1,1,0,2,-2,-1,-1,-1,-2,0], [0,-1,0,-1,0,0,0,1,1,-1,0,0,-1,0,0,1,-2,3,0,-2,-1,-1,1,1], [0,0,0,0,0,-1,0,0,0,1,0,-1,1,0,0,-1,0,-2,0,1,0,-1,0,0], [2,0,-1,0,-1,-1,1,1,2,0,2,-2,-1,0,0,0,-3,0,3,-1,-2,-2,1,2], [-2,-1,1,-1,0,0,0,-1,0,1,-1,0,1,-1,-1,1,-1,0,-2,1,0,-1,-2,-1], [0,0,0,0,0,-1,0,0,0,0,0,-1,0,0,0,0,-1,0,0,0,0,0,0,0], [3,1,-2,1,0,-1,0,1,1,-1,0,1,0,2,3,0,2,-2,2,0,1,3,1,2], [-3,-1,1,-1,0,1,0,-1,-1,1,0,-1,0,-2,-3,0,-2,2,-2,0,-2,-4,0,-2], [0,0,0,0,1,1,-1,-1,-2,0,-2,3,2,1,2,0,5,-2,-2,1,2,3,-1,-1], [0,0,0,-1,1,0,-1,-1,-1,0,-2,3,2,1,2,0,4,-2,-2,1,2,3,-1,-1], [0,0,0,-1,0,1,-1,0,0,-1,-1,2,0,0,1,1,1,2,-1,-1,0,1,1,0], [0,0,0,-1,0,-1,0,-1,0,1,0,0,1,0,0,-1,0,-2,0,1,0,-1,0,-1], [-2,-1,1,-1,1,2,-1,-1,-1,0,-1,1,0,-2,-2,0,0,3,-3,-1,-2,-2,0,-1], [-1,0,1,0,-1,-1,1,1,1,0,1,-2,-1,0,-1,0,-3,1,1,0,1,-1,0,0], [-2,-1,1,-1,-1,0,1,0,1,1,1,-3,-1,-2,-3,0,-5,2,0,0,-2,-5,0,0], [0,1,0,0,-1,-1,1,1,1,0,1,-2,0,0,0,-1,-2,-1,2,1,1,0,1,0]], [[-4,-2,2,-2,1,2,-1,-3,-2,1,-2,2,1,-3,-3,1,0,3,-5,0,-2,-3,-2,-3], [0,0,0,1,0,0,1,1,-1,0,1,-1,-1,0,-1,-1,-1,1,1,-1,0,-1,1,0], [-1,0,0,0,0,0,0,0,0,0,1,-1,-1,-1,-2,0,-2,2,0,-1,-1,-2,1,-1], [0,0,0,0,0,-1,1,0,1,0,0,0,0,0,0,0,-1,-1,1,1,1,0,-1,0], [0,0,0,0,1,1,-1,-1,-2,1,-1,2,1,0,0,0,3,-1,-2,0,0,1,-1,-1], [0,0,0,-1,0,0,0,-1,1,0,-1,1,1,0,1,1,0,-1,0,1,0,0,-1,0], [-1,0,0,0,0,0,1,0,1,1,1,-2,-1,-2,-2,0,-3,1,0,0,-2,-3,0,0], [1,0,0,0,-1,-1,0,0,0,0,0,0,0,1,0,-1,0,0,1,0,1,0,1,0], [0,0,0,-1,0,0,0,0,2,0,0,0,0,-1,0,1,-2,1,0,0,-1,-1,-1,1], [2,0,-1,0,0,-1,0,0,1,0,1,0,0,0,1,0,-1,-1,2,-1,-1,0,0,1], [-2,-1,1,0,0,0,0,0,0,0,0,-1,-1,-1,-2,1,-2,3,-2,-1,-1,-2,0,-1], [-1,0,1,1,0,-1,1,0,0,0,0,-1,-1,0,-1,0,-1,0,0,1,1,0,-1,-1], [-1,0,0,0,0,-1,1,0,0,1,1,-1,0,-1,-2,-1,-2,0,0,0,0,-2,0,-1], [0,1,0,1,-1,-1,1,1,1,0,1,-2,-1,0,0,0,-2,-1,1,1,1,0,0,0], [2,0,-1,1,0,-1,0,1,0,-1,0,0,0,1,2,0,1,0,1,-1,1,2,1,1], [-2,-1,1,-1,1,1,-1,-2,-2,2,-1,1,1,-1,-2,-1,2,-1,-3,1,-1,-2,-1,-2], [0,-1,0,-1,0,1,-1,0,0,0,0,0,0,-1,-1,0,-1,3,-1,-2,-2,-2,1,1], [0,-1,0,0,0,0,0,0,-1,0,0,0,0,-1,-1,0,-1,2,-1,-2,-1,-1,0,0], [2,0,-1,0,0,0,-1,0,-1,0,0,1,1,1,1,-1,2,-1,1,-1,0,1,1,1], [-2,-1,1,0,0,0,0,-1,-2,1,-1,0,0,-1,-2,0,0,1,-3,0,0,-1,-1,-2], [-1,-1,1,-1,2,2,-2,-2,-2,0,-3,4,2,0,1,1,5,0,-4,0,0,2,-2,-1], [1,1,-1,0,-1,-1,1,1,2,0,2,-2,-1,0,0,0,-3,-1,3,0,-1,-1,1,1], [-1,0,0,0,1,0,0,-1,0,1,0,0,0,-1,-1,0,0,-1,-1,1,-1,-1,-1,-1], [0,1,0,1,0,0,1,1,0,0,1,-1,-1,1,0,0,0,-1,1,0,1,1,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,-1,0,1,0,1,0,1,-1,-1,0,-1,0,-2,0,2,0,0,-1,0,0], [2,1,-1,1,0,0,0,1,0,-1,0,0,0,2,2,0,2,-2,2,0,1,2,1,1], [-2,-1,1,0,1,0,0,-1,-2,1,-1,0,1,-1,-2,-1,1,-1,-2,1,0,-1,-1,-2], [3,1,-2,1,-1,-1,1,1,1,0,2,-1,0,1,1,-1,-1,-2,4,0,0,0,1,2], [-2,-1,1,0,1,0,0,-1,-2,1,-1,0,1,-1,-2,-1,1,0,-3,1,0,-1,-1,-2], [-2,0,1,-1,1,2,-1,-2,-2,1,-2,2,2,0,0,0,4,-2,-3,2,1,1,-2,-2], [1,0,0,0,0,0,0,1,1,-1,0,0,-1,0,0,0,-1,1,1,-1,-1,0,1,1], [-3,-2,1,-1,2,1,-1,-2,-3,1,-2,2,2,-2,-2,0,2,1,-5,0,-1,-1,-2,-3], [2,0,-1,0,-1,-1,0,1,0,0,0,0,1,2,1,-1,1,-2,2,0,1,1,1,1], [2,1,-1,1,1,0,0,1,0,-1,0,1,0,2,3,0,3,-2,1,0,2,4,0,1], [0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,1,-1,0], [0,1,0,0,0,0,0,0,-1,0,-1,0,1,1,1,-1,2,-3,0,2,2,2,0,-1], [0,0,0,0,0,0,1,0,0,0,1,-1,0,0,0,0,-1,-1,1,0,0,0,-1,0], [0,0,0,-1,-1,0,0,1,2,-1,1,-1,-1,0,-1,0,-3,2,2,-1,-1,-2,2,1], [3,1,-1,1,0,-1,0,0,0,0,0,1,1,2,3,-1,3,-4,2,1,2,3,0,1], [0,0,0,-1,0,1,-1,0,0,-1,-1,2,0,0,1,1,1,2,-1,-1,0,1,1,0], [2,1,-1,-1,-2,0,0,2,2,-1,1,-1,-1,1,1,0,-2,1,3,-1,0,0,3,2], [2,1,-1,0,-2,-1,0,2,2,-1,1,-1,-1,1,1,0,-2,1,3,-1,0,0,3,2], [3,1,-1,0,-1,0,0,2,2,-1,1,-1,-1,1,2,0,-1,0,3,-1,0,1,2,3], [1,0,-1,1,0,-1,0,0,0,0,1,0,0,0,0,-1,0,0,1,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,1,-1,0,1,1,1,0,2,-2,-1,1,1,1,-1,0], [0,0,0,1,1,0,0,-1,-2,1,-1,1,2,1,1,-1,4,-4,-1,2,2,2,-2,-1], [1,1,-1,1,0,0,0,0,0,0,0,0,0,1,2,0,2,-2,1,1,1,2,0,1]]]], [ # Q-class [24][17] [[8], [2,8], [2,3,8], [-2,-2,0,8], [-2,0,0,-2,8], [-3,-1,-3,0,2,8], [-3,-1,-2,0,2,2,8], [-1,-4,-2,0,-1,-1,2,8], [1,0,-1,-2,0,2,-1,-2,8], [-1,0,2,2,-2,-4,0,2,-4,8], [0,-2,-2,0,2,2,0,0,0,-4,8], [0,2,1,-1,-2,-3,-1,-1,1,3,-4,8], [0,-1,1,2,-1,0,-2,1,1,0,3,-2,8], [2,4,4,-3,2,-1,0,-2,1,0,0,1,0,8], [-3,-2,-4,0,2,2,1,1,0,-1,1,-2,-4,-2,8], [0,0,-3,0,-1,-2,0,3,-4,2,1,2,0,-2,0,8], [2,2,4,2,-1,-2,-4,-2,0,3,-2,3,3,1,-4,0,8], [2,4,3,-4,2,-2,-2,-2,-2,1,-3,2,-4,2,0,1,1,8], [4,-2,1,-2,1,0,-3,0,2,-2,2,-2,3,2,-3,-2,1,0,8], [4,2,0,-4,-1,-2,-2,0,3,0,-3,3,-2,2,-1,0,0,3,3,8], [-1,3,0,-4,4,4,1,-3,4,-4,0,0,-2,3,2,-3,-1,2,0,2,8], [0,-2,-4,0,-2,4,2,2,2,-4,2,-3,2,-3,0,0,-2,-4,0,-2,0,8], [2,4,3,-1,-1,-1,2,0,-2,2,-4,0,-3,3,-1,-1,0,3,-2,1,0,-1,8], [-2,2,1,0,2,-2,3,2,-4,4,-4,2,-3,1,1,2,1,3,-4,-1,0,-2,4,8]], [[[-1,0,-1,1,1,-1,0,1,-1,0,0,1,0,0,0,-1,1,1,0,0,1,1,1,-2], [0,-1,-1,1,1,-1,0,0,-1,0,1,2,1,0,0,-1,0,1,0,0,1,1,2,-1], [0,0,-2,1,0,-1,0,1,0,1,1,1,0,0,-1,-1,0,1,0,-1,2,0,1,-1], [1,0,-1,0,-1,1,0,1,0,-1,-1,-1,0,1,-1,0,0,0,-1,-1,0,-2,-1,0], [0,0,1,0,1,0,-1,-1,1,1,1,0,0,-1,0,1,-1,-1,0,1,0,1,1,1], [1,-1,0,0,0,0,-1,-1,0,0,0,0,1,0,0,0,-1,0,-1,0,0,0,0,1], [0,0,2,1,1,0,-1,-1,1,2,1,0,0,0,0,1,-2,0,0,1,0,2,0,1], [0,2,2,0,0,1,0,0,1,1,0,0,-1,-1,1,1,-1,-1,2,0,-1,0,-1,1], [0,-1,-1,0,0,-1,0,0,0,0,-1,0,1,0,0,0,0,1,0,-1,1,0,1,-1], [-1,1,0,1,0,-1,0,1,0,1,1,0,-2,0,-1,0,0,0,1,0,1,1,0,-1], [1,0,0,-1,-1,1,1,0,0,-2,-1,-1,1,0,1,0,1,0,-1,0,-1,-2,-1,1], [-1,0,0,0,0,-1,0,0,-1,0,0,1,0,0,0,0,0,0,1,0,1,1,1,-1], [2,0,-1,0,-1,1,1,1,0,-1,-1,0,1,0,0,-1,0,1,-1,-1,0,-2,-1,0], [-1,0,0,1,0,-1,0,0,1,1,2,1,0,-1,0,0,0,1,1,0,1,1,2,0], [-1,1,2,-1,0,0,0,-1,1,0,0,-1,-1,-1,1,2,0,-2,2,0,-1,0,0,1], [0,1,1,-1,0,1,1,0,-1,-2,-1,0,0,0,1,0,1,-1,0,1,-2,-1,-1,0], [0,0,-2,1,0,-1,0,1,-1,0,0,1,0,0,-1,-1,0,1,0,-1,2,0,1,-2], [-1,0,-1,0,1,-1,0,0,-1,0,1,1,0,0,0,-1,1,0,0,1,0,1,1,-1], [0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,-1,1,1,-1,0,0,0,0,-1], [-1,0,-1,0,1,-1,0,1,-1,0,0,1,0,0,0,-1,1,1,0,0,0,1,1,-2], [0,-1,0,0,1,-1,-1,-1,0,1,1,1,1,-1,0,0,-1,0,0,0,1,1,2,0], [1,0,1,0,0,1,0,-1,0,0,-1,0,1,0,1,0,-1,0,0,0,-1,0,-1,1], [-1,0,0,2,1,-1,-1,0,1,2,2,1,-1,0,-1,0,-1,1,1,0,1,2,1,0], [-1,1,2,1,1,0,-1,-1,1,2,2,1,-1,-1,0,1,-2,-1,2,1,0,2,1,1]], [[0,0,1,0,0,0,0,-1,1,1,1,0,0,-1,0,1,-1,-1,1,0,1,0,1,1], [-1,-1,0,2,1,-1,-1,0,0,2,2,1,0,0,-1,0,-1,1,0,1,2,2,2,-1], [0,0,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,1,0], [1,0,-2,0,0,0,0,1,-1,-1,-1,-1,0,1,-1,-1,1,1,-2,0,0,-1,-1,-1], [0,-1,-1,0,-1,0,0,0,0,-1,0,0,1,0,-1,-1,0,1,-1,0,0,-1,0,1], [-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,-1], [1,0,0,0,0,1,0,0,0,0,0,1,1,0,0,-1,-1,1,0,0,-1,0,-1,1], [1,1,1,-1,0,1,1,0,0,-1,-1,0,0,0,1,0,0,-1,0,0,-2,-1,-2,1], [-1,0,2,0,0,0,-1,-1,2,1,0,-1,-1,0,0,2,-1,-1,1,0,0,1,0,1], [1,0,0,0,1,1,0,0,-1,0,0,1,1,0,1,-1,0,0,-1,1,-1,0,0,0], [0,0,0,-1,-2,0,1,0,0,-1,0,-1,0,0,0,0,1,0,0,0,0,-1,-1,1], [0,0,-1,0,1,0,0,1,-1,0,-1,0,0,1,0,-1,1,0,-1,0,0,0,0,-2], [0,1,1,-1,-1,1,0,0,1,0,0,-1,-1,0,0,1,0,-1,0,0,-1,-1,-1,1], [0,-2,0,0,0,0,-1,-1,0,1,1,0,1,0,-1,0,-1,0,-1,1,1,0,1,1], [0,-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,1,0,0], [0,1,0,0,0,0,1,1,-1,0,0,0,-1,0,0,-1,1,0,0,0,0,0,-1,-1], [0,0,-2,0,0,0,0,1,0,0,0,-1,0,1,-1,-1,1,1,-2,0,0,-1,0,-1], [-1,0,0,1,1,-1,0,0,0,1,1,1,0,-1,0,0,0,0,1,0,1,1,2,-1], [0,0,1,-2,-1,1,0,-1,1,-1,0,-1,0,-1,0,1,0,-2,0,0,-1,-2,0,2], [-1,0,2,0,1,0,-1,-1,1,1,1,0,-1,-1,0,1,-1,-2,1,1,0,1,1,1], [-1,-1,0,1,0,-1,-1,0,1,1,1,0,0,0,-1,0,-1,1,0,0,1,1,1,0], [0,1,1,0,0,0,0,0,1,1,0,0,-1,0,0,1,-1,0,1,-1,0,1,-1,0], [0,-1,0,1,1,0,0,-1,0,1,1,1,1,0,0,0,-1,1,0,1,0,1,1,0], [1,-1,-2,1,1,0,0,1,-1,0,0,1,1,1,-1,-2,0,2,-2,0,0,0,0,-1]], [[0,-1,-1,0,0,0,1,0,-1,-1,0,0,1,1,0,-1,1,2,-2,1,-1,0,0,-1], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,-1,0,0,0,0,0,0,0,-1,0,-1,0,-1,0,0,0,0,0], [0,0,2,0,0,0,0,-1,0,0,-1,0,0,0,1,1,-1,-1,1,0,0,1,-1,1], [0,0,-2,1,1,-1,-1,1,-1,1,0,1,0,0,-1,-1,0,1,0,-1,2,1,1,-2], [0,0,0,1,0,-1,-1,0,1,2,1,0,-1,-1,-1,0,-1,0,1,-1,2,1,1,0], [0,0,-1,0,0,-1,0,1,0,1,0,-1,-1,0,-1,0,1,0,0,-1,2,0,0,-1], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,-2,0,0,0,0,1,-1,-1,0,0,0,1,-1,-2,1,1,-2,0,0,-1,0,-1], [0,1,2,-1,0,1,0,-1,0,0,0,0,0,-1,1,1,-1,-2,1,1,-1,0,-1,2], [1,-1,-1,0,0,0,0,0,0,0,-1,0,1,1,0,0,0,1,-1,-1,0,0,0,-1], [0,1,1,0,0,1,0,0,0,0,1,0,-1,0,0,0,0,-1,0,1,-1,0,-1,1], [2,-1,-1,0,0,1,0,0,0,-1,-1,0,2,1,0,-1,-1,1,-2,0,-1,-1,-1,1], [1,0,0,0,1,1,-1,0,0,1,0,0,0,0,-1,0,-1,0,-1,0,0,0,0,0], [-1,1,1,0,0,-1,0,0,0,1,0,1,-1,-1,1,1,0,-1,3,-1,1,1,1,-1], [0,1,1,0,-1,1,1,0,1,0,0,0,0,0,1,1,0,0,1,0,-1,0,-1,1], [0,0,1,1,1,0,-1,-1,0,1,1,1,0,0,0,0,-2,0,0,1,0,2,0,1], [-1,1,0,0,0,0,0,0,0,0,1,1,0,-1,0,0,0,0,1,0,0,0,1,0], [1,-2,-2,0,0,1,0,0,-1,-1,0,0,2,1,-1,-2,0,2,-3,1,-1,-1,0,0], [0,0,-2,-1,-1,1,1,1,-1,-2,0,-1,0,1,-1,-2,2,1,-2,1,-2,-2,-1,0], [0,0,-2,1,0,-1,-1,1,0,1,1,0,-1,0,-2,-1,0,1,0,-1,2,0,1,-1], [0,-1,0,1,0,-1,0,0,1,1,1,0,0,0,0,0,0,1,0,0,1,1,1,0], [-1,1,1,0,1,-1,0,0,0,1,0,0,-1,-1,0,1,0,-1,1,0,1,1,1,-1], [-1,1,1,1,1,-1,-1,0,0,2,1,1,-1,-1,0,1,-1,-1,2,0,2,2,1,0]]]], [ # Q-class [24][18] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]]]], [ # Q-class [24][19] [[2], [1,2], [1,1,2], [1,1,1,2], [0,0,0,0,2], [0,0,0,0,1,2], [0,0,0,0,1,1,2], [0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2]], [[[0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [24][20] [[3], [1,3], [0,1,3], [-1,1,1,3], [1,0,1,-1,3], [-1,-1,1,0,1,3], [0,0,0,0,0,0,3], [0,0,0,0,0,0,1,3], [0,0,0,0,0,0,0,1,3], [0,0,0,0,0,0,-1,1,1,3], [0,0,0,0,0,0,1,0,1,-1,3], [0,0,0,0,0,0,-1,-1,1,0,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,1,3]], [[[0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [24][21] [[4], [-2,4], [0,0,4], [1,-2,2,4], [1,-2,0,2,4], [-2,2,-1,-2,0,4], [-2,2,2,0,-1,0,4], [-1,-1,-2,-1,-1,0,-1,4], [0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,-2,4], [0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,1,-2,2,4], [0,0,0,0,0,0,0,0,1,-2,0,2,4], [0,0,0,0,0,0,0,0,-2,2,-1,-2,0,4], [0,0,0,0,0,0,0,0,-2,2,2,0,-1,0,4], [0,0,0,0,0,0,0,0,-1,-1,-2,-1,-1,0,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-2,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-2,0,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,2,-1,-2,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,2,2,0,-1,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-2,-1,-1,0,-1,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,0,1,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,-1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,-1,1,-1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,-1,1,0,-1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [24][22] [[8], [-1,8], [2,-1,8], [0,4,-1,8], [4,-1,2,-1,8], [-1,-1,2,0,-2,8], [-1,0,0,0,-1,2,8], [-1,4,-2,2,-1,0,-2,8], [1,3,-2,2,0,-2,2,1,8], [-1,-2,-1,-3,-2,2,-2,2,-3,8], [3,0,-2,3,-1,-1,-2,1,3,0,8], [2,-1,0,1,0,-1,-4,-1,-1,1,4,8], [2,0,4,1,3,-2,-1,-2,-1,-2,0,1,8], [-4,-2,-3,-1,-4,1,1,-1,0,3,1,0,-2,8], [3,-2,-1,-2,0,-1,-4,2,-1,4,2,2,-2,1,8], [3,0,0,0,3,-3,-1,-3,0,-3,1,2,1,-3,-1,8], [0,-4,-1,-4,1,0,-1,-2,-3,4,-1,0,-2,2,2,1,8], [0,0,-2,1,-1,0,-4,0,-2,2,2,4,1,2,2,1,1,8], [-2,-4,3,-3,-2,0,-1,-3,-3,2,-2,2,2,2,1,-2,1,1,8], [3,0,4,0,2,3,2,-1,0,0,-2,-2,2,-1,0,-2,-1,0,0,8], [0,-2,-2,-2,-1,4,3,-1,0,2,-1,-3,-4,3,1,0,3,1,-2,2,8], [4,-2,2,-2,4,-4,-4,-2,-2,-1,1,4,4,-4,2,4,1,2,2,-1,-4,8], [1,2,-4,2,1,-2,-4,4,2,0,4,3,0,-1,2,1,-2,4,-3,-3,-1,2,8], [1,2,3,0,2,-1,4,-2,3,-4,-2,-4,3,-3,-4,1,-3,-4,-1,3,-1,0,-3,8]], [[[3,0,2,0,-2,1,2,-2,-3,-2,-2,-1,-2,2,2,3,5,-1,2,2,-7,-7,10,3], [1,1,0,1,0,0,-1,1,-1,0,0,0,-1,2,-2,-1,0,-1,1,0,2,3,0,1], [0,0,0,0,-1,0,1,0,-1,-1,0,0,0,0,1,1,2,-1,1,1,-1,-2,3,1], [1,-1,0,-1,0,0,0,0,-1,-1,0,0,0,0,0,0,1,1,0,0,-2,-3,1,1], [3,1,2,1,-2,1,2,-2,-3,-1,-2,-1,-3,4,1,3,5,-3,3,3,-6,-4,11,3], [-1,0,-1,0,1,0,-1,1,1,0,1,0,1,-1,0,-1,-2,0,0,-1,3,2,-4,-1], [0,1,-1,1,0,0,-2,1,1,0,0,0,0,1,-2,-1,-1,-2,1,0,4,5,-2,-1], [1,0,0,2,0,0,-1,1,0,1,-1,0,-1,2,-2,-1,-1,-1,0,0,2,4,-1,0], [1,0,0,1,-1,1,0,0,-1,-1,-1,0,-1,2,0,1,2,-1,1,1,-2,0,3,2], [-2,0,-1,0,1,-1,-1,1,1,1,1,1,2,-2,0,-1,-3,0,-1,-1,4,2,-5,-2], [1,-2,1,-1,-1,0,1,-1,-1,-1,-1,0,0,-1,2,1,2,2,-1,0,-5,-6,3,2], [1,-1,1,-1,0,-1,1,-1,-1,0,0,0,0,-1,1,0,0,2,-1,-1,-2,-4,1,1], [2,0,1,0,-1,0,1,-1,-1,0,-1,-1,-1,1,0,1,2,0,1,0,-3,-3,4,1], [-3,-1,-1,-1,1,-1,-1,1,3,1,1,1,3,-3,0,-2,-4,2,-3,-2,4,3,-8,-3], [0,-1,1,0,0,0,1,0,0,0,-1,0,0,0,1,1,0,1,-1,0,-2,-2,1,0], [0,1,1,-1,0,-1,1,-2,-2,-1,1,0,-1,-1,1,0,2,0,1,1,-2,-4,4,1], [-2,0,0,-1,0,0,1,-1,0,0,1,0,1,-2,2,1,0,0,0,1,-1,-2,1,-1], [-1,0,0,-1,1,-1,0,-1,0,1,1,0,1,-2,0,-1,-2,1,-1,-1,1,-1,-2,-1], [-2,-1,-1,-1,1,-1,0,1,2,1,1,1,2,-3,0,-1,-3,2,-2,-2,3,1,-6,-2], [1,1,0,1,-1,1,0,0,-1,-1,-1,0,0,2,0,1,2,-3,2,1,0,0,4,1], [-2,1,-1,0,1,0,-1,0,1,0,1,0,1,-1,0,-1,-2,-1,0,0,3,3,-3,-2], [2,0,2,0,-1,0,2,-2,-2,0,-1,-1,-2,1,1,2,3,0,1,1,-5,-5,7,2], [2,0,1,1,0,0,0,-1,-1,1,-1,-1,-2,2,-1,0,0,0,0,0,-2,0,2,1], [1,1,0,1,-1,1,0,0,-1,-1,-1,0,-1,2,0,1,3,-2,2,1,-1,0,4,2]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,1,0,1,0], [0,0,1,0,0,-1,-1,-1,0,1,0,0,-1,0,-1,-1,-1,0,-1,0,1,1,0,0], [-2,1,-1,0,0,0,0,0,0,0,1,1,1,-1,1,0,0,-2,1,1,2,1,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,-1,0,1,-1,-1,0,0,-1,-1,0,1,2,2,0,1,2,-3,-3,4,1], [-1,-1,0,-1,0,1,1,-1,1,0,0,-1,1,-2,2,1,0,2,-1,0,-3,-3,0,-1], [2,1,1,2,0,0,0,0,0,1,-1,-1,-2,3,-2,0,0,-2,2,0,1,3,2,0], [1,0,0,1,-1,1,0,0,0,0,-1,-1,0,2,0,1,1,-2,1,1,-1,1,3,0], [1,1,1,1,0,-1,0,0,0,1,0,-1,-1,1,-2,-1,-1,0,0,-1,2,3,-1,-1], [0,1,-1,1,-1,0,-1,1,0,0,0,1,1,1,-1,0,0,-3,1,1,3,3,0,0], [1,1,0,0,-1,0,0,0,-2,-1,0,1,0,1,0,0,2,-2,1,1,0,-1,3,2], [-1,0,0,-1,0,0,0,-1,0,0,0,1,1,-1,1,0,0,0,-1,0,0,-1,0,0], [-1,0,-1,1,0,0,-1,1,1,1,0,0,1,0,-1,-1,-2,0,-1,-1,3,4,-4,-1], [3,1,0,2,0,0,-1,1,0,1,-1,-1,-2,3,-3,-1,-1,-1,1,-1,2,5,-1,0], [-1,-1,-1,-2,1,-1,0,1,0,-1,1,2,2,-3,1,-1,-1,2,-1,-1,1,-3,-3,0], [-1,-1,0,-1,1,-1,0,1,1,0,1,0,1,-2,0,-1,-2,3,-2,-2,1,0,-5,-1], [0,0,0,0,-1,0,1,0,-2,-1,0,1,0,0,1,1,2,-1,1,1,-1,-2,3,2], [1,0,1,0,-1,0,0,-1,-1,0,-1,0,-1,1,0,0,1,0,-1,0,-2,-1,2,1], [0,0,1,1,0,0,0,-1,0,1,0,-1,-1,0,0,0,0,0,0,0,0,1,1,0], [0,-1,0,0,0,0,1,0,0,0,0,-1,0,-1,1,1,0,2,0,0,-2,-2,0,0], [1,0,0,-1,0,0,0,0,-1,-1,0,1,0,0,0,0,1,0,0,0,-1,-2,1,1], [2,1,0,1,-1,1,1,0,-2,-1,-1,0,-1,3,0,2,3,-3,3,2,-2,-1,6,2], [-1,-1,0,-1,0,0,0,-1,1,0,0,0,1,-2,1,0,0,1,-1,0,-1,-2,0,-1]]]], [ # Q-class [24][23] [[4], [-2,4], [0,-1,4], [0,1,-2,4], [-2,0,-1,0,4], [0,0,0,-2,-1,4], [0,-2,1,0,1,-2,4], [2,0,1,-1,-1,0,0,4], [-1,1,0,0,2,0,0,1,4], [1,-1,2,0,0,-1,1,2,2,4], [-1,0,1,1,1,-2,2,0,1,2,4], [0,0,0,0,1,0,1,2,2,2,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,-2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,-2,4], [0,0,0,0,0,0,0,0,0,0,0,0,-2,0,-1,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,-2,1,0,1,-2,4], [0,0,0,0,0,0,0,0,0,0,0,0,2,0,1,-1,-1,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,2,0,0,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,2,0,0,-1,1,2,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,1,1,-2,2,0,1,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,2,2,2,2,4]], [[[0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,-1,0,0,0,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,0,1,1,1,0,-1,2,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,1,0,1,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,-1,-1,-1,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,1,1,1,1,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,1,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,1,1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,1,1,0,0,0,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,1,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,1,0,0,0,-1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,-2,0,0,-1,-1,-1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,2,0,0,1,1,1,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,1,0,1,0,2,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,-1,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,1,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,0,-1,-1,-1,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,0,-1,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,1,1,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,0,-1,0,0,1,1,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,1,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [24][24] [[4], [-1,4], [2,-1,4], [-1,2,-1,4], [-2,2,-1,1,4], [-1,1,1,0,1,4], [1,0,1,-1,0,1,4], [0,-1,-1,1,-1,-1,1,4], [0,0,1,2,0,1,-1,1,4], [-1,1,1,2,1,1,1,1,2,4], [-1,-1,0,-1,0,1,1,1,1,1,4], [1,0,1,1,-1,1,1,0,1,2,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,2,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,-1,2,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,-2,2,-1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,0,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,-1,0,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,-1,-1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,0,1,-1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,2,1,1,1,1,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,-1,0,1,1,1,1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,-1,1,1,0,1,2,1,4]], [[[0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,-1,0,0,-1,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [-2,1,1,-1,0,-1,1,1,1,-2,-1,2,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,-1,2,-1,1,0,-1,-1,1,1,-2,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,-1,0,1,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [-2,0,1,0,0,-1,1,0,1,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,-1,1,-1,1,0,2,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,1,1,-1,0,-1,1,1,2,-2,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,-1,0,0,1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,1,-1,0,0,0,1,1,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,0,0,0,0,-3,1,2,-1,1,-2,1,1,2,-3,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,-1,0,-2,1,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-2,0,1,0,0,-1,1,0,1,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,-1,0,-1,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,-1,1,-1,0,-2,1,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,1,0,0,-1,0,0,0] , [0,0,0,0,0,0,0,0,0,0,0,0,-2,0,0,-1,0,-1,1,0,1,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,1,0,1,-1,0,-1,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-1,1,-1,1,0,-1,-1,2,0,-2], [0,0,0,0,0,0,0,0,0,0,0,0,2,-2,-2,2,-1,1,0,-2,-1,2,1,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,1,-1,0,0,0,-1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [24][25] [[6], [0,6], [1,0,6], [-2,-1,-1,6], [-3,0,0,1,6], [1,-1,0,0,-1,6], [-1,-2,1,0,2,-1,6], [-1,0,-2,1,0,2,-2,6], [0,1,-1,0,-2,0,-2,0,6], [-2,-1,0,0,1,-1,3,-2,-2,6], [1,-1,1,-1,1,-1,3,-3,-3,3,6], [0,2,-2,0,0,0,-2,1,3,-2,-2,6], [-2,-1,0,1,2,1,2,1,-3,2,1,-3,6], [1,-1,0,0,-1,-1,-1,0,0,-1,0,1,-2,6], [1,-1,-1,1,0,0,1,0,0,-1,0,1,-2,-1,6], [-1,-1,-2,0,1,-1,1,0,0,2,0,2,-1,0,3,6], [2,-1,2,0,-1,0,3,-2,-1,1,2,0,0,1,1,1,6], [0,1,1,0,0,3,-3,3,-1,-2,-2,-1,1,0,-2,-3,-3,6], [-2,0,-1,-1,1,0,0,2,2,0,-3,1,0,-1,-1,2,-1,0,6], [0,1,-1,0,1,2,-1,2,0,-2,-1,3,0,1,2,1,0,1,-1,6], [-2,0,-2,2,0,0,0,2,0,1,-1,0,3,0,-2,-1,0,0,0,0,6], [0,-3,1,3,0,1,1,1,0,-1,-1,1,0,2,1,1,3,-1,0,1,1,6], [0,2,-1,-1,0,1,-3,2,2,-3,-3,2,-2,-1,0,0,-2,2,3,0,0,-1,6], [0,0,-1,1,-2,-2,-1,-1,3,0,-1,0,0,0,-2,-1,0,-2,1,-3,3,0,1,6]], [[[0,0,0,0,0,0,1,0,-1,0,0,0,-1,0,0,0,0,1,0,1,0,0,0,2], [0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,-1,0,-2,0,0,0,0,1,-1], [1,-1,1,2,-1,0,0,0,0,-1,0,0,0,0,-2,1,0,-2,0,0,1,-2,1,-2], [0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,-1,-1], [0,0,0,0,0,0,-1,0,1,1,0,1,2,1,1,-1,0,-1,0,-2,0,0,1,-2], [0,0,1,0,0,1,1,0,-1,-1,0,0,-1,0,0,1,-1,0,0,0,1,-1,-1,1], [0,0,0,0,0,0,0,0,1,0,0,0,1,1,0,1,0,0,-1,-1,0,0,1,-1], [-1,1,0,-1,1,1,0,1,-1,0,0,0,-1,0,1,0,0,1,0,0,-1,0,-2,3], [0,0,0,0,-1,0,0,0,0,1,0,0,1,0,0,-1,-1,-1,0,1,-1,1,1,0], [0,0,0,0,0,0,0,-1,0,-2,1,-1,-2,-1,-1,2,0,1,1,0,2,0,-1,-1], [0,0,0,0,0,0,0,-1,0,-2,1,0,-1,0,0,1,0,1,1,-1,2,0,-1,-1], [0,1,-1,-1,0,0,0,0,0,1,0,0,1,0,1,-1,-1,0,0,0,-1,2,0,1], [-1,0,0,-1,1,1,0,0,-1,-1,0,1,-1,0,1,1,1,2,0,-1,0,-1,-2,2], [0,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,1,0,0,1,-1,1], [1,0,0,0,0,-1,0,0,1,2,-1,0,2,1,0,-1,-1,-1,-1,0,-1,1,2,-1], [1,0,0,0,0,-1,0,0,1,1,0,0,1,0,0,0,-1,0,0,0,0,1,1,-1], [0,0,0,0,0,0,1,0,0,-1,0,0,0,0,-1,2,0,1,-1,0,0,0,0,1], [0,0,1,1,0,1,0,0,-1,-1,0,0,-1,0,0,0,0,-1,1,0,1,-2,-1,0], [0,0,0,0,0,0,0,1,1,1,0,0,1,0,0,0,0,0,-1,0,-1,0,1,0], [0,1,0,-1,0,0,0,0,0,1,0,1,2,1,2,-1,-1,0,0,-1,-1,1,0,1], [-2,1,-1,-2,1,1,0,0,-2,-1,0,0,-2,-1,1,1,1,3,0,0,-1,1,-3,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,-1,1], [0,0,0,0,0,0,0,1,0,1,-1,0,1,0,0,-1,0,-1,-1,0,-1,0,1,0], [-1,0,-1,-1,0,0,0,0,-1,0,0,0,-1,-1,0,0,1,2,0,1,-1,1,-1,2]], [[0,0,0,0,0,0,1,0,-1,0,0,-1,-2,-1,-1,1,0,1,0,2,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,1,-1], [0,-1,0,1,0,0,0,0,0,0,0,0,-1,-1,-1,0,1,0,0,1,0,-1,0,0], [0,0,0,0,0,0,0,1,0,1,-1,1,2,1,1,-1,0,-1,-1,-1,-1,0,1,0], [0,0,0,0,0,0,0,0,1,-1,0,0,1,0,0,1,0,0,-1,-1,0,0,0,-1], [1,0,1,1,0,0,0,1,1,1,0,0,1,1,0,0,0,-1,0,0,0,-1,1,-1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,-1,-1,1,0,0,0,0,0,0,-1,0], [1,0,1,1,-1,0,0,0,1,1,0,1,3,2,1,-1,-1,-2,0,-1,0,-1,2,-2], [0,0,0,0,0,-1,-1,0,1,2,0,0,2,1,1,-2,0,-1,0,0,-1,1,2,-1], [0,0,0,0,0,0,0,0,0,-1,0,0,-1,-1,-1,1,0,0,0,-1,1,0,-1,-1], [0,0,0,0,0,0,1,0,-1,-2,0,-1,-3,-2,-2,2,0,1,0,1,1,0,-2,1], [0,1,0,0,0,0,0,0,0,1,0,0,1,1,1,-1,-1,-1,0,0,-1,1,1,0], [1,0,0,0,0,0,-1,0,1,0,0,0,1,0,0,0,0,-1,0,-1,1,0,0,-2], [0,-1,0,1,-1,-1,0,0,0,0,0,0,0,0,-1,0,0,-1,0,1,0,-1,1,-1], [-1,1,0,-1,1,1,1,0,-1,-1,0,0,-1,0,1,1,0,2,0,0,0,0,-2,3], [-1,1,0,-1,1,1,0,0,-1,-1,0,0,-1,0,1,1,0,1,0,-1,0,0,-2,2], [0,0,0,0,0,0,0,0,-1,0,0,0,-1,-1,0,0,0,0,1,1,0,0,-1,1], [1,-1,1,2,-1,0,0,0,1,0,0,0,1,1,-1,0,0,-2,0,0,1,-2,2,-3], [0,0,0,0,0,0,-1,0,1,1,0,0,2,1,1,-1,0,-1,0,-1,-1,0,1,-1], [1,0,1,1,0,0,0,0,1,0,0,0,1,1,0,0,-1,-2,0,0,1,-1,1,-2], [1,0,0,0,-1,-1,-1,0,1,2,0,1,3,1,1,-2,-1,-2,0,-1,0,1,2,-3], [0,0,0,0,0,0,0,1,0,2,-1,1,2,1,1,-1,0,-1,-1,0,-2,0,1,1], [0,0,0,0,0,0,0,0,0,1,0,0,1,1,1,-1,0,0,0,0,-1,0,1,0], [0,0,-1,-1,0,-1,-1,0,0,2,0,0,1,0,1,-2,0,0,0,0,-1,2,1,0]]]], [ # Q-class [24][26] [[8], [1,8], [1,2,8], [4,2,2,8], [3,3,1,3,8], [4,2,2,4,3,8], [3,2,4,1,2,1,8], [4,2,2,2,0,2,1,8], [4,2,2,2,2,4,1,4,8], [3,4,2,1,1,1,4,1,1,8], [3,3,1,3,2,2,2,2,0,1,8], [3,3,1,2,2,3,2,2,3,1,4,8], [2,4,4,4,3,4,2,4,4,2,3,3,8], [4,2,2,4,2,2,1,4,2,1,3,0,4,8], [3,3,1,2,4,0,2,3,2,1,2,4,3,3,8], [3,1,3,2,2,0,1,3,2,2,1,2,3,3,4,8], [2,2,2,2,3,4,1,0,0,1,3,1,4,4,1,1,8], [3,1,3,3,4,3,1,0,2,2,1,1,3,2,2,4,3,8], [3,1,3,2,1,3,1,2,3,2,2,4,3,0,2,4,1,2,8], [2,4,1,2,2,1,1,2,1,2,3,0,2,4,3,1,2,-1,0,8], [3,1,3,0,2,2,1,3,3,2,2,1,3,2,1,2,2,4,2,-1,8], [3,1,3,3,1,2,1,2,0,2,4,2,3,3,1,2,3,2,4,1,4,8], [3,3,1,0,4,2,2,3,3,1,4,2,3,2,2,1,2,2,1,2,4,2,8], [4,2,3,2,3,2,3,2,2,1,3,3,1,2,3,1,1,1,1,4,1,1,3,8]], [[[1,0,2,-1,0,2,-2,-1,2,2,3,-3,-1,-1,3,1,0,-2,-2,-3,-2,1,0,0], [-1,0,0,0,0,1,-1,0,2,1,2,-2,-1,-1,2,1,1,-1,-1,-2,-1,1,0,1], [-2,1,0,-1,-1,4,-1,-1,5,2,5,-7,-1,-2,5,3,1,-3,-3,-6,-3,3,-1,3], [0,0,1,0,0,2,-1,-1,1,1,2,-2,-1,0,2,1,0,-2,-1,-2,0,0,0,0], [0,0,1,0,0,1,-1,0,1,1,2,-2,-1,-1,2,1,1,-1,-1,-2,-1,0,0,0], [0,0,1,0,0,1,-1,0,1,1,2,-2,-1,0,2,0,0,-1,0,-2,-1,0,0,0], [1,0,1,0,0,0,-1,0,1,1,1,-1,0,-1,1,0,1,-1,-1,-1,-1,0,0,0], [0,0,1,-1,0,2,-1,0,2,1,2,-2,-1,-1,2,1,0,-1,-2,-2,-2,2,0,0], [0,0,1,-1,0,1,-1,0,2,1,2,-2,-1,0,2,0,0,0,-1,-2,-2,1,0,0], [0,0,1,-1,0,2,-2,-1,2,2,3,-3,0,-1,3,1,0,-2,-2,-3,-2,1,0,1], [0,0,1,0,0,1,-1,-1,2,1,2,-2,-1,-1,2,1,1,-2,-1,-2,-1,1,0,0], [0,0,1,0,0,0,-1,0,2,1,2,-2,-1,-1,2,0,1,-1,-1,-2,-1,1,0,0], [1,0,2,-1,0,2,-2,-1,2,1,3,-3,0,-1,3,1,0,-2,-2,-3,-2,1,0,0], [0,0,1,0,0,2,-1,-1,2,1,2,-2,-1,-1,2,2,0,-2,-2,-2,-1,1,0,0], [0,0,1,0,0,1,-1,0,2,1,2,-2,-1,-2,2,1,1,-1,-2,-2,-1,1,0,0], [0,1,1,-2,-1,4,-2,-2,4,2,5,-6,0,-2,5,3,0,-3,-4,-6,-3,3,-1,2], [1,0,2,0,0,1,-2,-1,1,1,2,-2,0,-1,2,1,0,-2,-1,-2,-1,0,0,0], [0,1,1,-2,-1,4,-2,-2,4,2,6,-7,0,-2,5,3,0,-3,-3,-6,-3,2,-1,2], [0,1,1,-2,-1,4,-2,-2,4,2,5,-7,0,-2,6,2,0,-3,-3,-6,-3,3,-1,2], [-2,-1,0,1,1,0,0,1,1,1,0,1,-2,0,0,0,1,0,0,0,0,0,0,0], [0,1,1,-2,-1,4,-2,-2,4,2,5,-7,0,-2,5,3,0,-3,-3,-6,-4,3,0,2], [0,1,1,-2,0,4,-2,-2,4,2,5,-7,0,-2,5,3,0,-4,-3,-6,-3,3,-1,2], [0,0,1,-1,0,1,-1,0,2,1,2,-2,-1,-1,2,1,1,-1,-1,-2,-2,1,0,0], [-3,-1,0,1,0,1,0,1,3,2,2,-2,-3,-1,2,1,2,-1,-1,-2,-1,1,0,1]], [[0,-1,0,2,0,-3,1,1,-3,-1,-4,5,0,1,-3,-2,0,2,2,4,2,-2,2,-2], [0,-1,1,0,1,-1,0,1,0,0,0,2,-1,0,-1,-1,0,1,0,2,0,0,0,-2], [-2,0,-1,1,0,0,1,0,0,0,0,0,-1,1,0,0,0,0,1,0,1,0,0,0], [0,-1,0,1,0,-2,1,1,-3,-1,-3,4,0,1,-2,-2,0,2,2,4,2,-2,1,-2], [-1,-2,0,2,1,-3,1,2,-2,0,-3,5,-1,1,-3,-2,1,2,2,4,2,-2,1,-2], [0,-1,0,2,1,-4,2,2,-4,-2,-5,7,0,2,-5,-3,0,3,3,6,3,-3,1,-3], [-2,-1,0,1,0,0,0,0,0,1,0,1,-1,1,0,0,0,0,0,0,0,0,1,0], [2,0,0,1,0,-3,1,0,-3,-2,-3,4,1,1,-3,-2,-1,2,2,4,2,-2,1,-2], [0,-1,0,2,0,-3,1,1,-2,-1,-3,4,0,1,-3,-2,0,2,2,4,2,-2,1,-2], [0,0,1,-1,0,1,-1,-1,2,1,2,-2,0,-1,2,1,0,-1,-2,-2,-2,2,0,0], [-1,-1,0,2,1,-3,1,2,-2,-1,-3,5,-2,1,-3,-2,1,2,2,4,2,-2,1,-2], [-2,-1,0,2,0,-1,1,1,0,0,-1,2,-2,0,-1,-1,1,1,1,2,1,-1,1,-1], [0,-1,0,1,1,-3,1,1,-2,-1,-2,4,0,1,-3,-2,0,2,2,4,2,-2,0,-2], [2,-1,0,1,1,-4,1,1,-5,-2,-5,7,1,2,-5,-3,-1,3,3,6,3,-3,1,-3], [0,-1,0,1,0,-1,0,0,-1,0,-1,2,0,0,-1,-1,0,1,1,2,1,-1,1,-1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,-1,0,1,1,0,0,0,0,0], [0,-1,0,1,2,-3,1,2,-3,-1,-3,5,0,1,-4,-2,0,2,2,4,2,-2,0,-2], [-2,0,-1,1,0,-1,1,1,0,0,-1,1,-1,0,-1,0,1,1,1,1,1,0,0,0], [-2,0,-1,1,0,-1,1,1,1,0,0,0,-1,0,0,-1,1,1,1,0,0,0,0,0], [3,-1,2,0,1,-2,-1,0,-3,-1,-2,4,1,1,-2,-2,-1,1,1,3,1,-2,1,-3], [-2,0,-2,2,0,-2,2,1,0,-1,-2,2,-1,0,-2,0,1,1,1,2,2,0,0,0], [-2,0,-2,1,0,-1,2,1,0,-1,-1,1,-1,0,-1,0,1,1,1,1,1,0,0,0], [0,-1,0,2,1,-4,1,2,-2,-1,-3,5,-1,1,-4,-2,1,2,2,4,2,-2,1,-2], [0,-1,1,2,0,-1,0,0,-2,0,-2,3,-1,1,-1,-1,0,0,1,2,2,-2,2,-2]]]], [ # Q-class [24][27] [[6], [0,6], [-3,3,6], [-3,3,3,6], [2,0,-1,-1,6], [0,2,1,1,0,6], [-1,1,2,1,-3,3,6], [-1,1,1,2,-3,3,3,6], [0,0,0,0,2,0,-1,-1,6], [0,0,0,0,0,2,1,1,0,6], [0,0,0,0,-1,1,2,1,-3,3,6], [0,0,0,0,-1,1,1,2,-3,3,3,6], [-2,0,1,1,2,0,-1,-1,2,0,-1,-1,6], [0,-2,-1,-1,0,2,1,1,0,2,1,1,0,6], [1,-1,-2,-1,-1,1,2,1,-1,1,2,1,-3,3,6], [1,-1,-1,-2,-1,1,1,2,-1,1,1,2,-3,3,3,6], [2,0,-1,-1,0,0,0,0,2,0,-1,-1,-2,0,1,1,6], [0,2,1,1,0,0,0,0,0,2,1,1,0,-2,-1,-1,0,6], [-1,1,2,1,0,0,0,0,-1,1,2,1,1,-1,-2,-1,-3,3,6], [-1,1,1,2,0,0,0,0,-1,1,1,2,1,-1,-1,-2,-3,3,3,6], [-2,0,1,1,-2,0,1,1,2,0,-1,-1,0,0,0,0,2,0,-1,-1,6], [0,-2,-1,-1,0,-2,-1,-1,0,2,1,1,0,0,0,0,0,2,1,1,0,6], [1,-1,-2,-1,1,-1,-2,-1,-1,1,2,1,0,0,0,0,-1,1,2,1,-3,3,6], [1,-1,-1,-2,1,-1,-1,-2,-1,1,1,2,0,0,0,0,-1,1,1,2,-3,3,3,6]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,-1,0,-1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1], [0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,1,-1], [0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1], [0,0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,-1,0,1,0,1,0,1,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,0,0,-1,1,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,-1,0,-1,0,1,0,-1,0,1,0,0,0,0], [0,0,0,0,1,0,1,0,-1,0,-1,0,0,0,0,0,0,0,0,0,1,0,1,0], [0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,1,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,-1,0,1,0,1,0,-1,0,0,0,0,0,0,0,0,0,-1,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [24][28] [[8], [1,8], [0,-1,8], [-1,-2,0,8], [-2,0,-1,-1,8], [1,2,2,1,-4,8], [1,-1,2,0,1,-2,8], [-2,2,-2,1,-1,2,-4,8], [0,1,-2,0,2,0,-1,1,8], [2,1,1,-1,-1,1,-1,2,2,8], [-2,1,1,-1,1,1,2,2,2,2,8], [-1,1,-1,2,2,-2,2,-1,2,-1,-1,8], [-4,0,0,2,-2,1,-2,1,0,0,0,0,8], [-4,-2,0,1,0,1,-2,4,2,2,2,0,2,8], [-1,1,2,0,-1,0,2,-2,0,0,0,2,2,-1,8], [-2,2,2,-2,0,1,0,0,0,2,2,0,4,0,1,8], [-1,-1,0,1,-1,-1,2,-2,-1,-4,0,1,0,-1,4,-1,8], [2,2,-4,-2,2,-1,-2,1,2,-1,-1,-1,-4,-1,0,-4,2,8], [1,-2,0,1,0,2,-2,0,1,-2,-2,-2,-2,1,-4,-2,-2,0,8], [0,-1,-1,1,0,-4,1,-2,-2,-2,-2,-2,0,-2,0,-2,2,1,-1,8], [0,-2,-1,1,1,-2,0,0,0,0,-4,1,-2,2,1,-4,-1,2,1,2,8], [0,1,2,-2,0,2,1,1,4,4,4,1,0,2,0,4,-2,-2,-1,-4,-2,8], [0,0,-1,0,4,0,-1,0,4,1,1,2,0,2,-2,0,-2,1,1,-4,-1,2,8], [2,2,0,-1,-4,4,-2,0,-1,2,-1,-1,2,-1,2,2,0,0,-2,-2,-1,1,-2,8]], [[[0,-1,1,-1,-1,0,1,1,-1,1,1,2,2,-1,0,0,0,2,2,1,0,0,1,0], [0,0,0,0,0,0,0,1,-1,0,0,0,0,0,1,0,0,0,1,1,0,1,1,0], [1,0,1,0,0,0,0,0,0,0,1,1,1,0,-1,1,0,1,0,0,1,-1,0,0] , [0,0,0,0,0,0,0,0,1,0,0,-1,-1,0,0,0,0,-1,-1,0,0,-1,0,0], [0,1,-1,1,0,-1,0,-1,0,-1,-1,-2,-1,1,0,0,0,-1,-1,-1,0,1,0,0], [0,0,1,-1,0,0,0,1,0,1,1,1,1,-1,-1,0,1,0,1,0,1,-1,0,0], [0,0,0,1,-1,-1,0,0,0,-1,0,0,-2,1,1,1,-1,0,0,1,-1,0,1,1], [0,0,0,-1,1,1,0,1,0,1,0,0,1,-1,-1,-1,2,-1,0,0,1,0,0,0], [-1,0,1,-1,0,0,1,1,-1,1,1,1,2,-2,-1,-1,1,1,2,1,1,1,1,1], [0,-1,1,-1,0,0,1,2,0,0,0,1,1,-1,0,0,0,1,1,1,0,0,1,1], [0,0,0,0,0,0,0,1,0,-1,0,0,-1,0,0,0,0,-1,0,1,0,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0], [0,0,0,0,0,0,-1,0,0,0,1,0,0,-1,0,0,0,0,0,0,1,0,0,0] , [0,1,0,0,1,0,0,0,1,0,-1,-1,0,0,-1,-1,1,-1,-1,-1,0,0,-1,0], [-1,-1,1,0,-1,0,1,1,-1,1,1,2,1,-1,0,1,-1,3,2,2,0,0,1,1], [1,0,0,0,0,0,-1,0,0,-1,1,0,0,0,0,1,0,0,0,0,1,0,0,0], [0,0,0,1,0,0,0,-1,0,0,0,0,0,1,0,0,-1,1,0,0,-1,0,-1,0], [-1,0,0,0,0,0,1,0,-1,1,-1,0,1,0,0,-1,0,1,1,0,-1,1,0,0], [0,1,0,0,0,0,0,-1,1,0,0,-1,0,0,-1,0,1,-1,-1,-2,1,-1,-1,-1], [0,0,-1,1,0,0,0,-1,0,-1,-1,-1,-2,2,2,0,-2,0,-1,0,-2,0,0,0], [-1,0,0,0,0,0,1,0,0,1,-1,0,0,0,0,0,0,1,0,0,-1,0,0,0], [0,0,1,-1,0,0,0,1,0,0,1,1,1,-1,-1,0,1,0,1,1,1,0,1,1], [0,1,0,0,0,-1,0,0,0,0,0,-1,1,-1,-1,-1,1,-1,0,-1,1,1,0,0], [0,-1,1,-1,0,0,0,1,-1,1,1,2,2,-1,0,0,0,2,2,1,0,0,0,0]], [[-1,-1,1,-1,-1,0,1,1,-1,1,1,2,1,-1,0,0,0,2,2,2,0,0,2,1], [-1,0,1,0,-1,-1,1,1,-1,1,0,1,1,-1,0,0,0,2,2,1,0,1,1,1], [1,0,0,0,1,0,0,0,-1,0,0,0,1,0,0,-1,0,0,0,0,0,1,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,-1,0,0,-1,0], [0,0,-1,1,0,0,0,0,1,-2,-2,-2,-3,2,2,1,-2,-1,-2,0,-2,0,0,0], [0,0,1,0,0,0,0,0,-1,1,1,1,2,-1,-1,-1,1,1,1,0,1,1,0,0], [0,0,0,0,0,0,0,0,0,-1,-1,0,-1,1,0,0,-1,0,-1,0,-1,0,0,0], [0,1,0,1,0,-1,0,-1,0,0,0,-1,0,1,0,0,0,0,0,-1,0,0,-1,0], [-1,0,0,0,0,0,0,0,1,0,-1,-1,-1,0,0,0,0,-1,-1,0,0,0,0,0], [0,1,0,1,0,-1,0,-1,1,-1,-1,-2,-1,1,0,0,0,-1,-1,-1,0,0,0,0], [0,1,0,1,0,-1,0,-1,1,-1,-1,-2,-1,1,-1,0,0,-1,-2,-2,0,0,-1,0], [-1,0,0,0,0,0,0,0,0,0,-1,0,-1,0,1,0,-1,0,0,0,-1,0,0,0], [1,1,0,0,1,0,-1,-1,1,0,0,-1,1,0,-1,-1,1,-1,-1,-2,1,0,-2,-1], [1,1,-1,1,1,0,-1,-2,1,-1,-1,-2,-1,2,0,0,0,-2,-2,-2,0,0,-2,-1], [0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,-1,0,0,0,0,-1,1,-1,0], [1,1,0,1,0,-1,-1,-1,1,-1,-1,-2,-1,1,0,0,0,-1,-2,-2,0,0,-1,-1], [0,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,1,0,0,-1,0,-1,0], [-1,-1,0,0,-1,0,1,1,0,0,0,1,-1,0,1,1,-1,1,1,2,-1,0,1,1], [0,-1,0,-1,0,1,0,1,-1,1,1,1,1,-1,0,0,1,0,1,1,1,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,1,1,0,0,0,0,-1,0,-1,1,1,0,0,-1,0,1,-1,0,0,0], [0,1,0,1,0,-1,-1,-1,1,-1,-1,-2,-2,1,0,0,0,-2,-2,-1,0,0,0,0], [0,0,0,0,0,0,0,0,1,-1,-1,-1,-1,1,1,0,-1,-1,-1,0,-1,0,0,0], [0,0,1,0,0,0,0,0,0,1,1,1,1,-1,-1,0,1,1,1,0,1,0,0,0]]]], [ # Q-class [24][29] [[6], [2,6], [2,2,6], [-2,2,0,6], [-2,0,2,2,6], [0,-2,2,-2,2,6], [3,1,1,-1,-1,0,6], [1,3,1,1,0,-1,2,6], [1,1,3,0,1,1,2,2,6], [-1,1,0,3,1,-1,-2,2,0,6], [-1,0,1,1,3,1,-2,0,2,2,6], [0,-1,1,-1,1,3,0,-2,2,-2,2,6], [0,0,0,0,0,0,0,0,0,0,0,0,6], [0,0,0,0,0,0,0,0,0,0,0,0,2,6], [0,0,0,0,0,0,0,0,0,0,0,0,2,2,6], [0,0,0,0,0,0,0,0,0,0,0,0,-2,2,0,6], [0,0,0,0,0,0,0,0,0,0,0,0,-2,0,2,2,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,-2,2,-2,2,6], [0,0,0,0,0,0,0,0,0,0,0,0,3,1,1,-1,-1,0,6], [0,0,0,0,0,0,0,0,0,0,0,0,1,3,1,1,0,-1,2,6], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,3,0,1,1,2,2,6], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,3,1,-1,-2,2,0,6], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,1,3,1,-2,0,2,2,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,1,3,0,-2,2,-2,2,6]], [[[0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,0,0,1,0,-1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,-1,1,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,-1,0,1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[1,-1,0,1,0,0,-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,-1,1,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,0,0,1,0,-1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [24][30] [[8], [1,8], [2,0,8], [4,-1,-1,8], [0,2,2,-2,8], [3,-1,4,0,4,8], [-4,-3,-3,-3,-3,-4,8], [-3,3,2,-1,2,-2,-1,8], [-2,-2,3,-4,4,2,1,1,8], [-2,1,-4,-2,-2,-4,2,1,-2,8], [-3,-4,-4,1,0,-1,3,-1,1,2,8], [2,4,0,-2,4,1,-3,0,2,2,-2,8], [0,0,0,0,0,0,0,0,0,0,0,0,8], [0,0,0,0,0,0,0,0,0,0,0,0,1,8], [0,0,0,0,0,0,0,0,0,0,0,0,2,0,8], [0,0,0,0,0,0,0,0,0,0,0,0,4,-1,-1,8], [0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,-2,8], [0,0,0,0,0,0,0,0,0,0,0,0,3,-1,4,0,4,8], [0,0,0,0,0,0,0,0,0,0,0,0,-4,-3,-3,-3,-3,-4,8], [0,0,0,0,0,0,0,0,0,0,0,0,-3,3,2,-1,2,-2,-1,8], [0,0,0,0,0,0,0,0,0,0,0,0,-2,-2,3,-4,4,2,1,1,8], [0,0,0,0,0,0,0,0,0,0,0,0,-2,1,-4,-2,-2,-4,2,1,-2,8], [0,0,0,0,0,0,0,0,0,0,0,0,-3,-4,-4,1,0,-1,3,-1,1,2,8], [0,0,0,0,0,0,0,0,0,0,0,0,2,4,0,-2,4,1,-3,0,2,2,-2,8]], [[[0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,-1,-1,1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,1,-1,-1,-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,1,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,1,1,1,0,1,-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,-1,0,-1,-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,1,0,1,1,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,-1,0,0,-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,-1,0,1,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,1,0,0,1,1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,-1,-1,-1,0,0,1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,-1,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,1,0,0,-1,1,1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,1,1,0,1,-1,1,1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,-1,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,1,0,1,0,-1,1,1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,-1,0,0,1,-1,-1,1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,1,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,1,-1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,-1,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,2,0,1,1,-1,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [24][31] [[8], [-2,8], [4,-2,8], [-2,4,-2,8], [-4,4,-2,2,8], [-2,2,2,0,2,8], [2,0,2,-2,0,2,8], [0,-2,-2,2,-2,-2,2,8], [0,0,2,4,0,2,-2,2,8], [-2,2,2,4,2,2,2,2,4,8], [-2,-2,0,-2,0,2,2,2,2,2,8], [2,0,2,2,-2,2,2,0,2,4,2,8], [4,-1,2,-1,-2,-1,1,0,0,-1,-1,1,8], [-1,4,-1,2,2,1,0,-1,0,1,-1,0,-2,8], [2,-1,4,-1,-1,1,1,-1,1,1,0,1,4,-2,8], [-1,2,-1,4,1,0,-1,1,2,2,-1,1,-2,4,-2,8], [-2,2,-1,1,4,1,0,-1,0,1,0,-1,-4,4,-2,2,8], [-1,1,1,0,1,4,1,-1,1,1,1,1,-2,2,2,0,2,8], [1,0,1,-1,0,1,4,1,-1,1,1,1,2,0,2,-2,0,2,8], [0,-1,-1,1,-1,-1,1,4,1,1,1,0,0,-2,-2,2,-2,-2,2,8], [0,0,1,2,0,1,-1,1,4,2,1,1,0,0,2,4,0,2,-2,2,8], [-1,1,1,2,1,1,1,1,2,4,1,2,-2,2,2,4,2,2,2,2,4,8], [-1,-1,0,-1,0,1,1,1,1,1,4,1,-2,-2,0,-2,0,2,2,2,2,2,8], [1,0,1,1,-1,1,1,0,1,2,1,4,2,0,2,2,-2,2,2,0,2,4,2,8]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,-1,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-2,1,1,-1,0,-1,1,1,1,-2,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-1,2,-1,1,0,-1,-1,1,1,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,1,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-2,0,1,0,0,-1,1,0,1,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,1,-1,1,0,2,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-2,1,1,-1,0,-1,1,1,2,-2,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,0,1,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,-1,0,0,0,1,1,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,1,0,0,1,0,0,-1,1,0,0,0,1,-1,0,0,-1,0,0,1,-1], [2,-1,-1,1,0,1,-1,-1,-1,2,1,-2,-2,1,1,-1,0,-1,1,1,1,-2,-1,2], [0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,1,-1,0,0], [-1,1,1,-2,1,-1,0,1,1,-1,-1,2,1,-1,-1,2,-1,1,0,-1,-1,1,1,-2], [0,0,0,-1,1,0,-1,1,0,0,0,1,0,0,0,1,-1,0,1,-1,0,0,0,-1], [2,0,-1,0,0,1,-1,0,-1,1,1,-1,-2,0,1,0,0,-1,1,0,1,-1,-1,1], [1,0,0,1,-1,1,-1,0,-2,1,1,-1,-1,0,0,-1,1,-1,1,0,2,-1,-1,1], [0,0,0,0,0,0,-1,0,-1,1,0,0,0,0,0,0,0,0,1,0,1,-1,0,0], [2,-1,-1,1,0,1,-1,-1,-2,2,1,-1,-2,1,1,-1,0,-1,1,1,2,-2,-1,1], [1,0,0,1,0,0,-1,0,-1,0,1,0,-1,0,0,-1,0,0,1,0,1,0,-1,0], [1,-1,-1,1,0,0,0,-1,-1,1,1,-1,-1,1,1,-1,0,0,0,1,1,-1,-1,1]], [[0,0,0,1,-1,0,1,-1,0,0,0,-1,0,0,0,-1,1,0,-1,1,0,0,0,1], [-1,1,0,-1,0,-1,0,0,1,-1,0,1,1,-1,0,1,0,1,0,0,-1,1,0,-1], [2,0,-1,1,-1,1,0,-1,-1,2,1,-2,-2,0,1,-1,1,-1,0,1,1,-2,-1,2], [-1,1,1,-1,0,0,-1,1,0,-1,0,1,1,-1,-1,1,0,0,1,-1,0,1,0,-1], [-1,1,1,-1,1,-1,0,1,1,-2,0,2,1,-1,-1,1,-1,1,0,-1,-1,2,0,-2], [2,0,-1,1,0,1,-1,0,-1,1,1,-1,-2,0,1,-1,0,-1,1,0,1,-1,-1,1], [1,0,0,1,0,0,0,0,-1,0,1,-1,-1,0,0,-1,0,0,0,0,1,0,-1,1], [0,0,1,0,0,0,-1,1,-1,0,0,0,0,0,-1,0,0,0,1,-1,1,0,0,0], [1,0,0,1,-1,1,-1,0,-1,1,1,-1,-1,0,0,-1,1,-1,1,0,1,-1,-1,1], [0,1,1,0,0,0,-1,1,-1,0,1,0,0,-1,-1,0,0,0,1,-1,1,0,-1,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [-1,1,1,0,0,0,0,1,0,-1,0,0,1,-1,-1,0,0,0,0,-1,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,1,0,1,0,0,-1,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-2,0,1,-1,1,-1,0,1,1,-2,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-1,1,0,0,1,-1,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-1,1,-1,1,0,-1,-1,2,0,-2], [0,0,0,0,0,0,0,0,0,0,0,0,-2,0,1,-1,0,-1,1,0,1,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,0,0,0,1,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,-1,1,0,0,0] , [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,1,-1,1,0,1,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,1,-1,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-1,0,0,0,0,-1,0,1,0,0]]]], [ # Q-class [24][32] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [0,0,0,0,0,0,2], [0,0,0,0,0,0,1,2], [0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [24][33] [[4], [1,4], [2,2,4], [1,2,2,4], [2,1,1,2,4], [1,2,1,1,1,4], [1,1,1,0,1,2,4], [0,-1,-1,0,-1,0,-1,4], [1,0,1,1,0,0,0,1,4], [-1,0,-1,-1,-2,-1,-1,1,1,4], [0,0,0,0,-1,-1,-1,2,1,2,4], [0,0,0,-1,1,1,2,-2,-2,-2,-2,4], [-1,0,-1,1,0,-1,-2,2,0,1,2,-2,4], [-1,-1,0,1,0,-1,-2,1,0,-1,0,-1,2,4], [1,1,2,1,1,1,1,-1,1,-2,-1,1,-1,1,4], [1,1,1,2,1,1,0,1,2,-1,1,-1,1,1,2,4], [1,1,1,1,2,1,2,-1,0,-2,0,1,0,0,2,2,4], [1,1,1,1,1,2,2,0,2,-1,-1,0,-1,-1,2,2,2,4], [-1,0,0,1,0,1,1,1,0,0,0,0,1,1,0,0,0,0,4], [0,-2,-1,0,1,-1,0,1,1,0,0,0,1,1,0,0,0,0,2,4], [-2,-1,-2,-1,-1,0,0,1,0,1,0,0,1,1,0,0,0,0,2,2,4], [-1,-2,-1,-1,-1,0,0,2,0,0,1,0,1,1,0,0,0,0,2,2,2,4], [-2,-1,-1,1,0,-1,-1,1,0,0,0,-1,2,2,0,0,0,0,2,2,2,2,4], [-1,-1,-2,0,1,1,0,1,-1,-1,-1,1,1,1,0,0,0,0,2,2,2,2,2,4]], [[[1,0,1,-1,-1,0,0,0,0,0,0,1,0,0,-1,1,0,0,0,0,0,-1,1,1], [0,1,1,-1,0,-1,0,0,-1,1,0,0,-1,1,-1,1,0,1,0,0,0,0,0,1], [1,0,1,-1,-1,0,1,-1,-1,0,1,0,0,1,-1,1,-1,1,0,0,0,-1,1,1], [0,-1,1,-1,0,1,0,0,-1,1,0,0,0,0,0,1,0,0,0,0,0,-1,1,0], [1,-1,0,-1,0,0,0,0,0,1,0,1,0,0,0,1,0,0,1,-1,0,-1,1,0], [0,0,0,-1,1,-1,0,0,-1,0,0,0,0,0,0,1,-1,1,1,-1,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,-1,1], [-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,1,-1,0], [-1,1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,2,-1,0,0,0], [1,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0], [-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,-1], [0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1], [1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,-1,1,0], [0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0], [0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0], [-1,-1,0,1,0,0,0,0,-1,0,0,-1,0,-1,1,0,0,0,0,0,0,0,-1,0], [0,-1,-1,1,0,1,0,0,0,0,0,0,0,-1,1,0,0,-1,0,0,0,0,0,-1], [-1,0,-1,1,1,0,0,0,0,0,-1,-1,0,-1,1,0,0,-1,0,0,0,1,-1,-1], [-1,0,-1,0,0,1,0,0,0,-1,0,-1,0,-1,1,0,0,-1,0,1,-1,0,0,-1], [-1,-1,0,0,1,1,0,0,0,0,0,-1,0,-1,1,0,0,-1,0,0,0,0,0,-1], [0,-1,-1,0,1,0,-1,0,0,0,0,0,0,-1,1,0,0,0,1,-1,0,0,0,-1]], [[0,-1,0,0,1,0,-1,1,0,1,-1,1,0,0,0,0,1,0,1,-1,0,0,0,-1], [1,-1,0,0,0,0,-1,0,0,-1,1,0,0,0,0,-1,0,1,1,-1,1,-1,0,0], [0,-1,0,0,1,0,-1,0,0,-1,0,0,0,-1,0,0,0,0,1,-1,1,0,0,-1], [0,0,0,0,1,-1,-1,0,0,-1,1,0,0,0,0,-1,0,1,1,-1,1,0,-1,0], [0,0,-1,0,1,0,-1,1,1,0,0,1,0,0,0,-1,1,0,1,-1,0,0,0,-1], [1,0,-1,0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,-1], [1,0,-1,0,0,1,-1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,1,-2], [0,1,1,-1,0,-1,0,0,-1,1,0,0,-1,1,-1,1,0,1,0,1,-1,0,0,1], [-1,0,1,0,0,-1,-1,1,0,0,-1,0,0,-1,0,0,1,0,1,0,0,0,-1,0], [0,0,2,0,-2,0,0,0,0,0,0,0,0,0,-1,0,1,0,-1,1,0,-1,0,2], [0,0,2,-2,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,-1,1,1], [0,0,-2,0,0,2,0,0,0,0,0,0,0,0,1,0,0,-1,0,1,-1,0,1,-2], [0,1,1,-1,0,-1,0,0,0,0,1,0,-1,1,-1,0,0,1,0,0,0,-1,0,2], [-1,1,0,0,1,-1,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,1,-1,1], [0,-1,-1,0,1,0,-1,0,0,0,0,0,0,-1,1,0,0,0,2,-1,0,0,0,-1], [0,0,0,-1,1,-1,-1,0,0,0,0,0,0,0,0,0,0,1,2,-1,0,0,-1,0], [1,0,-1,-1,1,0,-1,0,1,0,0,1,0,0,0,0,0,0,2,-2,0,0,1,-1], [1,0,-1,0,0,-1,-1,0,0,0,0,1,0,0,0,0,0,1,2,-1,0,0,0,-1], [0,1,0,0,0,0,-1,0,-1,0,1,0,-1,0,0,0,0,1,0,1,0,0,0,0], [-1,1,0,0,0,0,-1,1,0,1,0,1,-1,0,0,0,1,0,0,1,-1,0,0,0], [0,1,0,0,-1,0,-1,0,0,1,0,0,-1,0,0,0,1,0,0,1,-1,0,0,1], [0,1,0,-1,0,0,0,0,-1,1,0,0,-1,0,0,1,0,0,0,1,-1,0,1,0], [0,1,0,0,0,-1,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,1,-1,0,0,0,0,0,-1,1,1,0,-1,1,0,0,0,1,0,1,-1,0,0,0]]]], [ # Q-class [24][34] [[4], [0,4], [2,-2,4], [2,1,1,4], [1,-1,1,2,4], [0,-1,2,1,2,4], [0,0,0,0,0,0,4], [0,0,0,0,0,0,0,4], [0,0,0,0,0,0,2,-2,4], [0,0,0,0,0,0,2,1,1,4], [0,0,0,0,0,0,1,-1,1,2,4], [0,0,0,0,0,0,0,-1,2,1,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,2,-2,4], [0,0,0,0,0,0,0,0,0,0,0,0,2,1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2,1,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2,1,2,4]], [[[0,0,0,0,0,0,-1,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [24][35] [[8], [1,8], [1,4,8], [-3,0,-2,8], [0,0,-1,-2,8], [0,2,2,0,0,8], [2,0,2,-4,0,-2,8], [4,0,0,-3,-2,2,0,8], [1,-1,0,-1,0,-2,1,2,8], [0,0,0,-3,4,-1,0,-1,0,8], [0,0,1,1,1,0,-1,-2,0,1,8], [-1,0,0,0,1,-2,0,-3,-2,2,2,8], [2,-2,-2,-3,2,-1,2,1,0,-1,0,0,8], [-2,0,0,1,-1,2,-3,0,0,-2,0,-4,0,8], [-2,0,-1,2,3,-2,-1,-4,-2,2,0,4,-2,-4,8], [1,-2,2,-2,0,-2,2,-1,-1,1,2,4,2,-2,1,8], [2,2,2,-2,3,-1,1,-1,2,0,2,0,4,0,0,2,8], [-1,-4,0,-3,-2,0,2,1,-1,-1,-2,0,2,2,-3,4,-2,8], [2,-2,-2,-1,-2,0,-2,4,0,0,-2,-1,-1,0,0,-1,-3,1,8], [2,0,1,-1,-2,4,-3,4,0,-1,2,-3,-1,4,-4,-1,-1,1,4,8], [4,0,0,-4,-1,-2,4,4,3,-1,-2,-3,2,0,-4,-1,1,1,0,0,8], [-2,2,-2,4,-1,0,-4,-1,-3,0,2,0,-2,2,1,-4,-2,-4,1,1,-2,8], [0,2,2,0,-3,3,1,3,0,-1,-4,-4,-4,0,-2,-4,-4,0,1,1,2,0,8], [-3,-3,-3,4,0,2,-4,0,2,-2,-1,-2,-2,2,0,-2,-2,0,1,1,-2,0,1,8]], [[[0,-1,0,-1,0,0,0,0,0,0,0,1,0,1,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,1,1,1,2,0,0,-1,-2,1,-1,0,-2,1,0], [0,0,0,0,0,0,0,-1,0,0,0,1,1,1,0,1,0,-1,1,0,0,0,2,0], [1,1,1,2,0,-1,1,1,0,1,1,0,1,0,2,-2,0,3,-1,1,0,0,0,1], [-1,-1,-1,0,0,1,0,0,0,0,0,0,0,1,-1,2,0,-3,1,-1,0,-1,1,-1], [0,-1,0,-1,1,0,0,-1,0,-1,-1,0,-1,-1,-2,1,0,-1,0,0,-1,1,0,0], [0,0,-1,0,0,0,-1,0,0,0,1,1,0,1,0,0,1,0,1,-1,0,-1,2,-1], [0,0,1,-1,0,0,0,0,0,0,0,0,0,-1,0,-1,0,1,0,0,0,1,-1,1], [0,0,0,-1,1,1,-1,-1,2,-1,-1,-1,0,-1,0,2,-1,0,0,0,0,2,0,-1], [-1,-1,-1,-1,0,1,0,0,0,-1,-1,0,-1,0,-1,2,0,-3,0,0,0,0,0,-1], [1,0,0,-1,-1,-1,1,1,0,0,0,0,0,1,1,-1,0,0,-1,0,-2,0,0,1], [-1,-1,-1,0,0,1,0,0,0,-1,0,0,-1,1,-1,1,0,-2,1,-1,0,-1,0,-2], [0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,-1,-1,0], [1,1,1,1,0,-1,1,0,0,1,-1,0,1,-1,1,-1,0,2,-1,2,0,1,-1,2], [-1,0,-1,1,0,1,0,0,0,0,1,0,0,1,0,1,0,-1,1,-1,1,-1,1,-1], [0,0,0,1,-1,0,1,1,0,1,0,1,0,1,1,-1,1,1,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,1,0,0,1,1,1,0,-1,-1,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,-1,-1,-1,0,1,1,0,0,0,1,-1,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,1,0,0,1,1,-1,1], [1,0,1,-1,0,-1,1,0,0,0,-1,0,0,-1,0,-1,0,1,-1,1,-1,2,-1,2], [0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,1,1,-1,-1,1,1,-1,1,1,0,1,0,2,-3,0,2,-1,1,0,-1,-1,2], [0,0,0,-1,1,0,-1,-1,0,-1,0,0,0,-1,-1,1,0,0,0,0,0,1,1,0], [0,0,1,1,1,0,0,0,1,0,-1,-1,0,-2,0,0,0,2,-1,1,0,2,-1,0]], [[0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,1,0,1,-1,0,0,1,0], [0,0,0,1,0,0,0,1,0,0,0,1,0,0,0,-1,1,1,0,0,0,0,0,0], [0,1,0,1,0,-1,0,1,0,0,1,1,1,1,1,-1,0,1,0,0,0,-1,1,0], [0,0,0,-1,1,1,0,-1,1,-1,-2,-1,-1,-2,-1,1,-1,0,-1,1,0,2,-2,0], [-1,-1,0,0,0,0,0,1,-1,0,0,0,-1,1,-1,0,0,-2,1,-1,0,-2,-1,-1], [0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,1,0,0,-1,1,0,1,0,0], [0,1,0,2,0,0,0,0,0,1,2,1,1,1,1,-1,1,2,2,-1,1,-1,2,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,0], [-1,-1,-1,0,1,1,0,0,0,-1,0,0,-1,1,-1,2,0,-2,1,-1,0,0,1,-2], [-1,-1,0,0,0,-1,0,1,-2,0,1,1,0,2,-1,0,0,-3,1,-1,0,-3,1,0], [0,0,0,0,0,0,0,1,0,0,1,0,0,1,1,-1,0,0,0,-1,0,-1,0,0], [1,1,1,1,-2,-1,1,2,-2,2,2,1,1,2,2,-4,0,1,0,-1,0,-3,-1,2], [0,0,0,0,-1,0,0,0,0,1,0,0,0,0,1,-1,1,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,-1,-1,0,-2,1,0,0,2,-2,2,0,2,-1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,1,-1,0,-1,-2,1,-1,0,-2,-1,0], [1,1,0,0,-1,-1,0,1,-1,1,2,1,1,2,2,-2,0,1,0,-1,0,-2,1,1], [-1,-1,-1,-1,0,1,-1,0,0,-1,0,0,-1,1,-1,1,0,-2,1,-2,0,-1,0,-2], [1,1,0,0,-1,-1,0,0,0,1,1,0,1,0,2,-1,0,2,-1,1,0,0,1,1], [0,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,1,0,-1,0,1,0,0,1,0], [0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,1,0,0,-1,1,0,1,1,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,1,1,-1,0,1,1,0], [0,0,1,0,0,0,0,0,0,0,-1,-1,0,-2,0,-1,0,1,-1,1,0,1,-2,1], [0,0,0,0,1,0,0,-1,1,-1,-1,0,0,-1,-1,2,0,0,0,1,0,2,1,0], [0,-1,0,-1,1,1,0,-1,1,-1,-2,-1,-1,-1,-1,2,-1,-1,-1,1,0,2,-1,-1]]]], [ # Q-class [24][36] [[4], [-1,4], [-2,1,4], [0,-2,1,4], [1,2,0,-2,4], [0,-1,0,-1,0,4], [1,-1,1,2,0,-1,4], [0,0,1,0,0,1,0,4], [-1,1,0,-1,0,0,1,-1,4], [2,0,0,0,2,0,1,0,0,4], [-1,0,2,2,-1,0,2,0,1,1,4], [1,0,-1,-1,1,1,1,1,2,2,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,-2,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,-2,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,1,2,0,-2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,2,0,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,0,0,1,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,2,0,1,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,2,2,-1,0,2,0,1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,-1,1,1,1,1,2,2,1,4]], [[[-1,0,-2,-1,0,0,1,1,0,1,1,-2,0,0,0,0,0,0,0,0,0,0,0,0], [1,-2,1,0,2,-1,-2,0,1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,1,1,0,0,-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,-1,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-2,0,0,2,-1,-2,1,1,-1,2,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,1,0,-1,0,1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,-1,0,1,0,0,1,1,0,1,-2,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,-1,0,1,0,0,1,1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,2,0,0,-2,1,2,-1,-1,1,-2,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,1,0,-1,1,1,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,-1,1,-1,1,1,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,0,0,1,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,-1,1,1,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,1,0,-1,0,1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,-1,0,-1,1,1,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,-1,-1,1,0,0,1,1,0,1,-2,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,-1,0,-1,1,1,0,0,2,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [24][37] [[4], [0,4], [-2,2,4], [-2,2,2,4], [2,0,-1,-1,4], [0,2,1,1,0,4], [-1,1,2,1,-2,2,4], [-1,1,1,2,-2,2,2,4], [2,0,-1,-1,2,0,-1,-1,4], [0,2,1,1,0,2,1,1,0,4], [-1,1,2,1,-1,1,2,1,-2,2,4], [-1,1,1,2,-1,1,1,2,-2,2,2,4], [2,0,-1,-1,2,0,-1,-1,2,0,-1,-1,4], [0,2,1,1,0,2,1,1,0,2,1,1,0,4], [-1,1,2,1,-1,1,2,1,-1,1,2,1,-2,2,4], [-1,1,1,2,-1,1,1,2,-1,1,1,2,-2,2,2,4], [2,0,-1,-1,2,0,-1,-1,2,0,-1,-1,2,0,-1,-1,4], [0,2,1,1,0,2,1,1,0,2,1,1,0,2,1,1,0,4], [-1,1,2,1,-1,1,2,1,-1,1,2,1,-1,1,2,1,-2,2,4], [-1,1,1,2,-1,1,1,2,-1,1,1,2,-1,1,1,2,-2,2,2,4], [2,0,-1,-1,2,0,-1,-1,2,0,-1,-1,2,0,-1,-1,2,0,-1,-1,4], [0,2,1,1,0,2,1,1,0,2,1,1,0,2,1,1,0,2,1,1,0,4], [-1,1,2,1,-1,1,2,1,-1,1,2,1,-1,1,2,1,-1,1,2,1,-2,2,4], [-1,1,1,2,-1,1,1,2,-1,1,1,2,-1,1,1,2,-1,1,1,2,-2,2,2,4]], [[[0,0,0,0,-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,-1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,0,-1,1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,1,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,-1,1,1,-1,1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,-1,1,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,0,-1,0,0,0,0,1,-1,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,1,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,-1,1,1,0,0,0,0,-1,1,-1,-1,0,0,0,0,0,0,0,0], [0,0,0,0,1,-1,1,0,0,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,0,-1,0,0,0,0,0,0,0,0,1,-1,0,1,0,0,0,0], [0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0], [0,0,0,0,1,-1,1,1,0,0,0,0,0,0,0,0,-1,1,-1,-1,0,0,0,0], [0,0,0,0,1,-1,1,0,0,0,0,0,0,0,0,0,-1,1,-1,0,0,0,0,0], [0,0,0,0,-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,1], [0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0], [0,0,0,0,1,-1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,-1], [0,0,0,0,1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,0], [1,-1,0,1,-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,-1,-1,1,-1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,-1,0,1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0]]]], [ # Q-class [24][38] [[8], [-2,8], [-4,4,8], [4,-2,-1,8], [-2,-3,1,-2,8], [-3,4,3,0,1,8], [1,3,3,3,-4,2,8], [3,-4,-3,0,0,-4,-3,8], [4,-1,0,0,0,-1,1,4,8], [-4,2,1,0,0,2,1,-2,-4,8], [4,-1,-4,4,-2,-1,-1,0,0,0,8], [4,-1,-4,3,-1,-2,-2,3,0,-1,4,8], [0,0,0,0,0,0,0,0,0,0,0,0,8], [0,0,0,0,0,0,0,0,0,0,0,0,-2,8], [0,0,0,0,0,0,0,0,0,0,0,0,-4,4,8], [0,0,0,0,0,0,0,0,0,0,0,0,4,-2,-1,8], [0,0,0,0,0,0,0,0,0,0,0,0,-2,-3,1,-2,8], [0,0,0,0,0,0,0,0,0,0,0,0,-3,4,3,0,1,8], [0,0,0,0,0,0,0,0,0,0,0,0,1,3,3,3,-4,2,8], [0,0,0,0,0,0,0,0,0,0,0,0,3,-4,-3,0,0,-4,-3,8], [0,0,0,0,0,0,0,0,0,0,0,0,4,-1,0,0,0,-1,1,4,8], [0,0,0,0,0,0,0,0,0,0,0,0,-4,2,1,0,0,2,1,-2,-4,8], [0,0,0,0,0,0,0,0,0,0,0,0,4,-1,-4,4,-2,-1,-1,0,0,0,8], [0,0,0,0,0,0,0,0,0,0,0,0,4,-1,-4,3,-1,-2,-2,3,0,-1,4,8]], [[[0,-1,1,0,-1,0,-1,-1,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,1,-1,-1,1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,-1,0,1,0,2,2,-1,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,2,-2,2,2,-1,1,1,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,1,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,1,1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,-1,0,-1,-2,2,1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,-2,1,-1,-1,0,0,-1,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,0,1,0,1,1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,-2,2,-1,-1,1,-1,-1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,-2,1,0,-2,1,-2,-2,1,1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,-2,1,-1,-1,0,0,-1,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,1,0,0,-1,-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,-1,0,-1,-1,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,2,-1,2,1,-1,0,1,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [-2,3,-2,2,2,-1,1,1,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,-1,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,-1,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,-1,0,-1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,0,1,0,1,1,-1,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,1,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,1,-1,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [24][39] [[8], [0,8], [-4,4,8], [-4,4,4,8], [0,0,0,0,8], [0,0,0,0,0,8], [0,0,0,0,-4,4,8], [0,0,0,0,-4,4,4,8], [4,0,-2,-2,-4,0,2,2,8], [0,4,2,2,0,-4,-2,-2,0,8], [-2,2,4,2,2,-2,-4,-2,-4,4,8], [-2,2,2,4,2,-2,-2,-4,-4,4,4,8], [4,0,-2,-2,2,0,-1,-1,2,0,-1,-1,8], [0,4,2,2,0,2,1,1,0,2,1,1,0,8], [-2,2,4,2,-1,1,2,1,-1,1,2,1,-4,4,8], [-2,2,2,4,-1,1,1,2,-1,1,1,2,-4,4,4,8], [2,0,-1,-1,-2,0,1,1,2,0,-1,-1,4,0,-2,-2,8], [0,2,1,1,0,-2,-1,-1,0,2,1,1,0,4,2,2,0,8], [-1,1,2,1,1,-1,-2,-1,-1,1,2,1,-2,2,4,2,-4,4,8], [-1,1,1,2,1,-1,-1,-2,-1,1,1,2,-2,2,2,4,-4,4,4,8], [0,0,0,0,-2,0,1,1,4,0,-2,-2,2,0,-1,-1,4,0,-2,-2,8], [0,0,0,0,0,-2,-1,-1,0,4,2,2,0,2,1,1,0,4,2,2,0,8], [0,0,0,0,1,-1,-2,-1,-2,2,4,2,-1,1,2,1,-2,2,4,2,-4,4,8], [0,0,0,0,1,-1,-1,-2,-2,2,2,4,-1,1,1,2,-2,2,2,4,-4,4,4,8]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,0], [0,0,0,0,0,0,0,-1,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,-1,0,0,1,-1,0,0,-1,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,-1,1,0,0,1,-1,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,-1,0,-1,1,-1,0,1,-1,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,0,1,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0,1,-1,1,0], [0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0,1], [0,-1,1,0,0,0,0,0,0,1,-1,0,0,1,-1,0,0,0,0,0,0,-1,1,0], [0,0,1,-1,0,0,0,0,0,0,-1,1,0,0,-1,1,0,0,0,0,0,0,1,-1], [1,-1,1,0,0,0,0,0,-1,1,-1,0,-1,1,-1,0,0,0,0,0,1,-1,1,0], [0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1,0,0,0,1], [0,-1,1,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,1,-1,0,0,-1,1,0], [0,0,1,-1,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,-1,1,0,0,1,-1], [1,-1,1,0,0,0,0,0,-1,1,-1,0,0,0,0,0,-1,1,-1,0,1,-1,1,0]], [[-1,0,-1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [1,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,-1,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,-1,0,-1,0,-1,0,1,0,1,0,-1,0,-1,0,1,0,1,0], [0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,-1,0,0,0,1,0,0,0,-1], [0,0,0,0,1,0,0,1,1,0,0,1,-1,0,0,-1,1,0,0,1,-1,0,0,-1], [0,0,0,0,0,1,0,0,0,1,0,0,0,-1,0,0,0,1,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [1,0,1,0,0,0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,1,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1], [-1,0,0,-1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,0,-1,-1,1,0,-1,1,-1,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0], [0,0,0,0,1,-1,0,1,0,0,0,0,-1,1,0,-1,1,-1,0,1,0,0,0,0], [-1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0], [0,-1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,-1,0,0], [0,0,-1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,-1,0], [1,-1,0,1,0,0,0,0,-1,1,0,-1,-1,1,0,-1,0,0,0,0,1,-1,0,1]]]], [ # Q-class [24][40] [[12], [-2,12], [2,0,12], [2,-4,-1,12], [-1,3,1,-2,12], [6,-1,-1,1,-2,12], [-2,1,0,-2,2,-2,12], [1,-6,0,4,0,0,0,12], [-4,-2,-3,2,-3,1,2,1,12], [1,2,6,0,4,0,-2,-2,-5,12], [-4,0,-6,-1,3,0,1,2,-1,0,12], [-2,-4,0,-1,-3,-2,-2,4,3,2,1,12], [-3,2,-2,-2,-2,-2,4,-1,4,-3,-2,-1,12], [3,-3,-1,6,0,3,-4,4,2,0,-1,2,-6,12], [1,4,2,2,3,-1,2,-6,-3,6,-2,-4,-1,2,12], [0,0,-4,2,-2,3,1,4,6,-3,3,3,0,4,-3,12], [0,1,2,2,0,0,-5,1,-1,4,0,2,-2,6,4,2,12], [3,4,2,-3,0,0,-5,-6,-3,6,-2,2,0,-1,4,-2,5,12], [3,-1,-4,-1,-2,3,-5,0,0,2,4,4,0,2,0,4,5,6,12], [3,-1,4,3,-5,2,0,-1,1,3,-6,1,2,2,4,-2,4,3,0,12], [-4,5,-5,-2,3,-6,1,-4,0,0,4,0,4,-5,1,0,-1,4,3,-5,12], [3,-4,3,6,1,0,-3,2,-4,1,-3,-3,-6,4,2,-4,1,-2,-4,-1,-3,12], [-2,6,3,-5,1,-1,4,-6,-2,-1,-4,-6,4,-4,4,-6,-2,0,-6,2,-1,-2,12], [-5,-4,-5,5,-3,-4,0,5,6,-6,2,4,2,2,-5,3,0,-5,-1,-2,3,2,-5,12]], [[[0,0,-1,0,-1,0,0,0,1,1,0,0,0,0,-1,0,1,-1,-1,0,1,1,0,-2], [0,0,0,0,0,0,-1,1,0,-1,1,1,0,0,1,1,-1,0,0,1,1,1,1,-1], [-1,0,-1,1,0,0,1,0,0,1,-1,0,0,0,-1,0,0,1,1,-1,-1,0,1,0], [0,0,0,0,1,-1,0,-1,0,1,0,0,0,0,-2,2,-1,-1,2,2,0,2,2,0], [-1,1,0,1,1,0,0,0,0,-1,0,1,0,0,-1,0,-1,0,2,1,0,2,1,-1], [1,0,-1,-1,-1,0,0,0,1,1,0,0,0,0,0,0,1,-1,-1,0,1,1,0,-1], [0,0,0,0,0,1,0,0,-1,0,-1,0,0,0,1,-1,0,0,-1,-1,0,-2,-2,1], [-1,0,0,1,1,0,1,-1,-1,0,-1,0,0,0,-1,0,0,0,1,0,-1,0,0,0], [1,-1,0,-1,0,0,0,0,0,1,0,-1,0,1,0,0,0,0,-1,0,1,-1,0,1], [-1,1,0,1,0,0,1,0,0,0,0,0,0,0,-1,0,-1,1,2,0,-1,1,1,0], [0,0,1,0,0,1,0,0,-1,-1,0,0,0,0,1,-1,0,0,0,0,0,-1,-1,1], [0,-1,1,0,0,1,0,0,-1,0,0,-1,0,0,1,0,0,1,-1,-1,0,-2,0,2], [1,0,-1,0,0,-1,0,1,1,1,0,0,-1,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,1,0,0,-1,0,0,0,0,0,0,-1,1,0,-1,1,1,0,1,1,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,-1,0,0,1], [1,0,0,0,0,0,0,-1,0,0,1,1,1,1,-1,0,1,-2,-1,1,2,1,0,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,1,0], [0,0,0,0,-1,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,1,1,1,-1], [1,0,0,0,-1,0,0,0,1,0,1,0,0,0,0,-1,1,-1,-1,0,1,0,0,-1], [0,-1,0,-1,-1,1,0,1,0,1,-1,-1,-1,0,1,0,0,0,-1,-1,1,-2,0,1], [0,0,1,0,0,0,-1,1,0,-1,1,0,0,0,1,0,-1,0,0,1,1,0,0,0], [-1,1,0,0,1,-1,0,-1,0,0,0,0,1,0,-1,1,-1,0,2,1,-2,2,0,0], [0,0,-1,0,0,0,0,1,0,0,-1,0,-1,-1,1,0,0,1,0,-1,-1,-1,0,1], [0,-1,1,-1,1,0,-1,0,-1,0,0,-1,0,0,1,1,-1,0,0,1,0,-1,0,2]], [[0,1,0,1,1,-1,0,-1,0,-1,1,1,1,-1,-1,1,0,0,1,1,-1,2,0,-1], [0,0,0,0,1,-1,-1,0,1,-1,1,1,0,0,0,1,-1,-1,1,2,1,2,1,-2], [0,0,0,-1,-1,0,-1,1,0,0,1,0,1,1,1,0,0,0,-2,0,1,0,-1,-1], [0,0,1,0,0,0,0,0,-1,0,0,-1,0,0,1,0,-1,2,0,-1,-2,-2,0,3], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,1,-1,-1,-1,1,0,2,1,1,-1,-1,2,0,-1,1,2,0,3,2,-1], [-1,-1,1,0,0,1,0,0,-1,0,-1,0,0,1,0,0,0,-1,0,0,2,-1,0,0], [0,1,0,0,0,0,1,0,0,0,0,0,1,0,0,-1,0,1,0,-1,-2,0,-1,1], [1,-1,1,-1,-1,1,-1,0,0,0,0,0,0,0,2,-1,1,-1,-2,-1,1,-2,-1,1], [0,0,0,-1,0,0,-1,1,0,0,1,0,0,0,1,1,-1,0,0,1,1,1,1,0], [0,0,-1,1,1,0,1,0,0,1,-1,0,-1,-1,-1,0,0,0,2,0,-1,0,2,1], [0,0,0,-1,-1,1,0,1,0,0,0,0,0,0,1,-1,0,0,-1,0,1,0,-1,0], [0,-1,1,-1,-1,1,0,0,-1,0,-1,-1,0,1,2,-1,0,0,-1,-2,0,-3,-2,2], [1,1,0,0,1,-1,-1,-1,1,-1,2,2,1,-1,-1,1,0,-1,0,2,0,3,1,-2], [0,0,0,0,1,-1,-1,-1,0,0,1,1,0,0,-1,2,-1,-1,1,2,1,2,2,-1], [0,1,0,1,1,-1,0,-1,1,-1,1,2,1,-1,-1,0,0,-1,2,1,-1,3,1,-2], [1,1,-1,0,1,-2,-1,-1,1,0,2,2,1,-1,-1,2,-1,-1,1,2,-1,4,2,-2], [1,0,-1,0,0,-1,-1,0,1,0,1,1,0,-1,0,1,0,-1,0,1,1,2,1,-2], [1,1,-1,1,1,-1,0,-1,1,0,1,2,0,-2,-1,1,0,-1,2,1,-1,3,2,-1], [0,-1,1,-2,-1,1,-2,1,-1,0,0,-1,0,0,3,1,-1,0,-2,0,1,-2,-1,2], [0,0,0,1,0,0,1,0,0,0,-1,0,-1,0,0,-1,0,0,1,-1,0,-1,0,0], [0,1,0,1,0,-1,1,-1,0,0,1,0,1,1,-2,0,0,1,0,0,-1,1,0,-1], [0,-1,0,-1,0,0,-1,0,0,0,0,0,0,1,0,1,0,-1,-1,1,2,0,0,-1], [0,0,1,0,-1,1,1,0,-1,0,-1,-1,0,1,1,-2,0,1,-1,-2,-1,-3,-2,2]]]], [ # Q-class [24][41] [[4], [0,4], [1,1,4], [0,2,-1,4], [1,1,2,-1,4], [0,2,0,2,0,4], [1,2,1,1,0,2,4], [1,1,-1,0,0,-1,1,4], [1,-1,0,0,1,-1,-1,0,4], [-1,0,1,0,-1,-1,0,-1,0,4], [0,-1,1,-2,0,-2,0,0,1,1,4], [-1,-2,-2,-1,-1,0,-2,-1,0,-1,0,4], [1,1,0,0,1,1,0,1,-1,-2,-1,0,4], [1,-1,0,-1,0,-2,0,1,1,0,1,-1,0,4], [1,0,0,1,-1,0,0,0,0,0,-1,-1,0,0,4], [-1,-1,-1,0,-2,-1,-1,0,0,0,1,1,0,1,1,4], [2,0,2,0,2,0,1,0,1,0,0,-1,0,0,0,-2,4], [1,1,2,0,1,-1,1,1,-1,1,0,-2,0,1,0,0,1,4], [-1,1,-1,2,0,1,-1,-1,0,-1,-2,0,1,0,1,1,-1,-1,4], [2,2,1,1,0,1,2,1,0,0,0,-1,1,1,1,0,1,1,0,4], [1,-1,-1,0,0,1,1,0,0,-2,-1,1,0,1,-1,0,0,0,0,0,4], [-1,-1,-1,0,0,1,-1,-1,1,-1,-1,2,-1,-2,-1,-1,0,-2,0,-2,1,4], [2,-1,2,-1,0,-1,1,0,1,1,2,-1,-1,1,0,0,2,1,-2,1,0,-1,4], [1,-2,-1,0,-1,-1,0,0,2,1,1,0,-1,1,1,0,1,-1,-1,0,0,0,1,4]], [[[0,1,-1,-2,-2,0,0,-1,2,0,0,-1,0,-1,0,0,2,0,0,0,1,-1,-1,-1], [0,1,0,1,-1,-1,1,-1,1,0,0,1,1,1,1,-1,0,0,-1,-1,0,0,0,-1], [1,2,-1,-1,-1,0,1,-1,1,1,0,1,1,1,1,0,1,0,0,-2,0,0,0,-1], [-1,1,0,0,-1,-1,0,-1,1,-1,-1,0,0,0,0,-1,0,0,-1,0,0,-1,0,0], [0,1,0,0,0,1,0,0,0,0,0,1,0,1,1,0,0,0,0,-1,0,0,1,0], [0,0,-1,-1,-2,-1,0,-2,1,-1,-1,-2,0,-1,-1,0,1,0,-1,1,0,-1,-1,-1], [0,0,0,0,-1,-1,1,-1,1,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,-1], [0,-1,2,2,1,-1,1,1,0,0,0,1,0,0,0,0,-1,-1,0,0,0,0,0,0], [-1,2,-1,-1,0,0,-1,-1,0,-1,-1,-1,0,0,0,1,1,0,-1,0,0,0,1,1], [0,1,-2,-1,-1,0,0,-1,1,0,1,0,1,0,1,-1,1,1,0,-1,0,0,0,-1], [0,1,-1,0,1,1,0,0,0,1,1,1,1,1,1,0,0,1,0,-1,0,1,1,0], [0,-3,0,0,1,1,-1,1,-1,0,0,-2,-1,-1,-1,1,0,0,0,2,0,0,-1,0], [0,0,1,0,-1,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,1,-1,-1,0], [0,1,1,0,1,0,0,1,-1,0,0,1,0,0,0,0,-1,0,1,0,0,1,1,2], [0,1,1,0,-1,1,-1,1,0,1,2,1,0,1,1,-1,1,0,1,-1,1,0,-1,0], [0,1,2,1,1,0,0,1,-1,0,0,2,0,1,0,0,-1,0,0,-1,0,0,0,2], [0,0,0,-1,-1,2,-1,1,1,1,1,0,0,0,1,-1,1,0,1,-1,1,-1,0,-1], [1,0,1,1,1,-1,2,0,0,0,-1,2,0,1,0,0,-1,-1,0,-1,-1,0,0,0], [-1,2,2,1,0,0,-1,1,-1,0,0,2,0,1,1,-1,-1,0,0,-1,1,0,1,2], [0,0,0,0,-1,0,0,0,1,1,1,0,1,0,1,-1,1,0,0,0,1,0,-1,-1], [0,-2,1,0,1,-1,1,0,-1,-1,-2,-1,-1,-1,-2,1,-1,-1,0,2,-1,0,0,1], [0,-2,-1,0,1,-1,0,-1,-1,-1,-2,-3,-1,-1,-2,2,0,-1,-1,2,-1,0,0,0], [0,2,-1,-2,-2,1,0,0,2,1,1,1,1,0,1,-1,2,1,1,-2,1,-1,0,-1], [-1,0,-1,-1,0,1,-2,0,0,0,1,-2,0,-1,0,0,1,0,0,1,1,0,0,0]], [[0,0,-1,-1,0,1,0,0,0,0,1,0,0,0,0,0,1,1,1,0,0,0,0,0], [-1,-1,2,2,2,1,-1,2,-2,0,0,1,-1,1,0,0,-1,-1,0,0,0,0,1,1], [0,-2,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,-1,2,2,2,0,-1,1,-2,0,-1,0,-1,1,-1,1,-1,-2,-1,1,0,0,0,1], [-1,1,1,0,0,1,-1,1,0,0,1,1,0,0,1,-1,0,1,1,-1,1,0,1,1], [-1,-1,1,2,2,0,-1,1,-2,0,0,0,0,1,0,0,-1,-1,0,1,0,1,1,1], [0,-3,0,2,3,0,0,1,-2,0,0,-1,-1,0,-1,1,-1,-1,0,2,-1,1,0,0], [0,1,0,-1,0,0,0,0,0,-1,-1,0,-1,-1,-1,1,0,0,0,0,0,-1,0,1], [0,1,-1,-2,-2,0,0,-1,2,0,0,-1,0,-1,0,0,2,0,0,0,1,-1,-1,-1], [1,0,-1,0,-1,0,1,-1,1,0,0,0,0,1,0,0,1,0,-1,-1,-1,0,-1,-2], [1,-1,-1,-1,-1,0,1,0,1,1,1,-1,0,-1,0,0,1,0,1,0,0,0,-1,-2], [0,2,-1,-2,-2,1,-1,0,1,1,1,0,1,0,1,-1,1,1,1,-1,1,0,0,0], [-1,1,0,-1,-1,0,-1,0,0,-1,0,0,0,-1,0,-1,0,1,1,0,1,-1,1,1], [1,-2,-1,-1,0,-1,1,-1,0,-1,-1,-2,-1,-2,-2,1,0,0,0,2,-1,0,-1,0], [0,-1,1,1,1,-1,2,0,0,0,-1,2,0,1,0,0,-1,0,0,0,-1,0,0,0], [1,-2,0,0,0,-1,1,0,0,1,-1,-1,0,-1,-1,1,0,-1,0,1,0,0,-1,-1], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-2,1,1,1,1,0,1,-1,0,0,0,-1,0,-1,1,0,0,0,0,-1,0,-1,0], [-1,0,1,1,1,-1,-1,0,-1,0,-1,0,0,0,0,0,-1,-1,-1,1,1,0,1,1], [0,-2,0,0,1,1,0,1,-1,0,0,0,-1,0,-1,0,0,0,1,1,-1,0,0,0], [0,-1,-1,0,1,0,-1,0,-1,0,0,-2,0,-1,-1,1,0,0,0,2,0,1,0,1], [-1,2,-1,-1,-1,0,-1,-1,1,0,0,-1,1,0,1,0,1,0,-1,0,1,0,0,0], [1,-2,-2,-1,0,0,1,-1,1,0,0,-2,0,-1,-1,1,1,0,0,1,-1,0,-1,-2], [1,1,-1,-1,-1,-1,1,-1,1,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,-1]]]], [ # Q-class [24][42] [[4], [1,4], [0,1,4], [1,0,1,4], [1,1,1,1,4], [0,1,2,1,1,4], [1,0,1,2,2,2,4], [0,1,2,1,1,2,1,4], [1,1,1,1,0,1,1,2,4], [1,1,1,1,2,1,1,1,0,4], [1,1,1,1,2,2,2,2,1,1,4], [1,1,1,1,0,2,2,1,1,0,1,4], [1,1,1,1,1,2,2,1,0,1,2,2,4], [2,1,0,1,1,1,2,0,1,1,2,1,2,4], [2,1,0,1,2,1,2,1,0,1,2,1,2,2,4], [1,2,1,0,1,1,1,1,1,0,1,2,1,1,1,4], [1,1,1,1,1,1,2,0,0,0,1,2,1,1,1,1,4], [1,2,1,0,1,1,0,1,2,0,1,1,0,0,0,2,1,4], [0,1,2,1,1,1,1,1,1,0,1,1,1,1,0,2,1,1,4], [1,2,1,0,2,0,0,0,0,2,1,0,1,1,1,1,1,2,1,4], [1,1,1,1,2,0,1,0,1,0,1,0,0,1,0,1,2,2,2,2,4], [1,1,1,1,2,1,2,0,0,0,2,1,1,2,1,1,2,1,1,1,2,4], [1,0,1,2,2,1,2,1,0,1,2,1,1,1,2,0,1,0,1,1,1,2,4], [1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,2,1,1,2,0,1,2,1,4]], [[[0,-1,-1,0,-2,1,-1,0,1,2,0,0,0,-3,3,0,0,-1,2,0,1,3,-2,-1], [1,0,0,0,1,1,2,1,-1,-3,0,0,-1,1,-2,0,0,-1,-1,3,-1,-2,0,1], [2,3,2,1,7,1,6,1,-2,-11,2,1,-4,6,-10,-2,0,-3,-5,9,-5,-11,2,6], [0,0,0,0,0,0,1,0,0,-1,1,1,-1,-1,0,-1,-1,-1,0,2,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0], [2,2,1,1,6,1,4,1,-1,-9,2,1,-3,4,-8,-1,0,-4,-4,8,-4,-8,1,5], [1,1,1,1,4,1,2,0,0,-6,2,1,-2,2,-5,-1,0,-3,-3,6,-3,-5,0,4], [0,0,0,0,-1,0,1,1,-1,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0], [-1,-1,0,0,-2,0,-1,0,0,2,0,1,0,-1,3,0,-1,0,1,-1,2,2,-1,-1], [0,0,0,0,1,0,1,0,0,-1,0,0,0,0,-1,0,0,0,0,1,-1,-1,0,1], [0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,1,1,1,4,1,3,1,-1,-7,2,1,-3,3,-6,-1,0,-3,-3,7,-3,-6,0,4], [1,0,0,0,1,1,1,0,0,-2,1,0,-1,0,-2,0,0,-2,-1,3,-1,-2,0,2], [0,-1,-1,0,-1,1,-1,0,1,1,0,0,0,-2,2,0,0,-1,1,1,0,2,-1,0], [0,-1,-1,0,-2,1,-1,0,1,2,0,-1,1,-3,2,1,0,-1,1,0,1,3,-1,-1], [1,0,0,1,1,1,1,1,-1,-3,0,0,-1,1,-2,0,0,-1,-1,3,-1,-2,0,1], [2,2,1,1,5,1,4,1,-2,-8,2,1,-3,4,-7,-2,0,-2,-3,7,-4,-7,0,4], [1,1,1,1,3,0,3,1,-2,-5,1,1,-2,3,-4,-1,0,-1,-2,4,-2,-5,0,2], [0,0,0,0,-2,0,0,0,-1,1,0,0,0,-1,2,0,-1,1,1,-1,1,1,0,-1], [0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0], [0,0,0,0,-1,0,0,0,-1,1,0,1,0,-1,2,-1,-1,1,1,-1,1,1,-1,-1], [2,2,1,1,6,1,4,1,-1,-9,2,1,-3,4,-8,-2,1,-3,-4,8,-5,-8,1,5], [0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0], [2,1,0,1,2,1,3,1,-1,-5,1,0,-2,1,-4,-1,0,-2,-1,5,-3,-3,0,2]], [[2,2,1,1,7,1,5,1,-1,-10,2,1,-4,5,-9,-2,1,-3,-4,9,-6,-9,1,6], [0,0,0,0,0,0,0,1,-1,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0], [-2,-2,-1,-1,-5,-1,-4,0,0,8,-2,-1,3,-3,7,2,0,4,3,-8,4,7,0,-5], [-1,-1,-1,0,-3,0,-1,0,0,4,-1,0,1,-2,4,0,-1,2,2,-3,2,4,-1,-2], [-1,0,0,0,-1,0,0,0,-1,1,0,0,0,0,1,0,0,1,0,-1,1,0,0,0], [-1,-1,-1,0,-2,0,-2,0,0,3,-1,0,1,-1,3,1,0,1,1,-3,2,3,0,-2], [-1,0,-1,0,-1,0,-1,0,0,2,-1,0,1,-1,2,0,0,1,1,-2,1,2,0,-1], [-1,-1,0,0,-1,0,-2,0,0,2,-1,0,1,0,2,1,0,1,0,-2,1,2,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0], [0,0,0,0,0,1,1,0,0,-1,0,0,-1,0,0,0,0,-1,-1,2,0,-1,0,1], [-1,-1,-1,0,-3,0,-2,0,0,4,-1,0,1,-2,4,1,0,1,2,-3,2,4,-1,-2], [0,0,-1,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0], [-1,-1,-1,0,-2,0,-2,0,1,3,-1,0,1,-2,3,1,0,0,1,-2,2,3,0,-1], [0,0,-1,0,-1,0,0,0,0,1,0,0,0,-1,1,0,0,0,1,0,0,1,0,0], [1,1,0,1,3,1,2,1,-1,-5,1,1,-2,2,-4,-1,0,-2,-2,5,-2,-4,0,3], [0,1,0,0,1,0,1,1,-1,-2,0,0,-1,2,-2,0,0,0,-1,1,-1,-2,1,1], [0,0,-1,0,0,0,0,1,-1,1,-1,0,0,0,0,0,0,1,1,-1,0,1,0,-1], [0,0,0,0,0,0,1,1,-1,-1,0,0,-1,1,-1,0,0,0,0,1,-1,0,0,0], [-1,0,0,0,-2,-1,-1,0,-1,3,-1,-1,1,0,2,1,0,3,1,-4,1,2,1,-2], [0,0,0,0,-1,0,1,1,-1,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0], [-1,0,0,0,-1,-1,0,0,-1,2,0,0,0,0,1,0,0,2,1,-2,0,1,0,-1], [-2,-2,-2,-1,-6,-1,-4,0,0,9,-2,-1,3,-4,8,1,0,4,5,-8,4,8,-1,-5], [-1,-1,-1,0,-3,0,-2,0,0,4,-1,0,1,-2,4,0,0,2,2,-3,2,4,-1,-2], [-1,-1,-1,0,-2,0,-2,0,0,3,-1,-1,1,-1,3,1,0,2,2,-3,1,3,0,-2]]]], [ # Q-class [24][43] [[8], [1,8], [2,2,8], [2,4,2,8], [2,4,4,2,8], [1,2,2,1,2,8], [4,1,2,2,0,2,8], [2,2,2,2,0,4,4,8], [4,1,2,4,3,0,2,1,8], [4,0,4,1,2,2,3,4,2,8], [0,2,2,1,2,4,0,2,2,2,8], [1,4,4,3,2,4,2,4,1,2,2,8], [3,2,2,1,4,0,0,2,2,4,1,2,8], [1,2,2,1,4,2,0,2,1,2,3,0,4,8], [2,2,2,3,4,2,1,2,3,2,1,4,2,2,8], [4,2,4,2,3,1,2,1,4,2,2,2,1,2,3,8], [2,2,1,4,1,2,4,3,2,2,1,1,2,1,1,0,8], [2,1,2,1,1,2,2,4,2,4,4,2,3,2,1,0,2,8], [1,4,0,2,2,4,1,2,0,2,3,2,2,4,2,1,2,2,8], [2,2,3,4,0,2,4,2,2,1,2,4,0,0,1,4,2,0,1,8], [2,3,4,2,3,2,2,2,4,2,4,4,2,1,2,2,1,4,1,2,8], [2,1,4,3,4,1,2,0,4,2,2,1,2,2,1,2,2,0,0,3,2,8], [4,0,0,2,1,1,2,1,4,2,2,0,3,2,1,0,4,4,1,0,2,2,8], [-1,2,2,1,4,4,0,2,2,0,3,2,0,4,2,1,0,1,2,0,2,2,1,8]], [[[0,-1,-1,0,2,0,0,0,0,0,0,1,-1,1,-1,0,0,0,0,0,0,0,0,-1], [0,-1,-1,0,2,-1,-1,1,0,0,0,2,-2,1,-1,0,0,0,0,0,0,0,1,-1], [0,0,-1,0,0,0,0,-1,0,1,0,1,0,1,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-2,0,0,0,-1,-1,-1,1,-1,1,-1,1,0,1,1,1,-1,0,1,1,0,0], [0,0,-1,-1,1,0,-1,0,1,1,-1,2,-2,2,-1,0,1,0,-1,0,0,0,0,-1], [0,0,0,-1,1,0,0,0,1,0,0,1,-1,1,0,-1,0,0,0,0,-1,0,0,-1], [0,-1,0,0,1,0,0,0,1,0,0,2,-1,1,-1,0,0,0,0,-1,-1,0,0,-1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,-1,-1,0,2,-1,-1,1,0,1,0,2,-2,1,-1,0,0,-1,0,0,0,0,1,-1], [0,-1,-1,1,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,-1,1,1,0,0], [0,0,-1,0,-1,0,0,-1,0,0,0,1,0,1,0,1,1,1,-1,-1,0,1,-1,0], [0,-1,-1,0,2,-1,-1,0,0,1,0,2,-2,1,-1,0,1,0,0,0,0,0,0,-1], [0,-1,-1,0,2,-1,0,0,0,0,0,2,-1,1,-1,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,-1,-1,2,-1,-1,1,1,0,0,2,-2,1,-1,0,1,0,0,0,0,0,0,-1], [-1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,1,-1], [0,0,-1,0,0,0,0,-1,0,1,0,1,-1,1,0,0,0,0,-1,0,0,0,0,0], [0,1,0,0,-1,1,0,-1,0,0,0,-1,1,0,1,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,-1,-1,0,-1,-1,0,1,-1,1,-1,1,0,1,1,1,-1,0,0,1,0,0]], [[0,1,0,0,-2,1,0,-1,-1,0,-1,-2,1,-1,1,1,0,1,0,0,1,1,0,1], [0,0,0,0,1,0,0,1,-1,0,0,-1,0,-1,0,0,-1,0,0,1,0,0,1,0], [0,1,0,-1,-1,1,-1,0,0,0,-1,-1,0,0,1,0,0,1,0,1,0,1,0,0], [0,1,1,0,-1,0,0,0,-1,0,0,-2,1,-1,1,0,-1,0,0,1,0,0,1,1], [0,1,-1,-1,0,0,-1,0,0,1,-1,0,-1,0,0,0,0,1,0,1,0,1,0,0], [1,1,0,0,-1,1,0,-1,1,0,0,0,0,1,0,-1,0,1,-1,0,-1,0,-1,0], [0,1,-1,0,-2,1,0,-1,-1,0,-1,-1,1,0,1,1,0,1,-1,0,1,1,0,1], [1,1,0,0,-2,1,0,-1,0,0,0,-1,1,0,1,0,0,1,-1,0,0,0,-1,1], [0,1,0,0,-2,0,0,-1,-1,0,0,-1,1,-1,1,1,0,1,0,0,0,1,0,1], [0,1,0,0,-2,1,-1,0,-1,0,-1,-2,1,-1,1,1,0,1,0,0,1,1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0], [1,1,0,0,-2,1,0,-1,-1,0,0,-1,1,0,1,0,0,1,-1,0,0,1,-1,1], [0,0,-1,0,0,0,-1,0,-1,1,-1,0,-1,0,0,1,0,1,0,0,1,1,0,0], [0,0,-1,0,1,0,-1,0,0,1,-1,0,-1,0,0,0,0,1,0,1,0,0,0,0], [1,1,0,0,-2,0,0,-1,-1,0,0,-1,1,-1,1,0,0,1,0,0,0,1,-1,2], [0,1,0,0,-2,1,0,-1,-1,0,-1,-1,1,-1,1,1,0,1,0,0,0,1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,1,1,0,0,1,-1,0,0,-1,0,-1,0,0,-1,0,0,0,0,0,1,0], [0,1,0,0,-2,1,0,-1,-1,0,-1,-1,1,0,1,1,0,1,-1,0,0,1,0,1], [0,0,-1,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,1,0,0,0,1,0,0], [0,1,0,-1,-1,0,-1,0,0,0,-1,-1,0,0,1,0,0,1,0,1,0,1,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [1,1,-1,-1,0,0,-1,-1,1,1,0,1,-1,1,0,-1,1,1,-1,1,-1,0,-1,0]]]], [ # Q-class [24][44] [[10], [0,10], [3,-3,14], [3,-3,-1,16], [5,-5,6,4,16], [-1,1,-4,4,-6,16], [4,0,-3,-1,3,1,16], [3,1,-2,-5,-1,-3,8,16], [5,-5,6,4,8,-8,0,-2,16], [0,0,-3,5,3,-2,3,0,3,10], [-1,-3,1,0,2,-5,-5,0,1,2,10], [0,-2,5,0,5,1,5,1,2,0,-1,10], [0,0,-6,5,3,-2,-2,-5,3,5,2,-3,16], [-3,-5,4,1,5,-8,-4,-3,8,4,5,0,-1,16], [-5,0,0,0,-1,-1,1,-3,-1,0,-1,3,-3,3,10], [0,0,-2,-5,-3,2,5,8,-3,0,0,1,-5,0,0,10], [0,1,-2,-4,-1,3,5,2,-4,0,0,3,0,-5,0,2,10], [1,1,5,0,-3,-2,-8,-7,5,-1,0,-3,4,-1,-2,-5,-4,18], [0,-2,0,0,-3,2,-3,-4,2,-3,1,0,2,0,0,-1,0,2,10], [2,-3,-4,-3,4,2,5,6,1,2,0,2,1,1,-4,6,4,-5,0,18], [-2,0,2,0,3,-2,-5,-4,-2,-1,3,0,4,0,1,-3,-1,4,0,-3,10], [3,-1,7,0,4,-1,1,-1,4,0,1,5,-3,0,0,-1,3,0,0,-2,0,10], [-2,0,3,1,2,0,-3,1,2,1,0,2,-3,4,1,0,-1,-1,-2,3,0,1,10], [0,-4,1,8,7,-2,3,-3,6,5,-2,4,5,4,3,-3,-4,2,-3,-1,3,-1,1,16]], [[[-2,1,1,0,1,1,0,1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1,0], [-1,0,-1,1,1,-1,0,0,-1,0,-1,0,-1,0,-1,1,0,1,1,0,0,1,0,0], [2,-1,1,-1,-2,1,0,0,1,1,0,1,1,0,1,-1,-1,-1,-2,0,1,-1,0,-1], [0,0,0,-1,0,1,0,1,0,0,0,0,0,1,0,-2,0,0,0,0,0,0,0,0], [0,0,1,-1,-1,1,1,0,1,0,1,0,1,0,0,-1,-1,-1,-1,0,0,0,0,0], [0,0,-2,0,2,0,0,1,-2,-1,0,0,0,1,0,0,0,2,1,-1,-1,1,1,0], [-2,1,0,1,2,-1,1,0,-1,-1,0,-1,0,0,0,1,0,1,1,0,-1,1,0,0], [-2,1,2,1,0,-1,0,-1,1,0,0,-1,0,-2,0,1,0,-1,0,1,0,0,-1,0], [-1,1,2,0,-1,1,1,0,2,0,1,-1,0,0,0,-1,0,-1,-1,1,1,-1,-1,0], [0,0,-1,0,0,-1,0,-1,0,0,0,1,-1,0,-1,0,0,0,0,0,0,0,0,0], [1,-1,0,-1,-1,0,-1,-1,1,1,0,1,0,-1,0,0,0,-1,-1,0,0,-1,0,0], [1,-1,0,0,-1,-1,1,-1,-1,0,0,1,1,0,0,0,-1,0,-1,0,0,0,1,-1], [0,0,-1,0,0,0,0,0,0,-1,0,1,0,1,-1,0,0,0,0,0,0,0,0,0], [2,-1,0,-1,-2,0,0,-1,1,1,0,1,0,0,0,-1,0,-1,-1,0,1,-1,0,0], [1,-1,0,0,-1,-1,1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,-1,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0], [-1,0,-1,1,1,-1,0,0,-1,-1,0,0,0,0,0,1,0,1,0,0,-1,1,0,0], [1,0,0,0,-1,1,0,0,1,0,0,1,0,1,0,0,0,0,-1,0,1,-1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [-2,1,0,1,0,-1,1,-1,1,-1,1,0,0,-1,-1,1,0,0,0,0,0,0,0,0], [2,-1,0,-1,-2,0,0,-1,0,0,0,1,1,0,0,0,-1,-1,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,1,0,-2,0,1,-1,1,0,1,0,0,-1,0,-1,-1,-1,-1,1,1,0,0,0], [2,-1,0,-1,-2,0,1,-1,0,0,0,1,1,1,0,-1,-1,-1,-1,0,1,0,1,-1]], [[0,1,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0], [2,-1,0,-1,-2,0,0,-1,0,0,1,1,1,0,0,0,-1,-1,-1,0,0,0,1,0], [-1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,1,0,1,1,-1,1,-1,0,0,0,0,0,0,0,0,0,1,0,1], [0,0,1,0,0,-1,-1,-1,0,1,-1,0,0,-1,0,1,0,-1,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,-1,0,1,0,0,1,-2,-1,0,0,0,1,0,-1,0,1,1,0,-1,1,0,1], [1,0,0,-1,-2,1,0,0,2,0,1,1,0,0,0,-1,0,-1,-1,0,1,-1,0,0], [-1,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [2,-1,0,-1,-2,0,0,-1,0,0,0,1,1,0,0,0,-1,-1,-1,0,1,0,1,0], [-1,1,-1,0,2,1,0,1,1,0,0,-1,-1,0,0,0,1,1,1,-1,0,0,0,0], [0,-1,-1,0,-1,0,0,0,1,0,0,1,0,0,0,0,0,0,-1,0,1,0,0,-1], [1,-1,0,0,-1,0,0,0,0,0,-1,1,1,1,0,0,0,0,-1,0,1,0,0,-1], [1,-1,-1,0,0,-1,-1,0,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,-1,0,0,-1,0,-1,-1,0,-1,1,0,0,-1,1,0,0,0,-1,0,0,1,0], [1,0,1,-1,-1,0,0,-1,1,1,1,0,0,-1,0,0,0,-1,0,0,0,-1,0,0], [1,0,0,0,-1,0,0,-1,1,0,0,1,0,0,0,0,0,-1,-1,0,1,-1,0,-1], [-2,1,0,1,1,-1,0,0,0,-1,0,-1,-1,-1,-1,1,1,0,1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0,0], [2,-1,0,-1,-2,0,0,-1,0,0,0,1,1,0,0,0,-1,-1,-1,0,0,0,1,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0]], [[-1,0,0,0,1,0,0,0,0,1,0,-1,-1,-1,0,0,0,0,1,0,0,0,0,0], [0,0,1,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0], [0,0,-1,0,1,1,0,1,0,0,0,0,0,1,1,-1,0,1,0,0,0,0,0,-1], [1,-1,-2,0,0,-1,-1,-1,0,1,-1,2,-1,0,-1,1,0,0,0,-1,1,0,0,-1], [1,-1,0,-1,-1,1,0,0,1,1,0,0,0,0,1,-1,-1,-1,-1,0,1,0,0,-1], [0,0,-1,1,0,-2,-1,-1,0,0,-1,1,-1,-1,-1,1,1,0,0,0,0,0,0,0], [1,-1,0,-1,-1,0,0,0,0,1,-1,0,0,0,0,-1,0,-1,0,0,1,0,0,0], [0,0,1,-1,-1,0,1,-1,0,0,1,-1,0,-1,0,-1,-1,-1,0,1,0,0,0,1], [-1,0,-1,0,2,1,0,1,0,0,0,-1,-1,1,0,0,1,1,1,-1,0,0,0,0], [2,-1,-1,-1,0,0,-1,0,-1,1,-1,1,0,1,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [1,-1,-1,0,-1,0,0,0,0,0,-1,1,0,1,0,-1,0,0,-1,0,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,-1,0,0,0,0,0,-1,1,1,1,0,0,0,0,-1,0,1,0,0,-1], [0,0,1,0,-1,-1,0,-1,0,0,0,-1,0,-1,0,0,0,-1,0,1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,2,1,-1,2,-1,0,0,0,0,1,1,0,1,2,1,-1,-1,0,0,0], [-2,1,0,2,1,-1,1,0,0,-1,0,-1,-1,0,-1,1,1,1,1,0,0,0,0,0], [0,0,1,0,-1,-1,0,-1,0,0,0,-1,-1,-1,0,0,0,-1,0,1,0,0,0,1], [1,-1,0,0,-1,0,0,0,0,0,0,1,1,0,1,0,-1,0,-1,0,0,0,0,-1], [1,-1,-2,0,1,0,0,0,-1,0,-1,1,0,1,0,0,0,1,0,-1,0,0,1,-1], [0,0,-1,0,1,0,0,0,-1,-1,0,0,0,1,0,0,0,1,0,0,-1,1,0,0], [2,-2,-2,-1,-1,0,-1,0,0,1,-1,2,0,1,0,0,0,0,-1,-1,1,0,0,-1]]]], [ # Q-class [24][45] [[16], [6,16], [8,6,16], [5,3,1,16], [6,0,6,5,16], [4,3,5,6,4,16], [4,6,8,6,0,5,16], [8,6,4,6,0,8,4,16], [5,8,1,1,0,5,5,5,16], [5,0,1,6,8,8,1,4,4,16], [6,8,6,0,8,4,3,3,5,5,16], [5,8,1,6,0,2,5,5,8,4,5,16], [2,4,1,4,5,6,6,2,8,6,5,4,16], [5,3,1,3,5,6,1,6,5,6,8,6,5,16], [5,3,4,6,4,1,4,5,5,5,4,6,6,8,16], [1,0,5,5,8,4,5,0,0,8,3,0,5,3,5,16], [1,3,5,8,5,4,5,4,0,5,0,3,1,3,5,8,16], [1,8,5,0,0,6,5,5,8,0,3,0,4,2,0,4,3,16], [4,4,5,4,3,-3,6,0,5,0,3,5,-1,0,6,5,4,5,16], [4,3,5,4,4,5,6,6,5,4,3,0,5,-1,2,8,5,6,5,16], [8,0,4,3,6,4,0,8,4,5,3,4,2,3,6,5,1,0,4,6,16], [1,0,5,2,8,4,5,0,4,8,5,4,6,5,4,8,5,0,3,4,5,16], [1,5,2,5,4,5,3,0,5,4,4,2,4,0,-1,8,3,6,6,8,3,4,16], [5,8,1,3,0,2,6,6,8,1,5,8,8,1,6,-3,-3,0,2,2,5,1,-1,16]], [[[0,-2,2,2,-2,-3,0,-3,-1,2,0,-1,-1,3,-1,-2,1,3,-2,1,2,0,1,3], [0,-2,3,3,-3,-2,-2,-3,0,1,0,-1,-1,3,-2,0,1,2,-1,1,1,0,0,4], [0,-1,1,1,-1,-1,-1,0,1,0,0,-1,0,1,-1,1,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,1,-1,-1,1,-1,0,-1,1,0,-1,0,1,-1,0,1,0,1,1], [1,-1,-1,0,0,0,0,-1,-1,0,0,0,-1,0,1,-1,0,2,-1,0,0,1,1,1], [-1,0,1,1,-1,-1,0,-1,0,1,0,-1,0,1,-1,0,0,0,0,0,1,0,0,1], [0,-1,1,1,-1,-1,-1,0,0,0,0,0,0,1,-1,1,0,0,0,0,0,0,0,1], [0,-2,2,2,-2,-3,0,-3,-1,2,0,-1,-2,3,-1,-1,1,3,-2,1,1,0,1,4], [-1,0,2,2,-2,-1,-1,-1,0,1,0,-1,1,2,-2,0,0,0,1,0,1,0,-1,1], [0,0,-1,0,0,0,1,-1,-1,1,0,0,0,0,0,-1,0,1,0,0,1,0,0,0], [1,-1,0,1,-1,0,-1,-2,-1,0,0,0,-1,1,0,0,0,2,-1,1,0,1,0,2], [0,0,1,1,-1,-1,0,-2,-1,1,-1,0,0,2,-1,-1,0,1,0,1,1,0,0,1], [1,-1,0,1,-2,0,-1,-1,-1,0,1,0,0,0,0,0,0,1,0,0,0,1,0,1], [0,0,0,1,-1,-1,0,-2,-1,1,0,0,-1,1,0,-1,0,2,-1,1,1,1,0,1], [1,0,-1,0,-1,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,3,-3,-2,2,2,1,2,0,-1,-1,0,1,-2,1,1,-1,-2,2,-1,0,0,-1,-3], [-1,0,1,1,-1,0,-1,0,1,0,0,-1,0,1,-1,1,0,-1,1,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0], [-1,0,1,1,-1,-1,0,-1,0,1,0,-1,0,2,-1,0,0,0,0,0,1,-1,0,1], [0,-2,2,2,-2,-3,0,-3,-1,2,0,-1,-1,3,-1,-2,1,3,-2,1,1,0,1,3], [0,-1,1,1,-1,-1,-1,-1,0,1,0,0,0,1,-1,0,0,1,0,0,0,0,0,1], [-2,2,1,1,0,0,0,0,1,1,-1,-1,1,1,-1,0,-1,-2,1,0,1,-1,-1,-1], [2,-5,3,3,-4,-3,-2,-4,-2,1,1,0,-2,3,-1,-1,2,5,-3,1,0,1,2,6]], [[0,-4,4,3,-3,-4,-1,-5,-1,2,0,0,-3,4,-1,-2,2,5,-4,2,1,0,2,6], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [1,-4,3,2,-2,-3,-1,-3,-1,1,0,0,-2,3,-1,-1,2,4,-3,1,0,0,2,5], [2,-4,2,2,-3,-2,-2,-4,-1,0,1,0,-2,2,0,-1,2,4,-3,1,0,1,2,5], [1,-3,2,1,-2,-2,-1,-3,-1,1,0,0,-2,3,-1,-1,2,3,-2,1,0,0,2,5], [1,-5,3,3,-3,-3,-2,-4,-1,1,1,0,-2,3,-1,-1,2,5,-3,1,0,0,2,6], [1,-3,2,1,-1,-2,-1,-1,0,0,0,0,-1,1,0,0,1,2,-2,0,-1,0,2,3], [0,-3,3,3,-2,-3,-1,-4,0,1,0,0,-2,3,-1,-1,1,4,-3,1,1,0,1,4], [-1,-1,2,1,-1,-1,-1,0,1,0,0,0,0,1,-1,1,0,0,0,0,0,-1,0,1], [2,-3,0,0,-1,-1,-1,-2,-2,0,0,1,-2,1,1,-1,1,4,-2,1,-1,1,2,4], [0,1,-1,-1,1,1,0,1,0,-1,-1,0,0,0,0,1,0,-1,1,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-3,1,0,-1,-1,-1,-1,-1,0,0,1,-1,1,0,0,1,2,-1,0,-1,0,2,3], [0,-1,1,1,-1,-1,-1,-1,0,0,0,0,0,1,-1,0,1,1,0,0,0,0,0,2], [2,-2,0,0,-1,0,-1,-1,-1,-1,0,1,-1,0,1,0,1,2,-1,0,-1,1,1,2], [2,-3,0,-1,0,0,-1,0,-1,-1,0,1,-1,0,1,0,1,2,-1,0,-2,1,2,3], [3,-4,0,0,-1,-1,-1,-2,-1,-1,1,1,-2,0,1,0,2,4,-3,0,-1,1,2,4], [-1,-1,2,1,0,-1,-1,0,1,0,0,0,0,1,-1,1,0,0,0,0,0,-1,0,1], [0,0,1,0,0,0,-1,1,1,-1,0,0,0,0,0,1,0,-1,0,0,-1,0,0,0], [1,-4,2,1,-1,-2,-1,-2,0,0,0,1,-2,2,0,0,1,3,-3,1,-1,0,2,4], [0,-3,3,2,-2,-2,-1,-3,0,1,0,0,-2,3,-1,-1,1,3,-2,1,0,0,1,4], [1,-2,1,0,-1,-1,-1,0,0,0,0,0,0,1,-1,0,1,1,0,0,-1,0,1,2], [0,0,0,-1,0,1,-1,1,0,-1,0,0,1,0,0,1,0,-1,1,0,-1,0,0,0], [0,-1,1,1,-1,-1,0,-1,0,0,0,0,-1,1,0,0,0,1,-1,0,0,0,1,1]], [[1,-5,3,3,-3,-4,-1,-5,-1,2,1,0,-3,4,-1,-2,2,5,-4,2,1,0,2,6], [1,-3,1,1,-1,-2,0,-1,0,0,1,0,-1,1,0,0,1,2,-2,0,0,0,1,2], [0,-1,0,1,0,-1,0,-1,0,0,0,0,-1,1,0,0,0,1,-1,1,0,0,0,1], [1,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,-2,1,1,-1,-2,0,-2,0,1,0,0,-2,2,0,-1,1,2,-2,1,0,0,1,3], [1,-2,0,0,0,-1,0,-2,-1,0,0,1,-2,1,1,-1,1,3,-2,1,0,0,1,2], [2,0,-3,-2,1,2,0,1,-1,-2,0,1,0,-2,2,1,0,0,0,0,-1,1,0,-1], [1,-2,1,1,-1,-2,0,-3,-1,1,0,0,-1,2,0,-2,1,3,-2,1,1,0,1,2], [2,-3,0,0,-1,0,-1,-1,-1,-1,1,1,-1,0,1,0,1,2,-1,0,-1,1,1,2], [0,-2,2,1,-1,-2,-1,-2,0,1,0,0,-2,2,0,-1,1,2,-2,1,0,0,1,3], [0,-3,2,2,-2,-3,0,-3,0,1,1,0,-2,2,0,-1,1,3,-3,1,1,0,1,3], [0,0,0,-1,0,0,0,1,0,0,0,0,1,0,0,0,0,-1,1,0,0,0,0,-1], [2,-2,-1,-1,0,0,0,-1,-1,-1,0,1,-2,0,2,0,1,2,-2,0,-1,1,2,2], [-1,-2,3,2,-2,-3,0,-3,0,2,0,0,-1,3,-1,-2,1,2,-2,1,2,-1,1,2], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,-1], [0,0,0,0,0,0,-1,1,1,-1,0,0,0,0,0,1,0,-1,0,0,-1,0,0,0], [0,-1,1,1,-1,-1,-1,0,1,0,0,-1,0,1,-1,0,1,0,0,0,0,0,0,1], [2,-3,0,1,-1,-1,-1,-1,-1,-1,1,1,-1,0,1,0,1,3,-2,0,-1,1,1,2], [1,0,-1,0,-1,1,-1,1,0,-1,1,0,1,-1,0,1,0,-1,1,0,-1,1,-1,-1], [2,-2,-1,0,-1,0,-1,-1,-1,-1,1,0,-1,0,1,0,1,2,-1,0,-1,1,1,2], [0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,-1,0,0,0,1,0,0,0,0], [-1,3,-2,-2,2,2,1,2,0,-1,-1,0,1,-1,1,0,-1,-3,2,0,0,0,-1,-3], [1,-1,0,0,-1,0,-1,0,0,-1,1,0,0,0,0,1,1,0,0,0,-1,0,0,1], [2,-1,-2,-2,1,1,1,0,-1,-1,0,1,-1,-1,2,0,0,1,-1,0,-1,1,1,0]]]], [ # Q-class [24][46] [[4], [2,4], [2,1,4], [1,2,2,4], [2,1,2,1,4], [1,2,1,2,2,4], [2,1,2,1,2,1,4], [1,2,1,2,1,2,2,4], [2,1,2,1,2,1,2,1,4], [1,2,1,2,1,2,1,2,2,4], [2,1,2,1,2,1,2,1,2,1,4], [1,2,1,2,1,2,1,2,1,2,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,2,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,2,1,2,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,1,2,1,2,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,2,1,2,1,2,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,1,2,1,2,1,2,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,2,1,2,1,2,1,2,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,1,2,1,2,1,2,1,2,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,2,1,2,1,2,1,2,1,2,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,1,2,1,2,1,2,1,2,1,2,2,4]], [[[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,-1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,-1,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [24][47] [[8], [4,8], [4,2,8], [2,4,4,8], [-2,-1,2,1,8], [-1,-2,1,2,4,8], [0,0,-2,-1,2,1,8], [0,0,-1,-2,1,2,4,8], [4,2,0,0,-4,-2,2,1,8], [2,4,0,0,-2,-4,1,2,4,8], [4,2,4,2,-2,-1,-4,-2,2,1,8], [2,4,2,4,-1,-2,-2,-4,1,2,4,8], [0,0,0,0,0,0,0,0,0,0,0,0,8], [0,0,0,0,0,0,0,0,0,0,0,0,4,8], [0,0,0,0,0,0,0,0,0,0,0,0,4,2,8], [0,0,0,0,0,0,0,0,0,0,0,0,2,4,4,8], [0,0,0,0,0,0,0,0,0,0,0,0,-2,-1,2,1,8], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-2,1,2,4,8], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-1,2,1,8], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2,1,2,4,8], [0,0,0,0,0,0,0,0,0,0,0,0,4,2,0,0,-4,-2,2,1,8], [0,0,0,0,0,0,0,0,0,0,0,0,2,4,0,0,-2,-4,1,2,4,8], [0,0,0,0,0,0,0,0,0,0,0,0,4,2,4,2,-2,-1,-4,-2,2,1,8], [0,0,0,0,0,0,0,0,0,0,0,0,2,4,2,4,-1,-2,-2,-4,1,2,4,8]], [[[0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,-1,1,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,0,0,-1,1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,-1,-1,1,1,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,1,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,1,-1,-1,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [24][48] [[8], [-2,8], [-4,2,8], [0,-4,2,8], [2,4,0,-4,8], [0,-2,0,-2,0,8], [2,-2,2,4,0,-2,8], [0,0,2,0,0,2,0,8], [-2,2,0,-2,0,0,2,-2,8], [4,0,0,0,4,0,2,0,0,8], [-2,0,4,4,-2,0,4,0,2,2,8], [2,0,-2,-2,2,2,2,2,4,4,2,8], [4,-1,-2,0,1,0,1,0,-1,2,-1,1,8], [-1,4,1,-2,2,-1,-1,0,1,0,0,0,-2,8], [-2,1,4,1,0,0,1,1,0,0,2,-1,-4,2,8], [0,-2,1,4,-2,-1,2,0,-1,0,2,-1,0,-4,2,8], [1,2,0,-2,4,0,0,0,0,2,-1,1,2,4,0,-4,8], [0,-1,0,-1,0,4,-1,1,0,0,0,1,0,-2,0,-2,0,8], [1,-1,1,2,0,-1,4,0,1,1,2,1,2,-2,2,4,0,-2,8], [0,0,1,0,0,1,0,4,-1,0,0,1,0,0,2,0,0,2,0,8], [-1,1,0,-1,0,0,1,-1,4,0,1,2,-2,2,0,-2,0,0,2,-2,8], [2,0,0,0,2,0,1,0,0,4,1,2,4,0,0,0,4,0,2,0,0,8], [-1,0,2,2,-1,0,2,0,1,1,4,1,-2,0,4,4,-2,0,4,0,2,2,8], [1,0,-1,-1,1,1,1,1,2,2,1,4,2,0,-2,-2,2,2,2,2,4,4,2,8]], [[[-1,0,-2,-1,0,0,1,1,0,1,1,-2,1,0,2,1,0,0,-1,-1,0,-1,-1,2], [1,-2,1,0,2,-1,-2,0,1,-1,1,0,-1,2,-1,0,-2,1,2,0,-1,1,-1,0], [1,0,1,1,0,0,-1,0,1,0,-1,0,-1,0,-1,-1,0,0,1,0,-1,0,1,0], [0,1,0,0,-1,0,1,0,0,0,-1,0,0,-1,0,0,1,0,-1,0,0,0,1,0], [1,-2,0,0,2,-1,-2,1,1,-1,2,-1,-1,2,0,0,-2,1,2,-1,-1,1,-2,1], [0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,-1,0,0], [0,0,-1,0,0,0,0,1,1,0,0,-1,0,0,1,0,0,0,0,-1,-1,0,0,1], [0,0,0,0,0,0,0,1,1,1,0,-1,0,0,0,0,0,0,0,-1,-1,-1,0,1], [1,-1,0,0,1,0,-1,0,1,-1,1,0,-1,1,0,0,-1,0,1,0,-1,1,-1,0], [0,-1,-1,0,1,0,0,1,1,0,1,-2,0,1,1,0,-1,0,0,-1,-1,0,-1,2], [0,0,0,1,0,0,0,0,1,0,-1,0,0,0,0,-1,0,0,0,0,-1,0,1,0], [0,-1,-1,0,1,0,0,1,1,0,1,-1,0,1,1,0,-1,0,0,-1,-1,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,2,1,0,0,-1,-1,0,-1,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,-1,2,-1,0,-2,1,2,0,-1,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,-1,0,0,1,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,2,0,0,-2,1,2,-1,-1,1,-2,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,0,1,0,-1,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,-1,0,0,-1,-1,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,-1,0,0,-1,-1,0,-1,1]], [[-1,0,0,-1,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,1,0,0,-1,-1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,1,1,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,1,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,-1,1,1,-1,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,-1,0,-1,0,1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,1,-1,0,-1,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,-1,1,1,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,1,1,0,0,-1,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,0,1,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,-1,-1,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,-1,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,1,1,-1,-1,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,0,-1,0,1,0,-1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,-1,0,-1,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,1,1,0,-1,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,-1,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1]]]], [ # Q-class [24][49] [[16], [-4,16], [-8,8,16], [8,-4,-2,16], [-4,-6,2,-4,16], [-6,8,6,0,2,16], [2,6,6,6,-8,4,16], [6,-8,-6,0,0,-8,-6,16], [8,-2,0,0,0,-2,2,8,16], [-8,4,2,0,0,4,2,-4,-8,16], [8,-2,-8,8,-4,-2,-2,0,0,0,16], [8,-2,-8,6,-2,-4,-4,6,0,-2,8,16], [8,-2,-4,4,-2,-3,1,3,4,-4,4,4,16], [-2,8,4,-2,-3,4,3,-4,-1,2,-1,-1,-4,16], [-4,4,8,-1,1,3,3,-3,0,1,-4,-4,-8,8,16], [4,-2,-1,8,-2,0,3,0,0,0,4,3,8,-4,-2,16], [-2,-3,1,-2,8,1,-4,0,0,0,-2,-1,-4,-6,2,-4,16], [-3,4,3,0,1,8,2,-4,-1,2,-1,-2,-6,8,6,0,2,16], [1,3,3,3,-4,2,8,-3,1,1,-1,-2,2,6,6,6,-8,4,16], [3,-4,-3,0,0,-4,-3,8,4,-2,0,3,6,-8,-6,0,0,-8,-6,16], [4,-1,0,0,0,-1,1,4,8,-4,0,0,8,-2,0,0,0,-2,2,8,16], [-4,2,1,0,0,2,1,-2,-4,8,0,-1,-8,4,2,0,0,4,2,-4,-8,16], [4,-1,-4,4,-2,-1,-1,0,0,0,8,4,8,-2,-8,8,-4,-2,-2,0,0,0,16], [4,-1,-4,3,-1,-2,-2,3,0,-1,4,8,8,-2,-8,6,-2,-4,-4,6,0,-2,8,16]], [[[-2,1,-1,0,1,-1,2,1,0,-1,1,0,2,-1,1,0,-1,1,-2,-1,0,1,-1,0], [0,0,0,0,0,0,-1,-1,1,0,0,0,0,0,0,0,0,0,1,1,-1,0,0,0], [1,0,0,0,0,0,-1,-1,0,0,-1,0,-1,0,0,0,0,0,1,1,0,0,1,0], [0,-1,0,-1,0,0,1,0,0,0,0,1,0,1,0,1,0,0,-1,0,0,0,0,-1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [1,0,0,-1,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0], [-2,2,-2,2,1,-1,1,1,0,-1,0,-1,2,-2,2,-2,-1,1,-1,-1,0,1,0,1], [-2,2,-2,1,1,-1,1,1,0,-1,0,-1,2,-2,2,-1,-1,1,-1,-1,0,1,0,1], [2,-2,1,-1,-1,1,-1,-1,0,1,0,0,-2,2,-1,1,1,-1,1,1,0,-1,0,0], [0,-2,1,-1,-1,0,0,-1,1,1,0,1,0,2,-1,1,1,0,0,1,-1,-1,0,-1], [-1,-1,0,0,-1,0,0,-1,1,0,0,1,1,1,0,0,1,0,0,1,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,2,-1,1,0,-1,1,-2,-1,0,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,-1,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,2,-2,2,-2,-1,1,-1,-1,0,1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,2,-2,2,-1,-1,1,-1,-1,0,1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-2,2,-1,1,1,-1,1,1,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,2,-1,1,1,0,0,1,-1,-1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,1,-1,0,0,-1]], [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,-2,-1,1,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,1,0,1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,0,1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,0,-1,0,-2,-2,1,1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,-1,-1,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,1,1,-1,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,-1,-1,1,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,-1,1,0,1,1,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,2,-1,1,0,-1,1,-2,-1,0,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,-1,0,0,0,-1,0], [0,0,0,-1,1,0,2,1,-1,-1,1,0,0,0,0,1,-1,0,-2,-1,1,1,-1,0], [0,-1,1,0,-1,0,-1,-1,0,0,0,0,0,1,-1,0,1,0,1,1,0,0,0,0], [0,1,0,1,0,0,-1,0,0,0,0,-1,0,-1,0,-1,0,0,1,0,0,0,0,1], [-1,1,-1,0,1,0,2,2,-1,-1,1,-1,1,-1,1,0,-1,0,-2,-2,1,1,-1,1], [-1,1,-1,1,1,0,0,0,1,0,0,0,1,-1,1,-1,-1,0,0,0,-1,0,0,0], [-1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0], [1,-1,1,-1,-1,1,0,0,-1,0,0,0,-1,1,-1,1,1,-1,0,0,1,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,1,0,1,1,-1,-1,1,0,0,-1,0,0,-1,0,-1,-1,1,1,-1,0], [-1,0,-1,1,-1,0,-1,-1,1,0,-1,0,1,0,1,-1,1,0,1,1,-1,0,1,0], [-2,1,-1,0,1,-1,2,1,0,-1,1,0,2,-1,1,0,-1,1,-2,-1,0,1,-1,0], [0,-1,0,-1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,-1,0,0,0,-1,0]], [[0,0,0,1,-1,0,-2,-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,-1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,1,0,2,1,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,-1,0,-1,-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,1,0,1,1,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,-2,2,-1,-2,1,-2,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,1,-1,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,-1,1,-1,0,-1,-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-2,1,0,-2,1,-2,-2,1,1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,-2,-1,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,0,1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,2,1,-1,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,-1,-1,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,1,0,1,1,-1,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,2,-2,2,-1,-2,1,-2,-1,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,-1,-1,1,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,1,-1,0,-1,-1,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-2,1,0,-2,1,-2,-2,1,1,-1,1]]]], [ # Q-class [24][50] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [24][51] [[4], [0,4], [-2,0,4], [-1,2,2,4], [-2,2,2,2,4], [2,2,-2,0,0,4], [2,0,-2,-1,-2,1,4], [1,-1,1,0,0,-1,1,4], [-1,1,2,2,2,0,-2,-1,4], [-2,-1,2,1,0,-2,-2,0,0,4], [2,0,-2,-2,-2,2,2,0,-2,-1,4], [-1,-2,0,-2,0,-1,0,0,0,0,0,4], [-1,1,2,2,2,-1,-2,0,2,1,-2,-1,4], [-2,-1,2,1,1,-2,-1,1,0,2,-2,0,1,4], [-1,1,1,0,2,0,-2,0,0,1,0,0,1,0,4], [1,2,-1,1,1,2,1,-1,1,-2,0,-1,1,-1,-1,4], [2,0,-2,-1,-2,2,2,-1,0,-2,2,0,-1,-2,-2,1,4], [2,-2,-2,-2,-2,0,1,1,-2,-1,1,0,-1,-1,-1,0,1,4], [2,-1,0,-1,-1,0,1,2,0,-1,1,0,-1,-1,0,-1,1,1,4], [-1,-1,2,1,0,-1,0,1,0,2,0,0,1,2,0,-1,0,-1,0,4], [-2,-2,0,-1,0,-2,-1,0,0,1,-1,2,-1,1,0,-2,-1,0,0,0,4], [1,-1,-1,-2,-1,1,1,0,0,-1,2,2,-1,-2,0,0,2,1,1,0,0,4], [-1,1,2,2,2,-1,-1,1,1,1,-1,0,1,0,1,0,-2,-1,0,0,0,-1,4], [-2,2,0,1,2,0,0,-1,0,0,-1,0,1,1,1,1,-1,-2,-2,0,0,-1,0,4]], [[[0,0,0,0,-1,1,-1,-1,-2,-1,-1,0,1,1,-1,0,-1,-1,1,0,0,1,1,0], [0,0,-1,0,0,-1,0,1,1,0,0,0,-1,0,1,0,1,0,-1,0,-1,-1,0,0], [0,0,0,0,-1,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,1,0,0,-1,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,0,-1,0,0], [0,0,-1,0,0,-1,0,1,1,0,0,0,-1,0,1,0,1,0,-1,0,-1,0,0,0], [0,0,-1,0,1,0,0,0,0,0,0,0,0,0,-1,-1,-1,0,0,0,-1,0,0,0], [1,0,1,0,0,1,0,-1,-1,0,0,0,1,0,-1,0,-1,0,0,0,1,0,0,0], [1,0,1,0,-2,1,0,-1,0,-1,0,0,1,1,0,0,-1,0,0,0,1,1,1,1], [-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0], [0,1,1,0,-1,0,1,0,1,0,0,0,0,0,1,0,0,1,0,0,1,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,1,0,-1,-1,-1,0,0,0,0,0,0,0], [0,-1,0,0,1,0,-1,0,-1,0,0,-1,0,-1,-1,0,0,-1,0,0,0,1,0,0], [0,0,0,0,0,0,1,0,0,0,-1,0,0,0,1,0,1,0,0,0,0,0,0,0], [1,-1,1,-1,1,0,2,0,1,1,0,-1,0,0,1,0,1,0,-1,-1,1,0,0,0], [0,0,0,0,0,-1,0,1,1,0,0,0,-1,0,1,0,1,0,-1,0,-1,0,0,0], [0,0,0,0,0,1,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,1,0,-1,-1,0,0,0,1,0,-2,-1,-1,0,1,0,0,0,0,0], [0,1,1,1,-1,1,-1,-1,-2,-1,0,1,1,1,-1,0,-1,0,1,0,1,1,0,0], [0,0,1,0,-2,1,-1,-1,-1,-1,0,0,1,1,-1,0,-1,0,1,0,0,1,1,1], [1,0,1,0,0,1,2,-1,1,0,0,0,1,0,0,-1,-1,1,0,0,1,0,0,0], [-1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,1,0,0,0,1,-1,-1,-1,-1,0,0,1,0,-2,-1,-2,0,1,1,0,1,0,0], [-1,1,0,1,-3,0,-1,1,0,-1,0,1,0,0,1,1,0,0,0,0,0,0,0,0], [1,-1,0,-1,2,-1,1,1,1,1,0,-1,-1,-1,1,0,2,0,-2,0,0,-1,0,0]], [[-1,0,-1,0,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,1,0,0,1,1,-1,0,-1,0,0,1,0,0,-1,-1,1,0,0,1,0,0,0], [0,0,-1,0,0,0,0,0,1,-1,0,0,0,0,0,-1,-1,0,0,1,-1,0,0,0], [-1,1,0,1,-2,1,0,-1,0,-2,0,1,1,0,0,-1,-2,1,1,1,0,0,0,0], [1,0,1,0,0,1,1,-1,0,-1,0,0,1,0,0,-1,-1,0,0,0,1,0,0,0], [0,0,1,0,1,1,2,-1,0,1,0,0,1,0,0,-1,0,1,0,-1,1,0,0,0], [-1,-2,0,0,1,0,0,1,-1,1,0,-1,0,-1,0,1,1,-1,0,-1,0,0,0,0], [-1,-1,-2,0,2,-1,1,1,1,1,1,0,0,-1,0,0,0,-1,0,0,-1,-1,-1,-1], [1,1,0,1,0,0,0,-1,0,-1,0,1,0,0,0,-1,-1,1,0,1,0,0,0,0], [-1,2,-1,0,-2,0,-1,0,1,-1,0,1,0,1,0,0,-1,1,1,1,-1,0,0,0], [0,-1,0,-1,2,0,1,0,0,2,0,-1,0,0,0,0,1,0,0,-1,0,0,0,0], [1,-1,1,0,1,0,0,0,-1,1,0,0,0,0,0,1,1,-1,0,-1,0,0,0,0], [0,1,0,0,-1,1,0,0,1,-1,0,1,0,0,0,-1,-1,1,0,1,0,-1,0,0], [-1,0,-1,0,-1,0,-1,1,0,-1,0,0,0,0,0,0,0,-1,0,0,-1,0,0,0], [1,1,1,-1,0,1,2,-1,1,0,0,0,1,1,0,-1,-1,1,0,0,1,0,0,0], [0,0,1,0,0,1,0,0,-1,0,-1,0,0,-1,0,0,0,0,0,0,1,0,0,0], [0,-1,0,1,1,0,0,0,-1,1,0,0,0,0,0,0,1,0,0,-1,0,0,0,0], [0,0,-1,0,0,-1,-1,1,0,1,0,0,-1,0,0,1,1,-1,0,0,0,0,0,0], [0,0,-1,1,2,-1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,-1,-1], [-1,0,-1,0,0,1,0,0,0,0,0,0,1,0,-1,-1,-1,0,1,0,-1,0,0,0], [1,0,0,0,0,-1,-1,0,-1,0,0,0,0,0,0,1,1,-1,0,0,0,0,0,0], [1,-1,0,0,2,0,1,0,0,2,0,0,0,0,0,0,1,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,0,0,-1,0,1,1,0,0,0,0], [0,0,2,0,-1,1,0,0,-1,-1,0,0,1,0,0,0,0,0,0,-1,1,0,0,0]]]], [ # Q-class [24][52] [[4], [2,4], [2,2,4], [2,2,2,4], [2,2,2,2,4], [2,2,2,2,2,4], [2,2,2,2,2,2,4], [2,2,2,2,2,2,2,4], [2,2,2,2,2,2,2,2,4], [2,2,2,2,2,2,2,2,2,4], [2,2,2,2,2,2,2,2,2,2,4], [2,2,2,2,2,2,2,2,2,2,2,4], [2,1,1,1,1,1,1,1,1,1,1,1,4], [1,2,1,1,1,1,1,1,1,1,1,1,2,4], [1,1,2,1,1,1,1,1,1,1,1,1,2,2,4], [1,1,1,2,1,1,1,1,1,1,1,1,2,2,2,4], [1,1,1,1,2,1,1,1,1,1,1,1,2,2,2,2,4], [1,1,1,1,1,2,1,1,1,1,1,1,2,2,2,2,2,4], [1,1,1,1,1,1,2,1,1,1,1,1,2,2,2,2,2,2,4], [1,1,1,1,1,1,1,2,1,1,1,1,2,2,2,2,2,2,2,4], [1,1,1,1,1,1,1,1,2,1,1,1,2,2,2,2,2,2,2,2,4], [1,1,1,1,1,1,1,1,1,2,1,1,2,2,2,2,2,2,2,2,2,4], [1,1,1,1,1,1,1,1,1,1,2,1,2,2,2,2,2,2,2,2,2,2,4], [1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,1,0,0,0,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,-1,0,0,0,1], [0,1,0,0,0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,-1], [-1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0], [-1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0], [-1,1,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0], [-1,0,1,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0], [-1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,-1,0,0], [-1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,-1]]]], [ # Q-class [24][53] [[6], [1,6], [0,1,6], [2,-1,0,6], [-2,-3,-3,2,10], [2,0,-1,2,-2,6], [-2,-2,-2,2,2,2,6], [-1,-1,1,-2,1,0,-1,6], [-1,1,2,0,2,-3,0,-1,8], [3,2,-2,3,-2,3,2,-2,-3,10], [2,0,0,-1,-3,2,-1,1,-3,3,6], [2,-1,-2,-1,-1,0,0,-1,-1,2,3,6], [-3,-2,-2,0,5,-2,1,0,3,-4,-4,-1,8], [-1,2,0,-2,1,-2,-1,-1,1,-1,0,1,1,6], [0,0,1,1,3,-3,0,1,2,-2,-3,-2,1,1,8], [0,1,1,2,2,-2,0,0,1,2,-1,-1,0,0,1,6], [-2,-1,2,2,0,0,2,1,0,0,0,-2,0,-1,2,2,6], [-2,-3,2,-1,-2,-2,0,0,2,-3,0,1,0,-2,0,-1,2,8], [-1,-3,0,2,5,-2,0,-1,0,-3,-2,-2,3,0,1,2,1,0,8], [-2,-3,0,-2,-2,1,0,1,-1,-1,1,0,0,-3,-3,-3,0,4,-1,8], [0,-1,2,2,-2,2,2,1,-2,1,1,0,-3,-2,0,0,3,1,-1,0,6], [0,-1,1,-2,-2,-1,-2,2,-2,-3,0,-1,-1,0,2,-1,1,2,0,1,0,6], [-3,-3,-3,-1,5,-1,2,2,1,-4,-2,0,5,1,0,0,0,0,2,0,-1,0,8], [-1,2,1,-2,-1,-1,0,0,2,1,1,1,0,1,0,1,1,1,-2,0,-1,-1,-2,6]], [[[-2,-1,-2,1,-2,1,-1,1,2,0,0,1,-1,0,1,0,0,-1,1,0,0,0,0,0], [-1,1,0,1,0,1,0,0,0,-1,1,1,0,0,1,1,-1,0,0,1,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0], [3,2,0,0,1,-2,2,1,-1,0,0,-1,1,1,-1,-1,0,1,0,1,1,0,0,0], [3,2,1,-3,2,-1,2,0,-1,1,0,-1,2,0,-1,0,0,2,0,0,1,0,-1,-1], [0,0,1,0,0,0,0,0,0,0,-1,1,-1,-1,0,-1,1,-1,0,0,-1,0,1,0], [2,1,1,-1,1,-1,1,0,-1,0,-1,0,0,0,-1,-1,1,0,0,0,0,0,0,0], [0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [-1,0,0,-2,1,2,-1,-1,1,1,0,1,1,0,0,1,0,0,0,0,1,1,-1,-1], [-2,0,-1,2,-2,1,-1,2,1,0,-1,2,-2,0,1,-1,0,-1,2,0,-1,0,1,1], [-2,-1,-1,2,-2,1,-1,1,1,0,-1,1,-2,0,1,0,0,-1,1,0,-1,0,1,1], [-3,-1,-1,0,-1,2,-2,0,2,1,0,1,-1,-1,1,0,0,-1,1,-1,0,1,0,0], [2,2,2,-3,3,-1,1,-2,-1,1,1,-1,2,-1,-1,0,0,1,-1,0,1,1,0,-1], [0,1,1,-3,2,2,-1,-2,0,1,1,0,1,-1,1,1,0,1,0,0,1,0,0,-1], [1,0,-1,-1,0,0,0,0,0,0,0,-1,1,1,0,0,0,1,0,0,1,-1,-1,0], [2,1,-1,1,0,-2,2,2,-1,-1,0,-1,0,2,-1,0,0,1,0,1,0,-1,-1,0], [4,1,0,1,1,-3,2,1,-2,-1,-1,-2,0,2,-2,-1,1,1,-1,1,0,-1,0,1], [0,-2,-1,0,0,0,-1,0,0,0,-1,-1,0,1,-1,0,1,0,-1,-1,0,0,-1,0], [5,1,-1,0,1,-4,3,1,-2,-1,0,-3,1,2,-2,0,0,2,-1,1,1,-1,-1,0], [-3,-4,0,1,-2,1,-3,0,1,1,-2,1,-2,-1,0,-1,1,-2,0,-2,-2,0,1,1], [2,1,0,2,0,-2,2,1,-1,-1,0,-1,0,1,-1,-1,0,0,0,1,0,0,0,1], [0,-2,0,-1,0,0,-1,-1,0,0,0,-1,0,0,0,0,1,0,-1,-1,0,-1,0,0], [3,1,1,-3,2,-1,2,-1,-1,0,1,-2,2,0,-1,1,0,1,-1,0,1,0,-1,-1], [-1,0,0,0,0,1,-1,0,0,0,-1,1,-1,0,0,0,1,0,0,0,-1,0,0,0]], [[2,3,1,-1,2,0,2,-1,-1,0,2,-1,2,0,0,1,-1,2,0,1,1,1,0,-1], [0,1,2,-2,2,1,0,-1,0,1,0,1,1,-1,0,0,1,0,0,0,0,1,0,-1], [0,2,1,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,1,0,-1], [5,3,-1,1,1,-3,4,1,-2,-2,2,-3,2,2,-1,1,-1,2,-1,2,1,0,-1,0], [1,-1,-2,0,-1,-1,-1,0,0,0,0,-2,0,1,0,0,0,0,0,0,1,-1,0,1], [3,2,0,1,0,-2,3,1,-1,-1,1,-1,1,1,-1,0,0,1,0,1,0,0,0,0], [2,-1,-1,1,-1,-2,1,1,-1,-1,0,-2,0,1,-1,0,0,0,-1,0,0,-1,0,1], [-3,-2,-1,0,-2,2,-2,0,2,1,-1,1,-1,0,1,0,0,-1,1,-1,0,0,0,0], [-2,-1,0,-1,0,2,-3,-1,1,1,-1,1,-1,-1,1,0,1,-1,0,0,0,0,1,0], [3,1,1,0,1,-2,3,0,-2,-1,1,-2,1,0,-1,0,0,1,-1,0,-1,0,0,0], [0,-1,0,0,0,0,0,0,0,0,-1,0,-1,0,-1,-1,1,0,0,-1,-1,0,0,0], [-1,-1,0,-1,0,1,-1,-1,0,0,0,0,0,-1,0,0,0,0,0,-1,0,0,0,0], [-2,-1,-2,1,-2,1,-2,1,1,0,-1,1,-1,0,1,0,0,-1,1,0,0,-1,0,1], [-2,-1,0,-1,0,1,-2,0,1,1,-1,1,-1,-1,0,-1,1,-1,1,-1,0,0,0,0], [-1,-1,-2,1,-1,0,-1,1,1,0,0,-1,0,1,0,1,-1,0,0,0,1,0,-1,0], [2,2,2,-3,3,0,1,-2,-1,1,1,-1,2,-1,0,0,0,1,-1,0,1,1,0,-1], [1,0,-1,1,0,-1,1,1,0,-1,0,-1,0,1,-1,0,0,0,-1,0,0,0,-1,0], [-4,-3,-1,1,-2,2,-3,0,2,0,-1,2,-2,-1,1,0,0,-2,0,-1,-1,0,0,0], [2,2,0,0,1,-1,1,0,-1,0,1,-1,1,1,0,0,-1,1,0,1,1,0,0,0], [-1,-1,0,3,-2,-1,0,1,0,-1,-1,1,-2,0,0,-1,0,-1,0,0,-2,-1,1,1], [3,1,-1,1,0,-2,3,1,-1,-2,1,-2,1,2,-1,1,-1,1,-1,1,1,0,-1,0], [-4,-1,0,1,-1,2,-2,0,2,1,0,2,-1,-1,1,0,-1,-1,1,-1,0,1,0,0], [-2,-3,-2,-1,-2,2,-3,0,2,1,-1,0,-1,0,1,0,0,-1,1,-1,1,-1,0,1], [-3,-1,1,0,0,1,-2,-1,1,1,-1,2,-1,-2,0,-1,1,-2,0,-1,-1,1,1,0]]]], [ # Q-class [24][54] [[4], [2,4], [2,2,4], [2,2,2,4], [-2,-1,-1,-1,4], [-1,-2,-1,-1,2,4], [-1,-1,-2,-1,2,2,4], [-1,-1,-1,-2,2,2,2,4], [2,1,1,1,-2,-1,-1,-1,4], [1,2,1,1,-1,-2,-1,-1,2,4], [1,1,2,1,-1,-1,-2,-1,2,2,4], [1,1,1,2,-1,-1,-1,-2,2,2,2,4], [2,1,1,1,0,0,0,0,0,0,0,0,4], [1,2,1,1,0,0,0,0,0,0,0,0,2,4], [1,1,2,1,0,0,0,0,0,0,0,0,2,2,4], [1,1,1,2,0,0,0,0,0,0,0,0,2,2,2,4], [-2,-1,-1,-1,2,1,1,1,0,0,0,0,-2,-1,-1,-1,4], [-1,-2,-1,-1,1,2,1,1,0,0,0,0,-1,-2,-1,-1,2,4], [-1,-1,-2,-1,1,1,2,1,0,0,0,0,-1,-1,-2,-1,2,2,4], [-1,-1,-1,-2,1,1,1,2,0,0,0,0,-1,-1,-1,-2,2,2,2,4], [2,1,1,1,-2,-1,-1,-1,2,1,1,1,2,1,1,1,-2,-1,-1,-1,4], [1,2,1,1,-1,-2,-1,-1,1,2,1,1,1,2,1,1,-1,-2,-1,-1,2,4], [1,1,2,1,-1,-1,-2,-1,1,1,2,1,1,1,2,1,-1,-1,-2,-1,2,2,4], [1,1,1,2,-1,-1,-1,-2,1,1,1,2,1,1,1,2,-1,-1,-1,-2,2,2,2,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0], [-1,0,0,1,-1,0,0,1,0,0,0,0,1,0,0,-1,0,0,0,0,-1,0,0,1], [-1,1,0,0,-1,1,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,-1,1,0,0], [-1,0,1,0,-1,0,1,0,0,0,0,0,1,0,-1,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,-1,0,1,0], [0,0,0,0,-1,0,0,0,-1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,1,-1,0,0,1,1,0,0,-1,1,0,0,-1,0,0,0,0], [0,0,0,0,-1,1,0,0,-1,1,0,0,1,-1,0,0,1,-1,0,0,0,0,0,0], [0,0,0,0,-1,0,1,0,-1,0,1,0,1,0,-1,0,1,0,-1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,-1,0,0,0,1,0,0,0], [0,0,0,0,1,0,0,-1,0,0,0,0,-1,0,0,1,-1,0,0,1,1,0,0,-1], [0,0,0,0,1,-1,0,0,0,0,0,0,-1,1,0,0,-1,1,0,0,1,-1,0,0], [0,0,0,0,1,0,-1,0,0,0,0,0,-1,0,1,0,-1,0,1,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,-1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,-1,0,1,0]], [[1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,-1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,-1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,-1,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,1,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,1,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,1,0,-1,0,0,0,0,0]]]], [ # Q-class [24][55] [[4], [2,4], [2,1,4], [1,2,2,4], [2,1,2,1,4], [1,2,1,2,2,4], [2,1,2,1,2,1,4], [1,2,1,2,1,2,2,4], [0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,2,4], [0,0,0,0,0,0,0,0,2,1,4], [0,0,0,0,0,0,0,0,1,2,2,4], [0,0,0,0,0,0,0,0,2,1,2,1,4], [0,0,0,0,0,0,0,0,1,2,1,2,2,4], [0,0,0,0,0,0,0,0,2,1,2,1,2,1,4], [0,0,0,0,0,0,0,0,1,2,1,2,1,2,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,2,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,1,2,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,2,1,2,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,1,2,1,2,2,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,-1,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0]], [[-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [24][56] [[8], [4,8], [3,4,8], [3,4,4,8], [2,4,2,2,8], [2,3,3,3,3,8], [3,2,4,4,1,4,8], [3,2,4,2,4,3,2,8], [0,2,3,3,4,3,3,3,8], [3,2,1,2,4,4,1,2,3,8], [3,2,2,1,4,3,2,4,3,4,8], [2,3,2,3,3,2,3,4,4,3,3,8], [3,4,4,2,2,3,4,2,3,2,4,3,8], [2,2,3,3,4,4,4,3,4,3,3,3,3,8], [3,4,2,4,2,2,2,1,3,4,2,3,4,3,8], [4,3,4,3,3,3,3,2,2,3,3,0,3,2,3,8], [4,1,1,2,2,3,2,2,2,4,4,2,2,3,2,4,8], [3,1,2,2,2,2,4,4,3,2,4,3,2,2,1,3,4,8], [3,2,2,4,4,3,2,4,3,4,2,3,1,3,2,3,4,4,8], [3,3,4,3,3,4,3,2,2,4,3,2,3,3,2,4,3,3,3,8], [2,3,2,3,3,2,3,4,3,2,3,4,3,2,4,2,3,3,3,0,8], [1,0,2,2,3,2,2,4,3,2,3,2,0,4,1,2,0,1,1,0,2,8], [2,2,2,4,1,3,4,1,4,2,2,4,4,3,4,2,4,2,2,3,3,0,8], [3,2,1,3,1,2,1,2,0,4,3,1,0,-1,2,3,1,2,3,2,1,2,-1,8]], [[[-15,18,-10,4,-9,-9,27,18,-2,9,11,-6,-4,-22,13,-3,14,-11,10,2,-17,9, -12,-21], [-15,18,-10,4,-9,-9,26,18,-2,9,11,-6,-4,-22,13,-3,14,-11,10,2,-17,9, -11,-21], [-9,10,-5,2,-5,-5,15,10,-2,5,6,-3,-2,-13,8,-2,8,-6,6,1,-10,6,-6,-12], [-13,16,-9,3,-8,-8,24,16,-2,8,10,-5,-4,-20,12,-3,12,-10,9,2,-15,8,-10, -19], [-7,8,-4,2,-4,-4,11,8,-1,5,5,-3,-2,-9,5,-1,5,-4,4,0,-7,3,-4,-9], [-8,10,-5,2,-5,-5,14,9,-1,5,6,-3,-2,-12,7,-2,7,-6,6,1,-9,5,-6,-11], [-9,10,-5,2,-4,-5,16,10,-2,5,6,-3,-2,-14,9,-3,9,-6,6,1,-11,6,-7,-12], [-5,5,-2,1,-2,-3,8,5,-1,3,3,-2,-1,-7,4,-1,4,-3,3,0,-5,3,-3,-6], [-3,3,-1,0,-1,-1,4,2,-1,1,2,-1,-1,-4,3,-1,2,-1,2,0,-3,2,-1,-3], [-7,9,-5,2,-5,-4,12,8,-1,5,6,-3,-2,-10,5,-1,5,-5,5,1,-7,4,-5,-10], [-4,4,-2,1,-1,-2,6,4,-1,2,2,-2,0,-5,3,-1,3,-2,2,0,-4,2,-2,-4], [-5,5,-3,1,-2,-3,8,5,-1,3,3,-2,-1,-7,4,-1,4,-3,3,1,-5,3,-3,-6], [-6,6,-3,1,-2,-3,10,6,-1,2,4,-2,-1,-9,6,-2,6,-4,4,1,-7,4,-4,-7], [-4,4,-2,1,-1,-2,6,4,-1,2,2,-1,-1,-5,3,-1,3,-2,2,0,-4,2,-2,-4], [-12,15,-8,3,-7,-7,22,14,-2,7,10,-5,-4,-19,11,-3,11,-9,9,2,-14,8,-9, -18], [-12,15,-8,3,-8,-7,22,15,-2,8,10,-5,-4,-18,11,-2,10,-9,9,1,-14,7,-9, -18], [-8,10,-6,2,-5,-5,15,10,-1,5,6,-4,-2,-12,7,-2,7,-6,6,1,-9,5,-6,-11], [-9,10,-5,2,-4,-5,16,10,-2,5,6,-4,-2,-14,9,-3,9,-6,6,1,-10,6,-7,-12], [-7,8,-4,1,-4,-4,12,8,-1,4,5,-3,-2,-10,6,-2,6,-5,5,1,-7,4,-5,-9], [-5,6,-3,1,-3,-3,8,6,-1,3,3,-2,-1,-7,4,-1,4,-3,3,1,-5,3,-3,-6], [-11,13,-7,3,-6,-7,20,13,-2,7,9,-5,-3,-17,10,-3,10,-8,8,1,-13,7,-8,-16], [-2,2,-1,1,-1,-1,3,2,-1,2,2,0,-1,-2,1,1,0,-1,1,-1,-2,0,-1,-3], [-5,6,-3,0,-2,-3,9,5,-1,2,3,-2,-1,-8,5,-2,5,-3,4,1,-6,4,-3,-6], [-7,9,-5,2,-5,-4,13,9,-1,5,6,-3,-2,-11,6,-1,6,-6,5,1,-8,4,-6,-11]], [[-11,14,-7,3,-7,-6,20,13,-2,7,9,-4,-4,-17,10,-2,10,-8,8,1,-13,7,-9,-17], [0,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [-2,2,0,0,0,-1,4,2,-1,1,1,-1,-1,-3,2,-1,2,-1,1,0,-2,1,-1,-2], [-2,2,0,0,0,-1,3,2,-1,1,1,-1,-1,-3,2,-1,2,-1,1,0,-2,1,-1,-2], [0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,1,0,1,0,-1,0,0,0,0,-2,1,-1,1,0,1,0,-1,1,0,-1], [-3,3,-1,0,-1,-1,5,3,-1,1,2,-1,-1,-5,3,-1,3,-2,2,1,-3,2,-2,-4], [-4,4,-2,1,-1,-2,7,5,-1,2,2,-1,-1,-6,4,-1,4,-2,2,0,-5,2,-3,-5], [2,-3,2,-1,2,1,-3,-2,0,-2,-2,1,1,2,-1,0,-1,1,-1,0,2,-1,1,3], [4,-5,3,-1,3,3,-7,-5,0,-3,-3,2,1,5,-3,1,-4,3,-2,-1,4,-2,3,5], [-1,1,0,0,0,0,2,1,-1,0,0,0,0,-3,2,-1,2,0,1,0,-2,2,-1,-2], [1,-2,1,0,1,1,-2,-1,0,-1,-1,1,0,1,0,1,-1,1,-1,0,1,-1,0,1], [-5,6,-3,1,-3,-3,10,6,-1,3,4,-2,-2,-9,5,-1,5,-4,4,1,-6,4,-4,-8], [-2,2,-1,1,-1,-1,3,3,-1,2,1,-1,0,-3,1,0,1,-1,1,0,-2,1,-1,-3], [2,-2,1,0,1,1,-3,-2,0,-1,-1,1,0,2,-2,1,-2,1,-1,0,2,-1,1,2], [-5,7,-3,1,-3,-3,10,6,-1,3,4,-2,-2,-9,5,-2,5,-4,4,1,-6,4,-4,-8], [-9,11,-6,3,-6,-5,17,11,-2,6,8,-3,-3,-15,9,-2,8,-7,7,1,-11,6,-8,-15], [-6,7,-4,2,-3,-3,12,8,-1,3,5,-2,-2,-11,7,-2,7,-5,4,1,-8,4,-6,-10], [-4,4,-2,1,-1,-2,7,5,-1,2,2,-1,-1,-6,4,-1,4,-3,2,0,-5,2,-3,-5], [-3,3,-1,1,-1,-1,5,3,-1,1,2,-1,-1,-5,3,-1,3,-2,2,0,-3,2,-2,-4], [3,-4,2,-1,2,2,-5,-3,0,-2,-2,2,0,4,-2,1,-3,2,-2,0,3,-2,2,4], [5,-6,4,-2,4,3,-10,-6,0,-3,-5,2,2,8,-5,1,-5,5,-4,-1,6,-3,5,8], [-4,4,-2,1,-2,-2,7,4,-1,2,3,-1,-1,-7,4,-1,4,-3,3,1,-4,3,-4,-6], [4,-5,4,-2,4,3,-8,-6,0,-4,-4,2,1,6,-3,0,-3,4,-3,-1,4,-2,4,7]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [4,-5,3,-1,3,3,-7,-5,0,-2,-3,2,1,5,-3,1,-3,3,-3,-1,4,-2,3,5], [4,-5,3,-1,3,3,-7,-5,0,-3,-3,2,1,5,-3,1,-3,3,-2,-1,4,-2,3,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [2,-2,1,-1,1,1,-3,-2,0,-1,-1,1,0,3,-2,1,-2,1,-1,0,2,-1,2,2], [3,-3,2,-1,2,2,-5,-4,0,-2,-2,1,1,3,-2,0,-2,2,-1,0,3,0,2,3], [2,-2,1,-1,1,1,-3,-2,0,-1,-1,1,0,2,-1,1,-2,1,-1,0,2,-1,2,2], [4,-5,4,-2,3,3,-9,-6,0,-3,-4,2,1,7,-4,1,-4,4,-3,-1,5,-2,5,7], [-1,2,-1,0,-1,-1,3,2,0,1,1,-1,-1,-2,1,0,1,-1,1,0,-2,1,0,-2], [-1,2,-1,0,-1,-1,2,2,0,1,1,-1,0,-2,1,0,1,-1,1,0,-2,1,0,-2], [-1,2,-1,0,-1,-1,2,2,0,1,1,-1,-1,-2,1,0,1,-1,1,0,-1,1,0,-2], [8,-10,6,-3,6,5,-15,-10,1,-6,-7,3,3,12,-7,1,-6,6,-6,-1,9,-4,7,13], [8,-9,6,-3,5,5,-14,-10,1,-5,-6,3,2,11,-7,1,-7,6,-5,-1,9,-4,7,11], [8,-10,6,-3,6,5,-15,-10,1,-6,-8,3,3,12,-7,1,-6,7,-6,-1,9,-4,7,13], [7,-8,4,-1,4,4,-12,-8,1,-4,-5,3,2,10,-6,2,-6,5,-5,-1,7,-4,5,9], [5,-5,3,-1,2,2,-8,-5,1,-2,-3,2,1,7,-5,2,-5,3,-3,-1,5,-3,4,6], [-3,5,-3,1,-3,-2,6,4,0,2,3,-1,-1,-6,3,0,3,-3,3,1,-4,3,-3,-6], [2,-2,1,0,1,1,-3,-2,0,-1,-1,1,0,2,-2,1,-2,1,-1,0,2,-1,2,2], [5,-5,2,-1,2,3,-8,-5,1,-2,-3,2,1,7,-5,2,-5,3,-3,-1,5,-3,4,6], [2,-3,2,-1,2,1,-4,-3,0,-2,-2,1,1,2,-1,0,-1,2,-1,0,2,0,2,3], [-2,3,-1,0,-1,-1,4,2,-1,1,2,-1,-1,-4,3,-1,2,-1,2,0,-3,2,-1,-4], [10,-12,7,-3,6,6,-19,-12,1,-6,-8,4,3,16,-10,3,-10,8,-7,-2,12,-6,9,15], [-6,8,-5,2,-4,-4,12,8,-1,4,5,-3,-2,-10,6,-1,6,-5,5,1,-8,4,-5,-10]]]], [ # Q-class [24][57] [[8], [-4,8], [0,-2,8], [0,2,-4,8], [-4,0,-2,0,8], [0,0,0,-4,-2,8], [0,-4,2,0,2,-4,8], [4,0,2,-2,-2,0,0,8], [-2,2,0,0,4,0,0,2,8], [2,-2,4,0,0,-2,2,4,4,8], [-2,0,2,2,2,-4,4,0,2,4,8], [0,0,0,0,2,0,2,4,4,4,4,8], [4,-2,0,0,-2,0,0,2,-1,1,-1,0,8], [-2,4,-1,1,0,0,-2,0,1,-1,0,0,-4,8], [0,-1,4,-2,-1,0,1,1,0,2,1,0,0,-2,8], [0,1,-2,4,0,-2,0,-1,0,0,1,0,0,2,-4,8], [-2,0,-1,0,4,-1,1,-1,2,0,1,1,-4,0,-2,0,8], [0,0,0,-2,-1,4,-2,0,0,-1,-2,0,0,0,0,-4,-2,8], [0,-2,1,0,1,-2,4,0,0,1,2,1,0,-4,2,0,2,-4,8], [2,0,1,-1,-1,0,0,4,1,2,0,2,4,0,2,-2,-2,0,0,8], [-1,1,0,0,2,0,0,1,4,2,1,2,-2,2,0,0,4,0,0,2,8], [1,-1,2,0,0,-1,1,2,2,4,2,2,2,-2,4,0,0,-2,2,4,4,8], [-1,0,1,1,1,-2,2,0,1,2,4,2,-2,0,2,2,2,-4,4,0,2,4,8], [0,0,0,0,1,0,1,2,2,2,2,4,0,0,0,0,2,0,2,4,4,4,4,8]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,1,1,1,0,-1,2,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,1,0,1,0,1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,-1,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,-1,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,-1,0,0,1,0,0,0,1,1,-1,0,0,1,0,0,-1,0,0,0,-1,-1,1], [0,-1,1,0,-1,-1,-1,0,1,-2,0,1,0,1,-1,0,1,1,1,0,-1,2,0,-1], [1,1,0,-1,0,-1,0,-1,0,0,0,1,-1,-1,0,1,0,1,0,1,0,0,0,-1], [0,0,0,1,1,1,1,1,0,0,0,-1,0,0,0,-1,-1,-1,-1,-1,0,0,0,1], [-1,-1,-1,-1,-1,-1,-1,0,0,0,1,0,1,1,1,1,1,1,1,0,0,0,-1,0], [0,0,-1,-1,0,0,0,0,0,1,0,-1,0,0,1,1,0,0,0,0,0,-1,0,1], [0,0,-1,-1,-1,-1,0,0,1,0,0,0,0,0,1,1,1,1,0,0,-1,0,0,0], [0,0,-1,-1,-1,0,0,0,1,0,1,-1,0,0,1,1,1,0,0,0,-1,0,-1,1], [0,0,-1,-1,-1,0,0,0,0,0,1,0,0,0,1,1,1,0,0,0,0,0,-1,0], [0,0,-1,-1,0,0,0,1,0,0,1,-1,0,0,1,1,0,0,0,-1,0,0,-1,1]], [[-2,-2,-1,0,-1,-1,-1,1,0,0,0,0,2,2,1,0,1,1,1,-1,0,0,0,0], [1,1,1,1,1,1,1,0,0,0,0,0,-1,-1,-1,-1,-1,-1,-1,0,0,0,0,0], [0,0,0,-1,0,-1,0,-1,0,0,-1,1,0,0,0,1,0,1,0,1,0,0,1,-1], [0,0,0,0,0,0,0,1,0,0,1,-1,0,0,0,0,0,0,0,-1,0,0,-1,1], [1,1,0,0,1,1,0,0,0,0,1,-1,-1,-1,0,0,-1,-1,0,0,0,0,-1,1], [0,0,1,1,0,0,0,0,0,-1,-1,1,0,0,-1,-1,0,0,0,0,0,1,1,-1], [0,0,-1,-1,0,0,0,0,0,1,0,-1,0,0,1,1,0,0,0,0,0,-1,0,1], [-1,-1,-1,0,0,0,0,1,0,0,0,0,1,1,1,0,0,0,0,-1,0,0,0,0], [1,1,0,0,1,0,0,0,0,0,0,0,-1,-1,0,0,-1,0,0,0,0,0,0,0], [0,0,-1,-1,0,-1,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0], [0,1,-1,-1,0,0,1,0,0,1,0,-1,0,-1,1,1,0,0,-1,0,0,-1,0,1], [0,1,-1,0,1,1,1,1,-1,1,0,-1,0,-1,1,0,-1,-1,-1,-1,1,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,2,2,1,0,1,1,1,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,-1,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,-1,-1,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,1,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,0,0,-1,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,-1,-1,-1,1,-1,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,-1,-1,-1,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,0,0,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,-1,0,1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,-1,0,-1,0,1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,1,0,0,-1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,-1,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,0,1,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,-1,0,1,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,0,0,-1,0,1,-1,0,0]]]], [ # Q-class [24][58] [[6], [3,6], [3,3,6], [2,3,3,6], [3,3,3,3,6], [3,3,3,2,3,6], [3,3,2,3,3,2,6], [2,3,2,3,3,3,3,6], [2,1,1,2,2,1,2,1,6], [1,1,1,1,1,1,1,0,2,6], [3,2,2,3,3,3,3,3,0,1,6], [3,2,3,3,2,2,3,3,2,0,3,6], [2,3,3,3,2,3,3,3,0,1,3,3,6], [3,3,3,3,3,3,3,2,1,1,3,3,3,6], [1,1,2,1,1,2,1,1,3,2,1,2,0,1,6], [2,1,2,1,1,1,2,1,3,1,0,1,1,2,3,6], [3,3,3,2,3,3,3,3,0,0,2,3,3,3,0,0,6], [3,3,3,3,2,3,3,3,1,1,3,3,3,2,1,1,2,6], [2,1,2,1,1,1,1,1,1,1,1,1,2,2,0,3,0,0,6], [2,2,0,2,2,0,2,0,2,1,2,1,0,2,2,2,0,0,2,6], [0,0,1,1,1,1,0,1,0,2,1,1,1,1,-1,0,1,0,2,0,6], [3,3,3,3,3,3,2,3,1,0,3,3,2,3,1,0,3,3,0,1,1,6], [3,0,1,-1,0,1,0,-1,1,2,1,1,-1,0,3,1,0,0,1,2,0,1,6], [2,3,2,2,3,3,3,3,2,0,2,3,3,2,2,1,3,2,1,1,-1,3,0,6]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,1,-3,1,1,-2,0,-2,0,-1,1,-1,0,0,4,-1,2,1,3,-3,0,1,-1,-1], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,-2,4,-1,-2,1,0,3,0,1,-1,0,0,1,-3,0,-2,-1,-3,3,0,-1,0,2], [1,0,0,0,0,-1,0,0,0,-1,0,-1,0,1,1,-1,0,1,0,0,1,-1,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,-2,0,1,-2,0,-1,0,-1,0,-1,1,1,3,-1,0,1,1,-2,1,0,0,0], [2,1,-3,0,1,-2,1,-2,0,-1,0,-1,0,0,5,-2,1,1,3,-3,1,1,-2,-1], [0,-1,4,-1,-2,2,0,2,0,1,0,1,-1,0,-4,1,-2,-1,-3,3,0,-1,0,2], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,-1,0], [1,1,-2,0,1,-1,1,-1,-1,0,0,0,0,0,3,-1,0,0,2,-2,0,1,-1,-1], [0,0,0,0,0,0,0,1,0,0,0,0,0,1,-1,0,-1,0,-1,0,0,-1,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [2,1,-3,1,1,-2,1,-2,0,-2,0,-2,1,0,5,-2,1,1,3,-3,1,1,-1,-1], [1,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0], [1,2,-5,1,2,-2,1,-4,-1,-1,1,0,0,-1,6,-1,2,1,4,-4,0,2,-2,-2], [0,0,1,-1,-1,0,0,1,1,0,0,0,0,0,-1,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [1,1,-3,0,1,-1,1,-2,-1,0,0,0,0,-1,4,-1,1,0,3,-2,0,2,-2,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,-4,1,2,-2,0,-2,0,-1,0,-1,1,0,4,-1,2,1,3,-3,0,1,0,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,0,0,0,1,0], [0,0,0,0,0,1,0,0,0,1,0,1,0,-1,-1,1,0,-1,0,0,-1,1,0,-1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,0,0,-1,0,0,0,0,0,-1,1,0,1,0,1,0,0,1,-1,-1], [1,3,-7,1,3,-3,1,-5,0,-2,2,-1,1,-2,8,-1,4,1,6,-6,0,3,-2,-4], [-2,-2,5,-1,-2,2,-1,4,1,1,0,0,0,1,-7,2,-2,-1,-5,4,0,-2,3,3], [0,-1,3,-1,-1,2,0,2,0,1,-1,1,0,0,-4,1,-2,-1,-3,3,0,-1,1,1], [0,2,-4,1,2,-1,0,-3,0,-1,1,0,0,-1,3,0,2,1,3,-3,0,1,0,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [2,2,-6,1,3,-3,1,-4,0,-2,1,-2,1,-1,8,-2,3,1,5,-5,1,2,-2,-3], [4,3,-10,2,4,-5,2,-7,-1,-3,1,-3,2,-2,14,-4,5,2,9,-8,1,4,-4,-5], [1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,-4,1,2,-2,1,-3,-1,-1,0,-1,1,-1,5,-1,2,1,4,-3,0,2,-1,-2], [1,0,-1,0,1,0,1,-1,-1,0,0,0,0,-1,2,0,0,0,1,-1,0,1,-1,-1], [-2,-1,3,0,-1,2,-1,2,0,1,0,1,0,0,-5,2,-1,-1,-3,3,-1,-1,2,1], [-1,-1,3,-1,-1,2,-1,2,0,2,0,2,-1,0,-5,2,-1,-1,-3,3,-1,-1,1,1], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,-2,0,1,-1,0,-2,0,0,1,0,0,-1,2,0,1,0,2,-2,0,1,-1,-1]]]], [ # Q-class [24][59] [[4], [-1,4], [0,-1,4], [-1,0,0,4], [-1,1,-2,1,4], [-2,0,0,1,1,4], [0,0,0,0,0,0,4], [-1,1,-2,1,1,1,-1,4], [-1,-1,-1,1,1,1,0,1,4], [1,0,1,-2,-1,0,0,-1,-2,4], [1,0,1,-1,-1,0,1,-2,-1,1,4], [-2,1,-1,0,1,2,0,2,1,0,-2,4], [0,0,0,0,1,1,0,1,0,1,-2,2,4], [1,-1,1,0,-1,-2,-1,-1,0,0,1,-2,-2,4], [1,0,-1,-1,0,-1,-1,0,1,-1,0,0,-1,1,4], [-1,2,-1,0,1,0,0,1,1,-2,0,1,-1,0,1,4], [1,1,-2,1,1,0,1,2,0,-1,-1,1,1,-1,0,1,4], [-1,-1,2,0,-1,0,1,-2,1,-1,1,-1,-2,1,0,1,-2,4], [0,0,0,-2,0,-1,0,-1,-1,2,1,-1,-1,1,0,-1,-2,0,4], [1,0,-1,1,0,-1,1,0,1,-2,-1,0,0,0,2,1,2,0,-2,4], [-1,1,-1,-1,1,1,0,0,1,-1,0,1,-1,-1,2,2,0,1,0,1,4], [0,2,-1,0,0,0,0,2,-1,0,-2,2,2,-2,0,1,2,-2,-1,1,0,4], [1,1,-1,-1,0,-1,-1,0,1,-1,1,-1,-1,1,2,2,0,0,0,1,1,0,4], [1,-1,2,-2,-2,-1,0,-2,-2,2,2,-2,-1,1,-1,-1,-2,1,2,-2,-1,-1,0,4]], [[[1,1,-1,1,0,0,0,1,0,0,0,1,1,0,0,0,-1,1,0,1,0,-1,0,2], [0,0,0,0,0,0,-1,0,0,-1,1,0,1,0,0,-1,1,1,1,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,-1,0,1], [0,0,0,0,-1,1,0,-1,0,0,-1,-1,0,-1,1,1,1,0,1,-1,-1,-1,0,-1], [0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,-1,0,1,0,0,0,1,0,-1], [-1,-1,0,-1,0,0,0,-1,0,0,0,-1,-1,0,0,0,0,-1,-1,-1,0,1,0,-1], [0,0,1,0,0,0,0,0,0,0,-1,0,-1,-1,0,1,0,-1,0,0,-1,-1,0,0], [0,0,0,-1,0,0,-1,0,0,-1,1,0,0,0,-1,-1,0,1,1,1,0,1,0,-1], [0,0,0,-1,0,1,0,0,0,0,0,-1,-1,0,0,1,-1,-1,0,1,-1,0,-1,-1], [0,0,0,0,1,-1,0,1,0,0,1,1,0,1,-1,-2,0,1,-1,0,1,1,1,1], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [-1,-1,1,-1,0,0,0,0,0,0,0,-1,-1,0,0,0,0,-1,0,0,0,1,0,-1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,0,1,0,0,1,0,0,0,1,0,0,0,-1,0,1,0,1,0,-1,0,1], [1,0,0,0,0,1,1,1,-1,0,-1,0,0,0,0,1,-2,-1,0,1,0,-1,0,0], [0,0,0,0,0,0,-1,0,0,-1,1,0,1,0,0,0,0,0,1,1,0,0,-1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0,0,1,1,1,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,-1,-1,0], [0,0,0,0,1,-1,0,1,0,0,1,1,0,1,-1,-2,0,1,-1,0,1,1,1,0], [1,0,0,1,-1,1,1,0,-1,0,-2,0,0,-1,1,2,-1,-1,1,0,-1,-2,0,0], [0,-1,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,-1,-1,0,0,0,0,0,-1], [0,0,0,0,-1,0,0,0,0,-1,0,0,1,0,0,0,0,0,1,0,0,0,0,0], [1,1,-1,0,0,1,0,0,0,-1,0,0,1,1,0,0,-1,0,0,1,0,0,-1,1], [0,0,0,0,1,-1,0,0,1,0,1,1,0,1,-1,-1,0,0,-1,0,1,1,0,1]], [[1,1,-1,1,0,0,0,0,0,-1,0,1,1,1,0,-1,0,1,0,0,1,0,0,2], [0,0,0,0,1,-1,-1,1,0,0,2,1,0,0,-1,-2,0,2,0,1,0,1,0,0], [0,1,0,0,0,0,1,0,0,0,-1,0,0,0,1,0,0,-1,-1,-1,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1], [-1,-1,0,0,0,0,-1,0,0,1,1,-1,0,0,0,0,1,1,0,0,0,1,0,-1], [0,0,1,-1,0,1,0,0,0,0,-1,-1,-1,-1,0,1,0,-1,0,0,-1,-1,0,-1], [0,1,0,-1,0,0,-1,0,1,-1,1,0,0,1,-1,-1,0,0,0,1,0,1,-1,0], [0,-1,1,-1,1,0,0,1,0,0,1,0,-1,0,-1,0,-1,0,0,1,0,1,0,-1], [0,-1,0,0,-1,1,1,0,-1,0,-1,-1,0,0,0,2,-1,-2,0,0,0,-1,0,-1], [0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1,0,1], [1,1,0,1,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,-1,0,1], [-1,-1,1,-1,0,0,0,0,0,0,0,-1,-1,-1,0,1,0,-1,0,0,-1,0,0,-1], [-1,0,0,-1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,1,0,0,1,0,0,1,-1,0,0,0,1,1,0,-1,0,0,0,-1,0,1], [0,-1,0,1,0,0,1,0,-1,0,-1,0,0,0,1,0,0,0,0,-1,0,0,1,0], [0,-1,0,0,1,-1,-1,1,0,0,2,1,0,0,-1,-1,0,1,0,1,0,1,0,0], [0,0,0,-1,1,0,-1,0,1,-1,2,0,0,1,-1,-1,0,1,0,1,0,2,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,-1,1,0,1,1,0,-1,0,1,0,0,0,1,0,0], [0,-1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1,0,1,0,-1], [0,0,0,-1,1,-1,-1,1,0,-1,2,1,0,0,-1,-2,0,2,0,1,0,1,0,0], [1,0,-1,1,0,0,0,1,-1,0,0,1,1,0,0,0,-1,1,0,1,0,-1,0,1], [1,1,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,-1,0,1]]]], [ # Q-class [24][60] [[4], [0,4], [1,1,4], [1,1,0,4], [1,1,1,1,4], [1,1,0,1,1,4], [1,1,1,1,1,1,4], [1,1,1,1,0,1,1,4], [0,1,1,1,1,0,1,1,4], [1,1,1,1,1,1,1,1,0,4], [1,0,1,0,1,0,-1,0,1,0,4], [0,1,-1,0,1,1,1,0,1,0,1,4], [1,1,0,0,0,1,1,1,-1,1,0,1,4], [1,0,1,1,0,1,1,0,0,0,0,1,1,4], [1,1,1,0,1,0,0,0,1,1,1,1,1,1,4], [1,1,0,1,0,1,-1,1,0,0,1,1,1,0,1,4], [0,1,-1,1,0,1,0,0,1,0,1,1,1,1,1,1,4], [1,1,1,1,1,0,1,1,0,1,1,1,1,1,1,1,0,4], [1,-1,0,1,1,1,0,1,1,0,1,1,0,1,0,1,0,1,4], [1,0,1,1,0,0,1,1,0,-1,0,0,1,1,0,1,0,0,1,4], [0,1,1,1,0,1,1,0,0,0,1,1,0,1,1,1,1,1,-1,1,4], [-1,1,1,0,0,0,1,1,1,0,0,1,0,1,0,0,1,0,1,1,1,4], [1,1,1,0,0,1,1,0,0,-1,-1,0,1,1,0,1,0,0,0,1,0,0,4], [0,1,1,1,1,-1,1,0,1,1,1,1,1,0,1,1,0,1,1,1,0,1,0,4]], [[[-1,-2,1,3,-1,3,1,-1,-1,-1,2,1,-1,-1,2,1,-1,2,-4,1,-5,3,0,-1], [0,0,3,1,-1,0,0,0,-1,-1,-1,2,0,-1,0,0,1,0,0,0,-1,-1,-1,0], [-1,-1,0,1,0,1,1,-1,0,0,1,0,0,0,1,1,-1,1,-2,1,-2,1,0,-1], [0,1,3,1,-1,-1,1,0,-2,-1,-1,2,0,-1,0,0,1,-1,2,-1,0,-1,-1,-1], [0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,1,-1,1,-1,0,0,0], [0,1,-1,0,0,0,0,0,0,0,1,-1,0,1,0,0,-1,0,0,0,0,0,0,0], [-1,0,2,2,-1,0,2,-1,-1,-1,1,1,0,-1,1,1,0,0,0,0,-2,0,-1,-2], [-1,0,-1,0,0,0,1,0,0,0,1,-1,0,1,0,1,-1,0,0,0,0,0,0,0], [-1,1,0,0,0,-1,2,0,-1,0,1,0,0,0,0,1,0,-1,1,0,0,-1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,1,-2,-1,0,0,1,0,1,0,1,-2,0,1,0,1,-1,0,0,0,0,0,0,0], [0,-1,-1,0,0,1,0,0,1,0,1,-1,0,1,0,1,-1,1,-2,0,-1,1,0,0], [0,-1,-3,0,0,3,0,-1,2,0,2,-2,0,1,1,1,-3,2,-4,1,-2,3,0,0], [0,-1,-1,0,0,2,0,-1,1,0,1,-1,0,0,0,1,-1,2,-3,1,-2,2,0,0], [0,0,-1,0,0,0,1,0,0,0,1,-1,0,1,0,1,-1,0,-1,0,-1,1,0,0], [1,-1,1,1,-1,2,-1,0,0,-1,0,1,0,-1,0,-1,0,1,-2,0,-1,1,0,1], [0,-1,-2,0,0,2,0,-1,2,0,1,-1,0,1,0,1,-2,2,-3,1,-2,2,0,0], [0,0,-5,-1,1,1,0,0,2,1,2,-3,0,2,0,1,-3,1,-2,1,0,2,1,0], [0,-1,2,2,-1,1,1,-1,-1,-1,0,1,0,-1,1,1,0,0,-1,0,-2,1,-1,-1], [0,1,3,1,-1,-1,1,-1,-1,-1,-1,1,1,-1,0,0,1,-1,2,-1,0,-1,-1,-1], [0,0,-1,0,0,0,0,0,1,0,0,-1,1,0,0,0,-1,0,0,0,1,0,0,0], [-1,-2,-1,2,-1,3,1,-1,0,0,3,0,-1,0,2,1,-2,2,-5,2,-5,3,0,-1], [0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,2,0,0,-1,0,0,-1,-1,-2,1,0,-1,0,0,1,-1,2,-1,1,-1,-1,0], [1,-2,1,2,-1,3,-2,0,0,-1,0,2,-1,-1,1,-1,0,2,-4,1,-3,2,0,1], [1,-2,-3,0,0,4,-2,0,2,0,1,-1,-1,0,1,-1,-2,3,-5,2,-2,3,1,2], [0,1,-2,-1,0,0,0,0,1,1,1,-1,0,1,0,0,-1,0,0,1,0,0,0,0], [1,0,1,0,0,0,-1,0,0,0,-1,1,0,-1,0,-1,1,0,0,0,0,0,0,0], [1,1,-3,-2,1,0,-1,0,2,1,0,-2,0,2,-1,0,-1,0,0,0,2,0,0,1], [0,-1,-1,1,0,2,0,0,0,0,1,0,-1,0,1,0,-1,1,-3,1,-2,2,0,0], [1,1,1,-1,0,-1,-1,1,0,0,-2,1,0,0,-1,-1,1,-1,2,-1,2,-2,0,1], [0,0,-5,-1,1,1,0,0,2,1,2,-3,0,2,0,1,-3,1,-2,1,0,2,1,0], [0,0,-2,0,0,1,-1,0,1,1,1,-1,0,0,0,-1,-1,1,-1,1,0,1,1,0], [1,1,0,-1,0,0,-1,0,0,0,-1,0,0,0,-1,-1,1,0,1,0,1,-1,0,1], [1,0,3,1,-1,0,-1,0,-1,-1,-2,2,0,-2,0,-1,2,0,1,0,0,-1,-1,0], [0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,1,-1,1,-1,0,0,0], [0,1,-1,0,0,0,0,0,0,0,1,-1,0,1,0,0,-1,0,0,0,0,0,0,0], [0,0,-2,0,0,1,0,0,1,0,1,-1,0,1,0,0,-1,1,-2,1,-1,1,0,0], [1,1,-2,-2,1,-1,-2,1,1,1,-1,-1,0,1,-1,-1,0,0,1,0,3,-1,1,1], [1,-1,-1,0,0,2,-2,0,1,0,0,0,0,0,0,-1,-1,1,-2,1,0,1,0,1], [1,-1,3,2,-1,2,-1,-1,-1,-2,-1,2,0,-2,1,-1,1,1,-1,0,-2,1,-1,0], [0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1], [1,1,2,0,0,-1,-1,0,0,-1,-2,1,1,-1,-1,-1,1,-1,2,-1,2,-1,-1,0], [0,0,3,2,-1,0,1,-1,-2,-1,0,2,0,-2,1,0,1,0,0,0,-2,0,-1,-1], [1,-1,1,1,0,2,-2,0,0,-1,-1,1,0,-1,0,-1,0,1,-2,0,-1,1,0,1]]]], [ # Q-class [24][61] [[4], [2,4], [2,0,4], [-2,-1,-2,4], [-1,-2,-1,2,4], [2,1,2,-1,0,4], [2,2,1,-2,-1,0,4], [1,-1,2,0,1,0,1,4], [0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,2,4], [0,0,0,0,0,0,0,0,2,0,4], [0,0,0,0,0,0,0,0,-2,-1,-2,4], [0,0,0,0,0,0,0,0,-1,-2,-1,2,4], [0,0,0,0,0,0,0,0,2,1,2,-1,0,4], [0,0,0,0,0,0,0,0,2,2,1,-2,-1,0,4], [0,0,0,0,0,0,0,0,1,-1,2,0,1,0,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-1,-2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2,-1,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,2,-1,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,1,-2,-1,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,2,0,1,0,1,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,-1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,-1,0,1,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0]], [[-1,0,-1,0,-1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [24][62] [[4], [2,4], [2,2,4], [2,2,2,4], [2,1,1,1,4], [1,2,1,1,2,4], [1,1,2,1,2,2,4], [1,1,1,2,2,2,2,4], [2,1,1,1,2,1,1,1,4], [1,2,1,1,1,2,1,1,2,4], [1,1,2,1,1,1,2,1,2,2,4], [1,1,1,2,1,1,1,2,2,2,2,4], [2,1,1,1,2,1,1,1,2,1,1,1,4], [1,2,1,1,1,2,1,1,1,2,1,1,2,4], [1,1,2,1,1,1,2,1,1,1,2,1,2,2,4], [1,1,1,2,1,1,1,2,1,1,1,2,2,2,2,4], [2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,4], [1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,2,4], [1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,2,2,4], [1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,2,2,2,4], [2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,4], [1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,2,4], [1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,2,2,4], [1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,2,2,2,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1], [-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0], [-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,1,0,-1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,-1], [0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,1,-1,0,0], [0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,1,0,-1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1], [0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0], [0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1]]]], [ # Q-class [24][63] [[8], [4,8], [4,4,8], [4,4,4,8], [0,0,0,0,8], [0,0,0,0,4,8], [0,0,0,0,4,4,8], [0,0,0,0,4,4,4,8], [4,2,2,2,-4,-2,-2,-2,8], [2,4,2,2,-2,-4,-2,-2,4,8], [2,2,4,2,-2,-2,-4,-2,4,4,8], [2,2,2,4,-2,-2,-2,-4,4,4,4,8], [4,2,2,2,2,1,1,1,2,1,1,1,8], [2,4,2,2,1,2,1,1,1,2,1,1,4,8], [2,2,4,2,1,1,2,1,1,1,2,1,4,4,8], [2,2,2,4,1,1,1,2,1,1,1,2,4,4,4,8], [2,1,1,1,-2,-1,-1,-1,2,1,1,1,4,2,2,2,8], [1,2,1,1,-1,-2,-1,-1,1,2,1,1,2,4,2,2,4,8], [1,1,2,1,-1,-1,-2,-1,1,1,2,1,2,2,4,2,4,4,8], [1,1,1,2,-1,-1,-1,-2,1,1,1,2,2,2,2,4,4,4,4,8], [0,0,0,0,-2,-1,-1,-1,4,2,2,2,2,1,1,1,4,2,2,2,8], [0,0,0,0,-1,-2,-1,-1,2,4,2,2,1,2,1,1,2,4,2,2,4,8], [0,0,0,0,-1,-1,-2,-1,2,2,4,2,1,1,2,1,2,2,4,2,4,4,8], [0,0,0,0,-1,-1,-1,-2,2,2,2,4,1,1,1,2,2,2,2,4,4,4,4,8]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,-1,0,0,1,-1,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,-1,0,1,0,-1,0,-1,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,-1,1,0,0,-1,-1,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,-1,1,0,0,0,0,0,0,1,-1,0,0,1,-1,0,0,0,0,0,0,-1,1], [0,-1,0,1,0,0,0,0,0,1,0,-1,0,1,0,-1,0,0,0,0,0,-1,0,1], [-1,0,0,1,0,0,0,0,1,0,0,-1,1,0,0,-1,0,0,0,0,-1,0,0,1], [0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,-1,1,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,1,-1,0,0,-1,1], [0,-1,0,1,0,0,0,0,0,1,0,-1,0,0,0,0,0,1,0,-1,0,-1,0,1], [-1,0,0,1,0,0,0,0,1,0,0,-1,0,0,0,0,1,0,0,-1,-1,0,0,1]], [[-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,1,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,-1,0,0,0,1,0,0,0,-1,0,0,0,1,0,0,0], [0,0,0,0,-1,0,0,1,-1,0,0,1,1,0,0,-1,-1,0,0,1,1,0,0,-1], [0,0,0,0,-1,1,0,0,-1,1,0,0,1,-1,0,0,-1,1,0,0,1,-1,0,0], [0,0,0,0,-1,0,1,0,-1,0,1,0,1,0,-1,0,-1,0,1,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0], [1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [1,0,0,-1,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,-1], [1,-1,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,1,-1,0,0], [1,0,-1,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,1,0,-1,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [1,0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0], [0,1,0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0,-1,0,0,0,1,0,0], [0,0,1,0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,1,0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [24][64] [[12], [3,12], [6,4,12], [4,6,6,12], [6,2,4,1,12], [6,2,6,4,4,12], [6,2,4,3,3,6,12], [4,6,6,6,3,6,6,12], [6,6,6,4,6,3,3,4,12], [3,6,6,6,3,2,1,4,6,12], [6,3,6,3,6,4,6,6,4,4,12], [4,4,4,2,1,6,3,2,2,-2,1,12], [1,0,1,-1,4,3,2,-1,2,1,2,3,12], [2,1,1,0,2,1,2,-2,1,3,4,1,6,12], [1,4,4,-2,3,2,1,2,2,2,4,4,4,3,12], [0,3,1,1,2,1,-1,-1,3,2,2,2,6,6,6,12], [3,1,4,-2,6,2,1,0,3,1,4,3,6,4,6,6,12], [3,2,2,-2,2,6,3,0,2,0,0,6,6,2,6,4,6,12], [2,2,2,0,2,4,1,-2,1,2,1,2,2,4,6,6,4,6,12], [4,2,6,2,6,3,4,3,6,4,6,2,2,2,6,4,6,3,4,12], [-1,4,0,2,0,2,2,-2,1,2,-1,4,4,2,4,6,2,6,6,1,12], [1,3,1,2,2,4,4,2,3,-1,2,4,3,6,2,4,3,3,3,3,2,12], [2,0,4,2,3,6,4,2,0,-2,2,4,2,0,4,3,1,2,6,3,4,3,12], [4,1,3,1,4,1,4,2,3,0,6,2,4,2,4,2,6,3,1,6,2,4,2,12]], [[[-2,1,0,0,1,1,2,-2,0,1,-1,1,-1,0,0,1,0,0,0,-1,-2,-1,0,2], [-1,0,-1,0,0,0,0,0,1,1,0,1,-1,1,-1,0,0,1,0,0,-1,-1,1,1], [-2,1,-1,0,1,1,2,-2,0,2,-1,1,-2,0,0,2,0,1,-1,-1,-3,-1,1,2], [0,1,0,-1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0], [-2,1,0,0,1,1,2,-2,0,1,-1,1,-1,0,0,2,-1,0,0,-1,-2,-1,0,2], [0,1,0,-1,0,1,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0,0,0,0,1], [-1,1,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [-1,1,-1,0,0,1,0,-1,1,0,0,0,-1,1,0,0,0,1,-1,0,-1,-1,1,1], [-3,1,-1,1,1,1,2,-2,1,1,-1,1,-2,1,0,1,0,1,0,-1,-3,-2,1,2], [-1,1,-1,0,0,0,1,-1,0,1,0,1,-1,0,-1,1,0,1,0,0,-2,-1,1,1], [-2,1,0,0,1,1,2,-2,0,1,-1,1,-1,0,0,2,-1,1,0,-1,-3,-1,0,2], [0,0,0,-1,0,1,0,0,0,1,-1,0,0,0,0,0,0,-1,0,0,0,0,0,1], [-1,1,0,0,0,2,1,-1,0,0,-1,0,0,0,0,1,0,-1,0,0,-1,-1,0,1], [-1,0,0,0,0,1,1,0,0,0,-1,1,0,0,0,1,0,-1,1,0,-1,-1,-1,1], [-1,0,0,0,1,1,1,-1,0,1,-1,1,-1,0,0,2,-1,0,0,-1,-2,-1,0,2], [-1,0,0,0,1,1,1,0,0,0,-1,1,0,0,0,1,-1,-1,1,0,-1,-1,-1,1], [-2,0,0,0,1,1,2,-1,0,1,-1,1,-1,0,0,2,-1,0,0,-1,-2,-1,0,2], [0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,1,-1,1,0,0,1,-1,0,-1,1,0,0,-1,1,-1,-1,1,0,0,0,-1,1], [-2,1,0,0,1,1,2,-2,0,1,-1,1,-1,0,0,2,-1,0,0,-1,-3,-1,0,2], [1,0,1,-1,0,0,-1,1,-1,0,0,0,1,-1,-1,0,-1,-1,1,1,1,1,-1,0], [-1,0,0,0,0,1,0,1,1,-1,-1,0,0,1,0,0,0,-1,1,0,0,-1,-1,1], [0,1,1,-1,1,1,0,0,-1,0,-1,0,0,0,0,1,-1,-1,0,0,0,0,-1,1], [-2,1,1,0,1,2,2,-2,0,0,-1,0,-1,0,0,2,-1,0,0,-1,-2,-1,-1,2]], [[0,0,1,-1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0], [-1,0,0,0,1,1,1,-1,0,1,-1,0,-1,0,0,1,0,0,0,-1,-1,0,0,1], [0,0,0,-1,0,0,0,0,0,1,0,0,-1,0,-1,1,0,1,-1,0,0,0,1,0], [0,0,1,-1,1,-1,0,0,-1,1,0,0,0,-1,-1,1,-1,1,0,0,0,1,0,0], [0,0,1,-1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,1,-1,0,0,-1,1,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0], [1,0,1,-1,-1,0,-2,1,0,-1,1,-1,1,0,-1,-1,0,0,0,1,2,1,0,-1], [0,0,1,-1,0,0,0,0,-1,1,0,0,0,-1,-1,1,0,0,0,0,0,1,0,0], [0,0,0,-1,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [-1,0,0,0,1,0,1,-1,0,1,0,0,-1,0,0,1,0,1,-1,-1,-1,0,1,0], [0,0,1,-1,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [-1,0,0,0,0,1,0,0,1,0,-1,0,-1,1,0,0,0,0,0,0,0,-1,0,1], [-1,0,0,0,0,0,0,0,1,0,0,0,-1,1,0,0,0,1,0,-1,-1,-1,1,1], [0,-1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0], [-1,0,0,0,0,1,1,0,1,0,-1,0,-1,1,0,1,0,0,0,-1,-1,-1,0,1], [0,-1,0,0,0,-1,0,1,1,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0], [-1,0,0,0,0,1,1,-1,1,0,0,0,-1,0,0,1,0,0,0,-1,-1,-1,0,1], [-1,0,0,0,0,1,0,0,1,0,0,0,-1,1,0,0,0,0,0,-1,0,-1,0,1], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,1,-1,0,0,0,0,0,0,0,0,0,0,-1,1,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,1,-1,0,-1,0,1,0,-1,0,0,0,0,1,0,0,0], [1,-1,1,-1,0,0,-1,1,0,0,0,0,1,-1,0,0,-1,-1,1,0,1,1,-1,0], [2,0,1,-1,-1,-1,-2,2,0,-1,0,-1,1,0,-1,-1,0,0,0,1,2,1,0,-1], [0,0,1,-1,0,0,0,0,0,0,0,0,0,0,-1,1,-1,0,0,0,0,0,0,1]]]], [ # Q-class [24][65] [[6], [3,6], [2,2,6], [2,3,3,6], [1,1,2,1,6], [2,3,3,3,2,6], [2,1,2,2,3,2,6], [3,1,3,2,1,2,2,6], [3,3,1,2,2,0,2,2,6], [3,1,1,1,2,1,3,2,3,6], [1,2,1,1,2,2,1,1,2,2,6], [2,2,1,3,2,1,1,2,3,2,2,6], [2,2,3,3,2,3,3,3,2,2,0,0,6], [3,2,3,2,3,3,2,2,1,1,2,1,2,6], [1,1,3,2,2,2,3,2,2,2,1,1,3,1,6], [2,1,1,1,2,1,1,2,2,3,3,2,2,1,2,6], [1,2,2,2,3,3,2,1,2,3,3,1,3,2,2,2,6], [1,2,3,3,3,2,1,1,2,2,2,3,2,2,2,3,3,6], [0,0,0,1,2,0,1,1,1,1,2,2,1,0,-1,3,1,1,6], [2,2,2,2,1,1,1,3,1,1,2,2,2,3,1,2,1,1,2,6], [3,2,2,2,1,3,2,3,1,2,1,1,3,2,3,3,1,1,0,2,6], [2,2,1,0,1,1,2,1,1,1,2,0,0,1,0,1,1,0,2,2,0,6], [2,1,1,1,1,0,2,1,1,1,1,1,0,1,0,0,1,0,2,2,1,3,6], [2,3,0,3,1,1,1,1,2,0,0,2,1,1,0,0,0,0,2,2,1,2,2,6]], [[[-2,0,1,0,0,-1,-1,0,-1,1,1,2,3,1,-1,1,-1,-1,-2,-2,0,1,1,1], [-2,-1,1,0,0,0,0,-1,0,0,1,2,3,0,-2,2,-1,-1,-3,-1,0,1,1,1], [-1,0,0,0,0,-1,-1,0,-1,0,1,2,3,1,0,1,-1,-1,-1,-2,0,1,1,0], [-1,-1,0,1,1,0,-1,0,0,0,1,1,2,0,-1,1,-1,-1,-2,-1,0,1,1,0], [0,0,0,0,0,-2,-1,0,-1,0,1,1,2,0,0,-1,0,0,0,-1,1,1,0,0], [-1,-1,1,0,0,0,-1,-1,0,0,1,2,3,0,-1,1,-1,-1,-2,-1,0,1,1,0], [0,0,0,0,0,-2,-1,0,-1,0,1,1,2,1,0,-1,0,0,0,-2,1,1,0,0], [-1,0,0,0,0,-1,-1,0,-1,1,1,2,3,1,0,0,-1,-1,-1,-2,0,1,1,0], [-2,0,0,0,0,-1,-1,0,-1,1,1,2,3,1,-1,1,-1,-1,-2,-2,0,1,1,1], [-2,0,1,-1,0,-1,-1,0,-1,1,1,2,3,1,-1,1,-1,-1,-2,-2,0,1,1,1], [0,-1,1,-1,0,0,0,-1,0,0,1,1,1,-1,-1,0,0,0,-1,0,1,0,0,1], [-1,0,0,1,1,-1,-1,0,-1,1,1,1,2,0,-1,1,-1,-1,-2,-1,0,1,1,0], [-1,0,0,0,0,-1,-1,0,-1,0,1,2,3,1,0,0,-1,-1,-1,-2,0,1,1,0], [0,0,0,0,0,-1,-1,0,-1,0,1,1,2,0,0,-1,0,0,0,-1,1,1,0,0], [-1,0,0,0,0,-1,-1,0,-1,0,0,2,2,1,0,1,0,-1,-1,-2,0,1,1,0], [-1,0,1,-1,0,-1,0,0,-1,0,1,2,2,0,-1,1,0,-1,-2,-1,0,0,1,1], [-1,-1,1,-1,0,0,-1,-1,0,0,1,2,3,0,-1,1,-1,-1,-2,-1,0,1,1,1], [-1,0,0,0,1,-1,-1,0,-1,0,1,2,3,0,-1,1,-1,-1,-2,-1,0,1,1,0], [0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,1,0,0,0], [0,0,0,0,0,-1,0,0,-1,0,1,1,1,0,0,-1,0,0,0,-1,1,1,0,0], [-1,0,1,0,0,0,0,0,0,0,0,1,1,0,-1,1,0,-1,-1,-1,0,0,1,0], [-1,-1,1,-1,-1,-1,0,-1,0,0,1,2,2,1,-1,0,0,0,-1,-1,1,1,0,1], [0,0,0,0,0,0,0,0,1,0,0,-1,-1,0,0,-1,0,1,1,0,1,0,0,0], [-1,-1,0,1,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,-1,0,1,1,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,-1,0,0,1,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,1,0,0,0,1,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,-1,-1,1,-1,1,0,0,0,1,1,-1,0,0,1,-1,0,0,0,0], [0,-1,1,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,-1,1,1,-1,-1,1,-1,0,0,-1,0,0,1,-1,0,0,1,0,0,0,0,-1], [0,0,0,0,0,1,0,0,1,0,-1,-1,-1,0,0,0,0,0,0,1,0,0,0,0], [0,0,1,-1,-1,-1,0,0,-1,0,1,1,1,1,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,-1,0,0,-1,0,1,0,1,0,0,-1,0,0,0,0,0,0,0,0], [1,1,0,0,0,0,0,1,-1,0,0,-1,-1,0,1,0,0,0,1,0,-1,-1,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,-1,0,1,0,1,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,-1,-1,0,-1,1,1,1,2,1,0,-1,-1,0,0,-1,0,1,0,0], [1,0,0,1,1,0,0,0,0,0,0,-1,-1,-1,0,0,0,0,0,1,0,-1,0,0], [1,0,0,1,1,0,0,0,0,0,0,-1,-1,-1,0,0,0,0,0,1,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]] ]; MakeImmutable( IMFList[24].matrices ); gap-4r6p5/grp/perf1.grp0000644000175000017500000006136212172557252013470 0ustar billbill############################################################################# ## #W perf1.grp GAP Groups Library Volkmar Felsch ## Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains the perfect groups of sizes 2-7680 ## All data is based on Holt/Plesken: Perfect Groups, OUP 1989 ## PERFGRP[1]:=[]; PERFGRP[2]:=[# 60.1 [[1,"ab", function(a,b) return [[a^2,b^3,(a*b)^5],[[b,a*b*a*b^-1*a]]]; end, [5]], "A5",[1,0,1,2,3,4,5],-1, 1,5] ]; PERFGRP[3]:=[# 120.1 [[1,"abd", function(a,b,d) return [[a^2*d^-1,b^3,(a*b)^5,d^2,d^-1*b^-1*d*b], [[a*b]]]; end, [24]], "A5 2^1",[1,1,1,2,3,4,5],-2, 1,24] ]; PERFGRP[4]:=[# 168.1 [[1,"ab", function(a,b) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4], [[b,a*b*a*b^-1*a]]]; end, [7]], "L3(2)",[8,0,1,9,10,11],-1, 2,7] ]; PERFGRP[5]:=[# 336.1 [[1,"abd", function(a,b,d) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *d^-1,d^2,d^-1*b^-1*d*b], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1]]]; end, [16]], "L3(2) 2^1 = SL(2,7)",[8,1,1,9,10,11],-2, 2,16] ]; PERFGRP[6]:=[# 360.1 [[1,"abc", function(a,b,c) return [[a^2,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1*b^-1*c *b*c*b^-1*c*b*c^-1],[[a,b]]]; end, [6]], "A6",[13,0,1,14],-1, 3,6] ]; PERFGRP[7]:=[# 504.1 [[1,"abc", function(a,b,c) return [[a^2,b^3,(a*b)^7,b^-1*(a*b)^3*c^-1,c*b^-1 *c*b*a^-1*b^-1*c^-1*b *c^-1*a],[[a,c]]]; end, [9]], "L2(8)",[16,0,1],-1, 4,9] ]; PERFGRP[8]:=[# 660.1 [[1,"ab", function(a,b) return [[a^2,b^3,(a*b)^11,(a*b)^4*(a*b^-1)^5*(a*b)^4*(a *b^-1)^5],[[b,a*b*a*b^-1*a]]]; end, [11]], "L2(11)",[17,0,1,18,19],-1, 5,11] ]; PERFGRP[9]:=[# 720.1 [[1,"abcd", function(a,b,c,d) return [[a^2*d^-1,b^3,c^3,(b*c)^4*d^-1,(b*c^-1)^5, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,d^2, d^-1*b^-1*d*b,d^-1*c^-1*d*c], [[c*b*a*d,b]]]; end, [80]], "A6 2^1",[13,1,1,14],-2, 3,80] ]; PERFGRP[10]:=[# 960.1 [[1,"abstuv", function(a,b,s,t,u,v) return [[a^2,b^3,(a*b)^5,s^2,t^2,u^2,v^2,s^-1*t^-1*s *t,u^-1*v^-1*u*v,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1], [[a,b]]]; end, [16]], "A5 2^4",[1,4,1],1, 1,16], # 960.2 [[1,"abwxyz", function(a,b,w,x,y,z) return [[a^2,b^3,(a*b)^5,w^2,x^2,y^2,z^2,w^-1*x^-1*w *x,w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*w*a*z^-1, a^-1*x*a*x^-1,a^-1*y*a*(w*x*y*z)^-1 ,a^-1*z*a*w^-1,b^-1*w*b*x^-1, b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1],[[b,a*b*a*b^-1*a,w*x]] ]; end, [10]], "A5 2^4'",[1,4,2,7],1, 1,10] ]; PERFGRP[11]:=[# 1080.1 [[1,"abc", function(a,b,c) return [[a^6,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1*b^-1*c *b*c*b^-1*c*b*c^-1],[[a^3,c*a^2]] ]; end, [18]], "A6 3^1",[13,0,1,14],-3, 3,18], # 1080.2 (otherpres.) [[1,"abcd", function(a,b,c,d) return [[a^2*d^-1,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1 *b^-1*c*b*c*b^-1*c*b*c^-1, d^3,d^-1*b^-1*d*b,d^-1*c^-1*d*c], [[a^3,c*a^2]]]; end, [18]]] ]; PERFGRP[12]:=[# 1092.1 [[1,"abc", function(a,b,c) return [[a^2,b^13,(a*b)^3,c^6,(a*c)^2,c^-1*b*c*b^(-1*4), b^6*a*b^-1*a*b*a*b^7*a*c^-1],[[b,c]]]; end, [14]], "L2(13)",[20,0,1],-1, 6,14] ]; PERFGRP[13]:=[# 1320.1 [[1,"abd", function(a,b,d) return [[a^2*d^-1,b^3,(a*b)^11,(a*b)^4*(a*b^-1)^5*(a*b) ^4*(a*b^-1)^5*d^-1,d^2, b^-1*d*b*d^-1], [[a*b,(b*a)^2*(b^-1*a)^4*b^-1*d]]]; end, [24]], "L2(11) 2^1 = SL(2,11)",[17,1,1,18,19],-2, 5,24] ]; PERFGRP[14]:=[# 1344.1 [[1,"abxyz", function(a,b,x,y,z) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,x^2,y^2, z^2,x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1],[[a,b]]]; end, [8]], "L3(2) 2^3",[8,3,1],1, 2,8], # 1344.2 [[1,"abxyz", function(a,b,x,y,z) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4*(y*z)^-1 ,x^2,y^2,z^2,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*x*a*z^-1,a^-1*y*a*(x*y*z)^-1, a^-1*z*a*x^-1,b^-1*x*b*y^-1, b^-1*y*b*(x*y)^-1,b^-1*z*b*z^-1], [[b,a*b*a*b^-1*a,x]]]; end, [14]], "L3(2) N 2^3",[8,3,2],1, 2,14], # 1344.3 (otherpres.) [[1,"abuvw", function(a,b,u,v,w) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,u^2,v^2, w^2,u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,a^-1*u*a*(v*w)^-1, a^-1*v*a*v^-1,a^-1*w*a*(u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1],[[a,b]]]; end, [8]]], # 1344.4 (otherpres.) [[1,"abuvw", function(a,b,u,v,w) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4*(u*v*w)^(-1 *1),u^2,v^2,w^2,u^-1*v^-1*u*v, u^-1*w^-1*u*w,v^-1*w^-1*v*w, a^-1*u*a*(v*w)^-1,a^-1*v*a*v^-1, a^-1*w*a*(u*v)^-1,b^-1*u*b*(u*v)^-1, b^-1*v*b*u^-1,b^-1*w*b*w^-1], [[b,a*b^-1*a*b*a,u]]]; end, [14]]] ]; PERFGRP[15]:=[# 1920.1 [[1,"abstuve", function(a,b,s,t,u,v,e) return [[a^2,b^3,(a*b)^5,s^2,t^2,u^2,v^2,e^2,s^-1*t^-1 *s*t,u^-1*v^-1*u*v,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, e^-1*a^-1*e*a,e^-1*b^-1*e*b, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v], [[a*b,b*a*b*a*b^-1*a*b^-1,s]]]; end, [12]], "A5 2^4 E 2^1",[1,5,1],2, 1,12], # 1920.2 [[1,"abstuvd", function(a,b,s,t,u,v,d) return [[a^2*d^-1,b^3,(a*b)^5,s^2,t^2,u^2,v^2,d^2,s^-1 *t^-1*s*t,u^-1*v^-1*u*v, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, b^-1*s*b*(t*v*d)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, d^-1*a^-1*d*a,d^-1*b^-1*d*b, d^-1*s^-1*d*s,d^-1*t^-1*d*t, d^-1*u^-1*d*u,d^-1*v^-1*d*v], [[a*b,s]]]; end, [24]], "A5 2^4 E N 2^1",[1,5,2],2, 1,24], # 1920.3 [[1,"abdstuv", function(a,b,d,s,t,u,v) return [[a^2*d^-1,b^3,(a*b)^5,d^2,d^-1*b^-1*d*b, s^2,t^2,u^2,v^2,s^-1*t^-1*s*t, u^-1*v^-1*u*v,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, d^-1*a^-1*d*a,d^-1*s^-1*d*s, d^-1*t^-1*d*t,d^-1*u^-1*d*u, d^-1*v^-1*d*v],[[a,b],[a*b,s]]]; end, [16,24]], "A5 2^1 x 2^4",[1,5,3],2, 1,[16,24]], # 1920.4 [[1,"abdstuv", function(a,b,d,s,t,u,v) return [[a^2*d^-1,b^3,(a*b)^5,d^2,b^-1*d*b*(d*u*v) ^-1,s^2,t^2,u^2,v^2,s^-1*t^-1*s*t, u^-1*v^-1*u*v,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, d^-1*a^-1*d*a,d^-1*s^-1*d*s, d^-1*t^-1*d*t,d^-1*u^-1*d*u, d^-1*v^-1*d*v],[[b,d]]]; end, [80]], "A5 2^1 E 2^4",[1,5,4],1, 1,80], # 1920.5 [[1,"abdwxyz", function(a,b,d,w,x,y,z) return [[a^2*d^-1,b^3,(a*b)^5,d^2,b^-1*d^-1*b*d, a^-1*d^-1*a*d,w^2,x^2,y^2,z^2,(w*x)^2, (w*y)^2,(w*z)^2,(x*y)^2,(x*z)^2,(y*z)^2, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*x*y*z)^-1,a^-1*z*a*w^-1 ,b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1, d^-1*w^-1*d*w,d^-1*x^-1*d*x, d^-1*y^-1*d*y,d^-1*z^-1*d*z], [[b,a*b*a*b^-1*a,w*x],[a*b,w]]]; end, [10,24]], "A5 2^1 x 2^4'",[1,5,5,7],2, 1,[10,24]], # 1920.6 [[1,"abdwxyz", function(a,b,d,w,x,y,z) return [[a^2*d^-1,b^3,(a*b)^5,d^2,a^-1*d^-1*a*d, b^-1*d^-1*b*d,w^2,x^2,y^2,z^2,(w*x)^2*d, (w*y)^2*d,(w*z)^2*d,(x*y)^2*d,(x*z)^2*d,(y*z)^2*d, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*x*y*z)^-1,a^-1*z*a*w^-1 ,b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1, d^-1*w^-1*d*w,d^-1*x^-1*d*x, d^-1*y^-1*d*y,d^-1*z^-1*d*z], [[b,a*b*a*b^-1*a^-1*w*x]]]; end, [80]], "A5 2^4' C N 2^1",[1,5,6,7],2, 1,80], # 1920.7 [[1,"abwxyze", function(a,b,w,x,y,z,e) return [[a^2,b^3,(a*b)^5,e^2,a^-1*e^-1*a*e,b^-1 *e^-1*b*e,w^2,x^2,y^2,z^2,(w*x)^2*e, (w*y)^2*e,(w*z)^2*e,(x*y)^2*e,(x*z)^2*e,(y*z)^2*e, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*x*y*z)^-1,a^-1*z*a*w^-1 ,b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1, e^-1*w^-1*e*w,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z], [[a,b]]]; end, [32]], "A5 2^4' C 2^1",[1,5,7,7],2, 1,32], # 1920.8 (otherpres.) [[1,"abstuvf", function(a,b,s,t,u,v,f) return [[f^2,f^-1*a^-1*f*a,f^-1*b^-1*f*b,f^(-1 *1)*s^-1*f*s,f^-1*t^-1*f*t, f^-1*u^-1*f*u,f^-1*v^-1*f*v,s^2, t^2,u^2,v^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^2,b^3,(a*b)^5, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, b^-1*s*b*(t*v*f)^-1, b^-1*t*b*(s*t*u*v*f)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1], [[a*b,b*a*b*a*b^-1*a*b^-1,s*f]]]; end, [12]]] ]; PERFGRP[16]:=[# 2160.1 [[1,"abcd", function(a,b,c,d) return [[b^3,c^3,(b*c)^4*d^-1,(b*c^-1)^5,a^-1*b^(-1 *1)*c*b*c*b^-1*c*b*c^-1,d^2, d^-1*b^-1*d*b,d^-1*c^-1*d*c], [[a^3,c*a^2],[c*b*a*d,b]]]; end, [18,80]], "A6 3^1 x 2^1",[13,1,1,14],-6, 3,[18,80]] ]; PERFGRP[17]:=[# 2184.1 [[1,"abc", function(a,b,c) return [[a^4,b^13,(a*b)^3,c^6*a^2,(a*c)^2*a^2,a^2*b^-1 *a^2*b,c^-1*b*c*b^(-1*4), b^6*a*b^-1*a*b*a*b^7*a*c^-1],[[b,c^4]]]; end, [56]], "L2(13) 2^1 = SL(2,13)",[20,0,1],-2, 6,56] ]; PERFGRP[18]:=[# 2448.1 [[1,"abc", function(a,b,c) return [[a^2,(a*b)^3,(a*c)^2,c^-1*b*c*b^(-1*9),b^5*a*b ^-1*a*b^2*a*b^6*a*c^-1,c^8,b^17] ,[[b,c]]]; end, [18]], "L2(17)",[21,0,1],-1, 7,18] ]; PERFGRP[19]:=[# 2520.1 [[1,"ab", function(a,b) return [[a^2,b^4,(a*b)^7,(a*b)^2*a*b^2*(a*b*a*b^-1)^2 *(a*b)^2*(a*b^-1)^2*a*b*a*b^-1], [[a,b^2*a*b^-1*(a*b*a*b^2)^2*(a*b)^2, b*(a*b^-1)^2*a*b^2*(a*b)^2]]]; end, [7]], "A7",[23,0,1],-1, 8,7] ]; PERFGRP[20]:=[# 2688.1 [[1,"abdxyz", function(a,b,d,x,y,z) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *d^-1,d^2,b^-1*d^-1*b*d,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1], [[a,b],[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1, x]]]; end, [8,16]], "L3(2) 2^1 x 2^3",[8,4,1],2, 2,[8,16]], # 2688.2 [[1,"abxyze", function(a,b,x,y,z,e) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,x^2,y^2, z^2,e^2,e^-1*x^-1*e*x,e^-1*y^-1*e*y ,e^-1*z^-1*e*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*x*a*(z*e)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e)^-1,a^-1*e^-1*a*e, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,b^-1*e^-1*b*e], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,z]]]; end, [16]], "L3(2) 2^3 E 2^1",[8,4,2],2, 2,16], # 2688.3 [[1,"abdxyz", function(a,b,d,x,y,z) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *(d*y*z)^-1,d^2,b^-1*d^-1*b*d,x^2,y^2, z^2,x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1], [b,a*b*a*b^-1*a,x]]]; end, [16,14]], "L3(2) 2^1 x N 2^3",[8,4,3],2, 2,[16,14]] ]; PERFGRP[21]:=[# 3000.1 [[1,"abyz", function(a,b,y,z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,y^5,z^5,y^-1 *z^-1*y*z,a^-1*y*a*z^-1, a^-1*z*a*y,b^-1*y*b*z, b^-1*z*b*(y*z^-1)^-1],[[a,b]]]; end, [25]], "A5 2^1 5^2",[3,2,1],1, 1,25], # 3000.2 (otherpres.) [[1,"abdyz", function(a,b,d,y,z) return [[a^2*d^-1,b^3,(a*b)^5,d^2,d^-1*b^-1*d*b, y^5,z^5,y^-1*z^-1*y*z,a^-1*y*a*z^-1 ,a^-1*z*a*y,b^-1*y*b*z, b^-1*z*b*(y*z^-1)^-1],[[a,b]]]; end, [25]]] ]; PERFGRP[22]:=[# 3420.1 [[1,"abc", function(a,b,c) return [[c^9,c*b^4*c^-1*b^-1,b^19,a^2,c*a*c*a^-1, (b*a)^3],[[b,c]]]; end, [20]], "L2(19)",22,-1, 9,20] ]; PERFGRP[23]:=[# 3600.1 [[1,"abcd", function(a,b,c,d) return [[a^2,b^3,(a*b)^5,c^2,d^3,(c*d)^5,a^-1*c^-1*a*c ,a^-1*d^-1*a*d,b^-1*c^-1*b*c, b^-1*d^-1*b*d], [[a,b,c*d*c*d^-1*c,d],[a*b*a*b^-1*a,b,c,d]]] ; end, [5,5]], "A5 x A5",[29,0,1,30],1, [1,1],[5,5]] ]; PERFGRP[24]:=[# 3840.1 [[1,"abstuve", function(a,b,s,t,u,v,e) return [[a^2,b^3,(a*b)^5,e^4,e^-1*a^-1*e*a,e^-1 *b^-1*e*b,e^-1*s^-1*e*s, e^-1*t^-1*e*t,e^-1*u^-1*e*u, e^-1*v^-1*e*v,s^2,t^2,u^2,v^2, s^-1*t^-1*s*t,s^-1*u^-1*s*u*e^2, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v*e^2,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1], [[a,b]]]; end, [64]], "A5 ( 2^4 E 2^1 A ) C 2^1 I",[1,6,1],4, 1,64], # 3840.2 [[1,"abstuve", function(a,b,s,t,u,v,e) return [[a^2*e^2,b^3,(a*b)^5,e^4,e^-1*a^-1*e*a,e^(-1 *1)*b^-1*e*b,e^-1*s^-1*e*s, e^-1*t^-1*e*t,e^-1*u^-1*e*u, e^-1*v^-1*e*v,s^2,t^2,u^2,v^2, s^-1*t^-1*s*t,s^-1*u^-1*s*u*e^2, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v*e^2,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1], [[a*e^-1,b*u]]]; end, [64]], "A5 ( 2^4 E 2^1 A ) C 2^1 II",[1,6,2],4, 1,64], # 3840.3 [[1,"abstuvef", function(a,b,s,t,u,v,e,f) return [[a^2,b^3,(a*b)^5,e^2,f^2,e^-1*a^-1*e*a,e^(-1 *1)*b^-1*e*b,e^-1*s^-1*e*s, e^-1*t^-1*e*t,e^-1*u^-1*e*u, e^-1*v^-1*e*v,e^-1*f^-1*e*f, f^-1*a^-1*f*a,f^-1*b^-1*f*b, f^-1*s^-1*f*s,f^-1*t^-1*f*t, f^-1*u^-1*f*u,f^-1*v^-1*f*v,s^2, t^2,u^2,v^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,b^-1*s*b*(t*v*e*f)^-1 ,b^-1*t*b*(s*t*u*v*f)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1], [[a*b,b*a*b*a*b^-1*a*b^-1,s*f]]]; end, [24]], "A5 2^4 E ( 2^1 x 2^1 )",[1,6,3],4, 1,24], # 3840.4 [[1,"abstuvde", function(a,b,s,t,u,v,d,e) return [[a^2*d,b^3,(a*b)^5,d^2,e^2,d^-1*a^-1*d*a,d ^-1*b^-1*d*b,d^-1*s^-1*d*s, d^-1*t^-1*d*t,d^-1*u^-1*d*u, d^-1*v^-1*d*v,d^-1*e^-1*d*e, e^-1*a^-1*e*a,e^-1*b^-1*e*b, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v,s^2, t^2,u^2,v^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,b^-1*s*b*(t*v*e*d)^-1 ,b^-1*t*b*(s*t*u*v*d)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1], [[a*b,s*d]]]; end, [48]], "A5 2^4 E ( 2^1 x N 2^1 )",[1,6,4],4, 1,48], # 3840.5 [[1,"abdstuve", function(a,b,d,s,t,u,v,e) return [[a^2*d,b^3,(a*b)^5,d^2,d^-1*b^-1*d*b,e^2,d ^-1*a^-1*d*a,d^-1*s^-1*d*s, d^-1*t^-1*d*t,d^-1*u^-1*d*u, d^-1*v^-1*d*v,d^-1*e^-1*d*e, e^-1*a^-1*e*a,e^-1*b^-1*e*b, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v,s^2, t^2,u^2,v^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1], [[a*b,s,e],[a*b,b*a*b*a*b^-1*a*b^-1,s]]]; end, [24,12]], "A5 2^1 x ( 2^4 E 2^1 )",[1,6,5],4, 1,[24,12]], # 3840.6 [[1,"abdstuve", function(a,b,d,s,t,u,v,e) return [[a^2*d^-1,b^3,(a*b)^5,d^2*e,b^-1*d*b*(d*u*v) ^-1,s^2,t^2,u^2,v^2,e^2,s^-1*t^-1*s*t ,u^-1*v^-1*u*v,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, d^-1*a^-1*d*a,d^-1*s^-1*d*s, d^-1*t^-1*d*t,d^-1*u^-1*d*u, d^-1*v^-1*d*v],[[a*b,s]]]; end, [48]], "A5 2^1 E 2^4 E 2^1",[1,6,6],2, 1,48], # 3840.7 [[1,"abdwxyze", function(a,b,d,w,x,y,z,e) return [[a^2*d^-1,b^3,(a*b)^5,d^2,b^-1*d^-1*b*d, e^2,a^-1*d^-1*a*d,a^-1*e^-1*a*e, b^-1*e^-1*b*e,w^2,x^2,y^2,z^2,(w*x)^2*e, (w*y)^2*e,(w*z)^2*e,(x*y)^2*e,(x*z)^2*e,(y*z)^2*e, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*x*y*z)^-1,a^-1*z*a*w^-1 ,b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1, d^-1*w^-1*d*w,d^-1*x^-1*d*x, d^-1*y^-1*d*y,d^-1*z^-1*d*z, e^-1*w^-1*e*w,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z], [[a,b],[a*b,w]]]; end, [32,24]], "A5 2^1 x ( 2^4' C 2^1 )",[1,6,7,7],4, 1,[32,24]] ]; PERFGRP[25]:=[# 4080.1 [[1,"abc", function(a,b,c) return [[c^15,b^2,c^(-1*4)*b*c^3*b*c*b^-1,a^2,(a*c)^2, (a*b)^3],[[b,c]]]; end, [17]], "L2(16)",22,-1, 10,17] ]; PERFGRP[26]:=[# 4860.1 [[1,"abwxyz", function(a,b,w,x,y,z) return [[a^2,b^3,(a*b)^5,w^3,x^3,y^3,z^3,w^-1*x^-1*w *x,w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*w*a*z^-1, a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1], [[b,a*b*a*b^-1*a,w*x^-1]]]; end, [15]], "A5 3^4'",[2,4,1],1, 1,15], # 4860.2 [[1,"abwxyz", function(a,b,w,x,y,z) return [[a^2,b^3*z^-1,(a*b)^5,w^3,x^3,y^3,z^3,w^-1*x ^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1], [[b,w*x^-1]]]; end, [60]], "A5 N 3^4'",[2,4,2],1, 1,60] ]; PERFGRP[27]:=[# 4896.1 [[1,"abcd", function(a,b,c,d) return [[a^2*d^-1,b^17,c^8*d^-1,(a*b)^3,(a*c)^2*d^(-1 *1),d^2,d^-1*b^-1*d*b, d^-1*c^-1*d*c,c^-1*b*c*b^(-1*9), b^5*a*b^-1*a*b^2*a*b^6*a*c^-1],[[b]]]; end, [288]], "L2(17) 2^1 = SL(2,17)",[21,1,1],-2, 7,288] ]; PERFGRP[28]:=[# 5040.1 [[1,"abd", function(a,b,d) return [[a^2*d,b^4*d,(a*b)^7,(a*b)^2*a*b^2*(a*b*a*b^-1) ^2*(a*b)^2*(a*b^-1)^2*a*b*a*b^-1, d^2,d*a*d*a^-1,d*b*d*b^-1], [[a*b,b*a*b*a*b^2*a*b^-1*a*b*a*b^-1*a*b*a *b^2*d]]]; end, [240]], "A7 2^1",[23,1,1],-2, 8,240] ]; PERFGRP[29]:=[# 5376.1 [[1,"abdxyze", function(a,b,d,x,y,z,e) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *d^-1,d^2,d^-1*b^-1*d*b,x^2,y^2,z^2, e^2,e^-1*x^-1*e*x,e^-1*y^-1*e*y, e^-1*z^-1*e*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*x*a*(z*e)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e)^-1,a^-1*e^-1*a*e, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,b^-1*e^-1*b*e], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,x,e], [a,b]]]; end, [16,16]], "L3(2) 2^1 x ( 2^3 E 2^1 )",[8,5,1],4, 2,[16,16]] ]; PERFGRP[30]:=[# 5616.1 [[1,"ab", function(a,b) return [[a^2,b^3,(a*b)^13,(a^-1*b^-1*a*b)^4,(a*b)^4*a *b^-1*(a*b)^4*a*b^-1*(a*b)^2 *(a*b^-1)^2*a*b*(a*b^-1)^2*(a*b)^2 *a*b^-1],[[b,a*b*a*b^-1*a]]]; end, [13]], "L3(3)",[24,0,1],-1, 11,13] ]; PERFGRP[31]:=[# 5760.1 [[1,"abcstuv", function(a,b,c,s,t,u,v) return [[a^2,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1*b^-1*c *b*c*b^-1*c*b*c^-1,s^2,t^2,u^2, v^2,s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u)^-1, c^-1*v*c*(s*t*u*v)^-1],[[b,c]]]; end, [16]], "A6 2^4",[13,4,1],1, 3,16] ]; PERFGRP[32]:=[# 6048.1 [[1,"ab", function(a,b) return [[a^2,b^6,(a*b)^7,(a*b^2)^3*(a*b^(-1*2))^3,(a*b*a*b ^(-1*2))^3*a*b*(a*b^-1)^2], [[a,(b*a)^3*b^3]]]; end, [28]], "U3(3)",[25,0,1],-1, 12,28] ]; PERFGRP[33]:=[# 6072.1 [[1,"abc", function(a,b,c) return [[c^11,c*b^3*c^-1*b^-1,b^23,a^2,c*a*c*a^-1, (b*a)^3],[[b,c]]]; end, [24]], "L2(23)",22,-1, 13,24] ]; PERFGRP[34]:=[# 6840.1 [[1,"abc", function(a,b,c) return [[c^9*a^2,c*b^4*c^-1*b^-1,b^19,a^2*b^-1 *a^2*b,a^2*c^-1*a^2*c,a^4,c*a*c*a^-1, (b*a)^3],[[b,c^2]]]; end, [40]], "L2(19) 2^1 = SL(2,19)",22,-2, 9,40] ]; PERFGRP[35]:=[# 7200.1 [[1,"abcd", function(a,b,c,d) return [[a^2,b^3,(a*b)^5,c^4,d^3,(c*d)^5,c^2*d*c^2*d^-1, a^-1*c^-1*a*c,a^-1*d^-1*a*d, b^-1*c^-1*b*c,b^-1*d^-1*b*d], [[a*b*a*b^-1*a,b,c,d],[a,b,c*d]]]; end, [5,24]], "A5 2^1 x A5",[29,1,1,30],2, [1,1],[5,24]], # 7200.2 [[1,"abcd", function(a,b,c,d) return [[a^4,b^3,(a*b)^5,c^2*a^2,d^3,(c*d)^5,a^-1*c^-1 *a*c,a^-1*d^-1*a*d,b^-1*c^-1*b*c, b^-1*d^-1*b*d],[[a*b,c*d]]]; end, [288]], "( A5 N x A5 N ) 2^1",[29,1,2,30],2, [1,1],288] ]; PERFGRP[36]:=[# 7500.1 [[1,"abxyz", function(a,b,x,y,z) return [[a^2,b^3,(a*b)^5,x^5,y^5,z^5,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*x*a*z^-1,a^-1*y*a*y, a^-1*z*a*x^-1,b^-1*x*b*z^-1, b^-1*y*b*(y^-1*z)^-1, b^-1*z*b*(x*y^(-1*2)*z)^-1], [[a*b,b*a*b*a*b^-1*a*b^-1,y]]]; end, [30]], "A5 5^3",[3,3,1],1, 1,30], # 7500.2 [[1,"abxyz", function(a,b,x,y,z) return [[a^2,b^3,(a*b)^5*z^-1,x^5,y^5,z^5,x^-1*y^(-1 *1)*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*x*a*z^-1, a^-1*y*a*y,a^-1*z*a*x^-1, b^-1*x*b*z^-1, b^-1*y*b*(y^-1*z)^-1, b^-1*z*b*(x*y^(-1*2)*z)^-1], [[a*b,b*a*b*a*b^-1*a*b^-1,y]]]; end, [30]], "A5 N 5^3",[3,3,2],1, 1,30] ]; PERFGRP[37]:=[# 7560.1 [[1,"ab", function(a,b) return [[a^6,b^4,(a*b)^7,(a*b)^2*a*b^2*(a*b*a*b^-1)^2 *(a*b)^2*(a*b^-1)^2*a*b*a*b^-1 *a^2,a^2*b*a^(-1*2)*b^-1], [[a^3,(b^-1*a)^2*(b*a)^2*b^2*a*b*a]]]; end, [45]], "A7 3^1",[23,0,1],-3, 8,45] ]; PERFGRP[38]:=[# 7680.1 [[1,"abstuvef", function(a,b,s,t,u,v,e,f) return [[a^2,b^3,(a*b)^5,e^4,f^2,e^-1*a^-1*e*a,e^(-1 *1)*b^-1*e*b,e^-1*s^-1*e*s, e^-1*t^-1*e*t,e^-1*u^-1*e*u, e^-1*v^-1*e*v,e^-1*f^-1*e*f, f^-1*a^-1*f*a,f^-1*b^-1*f*b, f^-1*s^-1*f*s,f^-1*t^-1*f*t, f^-1*u^-1*f*u,f^-1*v^-1*f*v,s^2, t^2,u^2,v^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u*e^2,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v*e^2, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1, b^-1*s*b*(t*v*e*f^-1)^-1, b^-1*t*b*(s*t*u*v*f)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1], [[a*b,b*a*b*a*b^-1*a*b^-1,s*f,e],[a,b,f]]]; end, [12,64]], "A5 ( 2^4 E ( 2^1 A x 2^1 ) ) C 2^1",[1,7,1],8, 1,[12,64]], # 7680.2 [[1,"abstuvde", function(a,b,s,t,u,v,d,e) return [[a^2*d,b^3,(a*b)^5,d^2,e^4,d^-1*a^-1*d*a,d ^-1*b^-1*d*b,d^-1*s^-1*d*s, d^-1*t^-1*d*t,d^-1*u^-1*d*u, d^-1*v^-1*d*v,d^-1*e^-1*d*e, e^-1*a^-1*e*a,e^-1*b^-1*e*b, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v,s^2, t^2,u^2,v^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u*e^2,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v*e^2, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,b^-1*s*b*(t*v*e*d)^-1 ,b^-1*t*b*(s*t*u*v*d)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1], [[a*b,s*d,e],[a,b]]]; end, [24,64]], "A5 ( 2^4 E ( 2^1 A x N 2^1 ) ) C 2^1 I",[1,7,2],8, 1,[24,64]], # 7680.3 [[1,"abstuvde", function(a,b,s,t,u,v,d,e) return [[a^2*d,b^3,(a*b)^5,d^2,e^4,d^-1*a^-1*d*a,d ^-1*b^-1*d*b,d^-1*s^-1*d*s, d^-1*t^-1*d*t,d^-1*u^-1*d*u, d^-1*v^-1*d*v,d^-1*e^-1*d*e, e^-1*a^-1*e*a,e^-1*b^-1*e*b, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v,s^2, t^2,u^2,v^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u*e^2,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v*e^2, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1, b^-1*s*b*(t*v*d*e^-1)^-1, b^-1*t*b*(s*t*u*v*d*e^2)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1], [[a*b,s*d,e],[a*e^-1,b*u]]]; end, [24,64]], "A5 ( 2^4 E ( 2^1 A x N 2^1 ) ) C 2^1 II",[1,7,3],8, 1,[24,64]], # 7680.4 [[1,"abdstuve", function(a,b,d,s,t,u,v,e) return [[a^2*d,b^3,(a*b)^5,d^2,d^-1*b^-1*d*b,e^4,d ^-1*a^-1*d*a,d^-1*s^-1*d*s, d^-1*t^-1*d*t,d^-1*u^-1*d*u, d^-1*v^-1*d*v,d^-1*e^-1*d*e, e^-1*a^-1*e*a,e^-1*b^-1*e*b, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v,s^2, t^2,u^2,v^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u*e^2,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v*e^2, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1], [[a*b,s,e],[a,b]]]; end, [24,64]], "A5 2^1 x ( 2^4 E 2^1 A ) C 2^1",[1,7,4],8, 1,[24,64]], # 7680.5 [[1,"abdstuvef", function(a,b,d,s,t,u,v,e,f) return [[a^2*d,b^3,(a*b)^5,d^2,d^-1*b^-1*d*b,e^2,f^2, d^-1*a^-1*d*a,d^-1*s^-1*d*s, d^-1*t^-1*d*t,d^-1*u^-1*d*u, d^-1*v^-1*d*v,d^-1*e^-1*d*e, d^-1*f^-1*d*f,e^-1*a^-1*e*a, e^-1*b^-1*e*b,e^-1*s^-1*e*s, e^-1*t^-1*e*t,e^-1*u^-1*e*u, e^-1*v^-1*e*v,e^-1*f^-1*e*f, f^-1*a^-1*f*a,f^-1*b^-1*f*b, f^-1*s^-1*f*s,f^-1*t^-1*f*t, f^-1*u^-1*f*u,f^-1*v^-1*f*v,s^2, t^2,u^2,v^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,b^-1*s*b*(t*v*e*f)^-1 ,b^-1*t*b*(s*t*u*v*f)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1], [[a*b,s,e,f],[a*b,b*a*b*a*b^-1*a*b^-1,s*f]] ]; end, [24,24]], "A5 2^1 x ( 2^4 E ( 2^1 x 2^1 ) )",[1,7,5],8, 1,[24,24]] ]; ############################################################################# ## #E perf1.grp . . . . . . . . . . . . . . . . . . . . . . . . . ends here ## gap-4r6p5/grp/imf14.grp0000644000175000017500000004161112172557252013366 0ustar billbill############################################################################# ## #A imf14.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Q-class representative of the irreducible ## maximal finite integral matrix groups of dimension 14, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Q-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 14. ## IMFList[14].matrices := [ [ # Q-class [14][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[[0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [14][02] [[2], [-1,2], [0,-1,2], [0,0,-1,2], [0,0,0,-1,2], [0,0,0,0,-1,2], [0,0,-1,0,0,0,2], [0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,-1,0,0,0,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,-1,-1,-2,-2,-2,-1,-1], [0,0,0,0,0,0,0,2,3,4,3,2,1,2], [0,0,0,0,0,0,0,0,-1,-2,-2,-1,0,-1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0]], [[-1,-2,-3,-3,-2,-1,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,2,2,1,1,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,1,2,1,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [14][03] [[2], [1,2], [0,0,2], [0,0,1,2], [0,0,0,0,2], [0,0,0,0,1,2], [0,0,0,0,0,0,2], [0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0]], [[0,1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [14][04] [[4], [1,4], [1,1,4], [1,-1,1,4], [1,1,-1,1,4], [1,1,1,-1,1,4], [1,-1,1,1,-1,1,4], [1,-1,-1,1,1,-1,1,4], [1,-1,-1,-1,1,1,-1,1,4], [1,-1,-1,-1,-1,1,1,-1,1,4], [1,1,-1,-1,-1,-1,1,1,-1,1,4], [1,1,1,-1,-1,-1,-1,1,1,-1,1,4], [1,-1,1,1,-1,-1,-1,-1,1,1,-1,1,4], [1,1,-1,1,1,-1,-1,-1,-1,1,1,-1,1,4]], [[[1,0,0,0,0,-1,-1,0,-1,1,-1,0,-1,-1], [0,1,0,1,0,-1,0,-1,1,1,0,0,-1,-1], [0,0,-1,1,0,1,-1,0,-1,1,0,1,0,-1], [1,0,0,-1,0,0,-1,1,-1,0,0,-1,1,-1], [1,0,1,0,-1,-1,-1,0,1,0,0,-1,-1,0], [0,0,0,1,-1,0,-1,0,0,1,0,0,-1,0], [0,0,-1,0,0,0,0,0,-1,0,0,0,1,-1], [0,-1,1,-1,1,-1,0,0,0,0,0,0,0,0], [0,-1,1,0,0,0,-1,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,1,-1,1,-1,0,0,0,0,0,-1], [0,-1,0,0,1,0,0,-1,0,0,0,1,-1,0], [0,0,0,0,0,1,-1,1,-1,0,0,0,0,0], [1,1,0,0,0,-1,0,0,0,0,0,-1,0,-1]], [[-1,0,-1,0,0,1,1,0,0,-1,0,1,1,1], [-1,0,1,-1,1,0,1,1,0,0,0,0,1,1], [-1,0,0,0,0,0,1,0,1,0,0,0,0,1], [0,-1,0,0,0,0,0,-1,0,0,0,1,-1,1], [0,0,0,-1,1,0,0,0,-1,0,0,0,1,0], [0,1,-1,0,0,0,1,0,0,0,-1,0,1,0], [0,0,-1,1,-1,1,0,0,0,0,-1,1,-1,1], [0,0,-1,0,0,1,0,0,-1,0,0,1,0,0], [0,1,-1,0,0,0,0,0,0,0,0,0,1,-1], [1,0,-1,0,-1,0,0,0,0,-1,-1,0,0,0], [0,0,0,0,-1,1,0,1,0,-1,0,0,0,1], [-1,0,0,0,0,1,0,1,0,0,1,0,1,0], [0,-1,0,0,0,0,0,-1,1,-1,1,0,0,0], [0,-1,1,-1,0,0,0,0,0,-1,0,0,0,1]]]], [ # Q-class [14][05] [[3], [-1,3], [1,1,3], [1,0,1,3], [0,1,0,-1,3], [0,1,0,-1,1,3], [-1,0,-1,0,0,0,3], [0,-1,0,0,0,0,-1,3], [0,1,0,0,0,0,1,-1,3], [-1,0,0,0,-1,0,1,1,0,3], [0,-1,-1,0,0,-1,0,1,0,1,3], [1,-1,0,1,0,-1,0,0,1,-1,1,3], [-1,1,0,-1,1,0,1,0,1,1,1,0,3], [-1,0,0,0,0,-1,0,1,0,0,0,1,1,3]], [[[-1,-2,0,1,1,1,-1,-1,1,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,-1,0,0,1,0,-1,-1,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,1,-1,0,0], [1,1,0,-1,0,-1,1,1,0,0,0,0,-1,0], [0,1,0,-1,-1,0,0,0,-1,0,0,1,0,0], [0,-1,0,0,0,0,0,0,1,0,0,-1,0,0], [0,1,1,-1,-1,0,1,1,0,-1,1,0,-1,0], [-1,-1,1,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,1,-1,0,0,1,0,0,0,1,0,-1,0], [1,1,0,-1,-1,0,1,0,-1,0,0,1,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,1,0,0,0,0,0,0,-1,0,0,1,0,0], [1,2,0,-1,-1,0,1,1,-1,0,0,1,0,0], [0,1,0,-1,0,-1,1,1,-1,0,-1,1,0,-1], [0,-1,0,1,0,1,0,-1,0,0,1,-1,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0], [-1,-2,1,1,1,1,0,-1,1,0,1,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,1,0,0,-1,0,1,0,0,-1,1], [0,0,0,0,0,0,0,-1,0,0,1,-1,-1,1]]]], [ # Q-class [14][06] [[4], [-2,4], [-2,1,4], [1,-2,-2,4], [0,0,-2,1,4], [0,0,1,-2,-2,4], [0,0,0,0,-2,1,4], [0,0,0,0,1,-2,-2,4], [0,0,0,0,0,0,-2,1,4], [0,0,0,0,0,0,1,-2,-2,4], [0,0,0,0,0,0,0,0,-2,1,4], [0,0,0,0,0,0,0,0,1,-2,-2,4], [0,0,0,0,0,0,-2,1,0,0,0,0,4], [0,0,0,0,0,0,1,-2,0,0,0,0,-2,4]], [[[0,1,0,1,0,1,0,1,0,1,0,1,0,0], [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,0], [0,0,0,-1,0,-1,0,-1,0,-1,0,-1,0,0], [0,0,1,1,1,1,1,1,1,1,1,1,0,0], [0,-1,0,-1,0,-1,0,-1,0,0,0,0,0,-1], [1,1,1,1,1,1,1,1,0,0,0,0,1,1], [0,1,0,2,0,2,0,2,0,1,0,0,0,1], [-1,-1,-2,-2,-2,-2,-2,-2,-1,-1,0,0,-1,-1], [0,0,0,0,0,1,0,2,0,1,0,1,0,1], [0,0,0,0,-1,-1,-2,-2,-1,-1,-1,-1,-1,-1], [0,0,0,0,0,-1,0,-1,0,0,0,0,0,0], [0,0,0,0,1,1,1,1,0,0,0,0,0,0], [0,-1,0,-2,0,-3,0,-4,0,-3,0,-1,0,-2], [1,1,2,2,3,3,4,4,3,3,1,1,2,2]], [[0,0,0,0,0,0,0,0,1,1,1,1,0,0], [0,0,0,0,0,0,0,0,0,-1,0,-1,0,0], [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,0], [0,1,0,1,0,1,0,1,0,1,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,1,1,1,1,1,1,1,1,1,0,0,1,1], [0,-1,0,-1,0,-1,0,-1,0,-1,0,0,0,-1], [0,0,1,1,2,2,2,2,1,1,1,1,1,1], [0,0,0,-1,0,-2,0,-2,0,-1,0,-1,0,-1], [0,0,-1,-1,-1,-1,0,0,0,0,0,0,0,0], [0,0,0,1,0,1,0,0,0,0,0,0,0,0], [-1,-1,-2,-2,-3,-3,-4,-4,-3,-3,-1,-1,-2,-2], [0,1,0,2,0,3,0,4,0,3,0,1,0,2]]]], [ # Q-class [14][07] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,1,0]]]], [ # Q-class [14][08] [[4], [0,4], [2,1,4], [0,0,0,4], [0,-2,0,0,4], [0,2,1,0,-1,4], [0,0,-1,-1,0,1,4], [-1,2,1,-1,-1,1,0,4], [0,0,-1,1,-1,0,1,0,4], [2,-1,1,0,0,1,1,0,0,4], [2,0,1,0,0,0,0,0,-1,1,4], [0,0,0,0,1,1,0,0,0,0,-1,4], [2,0,1,0,1,0,-1,0,0,2,1,1,4], [1,0,1,0,-1,0,-1,0,2,1,-1,0,2,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,1,-1,0,1,0,0,0,-1,1,1,0,-2,2], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [1,0,-1,1,0,0,1,1,-1,-1,0,0,0,1], [0,-1,1,0,-1,0,0,0,1,-1,-1,-1,2,-2], [1,0,-1,0,0,0,0,0,-1,0,0,0,-1,1], [0,1,0,-1,0,0,-1,-1,1,1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,1,0,0,-1,0], [0,2,-1,0,1,-1,-1,0,0,2,1,1,-2,1], [1,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,-1,1,0,-1,0,1,0,0,-1,0,0,1,0], [-1,1,0,0,0,-1,0,-1,0,1,0,0,0,0], [0,1,0,0,1,-1,0,0,0,1,0,0,-1,1], [0,2,-1,0,2,-1,-1,0,0,2,1,1,-3,2]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,1,0,0,-1,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,-1,0,0,-1,1,0,0,0,1,-1], [-1,0,1,-1,0,0,0,-1,1,0,0,0,1,-1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,-1,1], [0,-1,0,1,-1,0,1,0,-1,-1,0,0,1,0], [1,0,0,0,0,0,0,0,0,-1,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,-1,0,0,0,1,0,0,0,-1,0,-1,1,0], [1,-1,0,0,0,1,0,0,0,-1,0,0,0,0], [1,-2,0,1,-1,1,1,1,-1,-2,0,0,1,0]]]], [ # Q-class [14][09] [[4], [-1,4], [2,-2,4], [1,0,0,4], [0,0,0,0,4], [0,0,1,1,-1,4], [-1,0,-1,2,0,1,4], [-1,0,0,0,2,0,0,4], [0,1,0,-1,0,-1,1,1,4], [1,1,0,1,1,1,1,2,2,4], [1,-1,1,2,1,1,1,1,0,2,4], [0,0,1,0,1,1,-1,1,-1,0,1,4], [0,0,-1,-1,0,-1,1,-1,2,1,1,-1,4], [-1,0,-1,1,1,0,2,0,0,1,2,1,2,4]], [[[-2,-1,0,0,0,-1,0,-2,-1,3,0,1,0,-1], [2,2,1,-1,-1,0,2,3,-2,-2,0,0,2,0], [-2,-1,0,-1,0,-2,1,-3,-1,4,1,1,-1,-2], [0,1,1,-1,0,-1,1,0,-2,1,0,0,0,0], [0,0,0,0,0,1,-1,0,1,-1,1,-1,-1,1], [0,1,1,-1,-1,-2,2,0,-3,2,0,1,1,-2], [0,1,1,0,0,-1,1,1,-2,0,0,0,1,-1], [1,0,-1,-1,0,1,0,0,1,-1,1,-1,-2,1], [0,0,0,0,0,0,1,1,-1,0,0,0,1,-1], [0,1,1,-1,-1,-1,2,1,-3,1,0,0,1,-1], [-1,0,1,-1,0,-1,1,-1,-2,2,0,0,0,-1], [1,0,-1,-1,0,1,-1,0,1,-1,1,-1,-1,1], [-1,0,1,1,0,0,0,1,-1,0,-1,0,2,-1], [0,1,1,0,0,0,0,1,-1,-1,0,-1,1,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,-1,1,1,0,-1,0,-1,-1,2,-1,1,1,-1], [2,1,0,0,0,1,0,2,0,-2,0,-1,1,1], [1,1,1,1,0,1,-1,2,0,-2,-1,-1,1,1], [0,1,1,-1,-1,-1,1,0,-1,0,1,0,0,0], [1,0,0,1,0,1,-1,2,1,-2,-1,-1,1,1], [0,1,1,1,0,0,0,1,0,-1,-1,0,1,0], [1,0,-1,1,0,2,-2,1,2,-3,0,-1,0,2], [0,0,0,1,0,0,0,0,0,0,-1,1,1,0], [1,0,0,1,0,1,-1,1,1,-2,-1,0,1,1], [2,1,0,0,0,1,-1,2,1,-3,0,-1,0,2], [0,0,0,0,0,0,-1,0,0,0,0,-1,0,1], [0,0,0,-1,0,-1,1,-1,0,1,0,1,-1,0], [0,1,1,-1,0,-1,1,0,-1,0,0,0,0,0]]]], [ # Q-class [14][10] [[7], [2,7], [-1,1,7], [1,-1,3,7], [3,3,-1,-1,7], [1,3,1,1,1,7], [1,1,1,2,1,-1,7], [1,1,2,1,1,2,1,7], [1,1,-3,-1,0,3,-1,0,7], [3,-2,1,1,-1,-1,2,1,1,7], [2,0,1,3,-2,-1,1,-1,-1,3,7], [1,-1,-2,2,1,1,-1,-2,2,1,1,7], [0,3,2,1,2,3,-1,3,-1,-1,1,0,7], [2,3,-1,-2,1,-1,0,1,1,2,2,1,1,7]], [[[0,0,1,-1,0,0,0,1,0,-1,1,1,-1,0], [0,1,0,-1,0,-1,0,1,0,0,1,1,0,-1], [-1,2,-1,1,0,-1,-1,0,0,1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,1,0,-1,0,0,0,1,0,0,1,1,-1,-1], [0,1,0,0,0,-1,0,1,0,0,0,1,0,-1], [0,-1,1,-1,1,0,0,0,1,-1,1,0,0,0], [1,0,1,0,0,-1,0,0,1,-1,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,-1,1,0,0,0,0,0,1,-1,0,0,0,1], [0,-1,0,0,0,0,0,0,0,-1,0,0,0,1], [0,-1,0,0,0,1,1,0,0,-1,0,0,0,1], [2,-1,1,-1,-1,-1,1,0,1,-2,0,1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,-1,0,0,0,1,0,0,1,1,0,-1], [1,-1,1,-1,0,0,1,0,0,-1,0,1,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0], [-1,1,0,0,1,0,-1,1,0,1,1,0,-1,-1], [0,1,0,-1,0,-1,0,1,0,0,1,1,0,-1], [0,0,0,1,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,1,0,0,0,1,0], [0,0,0,1,0,0,0,0,0,0,-1,0,0,1], [0,-1,0,0,0,1,1,0,0,-1,0,0,0,1], [-1,1,0,0,0,0,0,0,0,1,0,0,0,0], [0,1,0,-1,0,0,0,1,0,0,1,1,-1,-1], [0,-1,0,0,0,1,0,0,0,0,0,0,0,1]]]], [ # Q-class [14][11] [[6], [0,6], [-2,3,6], [-2,2,1,6], [-2,2,3,3,6], [2,-2,0,0,0,6], [2,-2,-2,0,0,0,6], [-2,-2,0,2,0,0,2,6], [2,0,0,1,2,3,0,-2,6], [-2,0,1,0,-1,0,-1,0,0,6], [0,-3,-2,-2,-2,2,-1,1,0,-1,6], [-2,-2,1,-2,-1,-1,0,0,-2,3,0,6], [-1,-2,-1,-2,-2,-2,-1,0,-1,2,0,3,6], [-1,2,3,0,2,0,-1,-2,0,-1,0,1,-1,6]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,-1,0,0,0,0,0,0,0,-1,0,0], [-1,1,-1,-1,0,0,0,1,1,0,0,0,0,0], [-2,1,0,0,-1,1,1,-1,0,-1,0,0,0,-1], [-1,1,0,0,0,0,1,-1,0,0,1,0,0,-1], [-1,1,0,0,-1,0,1,0,1,-1,0,1,0,0], [0,1,0,1,0,1,1,-1,-1,0,1,0,1,0], [0,0,0,1,-1,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,1,-1,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,1,1,0,-1,0,0,0,0,0,0,0,0], [1,0,-1,0,1,0,-1,1,0,0,0,1,0,0], [2,-2,-1,0,1,-1,-2,1,0,1,-1,0,-1,1], [0,1,-1,-1,1,0,0,1,0,0,0,0,0,0]], [[-2,1,1,1,-1,1,2,-2,0,-1,1,0,1,-1], [0,-1,0,0,0,0,-1,0,0,0,-1,0,0,0], [0,0,-1,-1,1,0,-1,1,0,0,-1,0,0,0], [0,0,-1,-1,0,0,-1,1,1,0,-1,1,-1,0], [0,-1,0,-1,0,-1,-1,1,1,0,-1,0,-1,0], [-1,1,0,0,0,0,1,-1,0,0,1,0,0,-1], [-1,1,0,0,-1,0,1,0,1,-1,0,1,0,0], [0,1,-2,-1,0,0,-1,2,1,0,-1,1,-1,1], [-1,0,1,0,0,0,1,-1,0,0,1,0,0,-1], [1,0,0,0,1,0,0,0,-1,1,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,1,0,0,0], [1,0,0,0,1,0,0,0,-1,0,0,0,0,0], [1,-1,0,0,1,0,0,0,-1,1,0,-1,0,1], [1,-1,0,0,1,-1,-1,0,0,0,0,0,0,0]]]], [ # Q-class [14][12] [[6], [-1,6], [-3,-2,6], [-1,3,-2,6], [2,-3,1,0,6], [-2,2,2,-1,-1,6], [3,0,-3,1,2,0,6], [3,1,-1,1,2,1,1,6], [-3,3,0,2,-2,3,0,0,6], [-2,3,0,3,0,0,-1,1,3,6], [-1,-1,0,-2,-2,0,-1,-2,1,0,6], [2,1,0,1,0,-1,0,2,-1,0,0,6], [2,2,-1,-1,-2,2,0,2,1,-1,1,3,6], [3,-2,0,-1,1,-3,1,0,-3,-2,1,3,0,6]], [[[-2,-1,-2,-1,0,0,0,0,0,1,-1,0,1,1], [1,-1,-1,1,0,2,-1,-1,-1,1,0,0,0,0], [1,1,2,0,-1,-1,1,1,0,-1,1,0,-1,-1], [0,0,-1,0,1,1,-1,0,0,0,0,0,0,0], [-2,0,0,-1,0,-1,1,1,0,0,0,0,1,0], [0,-1,0,1,-1,1,0,0,-1,0,0,0,0,0], [-2,-2,-2,0,0,1,0,0,0,1,-1,0,1,1], [-2,-1,-2,-1,0,1,0,0,-1,1,-1,0,1,1], [0,0,0,1,0,1,0,0,-1,0,0,0,0,0], [0,0,0,0,0,1,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,-1,0], [0,0,-1,-1,0,0,0,0,0,0,0,1,-1,-1], [-1,0,-1,0,0,0,0,0,-1,0,0,0,0,0], [0,0,-1,-1,0,0,0,0,1,0,0,1,-1,0]], [[-2,-1,-2,-1,0,1,0,0,-1,1,-1,0,1,1], [-1,0,0,0,1,-1,0,0,0,0,0,0,1,0], [2,2,2,0,0,-1,0,0,1,-1,1,0,-1,-1], [0,-1,0,1,0,0,0,0,0,0,0,0,1,0], [0,1,0,0,0,0,0,0,0,-1,0,0,0,0], [0,1,1,0,0,-1,0,0,0,0,0,0,0,0], [-2,-1,-2,0,0,1,0,0,-1,1,-1,0,1,1], [-1,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,1,1,0,-1,0,0,0,0,0,-1,1,0], [0,1,1,1,1,-1,0,0,0,-1,1,-1,1,0], [-1,0,0,0,0,0,0,1,0,0,0,-1,0,1], [-2,0,0,-1,0,-1,1,1,0,0,0,0,1,0], [-2,-1,-1,-1,0,0,0,0,0,1,-1,0,1,1], [-1,0,-1,-1,0,0,0,1,0,0,0,0,0,0]]]] ]; MakeImmutable( IMFList[14].matrices ); gap-4r6p5/grp/imf27.grp0000644000175000017500000005521412172557252013376 0ustar billbill############################################################################# ## #A imf27.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Q-class representative of the irreducible ## maximal finite integral matrix groups of dimension 27, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Q-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 27. ## IMFList[27].matrices := [ [ # Q-class [27][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [27][02] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1]]]], [ # Q-class [27][03] [[4], [2,4], [0,1,4], [1,2,2,4], [2,1,0,1,4], [2,1,1,2,2,4], [0,0,1,0,0,1,4], [0,1,2,1,0,0,1,4], [2,1,0,1,2,2,0,1,4], [1,1,0,1,2,1,0,0,1,4], [1,1,0,1,1,1,0,0,2,1,4], [1,1,0,2,2,1,0,0,1,2,1,4], [0,0,1,0,0,0,1,1,0,-1,0,0,4], [1,2,0,1,2,1,0,0,1,2,1,2,0,4], [0,1,2,1,0,0,2,2,0,0,0,0,1,0,4], [0,0,1,0,0,0,1,2,2,0,1,0,1,0,1,4], [0,0,1,0,0,0,1,1,0,1,0,0,2,0,1,1,4], [2,1,0,2,1,1,0,0,1,1,1,2,0,1,0,0,0,4], [1,2,2,1,0,0,1,2,0,0,0,0,1,0,2,1,1,0,4], [1,2,1,2,1,1,0,2,2,1,1,1,0,1,1,1,0,1,1,4], [1,1,0,2,1,1,0,0,2,1,2,2,0,1,0,1,0,2,0,1,4], [1,2,0,1,1,1,0,0,2,1,2,1,0,2,0,1,0,1,0,1,2,4], [2,1,0,1,1,1,0,0,1,1,2,1,0,2,0,0,0,2,0,1,1,1,4], [1,0,1,0,0,0,2,1,0,0,0,0,1,0,2,1,1,1,1,0,0,0,1,4], [0,0,1,0,1,0,2,1,0,2,0,1,1,1,2,1,2,0,1,0,0,0,0,2,4], [1,1,0,1,1,1,0,0,1,2,2,1,1,1,0,0,2,1,0,1,1,1,2,0,1,4], [0,0,1,0,0,0,2,1,1,0,1,0,1,0,2,2,1,0,1,0,1,1,0,2,2,0,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,-1,0,0,0,0,0,1,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,-1,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,1,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,1,0,0,-1,0], [-1,1,-1,0,0,1,0,0,0,1,0,0,1,-1,0,0,0,0,0,0,0,0,1,0,0,-1,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,1,0,-1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,-1,1,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0], [1,-1,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,1,0,0,-1,0,-1,1,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,-1,1,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,-1,0], [1,-1,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0]], [[-1,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [-1,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,1,0,0,0,-1,0,0,1,0], [-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,1,0], [-1,0,0,0,0,0,0,-1,1,0,-1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0], [1,-1,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,-1,0,1,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,-1,1,0,0,0,0,0,0,0,0,-1,1,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,-1,1,1,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [-1,1,0,0,0,0,0,-1,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,1,-1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,1,1,0,-1,0,0,0,0,0,0], [0,-1,-1,1,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,1,0], [0,-1,0,0,0,0,0,0,0,-1,0,0,-1,1,0,0,0,0,1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0]]]], [ # Q-class [27][04] [[6], [3,6], [1,1,6], [2,2,2,6], [3,2,0,1,6], [2,1,3,1,0,6], [1,1,3,3,0,2,6], [1,3,2,1,0,2,2,6], [1,2,2,1,0,2,3,3,6], [2,3,1,3,1,1,1,2,2,6], [2,1,2,1,0,3,2,3,2,1,6], [1,1,0,1,3,0,0,0,0,1,0,6], [2,3,1,2,1,1,1,2,3,3,1,2,6], [3,2,1,3,1,2,1,1,1,3,3,1,2,6], [3,3,3,3,2,1,2,1,1,2,1,1,2,2,6], [2,2,0,1,3,0,0,0,0,1,0,2,1,1,3,6], [2,3,0,1,3,0,0,0,0,1,0,2,1,1,2,3,6], [1,1,3,2,0,2,3,3,2,1,3,0,1,1,2,0,0,6], [0,0,1,0,3,1,2,1,2,0,1,2,0,0,0,1,1,1,6], [1,1,0,2,3,0,0,0,0,3,0,3,1,2,1,2,2,0,2,6], [0,0,1,0,2,1,1,2,1,0,2,3,0,0,0,1,1,3,3,2,6], [1,1,0,1,2,0,0,0,0,1,0,3,2,1,1,2,3,0,1,2,1,6], [1,1,0,2,2,0,0,0,0,2,0,2,1,3,1,3,2,0,1,3,1,2,6], [1,1,0,1,2,0,0,0,0,1,0,3,3,1,1,3,2,0,1,2,1,3,3,6], [3,2,1,2,1,3,1,1,1,2,2,2,3,3,2,1,1,1,0,1,0,3,1,2,6], [0,0,2,0,2,2,1,1,1,0,1,2,0,0,0,1,1,1,3,3,3,1,1,1,0,6], [0,0,1,0,1,1,3,1,2,0,1,1,0,0,0,1,2,1,3,1,2,2,1,1,0,2,6]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,-1,0,0,1,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,-1,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,0,0,1,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,1,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0], [0,0,0,-1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,0,1,0,1], [0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0], [0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,1], [0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,1], [0,0,0,-1,0,0,1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,1], [0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,1], [0,0,1,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,1], [0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,-1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0], [0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,-1,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0]]]], [ # Q-class [27][05] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]] ]; MakeImmutable( IMFList[27].matrices ); gap-4r6p5/grp/glzmodmz.gd0000644000175000017500000000230312172557252014106 0ustar billbill############################################################################# ## #W glzmodmz.gd GAP library Stefan Kohl #W Alexander Hulpke ## ## #Y Copyright (C) 2011 The GAP Group ## ## This file contains declarations for constructing clasical groups over ## residue class rings. ############################################################################# ## #F SizeOfGLdZmodmZ( d, m ) . . . . . . . . . . Size of the group GL(d,Z/mZ) ## ## Computes the order of the group `GL( , Integers mod )' for ## positive integers and > 1. ## DeclareGlobalFunction( "SizeOfGLdZmodmZ" ); ############################################################################# ## #F ConstructFormPreservingGroup(oper [,sign] d, R ) ## ## constructs the classical group sefined by oper over a prime field ## over the residue class ring R, which must be modulo an odd prime ## power. DeclareGlobalFunction("ConstructFormPreservingGroup"); ############################################################################# ## #E glzmodmz.gd . . . . . . . . . . . . . . . . . . . . . . . . . . ends here gap-4r6p5/grp/imf26.grp0000644000175000017500000022530612172557252013376 0ustar billbill############################################################################# ## #A imf26.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Q-class representative of the irreducible ## maximal finite integral matrix groups of dimension 26, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Q-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 26. ## IMFList[26].matrices := [ [ # Q-class [26][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [26][02] [[2], [1,2], [0,0,2], [0,0,1,2], [0,0,0,0,2], [0,0,0,0,1,2], [0,0,0,0,0,0,2], [0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [26][03] [[5], [3,5], [2,3,5], [1,2,3,5], [-1,1,2,3,5], [-3,-1,1,2,3,5], [-3,-3,-1,1,2,3,5], [-3,-3,-3,-1,1,2,3,5], [-3,-3,-3,-3,-1,1,2,3,5], [-1,-3,-3,-3,-3,-1,1,2,3,5], [1,-1,-3,-3,-3,-3,-1,1,2,3,5], [2,1,-1,-3,-3,-3,-3,-1,1,2,3,5], [3,2,1,-1,-3,-3,-3,-3,-1,1,2,3,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,3,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,3,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,2,3,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,-3,-1,1,2,3,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,-3,-3,-1,1,2,3,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,-3,-3,-3,-1,1,2,3,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,-3,-3,-3,-3,-1,1,2,3,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-3,-3,-3,-3,-1,1,2,3,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-3,-3,-3,-3,-1,1,2,3,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,-1,-3,-3,-3,-3,-1,1,2,3,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,3,2,1,-1,-3,-3,-3,-3,-1,1,2,3,5]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,1,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,1,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,-1,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,-1,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,1,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,-1,0,1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,-1,0,0,1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,-1,0,1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,-1,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,-1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,1,-1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,-1,0,0,0,1,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,0,-1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,-1,0,0,0,0,0,1,-1,-1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,1,0,1,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,-1,0,1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,-1,1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,-1,0,-1,1,1,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,1,0,-1,-1,0,0,1,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,-1,0,0,1,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,0,-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,1,-1,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,1,1,-1,-1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,1,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,1,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,-1,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,-1,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,1,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,-1,0,1,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,1,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,1,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,-1,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,-1,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,1,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,-1,0,1,0,0,0,0,1]]]], [ # Q-class [26][04] [[5], [-1,5], [-1,-1,5], [-1,-1,-1,5], [1,-1,-1,-1,5], [-1,1,-1,-1,-1,5], [1,-1,1,-1,-1,-1,5], [1,1,-1,1,-1,-1,-1,5], [-1,1,1,-1,1,-1,-1,-1,5], [1,-1,1,1,-1,1,-1,-1,-1,5], [-1,1,-1,1,1,-1,1,-1,-1,-1,5], [-1,-1,1,-1,1,1,-1,1,-1,-1,-1,5], [-1,-1,-1,1,-1,1,1,-1,1,-1,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,-1,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,-1,1,-1,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,-1,1,-1,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,1,-1,1,-1,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,1,1,-1,1,-1,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,-1,1,1,-1,1,-1,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,1,-1,1,1,-1,1,-1,-1,-1,5]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,0,-1,-1,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,1,0,0,0,-1,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,-1,0,-1,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,1,0,0,0,-1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,1,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,-1,-1,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,1,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,1,1,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,-1,-1,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,-1,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,1,0,0,0,-1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,1,1,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,-1,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,-1,0,-1,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,-1,0,-1,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,1,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [26][05] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [26][06] [[3], [1,3], [1,1,3], [1,1,1,3], [1,1,1,0,3], [1,1,1,1,1,3], [1,1,1,1,1,1,3], [1,1,1,1,1,1,1,3], [1,1,1,1,1,1,0,1,3], [1,1,1,1,1,1,1,1,1,3], [1,1,1,1,0,0,0,0,1,1,3], [1,1,1,0,1,1,0,0,1,1,1,3], [1,0,1,0,1,1,1,0,0,0,1,1,3], [1,1,1,0,1,1,1,1,0,1,0,1,1,3], [1,1,1,0,1,1,1,0,1,1,1,1,1,0,3], [1,1,1,1,0,0,1,0,0,0,0,0,0,1,0,3], [1,1,1,1,1,1,0,1,1,1,1,0,0,1,0,0,3], [1,1,1,0,1,1,1,0,0,1,1,1,1,1,1,1,0,3], [1,1,1,1,1,1,1,0,1,1,0,1,0,1,1,1,1,0,3], [1,1,1,1,0,1,1,1,1,0,1,1,1,0,1,0,0,0,0,3], [1,1,1,1,1,1,0,0,1,1,1,1,1,1,0,1,1,1,1,0,3], [0,1,1,1,1,1,1,1,1,1,0,1,0,1,0,0,1,0,1,1,0,3], [1,1,1,0,1,0,1,1,0,1,1,1,1,1,1,0,0,1,0,1,0,0,3], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,1,1,0,1,1,1,1,3], [1,0,1,1,0,0,1,0,1,0,1,0,1,0,1,1,0,0,1,1,0,0,1,0,3], [1,1,0,1,1,1,1,1,1,1,1,1,1,1,0,0,1,0,1,1,1,1,1,1,1,3]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,1,5,3,-2,-5,-1,-1,-2,-2,-6,1,-3,2,6,-4,1,3,-4,-1,1,-1,-4,1,1,7], [1,0,3,2,-2,-3,0,0,-1,-2,-4,1,-2,1,4,-3,1,2,-3,-1,2,0,-2,0,1,4], [1,0,3,1,-1,-2,0,0,-2,-2,-3,1,-3,1,4,-2,0,1,-3,-1,2,0,-2,1,1,4], [0,1,2,2,-1,-3,-1,-1,0,0,-4,0,0,1,2,-2,1,2,-1,1,0,-1,-2,0,0,3], [1,1,2,1,-1,-2,-1,0,-1,-1,-3,0,-1,1,3,-2,0,1,-2,-1,1,0,-2,1,1,3], [1,0,2,0,-1,-1,-1,0,-2,-1,-2,0,-2,0,3,-1,0,0,-2,-1,2,1,-1,1,1,3], [0,1,2,1,0,-2,-2,0,-2,0,-3,0,-1,1,2,-2,0,2,-1,1,0,-1,-3,1,2,3], [1,0,2,1,0,-1,-1,-1,0,-1,-1,-1,-1,1,2,-1,-1,1,-1,0,0,0,-1,0,-1,3], [1,0,2,1,-1,-1,-1,-1,0,-1,-2,-1,-1,1,2,-1,0,1,-1,0,0,0,0,0,-1,3], [1,-1,2,1,-1,-1,1,-1,0,-2,-1,0,-2,1,3,-1,0,0,-2,-1,1,0,0,0,-1,3], [1,0,2,2,-1,-2,0,-1,0,-2,-2,0,-2,2,3,-2,0,1,-2,-1,1,0,-1,0,0,3], [0,0,-1,0,0,0,1,0,0,0,0,1,0,0,0,0,1,-1,-1,0,1,0,0,0,1,-1], [0,1,1,2,-1,-3,0,0,-1,-1,-4,2,-1,1,2,-3,2,2,-2,0,1,-1,-2,0,2,2], [1,0,2,1,-1,-2,-1,-1,0,0,-2,-1,0,1,2,-1,0,1,-1,0,0,0,-1,0,-1,3], [1,0,2,1,-2,-2,1,0,-1,-2,-3,2,-2,0,3,-2,1,1,-3,-2,2,1,-1,0,1,3], [0,1,2,2,-1,-3,0,0,-1,-1,-4,1,-1,1,3,-3,1,2,-2,0,1,-1,-2,0,1,3], [1,0,2,1,-2,-2,0,-1,1,-1,-3,0,0,0,2,-1,1,1,-1,-1,0,0,0,0,-1,3], [1,0,2,1,-1,-2,0,0,-1,-2,-2,0,-2,1,3,-2,0,1,-2,-1,2,1,-1,0,0,3], [1,0,2,1,0,-1,-1,0,-2,-1,-1,0,-2,1,3,-1,-1,0,-2,-1,1,0,-2,1,1,3], [1,0,2,2,-1,-2,1,-1,0,-2,-3,1,-2,1,3,-2,1,1,-3,-1,1,0,-1,0,0,3], [0,1,2,2,-1,-3,-1,0,-1,-1,-4,1,-1,1,3,-2,1,2,-2,0,1,-1,-2,0,1,3], [1,0,2,1,-1,-2,-1,0,-2,-1,-2,0,-2,1,3,-2,0,1,-1,0,1,0,-2,1,1,3], [1,0,3,2,-1,-2,-1,-1,-1,-2,-3,0,-2,1,4,-2,0,1,-2,-1,1,0,-1,1,0,4], [1,-1,-1,-2,0,2,1,1,-1,-1,3,0,-1,-1,0,1,-1,-2,0,-1,2,2,1,0,0,-1], [1,0,1,0,0,0,0,0,-2,-2,0,0,-3,1,3,-1,-1,-1,-2,-1,2,1,-1,1,1,2]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,2,1,0,-1,-1,-1,0,-1,-1,-1,-1,1,2,-1,-1,1,-1,0,0,0,-1,0,-1,3], [2,-1,2,1,-1,-1,0,0,-2,-3,-1,0,-4,1,5,-2,-1,0,-3,-2,3,2,-1,1,1,3], [2,-1,2,0,-1,0,-1,0,-1,-2,0,-1,-2,0,3,0,-2,0,-1,-2,1,2,0,1,-1,3], [0,0,0,0,1,0,-1,0,-1,1,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,1,0], [1,0,3,2,-1,-3,-1,-1,-1,-1,-4,0,-2,1,4,-2,0,2,-2,0,1,0,-2,1,0,4], [1,-1,0,-1,0,1,0,0,0,-1,2,-1,-1,0,1,1,-1,-1,0,-1,1,2,1,0,-1,0], [1,0,3,1,-1,-3,-1,0,-2,-1,-3,0,-2,1,4,-2,0,2,-2,0,1,0,-3,1,1,4], [0,0,-1,0,1,1,-1,0,0,1,1,-1,1,0,-1,1,-1,0,1,1,-1,0,0,0,0,-1], [1,0,3,2,-1,-3,-1,0,-2,-2,-4,1,-3,2,5,-3,0,2,-3,-1,2,0,-3,1,2,4], [1,0,1,1,0,0,0,0,0,-1,0,0,-1,1,1,-1,-1,0,-1,-1,0,0,-1,0,0,1], [1,0,2,2,-1,-2,0,-1,0,-1,-3,0,-1,1,3,-2,0,1,-2,-1,1,0,-1,0,0,3], [1,0,1,1,0,-1,0,-1,0,0,-1,0,-1,1,1,-1,0,0,-1,0,0,0,-1,0,0,1], [1,0,2,1,-1,-2,0,-1,0,-1,-2,0,-1,1,2,-2,0,1,-1,0,1,0,-1,0,0,2], [0,0,-1,0,1,1,0,0,0,0,1,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,-1], [1,-1,-1,-2,0,3,0,0,1,-1,4,-2,0,-1,-1,2,-2,-2,2,-1,0,2,3,0,-2,-1], [1,0,2,1,0,-1,-1,0,-2,-1,-1,0,-2,1,2,-2,-1,1,-1,0,1,0,-2,1,1,2], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,-1,-1,0,2,0,0,0,-1,2,-1,0,-1,0,1,-1,-1,1,-1,1,2,2,0,-1,-1], [1,0,2,2,-1,-2,0,-1,0,-1,-2,0,-1,1,3,-1,0,1,-2,-1,0,0,-1,0,-1,3], [1,0,2,2,-1,-2,-1,-1,0,-1,-3,0,-1,1,2,-2,0,2,-1,0,0,0,-1,0,0,3], [1,0,2,1,-1,-2,-1,0,-2,-1,-2,0,-2,1,4,-2,-1,1,-2,-1,2,1,-2,1,1,3], [1,0,2,1,0,-1,0,-1,0,-1,-1,0,-1,1,2,-1,0,0,-2,-1,0,0,-1,0,0,2], [1,0,2,1,0,-1,-1,-1,0,0,-1,-1,-1,1,1,-1,-1,1,-1,0,0,0,-1,0,0,2], [1,-1,-2,-2,1,4,0,0,1,0,5,-2,1,-1,-2,3,-2,-3,2,-1,-1,2,3,0,-2,-3], [1,0,2,1,0,-1,-1,-1,0,0,-1,-1,0,1,1,-1,-1,1,0,0,-1,0,-1,0,-1,2]]]], [ # Q-class [26][07] [[8], [2,8], [4,1,8], [4,1,2,8], [2,2,-2,1,8], [4,1,2,2,1,8], [2,-1,1,4,2,1,8], [2,2,1,1,2,1,2,8], [2,2,4,1,-1,1,2,2,8], [1,1,2,-1,1,2,1,1,1,8], [2,2,1,1,2,1,2,2,2,1,8], [1,1,2,-1,1,2,1,4,4,2,1,8], [2,2,1,4,2,1,2,2,2,-2,2,1,8], [2,2,1,1,2,1,2,-1,2,1,2,1,2,8], [1,1,2,2,1,2,1,1,1,2,1,2,4,1,8], [2,2,1,1,2,4,-1,2,2,1,2,4,2,2,4,8], [1,1,2,2,1,2,4,1,1,2,1,2,1,4,2,1,8], [2,2,1,1,2,1,2,2,2,1,2,4,2,2,1,2,4,8], [1,1,2,2,1,2,1,1,1,2,1,2,1,4,2,4,2,1,8], [4,1,2,2,1,2,1,1,1,2,1,-1,1,4,-1,1,2,1,2,8], [4,1,2,2,1,2,1,1,1,2,1,2,1,1,2,1,-1,1,2,2,8], [1,1,2,2,1,2,1,1,1,2,1,-1,1,1,2,1,-1,-2,2,2,2,8], [2,-1,1,1,2,1,2,2,2,1,2,1,2,2,1,2,1,2,1,4,1,4,8], [2,2,1,4,2,1,2,2,2,1,-1,1,2,2,1,2,1,2,4,1,1,1,-1,8], [2,2,1,1,2,1,2,2,2,1,2,4,2,2,1,2,1,2,1,1,4,1,2,-1,8], [2,2,1,1,2,4,-1,2,-1,4,2,1,-1,-1,1,2,1,2,1,1,1,1,-1,2,-1,8]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [-5,-1,3,5,2,3,-1,5,0,3,-1,-4,-2,5,-1,2,-4,3,-2,-2,1,-2,-1,-3,-1,-3], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [4,2,-3,-6,-2,-2,1,-6,-1,-4,3,5,1,-7,2,-3,5,-5,1,3,-1,1,3,6,2,2], [1,0,0,-1,0,-1,1,-1,0,0,0,0,1,-1,-1,1,1,0,0,0,0,1,-1,0,0,0], [1,0,-1,-2,-1,-1,1,-1,0,-1,0,0,1,-1,-1,1,2,-1,0,0,1,1,0,1,0,1], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [-1,0,1,0,0,1,0,0,-1,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,1,0,-1], [-3,-1,2,4,2,2,-1,3,0,3,-1,-2,-1,3,-1,1,-3,3,-1,-1,0,0,-2,-3,-1,-3], [-5,-2,4,6,2,2,0,7,1,5,-4,-7,0,8,-4,5,-5,5,-2,-5,2,-1,-3,-7,-2,-2], [-6,-2,4,7,3,3,-1,7,1,5,-3,-6,-1,7,-3,4,-5,6,-2,-3,2,0,-4,-7,-3,-4], [-4,-2,3,5,2,2,-1,5,1,4,-2,-5,0,5,-3,4,-3,4,-2,-3,2,0,-3,-5,-2,-3], [2,0,-1,-3,-1,-1,1,-1,0,-1,0,0,1,-2,0,0,2,-1,1,0,0,1,0,1,1,1], [0,-1,0,0,0,0,0,1,0,1,0,-1,1,0,-1,1,0,1,0,0,0,1,-2,-1,0,-1], [-6,-2,4,7,2,3,-1,7,1,5,-3,-6,-1,8,-3,4,-5,5,-3,-4,2,-1,-3,-6,-2,-3], [2,0,-1,-2,-1,-2,1,-1,0,0,-1,0,2,-1,-2,2,2,-1,0,-1,1,1,0,0,0,1], [-3,-1,2,4,1,1,0,4,0,3,-2,-3,0,5,-2,3,-3,3,-2,-2,1,0,-2,-4,-2,-2], [-5,-1,3,5,2,2,0,5,1,4,-3,-5,0,6,-3,4,-4,4,-2,-3,2,-1,-2,-5,-2,-2], [-4,-2,3,4,2,1,0,5,1,4,-3,-5,1,5,-4,5,-3,4,-2,-3,2,0,-3,-5,-2,-2], [-2,-1,1,3,1,1,-1,3,1,3,-1,-3,0,3,-2,2,-1,2,-1,-2,1,0,-2,-3,-1,-2], [-1,0,1,0,0,0,1,0,-1,0,0,0,0,1,0,1,-1,0,-1,0,0,0,0,0,0,0], [5,2,-4,-6,-3,-2,1,-6,-1,-4,3,5,1,-7,2,-3,5,-5,2,3,-1,1,3,6,2,2]], [[-11,-4,7,13,5,6,-3,13,2,9,-5,-11,-2,14,-5,6,-10,10,-4,-6,3,-2,-6,-11,-4,-6], [-7,-2,5,8,3,4,-2,7,0,5,-2,-5,-2,8,-2,2,-6,5,-3,-3,1,-2,-2,-5,-2,-4], [-1,-1,0,2,1,1,-1,1,1,1,0,-1,-1,1,0,0,-1,1,0,0,0,0,-1,-1,0,-1], [-3,-1,2,3,1,2,-1,3,0,3,-1,-3,0,3,-2,2,-2,2,-1,-2,1,-1,-1,-2,-1,-2], [-4,-2,3,5,2,2,-1,6,1,4,-3,-5,0,6,-3,3,-4,5,-1,-3,1,0,-3,-6,-2,-2], [-3,-1,2,3,1,1,0,3,1,2,-2,-3,0,4,-2,2,-3,2,-1,-2,1,-1,-1,-3,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0], [-3,-1,2,3,1,1,0,3,0,2,-1,-2,0,3,-2,2,-2,2,-1,-1,1,0,-2,-3,-1,-1], [0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-3,-1,2,4,2,2,-1,3,1,2,-1,-2,-1,3,-1,1,-3,3,-1,-1,0,0,-2,-3,-1,-2], [-7,-2,5,8,3,4,-1,8,1,5,-3,-7,-2,9,-2,3,-7,6,-2,-4,1,-2,-3,-7,-2,-3], [-3,0,2,3,1,1,0,2,0,1,-1,-1,-1,3,-1,1,-2,1,-1,-1,1,-1,0,-2,-1,0], [1,1,-1,-1,-1,0,0,-2,-1,-1,1,2,0,-2,1,-2,1,-2,1,1,-1,-1,2,2,1,1], [-1,-1,1,2,1,0,0,2,1,2,-2,-3,1,2,-2,2,-1,2,0,-2,1,0,-1,-3,-1,0], [1,1,-1,-1,-1,0,0,-2,0,-1,1,2,0,-2,1,-2,1,-2,1,1,-1,-1,2,2,1,1], [-3,-1,2,3,1,1,0,3,1,2,-2,-3,0,4,-2,2,-2,2,-1,-2,1,-1,-1,-3,-1,0], [-1,-1,1,2,1,0,0,2,1,2,-2,-2,1,2,-2,2,-1,1,0,-2,1,0,-1,-3,-1,0], [-6,-2,4,8,3,3,-2,7,1,5,-3,-5,-1,8,-3,3,-5,5,-2,-4,2,-1,-3,-7,-3,-3], [-1,-1,1,1,1,0,0,1,1,1,-1,-2,1,1,-2,2,0,1,0,-1,1,0,-1,-2,-1,0], [-3,-2,2,4,2,2,-1,4,1,3,-2,-4,0,4,-2,2,-3,4,-1,-2,1,0,-3,-4,-1,-2], [-6,-1,4,6,2,4,-2,5,0,3,-1,-4,-2,6,-1,1,-5,4,-2,-2,1,-2,-1,-3,-1,-3], [4,1,-3,-5,-2,-2,1,-5,0,-3,2,3,1,-6,1,-2,4,-3,2,2,-1,1,2,4,2,2], [-2,-1,1,3,1,1,0,3,1,2,-2,-3,0,3,-2,2,-2,3,0,-2,1,0,-2,-4,-1,-1], [3,0,-2,-3,-1,-2,0,-3,0,-1,1,2,2,-4,-1,0,4,-2,1,1,0,2,0,2,0,1], [-6,-1,4,6,2,3,-1,5,0,3,-2,-4,-2,6,-1,2,-5,4,-2,-2,1,-2,-1,-4,-1,-2], [-4,-2,3,5,2,2,-1,5,1,4,-2,-4,0,6,-3,3,-4,4,-2,-3,1,0,-3,-5,-2,-2]]]], [ # Q-class [26][08] [[4], [1,4], [0,0,4], [1,1,0,4], [0,1,-1,1,4], [0,0,1,0,1,4], [1,1,1,-1,-1,0,4], [-1,0,1,-1,-1,-2,0,4], [0,0,0,0,1,1,-1,0,4], [1,1,0,2,1,-1,-2,0,0,4], [0,1,0,1,0,-1,0,0,0,1,4], [0,0,2,0,0,0,1,0,0,0,1,4], [0,1,0,-1,-1,0,0,1,-1,0,-1,-1,4], [1,0,0,-1,0,1,2,-2,0,-1,0,0,-1,4], [-1,1,-1,0,0,-1,0,1,0,0,1,0,-1,-1,4], [0,2,1,0,0,1,1,0,-1,0,0,-1,2,1,-1,4], [-1,0,1,-1,-1,-1,0,2,1,0,-1,-1,1,0,-1,1,4], [-1,1,0,1,0,-1,1,1,0,-1,1,0,-1,-1,2,0,0,4], [1,1,0,0,0,2,1,-1,0,-1,-1,-1,0,1,1,1,-1,0,4], [0,1,0,2,2,1,0,-2,0,1,1,1,-1,1,-1,1,-1,0,0,4], [1,-1,0,1,1,1,0,-1,1,0,0,1,-2,0,1,-2,-2,0,1,0,4], [0,-1,0,1,0,1,-2,-2,1,1,-1,0,-1,0,-1,-1,0,-1,0,1,0,4], [0,0,0,2,1,-1,-1,1,1,1,0,1,0,-2,0,-1,0,1,-1,1,1,0,4], [0,0,-1,1,1,-1,0,0,1,1,0,-1,-1,1,0,0,1,1,-1,1,0,0,1,4], [1,1,0,0,1,1,-1,-1,-1,1,0,0,1,0,-1,1,-1,-2,1,1,-1,1,-1,-2,4], [1,1,1,-1,-1,0,2,0,1,-1,0,0,0,2,-1,1,2,0,1,0,-1,0,-1,0,0,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,-1,0,1,0,-1,0,1,1,0,-1,0,1,1,0,0,-1,1,0,1,0,0,-1,-1,0,0], [0,0,0,-1,-2,0,-1,-1,1,1,-1,0,-1,0,0,0,0,1,0,1,0,-2,0,0,1,0], [-1,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,1,-1,-1,0,-1,0,0,0,1,0,1], [0,0,0,0,1,-1,1,1,0,-1,1,0,0,0,0,1,0,-1,1,0,0,2,0,0,-1,-1], [1,-1,1,0,1,-1,0,-1,0,-1,0,0,1,-1,1,0,1,0,0,1,0,0,-1,0,0,0], [-1,0,0,1,0,-1,0,0,1,1,-1,0,1,1,-1,-1,-1,1,0,0,0,-1,-1,-1,0,0], [0,-1,0,1,1,0,0,0,0,0,0,1,0,0,1,1,-1,-1,0,-1,-1,0,0,0,-1,1], [-1,1,-1,0,-2,1,-1,1,0,1,-1,0,-1,1,-1,0,-1,1,-1,0,1,-1,0,0,1,1], [1,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,-1,-1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,-1,0,0,0,0,0,0,0,0,1], [-1,1,0,0,0,0,1,1,0,1,0,-1,1,2,-1,-1,0,1,0,0,1,1,0,-1,0,-1], [1,0,1,0,1,0,0,0,-1,-2,1,0,0,-1,1,0,1,-1,0,0,0,1,0,1,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,-1,-1,0,0,0,-1,0,0,-1,-1,0,0,0,0], [0,1,1,0,0,-1,0,1,0,-1,0,-1,1,1,0,-1,0,0,0,1,1,1,-1,0,0,-1], [0,0,0,1,0,0,-1,0,0,0,-1,1,1,1,0,-1,0,1,0,0,0,-1,-1,0,0,0], [1,-1,1,0,0,-1,-1,-2,1,0,-1,0,0,-1,1,0,0,0,0,1,-1,-2,-1,0,0,0], [0,0,0,0,1,-1,1,0,0,-1,1,0,0,0,0,0,1,-1,1,0,0,1,0,0,0,-1], [0,0,0,-1,-1,0,0,0,0,0,0,0,-1,-1,0,1,0,0,0,0,1,0,0,1,1,0], [0,-1,0,0,0,0,0,-1,0,0,0,0,-1,-1,1,1,0,-1,0,0,-1,-1,1,0,0,1], [0,0,-1,0,-1,1,0,0,0,0,0,1,-1,0,0,1,0,0,0,-1,0,0,1,1,1,0], [-1,-1,0,0,-1,0,0,-1,1,2,-1,0,0,0,0,0,-1,1,0,0,0,-2,0,0,1,1], [0,0,1,0,-1,0,-1,-2,0,0,-1,0,-1,-1,1,0,0,0,-1,0,0,-2,0,1,1,1], [-1,1,-1,0,0,0,1,2,0,0,1,0,0,1,-2,0,0,0,1,-1,1,2,0,0,0,-1], [1,-1,0,1,1,0,0,0,0,-1,0,1,1,0,1,0,1,0,0,0,0,0,-1,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,-1,0,1,0,0,0,0,0,1,-1,0,0,0,1,0,0,1,0,-1,-1,-1], [1,-1,-1,-1,1,0,0,0,-1,0,1,1,0,-1,0,1,1,0,1,0,0,1,0,0,-1,0], [0,0,1,0,1,-1,0,0,0,0,0,-1,1,1,0,0,-1,0,0,0,0,1,0,-1,-1,0], [0,0,0,1,1,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,1,0,-1,-1,0], [1,0,0,-1,0,1,0,-1,-1,0,0,0,-1,-1,1,1,1,0,-1,0,0,0,1,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,1,0,-1,-1,0,0,0,1,0,0,0,-1,1,0,0], [0,0,-1,0,0,0,-1,1,0,0,0,1,0,0,-1,0,0,0,1,0,0,0,-1,0,-1,0], [0,-1,-1,1,0,0,0,0,1,1,-1,1,0,0,0,1,0,1,0,0,0,-1,-1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,1,-1,0,0], [-1,1,0,0,0,-1,0,0,0,0,0,0,0,0,-1,0,-1,-1,1,0,0,0,0,0,-1,0], [0,-1,0,0,1,-1,1,0,0,0,1,0,0,-1,0,1,0,-1,1,0,0,1,0,0,-1,0], [1,1,0,-1,-1,0,-1,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,0,0,0,-1], [0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,1,0], [-1,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,0,0], [1,1,0,-1,0,0,-1,1,-1,-1,0,0,0,0,0,0,0,0,0,1,0,1,0,0,-1,0], [0,0,-1,0,0,0,-1,1,0,0,0,1,0,0,-1,0,0,1,1,0,0,0,-1,0,0,0], [-1,0,0,1,1,-1,0,1,0,0,0,1,1,1,-1,0,-1,0,1,-1,0,1,-1,0,-1,0], [1,0,0,0,0,1,0,0,-1,0,0,0,0,0,1,0,1,0,-1,0,0,0,0,0,0,0], [0,0,1,0,1,-1,0,1,0,0,0,-1,1,1,0,0,-1,0,0,1,0,1,0,-1,-1,0], [0,-1,0,1,1,0,1,-1,0,0,0,0,0,-1,1,1,0,-1,-1,-1,0,0,0,0,0,1], [0,-1,0,0,0,1,1,0,0,1,0,-1,0,1,1,0,0,1,-1,0,0,0,1,-1,1,0], [0,-1,0,1,1,-1,0,1,1,0,0,0,1,1,0,1,-1,0,0,0,0,1,-1,-1,-1,0], [-1,0,0,1,0,-1,0,1,1,0,-1,0,1,1,-1,0,-1,1,0,0,1,0,-1,0,1,0], [1,1,0,-1,0,1,0,1,-1,0,1,-1,0,1,0,-1,1,0,0,1,0,1,1,-1,-1,-1], [0,0,-1,0,0,0,0,1,0,1,0,1,0,0,-1,0,0,1,1,0,0,0,-1,0,0,0]]]], [ # Q-class [26][09] [[6], [0,6], [-1,0,6], [2,-1,-1,6], [2,3,-1,0,6], [1,-1,1,0,-2,6], [2,-1,0,1,1,0,6], [2,-2,1,0,1,1,0,6], [1,-1,0,1,0,3,2,2,6], [-2,1,1,-1,-2,2,0,-1,2,6], [-1,-1,-1,0,-1,2,-1,1,2,0,6], [0,0,2,1,-1,1,2,1,2,1,2,6], [0,1,0,-1,0,-2,2,-2,0,-1,0,2,6], [0,-2,-3,0,-2,1,1,0,0,2,0,-1,-2,6], [-2,1,-1,-3,0,-2,1,-2,-1,1,1,1,3,0,6], [0,1,1,3,0,1,-1,0,1,0,-1,1,-1,-2,-3,6], [-1,3,0,1,1,2,-2,0,1,2,1,1,-2,0,-2,3,6], [3,1,1,2,2,1,1,1,1,-1,1,1,-1,-2,-1,0,0,6], [3,1,0,1,1,-1,3,0,-1,0,-3,1,2,1,0,0,-1,0,6], [0,1,2,1,-2,2,-3,-1,-1,0,0,1,0,-2,-2,3,2,0,0,6], [-3,2,1,-1,1,0,-1,-2,0,1,2,0,0,-2,2,0,2,0,-3,0,6], [0,1,-2,-1,0,-1,-1,-2,0,-1,2,-1,2,-1,2,-1,-1,1,-2,-1,1,6], [0,-1,-1,-2,-3,1,-2,-1,0,1,1,-2,1,1,1,-2,-2,-1,-1,1,-1,3,6], [1,-2,-2,-1,0,1,2,3,3,0,1,1,0,2,1,-1,-1,-1,0,-3,-2,0,0,6], [1,0,2,0,0,3,0,2,2,0,0,1,-1,-1,-3,3,2,-1,0,2,0,-2,-1,1,6], [0,-2,0,1,0,0,2,1,1,-1,0,0,-1,1,-1,0,-1,0,0,-2,0,-1,-2,2,2,6]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1,0,0,0,0], [1,0,1,0,1,0,0,-1,0,0,1,0,0,0,0,0,0,-1,-1,0,-1,0,0,0,0,0], [-1,0,-1,0,-1,0,0,0,0,-1,-1,1,-1,-1,0,-1,1,1,1,-1,0,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [-1,0,0,1,0,0,0,1,1,-1,-1,0,0,1,1,-1,0,0,0,1,0,1,0,-1,1,0], [2,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,-1,-1,0,0,0,0,0,-1,1], [-1,0,0,1,1,1,1,1,-1,1,0,0,0,0,-1,-1,-1,-1,0,1,0,2,-1,0,0,0], [0,-1,0,1,0,0,0,1,0,0,-1,0,0,0,1,-1,1,0,0,0,0,1,0,-1,1,0], [-1,-1,-2,0,-2,-1,1,1,1,0,-1,-1,-1,-2,1,-2,1,1,1,1,0,1,-1,-1,2,-1], [0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,-1,0,0], [3,1,1,0,1,1,1,0,-1,0,1,1,0,-1,0,1,1,-3,-2,-1,-1,-1,2,-1,-3,2], [3,0,1,-1,0,0,-1,-1,0,0,1,0,1,0,0,2,1,-1,-1,-2,0,-2,1,0,-2,1], [-1,0,-1,0,-1,0,1,1,0,0,-1,0,-1,-1,0,-1,0,0,1,1,1,1,0,0,0,0], [2,0,0,-1,-1,-1,0,0,0,1,1,-1,1,0,0,1,0,0,-1,0,0,-1,-1,0,-1,0], [-1,0,-1,1,0,1,0,0,0,-1,-1,1,-1,-1,1,-1,1,0,0,-1,-1,0,1,-1,1,0], [-1,1,-1,1,0,1,1,1,0,-1,-1,1,-1,-1,0,-1,0,-1,0,0,0,0,1,-1,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,1,1,0,0,-1,1,0,0,0,0,-1,0,1,0], [1,0,-1,-1,-1,0,1,0,0,0,0,0,-1,-2,0,0,1,-1,0,0,0,0,0,0,-1,1], [0,1,0,0,1,1,0,0,0,-1,0,1,0,0,0,1,0,-1,-1,-1,-1,-1,2,-1,-1,1], [0,0,0,0,0,-1,0,0,0,0,0,0,1,1,0,0,0,1,-1,0,0,-1,0,0,1,-1], [0,-1,0,0,-1,-1,-2,-1,1,0,0,-1,1,1,1,0,0,2,1,-1,0,-1,-1,0,2,-1], [-1,-1,0,0,-1,-1,-1,0,1,0,0,-2,1,1,1,0,0,2,1,0,0,0,-1,0,2,-1], [1,0,1,1,1,1,1,1,-1,1,0,0,0,0,0,0,0,-2,-1,1,0,1,0,0,-2,1], [0,0,1,1,2,1,1,0,0,-1,0,1,-1,0,1,0,1,-2,-1,0,-1,0,2,-1,-1,1], [1,0,1,0,2,1,1,0,-1,0,0,2,-1,0,0,1,0,-2,-1,0,0,0,2,0,-2,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,0,-1,0,-1,-1,0,1,1,0,-1,0,0,1,0,-1,-1,2,1,1,1,1,-1,0,2,-1], [0,-1,-1,0,0,0,0,0,0,1,0,0,-1,-1,0,-1,0,0,1,1,0,1,-1,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,-1,-1,0,0,0,0,0,0,1,0,-1,-1,1,0,0,0,-1,1,-1,1,0,-1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,1,0,1,0,0,0,0,0,0,0], [-1,-1,-1,0,1,0,0,0,0,0,-1,1,0,0,0,0,0,1,0,0,0,0,1,0,1,0], [0,-1,-1,-1,1,0,1,0,-1,1,0,1,0,-1,-2,0,0,0,0,1,1,0,1,1,-1,0], [-1,-1,-1,-1,-1,-1,0,0,0,1,0,-1,1,0,-1,0,0,2,1,1,1,0,-1,1,1,-1], [1,0,1,0,1,1,0,-1,0,-1,0,1,0,0,0,1,1,-1,-1,-1,0,-1,2,0,-2,1], [-1,0,0,1,1,1,0,0,0,0,-1,1,0,0,0,-1,0,0,0,0,0,0,1,0,0,0], [1,1,1,0,1,1,1,0,-1,0,0,1,0,0,-1,0,0,-2,-1,0,0,0,1,0,-2,1], [1,-1,1,0,0,0,-1,-1,0,0,1,-1,1,0,1,1,1,0,0,-1,-1,-1,0,0,0,0], [0,0,1,0,0,0,0,-1,0,-1,0,0,0,0,0,0,1,0,0,-1,0,-1,1,0,0,0], [-1,0,-2,0,0,0,0,1,0,1,-1,1,-1,-1,-1,-1,-1,0,1,1,1,1,0,0,0,0], [0,0,-1,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [1,2,0,0,0,1,1,1,0,0,0,1,-1,0,0,1,-1,-2,-1,0,0,0,1,-1,-2,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [2,1,2,0,1,0,0,-1,-1,0,1,0,1,1,-1,1,0,-1,-2,0,0,-1,1,1,-2,1], [2,1,1,-1,0,0,1,0,-1,0,1,0,1,1,-1,2,0,-1,-2,0,0,-1,1,0,-2,1], [0,-1,0,0,1,0,0,-1,-1,0,0,1,0,-1,-1,0,1,0,0,-1,0,-1,2,1,0,0], [0,0,-1,0,0,0,0,1,0,0,-1,1,0,0,0,0,0,0,0,0,1,0,1,0,0,0], [0,-1,1,1,1,0,0,0,-1,0,0,0,0,0,1,0,1,0,0,0,0,0,1,1,0,0]]]], [ # Q-class [26][10] [[5], [1,5], [-1,0,5], [1,1,-1,5], [1,0,1,1,5], [1,1,-1,1,-1,5], [0,0,-1,-1,-1,1,5], [1,0,-1,-1,-1,-1,0,5], [1,1,1,0,-1,1,1,-1,5], [0,1,1,1,1,-1,-1,-1,1,5], [1,-1,-1,1,1,-1,-1,1,-1,-1,5], [0,1,1,-1,0,-1,-1,1,1,1,1,5], [1,1,1,1,-1,1,-1,-1,1,1,-1,-1,5], [0,-1,1,-1,-1,1,-1,0,1,1,-1,1,1,5], [0,1,-1,0,-1,1,0,1,-1,1,-1,1,0,1,5], [1,1,0,1,-1,1,0,1,1,0,-1,-1,0,0,1,5], [0,0,-1,1,-1,0,1,1,-1,-1,1,-1,0,-1,-1,-1,5], [-1,1,1,-1,1,-1,-1,1,-1,0,-1,1,1,-1,1,-1,-1,5], [1,1,1,1,1,-1,1,0,1,1,1,1,-1,-1,-1,-1,1,-1,5], [0,-1,-1,1,1,1,-1,0,-1,1,0,0,-1,1,1,1,-1,-1,-1,5], [-1,0,-1,-1,-1,-1,1,1,-1,0,1,0,-1,-1,0,-1,1,1,1,-1,5], [-1,1,1,-1,1,1,1,-1,1,0,0,1,-1,0,0,-1,-1,1,1,1,1,5], [0,1,0,-1,1,0,0,1,-1,-1,1,-1,-1,-1,0,1,1,1,-1,-1,1,1,5], [-1,-1,-1,-1,1,-1,1,-1,-1,1,1,-1,-1,0,0,-1,-1,-1,-1,1,1,1,1,5], [-1,-1,1,0,1,-1,0,-1,1,1,0,1,1,1,-1,-1,-1,1,-1,-1,-1,-1,-1,1,5], [-1,0,-1,0,-1,1,0,0,1,0,-1,1,0,1,-1,-1,1,1,-1,1,1,1,-1,-1,1,5]], [[[-1,-1,-1,0,1,0,0,0,0,0,0,1,1,0,0,1,0,0,1,-1,-1,0,0,1,-1,1], [0,0,0,0,0,-1,0,1,0,0,0,-1,1,-1,1,-1,-1,-2,0,0,0,1,1,-1,1,1], [0,1,1,0,0,-1,1,0,0,0,1,-1,0,0,1,-1,-1,-1,0,1,0,-1,1,-1,0,1], [0,-1,-1,0,0,0,0,0,0,0,-1,1,1,0,0,0,0,0,1,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,-1,0,0,0,-1,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,1,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,1,-1,0,0,-1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,-1,0,-1,-1,-1,0,1,0,0,1,-1,1,0], [0,0,0,0,1,-1,0,0,0,-1,0,0,1,0,1,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,-1,0,0,1,0,1,0,-1,-1,1,0,0,0,1,0,0,1], [0,-1,0,0,0,0,0,0,-1,0,-1,1,1,-1,0,0,-1,-1,1,0,0,0,1,0,0,1], [0,0,1,1,0,-1,0,1,0,-1,-1,0,1,-1,1,-2,-2,-3,0,1,1,0,2,-1,1,1], [-1,0,0,-1,1,0,0,0,0,0,1,0,1,0,1,1,0,0,1,-1,-1,-1,0,1,-1,2], [-1,0,0,0,1,0,0,0,0,-1,0,0,1,0,1,0,-1,-1,1,0,0,-1,1,0,0,1], [0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,1,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,-1,1,1,-1,0,0,0,-1,0,0,0,0,1,0,0,0], [0,1,1,0,-1,0,0,0,1,0,1,-1,-1,0,0,-1,0,1,0,1,0,-1,0,0,0,0], [0,0,0,0,0,-1,1,0,0,0,0,0,1,0,0,-1,-1,-1,0,1,0,0,1,-1,0,0], [0,0,-1,0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,-1,0,0,1,1,0,-1,1,-1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,1,0,0,0,0,0,-1], [0,1,0,0,0,-1,0,0,0,0,0,-1,0,0,0,-1,0,-1,-1,1,1,1,0,-2,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,-1,0,1,-1,0,0,0], [0,0,1,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,1,0,0,-1,0,1,0,1], [0,0,0,0,0,0,-1,0,1,-1,-1,0,0,0,0,0,1,0,0,1,1,0,0,0,1,-1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,1,0,0,0,0,0,0,0,1,-1,-1,0,0,0,0,0,-1,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,-1,-1,0,1,-1,1], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,-1,0,1,0,-1,0,1,1,0,-1,1,-1,2,2,3,0,-1,-1,0,-2,1,-1,-1], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,1,-1,-1,0,0,0,0,-1,0,0,0,0,-1,0,-1,-1,1,1,1,1,-1,1,-1], [0,1,0,-1,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,1,0,0,0,0,0,0,0,0,1,-1,-1,1,0,0,0,1,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,1,0,-1,1,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,-1,1,1,0,0,-1,1,-1], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1,0,-1,-1,0,-1,1,-1,1], [0,0,0,0,0,1,0,0,0,1,1,0,-1,1,-1,1,1,2,-1,-1,0,0,-2,1,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [1,0,0,1,-2,0,0,0,0,0,-1,0,-1,0,-1,-1,0,1,0,1,0,0,1,0,1,-1], [0,0,0,0,0,-1,0,0,-1,0,0,0,1,-1,1,0,-1,-2,0,0,0,1,1,-1,1,1], [1,1,1,0,-1,0,0,0,0,0,0,-1,-1,0,0,-1,0,0,0,1,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,1,0,0,-1,1,-1,0,1,1,-1,0,0,1,-1,-1,0,-2], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,1,0], [0,1,0,-1,0,0,0,0,0,1,1,-1,-1,0,0,0,1,0,-1,0,0,1,-1,-1,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [-1,0,0,0,1,0,1,0,1,0,1,0,0,1,0,0,0,1,0,0,0,-1,0,0,-1,0], [-1,0,0,0,1,0,1,0,0,0,1,0,1,0,0,0,-1,0,0,0,0,-1,0,0,-1,1], [0,0,-1,0,-1,0,0,0,-1,1,0,0,0,0,-1,0,0,0,0,0,0,1,0,-1,1,-1]]]], [ # Q-class [26][11] [[6], [0,6], [0,-1,6], [1,2,-2,6], [-1,1,-1,3,6], [-1,-1,2,-1,0,6], [0,2,3,1,1,0,6], [-1,0,-2,-2,-1,-2,-1,6], [0,0,1,-1,-1,2,-1,0,6], [-2,-1,2,-3,0,0,0,2,2,6], [0,1,0,2,2,1,0,-1,1,0,6], [-1,1,-1,1,1,0,0,0,0,0,0,6], [1,1,-1,1,1,0,-1,0,-1,-2,0,-2,6], [1,2,-1,2,2,-1,1,-1,-2,-2,1,1,2,6], [1,-1,1,-1,-3,-2,1,1,-2,-1,-2,-1,1,-1,6], [1,-1,0,-1,-2,1,-1,0,-2,-2,-1,0,0,0,1,6], [0,0,0,0,0,0,1,0,0,-2,-2,1,1,2,1,1,6], [0,-2,-1,0,1,-1,-1,1,-2,0,1,-1,1,0,1,0,-2,6], [0,-1,1,1,-1,1,0,0,3,1,2,0,0,-2,1,-2,0,-1,6], [-1,-1,2,-1,-1,3,0,-3,3,1,1,1,-1,0,-1,-2,0,-1,2,6], [1,2,-1,0,0,-2,0,0,0,0,-2,-1,0,0,1,-1,0,-1,-2,-1,6], [1,2,0,1,0,-3,2,-1,-3,-2,-3,1,0,2,2,1,2,-1,-3,-2,3,6], [1,2,-1,3,3,0,1,-2,0,-2,3,0,2,3,-1,-2,0,2,0,1,1,0,6], [0,-2,-3,1,-1,-1,-3,0,-1,-2,-1,0,2,-1,2,1,0,2,1,0,0,0,0,6], [0,-1,-1,-1,-1,-3,-2,2,0,1,0,1,0,-1,1,0,-1,3,0,-1,-1,0,0,2,6], [-1,-1,-1,-1,1,1,-2,-1,1,0,-1,2,1,1,-1,-1,2,0,-1,3,1,0,1,2,0,6]], [[[-1,-1,-4,0,0,1,3,-2,0,-2,-1,-1,1,2,0,2,-3,1,5,-1,2,0,-3,-5,3,4], [0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,1,-1,-1,0,1,-1], [0,0,0,0,0,-1,-1,0,0,1,-1,0,0,-1,1,0,0,-1,-1,0,-2,0,2,0,-1,0], [0,0,0,-1,1,-1,1,0,0,-1,1,1,1,0,-1,0,1,1,0,2,2,-1,-2,1,0,-2], [1,1,2,0,1,0,-1,1,0,1,1,1,0,-1,0,-2,3,0,-4,2,0,-1,0,4,-1,-4], [0,1,1,0,1,-1,-1,1,0,0,-1,0,0,-1,0,1,0,0,0,1,-1,0,1,0,-1,0], [0,0,0,-1,1,-1,0,0,0,-1,-1,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,-1], [0,0,-1,0,0,2,0,0,0,0,0,-1,-1,1,1,0,-1,0,1,-1,0,1,0,-1,1,1], [0,1,1,0,0,0,-1,0,-1,0,-1,0,-1,0,0,0,0,0,1,-1,0,-1,1,0,0,1], [1,1,3,0,0,0,-3,1,0,2,0,1,-1,-1,1,-2,2,-1,-4,0,-2,0,3,4,-2,-3], [0,0,0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [1,1,4,-1,0,-1,-3,1,1,2,1,2,-1,-1,0,-3,3,-1,-6,0,-2,-1,3,7,-4,-5], [-1,-1,-3,1,0,1,3,-1,0,-1,0,-1,1,1,0,2,-2,1,3,0,2,0,-3,-4,3,3], [0,0,-1,0,0,0,1,-1,1,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0], [-1,-2,-2,0,-1,0,2,-1,0,-1,0,0,1,1,0,1,-2,0,2,-1,1,0,-1,-3,1,2], [-1,-1,-2,0,-1,0,1,-1,1,0,0,0,1,0,0,1,-1,0,1,-1,0,1,0,-2,0,1], [0,0,1,0,-2,-1,0,0,0,1,0,1,0,-1,-1,-1,1,0,-2,-1,-1,-1,2,2,-2,-1], [0,-1,-1,0,0,1,1,0,0,0,1,0,1,0,0,0,0,0,0,1,1,1,-1,-1,1,0], [0,0,1,-1,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,-1,1,1,-1,0], [0,1,2,0,0,-1,-1,0,0,0,-1,0,-1,0,0,0,0,0,0,-1,-1,-1,1,1,-1,1], [0,0,0,1,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,1,1,-1,-1,-1,1,0], [0,-1,0,0,-1,-1,0,0,0,0,1,1,1,-1,-1,-1,1,0,-2,1,0,0,0,1,-1,-2], [0,0,0,0,1,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,1,1,-1,-1,0,1,0], [-1,-1,-1,0,-1,0,2,-1,0,-1,1,0,1,1,-1,1,-1,1,2,-1,2,0,-2,-2,1,2], [0,-1,0,0,-1,1,0,0,0,1,1,0,0,0,0,-1,0,-1,-1,-1,0,1,1,1,0,0], [0,1,2,1,-1,0,-1,0,0,1,0,0,-1,0,0,-1,1,0,-2,-1,-1,-1,1,2,-1,0]], [[-1,0,-2,0,-1,1,2,-2,0,-1,-1,-1,0,2,0,1,-2,1,3,-2,1,-1,-2,-3,2,3], [0,0,0,0,0,1,0,0,1,0,1,0,-1,1,1,-1,0,0,-1,-1,0,0,-1,1,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,-1,0,1,0,0,0,1,1,1,0,-1,-1,1,0,-1,0,1,-1,-1,1,0,-1], [0,-1,1,0,0,0,0,1,0,-1,1,1,1,0,-1,-1,1,0,-1,1,1,0,-1,1,0,-2], [1,1,3,-1,0,-1,-3,1,0,2,1,2,0,-2,0,-3,3,-1,-5,1,-2,0,3,5,-3,-5], [-1,0,-2,0,0,1,2,-1,0,-2,0,-1,0,2,0,1,-2,1,4,-1,2,0,-3,-3,2,3], [-1,-1,-2,0,0,0,1,-1,0,-1,-1,-1,0,1,0,2,-2,1,4,-1,1,1,-1,-4,1,3], [0,0,-1,0,0,1,0,-1,1,1,0,0,0,0,1,-1,0,0,-1,-1,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [1,0,3,-1,-1,-1,-2,1,1,2,2,3,1,-2,-1,-3,4,0,-6,1,-1,0,2,6,-4,-6], [0,0,1,0,-1,0,-1,0,1,1,0,0,-1,0,0,-1,0,-1,-1,-2,-2,1,2,2,-1,0], [0,-1,0,0,0,0,0,1,-1,0,1,1,1,-1,-1,0,1,0,-1,2,1,0,0,0,0,-2], [0,0,2,0,-1,-1,-1,1,0,0,1,1,0,-1,-1,-1,1,0,-2,0,-1,0,1,2,-2,-1], [-1,0,-3,1,0,1,2,-1,-1,-1,-1,-2,0,1,0,3,-2,1,5,0,2,0,-2,-5,3,4], [0,1,1,-1,0,-1,-1,0,0,0,-1,0,-1,0,0,0,0,0,0,-1,-1,-1,2,1,-1,0], [-1,0,-2,0,1,0,1,-1,0,-2,-1,-1,0,1,0,2,-2,1,4,0,1,0,-2,-4,2,3], [0,0,1,0,0,0,0,0,-1,0,0,0,0,0,-1,0,1,0,0,0,1,-1,0,1,0,-1], [0,-1,-2,0,-1,0,1,-1,0,1,1,1,2,-1,-1,0,1,1,0,1,1,1,-1,-1,0,-1], [1,1,2,0,0,0,-2,1,0,2,1,1,0,-2,0,-2,2,-1,-4,1,-2,1,2,4,-2,-3], [-1,0,-3,1,1,2,2,-1,0,-2,-1,-3,-1,2,2,2,-3,0,4,-1,1,0,-3,-5,4,5], [-1,0,-2,1,0,1,2,-1,0,-2,-1,-2,-1,2,1,2,-3,0,4,-2,1,-1,-2,-4,3,5], [0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,-1,1,0,-1,0,0,0,-1,1,0,-1], [0,-1,-1,0,0,0,1,0,-1,0,0,0,1,-1,-1,1,0,0,1,1,1,0,0,-1,1,0], [0,0,-1,0,0,1,1,-1,0,0,-1,-1,-1,1,0,1,-1,0,2,-2,0,0,0,-1,1,2], [0,0,1,0,1,0,-1,1,0,0,0,0,0,-1,0,0,0,-1,-1,1,-1,1,1,1,0,-1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,-2,0,0,1,1,-2,0,-1,-1,-1,0,2,1,1,-2,1,4,-2,1,0,-2,-4,2,3], [0,1,0,0,0,0,0,0,0,-1,-1,-1,-1,0,0,0,-1,0,1,-1,-1,0,0,-1,0,2], [0,0,-1,0,-1,0,0,-1,0,1,0,0,0,0,1,0,0,0,0,-1,-1,0,1,-1,0,1], [0,0,1,0,-2,-1,-1,0,0,2,0,1,0,-1,0,-1,1,-1,-2,-1,-2,0,3,2,-2,-1], [0,0,1,0,0,-1,0,1,-1,-1,0,0,0,-1,-1,0,0,0,0,1,0,0,0,0,0,0], [0,1,0,0,0,0,-1,0,0,0,-1,-1,-1,0,1,0,-1,0,1,-1,-2,1,1,-1,-1,2], [0,0,0,0,1,0,0,1,0,0,0,0,1,0,-1,1,0,1,1,2,1,1,-1,0,0,-1], [0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1,-1,1,1], [0,1,1,0,1,0,-1,1,0,0,-1,-1,-1,0,0,0,0,-1,0,0,-1,0,1,1,0,0], [-1,0,-3,1,-1,1,2,-2,-1,-1,-1,-2,0,1,0,2,-2,1,5,-2,1,0,-2,-5,3,5], [0,0,2,0,-1,0,-1,0,0,1,0,1,0,0,0,-2,1,-1,-3,-1,-1,-1,2,3,-1,-2], [0,-1,-1,0,-1,0,1,0,0,0,1,1,1,0,-1,0,0,1,1,0,1,1,-1,-1,0,0], [0,0,0,0,-1,0,0,-1,1,1,0,1,0,0,1,-1,0,0,-1,-2,-1,0,1,1,-1,0], [0,0,-2,0,1,1,1,0,0,-1,0,-1,0,1,0,1,-1,1,2,1,1,1,-2,-2,1,1], [0,0,1,-1,0,-1,0,0,0,-1,0,1,0,0,-1,0,0,1,0,0,1,-1,0,1,-1,-1], [0,-1,0,0,-1,-1,0,0,1,1,1,1,1,-1,0,-1,0,0,-2,0,-1,1,1,1,-2,-1], [0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0], [0,0,-2,1,0,1,1,0,-1,0,0,-2,0,0,0,1,-1,0,2,0,0,1,-1,-3,2,3], [0,0,0,1,0,1,0,0,0,0,0,-1,-1,0,1,-1,0,-1,-1,-1,-1,0,0,0,1,1], [0,0,-1,-1,1,0,0,-1,1,0,0,0,0,1,1,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,-1,0,0,0,-1,1,0,0,1,0,1,1,-1,0,0,-1,-1,0,-1,0,1,-1,-1], [0,0,-1,1,-1,0,0,-1,0,1,0,0,0,0,1,0,0,0,0,-1,-1,0,0,-1,0,1], [0,-1,-1,0,0,1,1,0,0,0,1,0,0,1,0,0,0,0,0,0,1,0,-1,0,1,0], [0,0,0,1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,-1,-1,0,1,0], [0,-1,1,0,-1,0,0,0,1,1,1,1,0,0,0,-2,1,-1,-3,-1,-1,0,1,3,-1,-2]]]], [ # Q-class [26][12] [[4], [1,4], [0,0,4], [0,1,0,4], [1,1,1,1,4], [1,0,1,1,1,4], [1,0,1,0,1,0,4], [1,1,0,1,0,1,0,4], [0,1,0,0,1,0,-1,0,4], [1,0,1,0,0,1,1,0,0,4], [0,1,-1,0,0,0,0,-1,1,1,4], [0,1,1,1,0,0,1,0,0,0,0,4], [0,0,1,1,0,0,0,1,0,1,0,1,4], [0,0,0,0,0,0,0,0,1,0,1,0,0,4], [1,0,-1,0,1,0,0,0,1,-1,0,0,0,0,4], [1,1,0,0,0,0,-1,0,1,0,0,-1,0,1,1,4], [0,0,0,0,1,-1,0,0,0,0,1,-1,0,1,1,0,4], [1,0,0,-1,1,0,0,-1,0,0,1,0,0,0,0,0,1,4], [0,-1,0,1,0,0,1,0,-1,-1,0,0,0,1,0,0,0,0,4], [0,1,1,-1,0,0,0,0,0,-1,1,0,0,1,0,1,0,1,1,4], [0,0,-1,1,0,1,0,0,0,0,1,-1,0,1,0,0,0,-1,1,0,4], [0,0,0,1,0,1,0,0,1,-1,0,0,-1,-1,1,0,0,0,1,0,0,4], [1,0,0,0,0,-1,0,0,0,0,0,1,0,1,1,0,1,1,0,1,-1,-1,4], [0,-1,0,0,1,1,0,-1,0,0,0,0,0,0,1,-1,0,0,1,0,0,1,0,4], [-1,-1,0,0,0,0,0,0,1,1,0,0,0,1,1,0,1,-1,0,-1,0,0,0,0,4], [1,0,0,0,0,0,0,-1,0,1,0,0,-1,0,0,1,0,-1,0,-1,0,0,0,0,0,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,-1,-1,1,1,-1,-1,0,1,0,1,0,0,0,0,1,-2,1,0,-1,0,0,-1,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,-1,0,0,1,0,-1,1,1,-1,0,0,0,1,-1,1,-1,1,1,-1,-1,-1,-1,-1,0], [0,0,0,-1,1,0,0,0,-1,-1,1,0,1,0,-1,1,0,-1,0,-1,0,1,1,0,0,0], [0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,-2,2,0,-1,0,-2,0,1,0,1,1,0,0,-1,-1,0,-1,0,2,1,-1,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,1,-1,1,-1,-1,1,-1,0,1,0,0,1,0,0,-1,0,0,-1,0,1,0,0,0,0], [0,0,0,0,-1,1,0,0,1,0,0,0,0,-1,0,0,1,0,1,0,0,-1,0,0,0,0], [0,0,1,1,-1,-1,1,1,0,-1,1,-1,0,0,0,0,-1,1,-1,0,0,0,0,1,1,1], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,-1,0,0,0,1,1,-1,1,-1,0,1,0,1,0,0,1,0,-1,-1,0,-1,0], [0,0,0,0,-1,1,1,0,1,-1,0,0,0,-1,-1,1,1,0,0,0,0,-1,0,1,0,0], [1,-1,-1,1,-1,1,0,-1,2,1,-1,1,-1,-1,0,0,2,-1,1,1,-1,-2,-1,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,-1,1,1,-1,1,0,-1,0,0,0,0,0,1,0,0,1,-1,-1,-1,0,0,0], [1,-1,0,1,-1,0,0,0,1,0,0,1,-1,-1,0,0,1,0,0,1,0,-1,-1,0,0,0], [0,0,1,1,-1,0,1,1,0,-2,1,-1,0,0,0,0,-1,1,-1,0,0,-1,0,1,1,1], [0,1,1,-1,0,0,0,0,-1,-1,1,-1,1,0,0,0,-1,0,0,-1,0,1,1,0,1,0], [0,0,-1,-1,1,1,0,-1,0,0,0,0,1,0,-1,0,0,-1,0,0,0,1,1,-1,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,-1,0,0,0,0,0,1,1,-1,1,0,0,0,0,1,0,0,1,0,0,-1,0,-1,0], [0,0,-1,0,0,0,0,0,0,1,-1,1,0,0,0,0,1,0,0,1,0,0,-1,0,0,0], [0,0,0,1,-1,0,0,0,1,0,-1,0,0,0,1,-1,0,1,0,1,0,-1,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0], [0,0,1,-1,1,-1,-1,1,-1,0,1,0,0,0,0,0,-1,0,0,-1,1,1,1,0,0,0]]]], [ # Q-class [26][13] [[6], [-1,6], [-1,-1,6], [1,1,1,6], [1,1,1,1,6], [-1,1,1,0,0,6], [0,-1,1,-1,-1,-1,6], [-1,-1,-1,1,-1,-1,1,6], [1,1,1,-1,1,1,1,1,6], [1,1,1,1,-1,1,-1,-1,0,6], [1,0,1,0,1,0,1,0,1,1,6], [-1,-1,1,0,-1,-1,0,1,1,0,0,6], [-1,1,-1,0,-1,-1,1,-1,-1,-1,-1,1,6], [1,-1,0,-1,-1,0,-1,1,1,-1,1,1,1,6], [-1,0,1,1,-1,-1,-1,1,-1,1,1,1,-1,1,6], [-1,1,1,1,1,-1,0,0,1,0,0,0,1,-1,1,6], [0,-1,1,-1,-1,-1,1,-1,-1,1,1,-1,-1,-1,1,1,6], [1,1,-1,-1,1,-1,-1,-1,0,-1,-1,1,1,1,0,-1,1,6], [-1,1,-1,-1,0,-1,-1,1,0,-1,1,-1,1,1,0,1,0,0,6], [-1,0,-1,1,-1,-1,-1,1,-1,-1,1,1,0,-1,1,1,0,-1,1,6], [1,1,-1,1,-1,1,0,0,1,1,1,-1,1,1,-1,0,1,1,-1,1,6], [1,-1,1,1,-1,1,-1,-1,0,0,-1,1,-1,-1,-1,1,0,-1,0,1,-1,6], [-1,-1,-1,-1,1,-1,-1,0,-1,1,1,1,0,-1,-1,1,1,-1,-1,1,0,-1,6], [-1,0,1,1,1,0,1,1,1,-1,0,-1,-1,-1,1,0,1,1,-1,-1,1,-1,-1,6], [0,-1,1,1,1,1,-1,-1,-1,-1,1,1,1,0,1,-1,-1,1,1,1,-1,1,-1,1,6], [-1,1,1,-1,-1,-1,1,-1,1,1,-1,1,1,-1,-1,1,1,1,1,-1,1,1,-1,1,-1,6]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,-1,0,0,1,0,0,-1,0,0,0,0,0,0,-1,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,-1,1,0,0,0,0,1,0,1,-1,0,0,0,0,0,1,-1,0,-1,0,0,-1,0,1], [0,0,0,-1,0,-1,-1,0,0,0,0,1,0,-1,0,0,0,-1,0,-1,1,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,1,0,0,0,1,-1,0,0,0,0,1,-1,0,0,1,0,0], [1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,1,-1,0,0,1,-1,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,-1,0,0,-1,0,-1,0,1,0,-1,0,1,0,1,0,1,0,0,0], [-1,-1,0,1,0,0,1,-1,1,0,0,-1,0,0,1,-1,-1,1,1,0,0,1,1,0,-1,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,1,-1,0,0,-1,0,-1,1,0,0,0,0,1,0,0,0,1,0,0,0], [-1,0,-1,1,0,0,0,0,1,0,0,-1,0,1,0,0,1,0,-1,0,-1,0,0,-1,1,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,1,0,0,1,0,0,0,-1,0,0,1,-1,1,-1,0,0,1,0,0,0,1,0,-1,0], [0,0,0,1,0,0,1,-1,1,0,-1,0,0,0,1,-1,0,0,1,0,0,0,1,0,0,0], [1,1,1,-1,0,0,-1,1,-1,-1,0,1,0,-1,0,0,0,-1,0,-1,1,0,0,0,0,0], [0,-1,0,1,0,1,1,-1,0,0,0,0,0,0,1,0,-1,1,1,0,0,0,1,0,-1,0], [0,0,0,1,-1,0,0,0,1,0,0,-1,0,0,0,0,0,1,0,0,-1,0,1,0,0,0], [0,0,0,0,-1,0,-1,0,0,-1,1,0,0,-1,0,0,0,0,0,-1,0,0,0,0,0,0], [0,1,0,0,0,0,1,0,0,0,-1,0,-1,1,0,0,0,0,0,0,0,0,1,0,1,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [-1,-1,-1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,1,0,0,-1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,-1,0], [1,0,1,-1,0,0,0,0,-1,0,0,1,0,-1,0,0,-1,0,1,0,1,0,0,1,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,1,-1,0,0,-1,1,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,1,-1,0,0,-1,1,-1,-1,0,1,0,-1,0,0,0,-1,0,-1,1,0,0,0,0,0], [-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,1,0,-1,0,0,0,0,0,0,-1,0,0,0,0,-1,1,0,0,0,0,1,0,0,0], [-1,0,0,0,0,-1,-1,0,0,0,1,0,0,0,-1,0,0,0,-1,0,0,0,-1,0,0,0], [0,-1,0,0,0,0,-1,0,0,0,1,0,1,-1,0,0,0,0,0,0,0,0,-1,0,-1,0], [-1,0,-1,0,0,-1,0,0,0,1,0,0,-1,1,-1,1,0,0,-1,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,1,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [26][14] [[8], [-4,8], [-2,4,8], [4,-4,-2,8], [2,-4,-2,4,8], [-2,2,2,-2,-2,8], [-4,2,4,-2,-2,2,8], [-4,2,4,-4,-2,4,2,8], [4,-4,-4,2,4,-2,-2,-4,8], [-2,2,4,-2,-4,2,4,4,-4,8], [-2,2,4,-2,-4,4,4,2,-4,2,8], [-4,4,2,-2,-2,4,2,2,-4,2,2,8], [2,-2,-2,4,2,0,-2,-4,0,-4,2,2,8], [4,-2,-1,2,1,-1,-2,-2,2,-1,-1,-2,1,8], [-2,4,2,-2,-2,1,1,1,-2,1,1,2,-1,-4,8], [-1,2,4,-1,-1,1,2,2,-2,2,2,1,-1,-2,4,8], [2,-2,-1,4,2,-1,-1,-2,1,-1,-1,-1,2,4,-4,-2,8], [1,-2,-1,2,4,-1,-1,-1,2,-2,-2,-1,1,2,-4,-2,4,8], [-1,1,1,-1,-1,4,1,2,-1,1,2,2,0,-2,2,2,-2,-2,8], [-2,1,2,-1,-1,1,4,1,-1,2,2,1,-1,-4,2,4,-2,-2,2,8], [-2,1,2,-2,-1,2,1,4,-2,2,1,1,-2,-4,2,4,-4,-2,4,2,8], [2,-2,-2,1,2,-1,-1,-2,4,-2,-2,-2,0,4,-4,-4,2,4,-2,-2,-4,8], [-1,1,2,-1,-2,1,2,2,-2,4,1,1,-2,-2,2,4,-2,-4,2,4,4,-4,8], [-1,1,2,-1,-2,2,2,1,-2,1,4,1,1,-2,2,4,-2,-4,4,4,2,-4,2,8], [-2,2,1,-1,-1,2,1,1,-2,1,1,4,1,-4,4,2,-2,-2,4,2,2,-4,2,2,8], [1,-1,-1,2,1,0,-1,-2,0,-2,1,1,4,2,-2,-2,4,2,0,-2,-4,0,-4,2,2,8]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,-1,1,0,-1,0,0,-1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,0,-1,0,1,1,0,1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,1,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,1,-1,0,0,0,0,2,1,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,1,0,0,0,0,1,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,1,0,0,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,1,0,-1,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,1,-1,0,1,-1,0,1,0,0,1,1,0,-1,-1,1,0,-1,1,0,-1,0,0,-1,-1,0], [0,0,0,0,0,0,0,1,0,0,-1,0,1,0,0,0,0,0,0,0,-1,0,0,1,0,-1], [0,-1,1,-1,0,1,0,-1,-1,0,-1,-1,0,0,1,-1,1,0,-1,0,1,1,0,1,1,0], [0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,1,0,-1,-1,0,-1,0,0,0,0,0,0,0,-1,0,1,1,0,1,0,0], [0,-1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,-1,0], [-1,0,1,0,-1,1,0,0,0,0,-2,-1,2,1,0,-1,0,1,-1,0,0,0,0,2,1,-2], [0,0,-1,0,0,0,0,0,0,0,1,0,-1,0,0,1,0,0,0,0,0,0,0,-1,0,1], [0,-1,1,0,-1,0,0,0,0,-1,-1,1,0,0,1,-1,0,1,0,0,0,0,1,1,-1,0], [0,0,0,0,0,0,0,0,0,1,-1,0,1,0,0,0,0,0,0,0,0,0,-1,1,0,-1], [0,0,0,0,1,0,-1,-1,0,0,1,1,-1,0,0,0,0,-1,0,1,1,0,0,-1,-1,1], [0,0,0,0,1,0,-1,-1,0,1,1,0,-1,0,0,0,0,-1,0,1,1,0,-1,-1,0,1]], [[-1,-1,0,0,0,0,-1,-1,0,0,1,0,-1,1,1,0,0,0,0,1,1,0,0,-1,0,1], [1,1,-1,1,0,-1,1,1,0,-1,1,1,-1,-1,-1,1,-1,0,1,-1,-1,0,1,-1,-1,1], [1,0,-1,0,0,0,1,0,-1,-1,0,1,-1,-1,0,1,0,0,0,-1,0,1,1,0,-1,1], [0,0,-1,0,1,-1,-1,0,1,1,2,1,-1,0,0,1,0,-1,1,1,0,-1,-1,-2,-1,1], [-1,0,0,0,0,0,-1,0,1,1,0,0,1,1,0,0,0,0,0,1,0,-1,-1,0,0,-1], [1,0,0,0,0,0,1,0,-1,-1,-1,0,0,-1,0,0,0,0,0,-1,0,1,1,1,0,0], [1,0,0,-1,0,0,1,0,-1,0,-1,0,1,-1,0,0,1,0,0,-1,0,1,0,1,0,-1], [1,0,0,0,0,1,1,0,-1,-1,-1,0,0,-1,0,0,0,0,-1,-1,0,1,1,1,0,0], [-1,0,0,0,0,0,-1,0,0,1,0,-1,1,1,0,0,0,0,0,1,0,0,-1,0,1,-1], [1,-1,0,0,0,0,1,0,-1,-1,0,1,-1,-1,1,0,0,0,0,-1,0,1,1,0,-1,1], [1,0,0,-1,0,0,1,0,-1,-1,-1,0,0,-1,0,0,1,0,0,-1,0,1,1,1,0,0], [1,0,0,1,0,-1,0,0,0,-1,1,2,-2,-1,0,0,-1,0,1,0,0,0,1,-1,-2,2], [0,0,0,0,0,-1,-1,0,1,0,1,1,-1,0,0,0,0,0,1,1,0,-1,0,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,1,1,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,-1,0,1,-1,-1,0,1,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,-1,0,1,1,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,1,1,0,-1,-1,-2,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,-1,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,-1,0,1,1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,-1,0,1,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,-1,0,1,1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,-1,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,-1,0,1,1,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,-1,0,1,1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,1,0,0,0,1,-1,-2,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,-1,0,-1,-1,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1]]]], [ # Q-class [26][15] [[4], [2,4], [2,2,4], [2,2,2,4], [2,2,2,2,4], [2,2,2,2,2,4], [2,2,2,2,2,2,4], [2,2,2,2,2,2,2,4], [2,2,2,2,2,2,2,2,4], [2,2,2,2,2,2,2,2,2,4], [2,2,2,2,2,2,2,2,2,2,4], [2,2,2,2,2,2,2,2,2,2,2,4], [2,2,2,2,2,2,2,2,2,2,2,2,4], [2,1,1,1,1,1,1,1,1,1,1,1,1,4], [1,2,1,1,1,1,1,1,1,1,1,1,1,2,4], [1,1,2,1,1,1,1,1,1,1,1,1,1,2,2,4], [1,1,1,2,1,1,1,1,1,1,1,1,1,2,2,2,4], [1,1,1,1,2,1,1,1,1,1,1,1,1,2,2,2,2,4], [1,1,1,1,1,2,1,1,1,1,1,1,1,2,2,2,2,2,4], [1,1,1,1,1,1,2,1,1,1,1,1,1,2,2,2,2,2,2,4], [1,1,1,1,1,1,1,2,1,1,1,1,1,2,2,2,2,2,2,2,4], [1,1,1,1,1,1,1,1,2,1,1,1,1,2,2,2,2,2,2,2,2,4], [1,1,1,1,1,1,1,1,1,2,1,1,1,2,2,2,2,2,2,2,2,2,4], [1,1,1,1,1,1,1,1,1,1,2,1,1,2,2,2,2,2,2,2,2,2,2,4], [1,1,1,1,1,1,1,1,1,1,1,2,1,2,2,2,2,2,2,2,2,2,2,2,4], [1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,1,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,-1,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0]]]], [ # Q-class [26][16] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]]]] ]; MakeImmutable( IMFList[26].matrices ); gap-4r6p5/grp/imf25.grp0000644000175000017500000005256412172557252013401 0ustar billbill############################################################################# ## #A imf25.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Q-class representative of the irreducible ## maximal finite integral matrix groups of dimension 25, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Q-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 25. ## IMFList[25].matrices := [ [ # Q-class [25][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [25][02] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [0,0,0,0,0,2], [0,0,0,0,0,1,2], [0,0,0,0,0,1,1,2], [0,0,0,0,0,1,1,1,2], [0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [25][03] [[4], [2,4], [1,1,4], [2,2,2,4], [2,1,2,1,4], [1,2,0,1,0,4], [2,1,1,1,2,0,4], [1,1,1,1,1,-1,1,4], [1,1,1,1,1,0,2,2,4], [2,1,1,1,2,0,2,1,1,4], [1,1,2,2,1,0,2,1,2,1,4], [1,1,2,1,2,0,1,2,2,1,1,4], [1,1,1,1,1,0,2,1,2,1,2,1,4], [2,2,1,2,1,1,1,2,2,1,1,2,1,4], [2,1,1,1,2,-1,2,2,1,2,1,1,1,1,4], [1,2,1,1,1,0,2,1,2,1,2,1,2,1,1,4], [1,1,2,2,1,-1,1,2,1,1,2,1,1,1,2,1,4], [2,2,1,2,1,1,1,1,1,1,1,1,2,2,1,1,1,4], [1,1,1,1,1,0,1,2,2,2,1,2,1,2,1,1,1,1,4], [1,1,2,2,1,0,1,1,1,2,2,1,1,1,1,1,2,1,2,4], [1,1,1,1,1,0,1,1,1,2,1,1,2,1,1,1,1,2,2,2,4], [1,1,1,1,1,-1,1,2,1,1,1,1,2,1,2,1,2,2,1,1,2,4], [1,1,2,1,2,0,1,1,1,1,1,2,2,1,1,1,1,2,1,1,2,2,4], [1,2,2,1,2,0,1,1,1,1,1,2,1,1,1,2,1,1,1,1,1,1,2,4], [1,2,1,1,1,0,1,1,1,2,1,1,1,1,1,2,1,1,2,2,2,1,1,2,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,1], [0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,-1,0,0,0,0,1], [0,-1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,-1,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,1,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [1,-1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,-1,1], [0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1]], [[-1,0,0,0,0,0,0,-1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,-1,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,-1,0,0,0,1,0,0,0], [0,0,0,0,-1,0,0,-1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,-1,-1,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1], [0,1,0,0,0,-1,0,-1,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,1,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,0], [0,1,0,0,0,-1,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,-1,1,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0,-1,1,0,0,0], [0,0,0,-1,0,0,0,-1,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0], [0,1,0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,1,-1,0,0,0,0,0], [0,0,-1,0,0,0,0,-1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]]]], [ # Q-class [25][04] [[6], [3,6], [2,2,6], [2,2,2,6], [2,2,2,0,6], [2,2,3,2,2,6], [2,2,3,2,2,0,6], [3,3,1,1,1,0,1,6], [1,1,1,3,0,1,1,2,6], [2,3,2,1,1,1,1,3,2,6], [1,2,1,0,3,2,0,2,1,1,6], [3,0,2,2,2,2,2,1,1,0,0,6], [2,1,3,1,2,0,2,2,1,2,1,1,6], [2,2,1,2,0,1,0,2,1,2,2,2,2,6], [1,2,3,1,1,1,2,2,2,2,3,0,3,2,6], [2,2,2,2,0,0,2,2,2,2,0,1,3,2,3,6], [2,1,2,2,1,1,0,2,2,2,1,2,2,2,1,2,6], [0,1,2,0,3,1,1,1,1,3,3,1,2,2,1,1,2,6], [0,2,0,2,2,0,1,2,2,2,2,0,2,2,2,2,1,2,6], [2,2,2,0,2,2,0,1,0,2,2,1,2,2,2,2,2,2,0,6], [2,1,1,2,1,2,-1,2,2,1,2,2,1,2,1,1,0,1,1,1,6], [2,1,2,1,1,0,3,1,2,2,0,1,3,1,3,2,2,1,0,2,-1,6], [1,0,2,2,2,2,0,2,1,2,2,1,2,1,2,2,2,2,2,2,2,0,6], [2,1,3,1,1,0,3,2,2,2,0,1,2,0,2,3,1,2,0,2,1,3,2,6], [2,2,2,3,3,2,2,2,3,1,3,2,1,2,1,1,2,3,2,0,2,1,2,2,6]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [-1,-2,-1,2,2,1,-1,0,-1,2,2,0,1,1,0,1,0,-2,-1,-1,-1,-1,-2,2,0], [0,0,2,0,1,-1,-1,0,1,0,2,0,-1,1,-2,1,-1,-1,0,-1,-1,1,1,0,-1], [-2,-2,-2,3,3,2,-1,1,-1,2,2,0,1,1,0,1,0,-2,-1,-1,-1,-1,-3,3,-1], [-2,-3,-2,3,4,2,0,1,-1,3,2,-1,1,2,0,1,1,-3,-2,-1,-1,-2,-3,3,-1], [0,1,1,-1,-1,-1,-1,-1,0,0,1,1,0,0,-1,0,-1,-1,1,0,0,1,1,0,1], [2,2,1,-2,-2,-1,0,-1,1,-2,-2,0,-1,-1,1,-1,0,2,1,0,1,1,2,-2,1], [1,-1,1,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,1,0,0,0,0,0,0], [2,0,-1,0,-1,0,0,0,0,-1,-3,-1,0,-1,3,-1,0,2,0,1,0,-1,0,-1,2], [-1,-2,-2,2,3,2,0,1,-1,1,0,-1,0,1,1,1,1,-1,-1,-1,0,-1,-2,2,-1], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,-1,0,0,0,1,0,0,0,-1,1,-1,0,0,-1,0,1,0,0,0], [1,1,0,-1,-1,0,0,0,0,-1,-1,0,0,-1,1,0,0,1,0,0,0,0,1,-1,1], [0,-1,0,1,1,0,-1,0,-1,1,1,0,0,0,0,1,0,-1,0,-1,0,0,-1,1,0], [2,2,3,-3,-3,-2,0,-1,1,-2,0,0,-1,-1,-2,0,-1,1,2,0,1,3,3,-3,1], [2,1,2,-1,-2,-1,-1,0,1,-2,0,0,-1,-1,-1,0,-1,2,1,0,0,2,2,-2,0], [1,0,-1,0,0,1,0,0,0,-1,-1,-1,0,0,1,0,0,1,0,0,0,0,0,0,0], [1,2,2,-1,-1,-1,-1,0,1,-2,0,0,-1,0,-1,0,-1,1,1,-1,0,2,2,-1,-1], [0,-2,-3,1,1,2,1,1,-1,1,-1,-1,1,0,2,0,1,0,-1,0,0,-2,-2,1,1], [-1,-1,-1,1,2,1,1,0,0,1,1,-1,0,1,0,1,1,-1,-1,-1,0,-1,-1,1,-1], [1,1,1,-1,-2,-1,-1,-1,0,0,1,1,0,-1,-1,0,-1,0,1,0,0,1,1,0,1], [0,-2,-1,2,3,1,-1,1,0,1,0,-1,0,1,1,1,0,0,-1,-1,-1,-1,-2,1,-1], [1,0,0,-1,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1], [-1,-1,0,1,2,1,-1,0,0,1,2,0,0,1,-1,1,0,-2,0,-1,-1,0,-1,2,-1]], [[-2,-3,-2,2,2,2,0,1,-2,3,1,0,1,0,1,1,1,-2,-1,0,-1,-2,-3,2,1], [0,-2,0,1,1,1,0,1,-1,1,0,-1,-1,0,0,1,0,0,0,0,0,0,-1,0,0], [0,-2,0,2,1,1,-1,1,-1,1,0,0,0,0,1,0,0,0,0,0,-1,-1,-2,1,0], [1,1,0,-1,-2,0,0,0,0,-1,-2,0,0,-1,1,-1,0,2,1,1,0,0,1,-1,1], [1,0,0,0,-1,0,0,0,-1,0,-1,0,0,-1,1,0,0,1,0,0,0,0,0,-1,1], [1,1,0,0,-1,0,0,0,0,-1,-1,0,0,-1,1,-1,0,2,0,0,0,0,1,-1,0], [1,0,1,-1,-1,0,0,0,0,-1,-1,0,-1,0,0,0,0,1,1,0,0,1,1,-1,0], [-2,-2,0,2,2,1,-1,1,-1,2,3,0,0,1,-2,2,0,-2,-1,-1,-1,0,-2,2,-1], [1,3,3,-2,-3,-2,-1,-1,1,-2,1,1,-1,-1,-3,0,-1,1,2,0,0,3,3,-2,0], [-1,-1,1,1,1,0,-1,1,-1,1,1,0,-1,0,-1,1,0,-1,0,0,0,1,-1,0,0], [1,0,0,0,-1,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,-1,0], [1,2,1,-2,-3,-1,0,-1,0,-1,0,1,0,-1,0,-1,0,1,1,0,0,1,2,-1,1], [-2,-3,-2,3,3,2,-1,1,-2,3,1,0,1,1,1,1,1,-2,-1,-1,-1,-2,-4,3,0], [0,-2,-1,1,1,1,0,1,-1,1,0,-1,0,0,1,0,1,0,0,0,0,-1,-2,1,0], [0,-2,-1,2,1,1,-1,1,-1,1,0,0,0,0,1,0,0,0,0,0,-1,-1,-2,1,0], [-2,-2,0,2,2,1,-1,1,-1,2,2,0,0,1,-1,1,0,-2,0,-1,-1,0,-2,2,-1], [0,1,2,-1,-2,-1,-1,0,0,0,1,1,0,-1,-2,0,-1,0,1,0,0,2,1,-1,1], [1,1,2,-1,-2,-1,0,0,0,-1,0,0,-1,-1,-1,0,0,1,1,0,1,2,1,-2,0], [1,0,0,0,0,0,0,1,0,-1,-2,-1,-1,0,1,0,0,2,0,0,0,0,0,-1,0], [0,-1,0,1,0,0,-1,0,-1,1,0,0,0,-1,1,0,0,0,0,0,0,0,-1,0,1], [-1,-1,-2,2,1,1,0,0,-1,2,1,0,1,0,1,0,1,-1,-1,0,-1,-2,-2,2,0], [0,0,0,0,-1,0,-1,0,-1,0,0,1,0,-1,0,0,0,0,1,0,0,1,0,0,1], [-1,-1,-1,2,1,1,-1,1,-1,1,0,0,1,0,1,0,0,0,-1,0,-1,-1,-2,1,0], [-1,-2,0,2,1,1,-1,1,-1,1,1,0,0,0,0,1,0,-1,0,0,-1,0,-2,1,0], [1,1,1,-1,-2,0,0,0,0,-1,0,0,0,-1,-1,0,0,1,1,0,0,1,1,-1,0]]]], [ # Q-class [25][05] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]] ]; MakeImmutable( IMFList[25].matrices ); gap-4r6p5/grp/basicprm.gi0000644000175000017500000003024012172557252014051 0ustar billbill############################################################################# ## #W basicprm.gi GAP Library Frank Celler ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains the methods for the construction of the basic perm ## group types. ## ############################################################################# ## #M TrivialGroupCons( ) ## InstallMethod( TrivialGroupCons, "perm group", [ IsPermGroup and IsFinite ], function( filter ) filter:= Group( () ); SetIsTrivial( filter, true ); return filter; end ); ############################################################################# ## #M AbelianGroupCons( , ) ## InstallMethod( AbelianGroupCons, "perm group", true, [ IsPermGroup and IsFinite, IsList ], 0, function( filter, ints ) local grp, grps; if not ForAll( ints, IsInt ) then Error( " must be a list of integers" ); fi; if not ForAll( ints, x -> 0 < x ) then TryNextMethod(); fi; grps := List( ints, x -> CyclicGroupCons( IsPermGroup, x ) ); # the way a direct product is constructed guarantees the right # generators grp := CallFuncList( DirectProduct, grps ); SetSize( grp, Product(ints) ); SetIsAbelian( grp, true ); return grp; end ); ############################################################################# ## #M ElementaryAbelianGroupCons( , ) ## InstallMethod( ElementaryAbelianGroupCons, "perm group", true, [ IsPermGroup and IsFinite, IsPosInt ], 0,function(filter,size) local G; if size = 1 or IsPrimePowerInt( size ) then G := AbelianGroup( filter, Factors(size) ); else Error( " must be a prime power" ); fi; SetIsElementaryAbelian( G, true ); return G; end); ############################################################################# ## #M AlternatingGroupCons( , ) ## InstallMethod( AlternatingGroupCons, "perm group with degree", true, [ IsPermGroup and IsFinite, IsInt], 0, function( filter, deg ) if deg<0 then TryNextMethod();fi; return AlternatingGroupCons( IsPermGroup, [ 1 .. deg ] ); end ); ############################################################################# ## #M AlternatingGroupCons( , ) ## InstallOtherMethod( AlternatingGroupCons, "perm group with domain", true, [ IsPermGroup and IsFinite, IsDenseList ], 0, function( filter, dom ) local alt, dl, g, l; dom := Set(dom); IsRange( dom ); if Length(dom) < 3 then alt := GroupByGenerators( [], () ); SetSize( alt, 1 ); SetMovedPoints( alt, [] ); SetNrMovedPoints( alt, 0 ); SetIsPerfectGroup( alt, true ); else if Length(dom) mod 2 = 0 then dl := dom{[ 1 .. Length(dom)-1 ]}; else dl := dom; fi; g := [ MappingPermListList( dl, Concatenation( dl{[2..Length(dl)]}, [dl[1]] ) ) ]; if 3 < Length(dom) then l := Length(dom); Add( g, (dom[l-2],dom[l-1],dom[l]) ); fi; alt := GroupByGenerators(g); if Length(dom)<5000 then SetSize( alt, Factorial(Length(dom))/2 ); fi; SetMovedPoints( alt, dom ); SetNrMovedPoints( alt, Length(dom) ); if 4 < Length(dom) then SetIsSimpleGroup( alt, true ); SetIsPerfectGroup( alt, true ); elif 2 < Length(dom) then SetIsPerfectGroup( alt, false ); fi; SetIsPrimitiveAffine( alt, Length( dom ) < 5 ); fi; SetIsAlternatingGroup( alt, true ); SetIsNaturalAlternatingGroup( alt, true ); return alt; end ); ############################################################################# ## #M AlternatingGroupCons( , ) ## InstallMethod( AlternatingGroupCons, "regular perm group with degree", true, [ IsPermGroup and IsRegular and IsFinite, IsInt], 0, function( filter, deg ) if deg<0 then TryNextMethod();fi; return AlternatingGroupCons( IsPermGroup and IsRegular, [ 1 .. deg ] ); end ); ############################################################################# ## #M AlternatingGroupCons( , ) ## InstallOtherMethod( AlternatingGroupCons, "regular perm group with domain", true, [ IsPermGroup and IsRegular and IsFinite, IsDenseList ], 0, function( filter, dom ) local alt; alt := AlternatingGroupCons( IsPermGroup, dom ); alt := Action( alt, AsList(alt), OnRight ); SetIsAlternatingGroup( alt, true ); return alt; end ); ############################################################################# ## #M CyclicGroupCons( , ) ## InstallMethod( CyclicGroupCons, "regular perm group", true, [ IsPermGroup and IsRegular and IsFinite, IsInt and IsPosRat ], 0, function( filter, n ) local g, c; g := PermList( Concatenation( [2..n], [1] ) ); c := GroupByGenerators( [g] ); SetSize( c, n ); SetIsCyclic( c, true ); if n > 1 then SetMinimalGeneratingSet (c, [g]); else SetMinimalGeneratingSet (c, []); fi; return c; end ); ############################################################################# ## #M DihedralGroupCons( , <2n> ) ## InstallMethod( DihedralGroupCons, "perm. group", true, [ IsPermGroup, IsPosInt ], 0, function( filter, 2n ) local D, g, h; if 2n = 2 then D:= GroupByGenerators( [ (1,2) ] ); elif 2n = 4 then D := GroupByGenerators( [ (1,2), (3,4) ] ); elif 2n mod 2 = 1 then Error( "<2n> must be an even integer" ); else g:= PermList( Concatenation( [ 2 .. 2n/2 ], [ 1 ] ) ); h:= PermList( Concatenation( [ 1 ], Reversed( [ 2 .. 2n/2 ] ) ) ); D:= GroupByGenerators( [ g, h ] ); fi; return D; end ); ############################################################################# ## #M QuaternionGroupCons( , <4n> ) ## InstallMethod( QuaternionGroupCons, "perm. group", true, [ IsPermGroup, IsPosInt ], 0, function( filter, n ) local y, z, x; if 0 <> n mod 4 then TryNextMethod(); fi; y := PermList( Concatenation( [2..n/2], [1], [n/2+2..n], [n/2+1] ) ); x := PermList( Concatenation( Cycle( y^-1, [n/2+1..n], n/2+1 ), Cycle( y^-1, [1..n/2], n/4+1 ) ) ); return Group(x,y); end ); ############################################################################# ## #M MathieuGroupCons( , ) ## ## The returned permutation groups are compatible only in the following way. ## $M_{23}$ is the stabilizer of the point $24$ in $M_{24}$. ## $M_{21}$ is the stabilizer of the point $22$ in $M_{22}$. ## $M_{11}$ is the stabilizer of the point $12$ in $M_{12}$. ## $M_{10}$ is the stabilizer of the point $11$ in $M_{11}$. ## $M_{9}$ is the stabilizer of the point $10$ in $M_{10}$. ## InstallMethod( MathieuGroupCons, "perm group with degree", [ IsPermGroup and IsFinite, IsPosInt ], function( filter, degree ) local M; # degree 9, base 1 2, indices 9 8 if degree = 9 then M:= Group( (1,4,9,8)(2,5,3,6), (1,6,5,2)(3,7,9,8) ); SetSize( M, 72 ); # degree 10, base 1 2 3, indices 10 9 8 elif degree = 10 then M:= Group( (1,9,6,7,5)(2,10,3,8,4), (1,10,7,8)(2,9,4,6) ); SetSize( M, 720 ); # degree 11, base 1 2 3 4, indices 11 10 9 8 elif degree = 11 then M:= Group( (1,2,3,4,5,6,7,8,9,10,11), (3,7,11,8)(4,10,5,6) ); SetSize( M, 7920 ); SetIsSimpleGroup( M, true ); # degree 12, base 1 2 3 4 5, indices 12 11 10 9 8 elif degree = 12 then M:= Group( (1,2,3,4,5,6,7,8,9,10,11), (3,7,11,8)(4,10,5,6), (1,12)(2,11)(3,6)(4,8)(5,9)(7,10) ); SetSize( M, 95040 ); SetIsSimpleGroup( M, true ); # degree 21, base 1 2 3 4, indices 21 20 16 3 elif degree = 21 then M:= Group( (1,4,5,9,3)(2,8,10,7,6)(12,15,16,20,14)(13,19,21,18,17), (1,21,5,12,20)(2,16,3,4,17)(6,18,7,19,15)(8,13,9,14,11) ); SetSize( M, 20160 ); SetIsSimpleGroup( M, true ); # degree 22, base 1 2 3 4 5, indices 22 21 20 16 3 elif degree = 22 then M:= Group( (1,2,3,4,5,6,7,8,9,10,11)(12,13,14,15,16,17,18,19,20,21,22), (1,4,5,9,3)(2,8,10,7,6)(12,15,16,20,14)(13,19,21,18,17), (1,21)(2,10,8,6)(3,13,4,17)(5,19,9,18)(11,22)(12,14,16,20) ); SetSize( M, 443520 ); SetIsSimpleGroup( M, true ); # degree 23, base 1 2 3 4 5 6, indices 23 22 21 20 16 3 elif degree = 23 then M:= Group( (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23), (3,17,10,7,9)(4,13,14,19,5)(8,18,11,12,23)(15,20,22,21,16) ); SetSize( M, 10200960 ); SetIsSimpleGroup( M, true ); # degree 24, base 1 2 3 4 5 6 7, indices 24 23 22 21 20 16 3 elif degree = 24 then M:= Group( (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23), (3,17,10,7,9)(4,13,14,19,5)(8,18,11,12,23)(15,20,22,21,16), (1,24)(2,23)(3,12)(4,16)(5,18)(6,10)(7,20)(8,14)(9,21)(11,17) (13,22)(19,15) ); SetSize( M, 244823040 ); SetIsSimpleGroup( M, true ); # error else Error("degree must be 9, 10, 11, 12, 21, 22, 23, or 24" ); fi; return M; end ); ############################################################################# ## #M SymmetricGroupCons( , ) ## InstallMethod( SymmetricGroupCons, "perm group with degree", true, [ IsPermGroup and IsFinite, IsInt ], 0, function( filter, deg ) if deg<0 then TryNextMethod();fi; return SymmetricGroupCons( IsPermGroup, [ 1 .. deg ] ); end ); ############################################################################# ## #M SymmetricGroupCons( , ) ## InstallOtherMethod( SymmetricGroupCons, "perm group with domain", true, [ IsPermGroup and IsFinite, IsDenseList ], 0, function( filters, dom ) local sym, g; dom := Set(dom); IsRange( dom ); if Length(dom) < 2 then sym := GroupByGenerators( [], () ); SetSize( sym, 1 ); SetMovedPoints( sym, [] ); SetNrMovedPoints( sym, 0 ); SetIsPerfectGroup( sym, true ); else g := [ MappingPermListList( dom, Concatenation( dom{[2..Length(dom)]}, [ dom[1] ] ) ) ]; if 2 < Length(dom) then Add( g, ( dom[1], dom[2] ) ); fi; sym := GroupByGenerators( g ); if Length(dom)<5000 then SetSize( sym, Factorial(Length(dom)) ); fi; SetMovedPoints( sym, dom ); SetNrMovedPoints( sym, Length(dom) ); fi; SetIsPrimitiveAffine( sym, Length( dom ) < 5 ); SetIsSymmetricGroup( sym, true ); SetIsNaturalSymmetricGroup( sym, true ); return sym; end ); ############################################################################# ## #M SymmetricGroupCons( , ) ## InstallMethod( SymmetricGroupCons, "regular perm group with degree", true, [ IsPermGroup and IsRegular and IsFinite, IsInt], 0, function( filter, deg ) if deg<0 then TryNextMethod();fi; return SymmetricGroupCons( IsPermGroup and IsRegular, [ 1 .. deg ] ); end ); ############################################################################# ## #M SymmetricGroupCons( , ) ## InstallOtherMethod( SymmetricGroupCons, "regular perm group with domain", true, [ IsPermGroup and IsRegular and IsFinite, IsDenseList ], 0, function( filter, dom ) local alt; alt := SymmetricGroupCons( IsPermGroup, dom ); alt := Action( alt, AsList(alt), OnRight ); SetIsSymmetricGroup( alt, true ); return alt; end ); ############################################################################# ## #E gap-4r6p5/grp/perf.gd0000644000175000017500000003136712172557252013213 0ustar billbill############################################################################# ## #W perf.gd GAP Groups Library Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains the declarations for the Holt/Plesken library of ## perfect groups ## PERFRec := fail; # indicator that perf0.grp is not loaded PERFSELECT := []; PERFGRP := []; ############################################################################# ## #C IsPerfectLibraryGroup() identifier for groups constructed from the ## library (used for perm->fp isomorphism) ## ## ## ## ## ## ## ## DeclareCategory("IsPerfectLibraryGroup", IsGroup ); ############################################################################# ## #O PerfGrpConst(,) ## ## ## ## ## ## ## ## DeclareConstructor("PerfGrpConst",[IsGroup,IsList]); ############################################################################# ## #F PerfGrpLoad() force loading of secondary files, return index ## ## ## ## ## ## ## ## DeclareGlobalFunction("PerfGrpLoad"); ############################################################################# ## #A PerfectIdentification() . . . . . . . . . . . . id. for perfect groups ## ## <#GAPDoc Label="PerfectIdentification"> ## ## ## ## ## This attribute is set for all groups obtained from the perfect groups ## library and has the value [size,nr] if the group is obtained with ## these parameters from the library. ## ## ## <#/GAPDoc> ## DeclareAttribute("PerfectIdentification", IsGroup ); ############################################################################# ## #F SizesPerfectGroups() ## ## <#GAPDoc Label="SizesPerfectGroups"> ## ## ## ## ## This is the ordered list of all numbers up to 10^6 that occur as ## sizes of perfect groups. ## One can iterate over the perfect groups library with: ## for n in SizesPerfectGroups() do ## > for k in [1..NrPerfectLibraryGroups(n)] do ## > pg := PerfectGroup(n,k); ## > od; ## > od; ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("SizesPerfectGroups"); ############################################################################# ## #F NumberPerfectGroups( ) . . . . . . . . . . . . . . . . . . . . . . ## ## <#GAPDoc Label="NumberPerfectGroups"> ## ## ## ## ## returns the number of non-isomorphic perfect groups of size size for ## each positive integer size up to 10^6 except for the eight sizes ## listed at the beginning of this section for which the number is not ## yet known. For these values as well as for any argument out of range it ## returns fail. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("NumberPerfectGroups"); DeclareSynonym("NrPerfectGroups",NumberPerfectGroups); ############################################################################# ## #F NumberPerfectLibraryGroups( ) . . . . . . . . . . . . . . . . . . ## ## <#GAPDoc Label="NumberPerfectLibraryGroups"> ## ## ## ## ## returns the number of perfect groups of size size which are available ## in the library of finite perfect groups. (The purpose of the function ## is to provide a simple way to formulate a loop over all library groups ## of a given size.) ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("NumberPerfectLibraryGroups"); DeclareSynonym("NrPerfectLibraryGroups",NumberPerfectLibraryGroups); ############################################################################# ## #F PerfectGroup( [, ][, ] ) #F PerfectGroup( [, ] ) ## ## <#GAPDoc Label="PerfectGroup"> ## ## PerfectGroup ## ## ## ## ## returns a group which is isomorphic to the library group specified ## by the size number [ size, n ] or by the two ## separate arguments size and n, assuming a default value of ## n = 1. ## The optional argument filt defines the filter in which the group is ## returned. ## Possible filters so far are and ## . ## In the latter case, the generators and relators used coincide with those ## given in . ## G := PerfectGroup(IsPermGroup,6048,1); ## U3(3) ## gap> G:=PerfectGroup(IsPermGroup,823080,2); ## A5 2^1 19^2 C 19^1 ## gap> NrMovedPoints(G); ## 6859 ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("PerfectGroup"); ############################################################################# ## #F DisplayInformationPerfectGroups( [, ] ) . . . . . . . . . . . . #F DisplayInformationPerfectGroups( ] ) . . . . . . . . . . ## ## <#GAPDoc Label="DisplayInformationPerfectGroups"> ## ## DisplayInformationPerfectGroups ## ## ## ## ## ## displays some invariants of the n-th group of order size ## from the perfect groups library. ##

## If no value of n has been specified, the invariants will be ## displayed for all groups of size size available in the library. ##

## Alternatively, also a list of length two may be entered as the only ## argument, with entries size and n. ##

## The information provided for G includes the following items: ## ## ## a headline containing the size number [ size, n ] of G ## in the form size.n (the suffix .n will be suppressed ## if, up to isomorphism, G is the only perfect group of order ## size), ## ## ## a message if G is simple or quasisimple, i.e., ## if the factor group of G by its centre is simple, ## ## ## the description of the structure of G as it is ## given by Holt and Plesken in  (see below), ## ## ## the size of the centre of G (suppressed, if G is ## simple), ## ## ## the prime decomposition of the size of G, ## ## ## orbit sizes for a faithful permutation representation ## of G which is provided by the library (see below), ## ## ## a reference to each occurrence of G in the tables of ## section 5.3 of . Each of these references ## consists of a class number and an internal number (i,j) under which ## G is listed in that class. For some groups, there is more than one ## reference because these groups belong to more than one of the classes ## in the book. ## ## ## DisplayInformationPerfectGroups( 30720, 3 ); ## #I Perfect group 30720: A5 ( 2^4 E N 2^1 E 2^4 ) A ## #I size = 2^11*3*5 orbit size = 240 ## #I Holt-Plesken class 1 (9,3) ## gap> DisplayInformationPerfectGroups( 30720, 6 ); ## #I Perfect group 30720: A5 ( 2^4 x 2^4 ) C N 2^1 ## #I centre = 2 size = 2^11*3*5 orbit size = 384 ## #I Holt-Plesken class 1 (9,6) ## gap> DisplayInformationPerfectGroups( Factorial( 8 ) / 2 ); ## #I Perfect group 20160.1: A5 x L3(2) 2^1 ## #I centre = 2 size = 2^6*3^2*5*7 orbit sizes = 5 + 16 ## #I Holt-Plesken class 31 (1,1) (occurs also in class 32) ## #I Perfect group 20160.2: A5 2^1 x L3(2) ## #I centre = 2 size = 2^6*3^2*5*7 orbit sizes = 7 + 24 ## #I Holt-Plesken class 31 (1,2) (occurs also in class 32) ## #I Perfect group 20160.3: ( A5 x L3(2) ) 2^1 ## #I centre = 2 size = 2^6*3^2*5*7 orbit size = 192 ## #I Holt-Plesken class 31 (1,3) ## #I Perfect group 20160.4: simple group A8 ## #I size = 2^6*3^2*5*7 orbit size = 8 ## #I Holt-Plesken class 26 (0,1) ## #I Perfect group 20160.5: simple group L3(4) ## #I size = 2^6*3^2*5*7 orbit size = 21 ## #I Holt-Plesken class 27 (0,1) ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("DisplayInformationPerfectGroups"); ############################################################################# ## #F SizeNumbersPerfectGroups( , , ... ) ## ## <#GAPDoc Label="SizeNumbersPerfectGroups"> ## ## ## ## ## returns a list of pairs, ## each entry consisting of a group order and the number of those groups in ## the library of perfect groups that contain the specified factors ## factor1, factor2, ... ## among their composition factors. ##

## Each argument must either be the name of a simple group or an integer ## which stands for the product of the sizes of one or more cyclic factors. ## (In fact, the function replaces all integers among the arguments ## by their product.) ##

## The following text strings are accepted as simple group names. ## ## ## An or A(n) for the alternating groups ## A_{n}, ## 5 \leq n \leq 9, for example A5 or A(6). ## ## ## Ln(q) or L(n,q) for ## PSL(n,q), where ## n \in \{ 2, 3 \} and q a prime power, ranging ## ## ## for n = 2 from 4 to 125 ## ## ## for n = 3 from 2 to 5 ## ## ## ## ## Un(q) or U(n,q) for ## PSU(n,q), where ## n \in \{ 3, 4 \} and q a prime power, ranging ## ## ## for n = 3 from 3 to 5 ## ## ## for n = 4 from 2 to 2 ## ## ## ## ## Sp4(4) or S(4,4) for the symplectic group Sp(4,4), ## ## ## Sz(8) for the Suzuki group Sz(8), ## ## ## Mn or M(n) for the Mathieu groups ## M_{11}, M_{12}, and M_{22}, and ## ## ## Jn or J(n) for the Janko groups ## J_1 and J_2. ## ## ##

## Note that, for most of the groups, the preceding list offers two ## different names in order to be consistent with the notation used in ## as well as with the notation used in the ## command of &GAP;. ## However, as the names are ## compared as text strings, you are restricted to the above choice. Even ## expressions like L2(2^5) are not accepted. ##

## As the use of the term PSU(n,q) is not unique in the literature, ## we mention that in this library it denotes the factor group of ## SU(n,q) by its centre, where SU(n,q) is the group of all ## n \times n unitary matrices with entries in GF(q^2) ## and determinant 1. ##

## The purpose of the function is to provide a simple way to formulate a ## loop over all library groups which contain certain composition factors. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("SizeNumbersPerfectGroups"); ############################################################################# ## #E gap-4r6p5/grp/imf30.grp0000644000175000017500000065613712172557252013403 0ustar billbill############################################################################# ## #A imf30.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Q-class representative of the irreducible ## maximal finite integral matrix groups of dimension 30, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Q-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 30. ## IMFList[30].matrices := [ [ # Q-class [30][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [30][02] [[2], [1,2], [0,0,2], [0,0,1,2], [0,0,0,0,2], [0,0,0,0,1,2], [0,0,0,0,0,0,2], [0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [30][03] [[5], [-1,5], [-1,-1,5], [-1,-1,-1,5], [-1,-1,-1,-1,5], [0,0,0,0,0,5], [0,0,0,0,0,-1,5], [0,0,0,0,0,-1,-1,5], [0,0,0,0,0,-1,-1,-1,5], [0,0,0,0,0,-1,-1,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,5], [0,0,0,0,0,0,0,0,0,0,-1,5], [0,0,0,0,0,0,0,0,0,0,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,-1,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,5]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [30][04] [[2], [0,2], [-1,0,2], [0,-1,-1,2], [0,0,0,-1,2], [0,0,0,0,-1,2], [0,0,0,0,0,0,2], [0,0,0,0,0,0,0,2], [0,0,0,0,0,0,-1,0,2], [0,0,0,0,0,0,0,-1,-1,2], [0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2]], [[[0,0,0,0,0,0,-1,-2,-2,-3,-2,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-2,-2,-3,-2,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2,-2,-3,-2,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2,-2,-3,-2,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,-1,-2,-2,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,2,2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,-2,-2,-2,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,2,3,2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2,-2,-3,-2,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2,-2,-3,-2,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-2,-2,-3,-2,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,-2,-2,-3,-2,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,-1,-1,-2,-2,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2,-2,-3,-2,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2,-2,-3,-2,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-2,-2,-3,-2,-1,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [30][05] [[6], [-1,6], [-1,-1,6], [-1,-1,-1,6], [-1,-1,-1,-1,6], [-1,-1,-1,-1,-1,6], [0,0,0,0,0,0,6], [0,0,0,0,0,0,-1,6], [0,0,0,0,0,0,-1,-1,6], [0,0,0,0,0,0,-1,-1,-1,6], [0,0,0,0,0,0,-1,-1,-1,-1,6], [0,0,0,0,0,0,-1,-1,-1,-1,-1,6], [0,0,0,0,0,0,0,0,0,0,0,0,6], [0,0,0,0,0,0,0,0,0,0,0,0,-1,6], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,6], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,6], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,6], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,6]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [30][06] [[4], [-1,4], [-2,-1,4], [1,-2,-1,4], [1,1,-2,-1,4], [-2,1,1,-2,-1,4], [0,0,0,0,0,0,4], [0,0,0,0,0,0,-1,4], [0,0,0,0,0,0,-2,-1,4], [0,0,0,0,0,0,1,-2,-1,4], [0,0,0,0,0,0,1,1,-2,-1,4], [0,0,0,0,0,0,-2,1,1,-2,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,-2,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,1,-2,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,-2,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,-2,1,1,-2,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-2,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,-2,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,1,1,-2,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-2,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,-2,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,1,1,-2,-1,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,-1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [30][07] [[3], [-1,3], [-1,-1,3], [1,-1,0,3], [1,0,-1,-1,3], [0,1,-1,1,-1,3], [0,0,0,0,0,0,3], [0,0,0,0,0,0,-1,3], [0,0,0,0,0,0,-1,-1,3], [0,0,0,0,0,0,1,-1,0,3], [0,0,0,0,0,0,1,0,-1,-1,3], [0,0,0,0,0,0,0,1,-1,1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,-1,3]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [30][08] [[4], [1,4], [1,0,4], [-2,-1,1,4], [1,2,2,-1,4], [-2,1,-2,1,-1,4], [-2,0,1,2,1,0,4], [-2,0,1,1,1,1,2,4], [2,2,2,-1,2,-1,-1,-1,4], [-2,-2,1,2,0,0,1,2,-1,4], [0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,1,4], [0,0,0,0,0,0,0,0,0,0,1,0,4], [0,0,0,0,0,0,0,0,0,0,-2,-1,1,4], [0,0,0,0,0,0,0,0,0,0,1,2,2,-1,4], [0,0,0,0,0,0,0,0,0,0,-2,1,-2,1,-1,4], [0,0,0,0,0,0,0,0,0,0,-2,0,1,2,1,0,4], [0,0,0,0,0,0,0,0,0,0,-2,0,1,1,1,1,2,4], [0,0,0,0,0,0,0,0,0,0,2,2,2,-1,2,-1,-1,-1,4], [0,0,0,0,0,0,0,0,0,0,-2,-2,1,2,0,0,1,2,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,1,-2,1,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,1,2,1,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,1,1,1,1,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,-1,2,-1,-1,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-2,1,2,0,0,1,2,-1,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,1,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,-1,-1,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,-1,-1,1,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,-1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,1,-1,-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,-1,-1,1,1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,1,-1,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,1,0,-1,-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,1,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,-1,-1,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,-1,-1,1,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,0,-1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,-1,1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,-1,1,1,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,1,-1,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,1,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,-1,-1,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,-1]]]], [ # Q-class [30][09] [[3], [1,3], [1,1,3], [1,1,1,3], [-1,1,0,0,3], [-1,0,1,0,1,3], [-1,0,0,1,1,1,3], [0,-1,1,0,-1,1,0,3], [0,-1,0,1,-1,0,1,1,3], [0,0,-1,1,0,-1,1,-1,1,3], [0,0,0,0,0,0,0,0,0,0,3], [0,0,0,0,0,0,0,0,0,0,1,3], [0,0,0,0,0,0,0,0,0,0,1,1,3], [0,0,0,0,0,0,0,0,0,0,1,1,1,3], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,3], [0,0,0,0,0,0,0,0,0,0,-1,0,1,0,1,3], [0,0,0,0,0,0,0,0,0,0,-1,0,0,1,1,1,3], [0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,1,0,3], [0,0,0,0,0,0,0,0,0,0,0,-1,0,1,-1,0,1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,1,-1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,1,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,-1,0,1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,1,-1,1,3]], [[[-1,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1]]]], [ # Q-class [30][10] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [30][11] [[4], [1,4], [-2,0,4], [-2,1,1,4], [-2,1,2,1,4], [-2,1,2,2,1,4], [-2,1,0,1,1,1,4], [-1,1,2,0,1,2,0,4], [1,2,1,-1,0,0,0,2,4], [2,0,-2,0,-1,-1,-2,-2,-1,4], [0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,1,4], [0,0,0,0,0,0,0,0,0,0,-2,0,4], [0,0,0,0,0,0,0,0,0,0,-2,1,1,4], [0,0,0,0,0,0,0,0,0,0,-2,1,2,1,4], [0,0,0,0,0,0,0,0,0,0,-2,1,2,2,1,4], [0,0,0,0,0,0,0,0,0,0,-2,1,0,1,1,1,4], [0,0,0,0,0,0,0,0,0,0,-1,1,2,0,1,2,0,4], [0,0,0,0,0,0,0,0,0,0,1,2,1,-1,0,0,0,2,4], [0,0,0,0,0,0,0,0,0,0,2,0,-2,0,-1,-1,-2,-2,-1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,1,2,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,1,2,2,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,1,0,1,1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,2,0,1,2,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,1,-1,0,0,0,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,-2,0,-1,-1,-2,-2,-1,4]], [[[0,0,0,0,0,0,0,0,0,0,-2,1,0,0,-1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,-1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,1,0,0,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0], [-2,1,0,-1,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,-2,-1,1,1,1,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,-1,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,1,0,-1,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-2,-1,1,1,1,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-1,1,1,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,0,0,0]], [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,1,0,0,-1,-1,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-1,0,1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,1,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,1,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,0,0,0,1,1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,0,0,-1], [-2,1,0,-1,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,-2,-1,1,1,1,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,-1,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-2,1,0,-1,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,2,-2,-1,1,1,1,0,0,1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,2,-1,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,1,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,-1,0,0,1,-1,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,1,-1,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,-1,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,-1,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-2,1,0,-1,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,2,-2,-1,1,1,1,0,0,1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,2,-1,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,1,0,-1,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-2,-1,1,1,1,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-1,1,1,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,0,0,0]]]], [ # Q-class [30][12] [[6], [-1,6], [1,2,6], [-3,-1,-3,6], [-2,-1,0,2,6], [-2,2,2,1,2,6], [-2,-2,0,0,3,2,6], [-2,2,-2,0,-2,-2,-1,6], [2,-3,0,-2,-2,-1,0,-2,6], [-1,2,3,-1,-2,0,-2,0,0,6], [0,0,0,0,0,0,0,0,0,0,6], [0,0,0,0,0,0,0,0,0,0,-1,6], [0,0,0,0,0,0,0,0,0,0,1,2,6], [0,0,0,0,0,0,0,0,0,0,-3,-1,-3,6], [0,0,0,0,0,0,0,0,0,0,-2,-1,0,2,6], [0,0,0,0,0,0,0,0,0,0,-2,2,2,1,2,6], [0,0,0,0,0,0,0,0,0,0,-2,-2,0,0,3,2,6], [0,0,0,0,0,0,0,0,0,0,-2,2,-2,0,-2,-2,-1,6], [0,0,0,0,0,0,0,0,0,0,2,-3,0,-2,-2,-1,0,-2,6], [0,0,0,0,0,0,0,0,0,0,-1,2,3,-1,-2,0,-2,0,0,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-3,-1,-3,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-1,0,2,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,2,2,1,2,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,-2,0,0,3,2,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,2,-2,0,-2,-2,-1,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-3,0,-2,-2,-1,0,-2,6], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2,3,-1,-2,0,-2,0,0,6]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,-1,0,-1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,-1,0,0,-1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,-1,-1,0,-1,-1,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,1,1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,0,1,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,-1,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,-1,-1,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,-1,0,-1,-1,0,-1,-1,-1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,0,1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,-1,-1,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,-1,-1,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,1,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,-1,-1,0,-1,-1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,1,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,-1,-1,0,1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,-1,0,-1,-1,0,-1,-1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,-1,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,1,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,1,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,-1,0,-1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,-1,0,0,-1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,-1,-1,0,-1,-1,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,1,1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,0,1,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,-1,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,-1,-1,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,-1,0,-1,-1,0,-1,-1,-1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,0,1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,1,0,1,1,0,1,1,1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,1,0,-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,-1,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,1,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,-1,0,-1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,-1,0,0,-1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,-1,-1,0,-1,-1,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,1,1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,0,1,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,-1,0,0]]]], [ # Q-class [30][13] [[3], [1,3], [0,-1,3], [0,1,-1,3], [0,-1,0,0,3], [0,0,0,-1,-1,3], [-1,-1,1,0,1,1,3], [0,0,-1,0,0,0,-1,3], [-1,-1,0,-1,0,1,1,-1,3], [0,1,0,0,0,1,1,-1,1,3], [0,-1,0,-1,0,1,1,1,1,0,3], [1,1,0,0,-1,0,-1,1,0,0,1,3], [0,0,-1,1,1,0,1,0,0,1,0,-1,3], [0,1,1,0,0,-1,0,0,-1,1,0,1,0,3], [0,0,0,-1,1,0,1,-1,1,1,1,0,1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,-1,0,1,1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,1,-1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,1,1,1,1,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,-1,0,-1,1,0,0,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,0,1,0,0,1,0,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,-1,0,0,-1,1,0,1,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,1,-1,1,1,1,0,1,1,3]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,0,0,1,0,-1,0,-1,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,-1,0,-1,0,0,-1,1,0,1,1,-2,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,1,0,1,0,0,-1,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,-1,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,-1,0,-1,1,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,-1,0,0,0,1,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,1,1,-1,-1,-1,-1,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,-1,-1,0,0,1,0,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,1,-1,0,-1,0,0,-1,1,0,1,1,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,1,0,1,0,0,-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,1,0,0,-1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,0,0,-1,0,-1,1,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,1,0,0,0,-1,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,1,0,1,0,1,1,-1,-1,-1,-1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,-1,1,1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,1,0,1,0,-1,0,-1,1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,0,0,0,-1,1,0,0,-1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,-1,0,0,1,-1,0,-1,0,1,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,1,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,-1,0,0,1,-1,0,-1,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,-1,0,0,1,1,0,1,-1,-1,0,0,2,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,1,0,0,1,-1,0,-1,0,2,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,0,0,0,0,-2,1,0,1,0,-2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,1,-1,0,1,2,1,0,-1,-1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,-1,0,-1,0,2,1,0,0,-2,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,0,0,1,0,-1,0,-1,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,-1,0,-1,0,0,-1,1,0,1,1,-2,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,1,0,1,0,0,-1,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,-1,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,-1,0,-1,1,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,-1,0,0,0,1,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,0,1,1,-1,-1,-1,-1,1,1]]]], [ # Q-class [30][14] [[3], [-1,3], [1,-1,3], [1,1,-1,3], [1,1,-1,1,3], [-1,-1,0,-1,-1,3], [1,0,-1,1,1,-1,3], [1,-1,1,-1,0,1,-1,3], [1,-1,1,0,-1,1,-1,1,3], [0,1,1,0,0,-1,-1,0,0,3], [1,-1,0,1,0,-1,1,-1,0,-1,3], [-1,1,-1,0,1,1,0,0,-1,-1,-1,3], [1,0,1,1,0,0,-1,1,1,0,0,0,3], [1,0,1,0,1,0,-1,1,1,0,0,0,1,3], [0,-1,0,-1,-1,1,0,1,1,0,-1,0,-1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,-1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,-1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,1,1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,-1,0,1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,0,-1,1,-1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,-1,-1,0,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,1,0,-1,1,-1,0,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,0,1,1,0,0,-1,-1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,-1,1,1,0,0,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,1,0,-1,1,1,0,0,0,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,-1,1,0,1,1,0,-1,0,-1,-1,3]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,1,0,1,1,0,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,-1,0,1,0,0,1,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,-1,-1,-1,-1,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,1,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,-1,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,-1,0,0,-1,-1,-1,-1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,1,0,0,1,-1,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,1,1,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,-1,-1,1,1,-1,-1,1,0,0,1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,1,-1,-1,-1,-1,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,0,0,0,1,0,1,1,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,-1,0,-1,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,-1,-1,-1,-1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,1,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,-1,-1,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,1,1,0,-1,0,0,-1,-1,-1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,-1,0,1,0,0,1,-1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,-1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,-1,-1,1,1,-1,-1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,1,0,1,1,-1,-1,-1,-1,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,1,1,0,0,0,-1,0,0,-1,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-3,-1,1,1,1,-1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,-1,-1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,1,0,1,0,0,0,0,-1,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,1,0,-1,0,1,1,-1,-1,0,-1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,-1,-1,1,1,-1,-1,1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,1,1,0,-1,0,0,-1,-1,-1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,0,0,0,0,0,0,1,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,-1,0,1,0,-1,-1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,0,0,0,-1,0,-1,-1,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,0,0,-1,1,0,1,0,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,1,0,1,1,0,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,-1,0,1,0,0,1,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,-1,-1,-1,-1,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,1,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,-1,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,-1,0,0,-1,-1,-1,-1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,1,0,0,1,-1,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,1,1,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,-1,-1,1,1,-1,-1,1,0,0,1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,1,-1,-1,-1,-1,0,-1,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,-1,-1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,1,0,1,1,0,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,-1,0,1,0,0,1,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,-1,-1,-1,-1,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,1,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,-1,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,-1,0,0,-1,-1,-1,-1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,1,0,0,1,-1,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,1,1,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,-1,-1,1,1,-1,-1,1,0,0,1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,1,1,-1,-1,-1,-1,0,-1,0,0,1]]]], [ # Q-class [30][15] [[3], [1,3], [1,1,3], [1,1,1,3], [1,1,1,1,3], [-1,1,0,0,0,3], [-1,0,1,0,0,1,3], [-1,0,0,1,0,1,1,3], [-1,0,0,0,1,1,1,1,3], [0,-1,1,0,0,-1,1,0,0,3], [0,-1,0,1,0,-1,0,1,0,1,3], [0,-1,0,0,1,-1,0,0,1,1,1,3], [0,0,-1,1,0,0,-1,1,0,-1,1,0,3], [0,0,-1,0,1,0,-1,0,1,-1,0,1,1,3], [0,0,0,-1,1,0,0,-1,1,0,-1,1,-1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,1,1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,1,0,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,-1,0,1,0,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,-1,0,0,1,1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,1,0,-1,1,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,-1,0,1,-1,0,1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,1,0,-1,1,-1,1,3]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,-1,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [30][16] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]]]], [ # Q-class [30][17] [[3], [0,3], [1,0,3], [0,1,1,3], [0,1,0,0,3], [0,0,1,1,0,3], [0,0,0,0,0,0,3], [1,1,1,0,1,0,0,3], [0,0,0,0,0,0,1,0,3], [0,1,0,0,1,0,0,1,0,3], [1,1,0,0,0,1,0,0,0,0,3], [0,0,0,0,0,0,1,0,0,1,0,3], [1,0,1,0,-1,0,0,1,1,0,0,0,3], [-1,0,1,1,0,1,1,0,1,0,-1,0,0,3], [0,0,0,0,0,1,0,0,0,1,1,0,0,0,3], [1,0,1,0,0,0,0,1,-1,0,0,0,1,0,0,3], [0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,3], [0,0,0,0,0,0,1,0,1,0,0,0,0,1,0,0,0,3], [0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,1,0,3], [0,0,1,1,1,1,0,0,0,0,0,0,0,1,0,0,-1,0,0,3], [1,0,1,0,0,-1,0,1,0,0,0,0,1,0,0,1,0,0,0,0,3], [1,0,1,-1,0,0,0,1,0,0,0,0,1,0,0,1,0,0,0,0,1,3], [0,0,0,0,0,1,0,0,0,0,1,1,0,0,1,0,1,1,1,0,0,0,3], [1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,3], [0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,3], [0,1,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,3], [0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,3], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,-1,0,0,1,3], [1,0,1,0,0,0,0,1,0,-1,0,0,1,0,-1,1,1,0,0,-1,1,1,0,0,0,0,0,0,3], [0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,3]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,-1,0,1,0,0,-1,1,0,-1,1,1,0,0,0,0,0,1,0,-1,0,1,-1,1,0,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [-1,-1,0,1,0,-1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,-1,1,0,1,0,0,0,0,0,0], [-1,0,1,0,0,0,-1,1,0,-1,1,1,0,0,0,0,0,1,0,-1,0,0,-1,1,0,0,1,0,-1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,1,-1,0,0,0,0,0,0,0,1,0], [-1,0,0,0,-1,0,0,1,0,0,0,0,0,-1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,1,-1,1,0,-1,0,1,0,0,0,0,0,1,0,-1,0,0,-1,1,0,0,1,0,-1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,0,0,0,-1,2,0,-1,1,1,0,0,0,0,0,1,0,-1,0,0,-1,1,0,1,1,0,-1,0], [0,0,0,0,-1,-1,0,0,0,0,0,0,-1,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1], [-1,-1,0,0,0,0,-1,2,0,-1,1,1,0,0,0,0,0,1,0,0,0,0,-1,1,0,1,0,0,-1,0], [0,0,0,0,0,1,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,-1], [-1,0,0,0,0,0,0,1,0,-1,0,1,0,-1,1,0,0,1,0,0,0,0,-1,1,0,0,0,0,0,0], [-1,0,0,0,-1,1,0,1,1,0,0,0,-1,-1,0,1,0,0,-1,0,0,0,0,1,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0], [0,1,0,0,-1,0,0,0,1,0,-1,0,-1,-1,1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0], [0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0], [1,1,0,-1,0,1,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [-1,0,0,0,0,0,-1,1,0,-1,0,1,0,0,1,0,0,1,0,0,0,0,-1,1,0,0,0,0,0,0], [0,0,0,0,1,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1,0,0], [0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [-2,-1,0,1,0,0,0,1,0,0,1,0,0,-1,0,0,0,1,0,0,0,1,-1,1,0,0,0,0,0,0], [-1,0,1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0], [-1,0,1,0,-1,0,0,1,1,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0]], [[-1,-1,0,0,-1,0,0,2,0,0,1,0,-1,0,0,0,0,0,-1,0,0,0,0,1,0,1,0,1,0,0], [-1,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,1,1,0,0,0,0,0,0,1,0,-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,1,-1,0,0,-1,0,1,1,0,0,0,0,1,0,-1,0,0,-1,0,0,0,1,-1,-1,-1], [0,1,0,0,-1,0,0,0,1,0,-1,0,-1,-1,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,-1,0,0,1,0,0,0,0,-1,-1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,1,0,0,0,1,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0], [-1,-1,0,0,0,0,-1,2,0,-1,1,1,0,0,0,0,0,1,0,-1,0,0,-1,1,0,1,1,0,-1,0], [0,0,0,0,0,0,1,0,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,0,0,-1,0,-1,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,1,0,-1,1,0,-1,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1], [-1,-1,0,1,0,0,-1,2,0,-1,1,1,0,0,0,0,0,1,0,-1,0,0,-1,1,0,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [1,1,0,-1,-1,0,0,-1,1,1,-1,-1,-1,0,0,1,0,-1,0,1,0,-1,1,-1,0,0,0,0,1,0], [-1,0,0,0,0,1,-1,1,0,-1,0,1,0,0,0,0,0,1,0,-1,1,0,-1,1,0,0,1,0,-1,0], [0,0,0,0,1,1,-1,0,0,-1,0,1,1,0,0,0,0,1,0,-1,0,0,-1,0,0,0,0,0,-1,-1], [0,0,0,0,-1,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0], [-1,0,0,0,-1,0,0,1,0,0,0,0,-1,-1,1,0,0,1,0,1,0,0,-1,1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [-1,-1,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,-1,-1,0,1,0,1,0,0,0,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [1,1,0,-1,0,1,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,1,-1,0,-1,0,0,0,0,0,0], [1,1,0,-1,-1,0,1,-1,0,1,-1,-1,-1,0,0,0,0,-1,0,1,0,0,1,-1,0,0,0,0,1,0], [1,0,-1,0,1,0,0,-1,-1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1,0,0]]]], [ # Q-class [30][18] [[6], [3,6], [2,3,6], [2,3,3,6], [2,3,2,2,6], [3,3,2,2,2,6], [2,3,2,2,2,2,6], [2,3,0,3,2,2,2,6], [2,3,2,2,2,2,3,2,6], [2,1,2,0,2,0,1,0,2,6], [0,1,2,2,2,0,1,0,1,2,6], [2,3,2,2,2,2,3,2,3,0,1,6], [2,3,2,2,3,2,2,2,2,2,1,2,6], [3,3,2,2,2,0,2,2,2,2,1,2,2,6], [2,3,2,2,2,2,3,2,0,1,2,0,2,2,6], [2,2,2,3,2,1,2,1,1,2,2,0,0,2,2,6], [2,3,3,3,2,2,2,0,2,1,2,2,2,2,2,1,6], [0,2,2,1,2,0,2,1,1,1,1,0,0,2,2,3,0,6], [1,2,2,2,2,1,2,1,2,1,2,2,0,0,1,2,2,2,6], [2,1,3,2,2,2,1,1,1,2,2,1,2,0,2,2,1,1,1,6], [0,2,2,1,2,2,2,1,2,0,2,2,0,0,1,2,0,2,2,2,6], [0,1,1,2,0,0,3,2,2,1,1,1,0,1,2,2,0,3,2,1,1,6], [2,2,2,3,1,2,2,1,2,1,1,2,1,1,1,3,1,2,2,3,2,2,6], [0,1,1,1,2,2,2,2,0,-1,2,1,1,-1,2,0,1,2,2,2,2,2,0,6], [2,3,2,2,0,2,2,2,2,1,1,2,3,2,2,0,2,0,0,1,0,2,2,1,6], [3,3,2,2,2,3,2,2,2,1,0,2,2,0,2,0,2,0,1,2,1,0,2,1,2,6], [1,1,3,2,2,2,1,1,2,2,2,0,1,1,1,2,1,2,2,2,2,2,2,2,1,0,6], [2,2,2,2,2,2,1,1,1,1,1,1,0,1,0,2,2,2,2,2,1,0,2,2,0,2,2,6], [3,2,2,1,1,1,2,1,2,1,1,2,1,1,1,1,0,2,2,3,2,2,3,2,2,2,1,2,6], [2,2,2,1,0,1,2,1,2,2,1,2,1,2,1,2,0,1,2,2,2,2,2,0,1,0,1,1,3,6]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [-2,0,1,-1,0,1,0,1,0,0,0,0,0,1,0,1,0,-1,0,0,-1,0,0,0,-1,0,0,0,1,0], [0,-3,3,-5,2,1,0,5,-2,-3,2,-1,2,-2,-1,1,4,0,-1,-2,0,3,0,-5,-1,0,0,1,2,1], [0,-1,2,-4,1,1,1,4,-2,-2,2,-2,1,-1,-2,0,3,0,-1,-1,0,2,1,-3,-1,0,0,0,1,1], [1,0,-1,5,-1,-4,-4,-5,6,4,-5,4,-2,-1,7,1,-4,-1,-1,-2,0,-4,2,8,1,-2,-1,1,-3,1], [-2,1,2,-5,1,4,3,4,-5,-3,4,-4,1,3,-7,0,3,-1,1,1,-1,4,0,-4,-2,2,0,-2,2,0], [0,-1,2,-7,2,3,3,6,-6,-5,5,-4,2,0,-7,0,6,1,0,1,0,5,-1,-8,-1,2,1,-1,2,1], [-4,3,-2,0,-2,4,2,-1,-3,0,1,-2,0,6,-5,1,0,-1,2,3,-1,1,-2,0,-2,3,1,-3,2,-1], [-2,2,-1,0,-1,2,2,0,-2,0,1,-2,0,3,-4,0,0,0,1,2,-1,0,-1,0,-1,2,1,-2,1,0], [0,-1,0,4,-1,-2,-3,-3,5,4,-4,3,-1,-1,6,1,-3,-1,-1,-3,0,-4,2,6,0,-2,-1,1,-1,0], [-1,1,-2,3,-1,0,0,-3,1,2,-2,1,-1,2,1,0,-2,0,1,1,0,-2,0,3,0,0,0,-1,-1,0], [0,-2,3,-4,1,0,-1,3,0,-2,1,-1,2,-1,0,1,2,-1,-1,-2,0,2,2,-1,-1,0,-1,1,0,1], [-1,1,2,-6,1,4,4,5,-6,-4,5,-5,2,2,-8,-1,4,0,1,2,0,5,-1,-7,-2,2,0,-1,2,0], [1,-1,2,-1,1,-1,-1,1,1,0,0,0,0,-1,1,0,0,-1,-1,-2,0,0,2,1,0,-1,-1,1,-1,1], [1,-2,2,-2,1,0,0,3,-1,-1,1,0,1,-3,0,0,2,1,-1,-2,0,1,0,-3,0,-1,0,1,1,1], [-1,0,1,0,0,0,-1,0,1,1,-1,0,0,1,1,1,-1,-2,0,-1,0,0,1,2,-1,0,-1,0,0,0], [-1,1,3,-9,2,6,6,8,-9,-7,8,-7,2,2,-12,-1,6,1,1,3,-1,7,-2,-11,-2,3,1,-2,3,0], [-3,2,-5,7,-2,0,0,-6,2,4,-4,3,-3,3,2,1,-4,0,1,2,-1,-5,-2,5,1,1,2,-2,0,0], [1,-5,6,-8,2,0,-1,8,-1,-4,3,-1,3,-4,0,2,5,0,-2,-4,0,3,2,-5,-1,-1,-1,2,2,1], [0,0,-2,6,-2,-3,-3,-5,5,5,-5,5,-2,-1,7,1,-4,0,-1,-2,0,-5,1,7,1,-2,0,1,-2,0], [-4,4,-3,0,-1,5,4,-1,-5,-1,2,-3,-1,7,-8,0,0,0,3,5,-2,1,-3,-2,-1,4,2,-4,2,-1], [1,-3,4,-7,2,1,1,7,-3,-5,4,-2,3,-3,-3,1,5,1,-1,-2,0,4,0,-7,-1,0,0,1,2,1], [-1,0,2,-4,1,2,1,3,-2,-2,2,-2,0,1,-3,1,2,-1,0,0,-1,2,1,-2,-1,1,0,-1,1,0], [-2,2,-2,3,-1,0,-1,-4,2,2,-2,1,-1,3,1,1,-3,-1,1,1,-1,-2,0,4,0,1,0,-1,-1,0], [1,-1,2,-3,1,0,0,3,-1,-2,2,-1,1,-1,-1,0,2,0,-1,-1,0,2,1,-2,-1,0,0,0,0,1], [-2,1,0,-2,0,2,1,2,-2,-1,1,-1,0,1,-3,1,2,0,0,1,-1,1,-1,-2,-1,1,1,-1,2,0], [1,-3,6,-11,3,3,3,11,-6,-7,7,-5,3,-3,-7,0,8,1,-1,-1,0,7,0,-11,-2,1,0,0,3,1], [-2,0,1,-4,0,3,2,3,-3,-3,3,-2,1,2,-4,1,2,0,1,1,-1,2,-1,-4,-1,2,1,-1,2,0], [-2,1,-2,3,-2,0,0,-3,1,2,-2,2,-1,2,1,1,-2,0,1,1,-1,-3,-1,3,0,1,1,-1,0,0]], [[-6,7,-8,10,-5,2,1,-11,2,6,-5,2,-4,10,0,1,-8,-2,4,6,-2,-6,-3,9,0,3,2,-4,0,-3], [0,0,-4,9,-3,-4,-4,-8,7,6,-7,6,-2,0,9,1,-6,0,0,-1,1,-7,0,9,2,-2,0,1,-2,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [-1,1,-2,3,-1,0,0,-3,1,2,-2,1,-1,2,1,0,-2,0,1,1,0,-2,0,3,0,0,0,-1,0,-1], [-2,-1,2,-7,1,4,3,6,-6,-5,5,-4,3,2,-7,1,5,0,1,1,0,5,-2,-8,-2,3,1,-1,4,-1], [-2,1,-2,6,-3,-2,-4,-7,6,5,-6,4,-1,3,7,2,-6,-3,1,-1,0,-4,1,9,0,-1,-1,1,-1,-2], [-2,1,-2,4,-2,-1,-1,-4,3,3,-3,2,-1,2,3,1,-3,-1,0,0,0,-3,0,5,0,0,0,0,0,-1], [-2,2,-4,7,-3,-1,-2,-7,4,5,-5,3,-2,4,4,1,-5,-1,1,1,0,-5,0,8,0,0,0,-1,-1,-1], [-2,0,-2,5,-2,-1,-2,-4,4,4,-4,3,-1,1,5,1,-3,-1,0,-1,0,-4,0,5,0,-1,0,0,1,-1], [-3,4,-5,5,-2,2,2,-5,-1,2,-1,0,-2,5,-3,0,-3,0,2,4,-1,-2,-3,2,0,3,2,-3,1,-1], [0,0,1,-2,1,1,1,2,-2,-2,2,-2,1,0,-3,0,2,0,0,0,0,2,0,-2,-1,1,0,-1,1,0], [-1,0,0,0,-1,1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,-1], [-2,0,0,-4,0,3,2,3,-4,-3,3,-2,2,2,-5,1,3,0,1,2,0,3,-2,-5,-1,2,1,-1,3,-1], [-2,4,-3,2,-2,3,3,-2,-3,1,1,-2,-1,5,-5,-1,-1,0,2,4,0,0,-2,0,-1,2,1,-3,1,-2], [-1,2,-2,3,-2,-1,-1,-4,2,2,-2,1,-1,3,1,1,-3,-1,1,1,0,-2,0,5,0,1,0,-1,-1,-1], [-1,3,-4,8,-2,-2,-1,-8,4,5,-5,3,-3,3,4,0,-6,-1,1,1,0,-5,0,8,1,0,0,-1,-2,-1], [-1,1,-2,1,-1,1,1,-1,-1,0,0,0,0,1,-1,0,0,1,1,2,0,0,-2,-1,0,1,1,-1,1,-1], [2,-1,2,-2,1,-1,0,2,0,-1,1,-1,1,-2,0,0,1,0,-1,-2,1,1,1,-1,0,-1,-1,1,0,0], [0,0,0,1,0,-1,0,-1,1,0,-1,0,0,0,1,0,-1,0,0,0,0,-1,0,1,0,0,0,0,0,0], [-2,2,-2,3,-1,0,-1,-4,2,2,-2,1,-1,3,1,1,-3,-1,1,1,-1,-2,0,4,0,1,0,-1,0,-1], [2,-3,3,1,0,-4,-4,0,5,2,-3,3,1,-4,7,1,-1,-1,-2,-5,1,-2,3,4,0,-3,-2,3,-1,0], [0,0,0,3,-1,-2,-2,-3,4,3,-3,2,-1,0,4,1,-3,-1,-1,-2,0,-3,2,6,0,-1,-1,0,-1,0], [-1,2,-3,7,-2,-2,-2,-7,5,5,-5,3,-2,2,5,0,-6,-1,1,0,0,-5,1,8,1,-1,-1,0,-2,-1], [0,-2,3,-4,1,0,-1,3,0,-2,1,-1,2,-1,0,2,2,-1,-1,-2,0,2,1,-1,-1,0,-1,1,1,0], [-2,2,-4,7,-3,-1,-2,-7,4,5,-5,3,-2,3,4,1,-5,-1,1,1,0,-5,0,8,1,0,0,-1,-1,-1], [-3,2,-5,7,-3,0,-1,-7,3,4,-4,3,-2,4,3,1,-5,0,2,2,-1,-5,-2,6,1,1,1,-1,0,-1], [-1,0,1,0,0,0,-1,0,1,1,-1,0,0,1,1,1,-1,-2,0,-1,0,0,1,2,-1,0,-1,0,1,-1], [-1,2,-5,10,-2,-2,-2,-9,5,6,-6,4,-3,2,6,0,-7,0,1,1,0,-6,-1,8,2,-1,0,0,-2,-1], [-2,2,-3,6,-2,-1,-1,-6,4,4,-4,2,-2,3,3,1,-5,-1,1,1,-1,-5,0,7,1,0,0,-1,-1,-1], [0,1,0,3,-1,-1,-1,-3,3,2,-2,1,-1,1,2,0,-3,-1,0,0,0,-2,1,4,0,-1,-1,0,-1,-1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,2,-4,9,-2,-3,-3,-8,6,6,-6,4,-3,1,6,0,-6,0,0,0,0,-6,0,9,2,-1,0,0,-3,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,2,-4,0,1,1,3,-2,-3,3,-2,2,0,-3,0,2,0,0,0,0,3,0,-3,-1,1,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,2,-4,1,1,1,3,-2,-3,3,-2,1,0,-3,0,2,0,0,0,0,3,0,-3,-1,1,0,0,0,0], [0,1,-2,6,-2,-3,-3,-6,5,5,-5,4,-2,1,6,1,-5,-1,0,-1,0,-5,1,8,1,-1,0,0,-2,-1], [-2,4,-6,13,-4,-4,-4,-13,9,9,-9,6,-5,4,9,1,-10,-2,1,1,-1,-9,1,15,2,-1,0,-1,-4,-1], [0,2,-4,9,-3,-3,-3,-8,6,6,-6,5,-3,1,7,0,-6,0,0,0,0,-6,0,9,1,-1,0,0,-3,0], [0,2,-4,9,-2,-3,-2,-8,5,6,-6,4,-3,1,6,0,-6,0,0,0,0,-6,0,9,2,-1,0,0,-3,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [1,-2,4,-4,1,0,-1,4,0,-2,2,-1,2,-2,0,1,2,-1,-1,-3,0,2,2,-2,-1,-1,-1,1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-3,4,-5,2,-1,-1,5,0,-3,2,0,2,-4,1,1,3,0,-2,-3,0,2,1,-4,0,-1,0,2,1,1], [-2,2,-2,1,-1,1,1,-1,-1,0,0,0,-1,2,-2,1,0,0,1,2,-1,-1,-2,0,0,2,2,-2,1,0], [1,0,0,5,-1,-3,-3,-4,5,4,-4,3,-2,-1,6,0,-4,-1,-1,-2,0,-4,2,7,1,-2,-1,1,-2,0], [0,1,2,-1,0,0,-1,0,1,0,0,-1,0,1,0,0,-1,-2,0,-1,0,1,2,2,-1,0,-1,0,-1,0], [3,-3,2,-1,1,-3,-2,2,2,-1,0,2,1,-5,4,0,1,1,-2,-3,1,0,1,-1,1,-2,0,2,-1,1], [0,-1,2,-2,0,0,-1,2,0,-1,1,0,1,-1,1,1,1,-1,-1,-2,0,1,1,-1,-1,0,0,1,1,0], [1,0,-2,6,-1,-4,-3,-5,6,4,-5,4,-2,-2,7,0,-4,0,-1,-1,0,-5,1,7,2,-2,0,1,-3,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [-1,1,0,-1,0,1,1,1,-1,-1,1,-1,0,1,-2,0,1,0,0,1,-1,0,0,-1,-1,1,1,-1,1,0], [2,0,0,2,0,-3,-2,-2,3,1,-2,2,-1,-2,4,0,-2,0,-1,-1,0,-2,1,3,1,-1,0,1,-2,1], [0,1,-2,6,-2,-3,-3,-6,5,4,-5,4,-2,1,6,1,-5,-1,0,-1,0,-5,1,8,1,-1,0,0,-2,0]]]], [ # Q-class [30][19] [[4], [2,4], [2,2,4], [2,2,2,4], [2,2,2,2,4], [2,2,2,2,2,4], [2,2,2,2,2,2,4], [2,2,2,2,2,2,2,4], [2,2,2,2,2,2,2,2,4], [2,2,2,2,2,2,2,2,2,4], [2,2,2,2,2,2,2,2,2,2,4], [2,2,2,2,2,2,2,2,2,2,2,4], [2,2,2,2,2,2,2,2,2,2,2,2,4], [2,2,2,2,2,2,2,2,2,2,2,2,2,4], [1,1,1,1,1,1,2,1,1,1,1,1,1,1,4], [1,2,1,1,1,1,1,1,1,1,1,1,1,1,2,4], [1,1,2,1,1,1,1,1,1,1,1,1,1,1,2,2,4], [1,1,1,2,1,1,1,1,1,1,1,1,1,1,2,2,2,4], [1,1,1,1,2,1,1,1,1,1,1,1,1,1,2,2,2,2,4], [1,1,1,1,1,2,1,1,1,1,1,1,1,1,2,2,2,2,2,4], [1,1,1,1,1,1,1,1,1,2,1,1,1,1,2,2,2,2,2,2,4], [1,1,1,1,1,1,1,2,1,1,1,1,1,1,2,2,2,2,2,2,2,4], [1,1,1,1,1,1,1,1,2,1,1,1,1,1,2,2,2,2,2,2,2,2,4], [1,1,1,1,1,1,1,1,1,1,1,1,2,1,2,2,2,2,2,2,2,2,2,4], [1,1,1,1,1,1,1,1,1,1,2,1,1,1,2,2,2,2,2,2,2,2,2,2,4], [1,1,1,1,1,1,1,1,1,1,1,2,1,1,2,2,2,2,2,2,2,2,2,2,2,4], [2,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,4], [1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,4], [2,2,2,2,2,2,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,-1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,-1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,-1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,-1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,-1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,-1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0]]]], [ # Q-class [30][20] [[4], [-1,4], [1,-1,4], [0,0,1,4], [-2,0,-1,1,4], [1,0,0,0,-1,4], [0,-2,-1,-1,0,1,4], [-1,1,0,1,1,-1,0,4], [-2,2,-2,0,2,0,0,1,4], [0,1,-1,-1,0,-2,0,1,1,4], [2,0,0,-1,-1,0,0,0,-1,1,4], [-1,2,-1,0,0,0,-1,0,1,0,-1,4], [1,0,2,0,-1,0,-1,-1,-1,0,1,-1,4], [-1,0,0,2,1,0,0,1,1,0,-2,0,-1,4], [-1,0,0,1,2,0,0,1,1,-1,-2,0,-1,1,4], [-1,1,-1,1,1,0,-1,1,1,0,-1,2,-2,2,1,4], [0,-1,0,0,0,0,2,1,0,1,0,-2,-1,1,0,-1,4], [0,0,-1,0,1,0,1,2,1,1,1,-1,-2,1,1,1,2,4], [-1,1,-1,1,1,0,0,1,2,0,-2,2,-2,2,2,2,0,1,4], [1,0,0,-1,-1,0,1,0,0,2,2,-1,1,-1,-2,-2,2,1,-1,4], [0,1,-1,-2,0,-1,0,1,0,2,2,0,0,-1,-1,0,0,1,-1,1,4], [-1,0,-1,0,0,0,0,-1,0,-1,-1,2,-1,0,0,1,-1,-1,1,-1,-1,4], [1,1,0,-1,-1,0,-1,-2,0,1,1,0,2,-1,-1,-1,-1,-1,-1,1,1,-1,4], [2,0,1,0,-1,0,-1,-1,-2,-1,1,0,1,-2,0,-1,-1,-1,-1,0,0,0,1,4], [0,0,1,1,0,1,0,1,0,-2,-1,0,0,0,2,0,0,0,1,-1,-2,0,-1,1,4], [0,-1,1,1,0,-2,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,0,4], [0,0,1,1,0,-1,0,2,0,2,0,-1,0,1,0,0,2,1,0,1,0,-2,-1,-1,0,0,4], [-1,1,2,1,-1,-1,-2,0,-1,-1,-1,1,1,0,0,0,-1,-2,0,-1,-1,1,0,1,1,1,0,4], [0,0,0,2,0,0,0,1,0,-1,-1,1,-1,1,1,1,0,0,2,-1,-2,2,-2,0,2,1,0,1,4], [-1,2,-2,0,1,0,-1,1,2,2,0,1,-1,1,0,2,0,1,1,0,1,0,0,-2,-1,-2,1,-1,0,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,1,0,0,-1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,-1,-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,1,0,-1,-1,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,-1,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,1,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,0,1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,1,1,0,0,0,0,0,0,-1,1,0,-1,-1,0,-1,0,0,0,1,0,0,1,1,0,1,0], [0,0,1,-1,0,-1,1,1,0,-2,1,0,-1,1,1,0,0,-1,0,1,-1,0,1,1,-1,0,0,0,0,2], [0,0,1,1,-1,-1,0,0,1,0,-1,-1,0,-1,0,1,0,0,0,0,1,1,0,0,0,-1,0,-1,0,-1], [-1,-1,0,0,-1,0,0,0,1,0,0,1,0,0,1,0,0,0,-1,0,0,-1,0,1,-1,0,0,0,1,0], [0,-1,0,0,0,1,-1,0,1,1,-1,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,1,-1], [0,1,0,1,-1,-1,0,0,0,0,0,-1,1,-1,0,1,0,0,1,0,0,1,-1,0,0,-1,0,-1,-1,-1], [0,0,0,1,-1,0,0,-1,1,0,-1,0,1,-1,0,0,0,1,0,0,1,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,1,0,-1,0,0,0,0,0,-1,1,-1,0,1,0,0,0,0,0,1,0,1,-1], [1,1,0,0,0,-1,1,0,0,-2,0,-1,0,0,0,0,-1,0,1,1,0,1,0,0,0,0,1,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,-1,1,1,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,1,1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,-1,1,0,-1,-1,-1,-1,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,1,-1,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1]], [[-1,-1,-1,0,0,1,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,-1], [0,0,1,-1,0,0,1,0,1,-2,0,0,0,0,0,0,0,0,0,0,0,0,1,1,-1,1,1,0,1,2], [0,0,-1,-1,1,1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,1,0,1,0,0], [0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [1,1,0,1,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,1,1,-1,-1,1,0,0,0,-1,-1], [-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,1,0,1,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,1,-1,0,-1,-1,-1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,1,0,0,0], [0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,0,0,0,-1,0,0,1,1,0,1,0,0,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,1,-1,0,1,1,0,1,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,-1,0,0,0,1,0,-1,0,0,-1,0,1,0,0,-1,-1,1,-1,-1,1,0,-1,1,0,0,1,1], [0,0,0,0,0,0,0,-1,0,1,0,1,1,0,0,-1,0,1,0,-1,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,1,1,0,1,0,-1,0,0,0,0,0,0,-1,0,1,1,0,0,-1,1], [0,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,1,0,1,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,1,0,1,0,1,0,-1,0,1,-1,-1,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,-1,-1,1,0,0,1,1,0,0,1,0,1,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,1,1,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,-1,0,0,0,1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,-1,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,-1,1,0,0,1,1], [0,-1,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,1,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,1,0,0,-1,1], [0,0,-1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,-1,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1,-1,0,1,-1,1,0,1,0,2], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0]]]], [ # Q-class [30][21] [[4], [0,4], [-1,1,4], [0,-1,0,4], [1,1,0,0,4], [-1,-1,0,0,0,4], [1,0,0,0,0,0,4], [-1,0,0,0,0,0,0,4], [-1,-1,0,0,0,0,0,0,4], [0,-1,0,2,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,-1,0,0,0,0,1,4], [0,0,0,0,0,0,0,0,0,0,0,-2,-1,4], [0,0,0,1,-1,-1,0,0,0,1,-1,0,0,1,4], [1,-1,0,0,0,0,0,0,0,0,-2,0,1,0,1,4], [0,0,1,0,-1,-1,1,0,0,1,1,1,0,-1,0,-1,4], [0,0,1,1,0,0,0,-1,1,1,-1,1,0,0,0,1,0,4], [0,1,2,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,4], [0,2,0,-1,0,0,0,0,-1,0,1,0,0,0,0,-1,0,0,1,4], [0,-1,0,0,0,0,0,0,2,0,0,0,0,0,-1,0,-1,1,0,0,4], [0,0,1,-1,1,0,-1,1,1,0,1,-1,0,0,-2,0,0,0,0,0,1,4], [0,0,1,0,-1,0,1,-1,0,0,0,-1,0,0,0,-1,0,0,1,0,1,0,4], [0,0,0,0,-1,0,1,-1,1,0,1,-1,0,1,0,-1,0,0,1,0,1,0,2,4], [0,-1,0,0,0,2,0,0,0,0,0,0,-1,0,-1,0,-1,0,0,-1,0,1,0,0,4], [0,0,1,-1,1,1,1,0,1,-1,0,1,0,-1,0,0,0,0,1,0,1,0,0,0,0,4], [1,0,0,0,0,0,2,0,0,0,0,0,-1,0,1,0,1,-1,0,0,0,-1,1,0,0,1,4], [0,0,0,-1,1,1,1,-1,1,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,1,2,0,4], [0,-1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1,-1,0,-1,0,0,1,0,0,0,0,0,4], [0,0,0,-1,-1,-1,0,-1,1,0,0,1,0,0,0,-1,2,0,-1,0,0,0,0,0,0,0,1,0,-1,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,1,0,0,1,1,0,0,0,0,1,-1,0,-1,1,1,1,0,0,0,1,-1,0,0,1,0,-1,-1,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,-1,-1,1,0,-1,0,1,-1,0,-1,0,1,1,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,-1,-1,-1,0,0,0,-1,2,0,1,-1,-1,-1,0,-1,0,-1,1,0,1,-1,-1,2,2,-1,-2], [-1,0,-1,-1,1,1,2,-1,-2,-1,0,-3,2,-2,3,-2,1,2,1,-1,2,1,-3,0,1,0,0,-2,2,1], [0,-1,1,0,0,-1,-1,1,0,0,0,0,0,0,-1,0,-1,1,-1,1,-1,-1,0,1,0,0,1,1,0,0], [0,1,-1,-1,1,1,1,0,0,0,1,-2,1,-1,1,0,1,1,1,-1,1,-1,0,-1,1,0,-1,-2,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,0,0,0,0,0,0,0,1,-1,0,0,0,-1,-1,0,0,0,0,0,0,-1,-1,0,1,-1,0], [0,0,0,0,0,1,1,0,-1,0,0,0,0,-1,1,-1,-1,0,1,-1,1,1,-1,0,-1,-1,0,0,0,1], [1,-1,1,1,-2,-1,-1,0,1,1,-1,3,-1,2,-3,0,-2,-2,0,0,-2,1,1,0,-2,0,1,2,-2,-1], [0,0,0,-1,0,0,1,0,0,0,0,-1,1,-1,1,-1,0,1,0,0,0,0,-1,0,1,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [-1,1,-1,0,1,1,1,0,-1,0,1,-1,0,-1,1,1,0,0,1,-1,1,0,0,0,0,0,-1,-1,1,2], [-1,1,-1,0,2,1,1,0,-1,-1,1,-3,1,-2,2,1,2,1,1,0,2,-1,-1,0,2,0,-1,-2,2,2], [-1,0,-1,0,1,0,0,0,-1,-1,0,-1,1,0,1,0,2,1,0,0,1,0,0,0,1,0,0,0,1,0], [0,-1,1,0,0,-1,-1,0,0,0,-1,1,0,1,-1,0,0,0,-1,1,-1,0,0,1,0,0,1,1,0,-1], [-1,1,-1,0,1,1,1,0,-1,-1,0,-2,1,-1,2,0,2,1,0,0,2,0,-1,0,1,0,-1,-1,2,1], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,1,1,0,-1,-1,0,-1,1,-1,2,-1,0,1,0,0,1,1,-1,0,0,-1,0,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,-1,1,1,1,0,0,-1,0,-1,1,-1,2,-1,1,1,0,0,1,0,-1,0,1,-1,0,-1,1,0]], [[-1,0,-1,-1,2,1,2,-1,-1,-1,0,-3,2,-2,3,-1,2,1,1,0,2,0,-2,0,2,0,-1,-3,2,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,-1,0,0,-1,0,1,0,0,-1,0,0,0,0,0,1,-1,0,0,0,1,0,0,-1], [0,0,0,1,-1,0,0,0,0,0,0,1,0,1,-1,0,-1,0,0,0,-1,1,0,0,-1,0,1,1,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [1,-1,2,1,-2,-2,-2,1,1,1,-1,3,-1,2,-3,0,-2,-1,-2,1,-2,0,1,1,-1,0,2,3,-2,-2], [1,0,1,0,-1,0,-1,1,1,1,0,1,-1,1,-2,1,-1,-1,0,0,-1,-1,1,0,-1,0,0,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,-1,1,0,-1,-1,-1,0,1,1,0,2,-1,1,-2,0,-2,-1,0,0,-2,0,1,0,-1,0,1,1,-2,-1], [-1,1,-1,0,1,1,1,0,-1,0,1,-1,0,-1,1,1,0,0,1,-1,1,0,0,0,0,0,-1,-1,0,2], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,1,0,0,0,-1,1,0,0,0,1,-1,0,0,0,-1,0,-1,0,-1,0,1,1,-1,0,0,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,-1,1,0,0,0,0,0,0,0,0,1,-1,0,0,0,-1,-1,0,0,0,0,0,0,-1,-1,0,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,0,0,0,0,0,1,1,0,0,0,1,-1,1,1,-1,1,0,0,-1,1,-1,1,1,-1,-1,0,0], [0,1,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,1,0,0,0,1,-1,-1,0,1,0,0,0,1,0], [-1,1,-2,0,2,1,1,0,-1,-1,1,-3,1,-1,2,1,3,1,1,0,2,-1,0,-1,2,1,-2,-2,2,2], [0,1,-1,0,1,1,1,0,0,0,1,-2,0,-1,1,1,1,0,1,0,1,-1,0,-1,1,1,-2,-2,1,2], [0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,0,1,0,0,0,0,-1,0,0,0,1,0,1,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,-1,-1,0,1,0,0,0,0,1,-1,1,1,0,-1,1,-1,-1,1,0,1,1,0,0,0,-1], [0,0,0,-1,1,1,1,0,0,0,1,-1,0,-1,1,0,0,0,1,-1,1,-1,0,-1,0,-1,-1,-1,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,0,0,0,0,0,0,0,0,-1,1,0,0,0,1,1,0,0,0,0,0,0,1,1,0,-1,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,1,0,-1,0,0,0,1,1,0,1,-1,0,-1,0,-2,-1,0,0,-1,0,0,0,-1,0,0,0,-1,0], [-1,1,-1,0,1,1,1,0,-1,0,1,-1,0,-1,1,1,0,0,1,-1,1,0,0,0,0,0,-1,-1,0,2], [0,0,0,0,-1,-1,0,0,1,1,0,1,0,1,-1,0,-1,-1,0,0,-1,0,1,-1,0,1,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,1,0,0,0,1,-1,-1,0,1,0,0,0,1,0], [0,0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,-1,-1,1,0,-1,0,1,-1,0,-1,0,1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [1,0,1,1,-1,-1,-2,1,2,1,0,3,-2,2,-3,2,-1,-2,-1,1,-2,-1,3,0,-1,0,0,2,-2,-1], [0,0,0,0,1,0,0,1,0,0,1,0,-1,0,0,1,0,0,0,0,0,-1,1,0,0,0,-1,0,0,1], [1,-1,1,0,0,0,-1,1,0,0,0,1,-1,0,0,0,-1,0,-1,0,-1,0,1,1,-1,0,0,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [1,-1,1,0,-2,-1,-1,0,1,1,-1,3,-1,2,-2,-1,-2,-1,-1,0,-2,1,1,0,-2,0,1,2,-2,-2], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,-1,-1,0,-1,1,1,0,1,0,1,-1,0,-1,-1,0,0,-1,0,1,-1,0,1,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,-1,1,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,-1,0,0,-1,-1,0,0], [1,-1,2,1,-2,-2,-1,0,2,1,-1,3,-1,2,-3,0,-2,-2,-1,1,-2,0,1,0,-1,0,1,2,-2,-2], [0,0,0,0,0,1,1,0,-1,-1,0,-1,1,-1,2,-1,0,1,0,0,1,1,-1,0,0,-1,0,0,1,1], [0,0,0,0,-1,-1,0,0,0,1,0,0,0,0,-1,0,-1,0,0,0,-1,0,0,0,0,1,0,0,0,0], [0,1,-1,0,1,1,1,0,0,0,1,-2,0,-1,1,1,1,0,1,0,1,-1,0,-1,1,1,-2,-2,1,2], [0,0,0,-1,0,0,1,0,0,0,0,-1,1,-1,1,-1,0,1,0,0,0,0,-1,0,1,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0]]]], [ # Q-class [30][22] [[4], [2,4], [2,2,4], [1,0,0,4], [0,0,0,0,4], [2,2,2,0,0,4], [1,1,2,0,1,1,4], [0,1,1,0,1,0,2,4], [2,1,1,1,1,1,0,0,4], [1,1,1,2,0,0,0,0,1,4], [1,1,1,0,2,1,2,2,0,0,4], [1,1,1,0,1,2,2,0,0,0,2,4], [0,1,0,2,0,0,0,0,0,2,0,0,4], [0,0,0,2,0,1,0,0,0,0,0,0,2,4], [0,0,1,2,0,0,0,0,0,2,0,0,2,2,4], [1,0,0,0,1,1,0,0,0,0,2,2,0,0,0,4], [1,1,0,0,1,0,0,2,0,0,2,0,0,0,0,2,4], [0,0,0,0,2,0,1,0,1,0,1,2,0,0,0,1,0,4], [0,0,-1,1,1,-1,1,1,0,1,1,1,1,0,0,1,0,1,4], [0,0,0,0,2,0,0,0,1,0,1,1,0,0,0,2,1,2,1,4], [2,1,1,1,0,1,0,0,2,1,0,0,0,0,0,0,0,0,0,0,4], [1,2,1,0,1,1,0,0,2,1,0,0,1,0,0,0,0,1,0,0,1,4], [2,2,2,1,0,0,1,1,1,1,0,0,1,0,1,0,1,0,0,0,1,1,4], [0,0,0,0,2,0,2,1,1,0,1,1,0,0,0,0,0,2,1,0,0,1,0,4], [0,0,0,0,2,0,1,1,0,0,2,1,0,0,0,1,1,1,1,1,1,0,0,1,4], [0,0,0,0,1,0,0,0,0,0,1,1,0,0,0,2,1,1,1,2,1,0,0,0,2,4], [0,0,0,0,1,0,1,1,0,0,1,1,0,0,0,1,0,1,2,1,0,0,0,1,2,2,4], [0,0,0,0,1,0,1,0,0,0,1,2,0,0,0,1,0,2,1,1,1,0,0,1,2,2,2,4], [1,2,1,0,0,1,0,0,1,1,0,0,1,0,0,0,0,0,0,0,2,2,1,0,1,0,0,1,4], [1,1,1,2,0,0,0,0,1,2,0,0,2,0,2,0,0,0,0,0,1,1,2,0,0,0,0,0,1,4]], [[[-2,-1,1,0,0,1,0,-2,0,0,1,0,0,0,0,-1,2,0,1,0,1,0,1,0,-1,-1,1,0,0,0], [-1,-1,0,0,0,0,0,-1,0,0,1,1,0,0,0,-1,1,0,0,0,0,0,1,0,-1,0,1,-1,1,0], [-1,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,-1,0,0,0,0], [0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [1,1,0,1,0,-1,0,1,0,-1,-1,0,1,-1,1,1,-1,0,-1,0,0,0,-1,0,0,0,0,0,0,-1], [-1,-1,0,0,0,1,0,-1,0,0,1,0,0,0,0,-1,1,0,1,0,0,0,1,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [1,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,-1,-1,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,1,0,0,0,0,0,0,0,-1,0,0,0,1,0], [1,0,0,0,0,-1,-1,1,-1,0,0,1,0,0,0,0,-1,-1,-1,1,0,1,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,1,1,0,1,-1,0,0,0,0,-1,0,0,0,0,1,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0], [1,0,0,0,0,-1,0,1,0,0,-1,1,1,0,0,0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0], [1,0,0,0,0,-1,-1,1,0,0,0,1,0,0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,0,0,-2,0,1,0,0,-1,1,0,1,0,1,-1,0,-1,0,0,0,-1,0,0,0,0,0,0,0], [-1,-1,1,0,0,1,0,-1,0,0,0,0,0,0,0,-1,1,0,1,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,1,0,0,0], [1,0,-1,0,0,0,0,1,0,0,0,0,1,-1,1,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,1,0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [1,0,-1,0,0,0,0,1,-1,1,0,0,0,0,0,0,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,1,-1,0,0,-1,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,-1,0,0,-1,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,1,0,0,0,0,0,1,0,0,-1,-1,0,0,0,2,-1,0,0,0,0,0,0,0,1,-1,-1,1,-1,0], [0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,-1,0,0,1,0,0,1,0,0,-1,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,-1,0,0,1,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,-1,0,-1,1,0,0,-1,1,1,0,-1,0,0,-1,0,0,0,1,0,1,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [1,1,-1,0,0,-1,0,1,0,0,0,0,0,0,0,1,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,1,0,1,0,0,0,-1,-1,0,0,0,1,0,1,0,-1,0,-1,-1,-1,0,0,0,0,0,1], [0,0,-1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [-1,0,-1,0,0,1,1,-1,0,1,1,-1,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,-1,0,0,1,1,0,0,0,0,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,-1,0,0,1,0,0,1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0,1,-1,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,0,0,-1,0,1,0,0,0,0,0,0,0,1,-1,0,-1,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [30][23] [[8], [2,8], [2,2,8], [1,3,2,8], [3,1,4,3,8], [4,2,4,2,3,8], [2,1,4,2,4,2,8], [3,1,2,2,4,1,2,8], [2,2,2,3,4,2,1,3,8], [2,1,3,3,2,1,4,4,2,8], [3,4,4,1,2,4,1,2,4,1,8], [3,4,2,1,2,4,2,2,2,2,2,8], [2,2,2,4,4,2,4,2,2,3,1,1,8], [2,2,2,2,3,0,2,1,1,1,2,0,4,8], [4,1,3,2,4,3,2,2,2,4,3,2,3,3,8], [2,1,0,4,3,1,3,2,4,4,1,1,3,2,4,8], [2,4,2,4,2,4,3,2,2,3,2,2,4,2,1,2,8], [4,3,1,2,2,2,2,2,4,2,2,2,2,2,2,4,4,8], [2,2,2,2,1,4,1,3,0,2,2,2,2,2,2,1,4,2,8], [2,4,2,2,2,1,3,0,2,2,2,2,4,4,3,4,2,3,1,8], [4,1,1,2,3,2,1,3,1,1,0,3,1,1,2,1,1,2,1,1,8], [1,3,1,4,2,2,0,0,4,-1,2,1,2,1,0,2,3,2,1,2,2,8], [3,1,2,4,4,4,2,2,3,1,2,2,2,-1,2,2,2,1,2,0,3,3,8], [1,2,2,2,2,2,0,1,4,1,4,1,0,0,2,2,1,1,1,2,2,3,4,8], [1,2,4,2,1,2,2,3,-1,3,2,0,1,2,1,1,2,0,4,1,-1,-1,0,0,8], [1,4,1,3,2,1,2,2,1,2,2,2,4,1,2,2,2,0,1,2,2,3,2,1,1,8], [1,1,4,4,2,4,3,0,1,2,2,2,2,1,3,2,2,1,2,0,2,2,2,1,2,2,8], [1,3,1,2,0,2,-1,2,3,0,2,3,0,-1,-1,1,1,2,3,1,2,4,2,2,1,3,1,8], [0,4,2,4,1,0,1,1,0,1,2,0,2,4,1,1,2,-1,2,3,0,2,0,1,4,2,2,0,8], [1,1,4,3,2,1,2,3,4,4,2,1,1,-1,1,2,1,2,0,1,2,2,3,2,1,2,2,3,0,8]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,1,0,0,0,1,0,0,-1,0,0,0,1,0,0,1,-1,0,0,-1,0,1,-1,0,0,-1,-1,0,0,1], [-1,2,0,0,-1,3,1,1,-1,0,-1,-1,1,1,0,1,-2,0,0,-2,0,1,-1,1,-1,-1,-1,0,0,1], [-1,2,1,0,-2,3,1,2,-1,0,-1,-1,1,1,0,1,-2,0,-1,-1,0,1,0,0,-1,-1,-1,0,0,0], [-1,2,-1,0,-1,3,2,1,-1,0,-1,-1,1,1,1,0,-2,0,-1,-2,0,1,-1,1,0,-1,-1,1,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,1,-1,0,0,1,1,0,-1,0,0,0,1,0,0,0,-1,0,0,-1,0,1,-1,1,0,-1,0,0,0,1], [0,0,0,0,0,1,0,0,0,1,0,0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,1,0,-1,0,-1,0,-1,1,1,1,-1,0,1,0,0,0,-1,1,0,-1,0,1,0,-1,0,0,0], [0,0,0,0,0,1,0,0,0,1,0,0,0,0,-1,0,-1,0,0,0,0,1,0,0,0,0,0,-1,0,0], [0,0,1,0,0,0,-1,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,-1,0,0,0,0,-1,0,0,0,1,0,0,1,-1,0,0,-1,0,1,0,0,0,-1,0,0,0,1], [-1,1,-1,0,-1,3,1,1,0,1,-1,-1,0,1,0,-1,-2,1,-1,0,0,1,0,0,0,0,0,0,0,0], [-1,1,-1,0,-1,2,1,1,0,1,-1,-1,0,1,1,-1,-1,0,-1,0,0,1,0,0,0,-1,0,1,0,0], [-1,1,0,-1,-1,2,0,1,0,1,-1,-1,0,1,0,0,-1,0,-1,0,0,1,1,0,0,0,0,0,0,0], [-1,1,0,0,-1,1,1,0,0,0,0,0,1,0,1,0,-1,0,-1,-1,1,1,0,0,1,-1,-1,0,0,0], [1,-2,-1,1,1,-1,0,-1,0,-1,1,1,0,-1,0,-1,1,0,0,1,0,0,-1,0,1,0,0,0,0,1], [0,-3,-1,1,1,-2,0,-2,0,-1,2,2,1,-2,1,-1,1,1,0,0,1,0,-1,0,2,0,-1,0,1,1], [0,-1,-1,0,1,0,-1,0,0,1,1,0,-1,0,-1,-1,0,0,0,2,0,0,1,-1,0,0,1,0,0,0], [-1,1,-1,0,0,1,1,-1,0,0,0,0,1,0,1,0,-1,0,0,-1,1,1,-1,0,1,-1,-1,0,0,1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,1,0,1,-1,0,1,0,0,-2,0,0,1,0,1,1,0,-1,0,-1,1,0,-1,0,1,-1,-1,0,-1,1], [0,1,1,0,0,1,0,1,-1,0,0,-1,0,0,-1,1,-1,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,1,0,1,0,-1,0,-1,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,2,0,0,-1,3,1,1,0,1,-1,-1,0,1,0,0,-2,0,0,-1,0,1,0,0,-1,-1,-1,0,0,0], [0,2,0,0,-1,2,0,1,0,1,-1,-1,0,1,-1,0,-2,0,0,0,0,1,0,0,0,0,0,-1,-1,0], [-1,2,1,-1,-2,2,0,2,-1,0,-1,-1,1,1,0,1,-1,0,-1,-1,0,1,1,0,-1,-1,0,0,0,0], [0,-1,0,1,1,-2,-1,-1,0,0,2,1,0,-1,-1,0,0,0,1,1,1,0,0,-1,1,0,0,-1,-1,0], [-1,4,1,-1,-2,4,1,2,-1,1,-2,-2,1,2,0,2,-2,-1,-1,-2,0,1,0,0,-2,-2,-1,1,0,0], [0,0,1,1,0,0,0,-1,0,0,1,0,1,-1,-1,1,-1,0,1,-1,1,0,-1,0,0,0,-1,-1,0,0]], [[-2,1,1,-1,-1,3,0,1,-1,2,-1,-1,0,1,0,0,-2,2,-1,-1,0,1,1,0,-1,0,-1,0,1,-1], [0,-2,0,0,2,-2,-2,-1,0,1,1,1,-1,-1,-1,-1,1,1,0,2,0,0,1,-1,1,1,1,0,0,-1], [-1,1,0,-1,0,2,0,1,-1,1,-1,-1,0,1,0,0,-1,1,-1,-1,-1,0,1,0,-1,0,0,1,1,0], [0,-1,0,-1,1,-2,-1,-1,0,0,1,1,0,-1,0,0,1,0,0,1,0,0,1,-1,1,0,1,0,0,0], [-1,0,0,-1,0,0,0,0,-1,0,0,0,1,0,1,0,0,1,-1,-1,0,0,1,0,0,-1,0,1,1,0], [-2,2,0,-1,-1,3,1,1,-1,1,-1,-1,1,1,1,0,-2,1,-1,-2,0,1,0,0,-1,-1,-1,1,1,0], [0,0,0,-1,1,0,-1,0,-1,1,0,0,0,0,-1,0,0,1,0,0,-1,0,1,0,-1,0,1,0,1,0], [-1,-1,0,-1,0,0,0,0,-1,0,0,0,0,0,1,0,1,1,-1,0,0,0,1,0,0,0,0,1,1,0], [0,-2,-1,0,1,-1,0,-1,-1,0,1,1,0,-1,1,-1,1,1,-1,0,0,0,0,0,1,0,0,1,1,0], [0,-1,0,-1,1,0,-1,0,-1,1,0,0,-1,0,-1,0,0,1,0,1,-1,0,1,0,-1,1,1,0,1,0], [-1,0,0,0,0,1,0,0,-1,0,0,0,0,0,1,0,0,1,-1,-1,0,0,0,0,0,0,-1,1,1,0], [-1,0,-1,0,1,1,0,0,-1,1,0,0,0,0,0,-1,-1,1,0,0,0,1,0,0,0,0,0,0,0,0], [0,-2,0,-1,2,-2,-2,-1,-1,1,2,1,0,-1,-1,0,1,1,0,1,0,0,1,-1,0,0,1,0,1,0], [0,-1,1,0,1,-1,-1,-1,-1,0,1,1,1,-1,0,1,0,1,0,-1,0,0,0,0,0,0,-1,0,1,0], [-1,0,1,0,0,1,0,0,-1,0,0,0,0,0,0,1,-1,1,0,-1,0,0,0,0,-1,0,-1,0,1,0], [0,-1,0,0,1,-1,0,-1,-1,0,1,1,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0], [0,-2,1,-1,1,-2,-2,-1,0,1,1,1,0,-1,-1,0,1,1,0,1,0,0,1,-1,0,1,1,0,1,-1], [0,-2,1,0,1,-1,-1,-1,-1,1,1,1,0,-1,-1,0,0,2,0,0,0,0,0,0,0,1,0,0,1,-1], [-2,2,0,-1,-1,3,1,1,-1,1,-1,-1,1,1,1,1,-2,1,-1,-2,0,1,0,0,-1,-1,-1,1,1,0], [0,-1,0,0,2,-1,-1,-1,-1,1,1,1,0,-1,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0], [-1,2,1,-1,-1,1,1,0,0,0,-1,-1,1,0,1,1,-1,0,0,-2,1,1,0,0,0,-1,-1,0,0,0], [0,-1,-1,0,1,-2,0,-2,1,0,1,1,0,-1,1,-1,1,0,0,0,1,0,0,-1,2,0,0,0,0,0], [-2,4,0,-2,-2,4,1,2,-1,1,-2,-2,1,2,1,1,-2,0,-2,-2,0,1,1,0,-1,-2,0,1,0,0], [-1,2,0,-1,-1,2,1,0,0,0,-1,-1,1,0,1,1,-1,0,-1,-2,1,0,0,0,0,-1,-1,1,1,0], [-1,1,0,-1,0,2,0,1,-1,1,-1,-1,0,1,0,0,-1,1,-1,0,-1,0,1,0,-1,0,0,1,1,0], [0,0,0,-1,1,-1,-1,0,0,0,0,0,-1,0,0,0,1,0,0,1,0,0,1,-1,0,0,1,0,0,0], [0,0,0,0,1,-1,0,-1,0,0,1,0,0,-1,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,0], [-1,2,-1,-1,0,2,1,1,-1,1,-1,-1,0,1,1,0,-1,0,-1,-1,0,1,0,0,0,-1,0,1,0,0], [0,-1,0,0,1,-2,-1,-1,0,0,1,1,0,-1,0,0,1,0,0,1,0,0,1,-1,1,0,0,0,0,0], [0,1,0,-1,0,1,0,1,-1,1,-1,-1,-1,1,0,0,0,0,-1,0,-1,0,1,0,-1,0,1,1,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,1,1,-1,-1,0,0,0,0,1,-1,0,-1,-1,0,0,1,2,-1,0,0,0,0,1,1,-1,-1,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-4,0,1,2,-4,-2,-2,1,0,2,2,-1,-2,-1,-2,2,1,1,3,0,-1,1,-1,2,2,1,-1,0,-1], [1,-1,0,0,1,-2,-1,-1,1,1,1,0,-1,-1,-1,-1,1,0,1,2,0,-1,1,-1,0,1,1,0,0,-1], [1,-1,-1,0,1,-2,0,-1,0,0,1,1,0,-1,0,-1,1,0,0,1,0,0,0,0,1,0,1,0,0,0], [0,1,1,-1,0,0,-1,1,0,1,0,-1,0,0,-1,0,0,0,0,1,0,0,1,-1,-1,0,1,0,0,-1], [0,-1,0,0,1,0,-1,-1,0,2,1,0,-1,0,-1,-1,0,1,0,1,0,0,1,-1,0,1,0,0,0,-1], [1,-2,1,0,1,-2,-2,-1,1,1,1,1,-1,-1,-2,0,1,0,1,2,0,-1,1,-1,0,2,1,-1,0,-1], [0,-1,0,0,1,0,-2,0,0,2,1,0,-1,0,-2,-1,0,1,0,2,0,0,1,-1,0,1,1,-1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,1,0,-1,0,-1,1,0,0,0,0,-1,0,0,0,0,1,-1,0,0,0,-1,0,1,0,0,0], [0,-1,0,0,1,-1,-1,0,0,1,1,0,-1,-1,-1,-1,0,1,1,2,0,0,1,-1,0,1,1,-1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,1,0,0,0,1,0,0,0,0,0,-1,-1,1,0,0,0,0,0,0,0,0,0,0,1,0], [1,-3,1,0,1,-2,-2,-1,1,1,1,1,-1,-1,-2,-1,1,1,1,2,0,-1,1,-1,0,2,1,-1,1,-1], [1,-2,0,0,2,-3,-2,-1,0,1,2,1,-1,-1,-2,-1,1,0,1,3,0,0,1,-1,1,1,2,-1,-1,-1], [1,0,2,0,0,0,-1,0,0,1,0,0,0,0,-2,1,-1,0,1,0,0,0,0,0,-1,1,0,-1,0,-1], [0,-1,-1,0,1,-1,0,-1,-1,1,1,1,0,0,0,-1,0,1,0,0,0,1,0,0,1,0,0,0,0,0], [1,0,1,0,0,0,-1,1,0,0,-1,0,-1,0,-1,0,0,0,1,1,-1,0,0,0,-1,1,1,-1,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [2,-5,0,1,3,-6,-2,-3,1,-1,3,3,-1,-3,-1,-1,3,0,2,3,0,-1,0,-1,2,2,1,-1,0,0], [1,-2,0,0,1,-3,-1,-1,1,0,1,1,-1,-1,0,-1,2,0,0,2,0,-1,1,-1,1,1,1,0,0,-1], [1,-1,0,0,1,-1,-1,0,0,0,0,1,-1,0,-1,0,1,0,0,1,-1,-1,0,0,0,1,1,0,0,0], [0,-2,-1,1,1,-1,0,-1,0,0,1,1,-1,0,0,-2,1,1,0,1,0,0,0,0,1,1,0,0,0,0], [0,-2,-1,1,1,-1,0,-1,1,0,1,1,-1,-1,0,-2,0,1,1,2,0,0,0,-1,1,1,0,-1,0,0], [0,-1,-1,0,1,-1,0,-1,0,0,1,1,1,-1,0,-1,0,1,0,0,0,0,0,0,1,0,0,0,1,0], [1,-2,0,1,1,-2,0,-2,0,-1,1,2,0,-1,0,0,1,0,1,0,0,0,-1,0,1,1,-1,-1,0,1], [0,-2,-1,0,1,-1,-1,0,0,0,0,1,-1,0,0,-2,1,1,0,2,-1,0,1,0,1,1,1,0,0,0], [0,0,1,0,0,0,-1,0,1,1,0,0,-1,0,-1,0,0,0,0,1,0,0,1,-1,0,1,0,-1,0,-1]]]], [ # Q-class [30][24] [[6], [3,6], [0,0,6], [2,1,2,6], [1,2,1,1,6], [2,1,2,0,1,6], [1,2,0,1,2,1,6], [2,1,0,2,1,2,3,6], [2,1,2,2,3,2,1,2,6], [0,0,3,1,2,1,0,0,1,6], [2,1,2,0,0,2,1,2,0,1,6], [2,1,2,0,1,0,0,0,2,1,2,6], [2,1,2,0,1,2,0,0,2,1,2,2,6], [1,2,1,1,2,0,0,0,1,2,0,1,0,6], [1,2,1,3,2,0,2,1,1,2,0,0,0,2,6], [1,2,1,0,2,1,0,0,1,2,1,1,3,0,0,6], [2,1,2,2,1,0,0,0,2,1,0,2,0,3,1,0,6], [1,2,1,0,2,3,2,1,1,2,1,0,1,0,0,2,0,6], [0,0,2,2,1,0,1,2,2,1,2,2,0,1,1,0,2,0,6], [2,1,0,2,0,0,0,0,0,0,2,2,2,0,1,1,0,0,0,6], [0,0,1,1,2,1,2,1,1,2,1,0,1,2,2,2,1,2,1,1,6], [1,2,0,1,0,0,0,0,0,0,1,1,1,0,2,2,0,0,0,3,2,6], [0,0,2,2,1,2,1,2,2,1,2,0,2,1,1,1,2,1,2,2,3,1,6], [0,0,1,1,2,0,2,1,1,2,1,1,0,2,2,0,1,0,3,0,2,0,1,6], [1,2,1,1,0,0,2,1,0,2,1,1,0,2,2,0,1,0,0,1,2,2,1,0,6], [1,2,1,0,2,0,0,0,1,2,1,3,1,2,0,2,1,0,1,1,0,2,0,2,2,6], [1,2,1,0,0,1,2,1,0,2,3,1,1,0,0,2,0,2,1,1,2,2,1,2,2,2,6], [1,2,0,1,2,0,2,1,1,0,1,1,1,0,2,2,0,0,1,1,2,2,1,2,0,2,2,6], [2,1,2,0,0,2,0,0,0,1,0,0,2,0,0,1,0,1,-2,-2,-1,-1,-2,-1,0,0,0,0,6], [2,1,2,2,1,2,0,0,2,1,2,2,0,0,1,0,0,1,0,2,0,1,0,0,1,1,1,0,0,6]], [[[-1,-1,0,1,0,1,-1,0,1,-1,1,0,0,1,0,1,0,1,-1,0,-2,0,-1,1,2,-1,0,1,-1,-1], [0,-1,0,0,0,0,-1,0,0,-1,0,0,0,1,0,1,0,1,0,0,-2,0,0,1,2,-1,0,1,0,0], [0,1,0,-1,0,0,0,0,0,0,0,0,-1,-1,1,0,0,-1,0,1,1,-1,1,0,-1,1,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,-2,0,1,1,1,-1,0,0,-1,1,0,0,1,0,1,0,1,-1,0,-2,0,-1,1,2,-1,0,1,-1,-1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,0,0,1,-1,0,0,-1,1,0,-1,0,0], [0,-1,0,0,0,0,-1,0,1,-1,1,0,-1,0,1,1,0,1,-1,0,-1,0,0,1,1,0,0,0,0,-1], [1,-1,1,-1,0,0,0,0,0,-1,-1,0,-1,1,1,1,-1,0,0,0,-1,0,1,0,0,0,1,0,0,0], [0,-2,0,1,1,1,-1,-1,1,-2,1,1,-1,1,1,1,-1,1,-1,0,-2,0,0,1,2,-1,1,0,0,-2], [0,3,0,0,-1,0,1,0,0,2,0,0,0,-1,-1,-1,0,-2,0,0,2,0,0,0,-2,1,-1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,-2,0,0,1,0,-1,0,0,-2,0,0,0,1,1,1,0,1,0,0,-2,0,0,1,2,-1,1,0,0,0], [-1,3,-1,0,-1,0,1,0,0,2,0,0,0,-1,-1,-1,0,-2,0,0,2,0,1,0,-2,1,-1,-1,1,1], [0,-2,0,0,1,0,-1,0,0,-1,0,0,0,1,0,1,0,1,0,0,-2,0,0,1,2,-1,0,1,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,-1,0,0,1,0,1,0,-1,1,0,-1,1,0], [1,-2,0,0,0,0,0,-1,1,-1,0,0,-1,1,1,1,-1,1,0,0,-2,0,1,0,1,0,1,0,0,-1], [0,1,0,0,0,0,0,0,0,1,0,0,0,-1,0,-1,0,-1,0,0,1,0,0,0,-1,1,0,-1,0,0], [0,-2,0,0,0,0,0,0,0,-1,0,0,0,1,1,1,0,1,0,0,-2,0,0,0,1,0,1,0,0,0], [0,1,-1,0,0,0,0,0,0,1,0,0,0,-1,0,-1,0,-1,0,0,1,0,1,0,-1,1,0,-1,1,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1,0,0,1,0,0,0,-1,1,0,-1,0,0], [0,2,0,0,-1,0,0,0,0,1,0,0,0,-1,1,-1,0,-1,0,0,2,-1,0,-1,-2,2,0,-1,0,0], [0,-1,0,0,0,0,0,0,0,-1,0,0,0,1,1,1,0,0,0,0,-1,0,0,0,0,0,1,0,0,0], [0,-1,0,0,0,0,-1,0,0,-1,0,0,0,0,1,1,0,1,0,0,-1,0,0,1,1,0,0,0,0,0], [0,-2,0,0,1,0,-1,0,0,-1,0,0,0,1,0,1,0,1,0,0,-3,1,0,1,2,-2,1,1,0,0], [-1,-1,0,1,1,1,-1,0,0,-1,1,1,0,1,0,1,0,1,-1,0,-2,0,-1,1,2,-2,0,1,-1,-1], [1,-2,1,-1,0,0,0,0,0,-1,0,-1,0,1,1,1,0,1,0,0,-2,0,0,0,1,0,0,1,-1,0]], [[0,-3,0,0,1,0,0,0,0,-1,0,0,0,2,0,1,0,1,0,0,-3,1,0,0,1,-1,1,1,0,0], [2,-3,1,0,1,0,0,0,-1,-1,-1,0,0,2,0,1,-1,1,0,-1,-3,1,1,0,1,-1,1,1,-1,0], [0,-1,0,0,0,0,-1,0,0,-1,0,0,0,1,0,1,0,1,0,0,-2,0,0,1,2,-1,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,1,-1,1,-1,0,1,1,-1,0,0,0,0,-1,-1,1,0,0,0,-1,0,1,-1,1], [0,-2,0,0,0,0,0,0,0,-1,0,0,0,2,0,1,0,1,0,0,-2,1,0,0,1,-1,0,1,0,0], [0,-1,0,1,1,1,0,0,-1,0,0,0,1,1,-1,0,0,0,0,-1,-1,1,-1,0,1,-1,0,1,-1,0], [0,-1,0,0,1,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,-1,1,0,0,1,-1,0,1,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,1,-1,0,0,0,0,0,-1,1,0,0,0,-1,0,1,0,0], [-1,-1,0,1,0,1,-1,0,1,-1,1,0,0,1,0,1,0,1,-1,0,-2,0,-1,1,2,-1,0,1,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,-2,0,0,1,0,-1,0,0,-1,0,0,0,1,0,1,0,1,0,0,-3,1,0,1,2,-2,1,1,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,0,0,0,0,0,0,0,1,1,-1,0,0,1,-1,-1,-2,1,0,1,1,-1,0,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,1,0,0,-2,1,0,1,1,-1,0,1,0,0], [1,-2,1,0,0,0,0,0,0,-1,0,0,0,2,0,1,-1,1,0,-1,-2,1,0,0,1,-1,0,1,-1,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0,0,-1,1,0,1,1,-1,-1,1,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1,0,0,1,0,0,0,-1,1,0,-1,0,0], [-1,2,0,0,-1,0,0,1,0,1,0,-1,1,-1,-1,-1,1,-1,0,0,2,0,-1,0,-1,1,-1,0,0,1], [0,1,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,-1,0,0,1,0,1,0,-1,1,0,-1,1,0], [0,2,0,0,-1,0,0,0,0,1,0,0,0,-1,-1,-1,0,-1,0,0,2,0,0,0,-1,1,-1,0,0,0], [-1,0,-1,1,0,1,0,0,0,1,1,0,1,0,-1,0,1,0,-1,-1,-1,1,-1,1,1,-1,-1,1,-1,0], [0,-2,1,1,1,1,-1,0,0,-2,0,0,0,1,0,1,0,1,-1,0,-2,0,-1,1,2,-1,1,1,-1,-1], [0,-2,0,1,1,1,-1,0,0,-1,0,1,0,1,0,1,0,1,-1,-1,-3,1,0,1,2,-2,1,1,-1,-1], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,-1,0,0,0,1,-1,1,-1,-1,1,-1,0,-1,1,-1,1,0,1,0,0,-1,-1,1,0,0,0,1], [0,-3,0,0,1,0,-1,0,0,-2,0,0,0,2,1,1,0,2,0,0,-3,0,0,0,2,-1,1,1,0,0], [0,-1,0,0,0,0,0,0,0,-1,0,0,0,1,1,1,0,0,0,0,-1,0,0,0,0,0,1,0,0,0]]]], [ # Q-class [30][25] [[6], [-1,6], [3,1,6], [1,0,1,6], [0,0,0,-1,6], [1,0,1,0,0,6], [0,-2,0,0,0,0,6], [0,-1,0,0,0,0,-1,6], [0,0,0,1,1,1,0,0,6], [-3,0,-3,-1,0,-1,0,0,0,6], [0,0,0,-1,3,0,0,0,2,0,6], [0,0,0,1,0,0,0,1,0,-1,1,6], [-1,0,-1,2,-1,0,0,1,0,1,-1,3,6], [0,0,0,0,3,0,-1,1,0,0,0,0,0,6], [0,0,0,0,3,0,1,0,0,0,0,0,0,3,6], [0,-1,1,0,-1,0,0,1,0,0,0,0,0,-2,-1,6], [1,-1,0,0,0,-3,-1,0,0,0,0,0,0,0,0,0,6], [0,-3,-1,0,0,1,1,1,0,0,0,0,0,0,0,2,-1,6], [0,0,0,0,0,0,0,-1,-1,1,0,0,0,0,0,0,0,0,6], [0,-1,-1,0,0,0,-1,-2,0,0,0,0,0,0,0,0,0,1,3,6], [1,0,1,0,0,3,0,-1,1,-1,0,0,0,0,0,0,0,0,3,3,6], [1,0,1,-2,0,1,0,1,-1,-1,0,1,2,0,0,0,0,0,1,1,2,6], [-1,0,0,1,0,0,-1,0,0,0,0,0,0,0,1,0,1,0,-1,-1,-1,0,6], [0,0,0,1,-1,1,0,0,0,0,0,0,0,-1,-1,0,-1,0,-1,-1,-1,0,3,6], [0,0,1,0,0,0,-1,0,1,1,-1,0,0,-1,0,0,0,0,-1,1,0,0,0,0,6], [1,0,2,1,1,-1,-1,0,-1,-1,1,0,0,-1,0,0,0,0,0,1,-1,0,0,0,3,6], [0,0,1,-1,0,0,-1,0,0,0,0,0,0,-1,0,0,0,0,1,2,1,0,-3,-3,3,3,6], [0,1,0,1,0,0,-3,2,0,0,0,0,0,1,0,0,0,-1,1,2,1,-1,-1,-1,1,1,2,6], [0,1,0,-1,-1,-1,-3,1,-3,0,-1,0,0,1,0,0,0,-1,0,1,-1,1,0,0,1,2,1,3,6], [0,-1,0,0,1,1,3,0,0,0,0,0,0,1,2,0,-2,-1,0,0,0,0,-1,1,0,0,0,0,0,6]], [[[-1,-1,0,0,-1,0,-1,-1,0,0,0,0,0,0,1,0,0,0,0,-1,0,1,-1,0,0,1,-1,1,-1,0], [0,0,0,1,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1,1,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,1,1,0,0,0,0,0,0,1,0,1,0,-1,0,0,0,0,0,0,0,1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,1,1,0,-1,1,-1,1,0,0,0,0,-1,1,1,-1,-1,0,0,1,-1,0,-1,1,-1], [0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,-1,0,1,0,-1,0,0,0,0,0,-1,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,1,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,-1,0,0,0,-1,0,0,0], [0,0,0,-1,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,-1,0], [0,0,0,0,-1,0,-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,0,-1,1], [0,0,0,-1,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,-1,0,-1,1], [0,0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,-1,0,-1,1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,0,1,0,0,0,0,0,0,1,0,1,0,-1,0,0,0,0,0,1,0,0,1,0,0,-1], [0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,-1,0,0,0,0,0,1,0,0,1,0,0,-1], [0,0,0,-1,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,1,-1,0,0,-1,0,0,0,0,0,1,-1,0,-1,0,1,0,0,0,-1,0,-1,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0]], [[0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,-1,-1,-1,0,1,-1,1,-1,0,0,0,-1,0,-1,-1,1,1,0,0,-1,1,0,1,-1,0], [0,0,0,0,-1,0,-1,0,-1,0,1,0,0,0,1,0,0,0,0,0,0,0,-1,0,1,0,-1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0], [0,0,0,-1,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,-1,1,-1,0,0,0,0,0,-1,0,0,1,0,0,-1,1,0,1,-1,0], [0,0,-1,1,0,1,1,0,0,0,0,0,-1,1,0,1,0,-1,0,0,-1,1,0,0,0,0,1,0,0,-1], [0,0,-1,0,0,1,1,0,0,-1,0,0,0,1,0,1,0,-1,1,0,-1,0,0,0,1,0,0,0,0,-1], [0,-1,0,0,0,-1,-1,-1,0,0,0,0,0,0,0,0,-1,0,0,-1,0,1,0,0,0,0,0,1,-1,0], [0,-1,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,-1,0,0,-1,1,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,1,-1,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,-1,0,0,0], [0,0,0,-1,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,-1,0,-1,1], [0,0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,-1,0,-1,1], [0,0,0,0,-1,0,-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,1,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0,1,0,-1,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,-1,0,0,-1,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,1,-1,1,-1,0,0,0,0,0,-1,0,1,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [-1,0,0,1,0,1,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,-1,1,-1,0,0,0,0,0,0,0], [0,0,-1,1,0,1,1,0,0,0,0,0,-1,1,0,1,0,-1,0,0,-1,1,0,0,0,0,1,0,0,-1], [0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,-1,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,-1,0,0,0,0], [0,0,1,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,-1,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,1,-1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,-1]]]], [ # Q-class [30][26] [[6], [2,6], [2,2,6], [2,2,2,6], [2,2,2,2,6], [-2,2,0,0,0,6], [-2,0,2,0,0,2,6], [-2,0,0,2,0,2,2,6], [-2,0,0,0,2,2,2,2,6], [0,-2,2,0,0,-2,2,0,0,6], [0,-2,0,2,0,-2,0,2,0,2,6], [0,-2,0,0,2,-2,0,0,2,2,2,6], [0,0,-2,2,0,0,-2,2,0,-2,2,0,6], [0,0,-2,0,2,0,-2,0,2,-2,0,2,2,6], [0,0,0,-2,2,0,0,-2,2,0,-2,2,-2,2,6], [3,1,1,1,1,-1,-1,-1,-1,0,0,0,0,0,0,6], [1,3,1,1,1,1,0,0,0,-1,-1,-1,0,0,0,2,6], [1,1,3,1,1,0,1,0,0,1,0,0,-1,-1,0,2,2,6], [1,1,1,3,1,0,0,1,0,0,1,0,1,0,-1,2,2,2,6], [1,1,1,1,3,0,0,0,1,0,0,1,0,1,1,2,2,2,2,6], [-1,1,0,0,0,3,1,1,1,-1,-1,-1,0,0,0,-2,2,0,0,0,6], [-1,0,1,0,0,1,3,1,1,1,0,0,-1,-1,0,-2,0,2,0,0,2,6], [-1,0,0,1,0,1,1,3,1,0,1,0,1,0,-1,-2,0,0,2,0,2,2,6], [-1,0,0,0,1,1,1,1,3,0,0,1,0,1,1,-2,0,0,0,2,2,2,2,6], [0,-1,1,0,0,-1,1,0,0,3,1,1,-1,-1,0,0,-2,2,0,0,-2,2,0,0,6], [0,-1,0,1,0,-1,0,1,0,1,3,1,1,0,-1,0,-2,0,2,0,-2,0,2,0,2,6], [0,-1,0,0,1,-1,0,0,1,1,1,3,0,1,1,0,-2,0,0,2,-2,0,0,2,2,2,6], [0,0,-1,1,0,0,-1,1,0,-1,1,0,3,1,-1,0,0,-2,2,0,0,-2,2,0,-2,2,0,6], [0,0,-1,0,1,0,-1,0,1,-1,0,1,1,3,1,0,0,-2,0,2,0,-2,0,2,-2,0,2,2,6], [0,0,0,-1,1,0,0,-1,1,0,-1,1,-1,1,3,0,0,0,-2,2,0,0,-2,2,0,-2,2,-2,2,6]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,1,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1], [0,0,0,0,0,0,0,1,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,1,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1], [0,0,-1,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,1,0], [-1,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,1,0,0,0,0,0,0], [0,-1,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,-1,0], [0,0,0,0,0,-1,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,1,0,0,0]], [[0,-1,0,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0]]]], [ # Q-class [30][27] [[10], [4,10], [4,2,10], [4,4,4,10], [4,4,4,2,10], [2,0,1,2,1,10], [5,2,2,2,2,4,10], [1,2,1,1,1,2,2,10], [2,2,2,2,4,1,1,0,10], [2,2,-1,2,1,4,4,2,1,10], [1,1,1,1,2,2,2,0,5,2,10], [2,4,4,4,4,1,1,1,2,1,1,10], [2,2,-1,2,1,4,4,4,2,4,4,1,10], [2,2,2,5,1,4,4,2,1,4,2,2,4,10], [4,4,-2,4,2,2,2,2,4,2,2,2,5,2,10], [4,0,2,4,2,5,2,1,2,2,1,2,2,2,4,10], [1,1,2,2,1,2,2,2,2,2,4,0,2,4,1,1,10], [1,1,1,1,2,4,2,2,2,4,4,1,2,2,1,2,2,10], [2,1,2,1,0,4,4,2,1,2,2,1,2,2,1,2,4,2,10], [2,2,2,2,2,1,1,1,2,2,1,4,1,1,2,2,1,0,1,10], [1,2,1,0,1,-2,-1,0,1,-1,2,2,2,0,1,-4,4,-1,0,0,10], [4,2,2,2,2,0,2,2,1,0,-1,2,0,1,0,0,1,2,0,-4,2,10], [4,2,4,2,0,2,2,1,2,1,1,2,1,1,2,4,2,1,5,2,0,0,10], [2,2,2,2,4,2,1,1,4,2,2,2,1,1,2,4,1,5,1,0,-2,1,2,10], [2,2,4,4,2,1,1,1,4,1,2,0,1,2,2,2,5,1,2,2,2,-1,4,2,10], [2,0,0,0,0,0,4,1,2,2,1,-2,0,0,0,0,1,-1,0,1,0,2,0,-2,-1,10], [1,1,1,2,1,0,-1,1,-2,0,2,1,0,-2,0,0,0,2,2,2,2,1,1,-2,0,1,10], [4,4,-2,4,2,2,2,1,2,5,1,2,2,2,4,4,1,2,1,4,-2,0,2,4,2,1,0,10], [2,1,0,0,-2,4,4,1,2,0,1,-1,2,0,1,2,0,0,4,-1,0,2,2,0,0,4,0,0,10], [1,2,1,1,1,2,2,4,1,4,2,1,2,2,1,1,4,0,4,0,0,-1,2,0,2,-1,-2,2,0,10]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,1,0,0,0,0,1,1,1,0,0,-1,0,0,0,1,0,0,-1,0,-1,0,-1,-1,-1,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,1,1,1,1,0,0,-1,-1,0,0,1,0,0,-1,0,-1,0,-1,-1,-1,0,1,0,-1], [0,-2,11,-3,0,-2,4,5,9,5,-4,1,-2,-2,2,-2,10,-2,-4,-11,-2,-9,0,-8,-8,-9,4,11,4,-8], [-1,0,2,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,-1,0,0,0,2,0,0], [-2,2,-10,4,1,2,-4,-4,-10,-4,6,-3,1,1,-2,2,-11,1,5,12,3,11,1,7,8,8,-6,-10,-4,7], [0,4,-19,5,0,4,-7,-8,-16,-8,8,-2,3,2,-4,4,-17,2,8,19,3,17,0,13,15,15,-8,-19,-8,13], [0,-4,21,-7,-1,-4,8,8,18,8,-10,3,-3,-2,4,-4,19,-2,-9,-21,-4,-18,-1,-14,-15,-16,10,21,8,-13], [0,4,-16,4,0,3,-6,-7,-14,-7,7,-2,3,2,-4,4,-15,2,7,16,3,14,0,11,13,13,-7,-16,-7,11], [0,0,1,0,0,0,1,1,1,0,0,0,-1,0,0,0,1,0,0,-1,0,-1,0,-1,-1,-1,0,1,0,-1], [-1,4,-19,6,1,4,-8,-8,-18,-8,10,-3,3,2,-4,4,-19,2,9,20,4,18,0,13,16,16,-10,-19,-8,13], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,2,-10,3,0,2,-4,-4,-9,-4,5,-1,1,1,-2,2,-9,1,4,10,2,9,0,7,8,8,-5,-10,-4,7], [0,-1,5,-1,0,-1,2,2,4,2,-2,0,-1,-1,1,-1,5,-1,-2,-5,-1,-4,0,-3,-4,-4,2,5,2,-3], [1,0,1,-1,-1,0,1,1,3,0,-2,1,0,0,-1,0,2,0,-1,-3,0,-3,0,-1,-1,-1,2,2,0,-1], [0,-3,16,-5,0,-3,6,7,13,7,-7,2,-3,-2,3,-3,15,-2,-7,-16,-3,-14,0,-11,-12,-13,7,16,7,-11], [0,-2,12,-4,-1,-2,5,5,11,5,-6,2,-2,-1,2,-2,11,-2,-5,-13,-2,-11,0,-8,-9,-9,6,12,4,-8], [-1,0,1,0,0,0,1,0,1,0,0,-1,-1,0,0,1,0,0,0,0,1,0,0,-1,-1,-1,0,1,0,0], [1,3,-15,4,0,3,-5,-5,-11,-6,6,-1,2,2,-4,3,-13,2,6,13,3,11,0,9,11,11,-6,-14,-6,9], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,5,-2,0,-1,2,2,5,2,-3,1,-1,0,1,-1,5,-1,-2,-6,-1,-5,0,-3,-4,-4,3,5,2,-3], [1,-2,11,-3,0,-2,4,5,10,5,-6,2,-2,-2,2,-3,12,-1,-5,-12,-3,-11,0,-8,-9,-9,5,11,5,-8], [1,0,-1,0,0,0,0,0,1,0,-1,1,0,0,-1,0,1,0,0,-1,0,-1,0,0,0,0,1,0,0,0], [-2,1,-5,1,0,1,-2,-3,-6,-3,3,-2,1,1,0,2,-7,1,3,7,2,7,0,4,5,5,-3,-5,-3,5], [-1,-1,8,-2,0,-2,4,4,7,4,-3,0,-2,-1,1,0,7,-1,-3,-8,0,-7,0,-6,-7,-7,3,8,3,-6], [0,-2,10,-3,0,-2,4,4,9,4,-5,1,-2,-1,2,-2,10,-1,-5,-10,-2,-9,0,-7,-8,-8,5,10,4,-6], [-1,2,-7,2,0,2,-3,-3,-7,-3,4,-2,1,1,-1,2,-8,0,4,8,2,8,0,5,6,6,-4,-7,-4,5], [0,1,-3,0,-1,1,-1,-2,-2,-2,1,0,1,1,-1,0,-3,0,1,3,0,3,0,3,3,3,0,-3,-2,3]], [[-2,1,-5,1,0,1,-2,-3,-6,-3,3,-2,1,1,0,2,-7,1,3,7,2,7,0,4,5,5,-3,-5,-3,5], [-1,0,1,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,-6,1,0,2,-3,-3,-7,-3,4,-1,1,1,0,1,-7,0,3,7,1,7,0,5,6,6,-3,-6,-3,5], [-1,2,-7,2,0,1,-3,-3,-7,-3,4,-2,1,1,-1,2,-8,1,4,8,2,7,0,5,6,6,-4,-7,-3,5], [-1,1,-2,1,0,1,-1,-1,-3,-1,2,-1,0,0,0,1,-3,0,2,3,1,3,0,1,2,2,-2,-2,-2,1], [-1,1,-5,1,0,1,-2,-3,-6,-3,3,-1,1,1,0,1,-6,1,3,6,1,6,0,4,5,5,-3,-5,-3,4], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,-2,0,0,0,-1,-1,-3,-1,2,-1,0,1,0,1,-3,0,1,3,1,3,0,2,2,2,-1,-2,-1,2], [-1,0,2,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,-1,0,0,0,2,0,-1], [-2,1,-3,1,0,1,-1,-2,-4,-2,3,-2,0,1,0,1,-5,0,2,5,2,5,0,3,3,3,-2,-3,-2,3], [0,-1,8,-3,-1,-1,3,3,7,3,-4,1,-1,-1,2,-2,8,-1,-4,-8,-2,-7,0,-5,-6,-6,4,8,3,-5], [-2,3,-12,3,0,3,-5,-7,-13,-6,7,-3,2,2,-1,3,-14,1,6,15,3,14,0,10,11,11,-6,-13,-6,10], [-1,3,-13,3,0,3,-5,-6,-12,-6,7,-2,2,2,-2,3,-13,1,6,14,2,13,0,9,11,11,-6,-13,-6,9], [-2,3,-12,3,0,3,-5,-6,-13,-6,7,-3,2,2,-1,3,-14,1,6,15,3,14,0,10,11,11,-6,-13,-6,10], [-1,2,-7,2,0,2,-3,-3,-7,-3,4,-2,1,1,-1,2,-8,0,4,8,2,8,0,5,6,6,-4,-7,-4,5], [0,1,-3,0,-1,1,0,-1,-1,-2,1,0,0,1,-1,1,-3,0,1,2,1,2,0,2,2,2,0,-2,-2,2], [-1,-1,7,-2,0,-1,3,3,5,3,-2,0,-2,-1,2,-1,5,-1,-2,-6,0,-5,0,-5,-5,-5,2,7,2,-5], [0,2,-8,2,0,2,-2,-3,-6,-4,3,-1,1,1,-2,2,-7,1,3,7,2,6,0,5,6,6,-3,-7,-4,5], [0,1,-3,0,0,1,-2,-2,-3,-2,1,0,1,1,0,0,-3,1,1,3,0,3,0,2,3,3,-1,-3,-1,3], [0,0,1,-1,-1,0,1,0,2,0,-1,0,0,0,0,0,1,0,-1,-1,0,-1,0,0,-1,-1,2,1,0,0], [0,-2,9,-3,-1,-2,4,4,8,4,-4,1,-2,-1,2,-1,8,-1,-4,-9,-1,-8,0,-6,-7,-7,4,9,3,-6], [-1,4,-20,6,1,4,-7,-8,-17,-8,9,-3,3,2,-4,4,-18,2,8,20,4,18,1,13,15,15,-9,-19,-8,13], [-1,0,4,-1,0,-1,2,2,3,2,-1,0,-1,-1,1,0,3,-1,-1,-4,0,-3,0,-3,-3,-3,1,4,1,-3], [0,-1,4,-2,0,-1,2,2,4,2,-2,1,-1,0,1,-1,4,-1,-2,-5,-1,-4,0,-3,-3,-4,3,5,2,-3], [0,2,-11,3,0,2,-5,-5,-10,-5,5,-1,2,2,-2,2,-11,2,5,11,2,10,0,8,9,10,-5,-11,-5,8], [0,1,-7,2,0,2,-3,-3,-6,-3,3,-1,1,1,-1,1,-7,1,3,7,2,6,0,5,6,6,-3,-7,-3,5], [-1,0,2,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,-1,0,0,0,2,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0]]]], [ # Q-class [30][28] [[4], [2,4], [0,-1,4], [-1,0,2,4], [2,1,0,-1,4], [1,2,-1,0,2,4], [2,2,0,0,1,1,4], [2,1,0,-1,2,1,1,4], [1,2,-1,0,1,2,1,2,4], [0,0,-2,-2,0,0,1,0,0,4], [2,2,0,0,1,1,2,1,1,0,4], [1,1,0,0,2,2,2,1,1,1,1,4], [0,0,-1,-1,0,0,1,0,0,2,0,1,4], [-1,-1,-2,-2,-1,-1,-1,-1,-1,2,-1,-1,1,4], [0,0,-2,-2,0,0,0,0,0,2,1,0,1,2,4], [0,-1,1,0,0,-1,0,0,-1,0,1,0,0,0,1,4], [-1,0,0,1,-1,0,0,-1,0,0,1,0,0,0,1,2,4], [0,-1,2,1,0,-1,0,0,-1,-1,0,0,-1,-1,-1,1,0,4], [-1,0,1,2,-1,0,0,-1,0,-1,0,0,-1,-1,-1,0,1,2,4], [1,1,1,1,2,2,1,1,1,-1,1,2,-1,-2,-1,0,0,1,1,4], [-1,-1,0,0,-2,-2,-1,-1,-1,0,-2,-2,0,1,-1,-1,-1,0,0,-2,4], [-1,-1,0,0,-1,-1,-2,-1,-1,-1,-1,-2,-1,1,0,0,0,0,0,-1,1,4], [1,1,1,1,1,1,1,1,1,-1,1,1,-1,-2,-1,0,0,1,1,2,-1,-2,4], [2,2,1,1,1,1,2,1,1,-1,2,1,-1,-2,-1,0,0,1,1,2,-1,-1,2,4], [-1,-1,0,0,-1,-1,-2,-1,-1,-1,-1,-2,-1,1,0,0,0,0,0,-1,1,2,-1,-1,4], [1,1,0,0,1,1,1,1,1,0,2,1,0,-1,1,2,2,0,0,1,-2,-2,2,1,-1,4], [1,1,0,0,1,1,1,1,1,0,2,1,0,-1,1,1,1,0,0,1,-2,-1,1,1,-2,2,4], [-1,-1,-1,-1,-1,-1,-1,-1,-1,1,-1,-1,1,2,1,0,0,-2,-2,-2,1,1,-2,-2,2,-1,-2,4], [0,0,-1,-1,0,0,0,0,0,1,1,0,2,1,2,1,1,-1,-1,-1,-1,0,-1,-1,0,1,1,1,4], [1,1,1,1,1,1,1,2,2,-1,1,1,-2,-2,-1,0,0,1,1,2,-1,-1,2,2,-1,1,1,-2,-2,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,1,0,0,0,0,-1,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0], [0,0,0,1,0,0,0,1,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1], [0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1], [1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1], [0,0,-1,1,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,-1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0]]]], [ # Q-class [30][29] [[8], [0,8], [4,-4,8], [4,2,2,8], [2,-2,2,4,8], [0,-2,4,2,4,8], [4,0,2,2,1,0,8], [0,4,-2,1,-1,-1,0,8], [2,-2,4,1,1,2,4,-4,8], [2,1,1,4,2,1,4,2,2,8], [1,-1,1,2,4,2,2,-2,2,4,8], [0,-1,2,1,2,4,0,-2,4,2,4,8], [4,0,2,2,1,0,4,0,2,2,1,0,8], [0,4,-2,1,-1,-1,0,4,-2,1,-1,-1,0,8], [2,-2,4,1,1,2,2,-2,4,1,1,2,4,-4,8], [2,1,1,4,2,1,2,1,1,4,2,1,4,2,2,8], [1,-1,1,2,4,2,1,-1,1,2,4,2,2,-2,2,4,8], [0,-1,2,1,2,4,0,-1,2,1,2,4,0,-2,4,2,4,8], [4,0,2,2,1,0,4,0,2,2,1,0,4,0,2,2,1,0,8], [0,4,-2,1,-1,-1,0,4,-2,1,-1,-1,0,4,-2,1,-1,-1,0,8], [2,-2,4,1,1,2,2,-2,4,1,1,2,2,-2,4,1,1,2,4,-4,8], [2,1,1,4,2,1,2,1,1,4,2,1,2,1,1,4,2,1,4,2,2,8], [1,-1,1,2,4,2,1,-1,1,2,4,2,1,-1,1,2,4,2,2,-2,2,4,8], [0,-1,2,1,2,4,0,-1,2,1,2,4,0,-1,2,1,2,4,0,-2,4,2,4,8], [4,0,2,2,1,0,4,0,2,2,1,0,4,0,2,2,1,0,4,0,2,2,1,0,8], [0,4,-2,1,-1,-1,0,4,-2,1,-1,-1,0,4,-2,1,-1,-1,0,4,-2,1,-1,-1,0,8], [2,-2,4,1,1,2,2,-2,4,1,1,2,2,-2,4,1,1,2,2,-2,4,1,1,2,4,-4,8], [2,1,1,4,2,1,2,1,1,4,2,1,2,1,1,4,2,1,2,1,1,4,2,1,4,2,2,8], [1,-1,1,2,4,2,1,-1,1,2,4,2,1,-1,1,2,4,2,1,-1,1,2,4,2,2,-2,2,4,8], [0,-1,2,1,2,4,0,-1,2,1,2,4,0,-1,2,1,2,4,0,-1,2,1,2,4,0,-2,4,2,4,8]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,-1,0,0,0,-1,-1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,1,0,-1,1,0,-1,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,1,-1,1,0,-1,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,-1,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,1,0,-1,0,0,0,0,0,0,1,0,-1,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,1,-1,0,0,0,0,0,0,1,0,-1,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,-1,0,1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,-1,0,1], [0,0,0,0,0,0,-1,0,1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,-1,1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,0], [0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [-1,0,1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,-1,0,1], [-1,0,1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,-1,1]], [[-1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,1,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,1,0,1,-1,0,0,0,0,0,0,1,-1,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,1,-1,0,0,0,0,0,0,1,0,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,0,-1,0,0,0,0,0,0,1,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,-1,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-1,0,-1,1,-1,1,1,0,1,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,-1,1,-1,0,1,0,1,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,1,-1,0,1,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,-1,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-1,0,-1,1,0,0,0,0,0,0,-1,1,1,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,-1,1,0,0,0,0,0,0,-1,0,1,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,1,0,0,0,0,0,0,-1,0,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,1,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,1,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,1,0,1,-1,1,-1,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,1,0,1,-1,1,0,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,1,0,0,-1,1,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1]]]], [ # Q-class [30][30] [[15], [3,15], [4,5,15], [5,5,1,15], [3,3,3,3,15], [5,1,4,3,1,15], [5,2,5,4,4,1,15], [3,1,4,1,3,-3,3,15], [5,1,3,1,-1,-1,3,5,15], [3,5,0,1,0,3,3,0,5,15], [3,3,1,3,5,3,3,1,5,3,15], [-3,0,0,5,3,-3,3,5,3,-3,3,15], [3,4,4,3,4,3,3,3,3,1,5,3,15], [3,0,1,1,3,5,3,-1,1,-1,4,5,3,15], [3,5,2,3,3,5,-1,-5,-1,3,1,-3,-2,3,15], [3,1,3,-3,1,3,3,4,1,-1,3,1,3,4,-3,15], [3,3,3,-3,-1,-1,-1,-1,5,0,3,1,0,1,3,3,15], [-3,1,-2,3,1,-3,1,2,3,3,3,3,5,-1,-3,3,0,15], [4,1,3,3,5,4,3,3,1,-1,0,2,0,3,3,1,3,-3,15], [1,4,1,5,-3,3,4,-1,5,4,3,3,3,3,1,1,-1,3,-1,15], [4,4,4,0,5,3,-2,3,1,3,3,-3,3,-3,3,0,1,-3,3,-1,15], [3,1,3,-1,1,5,0,1,3,-1,-1,-1,5,3,0,3,3,1,1,-3,1,15], [0,3,-1,3,-3,3,0,3,1,1,3,5,-3,2,3,3,3,-2,3,1,-3,-1,15], [5,3,1,1,0,4,1,3,0,-3,3,-1,3,2,1,5,0,0,2,1,3,3,3,15], [3,0,1,3,3,3,3,0,1,3,3,0,2,3,5,3,-1,3,1,3,-3,0,0,1,15], [1,3,3,3,1,-1,5,-1,3,-3,5,3,1,2,5,3,3,3,3,3,0,-1,3,4,1,15], [3,1,1,4,3,1,3,3,0,-1,2,2,1,-1,3,3,1,0,3,4,3,-3,5,5,2,4,15], [1,1,-1,4,5,-1,3,3,1,-1,4,3,1,-3,0,0,0,-1,-3,1,1,1,1,-1,1,-1,3,15], [4,1,3,4,1,1,1,5,3,1,4,3,1,5,0,1,-1,3,3,5,5,-3,-1,5,2,3,2,-5,15], [4,4,3,-4,1,-1,5,3,1,3,-3,-1,0,1,3,3,5,-1,3,-2,-3,3,3,3,3,1,0,-1,-3,15]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,1,0,1,0,0,0,0,0,0,0,-1,0,0,-1,0,-1,0,0,1,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [3,2,1,-4,-3,0,0,-2,0,-1,1,2,0,0,1,-1,-3,3,2,-2,0,0,0,-1,0,-1,1,2,1,0], [5,5,1,-8,-6,1,1,-5,2,-4,1,4,0,0,2,-1,-6,6,4,-4,1,-1,1,-3,0,-3,2,4,2,0], [-1,-2,0,2,2,-1,0,2,-1,1,1,-1,0,-1,1,1,1,-2,-1,2,-1,1,0,1,-1,0,-1,-2,-1,0], [3,4,1,-5,-5,1,0,-3,1,-3,1,2,-1,2,-1,-2,-4,5,3,-3,2,-1,0,-2,1,-1,2,3,0,1], [1,1,0,-2,-1,0,0,-1,0,0,0,1,0,0,0,0,-1,1,1,-1,0,0,0,-1,0,0,1,1,1,0], [0,2,-1,-2,-1,1,1,-1,1,-1,0,1,1,-2,2,1,-1,0,1,-2,-2,0,-1,-1,-1,-1,1,1,3,0], [-5,-5,-1,9,5,0,-2,7,-2,4,0,-3,-1,1,-2,1,6,-6,-4,4,0,0,-3,3,0,4,-2,-5,-5,1], [3,3,1,-4,-3,1,0,-2,1,-2,0,2,-1,1,0,-1,-3,4,2,-2,1,-1,0,-1,0,-1,1,2,0,0], [7,8,1,-12,-9,2,2,-8,3,-6,1,5,0,0,2,-2,-9,9,6,-7,1,-1,1,-5,0,-4,4,7,5,0], [6,7,1,-10,-6,2,1,-5,2,-4,0,4,-1,1,0,-3,-6,7,4,-5,1,-1,1,-3,1,-2,3,5,2,-1], [4,6,0,-8,-6,2,2,-6,3,-5,2,4,0,-2,3,0,-7,5,4,-5,-1,0,0,-4,-1,-4,3,4,5,1], [-1,-2,0,2,1,-1,0,2,-1,1,1,0,0,-1,2,1,1,-2,-1,2,-1,1,-1,1,-1,0,-1,-2,-1,0], [5,5,1,-8,-5,1,1,-4,1,-3,0,3,-1,1,0,-2,-5,6,4,-3,1,-1,1,-2,1,-2,2,4,1,-1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [4,4,1,-6,-4,1,0,-3,1,-2,0,3,-1,1,0,-2,-4,5,3,-3,1,-1,0,-1,1,-1,2,3,0,-1], [6,6,1,-10,-7,0,2,-7,2,-5,2,5,1,-2,4,0,-8,6,5,-5,-1,0,1,-4,-1,-5,3,5,5,0], [-1,0,-1,1,1,1,0,2,0,0,0,-1,0,0,0,0,1,-1,-1,0,-1,0,-1,0,0,1,0,-1,0,0], [2,1,1,-3,-1,0,0,-1,0,0,-1,1,0,1,0,-1,-1,2,1,-1,0,-1,1,0,0,0,0,2,0,-1], [-1,0,-1,0,1,0,0,0,0,1,0,0,1,-2,1,1,0,-2,0,0,-2,1,0,0,-1,0,0,0,2,0], [0,-1,0,1,0,-1,0,1,-1,1,1,0,0,-1,1,1,0,-1,0,1,-1,1,-1,0,-1,0,0,-1,0,0], [4,3,1,-6,-3,-1,1,-4,1,-2,0,2,0,0,1,-1,-4,4,3,-2,0,0,2,-1,0,-2,1,3,2,-1], [0,-1,0,1,1,0,0,2,-1,0,0,0,-1,1,-1,-1,1,0,-1,2,2,0,0,1,1,1,-1,-2,-3,0], [8,9,2,-14,-10,1,2,-9,3,-6,1,6,0,0,3,-2,-10,10,7,-7,0,-1,1,-4,0,-5,4,8,5,-1], [4,3,1,-5,-4,0,1,-2,0,-2,0,2,-1,2,0,-2,-3,5,2,-2,2,-1,1,-1,1,-1,1,2,-1,-1], [-5,-6,-1,9,6,-1,-2,7,-3,5,-1,-4,0,1,-2,1,7,-6,-4,5,0,1,-1,3,0,4,-3,-5,-4,0], [4,4,1,-7,-4,1,1,-5,2,-3,0,3,0,0,1,-1,-5,5,3,-4,0,-1,1,-2,0,-2,2,4,3,0], [-3,-3,-1,5,3,-1,-1,3,-1,2,0,-2,0,0,-1,1,3,-4,-2,3,0,1,-1,1,0,2,-1,-3,-2,1]], [[-10,-10,-2,17,10,-1,-3,11,-3,7,-1,-7,-1,2,-4,2,11,-11,-8,8,1,1,-3,5,0,6,-4,-9,-7,2], [-3,-3,0,5,3,-1,-1,3,-1,3,-1,-2,0,1,-1,1,3,-3,-2,2,0,0,-1,2,0,2,-1,-2,-2,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-3,-4,0,6,3,0,-2,5,-2,3,0,-2,-1,2,-2,0,4,-3,-3,3,1,0,-2,2,0,3,-1,-3,-4,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [-1,-1,0,2,1,0,-1,2,0,1,0,-1,-1,1,-1,0,1,-1,-1,1,0,0,-1,1,0,1,0,-1,-2,0], [0,0,0,1,-1,1,-1,1,0,0,0,0,-1,2,-2,-1,0,1,0,0,2,-1,-1,0,1,1,0,0,-2,1], [-4,-5,-1,8,5,-1,-1,5,-2,3,0,-3,0,0,-1,1,5,-5,-4,4,0,1,-1,2,0,2,-2,-5,-3,1], [-7,-7,-2,11,7,-1,-1,7,-2,5,0,-4,1,-2,0,3,7,-9,-5,5,-2,2,-2,3,-1,3,-3,-6,-2,1], [-2,-2,0,4,2,0,-1,3,-1,2,-1,-1,-1,1,-2,0,3,-2,-2,2,1,0,-1,2,1,2,-1,-2,-3,0], [-1,-1,0,1,0,-1,0,0,0,1,1,0,1,-2,2,2,0,-2,0,0,-2,1,-1,0,-1,-1,0,0,2,0], [3,2,1,-4,-3,0,0,-2,0,-1,1,2,0,0,1,-1,-3,3,2,-2,0,0,0,-1,0,-1,1,2,1,0], [0,-1,0,1,0,-1,0,1,-1,1,1,0,0,-1,1,1,0,-1,0,1,-1,1,-1,0,-1,0,0,-1,0,0], [0,0,0,0,0,0,-1,1,0,1,0,0,0,0,0,0,0,-1,0,0,-1,0,-1,0,0,1,0,0,0,0], [-1,-2,1,2,2,-1,-1,2,-1,2,-1,-1,-1,2,-2,-1,2,-1,-1,2,1,0,0,2,1,2,-1,-1,-3,-1], [-3,-4,0,6,3,-2,-1,3,-1,2,0,-3,0,1,-1,1,3,-3,-2,3,1,0,0,2,0,1,-2,-3,-3,1], [-3,-4,0,5,4,-2,-1,2,-1,3,-1,-3,1,0,-1,1,3,-4,-2,3,0,1,1,2,0,2,-2,-2,-1,0], [1,-1,1,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,1,0,1,1,0,1,0,0,0,-1,0,-1,0], [-6,-7,-1,11,8,-1,-3,8,-3,6,-1,-5,0,1,-3,1,8,-8,-5,6,-1,1,-2,4,0,5,-3,-6,-5,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-5,-5,-1,8,6,-1,-1,5,-2,4,-1,-4,0,0,-2,1,6,-6,-4,4,-1,1,-1,3,0,3,-2,-4,-2,0], [-4,-5,-1,7,5,-1,-1,4,-1,3,0,-3,0,-1,0,2,4,-5,-3,4,-1,1,-1,2,-1,2,-2,-4,-2,1], [0,-1,1,1,0,-1,-1,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0], [-5,-6,-1,9,6,-2,-1,6,-2,4,0,-4,0,0,0,2,6,-6,-4,5,-1,1,-1,3,-1,2,-3,-5,-3,0], [-2,-4,0,5,3,-2,-1,4,-2,2,1,-1,-1,0,0,1,3,-3,-2,4,1,1,-1,2,0,1,-2,-4,-4,0], [-1,-2,1,2,1,-1,-1,1,-1,2,0,-1,0,1,-1,0,1,-1,0,1,0,0,0,1,0,1,-1,0,-1,0], [1,0,1,-1,-1,-1,0,-1,0,-1,0,0,0,1,0,-1,-1,2,1,0,1,0,1,0,0,-1,0,1,0,0], [1,1,0,-2,-2,0,1,-2,1,-2,1,1,0,0,1,0,-2,2,1,-1,1,0,0,-1,0,-2,1,1,1,1], [-5,-6,-1,9,7,-1,-2,7,-3,5,-1,-4,0,0,-2,1,7,-7,-5,5,-1,1,-1,3,0,4,-3,-5,-3,0], [-2,-3,0,5,3,-1,-1,3,-1,2,-1,-2,-1,2,-2,0,3,-2,-2,3,2,0,0,2,1,2,-2,-3,-4,0]]]], [ # Q-class [30][31] [[8], [3,8], [2,1,8], [1,-1,-2,8], [0,2,0,-4,8], [1,2,2,-2,1,8], [0,1,1,-1,0,2,8], [0,1,2,1,-1,3,1,8], [1,-1,0,3,0,1,2,-1,8], [0,2,-1,0,0,1,0,1,-3,8], [-1,-2,3,0,-1,1,3,-1,3,-2,8], [0,-1,-2,1,-3,0,-1,0,0,-2,0,8], [0,0,-2,-1,0,0,0,-2,0,2,2,1,8], [2,-1,1,-2,1,2,0,0,0,0,-1,-1,2,8], [0,-1,-1,3,-4,-1,-2,2,-1,-1,0,3,0,-1,8], [0,-1,-1,2,-2,-2,0,-3,3,0,0,1,0,-2,0,8], [-1,1,0,0,3,1,-2,-1,1,0,0,-1,1,0,-2,-1,8], [1,0,-2,1,0,-2,-3,-1,-1,1,-4,1,-1,2,-1,0,2,8], [2,0,2,0,0,2,1,2,-1,3,0,-2,-3,-1,0,-1,-2,0,8], [-3,0,-1,1,-1,-1,-1,-2,2,-1,2,2,2,-3,0,2,3,0,-3,8], [1,0,1,1,-2,-3,1,0,-3,1,0,-1,-2,-1,1,-1,-2,0,3,-2,8], [0,0,-1,2,-2,1,0,1,1,-1,-2,1,-1,1,3,-1,0,1,-1,1,-2,8], [0,2,-1,1,-1,1,4,2,1,0,0,1,0,-3,1,3,-1,-3,-1,0,-1,0,8], [3,0,2,2,-3,0,3,-1,1,1,2,1,-1,-1,1,2,-1,-1,3,-1,3,-1,2,8], [0,2,2,-2,1,-1,2,1,-1,-3,2,-1,-2,-2,-1,-3,-2,-2,0,0,2,-1,0,-2,8], [1,1,-1,-2,2,-1,-1,-2,-3,-1,-3,2,0,1,2,0,0,0,-1,-2,1,0,1,1,-1,8], [-1,-1,-1,3,-3,-3,-2,-1,-1,3,0,-2,1,-1,3,2,-2,0,0,1,2,1,-1,0,-2,-2,8], [-1,-1,-1,2,-4,-2,-2,1,-2,2,-3,0,0,0,3,3,0,2,-2,0,0,2,2,0,-3,0,4,8], [3,1,0,2,-2,0,-1,0,-1,1,-2,2,0,1,-1,-1,2,4,0,0,0,1,-1,3,-2,0,-2,1,8], [0,-3,0,2,-3,-3,-3,1,-2,0,0,0,-1,0,4,-2,-2,0,1,-3,3,0,-3,1,0,0,3,2,0,8]], [[[-2,-1,-3,-2,0,1,-5,5,2,-1,0,0,3,-2,-2,1,1,0,-2,-5,0,2,-4,8,5,1,3,1,-1,-5], [-2,0,-6,-2,-2,-1,-7,9,1,-2,3,0,3,-2,-5,1,2,0,-2,-7,-2,3,-7,12,6,3,4,2,-3,-8], [0,-2,3,0,0,2,2,-3,1,2,-3,0,0,1,2,1,1,1,0,2,1,-1,4,-4,1,0,1,-3,2,4], [-1,1,-3,0,1,-1,-4,4,0,-2,2,0,2,-2,-3,-1,-2,0,-1,-3,0,2,-5,7,1,0,-1,4,-3,-5], [0,-1,2,0,0,1,2,-2,0,1,-1,0,-1,1,2,1,1,0,0,1,0,-1,2,-3,0,0,1,-2,2,2], [0,-1,0,0,-1,0,-1,0,0,1,-1,0,0,-1,1,0,1,0,-2,-2,0,0,-1,2,1,-1,0,-1,-1,-2], [0,-1,0,0,-1,0,0,1,-1,0,-2,0,1,0,1,2,2,0,-1,-2,-1,0,-1,2,2,-1,1,-2,-1,-1], [-1,-1,2,0,0,0,1,-2,1,1,-3,1,0,1,2,0,1,0,0,0,0,-1,2,-1,1,-1,1,-2,1,1], [1,-3,7,0,1,3,8,-8,0,3,-6,1,-2,2,6,3,2,1,1,4,1,-3,8,-12,-1,-2,2,-7,6,9], [0,0,0,1,1,0,-1,0,-1,0,0,0,0,0,0,-1,-1,0,-1,0,0,0,0,2,0,-1,-1,1,-1,-1], [1,0,1,1,0,0,1,-1,-1,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,-1,-1,-1,-1,0,-1,1], [0,-1,3,0,0,1,3,-3,0,1,-3,0,0,0,3,1,1,1,0,1,0,-1,3,-4,0,-1,1,-4,2,3], [0,1,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0], [0,0,0,0,0,0,-1,-1,0,1,0,-1,0,-1,2,-1,-1,0,-2,-1,1,0,-1,1,-1,-2,-3,1,-1,-2], [-1,3,-8,-1,-1,-4,-9,9,0,-3,6,-1,2,-3,-6,-3,-2,-1,-2,-6,-1,4,-10,14,1,1,-2,7,-7,-11], [1,-2,7,1,2,3,8,-9,-1,2,-5,1,-2,3,5,2,1,1,3,6,1,-3,10,-13,-2,-2,1,-6,6,11], [1,-1,3,0,0,1,3,-3,0,1,-1,0,-1,0,2,0,0,1,0,2,1,-1,3,-5,-2,0,0,-2,2,3], [0,-1,3,1,2,2,3,-4,0,1,-2,0,0,0,3,0,-1,1,0,2,1,-1,3,-4,-1,-1,-1,-1,2,3], [0,-1,1,1,2,1,0,-1,0,1,-1,0,0,0,1,0,-1,0,-1,1,1,0,1,0,0,-1,-1,0,0,1], [1,-1,3,0,0,1,4,-3,-1,1,-2,0,-1,1,2,2,1,1,1,3,0,-1,4,-6,-1,0,1,-4,3,5], [0,1,-3,0,0,-1,-4,4,0,-1,3,-1,1,-1,-3,-1,-2,0,-1,-1,0,2,-3,5,0,1,-2,3,-3,-3], [-1,2,-10,-2,-3,-4,-10,12,0,-3,6,-2,3,-5,-6,-2,-1,-1,-4,-9,-2,4,-14,18,3,2,-1,7,-8,-15], [-1,-1,0,-1,-1,0,0,1,0,-1,-2,1,1,1,0,2,3,0,1,-2,-1,0,1,1,3,0,4,-3,1,0], [0,-2,2,0,1,2,1,-1,0,1,-3,0,1,0,2,2,1,1,-1,0,1,0,2,-1,2,-1,1,-3,1,2], [-1,1,-5,-1,-2,-2,-5,7,1,-2,3,0,2,-1,-5,0,1,-1,0,-4,-2,2,-6,8,3,3,2,3,-3,-6], [-1,1,-3,-1,-1,-1,-4,4,0,-1,3,-1,1,-1,-2,0,0,0,-1,-3,0,2,-3,5,1,1,0,1,-2,-4], [0,3,-7,0,0,-3,-7,7,-1,-3,6,-1,1,-2,-6,-3,-3,-1,-1,-3,-1,3,-8,11,0,1,-3,8,-6,-8], [0,1,-1,0,0,-1,-1,0,0,-1,1,0,0,0,-1,-2,-1,0,1,0,0,0,0,1,-1,0,-1,2,-1,-1], [-1,-1,1,0,1,2,0,0,1,0,-2,0,2,-1,1,1,0,1,-1,-1,1,0,0,1,2,0,1,-1,1,0], [0,2,-3,0,0,-2,-3,3,1,-1,3,0,0,-1,-3,-3,-2,-1,0,-1,0,1,-4,4,-1,1,-2,5,-3,-4]], [[-2,0,-1,-1,-1,0,-2,3,1,-1,-1,0,2,0,-1,2,2,0,0,-3,-1,1,-2,4,4,1,3,-1,0,-2], [-1,-1,-1,0,0,0,-2,3,0,-1,-1,0,2,-1,-1,1,1,0,-1,-3,-1,1,-3,5,3,0,2,0,-1,-3], [-1,0,-1,0,1,0,-3,1,0,0,0,-1,1,-1,1,0,-1,0,-2,-2,1,1,-2,4,1,-2,-2,1,-1,-3], [-1,3,-6,0,0,-2,-6,7,0,-3,5,0,2,-2,-6,-2,-2,-1,0,-3,-1,3,-8,10,1,2,-1,7,-5,-7], [1,-3,5,-1,-1,2,6,-5,0,3,-5,0,-2,2,5,3,3,1,0,3,0,-3,7,-9,0,-1,3,-8,5,7], [0,-2,5,0,1,2,5,-6,1,2,-4,1,-1,2,4,2,2,1,2,3,1,-2,7,-9,0,-1,2,-5,5,7], [0,-1,4,1,1,1,4,-5,1,2,-3,1,-1,1,3,0,0,0,1,2,1,-2,4,-7,-1,-1,0,-2,3,4], [-1,0,0,0,1,0,-1,0,1,0,0,1,0,1,0,0,0,0,1,0,0,0,1,0,1,0,1,0,1,0], [0,1,0,1,1,0,1,-1,-1,0,0,0,0,0,0,0,-1,0,0,1,0,0,-1,0,-1,-1,-2,1,-1,1], [0,1,-3,0,-1,-1,-3,4,0,-2,3,-1,1,-2,-3,-1,-1,0,0,-2,-1,1,-4,4,0,2,0,3,-2,-4], [0,1,-3,0,0,-1,-4,3,0,0,3,-1,1,-2,-2,-1,-2,0,-2,-2,1,2,-4,5,0,0,-3,3,-3,-4], [-1,1,-4,-1,-1,-1,-4,5,1,-2,2,1,2,-1,-4,0,1,-1,0,-4,-1,2,-5,7,3,2,2,3,-2,-5], [0,2,-6,-1,-2,-2,-6,7,0,-2,6,-1,1,-2,-6,-1,-1,0,-1,-4,-1,3,-6,8,1,3,0,4,-4,-6], [0,-1,4,0,0,2,4,-5,1,2,-2,0,-2,2,3,1,1,1,1,3,1,-2,6,-8,-1,0,1,-4,4,6], [-1,4,-9,-1,-1,-4,-9,10,1,-4,8,0,2,-2,-8,-3,-2,-2,0,-5,-1,4,-10,13,1,3,-1,9,-6,-10], [1,1,3,2,2,1,4,-5,-2,0,-1,0,-1,1,2,0,-2,0,1,4,1,-1,3,-6,-4,-2,-3,0,1,5], [0,-1,0,-1,0,1,0,0,0,0,-1,0,0,0,0,1,1,0,0,0,0,0,1,0,1,0,2,-2,1,1], [0,-1,1,0,-1,1,1,-1,0,0,-2,0,0,0,1,0,1,0,0,0,-1,-1,0,0,1,0,1,-1,0,0], [0,0,1,0,0,0,1,-1,1,0,-1,0,0,0,1,0,0,0,1,1,0,-1,1,-2,0,0,0,0,1,1], [0,2,-8,-1,-1,-3,-8,9,-1,-3,6,-1,2,-4,-6,-2,-2,-1,-3,-6,-1,4,-11,14,1,1,-2,7,-7,-11], [-1,1,-2,0,0,-1,-3,3,1,-1,2,0,1,-1,-2,-1,-1,-1,0,-2,0,1,-3,4,1,1,0,3,-1,-4], [0,1,-3,-1,-1,-2,-2,3,1,-1,2,0,0,-1,-2,-2,0,-1,0,-2,-1,1,-4,4,0,1,0,3,-2,-4], [0,-1,5,1,2,2,6,-6,0,1,-4,2,-1,3,3,2,1,0,3,4,1,-2,7,-10,-1,-1,2,-4,5,8], [-2,2,-4,0,0,-1,-5,5,1,-3,2,0,3,-2,-4,-1,-1,-1,0,-4,0,2,-6,8,2,1,0,5,-3,-6], [0,-2,1,0,0,0,0,0,0,2,-2,0,0,0,2,1,1,0,-2,-1,0,0,0,1,2,-1,0,-2,0,-1], [0,0,1,-1,-1,0,2,-1,1,0,-1,1,-1,2,0,1,2,-1,2,1,0,-1,3,-4,0,1,3,-2,3,3], [0,4,-9,0,-1,-4,-9,10,-1,-4,9,-2,2,-4,-7,-4,-4,-1,-2,-5,-1,4,-12,14,-1,2,-4,10,-8,-12], [0,2,-2,1,1,-1,-2,1,-1,-2,3,0,0,0,-2,-2,-2,-1,1,0,0,1,-2,2,-2,0,-2,4,-2,-2], [-2,0,-3,-1,-1,0,-5,5,1,-2,0,0,3,-2,-3,0,1,0,-1,-5,-1,2,-5,9,4,1,2,2,-3,-6], [-1,3,-7,0,-1,-3,-8,8,0,-3,6,-1,2,-2,-6,-3,-2,-1,-1,-4,-1,3,-8,12,1,2,-2,7,-6,-9]]]], [ # Q-class [30][32] [[16], [-2,16], [4,2,16], [1,4,2,16], [3,3,2,5,16], [4,4,0,5,4,16], [4,4,1,0,2,4,16], [0,2,-3,2,0,2,2,16], [5,0,2,-1,-3,4,1,5,16], [5,1,4,4,4,5,4,2,3,16], [4,2,0,4,2,4,2,4,5,4,16], [0,4,5,-1,-4,-5,-4,-2,2,2,2,16], [2,0,4,4,4,1,1,1,4,4,0,2,16], [0,5,0,0,3,4,-1,0,4,-1,0,4,5,16], [4,-2,4,-1,3,3,2,1,4,4,5,-1,4,0,16], [2,1,4,5,-4,-1,2,4,1,4,4,4,2,-2,2,16], [1,2,1,4,0,4,4,0,-1,4,0,0,-2,2,0,2,16], [-1,4,0,5,1,3,-3,0,-4,2,-1,3,0,4,-5,0,4,16], [0,1,0,0,-2,4,0,4,2,-2,2,1,-2,3,1,4,4,4,16], [5,2,2,3,2,2,-1,0,-4,2,-4,0,2,-2,4,0,4,4,2,16], [2,0,4,5,2,4,4,4,1,4,-2,-4,0,-4,2,3,3,-1,-3,3,16], [2,2,4,0,0,4,0,3,2,2,4,4,5,4,4,4,2,4,2,3,2,16], [0,4,4,4,2,2,-1,3,4,5,4,0,5,4,0,4,0,2,2,-2,0,4,16], [4,-1,0,4,-4,4,-2,5,4,5,0,-2,2,-2,4,5,2,4,1,4,4,2,4,16], [4,-2,2,3,5,3,-4,4,5,4,2,0,3,4,1,4,-2,0,3,0,2,2,4,1,16], [5,3,0,4,4,1,4,-1,-3,2,0,3,0,2,-4,4,4,0,5,4,-1,-2,-2,-5,3,16], [2,-1,-2,4,4,4,5,5,3,0,2,-3,3,4,-1,0,1,-1,4,-4,2,-2,-3,-3,1,5,16], [-4,4,5,2,0,1,3,5,0,0,-4,-3,4,4,4,2,4,0,2,2,4,4,5,4,0,-4,1,16], [4,0,3,5,2,4,0,0,4,5,1,1,4,0,4,2,1,1,2,4,4,2,4,2,2,0,4,0,16], [4,-2,5,3,4,4,-5,-4,4,4,2,0,5,2,4,-1,-1,0,1,2,2,2,4,2,4,-1,1,-1,4,16]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-5,3,2,-1,-8,1,7,1,-5,-8,-6,5,-3,-7,12,-6,5,3,-9,1,-4,2,12,4,11,2,12,-9,-3,2], [-2,0,1,0,-1,0,2,1,-1,-2,-1,1,-1,-1,2,-2,1,0,-2,0,-1,1,2,2,2,1,2,-2,0,1], [0,0,-1,0,0,1,1,-1,0,-1,-1,2,-1,-1,1,0,0,0,-1,1,0,0,2,0,1,-1,2,0,-1,0], [0,0,0,0,-1,0,1,1,-1,-1,0,0,0,0,1,-1,0,1,-1,-1,0,0,0,0,1,1,-1,0,1,1], [0,1,0,0,-2,1,1,1,-1,-2,-2,1,0,-2,3,-1,1,1,-2,-1,-1,0,2,0,2,1,1,-1,0,1], [-3,1,1,-1,-4,1,4,1,-2,-5,-3,3,-2,-4,6,-3,3,2,-6,1,-3,1,6,2,6,2,6,-4,-1,2], [2,0,-1,1,2,-1,-2,-1,2,3,1,-2,1,2,-3,2,-1,-1,3,0,1,0,-3,-2,-3,-2,-3,2,0,-1], [-1,0,0,-1,0,1,1,0,0,-2,0,1,0,-2,1,0,1,1,-2,0,-1,0,1,1,1,1,1,0,0,1], [0,0,0,0,0,0,0,1,0,0,0,-1,0,1,0,0,0,0,0,-1,0,0,-1,0,-1,1,-2,0,1,1], [-2,1,1,-2,-3,1,3,1,-2,-4,-1,2,-1,-3,4,-2,2,2,-5,0,-2,0,4,2,4,2,4,-2,0,2], [-6,4,3,-2,-9,1,7,1,-6,-9,-6,5,-3,-8,13,-7,6,3,-10,2,-4,2,14,5,12,2,15,-11,-4,2], [1,-2,-1,0,3,1,-1,0,1,1,2,0,1,2,-4,2,-1,-1,2,0,1,-1,-3,-1,-3,-1,-4,3,1,0], [-5,3,2,-2,-8,2,6,1,-5,-9,-5,5,-2,-8,12,-6,5,4,-10,1,-4,1,12,4,11,3,12,-8,-3,2], [-1,-1,0,-2,-1,2,1,2,0,-3,0,1,0,-2,2,0,1,3,-4,-1,-1,-1,1,0,1,3,0,1,1,2], [-2,0,0,-1,-1,1,2,0,0,-2,-1,2,-1,-2,2,-1,1,1,-3,1,-1,0,3,1,2,1,3,-1,-1,1], [-4,3,1,-2,-7,2,5,1,-4,-8,-6,5,-3,-8,12,-5,5,4,-10,1,-4,1,12,3,10,3,12,-7,-3,2], [0,2,0,1,-3,0,1,0,-2,-1,-3,1,-1,-2,4,-2,1,0,-1,0,-1,1,4,0,3,-1,4,-3,-2,0], [-1,1,0,-1,-3,2,2,1,-1,-4,-3,3,-1,-5,6,-2,2,3,-5,0,-2,0,6,0,4,2,5,-2,-2,1], [-2,2,1,0,-5,1,3,1,-3,-4,-5,3,-2,-4,8,-3,3,2,-5,1,-2,1,8,1,6,0,8,-6,-3,1], [0,1,0,1,0,-1,0,0,0,1,-1,-1,0,1,0,0,0,-1,1,0,0,1,-1,0,0,-1,0,-1,0,0], [-4,4,3,0,-8,0,6,2,-6,-6,-6,3,-2,-5,10,-6,5,1,-7,1,-4,2,10,4,10,0,11,-10,-3,2], [1,-2,-1,0,4,0,-1,0,2,2,3,-1,1,3,-5,2,-2,-1,3,-1,1,-1,-5,0,-4,0,-6,4,2,0], [4,-3,-3,1,7,0,-5,-1,5,6,4,-3,2,5,-9,6,-4,-2,7,-1,3,-2,-9,-4,-9,-2,-10,8,2,-1], [-4,2,2,-1,-5,1,5,1,-3,-6,-4,3,-2,-5,8,-4,3,3,-7,1,-3,1,8,3,7,2,8,-6,-2,2], [-3,2,1,-1,-5,1,4,0,-3,-5,-4,4,-2,-5,8,-4,3,2,-6,2,-2,1,9,2,7,1,9,-6,-3,1], [2,0,-1,1,1,0,-2,-1,1,2,1,-1,1,1,-2,1,-1,-1,2,0,1,0,-2,-2,-2,-1,-2,2,0,-1], [-3,1,1,0,-4,1,4,1,-2,-5,-4,3,-2,-4,7,-3,3,2,-6,1,-3,1,7,2,6,1,7,-5,-2,1], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [3,-1,-1,1,3,0,-3,1,1,3,2,-2,2,3,-4,2,-2,-1,4,-3,2,-1,-6,-2,-5,0,-7,4,2,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,-1,-2,0,3,1,-2,0,2,1,1,0,1,0,-3,2,-1,0,2,-1,1,-1,-3,-2,-3,0,-4,4,1,0], [1,1,0,1,0,-1,-1,-1,0,1,-1,-1,0,0,0,0,0,-1,1,0,0,1,0,0,0,-1,1,-1,-1,-1], [2,0,-1,1,2,-1,-2,0,1,3,1,-2,1,2,-3,2,-1,-1,3,-1,1,0,-4,-2,-3,-1,-4,2,1,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [4,-1,-2,1,4,-1,-4,0,2,5,3,-3,2,4,-6,3,-3,-2,6,-2,3,-1,-7,-3,-6,-1,-8,5,2,-1], [0,1,0,1,-2,0,1,0,-1,-1,-2,1,-1,-2,3,-2,1,0,-1,0,-1,1,3,0,2,0,3,-2,-1,0], [0,0,0,0,0,0,0,1,0,0,0,-1,0,1,0,0,0,0,0,-1,0,0,-1,0,-1,1,-2,0,1,1], [-6,4,3,-2,-10,1,8,2,-6,-10,-7,5,-4,-8,14,-7,6,4,-12,2,-5,2,14,5,13,3,15,-11,-3,3], [5,-2,-2,2,6,-2,-6,-1,3,8,5,-5,3,7,-10,4,-4,-4,9,-2,4,-1,-11,-3,-9,-2,-11,7,3,-2], [-5,2,2,-2,-7,2,7,2,-5,-9,-5,5,-3,-7,11,-5,5,4,-10,1,-4,1,11,4,10,3,11,-8,-2,3], [0,-1,-1,-1,1,1,0,-1,1,-1,1,1,0,-1,-1,1,0,1,-1,1,0,-1,0,0,0,0,0,2,0,0], [-2,4,2,1,-7,-1,4,1,-5,-4,-6,2,-2,-4,9,-5,4,1,-5,1,-3,2,9,2,8,-1,10,-9,-3,1], [0,-1,-1,-1,1,1,0,0,1,-1,0,1,0,-1,0,1,0,1,-1,1,0,-1,1,-1,0,0,0,1,0,0], [-3,2,2,1,-5,0,5,1,-4,-4,-5,3,-3,-3,7,-4,3,0,-5,2,-3,2,8,3,7,-1,9,-8,-3,1], [1,0,0,1,0,0,-1,0,0,1,0,-1,0,1,-1,1,0,-1,1,0,0,0,-1,-1,-1,-1,-1,0,0,0], [2,-2,-2,0,4,0,-3,-1,3,3,3,-1,1,2,-5,3,-2,-1,3,0,2,-1,-4,-2,-5,0,-5,5,1,-1], [7,-5,-4,1,11,-1,-9,-1,7,10,9,-6,5,9,-16,8,-7,-3,12,-3,6,-3,-17,-6,-15,-1,-19,14,5,-2], [3,-3,-2,0,6,0,-4,-1,4,5,5,-3,2,5,-9,5,-4,-2,6,0,3,-2,-8,-3,-8,-1,-9,7,2,-1], [8,-4,-4,3,11,-2,-9,-2,7,12,7,-6,4,10,-16,8,-7,-5,14,-2,6,-2,-16,-6,-15,-4,-17,12,3,-3], [-1,3,1,1,-4,-1,1,0,-2,-1,-3,0,-1,-2,5,-3,2,0,-2,0,-1,2,4,1,4,0,5,-5,-2,0], [1,1,0,1,-2,0,0,1,-1,-1,-2,0,0,-1,3,-1,1,1,-1,-1,0,0,2,-1,1,0,1,-2,-1,0], [1,1,0,0,-1,0,-1,1,-1,0,-1,-1,1,0,1,0,1,0,0,-1,0,0,0,-1,0,0,0,-1,0,0], [2,0,0,1,1,-1,-2,1,0,3,1,-2,1,3,-3,1,-1,-2,3,-1,1,0,-4,-1,-3,-1,-4,1,1,0], [2,-1,-1,0,3,0,-3,-1,2,3,2,-2,1,3,-4,3,-2,-1,3,0,2,-1,-4,-2,-4,-1,-4,3,1,-1], [7,-5,-4,1,12,-1,-9,-3,8,11,9,-6,4,9,-17,9,-7,-4,13,-1,6,-3,-16,-6,-15,-3,-17,14,4,-3], [-4,2,2,-1,-5,0,5,1,-3,-5,-3,2,-2,-4,7,-4,3,2,-6,1,-3,1,7,3,7,2,7,-6,-1,2], [1,1,0,2,0,-1,-1,0,0,2,-2,-1,0,1,0,0,0,-2,2,0,0,1,0,-1,-1,-2,0,-2,-1,-1], [0,1,0,0,-2,0,1,1,-1,-1,-1,0,0,-1,2,-1,1,1,-2,-1,-1,0,1,0,2,1,1,-1,0,1], [-4,4,3,0,-7,-1,5,1,-5,-5,-5,2,-2,-4,9,-5,4,1,-6,2,-3,2,9,4,9,0,11,-10,-3,1]]]], [ # Q-class [30][33] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]]]] ]; MakeImmutable( IMFList[30].matrices ); gap-4r6p5/grp/imf.gd0000644000175000017500000002226712172557252013031 0ustar billbill############################################################################# ## #W imf.gd GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland ## ## This file contains the declarations of operations for the GAP library of ## irreducible maximal finite integral matrix groups. ## ############################################################################# ## #V InfoImf ## ## is the info class for the imf functions ## (see~"Info Functions"). ## DeclareInfoClass( "InfoImf" ); ############################################################################# ## ## Some global variables. ## ############################################################################# ## #F IsImfMatrixGroup( ) ## DeclareFilter( "IsImfMatrixGroup" ); ############################################################################# ## #A ImfRecord( ) ## DeclareAttribute( "ImfRecord", IsGroup, "mutable" ); ############################################################################# ## ## list of global variables not thought for the user ## ############################################################################# ## #F BaseShortVectors( ) . . . . . . . . . . . . . . . . . . . . . . . ## ## 'BaseShortVectors' expects as argument an orbit of short vectors under ## some imf matrix group of dimension dim, say. This orbit can be ## considered as a set of generatos of a dim-dimensional Q-vectorspace. ## 'BaseShortVectors' determines a subset B, say, of which is a base ## of that vectorspace, and it returns a list of two lists containing ## ## - a list of the position numbers with respect to of the elements ## of the base B and ## - the base change matrix B^-1. ## ## Both will be needed by the function 'ImfPermutationToMatrix'. ## DeclareGlobalFunction( "BaseShortVectors" ); ############################################################################# ## #F DisplayImfInvariants( , ) . . . . . . . . . . . . . . . . . . . #F DisplayImfInvariants( , , ) . . . . . . . . . . . . . . . . . ## ## 'DisplayImfInvariants' displays some Z-class invariants of the specified ## classes of irreducible maximal finite integral matrix groups in some ## easily readable format. ## ## The default value of z is 1. If any of the arguments is zero, the routine ## loops over all legal values of the respective parameter. ## DeclareGlobalFunction( "DisplayImfInvariants" ); ############################################################################# ## #F DisplayImfReps( , , ) . . . . . . . . . . . . . . . . . . . . ## ## 'DisplayImfReps' is a subroutine of the 'DisplayImfInvariants' command. ## It displays some Z-class invariants of the zth Z-classes in the qth ## Q-class of the irreducible maximal finite integral matrix groups of ## dimension dim. ## ## If an argument z = 0 has been specified, then all classes in the given ## Q-class will be displayed, otherwise just the zth Z-class is displayed. ## ## This subroutine is considered to be an internal one. Hence the arguments ## are not checked for being in range. Moreover, it is assumed that the imf ## main list IMFList has already been loaded. ## DeclareGlobalFunction( "DisplayImfReps" ); ############################################################################# ## #F ImfInvariants( , ) . . . . . . . . . . . . . . . . . . . . . . . #F ImfInvariants( , , ) . . . . . . . . . . . . . . . . . . . . ## ## 'ImfInvariants' returns a record of Z-class invariants of the zth Z-class ## in the qth Q-class of irreducible maximal finite integral matrix groups ## of dimension dim. The default value of z is 1. ## ## Assume that G is a representative group of the specified Z-class. Then ## the resulting record contains the following components: ## ## size group size of G, ## isSolvable true, if G is solvable, ## isomorphismType isomorphism type of G, ## elementaryDivisors elementary divisors of G, ## minimalNorm norm of the short vectors associated to G, ## sizesOrbitsShortVectors a list of the sizes of the orbits of short ## vectors associated to G, ## maximalQClass Q-class number of coresponding rational imf ## class (only if it is different from q). ## ## If a value z > 1 has been specified for a dimension for which no Z-class ## representatives are available, the function will display an appropriate ## message and return the value 'false'. ## DeclareGlobalFunction( "ImfInvariants" ); ############################################################################# ## #F IMFLoad( ) . . . . . . . . load a secondary file of the imf library ## ## 'IMFLoad' loads the imf main list and, if dim > 0, the list of matrices ## containing the Gram matrices and the lists of generators for the ## irreducible maximal finite integral matrix groups of dimension . ## Nothing is done if the required lists have already been loaded. ## ## 'IMFLoad' finds the files in the directory specified by 'GRPNAME'. This ## variable is set in the init file 'LIBNAME/\"init.g\"'. ## ## The given dimension is not checked to be in range. ## DeclareGlobalFunction( "IMFLoad" ); ############################################################################# ## #F ImfMatrixGroup( , ) . . . . . . . . . . . . . . . . . . . . . . #F ImfMatrixGroup( , , ) . . . . . . . . . . . . . . . . . . . . ## ## 'ImfMatrixGroup' returns the representative of the zth Z-class in the qth ## Q-class of the irreducible maximal finite integral matrix groups of ## dimension dim. The default value of z is 1. ## ## If a value z > 1 has been specified for a dimension for which no Z-class ## representatives are available, the function will display an appropriate ## message and return the value 'false'. ## DeclareGlobalFunction( "ImfMatrixGroup" ); ############################################################################# ## #F ImfNumberQClasses( ) . . . . . . . . . . . . . . . . . . . . . . . ## ## 'ImfNumberQClasses' returns the number of available Q-classes of ## irreducible maximal finite subgroups of dimension dim, i. e., the number ## of Q-classes of irreducible maximal finite subgroups of GL(dim,Z), if dim ## is at most 11 or a prime, or the number of Q-classes of irreducible ## maximal finite subgroups of GL(dim,Q), else. ## DeclareGlobalFunction( "ImfNumberQClasses" ); ############################################################################# ## #F ImfNumberQQClasses( ) . . . . . . . . . . . . . . . . . . . . . . . ## ## 'ImfNumberQQClasses' returns the number of Q-classes of irreducible ## maximal finite subgroups of GL(dim,Q). ## DeclareGlobalFunction( "ImfNumberQQClasses" ); ############################################################################# ## #F ImfNumberZClasses( , ) . . . . . . . . . . . . . . . . . . . . . ## ## 'ImfNumberZClasses' returns the number of available class representatives ## in the qth Q-class of irreducible maximal finite integral matrix groups ## of dimension dim, i. e., the number of Z-classes in that Q-class, if dim ## is at most 11 or a prime, or just the value 1, else. ## DeclareGlobalFunction( "ImfNumberZClasses" ); ############################################################################# ## #F ImfPositionNumber( [ , ] ) . . . . . . . . . . . . . . . . . . . #F ImfPositionNumber( [ , , ] ) . . . . . . . . . . . . . . . . ## ## 'ImfPositionNumber' loads the imf main list if it is not yet available. ## Then it checks the given arguments and returns the position number of the ## specified Z-class representative within the list of all representatives ## of dimension dim which is still in the original order as submitted to ## us by LehrstuhL B. The default value of z is 1. ## DeclareGlobalFunction( "ImfPositionNumber" ); ############################################################################# ## #F OrbitShortVectors( , ) . . . . . . . . . . . . . . . . . . . ## ## 'OrbitShortVectors' is a subroutine of the 'PermGroupImfGroup' command. ## It returns the orbit of the short vector under the matrix group ## generators given in list . ## DeclareGlobalFunction( "OrbitShortVectors" ); ############################################################################# ## #F IsomorphismPermGroupImfGroup( ) . . . . . . . . . . . . . . . . . . . #F IsomorphismPermGroupImfGroup( , ) . . . . . . . . . . . . . . . . ## ## 'IsomorphismPermGroupImfGroup' returns an isomorphism from the given ## irreducible maximal finite integral matrix group to the permutation grou ## induced by the action of M on its nth orbit on the set of short vectors. ## The default value of n is 1. ## DeclareGlobalFunction( "IsomorphismPermGroupImfGroup" ); ############################################################################# ## #E gap-4r6p5/grp/imf1to9.grp0000644000175000017500000013777512172557252013757 0ustar billbill############################################################################# ## #A imf1to9.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Z-class representative of the irreducible ## maximal finite integral matrix groups of dimensions 1 to 9, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Z-class representative of ## the irreducible maximal finite integral matrix groups of dimension 1. ## IMFList[1].matrices := [ [ # Z-class [01][01] [[1]], [[[-1]]]] ]; MakeImmutable( IMFList[1].matrices ); ############################################################################# ## ## Quadratic form and matrix generators for the Z-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 2. ## IMFList[2].matrices := [ [ # Z-class [02][01] [[1], [0,1]], [[[0,1], [1,0]], [[-1,0], [0,1]]]], [ # Z-class [02][02] [[2], [-1,2]], [[[0,-1], [1,1]], [[0,1], [1,0]]]] ]; MakeImmutable( IMFList[2].matrices ); ############################################################################# ## ## Quadratic form and matrix generators for the Z-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 3. ## IMFList[3].matrices := [ [ # Z-class [03][01] [[1], [0,1], [0,0,1]], [[[1,0,0], [0,0,1], [0,1,0]], [[0,0,-1], [1,0,0], [0,1,0]]]], [ # Z-class [03][02] [[3], [-1,3], [-1,-1,3]], [[[0,1,0], [1,0,0], [0,0,1]], [[-1,0,0], [0,0,-1], [1,1,1]]]], [ # Z-class [03][03] [[2], [1,2], [1,1,2]], [[[0,1,0], [1,0,0], [0,0,1]], [[-1,1,0], [0,1,-1], [0,1,0]]]] ]; MakeImmutable( IMFList[3].matrices ); ############################################################################# ## ## Quadratic form and matrix generators for the Z-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 4. ## IMFList[4].matrices := [ [ # Z-class [04][01] [[1], [0,1], [0,0,1], [0,0,0,1]], [[[0,1,0,0], [1,0,0,0], [0,0,1,0], [0,0,0,1]], [[-1,0,0,0], [0,0,1,0], [0,0,0,1], [0,1,0,0]]]], [ # Z-class [04][02] [[2], [1,2], [0,1,2], [0,1,0,2]], [[[-1,1,-1,-1], [-1,0,0,0], [0,-1,1,0], [0,-1,0,1]], [[0,1,-1,-1], [0,0,0,-1], [-1,1,0,-1], [0,-1,0,0]]]], [ # Z-class [04][03] [[2], [-1,2], [0,0,2], [0,0,-1,2]], [[[0,1,0,0], [1,0,0,0], [0,0,1,0], [0,0,0,1]], [[0,-1,0,0], [1,1,0,0], [0,0,1,0], [0,0,0,1]], [[0,0,1,0], [0,0,0,1], [1,0,0,0], [0,1,0,0]]]], [ # Z-class [04][04] [[4], [-2,4], [-2,1,4], [1,-2,-2,4]], [[[0,1,0,0], [1,0,0,0], [0,0,0,1], [0,0,1,0]], [[0,-1,0,0], [1,1,0,0], [0,0,0,-1], [0,0,1,1]], [[1,0,0,0], [0,0,1,0], [0,1,0,0], [0,0,0,1]]]], [ # Z-class [04][05] [[2], [1,2], [1,1,2], [1,1,1,2]], [[[0,0,0,1], [-1,0,0,1], [0,-1,0,1], [0,0,-1,1]], [[0,1,0,0], [1,0,0,0], [0,0,1,0], [0,0,0,1]]]], [ # Z-class [04][06] [[4], [-1,4], [-1,-1,4], [-1,-1,-1,4]], [[[1,1,1,1], [-1,0,0,0], [0,-1,0,0], [0,0,-1,0]], [[0,1,0,0], [1,0,0,0], [0,0,1,0], [0,0,0,1]]]] ]; MakeImmutable( IMFList[4].matrices ); ############################################################################# ## ## Quadratic form and matrix generators for the Z-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 5. ## IMFList[5].matrices := [ [ # Z-class [05][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1]], [[[-1,0,0,0,0], [0,1,0,0,0], [0,0,0,1,0], [0,0,0,0,1], [0,0,1,0,0]], [[0,1,0,0,0], [0,0,1,0,0], [0,0,0,1,0], [1,0,0,0,0], [0,0,0,0,1]]]], [ # Z-class [05][02] [[2], [1,2], [0,1,2], [0,0,1,2], [0,0,1,0,2]], [[[-1,2,-2,1,1], [0,1,-1,1,1], [0,0,0,1,0], [0,0,1,0,-1], [0,0,-1,1,0]], [[0,1,0,0,0], [0,0,1,0,0], [1,-1,1,0,0], [1,-1,1,0,-1], [1,-1,1,-1,0]]]], [ # Z-class [05][03] [[4], [0,4], [0,0,4], [0,0,0,4], [2,2,2,2,5]], [[[-1,0,0,0,0], [0,1,0,0,0], [0,0,0,1,0], [-1,-1,-1,-1,2], [-1,0,0,0,1]], [[0,1,0,0,0], [0,0,1,0,0], [0,0,0,1,0], [1,0,0,0,0], [0,0,0,0,1]]]], [ # Z-class [05][04] [[5], [-1,5], [-1,-1,5], [-1,-1,-1,5], [-1,-1,-1,-1,5]], [[[0,1,0,0,0], [1,0,0,0,0], [0,0,1,0,0], [0,0,0,1,0], [0,0,0,0,1]], [[-1,0,0,0,0], [0,0,-1,0,0], [0,0,0,-1,0], [0,0,0,0,-1], [1,1,1,1,1]]]], [ # Z-class [05][05] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2]], [[[0,1,0,0,0], [1,0,0,0,0], [0,0,1,0,0], [0,0,0,1,0], [0,0,0,0,1]], [[-1,1,0,0,0], [0,1,-1,0,0], [0,1,0,-1,0], [0,1,0,0,-1], [0,1,0,0,0]]]], [ # Z-class [05][06] [[4], [1,4], [-2,1,4], [-2,-2,1,4], [-2,1,1,1,4]], [[[1,0,0,0,0], [1,-1,1,-1,1], [0,0,1,0,0], [0,0,0,1,0], [0,0,0,0,1]], [[-1,1,-1,1,-1], [0,0,-1,0,0], [0,0,0,-1,0], [1,0,1,0,0], [1,0,0,0,1]]]], [ # Z-class [05][07] [[3], [1,3], [-1,1,3], [-1,-1,1,3], [-1,1,1,1,3]], [[[1,0,0,0,0], [0,1,0,1,-1], [0,0,1,0,0], [0,0,0,0,1], [0,0,0,1,0]], [[0,-1,0,-1,1], [0,0,-1,0,0], [1,0,0,0,0], [0,1,0,0,0], [0,1,-1,1,0]]]] ]; MakeImmutable( IMFList[5].matrices ); ############################################################################# ## ## Quadratic form and matrix generators for the Z-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 6. ## IMFList[6].matrices := [ [ # Z-class [06][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1]], [[[0,1,0,0,0,0], [1,0,0,0,0,0], [0,0,1,0,0,0], [0,0,0,1,0,0], [0,0,0,0,1,0], [0,0,0,0,0,1]], [[-1,0,0,0,0,0], [0,0,1,0,0,0], [0,0,0,1,0,0], [0,0,0,0,1,0], [0,0,0,0,0,1], [0,1,0,0,0,0]]]], [ # Z-class [06][02] [[2], [1,2], [0,1,2], [0,0,1,2], [0,0,0,1,2], [0,0,0,1,0,2]], [[[1,0,0,0,0,0], [1,-1,2,-2,1,1], [0,0,1,0,0,0], [0,0,0,1,0,0], [0,0,0,0,1,0], [0,0,0,0,0,1]], [[-1,1,0,0,0,0], [0,0,1,0,0,0], [0,0,0,1,0,0], [0,0,0,0,1,0], [0,1,-1,1,0,-1], [0,-1,1,-1,1,0]]]], [ # Z-class [06][03] [[2], [0,2], [0,0,2], [0,0,0,2], [0,0,0,0,2], [1,1,1,1,1,3]], [[[0,1,0,0,0,0], [1,0,0,0,0,0], [0,0,1,0,0,0], [0,0,0,1,0,0], [0,0,0,0,1,0], [0,0,0,0,0,1]], [[-1,0,0,0,0,0], [0,0,1,0,0,0], [0,0,0,1,0,0], [0,0,0,0,1,0], [-1,-1,-1,-1,-1,2], [-1,0,0,0,0,1]]]], [ # Z-class [06][04] [[2], [1,2], [1,1,2], [0,0,0,2], [0,0,0,1,2], [0,0,0,1,1,2]], [[[0,1,0,0,0,0], [1,0,0,0,0,0], [0,0,1,0,0,0], [0,0,0,1,0,0], [0,0,0,0,1,0], [0,0,0,0,0,1]], [[-1,1,0,0,0,0], [0,1,-1,0,0,0], [0,1,0,0,0,0], [0,0,0,1,0,0], [0,0,0,0,1,0], [0,0,0,0,0,1]], [[0,0,0,1,0,0], [0,0,0,0,1,0], [0,0,0,0,0,1], [1,0,0,0,0,0], [0,1,0,0,0,0], [0,0,1,0,0,0]]]], [ # Z-class [06][05] [[3], [-1,3], [-1,-1,3], [0,0,0,3], [0,0,0,-1,3], [0,0,0,-1,-1,3]], [[[0,1,0,0,0,0], [1,0,0,0,0,0], [0,0,1,0,0,0], [0,0,0,1,0,0], [0,0,0,0,1,0], [0,0,0,0,0,1]], [[-1,0,0,0,0,0], [0,0,-1,0,0,0], [1,1,1,0,0,0], [0,0,0,1,0,0], [0,0,0,0,1,0], [0,0,0,0,0,1]], [[0,0,0,1,0,0], [0,0,0,0,1,0], [0,0,0,0,0,1], [1,0,0,0,0,0], [0,1,0,0,0,0], [0,0,1,0,0,0]]]], [ # Z-class [06][06] [[3], [1,3], [1,1,3], [1,1,1,3], [1,1,1,1,3], [1,1,-1,-1,1,3]], [[[1,0,-1,-1,1,-1], [0,0,0,-1,0,0], [0,1,-1,-1,1,-1], [0,0,-1,0,0,0], [1,1,-1,-1,0,-1], [1,0,0,-1,0,-1]], [[1,0,0,0,0,0], [0,1,0,0,0,0], [0,0,0,1,0,0], [0,0,0,0,1,0], [1,1,-1,-1,1,-2], [1,1,-1,-1,0,-1]]]], [ # Z-class [06][07] [[2], [-1,2], [0,0,2], [0,0,-1,2], [0,0,0,0,2], [0,0,0,0,-1,2]], [[[0,-1,0,0,0,0], [1,1,0,0,0,0], [0,0,0,0,1,0], [0,0,0,0,0,1], [0,0,1,0,0,0], [0,0,0,1,0,0]], [[0,1,0,0,0,0], [1,0,0,0,0,0], [0,0,1,0,0,0], [0,0,0,1,0,0], [0,0,0,0,1,0], [0,0,0,0,0,1]], [[0,0,0,0,-1,0], [0,0,0,0,0,-1], [-1,0,0,0,0,0], [0,-1,0,0,0,0], [0,0,-1,0,0,0], [0,0,0,-1,0,0]]]], [ # Z-class [06][08] [[2], [0,2], [-1,0,2], [0,-1,-1,2], [0,0,0,-1,2], [0,0,0,0,-1,2]], [[[0,0,1,0,0,0], [1,1,1,1,0,0], [0,0,0,1,0,0], [0,0,0,0,1,0], [0,0,0,0,0,1], [-1,0,-1,-1,-1,-1]], [[0,0,-1,0,0,0], [1,1,1,1,0,0], [0,0,0,-1,0,0], [0,-1,0,0,0,0], [-1,0,-1,-1,-1,0], [0,0,0,0,0,-1]]]], [ # Z-class [06][09] [[4], [1,4], [-2,1,4], [-2,-2,1,4], [1,-2,-2,1,4], [1,1,-2,-2,1,4]], [[[-1,0,-1,0,0,0], [-1,0,0,-1,0,0], [0,0,0,-1,0,-1], [0,1,0,0,1,-1], [0,0,0,1,0,0], [0,0,0,1,-1,1]], [[1,-1,1,1,-1,1], [1,-1,0,0,-1,0], [0,0,0,-1,0,0], [0,1,0,0,1,0], [0,1,0,1,0,0], [0,0,0,0,0,-1]]]], [ # Z-class [06][10] [[4], [2,4], [2,2,4], [-2,-1,-1,4], [-1,-2,-1,2,4], [-1,-1,-2,2,2,4]], [[[0,0,0,-1,0,0], [0,0,0,0,-1,0], [0,0,0,0,0,-1], [1,0,0,1,0,0], [0,1,0,0,1,0], [0,0,1,0,0,1]], [[0,0,0,1,-1,0], [0,0,0,0,-1,1], [0,0,0,0,-1,0], [1,-1,0,0,0,0], [0,-1,1,0,0,0], [0,-1,0,0,0,0]], [[0,1,0,0,0,0], [1,0,0,0,0,0], [0,0,1,0,0,0], [0,0,0,0,1,0], [0,0,0,1,0,0], [0,0,0,0,0,1]]]], [ # Z-class [06][11] [[6], [-2,6], [-2,-2,6], [-3,1,1,6], [1,-3,1,-2,6], [1,1,-3,-2,-2,6]], [[[0,0,0,-1,0,0], [0,0,0,0,-1,0], [0,0,0,0,0,-1], [1,0,0,1,0,0], [0,1,0,0,1,0], [0,0,1,0,0,1]], [[0,0,0,1,0,0], [0,0,0,0,0,1], [0,0,0,-1,-1,-1], [1,0,0,0,0,0], [0,0,1,0,0,0], [-1,-1,-1,0,0,0]], [[0,1,0,0,0,0], [1,0,0,0,0,0], [0,0,1,0,0,0], [0,0,0,0,1,0], [0,0,0,1,0,0], [0,0,0,0,0,1]]]], [ # Z-class [06][12] [[6], [-1,6], [-1,-1,6], [-1,-1,-1,6], [-1,-1,-1,-1,6], [-1,-1,-1,-1,-1,6]], [[[0,-1,0,0,0,0], [0,0,-1,0,0,0], [0,0,0,-1,0,0], [0,0,0,0,-1,0], [0,0,0,0,0,-1], [1,1,1,1,1,1]], [[0,1,0,0,0,0], [1,0,0,0,0,0], [0,0,1,0,0,0], [0,0,0,1,0,0], [0,0,0,0,1,0], [0,0,0,0,0,1]]]], [ # Z-class [06][13] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2]], [[[1,-1,0,0,0,0], [1,0,-1,0,0,0], [1,0,0,-1,0,0], [1,0,0,0,-1,0], [1,0,0,0,0,-1], [1,0,0,0,0,0]], [[0,1,0,0,0,0], [1,0,0,0,0,0], [0,0,1,0,0,0], [0,0,0,1,0,0], [0,0,0,0,1,0], [0,0,0,0,0,1]]]], [ # Z-class [06][14] [[4], [-1,4], [-2,-1,4], [1,-2,-1,4], [1,1,-2,-1,4], [-2,1,1,-2,-1,4]], [[[0,-1,-1,-1,0,0], [1,1,1,0,0,0], [-1,0,0,0,0,-1], [0,0,0,1,1,1], [0,0,-1,-1,-1,0], [0,0,1,0,0,0]], [[0,0,0,0,0,-1], [0,-1,0,-1,0,0], [0,0,0,1,0,1], [0,1,1,1,1,0], [0,0,0,-1,-1,-1], [1,0,0,0,0,1]]]], [ # Z-class [06][15] [[3], [-1,3], [-1,-1,3], [1,-1,0,3], [1,0,-1,-1,3], [0,1,-1,1,-1,3]], [[[0,0,0,-1,0,0], [0,0,0,0,-1,0], [-1,0,0,1,1,0], [0,0,0,0,0,-1], [0,-1,0,-1,0,1], [0,0,-1,0,-1,-1]], [[-1,0,0,0,0,0], [0,0,0,1,0,0], [0,0,0,0,1,0], [0,1,0,0,0,0], [0,0,1,0,0,0], [0,0,0,0,0,1]]]], [ # Z-class [06][16] [[4], [1,4], [2,1,4], [2,2,1,4], [1,2,2,1,4], [0,1,-1,-1,1,4]], [[[0,-1,0,0,0,0], [0,0,-1,0,0,0], [0,0,0,-1,0,0], [0,0,0,0,-1,0], [-1,0,0,0,0,0], [0,0,-1,0,1,-1]], [[-1,0,1,0,0,0], [0,-1,0,0,1,0], [0,0,1,0,0,0], [-1,-1,1,1,0,1], [0,0,0,0,1,0], [0,0,-1,0,1,-1]]]], [ # Z-class [06][17] [[5], [1,5], [-1,1,5], [-1,-1,1,5], [1,-1,-1,1,5], [2,2,2,2,2,5]], [[[0,-1,0,0,0,0], [0,0,-1,0,0,0], [0,0,0,-1,0,0], [0,0,0,0,-1,0], [-1,0,0,0,0,0], [0,0,0,0,0,-1]], [[0,0,0,0,0,1], [0,-1,0,-1,0,1], [1,0,1,0,0,-1], [1,0,0,1,0,-1], [0,0,-1,0,-1,1], [1,0,0,0,0,0]]]] ]; MakeImmutable( IMFList[6].matrices ); ############################################################################# ## ## Quadratic form and matrix generators for the Z-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 7. ## IMFList[7].matrices := [ [ # Z-class [07][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1]], [[[0,1,0,0,0,0,0], [0,0,1,0,0,0,0], [0,0,0,1,0,0,0], [1,0,0,0,0,0,0], [0,0,0,0,1,0,0], [0,0,0,0,0,1,0], [0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0], [0,1,0,0,0,0,0], [0,0,0,1,0,0,0], [0,0,0,0,1,0,0], [0,0,0,0,0,1,0], [0,0,0,0,0,0,1], [0,0,1,0,0,0,0]]]], [ # Z-class [07][02] [[2], [1,2], [0,1,2], [0,0,1,2], [0,0,0,1,2], [0,0,0,0,1,2], [0,0,0,0,1,0,2]], [[[0,1,0,0,0,0,0], [0,0,1,0,0,0,0], [1,-1,1,0,0,0,0], [1,-1,1,-1,2,-1,-1], [0,0,0,0,1,0,0], [0,0,0,0,0,1,0], [0,0,0,0,0,0,1]], [[-1,2,-2,2,-2,1,1], [0,1,-1,2,-2,1,1], [0,0,0,1,0,0,0], [0,0,0,0,1,0,0], [0,0,0,0,0,1,0], [0,0,1,-1,1,0,-1], [0,0,-1,1,-1,1,0]]]], [ # Z-class [07][03] [[4], [0,4], [0,0,4], [0,0,0,4], [0,0,0,0,4], [0,0,0,0,0,4], [2,2,2,2,2,2,7]], [[[0,1,0,0,0,0,0], [0,0,1,0,0,0,0], [0,0,0,1,0,0,0], [1,0,0,0,0,0,0], [0,0,0,0,1,0,0], [0,0,0,0,0,1,0], [0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0], [0,1,0,0,0,0,0], [0,0,0,1,0,0,0], [0,0,0,0,1,0,0], [0,0,0,0,0,1,0], [-1,-1,-1,-1,-1,-1,2], [-1,0,0,0,0,0,1]]]], [ # Z-class [07][04] [[7], [-1,7], [-1,-1,7], [-1,-1,-1,7], [-1,-1,-1,-1,7], [-1,-1,-1,-1,-1,7], [-1,-1,-1,-1,-1,-1,7]], [[[0,1,0,0,0,0,0], [1,0,0,0,0,0,0], [0,0,1,0,0,0,0], [0,0,0,1,0,0,0], [0,0,0,0,1,0,0], [0,0,0,0,0,1,0], [0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0], [0,0,-1,0,0,0,0], [0,0,0,-1,0,0,0], [0,0,0,0,-1,0,0], [0,0,0,0,0,-1,0], [0,0,0,0,0,0,-1], [1,1,1,1,1,1,1]]]], [ # Z-class [07][05] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2]], [[[0,1,0,0,0,0,0], [1,0,0,0,0,0,0], [0,0,1,0,0,0,0], [0,0,0,1,0,0,0], [0,0,0,0,1,0,0], [0,0,0,0,0,1,0], [0,0,0,0,0,0,1]], [[-1,1,0,0,0,0,0], [0,1,-1,0,0,0,0], [0,1,0,-1,0,0,0], [0,1,0,0,-1,0,0], [0,1,0,0,0,-1,0], [0,1,0,0,0,0,-1], [0,1,0,0,0,0,0]]]], [ # Z-class [07][06] [[2], [0,2], [1,0,2], [0,1,1,2], [0,0,0,1,2], [0,0,0,0,1,2], [0,0,0,0,0,1,2]], [[[1,-1,-1,1,0,0,0], [0,0,0,1,0,0,0], [1,0,0,0,0,0,0], [0,0,1,0,0,0,0], [0,-1,0,1,-1,0,0], [0,0,0,0,0,-1,0], [0,0,0,0,0,0,-1]], [[-1,0,1,-1,1,-1,1], [0,1,0,-1,1,-1,1], [-1,0,0,0,0,0,0], [0,0,-1,0,0,0,0], [0,0,0,-1,0,0,0], [0,0,0,0,-1,0,0], [0,0,0,0,0,-1,0]]]], [ # Z-class [07][07] [[3], [1,3], [1,1,3], [1,1,1,3], [1,1,1,1,3], [1,1,-1,-1,-1,3], [1,1,1,1,1,-1,3]], [[[0,0,0,0,0,0,1], [0,0,0,0,0,-1,0], [0,0,0,0,1,0,0], [1,0,0,-1,0,-1,0], [1,0,-1,0,0,-1,0], [0,1,0,0,-1,-1,0], [-1,-1,0,0,1,1,1]], [[-2,-1,1,1,1,2,1], [0,0,0,0,0,0,1], [0,0,0,0,0,-1,0], [-1,-1,0,1,0,1,1], [-1,-1,1,0,0,1,1], [0,1,0,0,0,0,0], [-1,-1,0,0,1,1,1]]]] ]; MakeImmutable( IMFList[7].matrices ); ############################################################################# ## ## Quadratic form and matrix generators for the Z-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 8. ## IMFList[8].matrices := [ [ # Z-class [08][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1]], [[[0,1,0,0,0,0,0,0], [1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1], [0,1,0,0,0,0,0,0]]]], [ # Z-class [08][02] [[2], [1,2], [0,1,2], [0,0,1,2], [0,0,0,1,2], [0,0,0,0,1,2], [0,0,0,0,0,1,2], [0,0,0,0,0,1,0,2]], [[[1,0,0,0,0,0,0,0], [1,-1,2,-2,2,-2,1,1], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1]], [[-1,1,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,1,-1,1,-1,1,0,-1], [0,-1,1,-1,1,-1,1,0]]]], [ # Z-class [08][03] [[2], [0,2], [0,0,2], [0,0,0,2], [0,0,0,0,2], [0,0,0,0,0,2], [0,0,0,0,0,0,2], [1,1,1,1,1,1,1,4]], [[[0,1,0,0,0,0,0,0], [1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [-1,-1,-1,-1,-1,-1,-1,2], [-1,0,0,0,0,0,0,1]]]], [ # Z-class [08][04] [[2], [1,2], [0,1,2], [0,1,0,2], [0,0,0,0,2], [0,0,0,0,1,2], [0,0,0,0,0,1,2], [0,0,0,0,0,1,0,2]], [[[-1,1,-1,-1,0,0,0,0], [-1,0,0,0,0,0,0,0], [0,-1,1,0,0,0,0,0], [0,-1,0,1,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1]], [[0,1,-1,-1,0,0,0,0], [0,0,0,-1,0,0,0,0], [-1,1,0,-1,0,0,0,0], [0,-1,0,0,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1]], [[0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0]]]], [ # Z-class [08][05] [[2], [0,2], [-1,0,2], [0,-1,-1,2], [0,0,0,-1,2], [0,0,0,0,-1,2], [0,0,0,0,0,-1,2], [0,0,0,0,0,0,-1,2]], [[[-1,-1,-1,-1,0,0,0,0], [0,0,0,1,0,0,0,0], [1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,1,0,1,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1]], [[-1,0,-1,-1,-1,-1,-1,-1], [0,1,0,1,1,1,1,1], [1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0]]]], [ # Z-class [08][06] [[4], [2,4], [0,2,4], [0,2,0,4], [-2,-1,0,0,4], [-1,-2,-1,-1,2,4], [0,-1,-2,0,0,2,4], [0,-1,0,-2,0,2,0,4]], [[[0,0,0,0,0,-1,1,1], [0,0,0,0,0,0,0,1], [0,0,0,0,1,-1,0,1], [0,0,0,0,0,1,0,0], [0,1,-1,-1,0,1,-1,-1], [0,0,0,-1,0,0,0,-1], [-1,1,0,-1,-1,1,0,-1], [0,-1,0,0,0,-1,0,0]], [[0,0,0,0,-1,1,-1,-1], [0,0,0,0,-1,0,0,0], [0,0,0,0,0,-1,1,0], [0,0,0,0,0,-1,0,1], [-1,1,-1,-1,0,0,0,0], [-1,0,0,0,0,0,0,0], [0,-1,1,0,0,0,0,0], [0,-1,0,1,0,0,0,0]], [[-1,1,-1,-1,0,0,0,0], [-1,0,0,0,0,0,0,0], [0,-1,1,0,0,0,0,0], [0,-1,0,1,0,0,0,0], [0,0,0,0,-1,1,-1,-1], [0,0,0,0,-1,0,0,0], [0,0,0,0,0,-1,1,0], [0,0,0,0,0,-1,0,1]]]], [ # Z-class [08][07] [[2], [-1,2], [0,0,2], [0,0,-1,2], [0,0,0,0,2], [0,0,0,0,-1,2], [0,0,0,0,0,0,2], [0,0,0,0,0,0,-1,2]], [[[0,-1,0,0,0,0,0,0], [1,1,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1]], [[0,1,0,0,0,0,0,0], [1,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0]], [[0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0], [1,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1]]]], [ # Z-class [08][08] [[4], [-2,4], [0,0,4], [0,0,-2,4], [-2,1,-1,-1,4], [1,-2,2,-1,-2,4], [1,-2,-1,2,-2,1,4], [1,1,-1,-1,1,-2,-2,4]], [[[-1,0,0,0,0,1,1,1], [0,-1,0,0,-1,-1,-1,0], [0,0,-1,0,0,0,0,0], [0,0,0,-1,0,0,0,0], [0,0,0,0,-1,-1,-1,-1], [0,0,0,0,1,0,1,0], [0,0,0,0,1,1,0,0], [0,0,0,0,-1,0,0,0]], [[0,0,1,0,0,-1,0,0], [0,0,0,1,0,1,0,1], [-1,0,0,0,0,0,1,1], [0,-1,0,0,0,0,-1,0], [1,1,0,0,1,1,1,0], [-1,0,0,0,0,0,0,0], [0,-1,0,0,0,-1,-1,-1], [1,1,0,0,0,0,0,0]], [[1,0,0,0,0,0,-1,-1], [0,1,0,0,0,0,1,0], [0,0,1,0,0,0,1,1], [0,0,0,1,0,0,-1,0], [0,0,0,0,1,0,1,0], [0,0,0,0,0,1,0,1], [0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,-1]]]], [ # Z-class [08][09] [[6], [0,6], [0,0,6], [0,3,0,6], [0,0,-3,0,6], [3,0,0,0,0,6], [3,-3,0,-3,3,3,8], [0,0,3,-3,0,3,4,8]], [[[-1,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0], [0,0,0,-1,0,0,0,0], [0,0,0,0,-1,0,0,0], [0,0,0,0,0,-1,0,0], [-1,1,0,0,-1,0,1,-1], [0,0,-1,1,-1,-1,1,0]], [[0,-1,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0], [1,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,-1,0,0], [0,0,0,-1,0,0,0,0], [0,0,0,0,-1,-1,1,0], [0,1,0,-1,-1,0,1,-1]], [[1,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0], [-1,1,0,0,-1,0,2,-1], [0,0,0,1,0,0,0,0], [0,0,1,-1,1,1,-1,-1], [0,0,0,0,0,1,0,0], [0,0,1,-1,0,1,0,-1], [-1,1,0,-1,-1,1,1,-1]]]], [ # Z-class [08][10] [[4], [-2,4], [-2,1,4], [1,-2,-2,4], [0,0,0,0,4], [0,0,0,0,-2,4], [0,0,0,0,-2,1,4], [0,0,0,0,1,-2,-2,4]], [[[0,1,0,0,0,0,0,0], [1,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0], [0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1]], [[0,-1,0,0,0,0,0,0], [1,1,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0], [0,0,1,1,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1]], [[0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0]]]], [ # Z-class [08][11] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2]], [[[0,1,0,0,0,0,0,0], [1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1]], [[1,-1,0,0,0,0,0,0], [1,0,-1,0,0,0,0,0], [1,0,0,-1,0,0,0,0], [1,0,0,0,-1,0,0,0], [1,0,0,0,0,-1,0,0], [1,0,0,0,0,0,-1,0], [1,0,0,0,0,0,0,-1], [1,0,0,0,0,0,0,0]]]], [ # Z-class [08][12] [[8], [-1,8], [-1,-1,8], [-1,-1,-1,8], [-1,-1,-1,-1,8], [-1,-1,-1,-1,-1,8], [-1,-1,-1,-1,-1,-1,8], [-1,-1,-1,-1,-1,-1,-1,8]], [[[0,1,0,0,0,0,0,0], [1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1]], [[0,-1,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0], [0,0,0,-1,0,0,0,0], [0,0,0,0,-1,0,0,0], [0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,-1], [1,1,1,1,1,1,1,1]]]], [ # Z-class [08][13] [[8], [-4,8], [-4,2,8], [2,-4,-4,8], [-4,2,2,-1,8], [2,-4,-1,2,-4,8], [2,-1,-4,2,-4,2,8], [-1,2,2,-4,2,-4,-4,8]], [[[0,0,0,0,-1,0,0,0], [0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,-1], [1,0,0,0,1,0,0,0], [0,1,0,0,0,1,0,0], [0,0,1,0,0,0,1,0], [0,0,0,1,0,0,0,1]], [[0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0]], [[1,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0], [0,1,0,0,0,0,0,0], [0,0,0,0,0,1,0,0], [0,0,1,0,0,0,0,0], [0,0,0,0,0,0,1,0], [0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,1]]]], [ # Z-class [08][14] [[2], [1,2], [1,1,2], [1,1,1,2], [0,0,0,0,2], [0,0,0,0,1,2], [0,0,0,0,1,1,2], [0,0,0,0,1,1,1,2]], [[[0,0,0,1,0,0,0,0], [-1,0,0,1,0,0,0,0], [0,-1,0,1,0,0,0,0], [0,0,-1,1,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1]], [[0,1,0,0,0,0,0,0], [1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1]], [[0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0]]]], [ # Z-class [08][15] [[4], [-1,4], [-1,-1,4], [-1,-1,-1,4], [0,0,0,0,4], [0,0,0,0,-1,4], [0,0,0,0,-1,-1,4], [0,0,0,0,-1,-1,-1,4]], [[[1,1,1,1,0,0,0,0], [-1,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1]], [[0,1,0,0,0,0,0,0], [1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1]], [[0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0]]]], [ # Z-class [08][16] [[4], [-2,4], [1,-1,4], [1,0,-1,4], [-1,-1,1,1,4], [-2,1,-2,1,1,4], [0,1,-2,2,-1,2,4], [2,-1,0,1,-2,0,1,4]], [[[0,0,0,0,0,0,0,1], [0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0], [0,1,0,0,1,-1,0,1], [0,1,0,0,0,0,0,0], [1,1,0,-1,1,0,0,0], [0,0,1,0,0,0,0,0], [1,0,0,0,0,0,0,0]], [[-1,-1,0,0,0,-1,1,0], [0,0,0,0,0,1,-1,0], [0,0,0,-1,0,0,1,0], [0,-1,1,1,-1,1,0,-1], [1,0,1,0,-1,1,0,-1], [0,0,1,1,-1,1,-1,0], [0,0,0,0,1,0,0,1], [-1,-1,0,1,-1,0,0,0]], [[1,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,1,-1,1,-1,0], [0,-1,1,1,-2,1,0,-1]]]], [ # Z-class [08][17] [[8], [3,8], [3,3,8], [3,3,3,8], [-3,2,2,2,8], [-3,2,2,2,3,8], [-2,-2,-2,-2,2,2,8], [-2,-2,-2,3,2,2,3,8]], [[[0,0,0,0,1,0,0,0], [1,-1,0,0,1,0,0,0], [1,0,-1,0,1,0,0,0], [1,0,0,-1,1,0,0,0], [1,0,0,-1,0,0,0,1], [2,-1,-1,-1,1,1,-1,0], [1,0,0,-1,0,1,-1,1], [1,0,0,-1,0,1,0,0]], [[0,0,0,0,-1,0,0,0], [-1,1,0,0,-1,0,0,0], [-1,0,1,0,-1,0,0,0], [-1,0,0,1,-1,0,0,0], [-1,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1]], [[1,-1,0,0,1,0,0,0], [0,-1,0,0,0,0,0,0], [-1,0,1,1,-1,-1,1,0], [1,-1,0,0,0,1,0,0], [0,0,0,0,-1,0,0,0], [-1,0,0,1,-1,0,0,0], [0,0,0,0,0,0,-1,0], [1,0,0,-1,0,1,-1,1]]]], [ # Z-class [08][18] [[8], [-2,8], [-2,-2,8], [-2,-2,-2,8], [-4,1,1,1,8], [1,-4,1,1,-2,8], [1,1,-4,1,-2,-2,8], [1,1,1,-4,-2,-2,-2,8]], [[[0,0,0,0,1,1,1,1], [0,0,0,0,-1,0,0,0], [0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,-1,0], [-1,-1,-1,-1,-1,-1,-1,-1], [1,0,0,0,1,0,0,0], [0,1,0,0,0,1,0,0], [0,0,1,0,0,0,1,0]], [[0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0]], [[0,1,0,0,0,0,0,0], [1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1]]]], [ # Z-class [08][19] [[4], [2,4], [2,2,4], [2,2,2,4], [-2,-1,-1,-1,4], [-1,-2,-1,-1,2,4], [-1,-1,-2,-1,2,2,4], [-1,-1,-1,-2,2,2,2,4]], [[[0,0,0,-1,0,0,0,-1], [1,0,0,-1,1,0,0,-1], [0,1,0,-1,0,1,0,-1], [0,0,1,-1,0,0,1,-1], [0,0,0,1,0,0,0,0], [-1,0,0,1,0,0,0,0], [0,-1,0,1,0,0,0,0], [0,0,-1,1,0,0,0,0]], [[0,0,0,0,-1,0,0,0], [0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,-1], [-1,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0], [0,0,0,-1,0,0,0,0]], [[0,1,0,0,0,0,0,0], [1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1]]]], [ # Z-class [08][20] [[4], [0,4], [0,0,4], [1,1,-1,4], [0,0,0,1,4], [1,-1,1,1,-1,4], [-1,-1,-1,0,1,1,4], [1,1,1,-1,1,0,1,4]], [[[0,-1,0,1,-1,-1,0,1], [0,0,0,-1,0,0,0,0], [-1,0,-1,0,0,1,-1,1], [0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,-1,0], [0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,-1], [0,0,0,0,-1,0,0,0]], [[0,0,0,0,0,0,0,-1], [-1,-1,0,1,0,0,-1,1], [0,0,1,1,-1,-1,1,0], [0,0,0,0,0,0,-1,0], [0,0,0,0,0,-1,0,0], [0,0,0,0,-1,0,0,0], [0,0,0,-1,0,0,0,0], [-1,0,0,0,0,0,0,0]]]], [ # Z-class [08][21] [[3], [1,3], [0,0,3], [0,0,-1,3], [0,1,-1,0,3], [-1,0,1,0,-1,3], [-1,0,0,-1,1,1,3], [1,0,1,0,1,0,1,3]], [[[-1,1,-1,-1,-1,0,-1,1], [0,0,-1,-1,0,1,-1,1], [-1,0,0,0,0,0,-1,1], [0,0,-1,0,0,0,0,0], [1,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0], [1,-1,1,0,1,0,0,-1], [0,0,0,0,0,0,-1,0]], [[-1,1,-1,-1,-1,0,-1,1], [0,1,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0], [0,0,0,0,0,1,0,0], [0,0,1,0,1,0,0,-1], [0,0,0,1,0,0,0,0], [0,0,1,1,0,-1,1,-1], [0,0,0,0,0,0,0,-1]]]], [ # Z-class [08][22] [[6], [-2,6], [2,-2,6], [3,-1,3,6], [3,1,1,1,6], [-1,3,1,1,0,6], [1,3,-1,2,3,3,6], [0,0,2,3,1,3,3,6]], [[[0,0,-1,0,1,1,-1,0], [0,1,1,0,0,-1,0,0], [0,0,0,0,0,1,0,0], [0,0,-1,1,1,1,-1,0], [-1,0,0,0,1,0,0,0], [0,0,1,0,0,0,1,-1], [-1,0,0,1,1,0,0,-1], [-1,-1,0,1,1,1,0,-1]], [[0,0,-1,1,0,0,-1,0], [-1,0,1,0,0,-1,1,0], [0,0,-1,0,0,0,0,0], [0,0,-1,1,0,0,0,0], [-1,0,0,1,0,0,0,-1], [-1,-1,0,0,0,0,1,0], [-1,0,0,1,0,0,0,0], [0,0,0,0,-1,0,1,0]], [[1,0,0,-1,0,0,0,1], [0,0,0,0,0,1,0,-1], [1,1,1,-1,-1,-1,0,1], [1,1,0,0,0,0,-1,1], [0,0,1,-1,0,0,1,0], [0,0,0,0,0,1,-1,0], [0,0,0,0,0,1,0,0], [0,1,0,0,0,0,-1,1]]]], [ # Z-class [08][23] [[8], [-4,8], [-1,2,8], [2,-4,-4,8], [2,-1,-4,2,8], [-4,2,2,-1,-4,8], [-1,-1,2,-1,2,-1,8], [2,-1,-1,-1,-1,2,-4,8]], [[[0,0,0,0,0,0,0,1], [0,0,0,0,0,0,1,0], [1,1,-1,0,-1,0,1,0], [0,0,1,0,1,0,-1,0], [-1,0,1,1,0,-1,0,1], [1,0,0,0,0,1,0,-1], [0,0,0,0,-1,-1,0,0], [0,0,0,0,0,1,0,0]], [[-1,-1,1,0,1,0,-1,0], [0,0,-1,0,-1,0,1,0], [0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,-1,0], [-1,0,0,0,0,-1,0,1], [1,0,-1,-1,0,1,0,-1], [0,0,0,0,0,-1,0,0], [0,0,0,0,1,1,0,0]]]], [ # Z-class [08][24] [[6], [-1,6], [0,-1,6], [1,0,3,6], [-1,-2,3,1,6], [1,1,2,1,3,6], [-1,2,-2,1,-1,2,6], [0,2,3,2,2,3,1,6]], [[[0,1,0,0,1,-1,0,0], [0,0,-1,0,0,1,-1,0], [0,0,-1,1,0,0,0,0], [-1,0,-1,1,-1,1,-1,0], [0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,1], [-1,-1,-1,0,-1,1,-1,1], [0,0,-1,0,0,0,0,0]], [[1,0,1,-1,0,-1,1,0], [0,0,-1,0,0,1,-1,0], [0,0,1,0,0,0,0,-1], [0,-1,0,0,0,0,0,0], [0,0,1,0,0,0,0,0], [0,0,1,-1,0,0,0,0], [-1,-1,-1,0,-1,1,-1,1], [0,0,0,0,0,0,-1,0]], [[1,0,0,0,0,0,0,0], [0,1,1,0,0,0,0,-1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,1,0,0], [-1,-1,-1,1,-1,1,-1,1], [0,0,0,1,0,0,0,0], [0,0,1,0,0,0,1,-1], [0,0,1,0,0,0,0,0]]]], [ # Z-class [08][25] [[4], [2,4], [2,1,4], [-1,0,-1,4], [0,-1,2,0,4], [1,1,0,2,1,4], [0,1,2,1,1,1,4], [-1,-1,1,0,1,1,2,4]], [[[1,-1,0,0,0,0,0,0], [1,0,-1,0,1,-1,0,0], [1,0,0,0,0,0,0,0], [0,0,-1,-1,0,0,1,0], [0,0,1,0,-1,0,0,0], [1,0,-1,0,0,-1,0,1], [1,1,-1,0,1,-1,0,1], [0,1,0,0,0,0,-1,1]], [[-1,0,1,0,0,1,-1,0], [-1,0,1,0,0,1,0,-1], [0,1,0,1,1,-1,-1,1], [0,0,-1,0,0,0,1,0], [0,1,0,1,0,-1,-1,1], [-1,0,1,0,-1,1,0,0], [1,1,-1,1,1,-1,0,1], [1,0,0,1,0,-1,0,1]], [[1,-1,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0], [0,-1,1,0,-1,1,0,0], [0,1,0,1,1,-1,-1,1], [0,0,0,0,0,1,0,0], [0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,1,0]]]], [ # Z-class [08][26] [[14], [1,14], [7,-4,14], [-4,7,-5,14], [4,-4,5,-5,14], [4,-4,5,-5,-1,14], [-5,-1,-1,4,5,-1,14], [1,5,-4,1,-1,5,5,14]], [[[0,0,1,0,0,-1,0,1], [-1,0,0,0,1,0,-1,1], [1,0,0,-1,-1,-1,1,0], [-1,0,0,0,1,0,-1,0], [1,0,0,0,0,0,0,0], [0,-1,1,0,-1,-1,0,1], [0,0,0,0,0,0,-1,0], [-1,0,1,0,0,0,-1,1]], [[1,0,0,0,0,0,0,0], [0,-1,0,1,0,0,-1,1], [0,0,1,0,0,0,0,0], [0,0,0,0,-1,0,0,0], [0,0,1,0,0,-1,0,1], [0,0,0,-1,0,0,0,0], [-1,0,1,0,0,-1,-1,1], [0,-1,0,0,0,-1,-1,1]], [[0,0,0,0,0,0,0,-1], [-1,0,0,1,1,1,-1,0], [1,0,0,0,-1,0,1,-1], [-1,0,1,1,1,0,-1,1], [1,0,-1,0,0,0,1,-1], [0,1,0,-1,-1,0,1,-1], [0,0,0,0,0,0,1,0], [-1,0,0,0,0,0,0,0]]]] ]; MakeImmutable( IMFList[8].matrices ); ############################################################################# ## ## Quadratic form and matrix generators for the Z-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 9. ## IMFList[9].matrices := [ [ # Z-class [09][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1]], [[[-1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1], [0,0,1,0,0,0,0,0,0]], [[0,1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0], [1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1]]]], [ # Z-class [09][02] [[2], [1,2], [0,1,2], [0,0,1,2], [0,0,0,1,2], [0,0,0,0,1,2], [0,0,0,0,0,1,2], [0,0,0,0,0,0,1,2], [0,0,0,0,0,0,1,0,2]], [[[-1,2,-2,2,-2,2,-2,1,1], [0,1,-1,2,-2,2,-2,1,1], [0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,1,-1,1,-1,1,0,-1], [0,0,-1,1,-1,1,-1,1,0]], [[0,1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0], [1,-1,1,0,0,0,0,0,0], [1,-1,1,-1,2,-2,2,-1,-1], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1]]]], [ # Z-class [09][03] [[4], [0,4], [0,0,4], [0,0,0,4], [0,0,0,0,4], [0,0,0,0,0,4], [0,0,0,0,0,0,4], [0,0,0,0,0,0,0,4], [2,2,2,2,2,2,2,2,9]], [[[-1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [-1,-1,-1,-1,-1,-1,-1,-1,2], [-1,0,0,0,0,0,0,0,1]], [[0,1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0], [1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1]]]], [ # Z-class [09][04] [[2], [1,2], [1,1,2], [0,0,0,2], [0,0,0,1,2], [0,0,0,1,1,2], [0,0,0,0,0,0,2], [0,0,0,0,0,0,1,2], [0,0,0,0,0,0,1,1,2]], [[[0,1,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1]], [[-1,1,0,0,0,0,0,0,0], [0,1,-1,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1]], [[0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0]], [[0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1]]]], [ # Z-class [09][05] [[3], [-1,3], [-1,-1,3], [0,0,0,3], [0,0,0,-1,3], [0,0,0,-1,-1,3], [0,0,0,0,0,0,3], [0,0,0,0,0,0,-1,3], [0,0,0,0,0,0,-1,-1,3]], [[[0,1,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0], [1,1,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1]], [[0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0]], [[0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1]]]], [ # Z-class [09][06] [[2], [1,2], [1,1,2], [0,0,0,2], [0,0,0,1,2], [0,0,0,1,1,2], [0,0,0,0,0,0,2], [0,0,0,0,0,0,1,2], [0,1,1,0,1,1,0,1,3]], [[[0,1,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [1,-1,0,0,0,0,0,0,1]], [[-1,1,0,0,0,0,0,0,0], [0,1,-1,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [1,0,-1,0,0,0,0,0,1]], [[0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [1,-1,-1,1,-1,-1,1,-1,2], [1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1]], [[0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1]]]], [ # Z-class [09][07] [[4], [0,4], [0,0,4], [0,0,0,4], [0,0,0,0,4], [0,0,0,0,0,4], [0,0,0,0,0,0,4], [0,0,0,2,2,2,2,6], [2,2,2,0,0,2,2,1,6]], [[[1,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1]], [[0,0,1,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [-1,0,0,0,0,0,0,0,1]], [[0,0,0,-1,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0], [-1,-1,-1,-1,-1,-2,-2,2,2], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [-1,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0], [0,0,1,0,0,1,1,0,-1], [-1,-1,-1,-1,-1,-1,-1,1,1]], [[0,0,0,-1,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0], [-1,-1,-1,-1,-1,-2,-2,2,2], [-1,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,1,0,0,1,1,0,-1], [-1,-1,-1,-1,-1,-1,-1,1,2]]]], [ # Z-class [09][08] [[3], [-1,3], [-1,-1,3], [0,0,0,3], [0,0,0,-1,3], [0,0,0,-1,-1,3], [-1,1,1,1,-1,1,3], [1,-1,1,1,1,-1,0,3], [1,1,-1,-1,1,1,0,0,3]], [[[1,1,1,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,-1,-1,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1]], [[0,1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,1,0,0]], [[0,0,1,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,1,0,0]], [[0,-1,-1,0,0,0,1,0,0], [0,1,1,1,0,1,-1,0,0], [0,0,0,-1,0,-1,1,0,0], [0,0,0,0,-1,-1,0,0,1], [-1,-1,0,0,0,0,0,0,1], [1,1,0,0,1,1,0,0,-1], [1,1,1,0,0,0,0,0,0], [-1,-1,-1,-1,-1,-1,1,1,1], [0,0,0,1,1,1,0,0,0]]]], [ # Z-class [09][09] [[4], [2,4], [2,2,4], [2,1,1,4], [1,2,1,2,4], [1,1,2,2,2,4], [2,1,1,2,1,1,4], [1,2,1,1,2,1,2,4], [1,1,2,-1,1,0,0,2,4]], [[[1,0,0,0,0,0,0,0,0], [1,0,0,-1,1,0,0,0,-1], [1,-1,1,-1,1,0,0,0,-1], [0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [1,-1,0,-1,1,0,0,1,-1], [1,-1,0,-1,1,0,0,0,0]], [[0,1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0], [-1,1,-1,1,-1,1,1,-1,2], [0,1,-1,0,-1,1,1,-1,1]], [[0,0,1,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,1,0,0,0,0,0], [-1,1,-1,1,-1,1,1,-1,2], [0,0,0,0,0,0,0,1,0], [1,-1,1,-1,1,-1,0,1,-1]], [[1,-1,0,0,0,0,-1,1,0], [0,0,0,0,0,0,-1,1,0], [0,0,0,1,-1,0,-1,1,0], [1,-2,2,-1,1,-1,-1,2,-2], [1,-1,1,-1,1,-1,-1,2,-2], [1,-1,1,-1,0,0,-1,2,-2], [0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1,0], [0,1,-1,1,-1,0,0,0,1]]]], [ # Z-class [09][10] [[4], [2,4], [2,2,4], [2,1,1,4], [1,2,1,2,4], [1,1,2,2,2,4], [2,1,1,2,1,1,4], [1,2,1,1,2,1,2,4], [1,1,2,1,1,2,2,2,4]], [[[0,1,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,1]], [[-1,1,0,0,0,0,0,0,0], [0,1,-1,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0], [0,0,0,-1,1,0,0,0,0], [0,0,0,0,1,-1,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,1,0]], [[1,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,1,0,0], [0,1,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,1,0], [0,0,1,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,1]]]], [ # Z-class [09][11] [[9], [-3,9], [-3,-3,9], [-3,1,1,9], [1,-3,1,-3,9], [1,1,-3,-3,-3,9], [-3,1,1,-3,1,1,9], [1,-3,1,1,-3,1,-3,9], [1,1,-3,1,1,-3,-3,-3,9]], [[[0,1,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0], [1,1,1,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0], [0,0,0,1,1,1,0,0,0], [0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,1,1,1]], [[1,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,1,0,0], [0,1,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,1,0], [0,0,1,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,1]]]], [ # Z-class [09][12] [[6], [-2,6], [-2,-2,6], [3,-1,-1,6], [-1,3,-1,-2,6], [-1,-1,3,-2,-2,6], [3,-1,-1,1,1,1,6], [-1,3,-1,1,1,1,2,6], [-1,-1,3,1,1,1,2,2,6]], [[[0,0,0,0,0,0,0,0,1], [0,0,1,0,0,-1,1,0,-1], [0,1,0,0,-1,0,0,0,0], [0,0,0,-1,-1,-1,0,0,1], [1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0], [0,1,-1,0,-1,0,0,-1,1]], [[-1,-1,-1,1,1,1,0,0,0], [0,1,0,0,-1,0,0,-1,1], [0,0,1,0,0,-1,0,1,-1], [0,0,0,1,1,1,0,0,0], [0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,-1,0,0,0], [0,-1,-1,1,1,1,-1,0,0], [1,0,0,0,0,0,-1,0,1], [1,0,0,0,0,0,-1,1,0]], [[1,0,0,0,0,0,0,0,0], [0,0,0,-1,-1,-1,0,1,0], [0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0], [0,-1,0,-1,0,-1,0,1,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1]]]], [ # Z-class [09][13] [[8], [4,8], [4,4,8], [0,0,0,8], [0,0,0,4,8], [0,0,0,4,4,8], [0,0,0,0,0,0,8], [0,0,0,0,0,0,4,8], [4,4,4,4,4,4,4,4,9]], [[[1,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1]], [[0,0,-1,0,0,0,0,0,0], [0,1,-1,0,0,0,0,0,0], [1,0,-1,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,1]], [[0,0,0,-1,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,-1,0,0,0], [-1,-1,-1,-1,-1,-1,-1,-2,4], [-1,-1,-1,-1,-1,-1,-1,-1,4], [-1,-1,-1,-1,-1,-1,-2,-1,4], [0,1,-1,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,0], [-1,0,-1,-1,-1,-1,-1,-1,3]], [[0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1]]]], [ # Z-class [09][14] [[6], [-2,6], [-2,-2,6], [3,-1,-1,6], [-1,3,-1,-2,6], [-1,-1,3,-2,-2,6], [3,-1,-1,3,-1,-1,6], [-1,3,-1,-1,3,-1,-2,6], [-1,-1,3,-1,-1,3,-2,-2,6]], [[[0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1]], [[-1,0,0,1,0,0,0,0,0], [0,-1,0,0,1,0,0,0,0], [0,0,-1,0,0,1,0,0,0], [0,0,0,1,0,0,-1,0,0], [0,0,0,0,1,0,0,-1,0], [0,0,0,0,0,1,0,0,-1], [0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0]], [[0,1,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0], [1,1,1,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0], [0,0,0,1,1,1,0,0,0], [0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,1,1,1]]]], [ # Z-class [09][15] [[9], [-1,9], [-1,-1,9], [-1,-1,-1,9], [-1,-1,-1,-1,9], [-1,-1,-1,-1,-1,9], [-1,-1,-1,-1,-1,-1,9], [-1,-1,-1,-1,-1,-1,-1,9], [-1,-1,-1,-1,-1,-1,-1,-1,9]], [[[0,1,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,-1], [1,1,1,1,1,1,1,1,1]]]], [ # Z-class [09][16] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2]], [[[0,1,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1]], [[-1,1,0,0,0,0,0,0,0], [0,1,-1,0,0,0,0,0,0], [0,1,0,-1,0,0,0,0,0], [0,1,0,0,-1,0,0,0,0], [0,1,0,0,0,-1,0,0,0], [0,1,0,0,0,0,-1,0,0], [0,1,0,0,0,0,0,-1,0], [0,1,0,0,0,0,0,0,-1], [0,1,0,0,0,0,0,0,0]]]], [ # Z-class [09][17] [[8], [3,8], [3,3,8], [3,3,3,8], [3,3,3,3,8], [3,3,3,3,3,8], [3,3,3,3,3,3,8], [3,3,3,3,3,3,3,8], [-3,-3,2,2,2,2,2,2,8]], [[[1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1], [0,-1,1,0,0,0,0,0,-1], [0,-1,0,1,0,0,0,0,-1], [0,-1,0,0,1,0,0,0,-1], [0,-1,0,0,0,1,0,0,-1], [0,-1,0,0,0,0,1,0,-1], [0,-1,0,0,0,0,0,1,-1], [0,-1,0,0,0,0,0,0,0]], [[0,-1,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,-1,0], [-3,-3,1,1,1,1,1,1,-4], [-1,0,1,0,0,0,0,0,-1]]]], [ # Z-class [09][18] [[4], [2,4], [2,2,4], [2,2,2,4], [2,2,2,2,4], [2,2,2,2,2,4], [2,2,2,2,2,2,4], [2,2,2,2,2,2,2,4], [0,0,0,2,2,2,2,2,5]], [[[-1,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,0], [-1,0,1,0,0,0,0,0,0], [-1,0,0,1,0,0,0,0,0], [-1,0,0,0,1,0,0,0,0], [-1,0,0,0,0,1,0,0,0], [-1,0,0,0,0,0,1,0,0], [-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1]], [[0,-1,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,-1,0], [1,1,1,-1,-1,-1,-1,-1,2], [1,1,1,0,-1,-1,-1,-1,1]]]], [ # Z-class [09][19] [[12], [2,12], [2,-3,12], [-3,2,2,12], [3,3,-2,3,12], [3,3,3,-2,2,12], [-3,-3,2,2,3,3,12], [-2,3,3,3,2,-3,-2,12], [3,-2,-2,3,2,-3,3,-3,12]], [[[1,-1,-1,1,0,0,0,0,-1], [0,0,0,0,0,-1,0,0,0], [0,-1,-1,0,0,1,0,1,0], [-1,0,1,-1,1,0,-1,0,1], [0,0,0,0,0,0,-1,0,0], [0,0,-1,0,0,0,0,0,0], [-1,0,0,0,0,1,-1,0,1], [0,0,0,0,0,0,0,1,0], [-1,0,1,0,1,0,-1,-1,0]], [[1,-1,-1,1,-1,1,0,1,0], [0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,1], [0,0,0,0,1,0,0,0,0], [0,-1,-1,0,0,1,0,1,0], [-1,0,0,0,0,1,-1,0,1], [0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0], [1,-1,-1,1,0,0,0,0,-1]]]], [ # Z-class [09][20] [[4], [-2,4], [-1,2,4], [-1,2,0,4], [0,0,-1,-1,4], [-1,0,0,0,1,4], [1,1,0,2,0,0,4], [2,-1,1,-1,-1,1,1,4], [-1,2,1,1,-1,-1,2,0,4]], [[[0,1,0,-1,-1,0,1,-1,-1], [-1,0,-1,0,0,0,0,1,0], [0,1,-1,0,0,0,0,1,0], [-1,-1,0,0,0,0,1,0,0], [-1,0,0,0,0,-1,0,1,-1], [-1,0,0,0,1,-1,0,1,0], [-1,0,0,0,0,0,1,0,-1], [0,1,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0]], [[0,0,0,0,0,0,1,0,0], [0,0,0,1,0,0,-1,0,0], [-1,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,-1,1,0], [0,0,-1,0,0,0,0,0,0], [0,1,-1,-1,-1,0,0,0,0], [1,0,0,1,0,1,-1,0,1], [0,0,0,0,0,0,0,0,1], [1,-1,1,1,0,1,-1,-1,1]]]] ]; MakeImmutable( IMFList[9].matrices ); gap-4r6p5/grp/perf0.grp0000644000175000017500000002723212172557252013465 0ustar billbill############################################################################# ## #W perf0.grp GAP Groups Library Volkmar Felsch ## Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## All data is based on Holt/Plesken: Perfect Groups, OUP 1989 ## ## The 1097 nontrivial ## perfect groups of the library have been ordered by increasing ## size, and each library group G is charcterized by the pair [size, n], ## where size is the group size of G and n is its number within the list of ## library groups of that size. We denote this pair as the 'size number' of ## G. Another number associated with G is the Holt-Plesken number which ## consists of a triple [k,i,j] which means that, in the Holt-Plesken book, ## G occurs under the number (i,j) in class k. As G may occur in more than ## one of these classes it may have more than one such Holt-Plesken numbers. ## ## 489 of the library groups are given by explixit presentations on file. ## The essential information about each ot these group is available in form ## of a function which allows to construct the group as a finitely presented ## group. The list of all these functions has been broken into 12 parts ## which are provided in 12 separate secondary files. Whenever a group is ## needed and the associated function is not available, the corresponding ## part of the list will be loaded into the list PERFFun. ## ## The record PERFRec provides certain reference lists and some additional ## information. It contains the following components: ## ## The following components of PERFRec are general lists of different ## lengths. ## ## PERFRec.covered ## is a list which in its n-th entry provides the number of perfect ## group sizes covered by the first n function files. It is needed by ## subroutine PERFLoad. ## ## PERFRec.notKnown ## is a list of all sizes less than 10^6 for which the perfect groups ## have not yet been determined. It is needed by subroutine ## NumberPerfectGroups. ## ## PERFRec.notAvailable ## is a list of all sizes less than 10^6 for which the perfect groups ## are known, but not yet in the library. It is needed by subroutines ## DisplayInformationPerfectGroups and NumberPerfectLibraryGroups. ## ## PERFRec.sizeNumberSimpleGroup ## is an ordered list of the 'size numbers' of all nonabelian simple ## groups which occur as composition factor of any library group. ## ## PERFRec.nameSimpleGroup ## is a list which contains one or two names (as text strings) for ## each simple group in the preceding list. ## ## PERFRec.numberSimpleGroup ## is a list which, for each simple group name in the preceding list, ## contains the number of the respective group with respect to the ## list PERFRec.sizeNumberSimpleGroup. ## ## PERFRec.sizes ## is an ordered list of all occurring group sizes. ## ## The remaining lists are all parallel to the preceding ## list of all occurring group sizes. We assume in the following that ## PERFRec.sizes[i] = s(i). ## ## PERFRec.number[i] ## is the number of perfect groups of size s(i). ## ## PERFGRP is the actual storage of groups. It is a list whose i-th entry ## is a list of all perfect groups of size s(i). (The list might be longer ## than number[i], then this group is just used as intermediate storage.) ## Each group is represented either by 'fail' if no information is ## available or by a list l giving information about this group. ## We list the entries of 'l': ## ## l[1] (source) information on how to construct the group. It is of one of ## the following forms: ## [1,namesgens,wordfunc,subgrpindices] where namesgens is a list of ## characters giving names for the generators, ## wordfunc is a function that gets |namesgens| free generators as ## arguments and returns a list [relators,subgrpgens], where relators ## are defining relators and subgrpgens is a list whose entries are ## lists of subgroup generators. (It is a function to allow storage ## of *terms* in unexpanded form.) ## subgrpindices is a list that gives the indices of the subgroups ## defined in wordfunc. ## A further component 'auxiliaryGens' might be added. ## ## [2,,,,], if G is given as a direct product, ## ## [3,,,,,,...], if G is given ## as a central product, ## ## [4,,,,,] or ## ## [4,,,,,,,], if G is given as ## a subdirect product. ## ## The entries 2.. might be missing if the group is not actually a library ## group but only used as part of some construction. ## ## l[2] (description) ## is a descriptive name as given in the Holt-Plesken book. ## ## l[3] (hpNumber) ## is either a class ## number k or a list [k,i,j] or [k,i,j,k2,...,kn]. The tripel [k,i,j] ## means that the respective group is listed in the k-th class of the ## Holt-Plesken book under the number (i,j). If the group also occurs ## in some additional classes, then their numbers are given as ## k2, ..., kn. ## ## l[4] (centre) ## gives the size of the groups centre, a negative index indicating the ## group is simple or quasisimple ## ## l[5] (simpleFactors) ## is the 'size number' ## (if there is only one) or a list of the 'size numbers' (if there is ## more than one) of its nonabelian composition factors. ## ## l[6] (orbitSize) ## is a list of ## the orbit sizes of the faithful permutation representation of G ## which is offered by the library or, if that representation is ## transitive, i. e., if there is only one orbit, just the size of ## that orbit. ## PERFRec := rec(length:=331); PERFRec.covered := [38,59,70,71,80,113,151,158,201,249,295,331]; IsSSortedList( PERFRec.covered ); PERFRec.notKnown := [ 61440,122880,172032,245760,344064,491520,688128,983040]; IsSSortedList( PERFRec.notKnown ); PERFRec.notAvailable := [86016,368640,737280]; IsSSortedList( PERFRec.notAvailable ); PERFRec.nameSimpleGroup := [ "A(5)","A(6)","A(7)","A(8)","A(9)","A5","A6","A7","A8","A9","J(1)", "J(2)","J1","J2","L(2,101)","L(2,103)","L(2,107)","L(2,109)", "L(2,11)","L(2,113)","L(2,121)","L(2,125)","L(2,13)","L(2,16)", "L(2,17)","L(2,19)","L(2,23)","L(2,25)","L(2,27)","L(2,29)", "L(2,31)","L(2,32)","L(2,37)","L(2,4)","L(2,41)","L(2,43)", "L(2,47)","L(2,49)","L(2,5)","L(2,53)","L(2,59)","L(2,61)", "L(2,64)","L(2,67)","L(2,7)","L(2,71)","L(2,73)","L(2,79)", "L(2,8)","L(2,81)","L(2,83)","L(2,89)","L(2,9)","L(2,97)","L(3,2)", "L(3,3)","L(3,4)","L(3,5)","L2(101)","L2(103)","L2(107)","L2(109)", "L2(11)","L2(113)","L2(121)","L2(125)","L2(13)","L2(16)","L2(17)", "L2(19)","L2(23)","L2(25)","L2(27)","L2(29)","L2(31)","L2(32)", "L2(37)","L2(4)","L2(41)","L2(43)","L2(47)","L2(49)","L2(5)", "L2(53)","L2(59)","L2(61)","L2(64)","L2(67)","L2(7)","L2(71)", "L2(73)","L2(79)","L2(8)","L2(81)","L2(83)","L2(89)","L2(9)", "L2(97)","L3(2)","L3(3)","L3(4)","L3(5)","M(11)","M(12)","M(22)", "M11","M12","M22","S(4,4)","Sp4(4)","Sz(8)","U(3,3)","U(3,4)", "U(3,5)","U(4,2)","U3(3)","U3(4)","U3(5)","U4(2)"]; IsSSortedList( PERFRec.nameSimpleGroup ); PERFRec.numberSimpleGroup := [ 1,3,8,19,38,1,3,8,19,38,36,50,36,50,48,49,51,52,5,53,54,55,6,10,7,9, 13,14,16,17,18,24,21,1,25,26,27,28,1,30,32,33,41,35,2,37,39,40,4,42, 43,44,3,47,2,11,20,45,48,49,51,52,5,53,54,55,6,10,7,9,13,14,16,17,18, 24,21,1,25,26,27,28,1,30,32,33,41,35,2,37,39,40,4,42,43,44,3,47,2,11, 20,45,15,31,46,15,31,46,56,56,23,12,29,34,22,12,29,34,22]; PERFRec.sizeNumberSimpleGroup := [ [60,1],[168,1],[360,1],[504,1],[660,1],[1092,1],[2448,1],[2520,1], [3420,1],[4080,1],[5616,1],[6048,1],[6072,1],[7800,1],[7920,1], [9828,1],[12180,1],[14880,1],[20160,4],[20160,5],[25308,1],[25920,1], [29120,1],[32736,1],[34440,1],[39732,1],[51888,1],[58800,1],[62400,1], [74412,1],[95040,1],[102660,1],[113460,1],[126000,1],[150348,1], [175560,1],[178920,1],[181440,1],[194472,1],[246480,1],[262080,1], [265680,1],[285852,1],[352440,1],[372000,1],[443520,1],[456288,1], [515100,1],[546312,1],[604800,1],[612468,1],[647460,1],[721392,1], [885720,1],[976500,1],[979200,1]]; IsSSortedList( PERFRec.sizeNumberSimpleGroup ); PERFRec.sizes := [ 1,60,120,168,336,360,504,660,720,960,1080,1092,1320,1344,1920,2160, 2184,2448,2520,2688,3000,3420,3600,3840,4080,4860,4896,5040,5376, 5616,5760,6048,6072,6840,7200,7500,7560,7680,7800,7920,9720,9828, 10080,10752,11520,12144,12180,14400,14520,14580,14880,15000,15120, 15360,15600,16464,17280,19656,20160,21504,21600,23040,24360,25308, 25920,28224,29120,29160,29760,30240,30720,32256,32736,34440,34560, 37500,39600,39732,40320,43008,43200,43320,43740,46080,48000,50616, 51840,51888,56448,57600,57624,58240,58320,58800,60480,61440,62400, 64512,64800,65520,68880,69120,74412,75000,77760,79200,79464,79860, 80640,84672,86016,86400,87480,92160,95040,96000,100920,102660,103776, 110880,112896,113460,115200,115248,115320,116480,117600,120000,120960, 122472,122880,126000,129024,129600,131040,131712,138240,144060,146880, 148824,150348,151200,151632,155520,158400,159720,160380,161280,169344, 172032,174960,175560,178920,180000,181440,183456,184320,187500,190080, 192000,194472,201720,205200,205320,216000,221760,223608,225792,226920, 230400,232320,233280,237600,240000,241920,243000,244800,244944,245760, 246480,254016,258048,259200,262080,262440,263424,265680,276480,285852, 288120,291600,293760,300696,302400,311040,320760,322560,332640,336960, 344064,345600,352440,357840,360000,362880,363000,364320,366912,367416, 368640,369096,372000,375000,378000,384000,387072,388800,388944,393120, 393660,410400,411264,411540,417720,423360,432000,435600,443520,446520, 447216,450000,451584,453600,456288,460800,460992,464640,466560,468000, 475200,480000,483840,489600,491520,492960,504000,515100,516096,518400, 524880,531360,544320,546312,550368,552960,571704,574560,583200,587520, 589680,600000,604800,604920,607500,612468,622080,626688,633600,645120, 647460,665280,673920,675840,677376,685440,688128,691200,693120,699840, 704880,712800,720720,721392,725760,728640,729000,730800,733824,734832, 737280,748920,768000,774144,777600,786240,787320,806736,816480,820800, 822528,823080,846720,864000,871200,874800,878460,881280,885720,887040, 892800,900000,903168,907200,912576,921600,921984,929280,933120,936000, 937500,943488,950400,950520,960000,962280,967680,976500,979200,979776, 983040,987840]; IsSSortedList( PERFRec.sizes ); PERFRec.number := [ 1,1,1,1,1,1,1,1,1,2,1,1,1,2,7,1,1,1,1,3,1,1,1,7,1,2,1,1,1,1,1,1,1, 1,2,2,1,5,1,1,3,1,1,9,4,1,1,1,1,1,1,3,1,7,1,1,1,1,5,22,1,3,1,1,1, 1,1,4,1,1,37,2,1,1,4,1,1,1,4,25,3,1,1,1,3,1,1,1,2,2,2,1,2,1,3,0,1, 4,1,1,1,4,1,4,4,3,1,1,6,1,52,1,8,2,1,3,1,1,1,1,1,1,15,3,1,1,1,4,5, 2,0,1,6,4,3,2,2,1,1,1,1,1,1,18,1,3,1,12,1,0,8,1,1,1,3,1,19,1,1,2,1, 1,1,1,1,3,1,2,1,26,3,3,1,17,5,1,1,2,0,1,1,4,3,2,7,1,1,2,1,3,2,3,1, 3,18,1,27,1,1,0,3,1,1,1,6,1,1,3,3,46,1,1,11,1,1,2,2,1,1,4,3,1,1,1,1, 3,1,2,1,1,3,8,1,1,25,4,3,18,1,4,17,6,1,0,1,1,1,1,1,9,1,1,1,1,19,1,1, 7,1,1,2,3,1,4,1,12,1,2,41,1,1,1,3,2,1,0,23,3,2,1,1,1,1,2,3,2,1,1,3, 54,1,13,2,5,3,16,2,2,1,3,2,3,3,2,1,2,1,1,3,1,7,6,4,1,23,8,2,21,3,8,1, 2,1,12,1,20,1,1,4,0,1]; PERFGRP := []; PERFSELECT:=BlistList([1..PERFRec.length],[]); # what have we loaded ############################################################################# ## #E perf0.grp . . . . . . . . . . . . . . . . . . . . . . . . . ends here ## gap-4r6p5/grp/imf11.grp0000644000175000017500000002103412172557252013360 0ustar billbill############################################################################# ## #A imf11.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Z-class representative of the irreducible ## maximal finite integral matrix groups of dimension 11, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Z-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 11. ## IMFList[11].matrices := [ [ # Z-class [11][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1]], [[[0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0]], [[0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0]]]], [ # Z-class [11][02] [[2], [0,2], [1,0,2], [0,1,0,2], [0,0,1,0,2], [0,0,0,1,0,2], [0,0,0,0,1,0,2], [0,0,0,0,0,1,0,2], [0,0,0,0,0,0,1,0,2], [1,0,0,0,0,0,0,1,0,2], [0,1,0,0,0,0,0,0,1,0,2]], [[[1,0,-1,1,1,-1,-1,1,1,-1,0], [-1,0,1,0,-1,0,1,-1,-1,1,1], [1,0,-1,1,1,-1,-1,1,0,-1,0], [-1,0,1,0,-1,0,1,0,-1,0,1], [0,0,0,0,0,0,-1,0,0,0,0] , [0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,1,0,-1,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0], [0,-1,0,1,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,-1,0,1,0]], [[-1,-1,1,0,-1,0,1,0,-1,0,1], [0,0,0,0,1,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,1,0,-1,0,1,0,-1], [0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,1,0,-1,0,0], [0,1,-1,-1,1,0,-1,0,1,0,-1], [0,-1,0,0,0,0,1,0,-1,0,1], [0,0,-1,0,1,0,-1,0,0,0,0]]]], [ # Z-class [11][03] [[11], [-9,11], [7,-9,11], [-5,7,-9,11], [3,-5,7,-9,11], [-1,3,-5,7,-9,11], [-1,-1,3,-5,7,-9,11], [3,-1,-1,3,-5,7,-9,11], [-5,3,-1,-1,3,-5,7,-9,11], [7,-5,3,-1,-1,3,-5,7,-9,11], [-9,7,-5,3,-1,-1,3,-5,7,-9,11]], [[[0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0]], [[1,0,-1,-1,-1,0,0,0,1,0,0], [0,0,1,1,1,0,0,0,-1,0,1], [0,0,0,0,-1,0,0,0,1,0,-1], [0,0,0,0,0,-1,0,0,-1,0,1], [0,0,0,0,0,0,-1,0,1,0,-1], [0,0,0,0,0,0,0,-1,-1,0,1], [0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,-1,-1,0,0,0,1,0,0], [0,1,1,1,1,0,0,0,-1,0,0]]]], [ # Z-class [11][04] [[11], [-1,11], [-1,-1,11], [-1,-1,-1,11], [-1,-1,-1,-1,11], [-1,-1,-1,-1,-1,11], [-1,-1,-1,-1,-1,-1,11], [-1,-1,-1,-1,-1,-1,-1,11], [-1,-1,-1,-1,-1,-1,-1,-1,11], [-1,-1,-1,-1,-1,-1,-1,-1,-1,11], [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,11]], [[[0,-1,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,-1], [1,1,1,1,1,1,1,1,1,1,1]], [[1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0]]]], [ # Z-class [11][05] [[5], [2,5], [-1,2,5], [-1,-1,2,5], [-1,-1,-1,2,5], [-1,-1,-1,-1,2,5], [-1,-1,-1,-1,-1,2,5], [-1,-1,-1,-1,-1,-1,2,5], [-1,-1,-1,-1,-1,-1,-1,2,5], [-1,-1,-1,-1,-1,-1,-1,-1,2,5], [2,-1,-1,-1,-1,-1,-1,-1,-1,2,5]], [[[0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0]], [[1,0,1,0,1,0,1,0,0,1,0], [0,0,0,0,0,0,0,0,-1,1,-1], [0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,-1,1,-1,0,0], [0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,-1,1,-1,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0], [0,0,-1,1,-1,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0], [0,1,0,0,1,0,1,0,1,0,1]]]], [ # Z-class [11][06] [[9], [5,9], [1,5,9], [-3,1,5,9], [-3,-3,1,5,9], [-3,-3,-3,1,5,9], [-3,-3,-3,-3,1,5,9], [-3,-3,-3,-3,-3,1,5,9], [-3,-3,-3,-3,-3,-3,1,5,9], [1,-3,-3,-3,-3,-3,-3,1,5,9], [5,1,-3,-3,-3,-3,-3,-3,1,5,9]], [[[0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0]], [[-2,1,0,-1,1,-1,0,1,-1,0,1], [-1,1,1,-1,1,0,0,1,0,0,1], [0,0,1,-1,1,0,0,1,0,0,1], [0,0,1,-1,1,1,-1,1,0,0,1], [0,0,0,-1,1,0,-1,1,-1,0,0], [0,0,0,0,0,0,0,0,-1,1,-1], [1,-1,0,1,-1,0,0,0,0,0,-1], [1,-2,1,1,-2,1,0,-1,1,-1,0], [1,-1,0,1,-2,1,0,-1,1,-1,0], [0,0,-1,1,-1,0,1,-1,0,0,0], [-1,1,-1,0,0,0,0,0,0,0,0]]]], [ # Z-class [11][07] [[8], [5,8], [2,5,8], [-1,2,5,8], [-4,-1,2,5,8], [-4,-4,-1,2,5,8], [-4,-4,-4,-1,2,5,8], [-4,-4,-4,-4,-1,2,5,8], [-1,-4,-4,-4,-4,-1,2,5,8], [2,-1,-4,-4,-4,-4,-1,2,5,8], [5,2,-1,-4,-4,-4,-4,-1,2,5,8]], [[[0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0]], [[-2,0,1,0,-1,0,1,-1,-1,1,1], [-1,0,1,1,-1,0,1,0,-1,1,1], [0,0,0,1,0,-1,1,0,0,0,1], [0,0,0,1,-1,0,1,0,0,0,1], [1,-1,0,1,0,-1,1,1,0,-1,1], [1,-1,-1,1,0,-1,0,1,0,-2,1], [1,-1,-1,1,0,0,-1,1,0,-1,0], [1,0,-1,0,1,0,-2,1,1,-1,-1], [0,1,-1,-1,1,1,-2,0,1,0,-1], [-1,1,0,-1,0,1,-1,0,0,1,-1], [-1,0,1,-1,0,0,0,0,-1,1,0]]]], [ # Z-class [11][08] [[3], [2,3], [1,2,3], [0,1,2,3], [-1,0,1,2,3], [-2,-1,0,1,2,3], [-2,-2,-1,0,1,2,3], [-1,-2,-2,-1,0,1,2,3], [0,-1,-2,-2,-1,0,1,2,3], [1,0,-1,-2,-2,-1,0,1,2,3], [2,1,0,-1,-2,-2,-1,0,1,2,3]], [[[0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,-1,1,0,0,0,-1,0], [0,0,0,-1,0,1,0,0,-1,-1,1], [0,0,-1,0,0,1,0,-1,-1,0,1], [0,-1,0,0,0,1,-1,-1,0,0,1], [-1,0,0,0,0,0,-1,0,0,0,1]], [[-1,-1,0,0,1,0,-1,-1,0,1,1], [0,-1,0,0,1,1,-1,-1,0,1,1], [0,0,-1,0,1,1,0,-1,-1,1,1], [0,0,0,-1,1,1,0,0,-1,0,1], [0,0,0,0,0,1,0,0,0,-1,1], [0,1,0,0,-1,1,0,1,0,-1,0], [0,1,0,0,-1,0,0,1,0,-1,-1], [-1,1,1,0,-1,-1,0,1,1,-1,-1], [-1,0,1,1,-1,-1,-1,1,1,0,-1], [-1,0,0,1,0,-1,-1,0,1,1,-1], [-1,0,0,0,1,-1,-1,0,0,1,0]]]], [ # Z-class [11][09] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,1,0], [-1,0,0,0,0,0,0,0,0,1,0]], [[-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,1,0]]]] ]; MakeImmutable( IMFList[11].matrices ); gap-4r6p5/grp/imf15.grp0000644000175000017500000002366712172557252013402 0ustar billbill############################################################################# ## #A imf15.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Q-class representative of the irreducible ## maximal finite integral matrix groups of dimension 15, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Q-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 15. ## IMFList[15].matrices := [ [ # Q-class [15][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]], [[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [15][02] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0]]]], [ # Q-class [15][03] [[3], [-1,3], [1,-1,3], [1,1,-1,3], [1,1,-1,1,3], [-1,-1,0,-1,-1,3], [1,0,-1,1,1,-1,3], [1,-1,1,-1,0,1,-1,3], [1,-1,1,0,-1,1,-1,1,3], [0,1,1,0,0,-1,-1,0,0,3], [1,-1,0,1,0,-1,1,-1,0,-1,3], [-1,1,-1,0,1,1,0,0,-1,-1,-1,3], [1,0,1,1,0,0,-1,1,1,0,0,0,3], [1,0,1,0,1,0,-1,1,1,0,0,0,1,3], [0,-1,0,-1,-1,1,0,1,1,0,-1,0,-1,-1,3]], [[[-1,-1,0,0,0,-1,1,0,1,1,0,1,0,0,0], [1,1,1,0,1,1,-1,-1,-1,-1,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,1,1], [-1,0,1,0,1,0,1,0,1,0,0,0,0,0,0], [-1,0,0,0,0,0,0,1,0,0,1,0,0,0,0], [0,0,0,0,0,-1,0,0,1,0,0,1,0,0,0], [-1,0,0,0,0,0,1,1,0,1,1,0,0,0,0], [-1,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,1,0,-1,-1,0,0,-1,1,0,1], [0,-1,0,1,-1,-1,0,0,1,0,-1,1,-1,0,-1], [1,1,0,-1,0,1,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [-1,0,1,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,-1,-1,0,0,0,0,0,1,1,0,1,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,0,0,-1,0,0,0,0,0,0,0,0,0], [-1,0,1,1,0,0,1,1,0,0,0,0,0,0,0], [1,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0], [-1,-1,0,0,1,-1,0,0,1,0,0,0,0,0,0], [1,1,-1,-1,0,1,0,0,0,1,1,0,0,0,0], [0,-1,0,1,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,-1,-1,0,0,0,0,0,1,0,0,0], [1,0,-1,-1,0,0,0,-1,0,0,0,0,1,0,0], [1,0,0,0,0,-1,-1,0,1,-1,-1,0,-1,-1,-1], [-1,0,1,0,1,0,0,0,0,0,1,0,0,0,1]]]], [ # Q-class [15][04] [[3], [1,3], [0,-1,3], [0,1,-1,3], [0,-1,0,0,3], [0,0,0,-1,-1,3], [-1,-1,1,0,1,1,3], [0,0,-1,0,0,0,-1,3], [-1,-1,0,-1,0,1,1,-1,3], [0,1,0,0,0,1,1,-1,1,3], [0,-1,0,-1,0,1,1,1,1,0,3], [1,1,0,0,-1,0,-1,1,0,0,1,3], [0,0,-1,1,1,0,1,0,0,1,0,-1,3], [0,1,1,0,0,-1,0,0,-1,1,0,1,0,3], [0,0,0,-1,1,0,1,-1,1,1,1,0,1,1,3]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,1,-1,0,0,0], [0,0,0,0,-1,-1,1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,1,-1,0,0,0,0,0], [0,-1,-1,-1,0,0,1,0,-1,0,-1,1,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [-1,1,1,-1,0,-1,0,0,-1,1,0,1,1,-2,0], [0,-1,0,1,0,1,0,1,0,0,-1,0,-1,0,1], [0,0,0,0,0,1,0,0,0,-1,0,0,0,1,0], [0,0,1,0,0,0,0,1,0,0,-1,0,0,-1,1], [-1,0,1,0,0,0,-1,0,-1,1,0,0,0,-1,1], [0,1,0,0,0,0,1,0,0,-1,0,0,0,0,0], [0,1,1,0,0,0,-1,0,0,0,1,-1,0,0,0], [1,0,0,1,0,1,0,1,1,-1,-1,-1,-1,1,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,-1,1,1,1,0,0,-1,0,0,0], [-1,1,1,0,1,0,-1,0,-1,1,1,0,0,-1,0], [0,-1,0,1,0,0,0,0,-1,1,0,0,-1,-1,1], [0,0,-1,-1,0,0,1,-1,0,-1,0,1,1,1,-1], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,-1,0,1,0,1,-1,0,0,0,0,0,0,1,0], [0,0,-1,-1,0,0,1,-1,0,-1,0,0,0,1,-1], [0,1,0,0,0,0,1,0,0,-1,0,0,0,0,0], [1,-1,-1,0,0,1,1,0,1,-1,-1,0,0,2,-1], [1,0,-1,0,0,1,0,0,1,-1,0,-1,0,2,-1], [-1,0,1,0,0,0,0,0,-2,1,0,1,0,-2,1], [1,0,0,1,-1,0,1,2,1,0,-1,-1,-1,0,1], [1,-1,-1,0,-1,0,2,1,0,0,-2,0,-1,0,1]]]], [ # Q-class [15][05] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [0,0,0,0,0,2], [0,0,0,0,0,1,2], [0,0,0,0,0,1,1,2], [0,0,0,0,0,1,1,1,2], [0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0]], [[-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [15][06] [[3], [1,3], [1,1,3], [1,1,1,3], [1,1,1,1,3], [-1,1,0,0,0,3], [-1,0,1,0,0,1,3], [-1,0,0,1,0,1,1,3], [-1,0,0,0,1,1,1,1,3], [0,-1,1,0,0,-1,1,0,0,3], [0,-1,0,1,0,-1,0,1,0,1,3], [0,-1,0,0,1,-1,0,0,1,1,1,3], [0,0,-1,1,0,0,-1,1,0,-1,1,0,3], [0,0,-1,0,1,0,-1,0,1,-1,0,1,1,3], [0,0,0,-1,1,0,0,-1,1,0,-1,1,-1,1,3]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1], [0,0,0,0,0,0,0,-1,1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1], [0,0,0,-1,1,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,-1,0,1,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,-1,0,1,0,-1,0], [0,0,-1,0,1,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,1,0,0,-1,0,0,1,0,0,0], [-1,0,0,0,1,0,0,0,-1,0,0,0,0,0,0], [0,-1,0,0,1,0,0,0,0,0,0,-1,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,-1,0,0,0,0,0,0,0,0,0], [-1,0,1,0,0,0,-1,0,0,0,0,0,0,0,0], [-1,0,0,0,1,0,0,0,-1,0,0,0,0,0,0], [-1,0,0,1,0,0,0,-1,0,0,0,0,0,0,0], [0,-1,1,0,0,0,0,0,0,-1,0,0,0,0,0], [0,-1,0,0,1,0,0,0,0,0,0,-1,0,0,0], [0,-1,0,1,0,0,0,0,0,0,-1,0,0,0,0], [0,0,-1,0,1,0,0,0,0,0,0,0,0,-1,0], [0,0,-1,1,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,1,-1,0,0,0,0,0,0,0,0,0,1]]]] ]; MakeImmutable( IMFList[15].matrices ); gap-4r6p5/grp/imf23.grp0000644000175000017500000027300412172557252013371 0ustar billbill############################################################################# ## #A imf23.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Z-class representative of the irreducible ## maximal finite integral matrix groups of dimension 23, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Z-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 23. ## IMFList[23].matrices := [ [ # Z-class [23][01] [[23], [-1,23], [1,1,23], [1,1,-1,23], [1,1,-1,-1,23], [1,1,-1,-1,-1,23], [1,1,-1,-1,-1,-1,23], [1,1,-1,-1,-1,-1,-1,23], [1,1,-1,-1,-1,-1,-1,-1,23], [1,1,-1,-1,-1,-1,-1,-1,-1,23], [1,1,-1,-1,-1,-1,-1,-1,-1,-1,23], [1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,23], [1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,23], [1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,23], [1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,23], [1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,23], [1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,23], [1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,23], [1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,23], [1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,23], [1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,23], [-1,-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,23], [-1,-1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,-1,23]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,1]], [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Z-class [23][02] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]]]], [ # Z-class [23][03] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [-1,0,-1,0,-1,0,-1,-1,0,-1,0,-1,0,-1,0,0,0,0,6], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,-1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,-1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,-1,1,1,2], [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,-1,-1,-1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [1,0,1,-1,0,-1,0,1,-1,1,-1,1,-1,1,0,-1,0,-1,1,1,0,0,-1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [1,-1,1,-1,1,-1,1,1,-1,1,-1,1,-1,1,-1,-1,-1,-1,2,1,1,0,-1]], [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,1,0,1,-1,0,-1,-1,1,-1,1,-1,1,-1,1,1,0,1,-1,-1,0,-1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0]]]], [ # Z-class [23][04] [[6], [3,6], [3,3,6], [3,3,3,6], [3,3,3,3,6], [3,3,3,3,3,6], [3,3,3,3,3,3,6], [3,3,3,3,3,3,3,6], [3,3,3,3,3,3,3,3,6], [3,3,3,3,3,3,3,3,3,6], [3,3,3,3,3,3,3,3,3,3,6], [3,3,3,3,3,3,3,3,3,3,3,6], [3,3,3,3,3,3,3,3,3,3,3,3,6], [3,3,3,3,3,3,3,3,3,3,3,3,3,6], [3,3,3,3,3,3,3,3,3,3,3,3,3,3,6], [3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,6], [3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,6], [3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,6], [3,0,3,0,3,3,0,3,0,3,0,3,0,3,0,0,0,0,16], [3,0,3,0,3,3,0,3,0,3,0,3,0,0,0,0,0,0,13,16], [-3,0,-3,0,-3,-3,0,-3,0,-3,0,-3,0,0,0,0,0,0,-13,-13,16], [3,0,3,0,3,3,0,3,0,3,0,3,0,0,0,0,0,0,13,13,-13,16], [-3,0,-3,0,-3,-3,0,-3,0,-3,0,-3,0,0,0,0,0,0,-13,-13,13,-13,16]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,-1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,-1], [1,0,1,0,1,1,0,0,0,0,0,0,0,-2,0,-1,-1,0,1,-1,1,0,0], [1,0,0,0,1,1,0,1,0,0,0,0,0,-2,0,-1,-1,0,1,-1,1,0,0], [1,-1,1,-1,1,1,-1,1,-1,2,-1,2,-1,0,-1,0,0,-1,0,0,0,-1,1], [1,-1,1,0,1,1,0,1,0,0,0,0,0,-2,0,-1,-1,0,1,-1,1,0,0], [0,0,-1,0,-1,-1,0,-1,0,0,0,0,0,2,0,1,1,0,-1,1,-1,0,0]], [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,-1], [1,0,1,0,1,1,0,1,-1,1,-1,1,-1,-1,-1,0,-1,-1,1,0,1,-1,0], [1,0,1,-1,1,1,0,1,0,1,-1,1,-1,-1,-1,0,-1,-1,1,0,1,-1,0], [0,0,-1,0,-1,-1,0,-1,0,-1,1,-1,1,1,1,0,1,1,-1,0,-1,1,0], [1,0,0,0,1,1,0,1,0,1,-1,1,-1,-1,-1,0,-1,-1,1,0,1,-1,0], [-1,1,-1,0,-1,-1,0,-1,0,-1,1,-1,1,1,1,0,1,1,-1,0,-1,1,0]]]], [ # Z-class [23][05] [[4], [-2,4], [-2,2,4], [-2,2,2,4], [-2,2,2,2,4], [-2,2,2,2,2,4], [-2,2,2,2,2,2,4], [-2,2,2,2,2,2,2,4], [-2,2,2,2,2,2,2,2,4], [-2,2,2,2,2,2,2,2,2,4], [-2,2,2,2,2,2,2,2,2,2,4], [-2,2,2,2,2,2,2,2,2,2,2,4], [-2,2,2,2,2,2,2,2,2,2,2,2,4], [-2,2,2,2,2,2,2,2,2,2,2,2,2,4], [-2,2,2,2,2,2,2,2,2,2,2,2,2,2,4], [2,0,-2,-2,0,-2,0,-2,0,-2,0,0,0,0,0,9], [-2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,4], [-2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,4], [-2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,4], [-2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,4], [2,0,-2,-2,0,-2,0,-2,0,0,0,0,0,0,0,7,0,0,0,0,9], [-2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,0,2,2,2,2,0,4], [2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,0,-2,-2,-2,-2,0,-2,4]], [[[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [1,0,-1,-1,0,-1,0,-1,0,0,0,1,0,1,0,0,1,0,1,1,-1,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [-2,-1,2,2,-1,2,-1,2,-1,2,-1,-1,-1,0,-1,3,0,-1,0,0,0,-1,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [1,0,-1,-1,0,-1,0,-1,0,0,0,0,1,0,1,0,0,1,0,1,-1,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,-1,-1,0,-1,0,-1,0,0,0,0,0,0,1,0,0,1,0,1,-1,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Z-class [23][06] [[6], [3,6], [3,3,6], [3,3,3,6], [3,3,3,3,6], [3,3,3,3,3,6], [3,3,3,3,3,3,6], [3,3,3,3,3,3,3,6], [3,3,3,3,3,3,3,3,6], [3,3,3,3,3,3,3,3,3,6], [3,3,0,3,0,3,0,0,0,0,10], [3,3,3,3,3,3,3,3,3,3,0,6], [3,3,3,3,3,3,3,3,3,3,0,3,6], [3,3,3,3,3,3,3,3,3,3,0,3,3,6], [3,3,3,3,3,3,3,3,3,3,0,3,3,3,6], [3,3,3,3,3,3,3,3,3,3,0,3,3,3,3,6], [3,3,3,3,3,3,3,3,3,3,0,3,3,3,3,3,6], [3,3,3,3,3,3,3,3,3,3,0,3,3,3,3,3,3,6], [3,3,3,3,3,3,3,3,3,3,0,3,3,3,3,3,3,3,6], [3,3,3,3,3,3,3,3,3,3,0,3,3,3,3,3,3,3,3,6], [-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,0,-3,-3,-3,-3,-3,-3,-3,-3,-3,6], [3,3,3,3,3,3,3,3,3,3,0,3,3,3,3,3,3,3,3,3,-3,6], [-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,0,-3,-3,-3,-3,-3,-3,-3,-3,-3,3,-3,6]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,-1], [1,1,0,1,0,1,0,0,0,0,-1,0,0,0,0,0,-1,0,-1,0,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [5,5,-1,5,-1,5,-1,-1,-1,-1,-6,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,-1,2], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,-1], [1,1,0,1,0,1,0,0,0,0,-1,0,0,0,0,0,0,-1,0,-1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Z-class [23][07] [[21], [0,16], [8,-8,16], [8,-8,8,16], [8,-8,8,8,16], [8,-8,8,8,8,16], [8,-8,8,8,8,8,16], [0,8,-8,-8,-8,-8,-8,16], [8,-8,8,8,8,8,8,-8,16], [8,-8,8,8,8,8,8,-8,8,16], [8,-8,8,8,8,8,8,-8,8,8,16], [8,-8,8,8,8,8,8,-8,8,8,8,16], [8,-8,8,8,8,8,8,-8,8,8,8,8,16], [8,-8,8,8,8,8,8,-8,8,8,8,8,8,16], [8,-8,8,8,8,8,8,-8,8,8,8,8,8,8,16], [8,-8,8,8,8,8,8,-8,8,8,8,8,8,8,8,16], [8,-8,8,8,8,8,8,-8,8,8,8,8,8,8,8,8,16], [8,-8,8,8,8,8,8,-8,8,8,8,8,8,8,8,8,8,16], [8,-8,8,8,8,8,8,-8,8,8,8,8,8,8,8,8,8,8,16], [8,-8,8,8,8,8,8,-8,8,8,8,8,8,8,8,8,8,8,8,16], [8,-8,8,8,8,8,8,-8,8,8,8,8,8,8,8,8,8,8,8,8,16], [8,-8,8,8,8,8,8,-8,8,8,8,8,8,8,8,8,8,8,8,8,8,16], [-8,8,-8,-8,-8,-8,-8,8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,-8,16]], [[[7,-6,-1,-1,-1,-1,-1,-7,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1], [8,-7,-1,-1,-1,-1,-1,-7,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Z-class [23][08] [[11], [5,11], [-5,-5,11], [-5,-5,5,11], [-5,1,5,-1,11], [-5,1,-1,-1,5,11], [-5,1,-1,-1,5,5,11], [-5,1,-1,-1,5,5,5,11], [-5,1,-1,-1,5,5,5,5,11], [-5,1,-1,-1,5,5,5,5,5,11], [-5,1,-1,-1,5,5,5,5,5,5,11], [-5,1,-1,-1,5,5,5,5,5,5,5,11], [-5,1,-1,-1,5,5,5,5,5,5,5,5,11], [-5,1,-1,-1,5,5,5,5,5,5,5,5,5,11], [-5,1,-1,-1,5,5,5,5,5,5,5,5,5,5,11], [-5,1,-1,-1,5,5,5,5,5,5,5,5,5,5,5,11], [-5,1,-1,-1,5,5,5,5,5,5,5,5,5,5,5,5,11], [-5,1,-1,-1,5,5,5,5,5,5,5,5,5,5,5,5,5,11], [-5,1,-1,-1,5,5,5,5,5,5,5,5,5,5,5,5,5,5,11], [-5,1,-1,-1,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,11], [-5,1,-1,-1,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,11], [-5,1,-1,-1,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,11], [5,-1,1,1,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,11]], [[[-9,1,-8,-1,7,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0], [-10,1,-8,-1,7,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1], [9,-1,8,1,-7,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,-1], [9,-1,8,1,-7,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,-1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [-1,0,-1,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [-1,0,-1,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [-1,0,-1,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,-1,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,-1,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,-1,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,-1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1]], [[1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [-1,0,-1,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [-1,0,-1,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [-1,0,-1,0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [-1,0,-1,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,-1,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,-1,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,-1,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,-1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1]]]], [ # Z-class [23][09] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]], [[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Z-class [23][10] [[2], [1,2], [0,1,2], [0,0,1,2], [0,0,0,1,2], [0,0,0,0,1,2], [0,0,0,0,0,1,2], [0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,4]], [[[1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,-1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,2,-2,2,-2,2,-2,2,-2,2,-2,2,-2,2,-2,2,-2,2,-2,2,-2,1], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Z-class [23][11] [[4], [-4,8], [4,-8,12], [-4,8,-12,16], [4,-8,12,-16,20], [-4,8,-12,16,-20,24], [4,-8,12,-16,20,-24,28], [-4,8,-12,16,-20,24,-28,32], [4,-8,12,-16,20,-24,28,-32,36], [-4,8,-12,16,-20,24,-28,32,-36,40], [4,-8,12,-16,20,-24,28,-32,36,-40,44], [-4,8,-12,16,-20,24,-28,32,-36,40,-44,48], [4,-8,12,-16,20,-24,28,-32,36,-40,44,-48,52], [-4,8,-12,16,-20,24,-28,32,-36,40,-44,48,-52,56], [4,-8,12,-16,20,-24,28,-32,36,-40,44,-48,52,-56,60], [-4,8,-12,16,-20,24,-28,32,-36,40,-44,48,-52,56,-60,64], [4,-8,12,-16,20,-24,28,-32,36,-40,44,-48,52,-56,60,-64,68], [-4,8,-12,16,-20,24,-28,32,-36,40,-44,48,-52,56,-60,64,-68,72], [4,-8,12,-16,20,-24,28,-32,36,-40,44,-48,52,-56,60,-64,68,-72,76], [-4,8,-12,16,-20,24,-28,32,-36,40,-44,48,-52,56,-60,64,-68,72,-76,80], [4,-8,12,-16,20,-24,28,-32,36,-40,44,-48,52,-56,60,-64,68,-72,76,-80,84], [-4,8,-12,16,-20,24,-28,32,-36,40,-44,48,-52,56,-60,64,-68,72,-76,80,-84, 88], [2,-4,6,-8,10,-12,14,-16,18,-20,22,-24,26,-28,30,-32,34,-36,38,-40,42,-44, 23]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,-2], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,-2], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1]], [[1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-2,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,2,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-2,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,2,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-2,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,2,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-2,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,2,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,-2,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,2,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,-2,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,2,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,-2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Z-class [23][12] [[4], [0,4], [0,0,4], [0,0,0,4], [0,0,0,0,4], [0,0,0,0,0,4], [0,0,0,0,0,0,4], [0,0,0,0,0,0,0,4], [0,2,0,0,-2,2,0,-2,7], [-2,0,0,-2,0,2,0,-2,3,7], [0,0,0,2,2,2,-2,-2,1,1,7], [2,0,2,2,0,0,-2,0,1,-1,3,7], [0,2,0,0,0,0,-2,0,3,-1,1,1,7], [0,-2,2,2,0,0,-2,2,-3,-3,1,3,-1,7], [-2,0,-2,-2,-2,0,0,-2,3,3,-1,-3,1,-3,7], [0,0,-2,0,-2,0,-2,-2,3,1,1,1,1,-1,3,7], [0,-2,-2,0,0,0,0,-2,-1,1,1,-1,-3,-1,1,3,7], [0,0,-2,-2,0,0,2,0,-1,1,-3,-3,-3,-3,1,1,3,7], [2,0,0,0,-2,0,-2,0,3,-1,-1,3,3,1,1,3,-1,-1,7], [0,-2,0,0,0,-2,0,-2,-1,1,1,1,-3,1,1,1,1,-1,-1,7], [-2,-2,0,2,0,0,0,-2,-1,1,3,-1,-1,1,1,-1,1,-3,-3,3,7], [0,-2,-2,-2,-2,-2,0,0,-1,1,-3,-1,-3,-1,3,3,3,3,1,3,-1,7], [-2,-2,0,0,-2,0,2,2,-1,1,-3,-1,-3,1,1,-1,-1,1,-1,1,1,3,7]], [[[0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,-1,-1,1], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,-1,0,0,0,0,-1,0,0,-1,1,-1,0,0,0,-1,0,0,-1,0,0,-1], [0,-1,-1,0,0,0,0,-1,1,0,-1,1,0,1,0,0,-1,0,-2,-1,0,1,-1], [0,-1,0,0,-1,-1,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,-1,-1,0], [0,0,-1,0,-1,0,0,0,-1,1,-1,1,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,1,0,0,-1,0,-1,0,-1,1,-1,-1,1,0,0,0,0,0,0,-1,0], [0,0,0,0,1,0,-1,0,0,0,0,0,-1,-1,0,0,0,0,1,0,0,-1,1], [0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,1,0,1,1,0,-2,1], [0,0,0,-1,-1,-1,1,1,-1,1,1,0,0,0,0,0,0,0,1,0,0,-1,0], [0,0,0,0,0,0,1,0,0,0,1,-1,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,1,-1,0,0,0,-1,1,0,0,0,0,0,0,-1,0,0,0,0,1,-1], [0,1,0,0,0,1,-1,0,-1,0,-1,0,0,-1,0,0,1,-1,1,1,0,-1,1], [0,1,0,0,1,1,-2,-1,1,-1,-1,0,0,0,0,-1,1,0,0,1,0,0,1], [0,0,0,0,1,1,-1,0,1,-1,-2,1,0,0,0,0,0,0,-1,0,1,1,-1], [0,0,0,0,-1,0,1,1,-1,1,0,0,1,0,0,0,1,0,1,1,0,-1,0], [1,1,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,1], [0,0,0,0,0,0,0,-1,0,0,1,0,-1,0,0,0,-1,0,0,-1,0,1,0], [1,1,1,1,0,0,-1,0,0,0,0,-1,1,0,0,0,1,0,0,1,0,0,1], [0,-1,0,1,-1,0,0,-1,0,0,0,0,0,0,0,0,-1,0,-1,-1,0,1,-1]], [[1,0,0,0,0,-1,-1,-1,0,0,1,-1,0,0,0,0,0,0,0,0,-1,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,1,-1,-1,1], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,-1,0,-1,0,0,1,0,0,0,-1,1,0,0,0,0,0,0,0,-1,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,1,0,1,1,0,0,-1,1,-1,0,0,2,-1,0,0,-1,2,0,-1], [0,-1,0,0,-1,-2,-1,0,1,0,1,-1,0,0,0,-1,1,0,0,1,-2,-2,1], [0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,-1,0,0,0,0,0,1,-1], [0,0,0,0,-1,0,0,0,0,0,1,-1,0,0,0,-1,1,0,1,1,-1,-1,1], [1,-1,0,0,-1,-1,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,-1,-1,1], [0,-1,0,0,-1,-1,-1,1,0,0,0,0,0,-1,1,0,1,0,0,1,-1,-3,1], [0,0,0,0,0,0,1,1,0,0,0,0,-1,0,0,1,-1,0,0,-1,1,1,-1], [0,0,0,0,0,-1,-1,0,1,0,0,0,0,0,0,-1,1,0,0,0,0,0,0], [0,0,0,0,-1,-1,0,-1,1,0,1,-1,1,1,-1,-1,0,1,0,0,0,1,0], [0,1,0,0,0,1,0,-2,0,0,0,-1,1,1,-1,-1,0,0,0,0,0,2,0], [0,0,-1,0,0,0,1,-2,0,1,0,0,1,2,-1,0,-1,0,-1,-1,0,2,-1], [0,-2,-1,0,-1,-2,-1,-1,1,0,0,0,-1,0,0,0,-1,0,-1,-1,-1,-1,0], [0,0,1,1,-1,0,0,0,-1,0,2,-1,0,-1,0,-1,0,0,1,0,-1,1,0], [0,1,1,1,0,1,0,1,-1,0,0,0,0,-1,1,-1,1,0,1,1,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,-1,0,0,-1,1,2,-1], [0,0,0,0,1,0,1,1,0,0,-1,1,-1,0,0,1,-1,0,0,-1,2,1,-2]]]], [ # Z-class [23][13] [[2], [0,2], [-1,1,4], [0,1,-1,4], [-1,-1,-1,0,4], [1,0,-2,2,1,4], [1,1,1,-1,-2,0,4], [-1,0,-1,2,2,1,-1,4], [-1,-1,1,0,2,0,-2,1,4], [0,0,1,0,0,-1,0,0,1,2], [-1,0,2,0,-1,-2,-1,-1,1,1,4], [1,0,0,1,-2,1,1,-1,-1,0,1,4], [-1,-1,1,-2,1,-1,-1,0,1,0,1,0,4], [0,1,-1,2,-1,1,1,1,-1,0,0,1,-2,4], [0,0,0,1,0,1,0,1,0,0,0,1,0,0,2], [-1,0,-1,0,2,1,0,2,0,-1,-1,-1,1,1,0,4], [-1,0,-1,2,0,0,-1,1,0,0,1,0,-1,2,0,1,4], [-1,-1,1,0,1,-1,-2,1,2,1,1,0,2,-2,1,-1,0,4], [0,0,1,-1,-1,-1,1,-1,-1,0,1,1,1,0,0,0,0,0,2], [0,0,0,0,-1,-1,0,0,0,0,1,0,0,0,0,0,1,0,0,2], [1,0,1,-2,-1,-1,2,-1,0,1,-1,0,0,-1,0,-1,-2,0,0,0,4], [0,1,2,1,-1,-1,0,0,1,1,2,0,-1,0,0,-1,0,0,0,1,0,4], [0,-1,0,-2,-1,-2,0,-2,0,0,1,0,0,-1,-1,-1,0,0,0,1,1,0,4]], [[[-1,0,1,-2,0,2,-1,1,-1,1,0,1,-1,0,-1,0,0,0,0,1,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [2,1,0,1,0,-1,1,1,1,-1,0,-1,2,0,1,-1,1,-1,0,-1,0,0,1], [-2,0,-1,0,0,0,0,-1,0,0,0,0,-1,0,0,0,-1,0,1,1,0,0,-1], [1,0,1,-3,0,0,-2,1,-1,0,0,1,-1,0,0,0,1,0,-1,0,0,0,-1], [-1,0,1,-3,0,1,-2,1,-1,0,0,2,-2,0,-1,0,0,0,0,1,0,0,-1], [1,1,1,0,1,0,0,1,0,0,-1,1,1,0,0,-1,1,-1,0,0,0,0,1], [0,0,-1,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [1,0,0,-2,0,0,0,1,0,-1,1,0,0,0,0,-1,1,0,-1,0,0,0,-1], [0,1,0,-2,0,1,0,1,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0], [-1,0,-1,1,-1,0,1,0,1,0,0,-1,0,-1,0,0,0,0,1,0,0,0,0], [-1,0,0,-1,-1,0,0,1,1,1,-1,1,-1,-1,0,0,0,-1,1,0,-1,0,0], [2,0,0,-1,-2,-1,0,1,1,0,0,0,0,-1,0,1,1,0,-1,-2,-1,0,0], [-2,1,-2,0,0,-1,1,-1,1,0,0,1,-1,-1,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [1,0,0,-1,-1,-1,-1,0,0,0,0,1,-1,-1,0,1,1,0,-1,-1,0,0,-1], [-1,-1,-2,3,0,-2,2,-3,1,-1,0,-1,0,0,1,1,-1,1,0,0,0,0,-1], [1,0,-1,0,-1,-1,1,0,1,0,0,-1,1,0,1,0,0,0,0,-1,-1,0,0], [0,0,-1,1,-1,-1,1,0,1,0,0,0,0,-1,0,1,0,0,0,-1,0,0,0], [0,-1,0,2,0,0,1,-1,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0], [2,0,2,-1,1,1,0,1,-1,0,0,0,1,1,0,-1,1,0,-1,0,0,0,1], [-1,0,0,1,0,1,0,0,0,0,0,-1,1,0,0,-1,0,-1,1,1,1,0,0], [0,-1,0,2,1,0,1,-1,0,0,-1,-1,2,1,1,-1,0,0,0,0,0,1,1]], [[0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,-1,0,0,-1,0,0,0,-1,0,1,0,1,-1,1,0,0,0,0,0], [1,0,-1,2,0,-2,2,-2,1,0,0,-1,1,1,1,1,-1,1,-1,-1,-1,0,0], [-1,-1,1,-1,-1,2,-2,1,-1,1,1,0,-2,0,-1,1,-1,0,1,1,1,-1,0], [0,-1,1,2,2,1,0,-1,-1,0,0,-1,1,1,0,-1,0,0,1,1,1,0,1], [-1,-1,1,1,1,1,-1,0,-1,0,-1,0,1,1,0,-1,0,-1,1,1,1,0,1], [0,0,0,0,0,-1,0,-1,0,0,-2,0,1,1,1,0,0,0,-1,0,-1,1,0], [-1,-1,2,-2,1,3,-2,1,-2,1,0,0,-1,1,-1,-1,0,0,1,2,1,0,0], [0,-1,-1,3,2,-1,2,-2,0,-1,1,-1,1,1,0,0,-1,1,0,0,1,0,0], [0,0,-1,1,0,0,1,-1,0,0,1,-1,0,0,0,1,-1,1,0,0,0,0,0], [-1,1,-2,0,-2,0,1,0,1,1,2,0,-2,-2,-1,2,-1,1,0,-1,0,-1,-1], [-1,1,0,-1,-1,1,-1,1,0,1,0,1,-2,-1,-1,1,-1,0,1,1,0,-1,0], [1,1,0,0,1,0,1,0,0,0,0,0,1,0,0,-1,1,0,0,0,0,0,0], [-2,0,0,-1,-1,2,-2,1,-1,1,0,0,-1,0,-1,0,-1,0,1,1,1,0,0], [-1,0,1,-2,0,2,-1,1,-1,1,0,1,-1,0,-1,0,0,0,0,1,0,0,0], [-1,-1,2,0,1,2,-2,0,-2,1,-1,0,0,1,-1,-1,0,0,1,2,1,0,0], [-1,0,0,-2,-1,1,-2,1,-1,1,1,1,-2,-1,-1,1,0,0,0,0,1,0,-1], [1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,-1,-2,-1,0,0,0,0,0,1,1,-2,-1,-1,1,0,1,-1,0,0,0,-2], [1,0,0,0,1,-1,1,-1,0,-1,-1,0,1,1,1,0,0,1,-1,0,-1,1,0], [-1,-1,-1,1,-1,0,1,-1,0,0,2,-1,-2,0,-1,2,-2,2,0,0,0,-1,-1], [0,0,-1,0,-1,-2,1,0,1,0,0,1,-1,-2,0,1,0,0,-1,-1,-1,0,-1]]]], [ # Z-class [23][14] [[28], [-12,28], [2,-10,23], [4,4,2,28], [2,-2,7,2,23], [-10,2,1,-2,9,23], [2,6,-1,2,7,9,23], [2,6,-9,10,-9,-7,-9,23], [-10,-6,1,-10,-7,-1,-7,-7,23], [12,4,-10,4,-10,-14,-2,6,-6,28], [-2,-6,1,-2,9,-1,1,-7,-1,2,23], [0,0,-4,0,-4,4,-4,4,4,0,-4,16], [12,-12,-2,4,-10,-6,-2,6,2,4,-6,0,28], [-2,2,-7,6,-7,-9,-7,9,-1,10,7,-4,2,23], [-14,14,-5,-6,3,5,-5,3,-3,-2,5,4,-10,-3,31], [6,-14,13,-10,-3,3,-3,-3,3,-6,-5,4,10,-5,-7,31], [-10,-6,-3,6,-11,3,-11,5,11,2,3,4,10,11,1,-1,31], [-4,12,-14,-12,-6,6,2,2,-2,4,-2,8,-4,-2,10,-2,-2,28], [-12,-4,10,-4,-6,6,-6,-6,14,-12,-2,0,4,-2,2,6,14,-4,28], [-2,10,1,14,1,7,1,9,-9,2,-9,4,-6,-1,5,-5,3,-2,-2,23], [-6,-2,11,10,-5,5,3,3,-3,-10,-3,-4,6,5,-9,9,9,-6,10,5,31], [10,-10,7,2,-1,1,7,-9,1,6,1,-4,6,1,-13,5,5,-6,2,1,3,23], [-12,12,6,12,-2,2,-2,6,-6,-4,-6,0,-4,2,6,2,2,-4,4,10,14,-10,28]], [[[1,-1,-2,0,1,-1,0,-1,1,0,-1,0,-1,0,1,0,0,0,0,0,1,1,1], [-1,-1,-1,2,0,-1,1,0,-1,0,-1,0,-1,0,1,1,0,0,1,-1,0,0,-1], [-2,1,1,-1,0,-1,0,-1,-2,0,0,1,1,0,-2,0,1,0,0,1,-1,-1,-1], [-2,1,0,-1,1,-1,0,0,-3,0,-1,2,0,0,-1,0,1,-1,0,-1,0,1,-1], [0,-1,-3,1,1,-2,0,-1,0,0,0,-1,-1,-1,0,1,0,1,1,1,1,0,0], [1,0,1,1,-2,1,0,0,1,-1,1,-2,0,0,0,0,0,1,-1,1,-1,-1,0], [1,-2,-2,2,0,-1,1,0,2,0,-1,-2,-2,0,2,1,0,1,0,0,1,0,0], [0,1,0,0,0,1,-1,0,-1,0,0,1,0,0,0,0,0,-1,0,-1,0,1,0], [0,1,4,-2,-1,2,0,1,0,0,1,1,2,1,-1,-2,0,0,-1,0,-1,-1,0], [-1,-1,-1,0,1,0,0,0,0,1,-1,1,0,0,1,0,-1,-1,0,-1,1,1,0], [-1,-1,-2,0,2,0,-1,1,1,2,0,0,0,-1,0,0,-2,0,1,0,2,1,0], [1,0,3,-1,-2,3,0,1,1,0,1,0,1,1,0,-2,-1,0,-1,0,-1,0,1], [-1,0,0,-1,2,-2,0,0,-1,0,-1,1,0,0,0,0,1,0,0,0,0,1,0], [0,-1,-2,1,2,0,0,1,1,1,-1,0,-1,0,1,1,-1,0,1,-1,1,1,0], [-2,1,0,0,0,0,-1,0,-2,1,1,1,1,-1,-1,0,-1,-1,1,0,0,0,-1], [0,-1,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,1,0,1,-1,0,1], [-2,2,3,-2,0,1,-1,1,-2,0,1,2,2,0,-2,-1,0,-1,-1,0,-1,0,-1], [2,-2,0,2,-1,1,1,1,3,0,0,-2,-1,0,2,0,-1,1,0,0,0,0,1], [-2,2,5,-1,-1,1,0,0,-2,0,0,1,2,1,-2,-1,1,0,-1,0,-2,-2,-2], [-1,2,1,0,-2,1,-1,-1,-2,-1,1,1,1,0,-1,0,0,-1,-1,0,-1,0,-1], [-1,1,0,0,0,-1,0,0,-1,-1,0,0,0,0,-1,1,1,0,0,1,-1,0,-1], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [-3,0,0,0,1,-2,1,0,-3,0,-1,1,0,0,-1,1,1,0,1,0,-1,0,-1]], [[1,-2,-2,2,1,-1,0,0,2,0,0,-2,-1,0,1,1,-1,2,1,1,0,0,1], [0,0,0,-1,0,1,0,0,-1,1,-1,1,0,0,0,-1,0,-1,0,-1,1,0,0], [0,-1,1,0,0,0,1,1,1,0,0,-1,0,0,0,0,0,1,0,0,-1,0,1], [0,0,2,0,-1,1,0,-1,0,0,-1,0,1,1,0,-1,0,0,-1,0,-1,-1,0], [0,-1,-1,0,1,-1,1,1,0,0,-1,0,-1,0,1,0,0,0,1,-1,0,1,1], [-1,0,-2,-1,1,-2,0,0,-1,0,0,1,0,-1,0,0,0,-1,1,0,1,1,0], [1,-1,1,-1,0,2,0,1,2,1,0,0,1,1,1,-2,-2,0,0,0,1,0,1], [0,0,-1,1,0,-1,0,-2,-1,0,-1,0,-1,0,0,1,1,0,0,0,0,-1,-1], [-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1], [0,1,1,0,-1,2,-2,0,0,0,1,0,1,0,-1,-1,-1,0,-1,0,0,0,0], [2,2,1,-1,-1,2,-1,1,1,-1,1,0,0,0,0,-1,0,-1,-1,-1,0,1,1], [-1,0,-3,1,2,-3,0,-1,-1,0,-1,0,-1,-1,0,2,1,0,1,0,1,0,-1], [0,0,0,1,0,0,-1,-1,1,0,1,0,1,0,0,0,-1,1,0,1,0,0,0], [0,2,1,-1,-1,2,-2,0,0,0,1,1,1,0,-1,-1,-1,-1,-1,0,0,1,0], [0,1,-1,-1,1,-1,0,0,-2,0,-1,1,-1,-1,0,0,2,-1,0,-2,1,1,0], [-1,0,-1,0,1,-2,0,0,0,0,1,0,0,-1,-1,1,0,1,1,1,0,0,0], [-1,2,0,0,-1,0,-2,-1,-1,-1,1,1,1,-1,-1,0,0,-1,-1,0,0,1,-1], [1,1,-4,0,1,-1,-1,0,0,0,1,0,-1,-2,0,1,0,-1,1,0,2,1,0], [-1,1,0,-1,0,0,-1,0,-1,0,1,1,1,-1,-1,0,0,-1,0,0,0,1,0], [-1,-1,-1,0,0,-1,0,-1,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,1,-1,-1,1,0,0,2,0,1,0,1,0,0,-1,-1,0,-1,1,0,0,1], [0,-1,0,0,0,1,-1,1,2,0,1,-1,1,0,0,-1,-2,1,0,1,0,1,1], [-2,2,3,-2,-1,0,0,-1,-3,0,0,2,2,0,-2,-1,1,-1,-1,0,-1,-1,-1]]]], [ # Z-class [23][15] [[4], [-2,4], [0,-2,4], [-2,2,-2,4], [1,0,-1,1,4], [1,-2,0,0,0,4], [-1,2,-1,1,1,-2,4], [0,1,0,-1,-1,-1,0,4], [-1,1,-1,2,0,-1,1,-1,4], [-1,0,0,0,-2,0,0,0,1,4], [-1,0,-1,1,-1,2,0,-1,0,2,4], [0,-1,0,0,-1,2,-2,-1,-1,-1,1,4], [-1,1,-1,0,-1,1,0,1,-2,0,2,2,4], [-2,1,-1,1,-1,0,0,0,0,0,1,2,2,4], [1,-1,1,-1,0,-1,0,1,1,1,-1,-2,-2,-2,4], [1,0,-1,1,2,0,1,-1,2,0,0,-2,-2,-2,2,4], [0,1,0,1,0,-1,1,1,2,0,-1,-2,-2,-2,2,2,4], [1,1,-1,0,0,-2,1,0,2,1,-1,-2,-2,-2,2,2,2,4], [1,0,-1,1,1,0,0,0,1,1,0,-2,-2,-2,2,2,2,2,4], [0,1,0,1,2,-2,1,0,1,-1,-2,-2,-2,-2,2,2,2,2,2,4], [-2,0,1,0,-2,1,-1,-1,-1,1,2,2,2,2,-2,-2,-2,-2,-2,-2,4], [0,0,0,-1,-1,1,-2,1,-2,-1,0,2,2,2,-2,-2,-2,-2,-2,-2,2,4], [2,0,0,-1,1,-1,0,1,0,-1,-2,-2,-2,-2,2,2,2,2,2,2,-2,0,4]], [[[-1,-1,-1,-1,-1,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,1,0,-1,1], [1,1,1,1,0,1,1,0,1,0,0,0,0,-1,1,-1,-1,0,0,0,0,1,0], [-1,0,0,0,0,-1,-1,-1,-1,0,0,0,0,0,0,1,0,0,0,-1,-1,0,0], [1,1,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,-1,0,-1,0,1,0,0,-1,2,1,-2,0,0,0,0,1,-1,-1,1], [-1,0,-1,-1,1,0,-1,0,0,0,1,0,0,0,0,-1,1,0,-1,0,0,-1,1], [1,0,0,1,-1,1,0,0,1,0,0,-1,0,0,0,-1,-1,0,-1,1,0,0,1], [0,1,0,1,0,1,0,0,-1,0,0,0,-1,0,1,-1,-1,0,-1,0,0,-1,1], [1,1,0,0,-1,-1,1,0,0,0,0,1,-1,-1,1,1,0,-1,1,0,0,2,-2], [0,0,-1,1,0,0,1,0,-1,1,0,1,-1,-1,1,0,0,0,-1,0,0,1,0], [0,0,-1,0,1,1,0,0,0,0,0,0,0,0,1,-1,1,1,-1,0,1,0,0], [0,0,0,-2,2,0,0,0,0,0,0,0,0,1,0,0,2,1,1,0,1,1,-2], [0,0,0,0,2,2,0,0,0,0,0,-1,0,1,1,-2,1,2,-1,0,1,0,0], [2,0,0,0,2,0,0,0,0,0,0,-1,0,1,1,-1,2,1,0,0,2,1,-2], [0,0,0,0,-2,0,0,0,-2,0,0,0,-1,1,-1,2,0,0,0,1,-1,0,-1], [0,0,0,0,-2,0,0,0,0,0,0,0,0,0,-1,1,0,-1,0,1,-1,0,0], [0,2,0,0,-2,0,0,0,0,0,0,1,-1,-1,0,1,-2,-2,0,0,-1,-1,1], [0,0,0,0,-2,0,2,0,0,0,0,1,-1,-1,0,1,-1,-1,1,1,-1,2,-1], [0,0,0,0,-2,0,0,0,0,0,0,0,1,0,-1,1,-1,-1,0,1,-1,-1,1], [0,0,2,0,-2,0,0,0,0,0,0,0,1,1,-2,2,-1,0,1,1,-2,0,0], [0,0,0,0,2,0,0,0,0,0,0,0,0,0,1,0,1,1,0,-1,1,1,-1], [0,0,0,0,2,0,0,0,0,0,0,0,0,0,1,-1,1,0,0,-1,1,0,0], [0,0,0,0,-2,0,0,0,0,0,0,0,0,0,-1,1,-1,-2,0,1,-1,-1,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,0,1,-1], [1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,1,0,0], [-1,0,-1,0,-1,0,0,0,0,0,1,0,-1,-1,0,-1,-1,-1,-1,1,-1,0,1], [0,1,-1,0,-1,0,0,0,0,-1,0,0,-1,-1,1,0,-1,-1,0,0,0,0,0], [1,1,0,0,-1,0,0,0,0,0,0,0,-1,0,0,0,-1,-1,0,0,0,-1,0], [-1,0,-1,-1,0,0,0,0,-1,0,0,0,-1,0,0,1,1,0,0,0,0,1,-1], [0,0,1,-1,1,0,0,-1,0,0,0,0,1,1,0,0,2,1,1,0,-1,2,-2], [-1,-1,0,1,-1,0,-1,0,0,0,0,-1,1,0,-1,0,-1,0,-1,0,-1,-1,2], [0,-1,1,0,0,0,0,0,0,0,0,-1,1,1,-1,0,1,1,0,0,0,0,0], [0,0,0,-1,-1,1,0,0,0,0,0,-1,0,1,-1,0,0,0,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,0], [0,0,0,-2,0,0,0,0,0,0,0,0,0,1,-1,1,1,0,1,1,0,0,-2], [-2,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,-1,0,0,-1,-1,-1,1], [0,0,2,0,0,0,0,0,0,0,0,0,1,1,-1,1,0,1,1,0,-1,1,0], [0,0,0,0,-2,0,0,0,0,0,0,0,0,0,-1,1,-1,-1,0,1,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-2,0,0,0,0,0,0,0,0,0,-1,1,1,-1,0,1,1,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Z-class [23][16] [[23], [11,47], [0,0,48], [-1,-13,-12,47], [-11,-23,-12,25,47], [-10,14,12,-22,-2,44], [11,23,0,11,-11,-10,47], [11,23,0,-25,-11,14,11,47], [11,23,-24,-1,-11,2,23,11,47], [-10,-10,24,14,10,8,2,-10,-22,44], [-10,-22,-12,-10,10,8,-22,-10,2,-4,44], [-7,-19,24,-19,-5,14,-19,-7,-19,14,14,47], [10,-14,12,22,2,-20,-2,-14,-14,16,-8,-2,44], [-11,-23,-12,-11,-1,-2,-11,-11,1,-14,22,19,-10,47], [9,9,-24,-15,-9,-6,9,21,21,-30,6,-9,-18,15,39], [-4,-4,-24,-4,4,8,-16,-4,8,-16,20,-4,-8,16,12,32], [1,13,24,-23,-25,22,1,1,1,10,-2,19,-10,-1,-9,-8,47], [-7,-19,-24,17,7,-22,5,-7,5,-10,2,-13,-2,19,15,8,-17,47], [-4,-4,12,8,-8,-4,-4,-16,-16,8,-4,8,16,4,-12,-4,4,-4,32], [1,13,12,-11,-13,10,13,13,1,-2,-14,7,-10,-1,3,-8,11,-5,4,23], [10,22,12,-26,-34,4,10,10,10,-8,-8,10,-4,2,6,-8,26,-14,4,14,44], [2,14,12,-22,-14,8,-10,2,2,-4,8,2,-8,-14,-6,-4,22,-22,-4,-2,16,44], [9,-15,-12,-3,-9,-18,-15,-3,-3,-18,6,3,6,15,15,12,-9,15,0,-9,-6,-6,39]], [[[2,-1,-2,-5,1,1,1,-2,1,1,-1,0,0,-1,-1,-1,-1,1,2,0,-1,0,0], [0,0,-1,0,1,2,1,0,0,1,0,0,0,0,0,-1,-1,0,1,0,1,1,2], [-1,1,1,0,1,-3,-1,1,1,0,0,0,0,0,0,1,2,-1,0,1,-1,-1,0], [0,-1,-1,1,-1,1,0,0,-1,-1,0,0,0,0,0,-1,0,0,-1,0,0,0,-1], [-1,0,0,1,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,-1,0,1,0,0], [-1,0,2,3,1,0,0,1,0,1,0,-1,-1,1,1,1,0,-1,0,0,2,1,2], [-1,1,-2,-1,0,0,1,0,-1,-1,1,1,1,-1,-1,-1,1,0,0,0,-1,-1,0], [0,-1,0,-2,1,0,1,0,1,1,-1,0,-1,-1,-1,1,-1,0,2,-1,1,0,1], [1,1,-1,-2,1,1,1,-1,0,1,1,0,0,0,-1,-1,-1,1,1,0,0,0,1], [-1,0,1,1,0,-1,-1,0,0,0,0,-1,0,0,1,0,1,-1,-1,1,0,-1,0], [0,1,1,2,-1,0,0,0,-1,-1,1,0,0,1,0,0,0,0,-1,0,0,0,0], [1,1,1,-2,1,-2,-1,-1,1,1,0,-1,0,0,0,1,1,0,0,1,-1,-1,0], [1,-2,0,-3,0,-1,-1,-1,2,1,-1,-1,-1,-1,0,0,0,0,1,1,-1,-1,-1], [0,1,1,0,-1,-2,-1,0,0,0,1,0,0,0,0,1,1,0,-1,0,-1,-1,-1], [1,0,-1,-2,0,1,1,-1,0,0,0,1,0,-1,-1,0,-1,1,1,-1,0,0,0], [1,-1,1,2,-1,1,-1,0,0,1,0,-1,-1,1,1,0,-1,0,0,0,1,1,0], [-1,0,0,0,1,0,1,0,0,0,0,0,1,0,1,0,1,-1,0,0,0,0,1], [0,-1,0,2,-2,0,0,1,-1,-1,0,1,0,0,0,1,0,0,-1,-1,0,0,-2], [-1,-1,0,2,-1,0,0,1,0,-1,0,0,0,0,0,0,1,-1,-1,0,0,0,0], [-1,0,0,1,0,-1,0,1,0,0,0,0,0,0,0,1,1,-1,0,0,0,0,0], [0,0,-1,-3,1,0,1,-1,1,1,0,0,1,-1,0,0,0,0,1,1,-1,0,1], [0,2,0,0,1,0,0,0,0,0,1,0,1,1,0,-1,0,0,0,1,0,0,1], [3,-1,0,-2,-1,0,-1,-1,1,1,-1,0,-1,0,0,0,-1,1,1,-1,-1,0,-2]], [[0,1,0,-1,0,-2,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,-1,-1], [-2,-1,1,4,-2,0,0,2,-1,-2,-1,1,0,0,1,1,1,-1,-1,-2,0,0,-1], [-1,-1,0,3,-2,0,0,1,-1,-1,0,0,0,1,0,0,0,-1,-1,0,0,1,-1], [2,0,-2,-4,1,1,1,-2,0,1,0,0,1,-1,0,-1,0,1,1,1,-1,0,0], [1,0,0,0,1,1,0,-1,0,1,1,-1,0,0,1,-1,0,0,0,1,1,0,1], [-1,-3,1,4,-2,2,1,1,-1,-1,-1,0,-1,0,1,1,-1,-1,-1,-2,2,1,0], [-1,-1,0,1,-1,-1,0,1,0,0,-1,0,0,0,1,1,1,-1,0,0,-1,0,-1], [-1,0,2,3,-1,-2,-1,2,0,-1,0,0,-1,1,0,1,1,-1,-1,-1,0,-1,-1], [0,-2,0,-1,0,0,0,0,1,1,-2,0,-1,-1,1,1,0,0,1,-1,0,0,0], [2,-1,-1,-2,-1,1,0,-2,0,1,0,-1,0,0,0,-1,-1,0,0,1,-1,0,-1], [1,0,0,-1,1,0,-1,-1,1,2,0,-1,-1,0,0,0,-1,0,0,1,1,0,1], [1,-2,0,-1,0,1,0,-1,1,1,-1,-1,-1,0,0,0,-2,0,1,0,1,1,0], [2,2,-2,-4,0,-1,-1,-2,0,1,1,0,1,0,-1,-2,0,1,0,2,-2,-1,-1], [0,0,1,-1,1,-1,-1,0,2,2,0,-1,-1,0,0,1,-1,0,1,1,1,0,1], [-1,1,1,0,1,-2,-1,1,1,0,0,0,0,0,0,1,1,0,0,0,0,-1,0], [1,1,0,-1,1,1,0,-1,0,1,0,0,0,0,0,0,-1,1,0,0,1,0,1], [-2,-2,0,0,-1,0,1,0,0,-1,-1,0,0,-1,0,1,0,-1,0,-1,0,0,0], [1,1,-1,-4,2,0,1,-1,1,1,0,0,1,0,-1,0,0,1,1,1,-1,0,1], [-1,0,-1,-1,0,0,1,0,0,-1,0,1,1,-1,-1,0,0,0,0,0,0,0,0], [-2,-2,0,3,-1,1,2,2,-1,-2,-1,1,0,0,0,1,0,-1,0,-2,1,1,0], [-2,-1,0,1,-1,0,0,1,0,-1,-1,0,0,0,0,0,0,-1,0,-1,0,0,0], [-2,0,0,3,-1,0,0,1,-1,-2,0,1,0,0,0,0,1,-1,-1,-1,0,0,0], [2,3,0,-4,2,-2,-1,-1,1,1,1,0,0,0,-2,0,0,2,1,1,-1,-1,0]]]], [ # Z-class [23][17] [[4], [0,4], [1,-1,4], [0,1,1,4], [-1,0,-1,0,4], [2,0,2,2,-1,4], [1,1,1,0,-1,1,4], [0,-2,2,0,0,1,0,4], [1,0,2,2,-1,2,0,2,4], [-2,0,-1,0,0,-1,-1,0,-1,4], [0,-1,1,0,0,1,-1,0,0,-1,4], [1,1,-1,1,2,1,0,-1,0,-1,0,4], [2,1,-1,1,0,1,1,-1,0,-1,-1,1,4], [1,-2,2,0,0,1,0,2,1,-2,1,0,0,4], [-1,0,-1,1,0,0,-2,1,1,1,0,0,0,0,4], [1,1,0,0,1,1,-1,0,1,-1,1,2,0,0,0,4], [1,0,2,0,-1,1,1,2,2,0,-1,-1,-1,0,-1,0,4], [0,1,0,0,0,0,2,1,0,0,-1,0,1,0,0,0,0,4], [-2,0,-2,0,1,-2,-2,-2,-2,1,1,0,-1,-1,1,-1,-2,-2,4], [0,-1,2,2,1,2,0,2,2,-1,1,1,0,2,1,0,0,0,-1,4], [-2,1,-2,-1,2,-2,-1,-2,-2,1,1,1,-1,-2,0,1,-2,0,2,-1,4], [1,-2,2,-1,-2,1,0,1,1,-1,2,-2,-1,1,-1,0,1,-1,-1,0,-1,4], [-2,-1,1,1,-1,0,-2,1,1,2,1,-2,-2,0,2,-1,0,-1,1,1,0,1,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,-1,1,2,-1,0,-4,-1,1,1,0,-1,1,2,0,2,1,-2,1,-2,2,-1], [0,0,1,-1,0,0,-1,0,1,0,0,0,0,-1,-1,0,-1,1,1,0,-1,0,0], [-1,0,1,0,0,0,-1,-1,1,1,1,0,0,0,0,-1,0,0,-1,0,0,0,-2], [0,1,1,-1,-1,1,0,3,0,-1,-2,1,2,0,-1,0,0,0,3,0,2,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,-1,0,1,1,-1,0,-4,-1,1,0,-1,-1,1,2,1,2,1,-1,1,-1,1,-1], [1,1,1,-1,-2,1,-1,4,1,-1,-2,0,1,-1,-3,0,-2,0,3,0,2,-1,1], [0,1,1,-1,0,1,-1,2,2,0,0,0,0,-1,-2,-1,-2,0,1,-1,0,-1,0], [0,-1,-1,0,0,-1,1,-3,-1,1,0,-1,0,0,1,2,2,1,1,3,-1,1,-1], [0,1,0,0,0,0,0,3,1,-1,1,1,0,0,-1,-2,-2,-2,-2,-3,1,-1,1], [-1,0,0,0,0,1,0,0,0,0,-1,0,1,1,0,0,1,0,1,0,1,1,0], [0,0,0,1,0,-1,1,-1,-1,1,0,0,0,1,1,1,1,0,0,1,0,1,0], [0,1,2,-1,-1,1,-1,4,1,-1,-1,1,1,-1,-2,-1,-3,-1,1,-2,1,-1,1], [0,1,0,-1,-1,1,0,2,1,0,-1,1,1,0,-2,0,-1,0,2,0,1,0,1], [0,1,0,-1,0,1,0,3,1,-1,-1,1,1,0,-2,-1,-1,0,2,-1,1,0,2], [0,0,0,0,0,0,-1,-1,0,0,0,-1,-1,-1,0,0,0,1,0,1,-1,0,-1], [1,0,0,1,0,0,0,0,0,0,-1,-1,0,1,0,0,0,0,0,0,2,0,0], [-1,0,0,0,0,0,0,0,0,0,1,1,0,0,1,-1,0,-1,-2,-1,0,0,-1], [0,1,1,-1,-1,1,-1,2,1,0,-1,0,1,0,-2,0,-1,0,2,0,1,0,0], [0,0,-1,0,1,0,1,-1,0,0,0,0,0,1,1,0,1,0,0,0,0,1,0], [1,0,0,0,0,0,0,2,1,-1,1,0,-1,-1,-1,-1,-2,-1,-1,-2,0,-2,1], [0,0,0,-1,0,0,0,0,1,0,1,0,0,-1,-1,0,-1,0,0,0,-1,-1,0]], [[-1,-2,-1,-1,1,-1,1,-7,0,2,0,-1,0,1,2,3,4,3,2,4,-3,2,-1], [0,0,-1,0,0,-1,0,-2,-1,0,1,0,-1,0,1,0,1,0,-2,1,-1,0,0], [0,0,0,0,1,-1,1,-2,-1,1,0,1,1,1,1,1,2,1,1,1,-1,2,1], [1,0,0,1,-1,-1,0,0,-1,0,0,0,0,0,0,0,1,0,0,1,1,0,0], [1,1,0,0,0,0,0,3,1,-1,0,0,0,-1,-1,-1,-2,-1,0,-1,1,-1,1], [0,0,0,0,0,0,0,-2,0,1,0,0,0,1,1,0,2,1,1,1,0,1,-1], [-1,0,-1,0,1,-1,1,-3,-1,0,0,1,0,1,1,1,2,1,0,1,-2,2,1], [0,1,1,-1,0,0,1,2,0,0,-1,1,2,0,-1,1,0,0,3,0,0,1,2], [0,0,1,-1,0,-1,1,-1,0,1,0,1,1,0,0,1,1,1,2,1,-1,1,1], [0,1,1,1,-1,1,-2,2,0,0,0,-1,-1,0,0,-2,-2,-2,-2,-1,2,-1,-3], [1,0,0,0,0,1,0,1,0,0,-1,0,0,0,0,0,0,1,2,0,1,1,0], [0,0,0,-1,0,0,0,-1,1,0,0,0,0,-1,0,0,0,1,1,1,-1,0,0], [0,-1,-1,0,-1,0,0,-2,0,0,-1,-1,0,1,0,1,2,1,1,2,1,0,0], [0,0,0,-1,0,0,1,1,0,0,-1,1,2,0,-1,1,1,1,3,1,0,1,2], [1,1,1,-1,-2,2,-1,5,1,-1,-1,0,1,-1,-3,-1,-2,-1,2,-1,3,-2,1], [0,0,1,-2,0,0,0,0,1,0,0,1,1,-1,0,0,0,1,2,0,-1,0,1], [-1,0,0,0,1,-2,1,-4,-1,2,1,0,0,1,2,2,2,1,0,2,-3,2,-1], [0,1,0,-1,0,0,0,1,0,-1,-1,1,1,0,-1,0,0,0,1,0,0,1,2], [1,0,0,1,-1,1,-1,3,0,-1,0,-1,-1,-1,-1,-1,-2,-1,-1,-1,2,-2,-1], [1,1,0,0,0,0,1,2,0,0,-1,1,1,0,-1,0,0,0,2,0,1,1,2], [1,1,0,0,0,1,-1,3,1,-1,0,0,-1,-1,-1,-2,-3,-1,-1,-2,1,-1,0], [0,-1,0,0,1,0,1,-2,0,1,0,0,0,1,1,1,1,1,1,0,-1,1,0], [1,1,1,1,-1,1,-1,4,0,0,0,0,0,0,-1,-2,-2,-2,-1,-2,3,-1,-1]]]], [ # Z-class [23][18] [[12], [0,12], [6,-6,12], [-6,3,-3,12], [6,-6,6,-6,12], [3,-6,6,-3,6,12], [-3,-3,3,3,-3,-3,12], [6,0,0,-6,6,0,-6,12], [-6,6,-3,9,-9,-6,3,-6,18], [-3,-3,-3,3,-3,-3,3,0,3,12], [0,-6,3,-3,6,3,3,3,-3,0,12], [-3,-6,0,-3,0,3,0,0,-6,0,0,12], [6,0,0,-6,6,0,-6,6,-6,0,0,-3,12], [-3,3,0,3,-3,0,3,-3,6,0,0,-3,-3,8], [-6,3,-6,0,-6,-6,3,-3,6,0,0,0,-3,3,12], [0,3,0,0,0,3,0,-3,0,-6,0,0,-3,2,0,8], [0,-6,6,3,0,0,9,-3,3,6,3,0,-3,1,-3,-2,14], [-6,6,-6,3,-6,-3,-3,0,3,0,-3,0,-3,3,3,0,-6,12], [0,-6,3,-3,3,6,0,0,-6,0,3,6,0,-2,-3,1,2,-3,8], [6,0,6,-6,6,3,-3,6,-6,-6,0,0,3,0,-3,0,-3,0,0,12], [3,3,0,-3,0,0,0,3,0,0,0,-3,0,1,0,1,-1,0,-1,3,8], [6,6,3,3,-3,0,-3,0,6,-3,-6,-6,0,1,-3,1,-1,0,-4,3,2,14], [-6,3,-3,3,-6,-3,3,-6,6,0,-3,0,-3,4,6,1,-1,3,-1,-3,-1,-1,8]], [[[-1,3,1,0,1,0,-1,-1,-1,1,1,1,0,0,1,-1,1,0,0,0,0,1,0], [1,1,1,1,0,0,-2,-1,0,0,1,1,0,0,1,0,1,0,-1,0,1,-1,0], [-2,0,0,-1,0,0,1,1,0,0,-1,-1,0,0,0,0,0,0,1,0,-1,1,-1], [0,-1,0,0,-2,0,-1,0,0,0,0,-1,0,0,0,1,0,-1,0,1,0,-1,-1], [-1,2,0,0,0,2,3,1,1,0,-1,0,1,-1,0,-1,-1,0,1,0,-1,0,-1], [-3,1,0,-2,-1,2,4,3,1,0,-2,-2,0,-1,-1,0,-2,-1,1,0,-2,0,-1], [1,-4,-1,0,-2,-2,-1,0,0,0,0,-1,0,1,-1,2,0,0,0,1,0,0,0], [1,2,-1,0,2,1,1,-1,1,0,0,1,0,0,0,-2,0,1,1,0,0,0,0], [1,-1,-1,0,0,-1,-2,-1,0,0,1,0,-1,0,0,1,1,0,0,1,0,0,0], [1,-1,-1,0,0,-1,-1,-1,0,1,1,0,0,0,-1,1,0,0,0,1,0,0,1], [1,-2,-1,0,-2,0,1,1,1,0,-1,-1,0,0,-1,1,-1,0,1,1,-1,-1,0], [-1,-1,-1,-1,1,0,2,1,0,-1,-1,0,0,1,-1,-1,-1,0,0,-1,0,1,0], [0,3,1,1,1,1,-1,-1,-1,1,1,1,0,-1,1,-1,1,0,-1,0,0,0,1], [0,-1,-1,-1,-1,1,2,1,2,0,-1,-1,0,-1,-1,1,-1,0,0,1,-1,-1,-1], [2,-2,0,1,0,-1,-1,-1,0,0,1,1,0,0,0,1,0,1,-1,0,1,0,1], [-1,0,0,-1,-2,1,2,2,1,-1,-1,-1,0,0,-1,0,-1,-1,0,0,-1,-1,-1], [0,-3,-2,-1,-2,-2,-1,0,0,0,0,-2,-1,1,-2,1,0,-1,1,2,-1,0,0], [1,-1,0,0,1,0,0,0,1,-1,-1,0,0,0,0,0,0,1,0,-1,1,-1,0], [-2,0,0,-1,-1,1,2,2,0,0,-1,-1,0,0,-1,0,-1,-1,0,0,-1,0,0], [-1,1,-1,-1,2,1,2,0,1,-1,-1,0,0,0,0,-2,0,1,1,-1,0,1,-1], [1,0,-1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0], [-1,2,0,-1,1,0,-2,-1,-1,0,1,0,-1,0,1,-1,2,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0]], [[-1,1,0,-1,1,0,1,0,0,1,0,0,0,0,0,0,-1,0,1,0,-1,1,0], [0,1,0,0,0,1,1,0,0,-1,0,1,1,0,0,-1,0,0,-1,-1,0,0,0], [-1,1,-1,-1,1,1,2,0,1,1,0,0,0,-1,0,0,-1,0,1,1,-1,1,-1], [0,1,-1,0,0,2,1,1,0,-1,0,0,0,-1,0,-1,1,0,-1,0,0,0,1], [-1,0,1,0,1,-1,0,0,0,1,0,0,0,0,0,1,-1,0,1,0,0,1,0], [0,0,-1,-1,2,-1,-1,-1,0,0,0,0,-1,0,0,0,1,1,1,0,0,1,0], [-1,0,0,0,-2,2,2,2,1,0,-1,-1,0,-1,0,0,-1,-1,0,1,-1,-1,-1], [-1,0,0,-1,1,-1,1,0,0,0,0,0,0,1,-1,0,-1,0,1,-1,0,1,0], [0,1,-1,-1,-1,3,4,2,2,-1,-1,0,1,-1,-1,-1,-1,0,-1,0,-1,-1,-1], [0,-2,-1,-1,-3,0,1,2,1,-1,-1,-3,-1,0,-2,0,-1,-1,1,1,-1,-2,0], [-2,1,2,0,-1,0,0,1,0,1,0,0,0,0,0,1,-1,-1,0,0,0,0,-1], [1,-2,-1,0,1,-3,-4,-2,-2,0,1,0,-2,2,0,0,2,0,0,0,1,1,1], [0,1,1,0,1,-1,0,-1,0,1,0,0,0,0,0,0,-1,0,1,0,0,0,0], [0,1,-1,-1,0,2,3,1,2,-1,-1,0,0,-1,-1,-1,-1,0,0,0,-1,-1,-1], [1,-1,1,1,-2,1,1,1,1,0,-1,0,1,0,0,1,-1,0,-1,0,0,-2,-1], [-1,1,1,0,1,0,-1,0,-1,0,0,1,0,0,1,0,1,0,-1,-1,0,1,0], [-2,1,-1,-2,-1,2,3,2,1,0,-1,-2,-1,-1,-1,-1,-1,-1,1,1,-2,0,-1], [1,0,0,1,-1,0,-1,-1,0,-1,1,1,1,0,0,0,1,0,-1,0,1,-1,0], [0,-1,-1,-1,1,-2,-2,-1,-1,0,0,-1,-2,1,0,0,1,0,1,0,0,1,0], [0,0,-1,0,2,0,2,-1,1,0,0,1,1,0,0,0,-1,1,1,0,0,1,-1], [0,-1,0,0,0,0,2,1,1,-1,-1,0,1,0,0,0,-1,1,1,-1,0,0,-1], [0,2,-2,-1,2,2,3,0,1,0,0,1,1,-1,0,-1,0,1,0,0,-1,1,0], [1,0,-1,0,0,1,1,0,1,-1,-1,0,0,0,0,-1,0,0,0,0,0,-1,-1]]]], [ # Z-class [23][19] [[4], [-1,4], [0,1,4], [-1,2,-1,4], [0,-1,1,-2,4], [1,-2,-1,-1,0,4], [-1,1,-1,2,0,-2,4], [2,0,-1,1,-2,1,-1,4], [-2,2,0,2,-2,-1,0,0,4], [-1,2,0,2,0,0,0,0,1,4], [1,-1,0,0,1,1,-1,0,0,1,3], [0,1,2,-1,1,-1,-1,-1,0,1,0,3], [-2,1,0,1,1,-2,1,-2,1,1,0,1,4], [-2,2,0,1,-1,-1,0,0,2,1,-1,0,1,3], [0,-1,1,0,0,-1,1,0,0,-1,0,0,0,-1,4], [2,-1,0,-1,1,0,-1,1,-1,-1,1,0,0,-1,0,3], [-1,1,2,0,-1,-1,-1,-1,1,0,-1,1,1,1,0,-1,4], [-1,2,-1,2,-2,0,1,1,2,1,-1,-1,0,2,-1,-1,0,4], [2,-2,-1,0,1,2,-1,1,-2,0,2,-1,0,-2,-1,2,-1,-1,5], [1,1,-1,0,1,1,0,0,-1,1,0,0,0,0,-2,0,-1,0,1,4], [-2,0,-1,1,0,1,0,0,1,1,0,-1,1,1,0,-1,0,1,0,0,3], [2,0,2,-2,0,0,-1,0,-1,-1,0,1,-2,-1,1,0,1,-1,-1,0,-2,4], [2,-2,-1,-1,1,0,0,1,-2,-1,1,0,0,-2,1,2,-2,-2,2,0,-1,0,4]], [[[2,0,1,-3,-1,0,2,0,2,2,-1,-1,0,0,0,0,0,-1,1,0,1,-1,0], [0,2,-1,1,1,0,-3,-1,-1,-1,0,-1,0,0,2,-1,0,1,0,0,-2,-1,0], [-1,0,-1,1,0,-1,-1,0,-1,-1,1,1,-1,0,1,0,0,1,0,1,0,0,0], [0,0,1,-1,-1,0,1,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0], [-2,0,0,0,0,-1,-1,1,-1,0,1,0,0,-2,0,0,0,1,-1,1,0,0,0], [0,0,0,0,0,1,2,0,1,0,0,1,-1,1,-1,1,1,-1,0,0,1,0,1], [0,-1,1,-1,-1,-1,0,0,0,1,-1,0,0,0,0,0,-1,0,1,0,0,0,-1], [2,1,0,0,0,1,1,-1,1,0,-1,0,0,1,0,0,0,-1,1,-1,1,0,0], [-1,1,-1,2,1,1,-1,-1,-1,-2,1,1,-1,1,1,0,1,1,0,0,-1,0,1], [0,3,-1,1,1,1,-2,-1,-1,-1,0,-1,0,1,1,-1,0,0,0,-1,-1,0,1], [-1,1,0,-1,0,1,1,1,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1], [0,1,-1,0,1,0,-1,0,0,0,0,-1,0,0,1,-1,0,0,0,0,-1,0,0], [-1,-1,1,0,0,-1,-1,1,-1,0,1,-1,1,-1,0,-1,0,1,-1,1,-1,0,0], [-1,1,-1,3,1,0,-3,-1,-2,-2,1,0,0,0,1,0,0,1,-1,0,-1,0,0], [1,-1,0,0,-1,-1,1,-1,0,0,0,2,-2,1,0,0,0,0,1,0,2,0,0], [1,0,1,-2,0,0,1,1,1,1,0,-1,1,-1,0,-1,0,0,0,0,0,-1,0], [0,-1,0,1,0,-1,-1,0,-1,-1,1,0,0,0,0,0,0,1,-1,1,0,0,0], [0,1,0,1,0,1,-1,-1,-1,-1,0,0,0,1,1,0,0,0,0,0,-1,-1,0], [0,-2,3,-4,-2,0,4,3,2,2,0,-1,2,-1,-2,0,0,-1,0,1,1,0,0], [0,0,1,-2,-1,-1,0,0,1,1,0,-1,0,-1,0,0,0,0,0,1,0,-1,0], [-1,1,-1,3,1,0,-2,-1,-2,-2,1,1,-1,0,0,0,1,1,-1,0,0,0,1], [1,1,-1,0,0,0,-1,-1,0,0,0,0,-1,0,1,0,0,0,0,0,0,-1,0], [2,-1,1,-1,0,0,1,0,2,2,-2,-1,1,0,-1,-1,-1,-1,1,-1,1,1,0]], [[-1,-1,1,0,-1,0,0,0,-1,0,1,0,0,0,0,1,0,1,-1,1,-1,-1,0], [1,1,0,0,0,1,0,-1,1,1,-2,-1,1,0,0,0,-1,-1,1,-1,0,1,0], [0,2,0,-2,0,1,0,1,-1,1,1,-2,1,-1,1,-1,1,0,-1,0,-2,-2,0], [0,1,-1,3,1,1,-1,-2,0,-1,-1,1,-1,0,0,1,0,0,0,-1,1,1,1], [-1,0,0,-2,0,0,1,2,0,1,0,-1,1,0,0,0,0,-1,0,0,-1,0,-1], [0,1,-1,0,1,1,0,0,0,-1,1,1,-1,1,1,0,1,0,0,0,-1,-1,0], [0,1,-1,3,1,0,-3,-1,-1,-1,-1,-1,1,-1,0,0,-1,0,-1,-1,0,1,0], [0,-1,0,1,0,0,0,-1,0,0,0,1,-1,0,0,1,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,-1,1,0,-1,1,-1,0,0,0,0,0,1,0,1,1,1], [1,2,-1,1,2,2,0,-1,1,0,-2,0,0,1,0,0,0,-1,1,-2,0,1,1], [-1,0,0,0,0,1,1,0,0,0,0,1,-1,1,0,1,1,0,0,0,0,0,1], [0,1,1,-2,0,0,0,1,0,1,0,-2,1,-1,0,-1,0,0,0,0,-1,-1,0], [0,-1,1,-1,-1,-1,1,0,1,1,-1,0,0,0,-1,0,-1,-1,1,0,2,1,0], [2,0,0,-1,0,0,1,-1,2,1,-2,0,0,1,0,-1,-1,-1,2,-1,1,1,0], [0,1,-1,4,2,0,-4,-1,-2,-1,0,-1,0,-1,0,-1,0,1,-2,-1,-1,0,1], [-2,-1,0,0,-1,-1,0,0,-1,0,1,1,-1,0,0,1,0,1,0,1,0,0,0], [2,0,1,-2,-1,0,2,0,1,1,0,0,0,1,0,-1,0,-1,1,0,1,-1,0], [2,1,-1,1,1,0,-2,-2,1,0,-2,0,0,0,1,-1,-1,0,1,-1,0,0,0], [-1,-1,0,-1,-1,0,2,0,0,0,1,2,-2,1,0,2,1,0,0,1,1,-1,0], [0,-1,1,-2,-1,1,3,1,2,1,-1,0,1,1,-1,1,-1,-2,1,0,0,1,-1], [1,0,-1,1,1,0,0,-1,1,0,-1,1,-1,1,0,0,0,-1,1,-1,1,1,0], [1,0,1,-1,0,1,0,1,0,1,0,-2,2,0,0,-1,0,0,-1,0,-2,-1,0], [-2,-2,1,0,-1,-1,0,1,-1,0,1,0,0,-1,-1,1,0,1,-1,1,0,0,0]]]], [ # Z-class [23][20] [[12], [3,11], [6,6,12], [3,-2,3,11], [-6,-6,-6,0,12], [0,4,0,-4,0,8], [-6,-5,-6,-4,6,2,14], [-3,-5,-6,2,3,-4,5,11], [6,1,0,-1,0,2,-4,-1,11], [3,5,0,-2,-3,1,-2,1,4,8], [-3,-4,-6,1,3,1,4,4,-2,-1,8], [3,1,3,-1,0,2,-4,-4,2,-2,-2,8], [0,0,3,-3,0,0,-3,-6,0,-3,-3,3,12], [6,4,3,2,-3,-1,-7,-1,5,4,-2,2,-3,11], [0,4,0,-4,0,2,2,-1,2,4,-2,-1,0,-1,8], [0,-4,-3,4,0,-2,1,4,1,-1,2,-2,-3,-2,-2,8], [3,-2,0,5,0,-4,-1,5,2,1,1,-1,-3,2,-1,4,8], [-3,-4,0,1,0,-2,4,1,-5,-4,2,-2,0,-5,-2,2,1,8], [-6,0,0,-3,0,0,3,0,-6,-3,0,0,3,-3,0,-3,-3,3,9], [-6,-6,-3,3,6,-3,6,6,-6,-3,3,-3,-3,-3,-3,0,0,3,3,12], [0,0,3,-3,-3,0,3,0,0,0,-3,0,0,0,0,0,0,3,3,0,9], [-3,2,-3,-5,0,1,-2,-2,1,2,-1,1,0,1,1,-1,-2,-1,0,-3,0,8], [0,5,0,-5,-3,1,-5,-2,4,5,-4,1,3,1,4,-1,-2,-4,0,-6,0,5,11]], [[[1,-1,1,1,0,1,1,1,-1,-1,0,-1,1,1,0,0,0,-1,0,0,0,2,1], [2,0,1,-1,2,0,-2,1,-1,0,1,-1,0,-1,0,1,-1,-1,1,0,1,1,-1], [1,-1,1,0,1,0,-1,0,-1,0,1,-1,0,-1,0,0,0,-2,0,0,1,1,0], [-1,-2,1,1,-1,2,1,0,0,1,-1,0,1,1,0,0,1,0,0,0,-1,1,0], [-1,-1,0,-1,-1,1,0,-1,0,0,-1,0,-1,0,0,0,1,0,0,0,-1,-1,0], [1,-3,1,-1,1,3,-2,2,-3,0,-1,-1,0,1,1,0,0,0,0,-1,0,0,0], [0,-1,0,-2,1,2,-2,0,-2,-1,-1,-1,-1,1,1,0,1,1,-1,0,0,-2,1], [-2,1,0,0,-1,-1,2,-1,2,1,-1,1,0,1,-1,0,0,2,0,0,-2,-1,0], [0,0,1,0,-1,-1,2,0,1,0,0,0,0,0,-1,0,0,-1,1,0,-1,1,0], [1,0,1,-1,1,0,-1,1,0,0,0,-1,0,0,0,1,-1,0,1,0,0,1,-1], [-1,-2,0,1,-1,3,0,2,-1,0,-2,0,1,2,1,-1,0,2,-1,-1,-1,0,0], [0,-1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,-1,0,-1,0,0,0], [1,1,-1,1,0,-1,0,0,0,0,1,0,0,-1,0,0,-1,-1,0,0,1,0,0], [0,1,0,0,0,-1,0,0,1,0,0,0,0,-1,-1,0,0,-1,1,0,0,1,-1], [2,0,1,-2,2,0,-2,0,-1,-1,1,-2,-1,-1,0,1,0,-1,1,0,1,0,0], [-1,0,0,1,-1,0,2,0,1,1,-1,1,1,1,0,0,0,1,0,0,-1,0,0], [-1,0,1,1,-1,0,2,0,1,0,0,0,1,1,0,0,0,0,0,0,-1,1,0], [0,0,0,1,0,0,0,0,0,-1,1,0,0,0,1,-1,0,0,-1,0,1,0,1], [0,1,-1,-1,1,-1,-2,-1,0,0,1,0,-1,-1,0,0,0,0,0,0,1,-2,0], [-1,-1,0,-1,0,1,-1,-1,0,1,-1,0,-1,0,0,0,1,1,0,0,-1,-1,0], [0,1,0,-1,1,-2,-1,-1,0,0,1,0,-1,-1,0,0,0,-1,0,0,1,-1,0], [0,2,-1,0,0,-2,0,0,1,0,1,1,0,-1,0,0,-1,0,0,0,1,0,-1], [0,2,0,0,0,-3,1,0,2,1,1,1,0,-1,-1,1,-2,0,1,0,0,0,-1]], [[0,1,-1,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,-1,0], [1,1,-1,1,0,-1,0,-1,1,-1,1,0,0,-1,0,0,0,-1,1,1,1,1,0], [0,1,-1,0,0,0,-1,0,0,-1,0,0,0,-1,0,0,0,-1,0,0,1,0,-1], [0,-2,0,-1,1,3,-3,1,-3,0,-1,-1,0,0,1,0,1,0,-1,-1,1,-1,0], [-1,-2,1,0,0,2,0,2,-2,1,-1,0,1,2,1,0,0,1,-1,-1,-1,0,0], [0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0,0], [-1,1,0,-1,0,-2,1,-1,1,2,0,1,0,0,-1,0,0,1,0,0,-1,-1,-1], [1,0,1,-1,1,0,0,0,0,1,0,0,0,0,0,1,0,1,1,0,-1,0,0], [1,0,0,0,1,1,-1,1,-1,-2,0,-1,0,1,1,0,0,0,0,0,1,0,1], [1,1,0,1,0,-1,1,-1,1,-1,1,0,0,0,0,0,0,0,1,1,0,1,1], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0], [-1,0,-1,2,-1,1,1,2,0,0,-1,1,1,1,0,-1,-1,1,-1,-1,0,0,0], [-2,1,0,1,-2,-2,3,-1,2,0,0,1,0,0,-1,0,0,-1,0,0,-1,0,0], [1,1,-1,0,0,0,-1,0,0,-2,1,0,0,0,1,0,0,0,0,1,1,0,1], [0,0,0,1,0,0,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,0], [1,0,0,-1,2,0,-2,0,-1,0,0,-1,-1,-1,0,0,0,0,0,-1,1,-1,0], [0,1,0,-1,1,0,-1,0,0,0,0,0,0,0,0,1,0,1,0,0,0,-1,0], [0,1,0,-2,1,-1,-1,-1,0,1,0,0,-1,-1,-1,1,0,0,0,0,0,-1,-1], [-1,0,0,0,-1,-1,2,-1,1,1,0,1,0,0,-1,0,0,0,0,0,-1,0,0], [0,-1,1,-1,0,1,0,0,-1,1,0,0,0,0,0,0,1,0,0,0,-1,0,0], [0,3,-1,-1,0,-3,1,-2,2,-1,1,1,-1,-1,-1,0,0,0,0,1,0,-1,0], [1,1,0,1,0,-1,1,0,1,-1,1,0,0,0,0,0,-1,0,0,1,0,1,1], [1,0,1,2,0,-1,2,0,1,-1,1,0,0,0,0,0,-1,-1,1,0,0,2,1]]]], [ # Z-class [23][21] [[16], [-4,16], [4,-8,13], [-4,-4,-1,13], [-4,8,-8,0,16], [0,-4,5,3,0,13], [4,0,-1,-3,4,-1,13], [8,-4,4,-4,0,0,8,16], [-4,8,-8,4,4,0,-4,-4,16], [4,4,1,-5,-4,1,3,4,0,13], [-8,-4,4,4,0,0,0,-4,-4,-4,16], [0,0,-2,2,-4,-6,-2,0,4,-2,0,12], [-8,-4,0,8,4,4,-4,-4,0,-8,8,0,16], [4,4,-1,-7,0,-5,5,4,-4,3,-4,2,-8,13], [4,4,-1,1,0,-5,5,0,0,3,0,2,-4,1,13], [8,0,-3,-1,-4,-3,3,4,4,5,-8,2,-8,3,3,13], [4,4,2,-6,-4,-2,2,4,0,6,-4,4,-8,6,2,2,12], [-8,-4,0,0,4,4,0,0,-4,-4,4,-4,8,-4,-8,-8,-4,16], [-4,-4,-1,1,-4,-5,-3,-4,-4,-5,4,2,4,1,-3,-1,-2,4,13], [4,4,2,-2,4,-2,-2,0,0,-2,0,0,0,2,2,-2,0,-4,-2,12], [8,4,-4,-4,0,-8,0,4,4,0,-8,4,-8,4,4,8,4,-8,0,4,16], [-4,4,-6,2,0,-6,-6,-4,4,-2,-4,4,0,2,-2,2,0,0,6,0,4,12], [0,4,-3,3,0,1,3,-4,4,1,0,2,0,-1,7,1,2,-4,-1,-2,0,-2,13]], [[[0,0,-4,0,-2,1,-2,2,-1,-2,1,-1,-1,0,1,1,1,0,-1,1,-2,0,0], [1,1,1,-1,-1,1,3,-1,0,0,1,1,0,-1,-1,-1,-1,0,-1,0,1,3,0], [-1,-2,0,0,2,0,-1,0,0,1,-1,0,0,0,0,0,1,-1,1,0,0,-1,0], [-1,0,1,0,1,0,0,0,0,1,-1,1,0,0,0,0,-1,0,1,0,0,-1,0], [3,2,2,0,-1,-1,2,-1,1,0,1,0,1,0,-1,-1,-1,1,-1,-1,0,2,0], [1,1,-1,0,-1,1,1,0,0,0,0,0,0,-1,0,-1,0,0,1,0,0,0,-1], [2,1,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,-1,-1,1,0], [1,-1,2,0,1,-1,2,-2,1,1,-1,0,1,0,-1,-1,0,-1,0,-1,0,1,0], [-1,0,1,0,-1,0,3,-1,0,1,-1,1,0,-1,-1,-1,-1,0,0,1,1,1,0], [1,1,-2,-1,-2,2,2,0,0,-1,1,0,0,-1,0,-1,0,-1,0,0,0,2,-1], [-1,-1,0,0,1,-1,-2,1,0,0,0,-1,1,1,0,1,1,0,0,0,0,-1,1], [-3,-2,0,0,1,-1,-1,0,-1,0,-1,0,0,0,0,2,1,0,-1,1,0,-1,1], [-1,-1,2,1,2,-2,-1,-1,0,2,-1,0,1,1,-1,1,0,1,0,0,1,-2,1], [1,0,0,-1,0,1,0,0,0,-1,1,0,0,0,1,0,0,0,-1,-1,0,2,0], [0,1,-1,0,0,1,-1,1,-1,-1,1,1,-1,0,0,1,0,0,0,0,-1,0,0], [-1,0,-2,0,-1,1,-1,1,-1,-1,0,0,-1,0,1,1,0,0,0,1,-1,0,0], [-1,-1,-2,-1,-1,1,1,0,-1,-1,0,0,0,-1,0,0,1,-1,-1,1,0,1,0], [1,0,3,1,2,-2,1,-2,1,2,-1,0,1,0,-1,-1,0,0,1,-1,1,-1,0], [-2,-1,1,1,2,-1,-2,0,-1,1,-1,0,0,1,0,1,0,0,0,0,1,-2,1], [0,-1,1,0,1,-1,0,0,0,1,0,0,0,0,-1,0,0,0,-1,0,0,1,1], [-1,0,-1,0,-1,0,-1,1,-1,-1,0,0,-1,0,0,1,0,0,-1,1,-1,0,1], [-1,0,2,0,1,0,1,-1,0,1,-1,1,0,0,0,0,-1,0,0,0,1,0,0], [-1,1,-2,0,-1,2,0,1,-2,-1,1,1,-1,-1,0,1,0,0,0,1,0,0,0]], [[-1,0,1,1,1,0,1,-1,-1,1,-1,1,0,-1,-1,1,0,0,1,1,1,-1,0], [0,1,-1,0,-1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-2,1,0,1,-1,1,-1,0,1,0,0,0,0,-1,0,0,0,-1,1,1,1,1], [1,1,1,0,0,1,2,0,1,0,0,1,-1,-1,0,-2,-1,-1,1,-1,0,1,-1], [0,0,2,0,2,0,0,-1,0,1,-1,1,0,0,0,0,0,0,1,-1,0,-1,0], [1,-1,2,-1,1,0,3,-2,1,1,0,1,0,-1,-1,-2,-1,-1,0,-1,1,2,0], [1,1,3,0,1,0,2,-2,1,1,-1,1,1,0,0,-1,-1,0,1,-1,1,0,-1], [0,1,0,0,-1,0,0,0,0,-1,0,0,0,0,0,1,0,1,0,1,0,-1,0], [1,2,0,0,-1,1,1,0,0,0,0,1,-1,-1,0,-1,-1,0,1,-1,0,0,-1], [1,1,0,0,-2,0,2,-1,0,0,0,0,1,0,-1,-1,-1,0,-1,0,1,1,0], [0,-1,2,0,1,-1,1,-1,1,1,0,0,1,1,0,-1,0,0,-1,-1,1,1,0], [-1,0,-2,0,-2,1,0,1,0,-1,0,-1,0,0,1,0,1,0,0,1,0,0,-1], [0,-1,1,-1,1,0,1,0,1,0,0,0,0,0,0,-1,0,-1,0,-1,0,1,0], [0,0,-1,0,-1,0,0,0,0,0,0,-1,1,0,0,0,1,0,0,1,0,0,0], [0,1,1,1,0,1,2,-1,0,1,-1,1,0,0,0,-1,-1,0,1,0,1,0,-1], [1,2,0,0,-1,1,1,0,0,0,0,1,0,-1,0,0,-1,0,1,0,0,0,-1], [-1,0,-1,0,-1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,1,0,0], [-1,-2,-1,-1,1,-1,-3,1,0,-1,0,-1,0,1,1,1,1,0,-1,0,-1,-1,1], [0,0,-2,0,0,0,-3,2,0,-1,1,-1,0,1,1,1,1,0,0,0,-1,-1,0], [-2,-2,1,1,2,-1,0,-1,-1,2,-1,0,0,0,-1,1,1,0,0,1,1,-1,1], [-2,1,-3,1,-1,1,-3,2,-2,-1,0,0,-1,0,1,3,1,1,1,2,-1,-3,0], [0,1,-4,0,-2,1,-3,3,-1,-2,1,-1,-1,0,1,1,1,0,0,1,-2,-1,0], [1,2,0,0,-1,2,3,-1,0,0,0,1,0,-1,0,-2,-1,-1,1,-1,1,1,-2]]]], [ # Z-class [23][22] [[3], [1,3], [-1,-1,3], [0,0,1,3], [-1,-1,1,1,3], [0,0,1,0,0,3], [0,1,0,1,0,0,3], [1,0,-1,-1,-1,1,0,3], [0,0,0,-1,-1,0,0,0,3], [0,0,-1,-1,-1,0,-1,1,0,3], [0,-1,1,0,0,1,-1,0,0,-1,3], [-1,-1,0,-1,0,0,0,1,1,0,0,3], [1,1,-1,-1,-1,-1,0,0,1,0,0,-1,3], [0,0,0,0,0,1,1,0,0,0,0,-1,0,3], [0,0,0,-1,0,1,0,0,1,-1,1,1,0,0,3], [0,1,1,1,0,0,1,0,0,-1,0,0,0,-1,-1,3], [1,0,0,0,0,-1,0,-1,0,0,0,-1,1,1,0,-1,3], [1,1,-1,0,-1,0,1,0,1,0,-1,0,0,1,1,-1,1,3], [-1,-1,1,0,0,-1,0,-1,1,-1,1,1,0,-1,0,1,0,-1,3], [1,1,-1,-1,-1,0,-1,1,0,1,-1,0,0,-1,0,0,-1,0,-1,3], [0,1,-1,0,-1,0,1,1,1,1,-1,0,1,0,-1,1,-1,0,0,0,3], [0,1,0,1,1,-1,0,-1,-1,0,-1,-1,0,-1,-1,1,0,-1,0,1,0,3], [-1,1,1,1,1,1,1,-1,0,-1,0,0,-1,0,1,1,-1,0,0,0,0,1,3]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,-1,1,0,-1,-1,0,0,0,-1,-1,0,0,0,-1,0,0,1], [0,0,0,0,-1,-1,-1,1,0,0,-1,-1,0,0,0,0,-1,0,0,-2,-1,0,1], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,-1,0,0,1,0,0,0,1], [0,0,-1,0,-2,-1,0,1,2,-1,-1,-1,-2,-1,0,0,1,-3,-2,-2,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,1,-1,0,0,1,0,0], [1,0,0,1,0,1,0,-1,-1,1,-1,2,2,1,0,0,-1,0,1,0,-1,0,0], [1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,-1,-1,0,0,-1,0,1,0], [0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,1,1,1,1,-1,0], [0,1,0,1,0,0,0,0,1,0,-1,0,-1,0,1,0,1,-2,0,0,0,-1,-1], [1,-1,0,0,0,0,0,-1,-1,1,0,1,1,1,1,1,-1,1,0,0,0,1,0], [0,-1,0,0,0,0,0,0,-1,0,1,1,1,0,-1,0,0,1,0,1,0,0,1], [0,0,0,0,1,0,1,-1,0,0,1,1,0,0,-1,0,1,0,0,2,1,-1,0], [0,1,-1,1,-1,0,-1,1,1,0,-2,-1,-1,0,1,0,0,-2,0,-2,-1,0,0], [1,0,1,0,0,-1,-1,0,-1,0,0,1,1,1,0,0,-1,1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1,1,0,-1,0,0,0,0,0,-1,0,1], [0,1,0,1,0,0,0,0,0,0,-1,0,0,0,1,0,0,-1,0,0,0,-1,-1], [-1,0,0,0,1,1,1,-1,0,0,1,0,0,0,0,0,1,0,0,2,1,0,-1], [1,0,0,0,-1,0,0,0,0,1,-1,0,0,0,1,0,-1,-1,0,-2,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0]], [[-1,-1,-1,-1,-1,0,0,0,1,-2,0,-1,-2,-1,0,1,2,-1,-2,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,1,1,1,-1,-1,0,0,0,0,0,-1,1,0,-2,-1,1], [-1,0,-1,0,0,0,1,1,1,0,0,-1,-1,-1,0,0,1,-1,0,0,-1,0,0], [0,0,0,0,0,0,0,0,-1,1,0,0,1,0,0,0,-1,1,1,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0], [-1,0,0,0,1,0,1,0,0,1,1,0,0,0,0,1,0,1,0,1,0,0,-1], [-1,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,1,0,0,1,1,0,-1], [1,0,0,0,0,0,-1,0,0,0,-1,1,1,1,-1,0,-1,0,0,-1,-1,0,1], [0,1,1,1,1,0,-1,0,-1,0,0,1,1,1,1,0,0,1,1,1,1,0,-1], [0,-1,0,-1,-1,0,1,0,1,-1,0,-1,-1,-1,-1,-1,1,-1,-1,0,0,0,1], [0,0,0,1,1,1,0,-1,-1,1,0,1,2,1,0,0,-1,1,1,1,0,0,-1], [0,0,0,-1,-1,0,0,0,1,-1,0,0,-1,-1,-1,0,1,-1,-2,-1,0,0,1], [0,0,1,0,0,-1,0,0,-1,0,1,1,0,1,0,0,0,1,0,1,1,0,0], [0,-1,0,-1,1,1,1,-2,-1,0,2,1,1,0,-2,0,0,2,0,2,1,0,0], [0,0,-1,0,-1,0,0,2,2,0,-2,-2,-1,-1,0,0,0,-2,0,-2,-2,0,1], [0,-1,0,0,0,0,0,-1,-1,0,1,1,0,0,0,1,1,1,-1,1,1,0,0], [0,0,0,0,1,0,0,-1,-1,0,1,1,0,1,0,1,0,1,0,1,1,0,-1], [1,-1,0,0,0,0,0,0,0,1,-1,0,1,0,0,0,-1,0,0,-1,-1,0,1], [0,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,1,0,0,0,0,0,1,1,0,-1,0,0,0,0,0,0,-1,0,-1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,1,0,0,1,1,0,1,0,-1,0,-1,1,1,1,-1,0,0]]]], [ # Z-class [23][23] [[8], [2,4], [-2,3,8], [-2,1,6,8], [-2,1,3,4,6], [1,2,2,1,3,6], [2,0,-1,-1,0,4,6], [1,-1,-3,-4,-1,1,3,6], [0,-1,-3,-4,-2,-1,0,4,6], [-1,-1,-1,-2,0,-1,-1,1,2,4], [-3,-1,0,-1,1,0,0,2,0,2,6], [0,-1,-3,-3,-2,-1,1,3,2,0,2,4], [2,0,-2,-2,-1,1,1,1,1,0,-2,1,6], [0,0,-1,-1,2,3,1,1,0,0,1,0,3,6], [1,2,1,0,1,2,1,1,-1,-1,2,1,-1,1,4], [2,2,2,1,-1,0,0,-1,-1,-1,-1,0,1,-1,1,4], [3,0,-1,-1,-2,0,0,0,1,-1,-2,0,3,3,-1,2,8], [0,0,0,-1,-2,0,0,1,1,-1,1,1,0,1,1,1,3,4], [0,0,-1,-2,-2,-2,-1,1,1,0,1,1,-2,-2,1,0,-2,1,4], [3,0,-3,-3,-2,0,2,3,3,0,-2,1,0,-2,0,-1,-2,-1,2,6], [2,1,0,1,-1,0,1,0,1,-1,-3,0,0,-3,0,1,-2,-1,1,4,6], [1,3,3,4,2,1,-1,-3,-2,-2,-2,-2,-2,-1,2,1,-2,-1,1,1,4,8], [0,4,4,4,4,4,0,-2,-2,-2,0,-2,-2,2,4,0,-2,0,0,0,2,8,12]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,1,-2,3,-3,2,-3,3,-3,3,-4,3,-3,3,-3,2,-2,3,-1], [0,0,0,0,-2,1,-3,5,-5,4,-6,5,-5,5,-6,5,-6,6,-6,3,-4,4,-1], [0,0,0,0,-1,0,-1,2,-2,2,-2,1,-1,1,-2,2,-3,4,-4,2,-3,3,-1], [0,0,0,0,0,0,0,1,-1,1,0,0,0,0,-2,1,-1,2,-1,1,-1,1,0], [0,0,-1,1,-3,2,-2,4,-2,1,-2,1,-3,2,-3,2,-1,-2,1,-3,2,-2,2], [0,0,-1,1,-3,2,-2,3,-1,0,-1,0,-3,2,-1,1,1,-5,3,-5,5,-5,3], [1,-1,1,0,0,1,-1,0,-1,2,-3,5,-4,5,-4,4,-4,3,-2,2,-2,2,-1], [2,-2,3,-3,3,-2,2,-3,2,-1,0,2,0,1,-1,0,-2,2,-1,0,-1,2,-1], [1,-1,2,-3,4,-4,4,-4,3,-3,3,-3,3,-3,3,-4,3,-2,3,-3,4,-4,2], [0,1,-1,2,-1,1,-1,1,-1,1,-2,2,-3,3,-2,2,-1,0,1,0,1,-3,1], [1,-1,1,0,0,0,0,-1,1,0,-1,2,-2,3,-1,2,-2,1,-1,1,-1,1,-1], [1,-3,3,-3,3,-3,3,-4,2,-1,2,0,2,-1,1,0,-1,3,-3,4,-4,5,-2], [0,-1,1,-1,2,-2,3,-4,3,-3,5,-3,4,-4,2,-2,3,-2,2,1,0,-1,1], [0,1,-2,3,-3,3,-3,3,-2,2,-3,3,-4,4,-4,4,-3,1,-1,1,-1,0,0], [1,0,0,1,-2,1,-3,4,-4,4,-6,6,-6,7,-6,6,-7,6,-6,4,-5,5,-2], [1,-1,2,-2,2,-3,2,-2,1,-1,1,1,1,0,-1,1,-2,3,-3,3,-4,4,-1], [0,1,-1,2,-2,2,-2,2,-2,2,-3,4,-3,3,-3,3,-3,2,-2,2,-3,2,-1], [-1,2,-2,3,-2,3,-2,1,-1,1,-1,1,-1,1,0,0,1,-2,2,0,1,-2,0], [0,0,0,0,0,1,0,-1,1,0,0,0,0,0,1,-1,1,-2,2,-2,2,-1,0], [1,-1,1,-1,0,0,0,0,0,1,-2,1,-1,1,0,0,-1,0,0,-2,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-2,2,-2,2,-2,2,-2,2,-1]], [[-1,0,-1,0,-1,1,-1,1,0,-2,2,-3,1,-2,2,0,2,-3,1,-1,2,-2,1], [0,0,-1,2,-2,2,-2,3,-2,3,-4,3,-3,3,-3,4,-4,3,-2,2,-4,3,-1], [-1,1,-3,4,-4,4,-3,5,-3,4,-5,3,-4,3,-3,3,-2,0,1,-1,-2,1,0], [-1,1,-2,2,-2,2,-1,2,-2,3,-3,2,-2,1,-1,1,-1,1,0,0,-2,2,-1], [0,0,0,0,0,0,0,0,-1,2,-2,2,-1,2,-2,2,-3,4,-2,3,-4,4,-2], [-1,1,-1,1,0,0,1,-1,1,0,1,-1,1,0,0,1,-1,2,-1,3,-3,3,-2], [-2,2,-2,2,-1,2,-1,1,-1,1,0,0,0,0,0,1,0,1,-1,3,-2,2,-2], [0,0,0,0,0,1,-2,2,-2,1,-2,3,-2,3,-4,4,-4,4,-4,4,-4,4,-2], [1,0,1,0,1,-1,-1,1,-2,2,-3,5,-3,5,-5,5,-6,7,-6,6,-6,6,-3], [0,0,1,-1,1,-1,1,-1,1,-2,2,-2,2,-2,2,-3,4,-4,4,-3,4,-4,2], [0,-1,1,-1,1,0,1,-2,2,-2,2,-2,3,-3,2,-3,3,-3,3,-2,2,-2,1], [0,0,0,0,0,1,-1,0,0,0,0,1,0,0,-1,1,-1,1,-2,2,-2,2,-1], [0,0,1,-2,1,-2,2,-2,2,-3,4,-3,2,-2,1,-1,2,-2,0,0,1,-1,1], [0,-1,2,-3,4,-4,5,-7,5,-5,8,-6,7,-6,4,-4,4,-1,1,2,0,0,0], [0,-1,0,-1,1,0,1,-1,2,-2,2,-3,3,-4,2,-2,2,-2,2,-2,1,-1,1], [0,-1,0,0,-1,1,-1,2,-1,1,-2,1,-2,1,-1,2,-1,0,-1,0,-1,1,0], [0,-1,1,-1,2,-2,2,-4,2,-2,4,-2,2,-1,1,1,0,2,-3,5,-3,3,-2], [1,-2,2,-2,3,-3,3,-4,3,-2,2,-1,2,-1,1,0,-1,2,-2,2,-2,2,-1], [1,-2,2,-2,2,-2,1,-1,1,-1,0,0,1,-1,1,-1,0,0,0,-1,1,-1,1], [0,1,-1,1,-1,1,-2,3,-2,1,-2,2,-2,2,-2,2,-2,1,-1,0,0,0,0], [0,1,-1,1,-1,1,-1,2,-1,1,-2,2,-2,1,-1,1,-1,0,0,-1,0,0,0], [0,0,0,0,1,-1,2,-2,2,-1,2,-2,3,-4,3,-3,2,-1,2,-1,0,0,0], [0,0,0,0,2,-2,4,-4,4,-2,4,-4,6,-6,4,-4,2,0,2,0,-2,2,-1]]]], [ # Z-class [23][24] [[15], [2,12], [2,-4,12], [2,0,4,12], [2,-4,4,4,12], [2,0,4,0,0,12], [2,4,0,4,0,0,12], [2,0,-4,-4,-4,4,0,12], [2,0,0,-4,-4,0,0,0,12], [2,0,-4,-4,-4,0,-4,4,0,12], [-2,-4,4,0,0,4,-4,0,0,-4,12], [-2,-4,0,-4,0,0,0,4,4,0,0,12], [2,4,-4,-4,-4,-4,0,0,4,0,0,-4,12], [2,0,0,0,0,4,4,0,0,0,0,-4,0,12], [-2,0,0,-4,0,4,0,0,4,-4,4,4,0,0,12], [2,4,4,4,0,0,4,0,0,-4,0,0,0,-4,-4,12], [6,0,0,0,0,-4,0,-4,0,0,0,-4,4,4,0,-4,12], [2,4,-4,0,-4,0,4,0,4,0,-4,0,0,4,4,-4,4,12], [-2,-4,4,0,0,-4,0,-4,4,-4,4,4,0,-4,0,4,0,-4,12], [-2,4,-4,-4,-4,0,-4,4,0,4,-4,0,0,-4,0,0,-4,0,-4,12], [2,4,-4,0,-4,0,4,4,4,4,-4,0,4,0,-4,4,-4,0,0,0,12], [-2,-4,0,-4,-4,4,0,4,4,0,4,4,0,4,4,-4,0,4,0,-4,0,12], [-2,4,4,4,4,4,4,-4,0,-4,0,0,-4,0,4,4,-4,0,0,0,0,-4,12]], [[[3,-1,-1,-1,-4,-2,-1,1,0,-3,-1,-1,-1,-1,-2,-3,-1,-2,-1,-2,-1,1,5], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,-1,0,-1,1,0,-1,-1,0,0,0,-1,-1,0,0,0,-1,0,0,1], [0,0,0,0,-1,-1,-1,1,0,0,-1,-1,0,0,0,0,-1,0,0,-2,-1,0,1], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,-1,0,0,1,0,0,0,1], [0,0,-1,0,-2,-1,0,1,2,-1,-1,-1,-2,-1,0,0,1,-3,-2,-2,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,1,-1,0,0,1,0,0], [2,-1,-1,0,-2,0,0,-1,-1,-1,-1,1,1,0,-1,-1,-1,-1,0,0,-1,1,2], [2,-1,0,-2,-2,-1,0,0,0,-2,0,-1,-1,-1,-1,-2,-1,-1,-1,-1,0,0,2], [0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,1,1,1,1,1,0], [0,1,0,1,0,0,0,0,1,0,-1,0,-1,0,1,0,1,-2,0,0,0,1,-1], [2,-2,-1,-1,-2,-1,0,-1,-1,-1,0,0,0,0,0,0,-1,0,-1,0,0,0,2], [0,-1,0,0,0,0,0,0,-1,0,1,1,1,0,-1,0,0,1,0,1,0,0,1], [0,0,0,0,1,0,1,-1,0,0,1,1,0,0,-1,0,1,0,0,2,1,1,0], [0,1,-1,1,-1,0,-1,1,1,0,-2,-1,-1,0,1,0,0,-2,0,-2,-1,0,0], [2,-1,0,-1,-2,-2,-1,0,-1,-2,0,0,0,0,-1,-1,-1,0,-1,0,0,1,3], [0,0,0,0,0,0,0,0,0,0,0,1,1,0,-1,0,0,0,0,0,-1,0,1], [0,1,0,1,0,0,0,0,0,0,-1,0,0,0,1,0,0,-1,0,0,0,1,-1], [-2,1,1,1,3,2,1,-1,0,2,1,1,1,1,1,1,1,1,1,2,1,-1,-3], [2,-1,-1,-1,-3,-1,0,0,0,-1,-1,-1,-1,-1,0,-1,-1,-2,-1,-2,-1,0,2], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0]], [[-1,0,0,1,1,1,-1,0,-1,1,-1,1,1,1,1,2,1,1,1,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,1,1,1,-1,-1,0,0,0,0,0,-1,1,0,-2,1,1], [-2,1,0,1,2,1,1,1,1,2,0,0,0,0,1,1,1,0,1,0,-1,-1,-2], [0,0,0,0,0,0,0,0,-1,1,0,0,1,0,0,0,-1,1,1,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0], [-2,1,1,1,3,1,1,0,0,3,1,1,1,1,1,2,0,2,1,1,0,-1,-3], [-2,1,1,1,2,2,0,0,0,1,0,1,1,1,1,1,1,1,1,1,1,-1,-3], [2,-1,-1,-1,-2,-1,-1,0,0,-2,-1,0,0,0,-2,-1,-1,-1,-1,-1,-1,1,3], [0,1,1,1,1,0,-1,0,-1,0,0,1,1,1,1,0,0,1,1,1,1,0,-1], [0,-1,0,-1,-1,0,1,0,1,-1,0,-1,-1,-1,-1,-1,1,-1,-1,0,0,0,1], [0,0,0,1,1,1,0,-1,-1,1,0,1,2,1,0,0,-1,1,1,1,0,0,-1], [0,0,0,-1,-1,0,0,0,1,-1,0,0,-1,-1,-1,0,1,-1,-2,-1,0,0,1], [0,0,1,0,0,-1,0,0,-1,0,1,1,0,1,0,0,0,1,0,1,1,0,0], [0,-1,0,-1,1,1,1,-2,-1,0,2,1,1,0,-2,0,0,2,0,2,1,0,0], [0,0,-1,0,-1,0,0,2,2,0,-2,-2,-1,-1,0,0,0,-2,0,-2,-2,0,1], [0,-1,0,0,0,0,0,-1,-1,0,1,1,0,0,0,1,1,1,-1,1,1,0,0], [0,0,0,0,1,0,0,-1,-1,0,1,1,0,1,0,1,0,1,0,1,1,0,-1], [2,-2,-1,-1,-2,-1,0,0,0,-1,-1,-1,0,-1,-1,-1,-1,-1,-1,-1,-1,1,3], [0,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,1,0,0,0,0,0,1,1,0,-1,0,0,0,0,0,0,-1,0,-1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,1,0,0,1,1,0,1,0,-1,0,-1,1,1,1,-1,0,0]]]], [ # Z-class [23][25] [[9], [-2,8], [2,0,8], [0,2,-2,8], [2,-4,0,0,8], [-2,2,-4,4,0,8], [3,0,0,0,0,-2,5], [-1,-2,0,0,0,-2,-1,5], [4,-4,-2,0,4,0,2,0,8], [4,2,2,-2,-2,0,0,-2,-2,8], [3,0,0,2,0,2,-1,-1,0,2,5], [2,2,-2,4,2,2,2,-2,2,0,0,8], [-4,2,0,2,-4,0,0,2,-4,-2,-2,-2,8], [-4,4,0,4,-2,2,-2,0,-4,-2,0,2,4,8], [-3,0,2,2,-2,2,-1,-1,-4,0,1,-2,4,2,9], [1,2,-2,4,-2,2,1,1,0,0,1,2,2,2,-1,5], [4,2,-2,2,2,2,0,0,2,2,2,4,-2,0,-4,2,8], [-1,0,0,2,2,0,1,1,2,-4,-1,2,0,2,-1,1,0,5], [4,2,0,-2,0,0,2,-2,0,4,2,2,-2,-2,-2,0,4,-2,8], [-3,2,2,0,-2,-2,-1,1,-2,-2,-1,-2,2,2,1,-1,-2,1,-2,5], [2,-4,0,2,4,-2,2,2,4,-4,0,0,0,-2,0,0,0,2,-2,0,8], [2,-4,4,-4,4,-4,0,0,2,0,0,-2,-4,-4,0,-4,-2,0,0,0,2,8], [3,0,2,0,-2,-2,1,1,0,2,1,-2,0,-2,-1,1,0,-1,0,1,0,0,5]], [[[2,1,0,-2,1,0,-2,0,0,-1,0,1,0,0,1,1,-1,0,0,1,0,-1,0], [1,1,-1,-3,0,1,-1,0,-1,0,1,2,1,0,0,0,-1,0,-1,0,2,0,1], [0,-1,0,1,0,0,0,-1,-1,1,1,0,1,-1,-1,0,0,1,0,1,0,0,-1], [1,0,0,-3,0,2,-1,0,-1,0,1,3,2,-1,-1,0,-1,0,-1,1,1,0,1], [-1,-1,1,2,-1,-1,0,-1,0,-1,-1,-1,-1,0,0,0,1,0,1,-1,-1,0,0], [0,0,0,-2,-1,2,0,0,0,0,1,2,2,0,-1,-1,0,0,-1,0,1,1,1], [1,1,0,-1,1,-1,-2,0,0,-1,0,1,0,-1,1,1,-1,0,0,0,0,-1,0], [0,0,0,1,0,0,0,0,0,0,-1,-1,-1,0,0,0,0,0,1,0,0,0,0], [-1,0,1,2,0,-2,-1,-1,1,-1,-2,-2,-2,0,1,1,1,0,1,-1,-1,-1,0], [2,1,-1,-2,0,1,-1,1,0,0,0,1,0,1,1,0,-1,0,0,1,1,0,0], [1,0,0,-2,0,1,0,0,0,0,1,1,1,0,0,0,0,0,-1,1,0,0,0], [3,1,-1,-2,0,1,-3,0,-1,-1,-1,2,1,0,0,0,-2,0,0,0,1,0,1], [0,0,0,-1,0,2,1,1,-1,1,2,2,2,-1,-2,-1,-1,0,-1,1,1,1,0], [3,1,-1,-3,0,3,0,1,-2,0,2,3,3,-1,-2,-1,-2,0,-2,1,1,1,0], [-2,-2,1,1,-1,1,2,0,0,2,2,1,2,-1,-2,-1,1,0,-1,1,0,1,-1], [3,2,-1,-4,1,2,-2,1,-1,-1,1,3,2,-1,0,0,-2,0,-1,1,1,0,1], [1,1,0,-2,0,1,-1,0,0,-1,0,1,0,1,0,0,-1,-1,0,0,1,0,1], [1,0,0,0,0,0,-1,-1,-1,-1,-1,0,0,-1,0,1,0,0,0,0,0,0,0], [2,1,-1,-2,0,0,-2,0,0,-1,0,1,0,1,1,0,-1,0,0,0,1,0,1], [-2,-1,0,1,0,-1,1,-1,0,1,0,-1,-1,0,0,1,1,0,0,0,0,0,0], [-3,-1,2,2,0,-2,0,-1,1,0,0,-1,-1,-1,0,1,1,0,1,-1,-1,-1,0], [-2,-1,1,4,0,-3,1,-1,1,0,-1,-3,-2,0,1,0,2,0,1,-1,-2,-1,-1], [0,0,0,-1,1,0,0,0,0,0,0,0,-1,0,1,1,0,0,0,1,0,-1,0]], [[0,0,-1,-1,0,1,-1,0,0,1,1,1,2,0,-1,0,-1,1,0,0,1,1,1], [1,1,0,-1,0,0,-1,0,0,0,1,1,1,-1,0,0,0,0,-1,0,0,0,-1], [-3,-1,1,1,0,-1,2,0,1,1,2,0,1,-1,-1,0,1,-1,-1,0,-1,0,-1], [0,2,0,0,1,-1,-1,1,1,0,0,0,-1,0,1,0,-1,0,0,-1,0,-1,0], [1,1,-1,-1,1,0,0,1,0,0,0,0,0,1,1,0,-1,0,0,0,0,0,1], [1,2,0,-2,1,0,-2,0,0,-1,0,1,0,0,1,0,-1,0,0,-1,1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [1,0,0,-1,0,1,0,1,0,0,0,1,0,0,0,0,-1,0,0,1,0,0,0], [1,0,-1,-1,0,1,-1,0,-1,0,-1,0,0,1,0,1,-1,1,1,0,1,1,1], [0,0,0,-1,0,1,0,0,0,0,2,1,2,-1,-1,-1,0,0,-1,0,0,0,0], [1,1,-1,-1,0,0,-2,0,0,0,0,1,1,0,0,-1,-1,1,0,-1,1,0,1], [0,0,0,1,0,0,0,0,0,1,0,-1,0,0,0,0,0,1,0,0,0,0,-1], [-2,0,1,0,0,-1,1,0,1,0,0,0,-2,0,1,1,1,-1,0,0,0,-1,0], [-2,0,1,2,-1,-1,1,0,1,1,0,-1,-1,0,0,-1,1,0,0,-1,0,0,-1], [-2,1,1,0,1,-2,1,0,1,-1,1,0,-1,-1,1,0,1,-1,-1,-1,-1,-2,0], [1,1,0,-1,0,1,-1,1,0,0,0,1,0,0,0,0,-1,0,0,0,1,0,0], [3,1,-2,-3,0,2,-3,0,-1,1,0,2,2,0,0,0,-2,2,0,1,2,1,1], [1,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,-1], [1,0,-1,-2,0,0,-2,-1,0,0,0,1,1,0,1,1,0,1,0,0,1,0,1], [0,0,0,1,0,-1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,-1], [1,1,-1,-1,1,0,0,1,0,0,-1,0,-1,1,1,1,-1,0,0,0,0,0,1], [-1,-1,0,1,0,-1,1,0,0,0,0,-1,0,0,0,0,1,0,0,0,-1,0,0], [0,0,0,0,0,0,-1,0,0,0,1,1,1,-1,-1,0,-1,0,0,0,0,0,0]]]], [ # Z-class [23][26] [[4], [-1,4], [0,0,4], [0,1,-1,4], [-1,2,0,1,4], [0,-1,0,1,0,4], [-1,1,-2,2,1,0,4], [1,-1,0,0,-1,0,-2,4], [0,0,1,0,-1,0,-1,1,4], [2,-1,0,1,-1,0,0,1,0,4], [-1,0,1,-1,0,0,-1,1,0,1,4], [1,0,0,0,-1,1,-1,2,1,2,1,4], [-1,0,1,1,2,1,0,0,-1,0,1,0,4], [1,2,1,0,1,0,-1,1,0,1,1,2,0,4], [2,-1,-1,-1,-1,0,0,1,0,2,1,1,-2,1,4], [0,1,0,0,2,-1,1,-2,-2,0,-1,-1,1,0,-1,4], [-1,2,-1,1,2,-2,1,0,1,-1,-1,-1,0,0,-1,1,4], [-2,1,0,-1,2,-1,1,-1,-1,-1,2,-1,1,0,0,1,1,4], [-1,1,0,0,-1,1,0,-1,2,-1,-1,1,-1,0,-1,-1,0,-1,4], [-1,1,0,1,2,-1,2,-2,-2,-1,-1,-2,2,-1,-2,2,1,1,-1,4], [1,1,0,0,-1,-1,-1,2,1,1,1,2,-1,2,1,-2,0,-1,0,-1,4], [-1,1,1,0,1,1,-1,1,-1,0,2,2,2,2,-1,0,-1,1,0,0,1,4], [-1,1,2,-2,1,-1,-1,0,0,0,2,1,1,2,0,1,0,2,0,0,0,2,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,2,-1,0,-1,0,0,-2,1,0,0,0,2,2,0,0,1,1,1,0,0], [1,0,0,2,0,0,0,-1,-1,-1,0,0,1,-1,0,0,0,0,0,-2,1,-1,2], [-1,-1,0,0,-1,0,0,0,1,-1,0,0,0,2,1,1,0,0,0,1,0,0,-1], [0,0,1,1,0,0,0,0,-1,-1,0,0,0,-1,1,1,0,0,1,-1,1,0,0], [-1,1,-2,-2,-2,1,-1,1,4,2,-1,-1,-1,3,0,0,-1,1,-1,4,-3,2,-2], [-1,-1,0,1,-1,0,-1,0,1,-1,0,1,-1,1,1,1,0,1,0,2,0,0,-1], [0,0,0,-1,1,0,1,0,0,1,-1,-2,1,-1,0,0,0,-1,0,-2,1,1,1], [-1,0,-1,0,-1,0,-1,0,2,0,0,0,0,2,0,1,-1,0,-1,2,-1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [1,1,0,1,0,1,0,0,-1,0,-1,-1,1,-3,0,0,0,0,0,-2,2,-1,3], [-1,1,-2,-1,-2,1,-2,1,4,2,-1,-2,-1,2,1,1,-1,1,-1,4,-2,2,-1], [0,1,0,0,0,1,0,0,0,1,-1,-1,0,-1,0,0,0,0,0,-1,1,0,1], [0,0,-1,1,-1,1,-1,1,1,0,0,-2,0,0,1,2,-1,1,1,1,1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [1,-1,2,1,1,-1,1,0,-3,-1,1,1,0,-1,0,0,1,0,2,-2,1,-1,0], [0,-1,1,0,1,-1,1,0,-1,-1,1,0,0,0,0,1,0,-1,1,-1,1,0,-1], [1,0,1,2,1,0,0,0,-2,-1,0,0,0,-3,0,0,0,0,1,-2,2,-1,2], [-1,0,-2,-1,-2,1,-2,1,4,1,1,0,-2,4,0,1,-1,1,-1,6,-3,1,-3], [0,0,1,1,0,0,0,-1,-1,-1,0,1,0,-1,1,0,1,0,0,-1,1,0,0], [-1,1,-1,0,-1,0,-1,0,2,0,-1,-1,1,0,2,1,-1,0,-1,1,0,1,0], [0,1,-1,0,-1,1,-1,1,2,1,-1,-2,0,0,1,1,-1,1,0,1,0,1,0], [1,0,0,2,0,1,-1,0,-1,0,0,-1,0,-2,0,1,0,1,1,-1,2,-1,2]], [[-2,0,-2,-1,-2,0,-2,1,4,1,0,0,-1,4,1,1,-1,1,-1,5,-3,1,-3], [1,0,0,0,0,1,0,-1,0,0,0,0,0,-1,0,0,1,0,0,0,1,0,1], [0,0,0,1,-1,0,-1,-2,-1,-1,-1,1,1,-1,1,-1,1,0,-1,-1,1,0,1], [0,0,0,-2,0,0,1,0,1,1,1,-1,0,1,0,0,1,-1,0,1,-1,2,-2], [1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,1,0,0,0], [0,0,0,1,0,-1,0,-1,0,-1,1,1,0,0,0,-1,0,-1,-1,0,-1,0,0], [0,-1,1,0,1,-1,1,0,0,-1,1,0,0,0,1,1,0,-1,1,0,0,1,-1], [0,0,0,-1,-1,1,1,1,0,1,0,-1,0,1,-1,0,1,0,0,0,0,0,0], [1,-1,0,1,0,0,1,-1,-2,-1,0,0,1,-1,-1,0,1,0,0,-3,2,-1,2], [-1,-1,-1,-2,-1,0,0,1,3,1,1,-1,-1,3,0,1,0,0,0,3,-2,2,-3], [1,0,0,-1,0,0,1,0,0,0,1,0,-1,0,-1,-1,1,-1,0,0,-1,1,0], [0,-1,0,1,-1,1,0,0,0,-1,1,0,0,0,0,1,1,0,0,0,1,-1,1], [1,0,1,0,1,0,1,0,-2,0,1,0,0,-2,0,-1,1,-1,1,-1,1,0,1], [0,0,-1,0,-2,1,-1,-1,2,0,0,0,0,1,1,0,1,0,-1,2,-1,1,0], [-1,-1,-1,-1,-1,-1,0,1,3,0,1,0,-1,4,0,1,-1,0,0,3,-3,1,-3], [0,0,0,0,0,0,-1,1,1,0,0,0,0,0,1,1,-1,1,1,2,0,0,-1], [1,0,0,-1,0,1,1,1,0,1,0,-1,0,0,-1,1,0,1,1,0,1,0,0], [1,0,1,0,1,-1,1,0,-1,-1,1,1,0,-1,0,0,0,-1,1,-1,0,0,0], [1,-1,1,3,1,0,0,-2,-3,-2,0,1,1,-3,0,0,1,0,0,-4,3,-2,3], [0,0,1,0,1,0,0,0,-1,0,0,0,0,-1,1,0,0,0,1,0,1,0,0], [0,0,-1,-1,-1,2,0,0,1,1,0,-1,-1,1,-1,0,1,0,-1,1,0,0,1], [1,0,1,1,0,1,0,-1,-2,-1,1,1,0,-2,0,-1,2,-1,0,-1,1,-1,2], [1,-1,1,2,0,0,0,-1,-2,-2,0,1,1,-2,1,0,1,0,1,-2,2,-1,2]]]], [ # Z-class [23][27] [[12], [3,12], [6,6,12], [-3,-3,-6,12], [6,3,6,-6,12], [3,0,3,-6,6,10], [3,6,6,-3,0,-2,10], [6,6,6,-6,6,4,4,10], [-6,-6,-6,3,-6,-4,-1,-4,10], [-3,-3,-6,0,-3,-1,-4,-4,1,10], [3,6,3,-6,0,0,3,3,-3,0,12], [-6,3,-3,6,-6,-3,0,-3,0,0,0,12], [-3,-6,-6,3,0,1,-5,-5,2,5,-6,0,10], [0,0,-3,-3,3,1,-2,1,-1,5,0,-3,4,10], [3,6,6,-3,3,-1,5,2,-5,-2,3,0,-4,-1,10], [3,0,3,-6,0,2,2,2,-2,1,6,-3,-4,-1,1,10], [3,-3,3,0,3,-1,2,2,1,-5,-3,-3,-1,-1,1,1,10], [6,6,3,0,0,-3,6,3,-3,-3,6,0,-6,-3,3,3,0,12], [0,-3,-3,6,-3,-5,-2,-2,2,-1,-3,0,1,1,-1,-4,2,0,10], [-6,-6,-3,6,-6,-6,0,-6,6,0,-6,3,3,-3,-3,-3,3,-3,3,12], [-6,-3,0,-3,0,2,-1,-1,4,1,-3,0,2,-1,-2,1,1,-6,-4,3,10], [-6,0,0,3,-3,-4,2,-4,4,-2,-3,3,-1,-4,1,-2,1,0,-1,6,4,10], [0,-3,-3,-3,3,2,-1,2,1,1,0,-3,2,2,-2,1,1,0,-1,0,1,-2,10]], [[[1,4,0,-2,1,1,1,-3,2,2,-1,1,0,-2,-2,1,2,-2,2,-1,-2,1,1], [0,1,-1,-1,1,1,1,0,0,2,1,0,0,-2,-1,0,1,-1,2,0,-1,1,0], [-1,2,0,-1,1,1,1,0,1,2,0,0,1,-2,-1,1,1,-1,2,0,-2,1,0], [1,1,1,-2,-1,-1,-2,-2,1,-1,-2,1,-1,1,0,0,0,1,-1,0,0,-1,1], [0,1,0,0,0,0,1,0,0,1,0,0,1,-1,-1,1,1,-1,1,-1,-1,1,0], [0,1,1,1,0,1,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,0,0], [-1,-1,-2,-1,2,0,2,1,-1,1,1,0,0,-2,-1,0,0,-1,1,0,-1,1,-1], [0,0,0,1,1,1,1,1,1,1,1,0,1,-1,0,1,0,-1,1,0,-1,1,0], [0,-4,-1,0,0,-2,0,2,-2,-2,0,0,0,1,1,-1,-2,1,-2,0,1,0,-1], [-1,0,1,2,-1,1,-1,0,0,0,1,-1,0,1,1,-1,1,1,-1,0,1,-1,0], [1,1,-2,-1,1,1,2,-1,-1,2,1,0,-1,-2,-1,-1,1,-2,2,0,0,1,0], [0,-1,0,0,0,0,-1,0,0,-1,0,0,-1,1,1,0,-1,1,0,1,1,-1,0], [0,0,1,0,-1,-1,-1,-1,0,-1,-1,0,0,1,0,0,0,1,-1,-1,1,-1,0], [0,1,0,2,0,1,0,0,0,1,1,-1,0,0,0,0,1,0,0,0,1,0,0], [-1,1,-1,0,0,1,1,0,-1,1,1,-1,0,-1,-1,0,1,-1,1,0,-1,1,0], [0,2,-1,-1,1,0,1,-1,0,1,0,0,0,-2,-1,0,1,-2,1,0,-1,0,0], [0,1,-1,-1,1,-1,1,-1,0,0,-1,0,0,-1,-1,1,0,-1,0,0,-1,0,0], [1,0,-2,-3,1,-1,2,-1,-1,1,0,1,-1,-2,-2,-1,1,-2,1,-1,-1,1,0], [1,1,1,0,-1,0,-1,-1,1,0,-1,0,-1,1,0,0,0,0,-1,0,0,0,1], [-1,-3,0,1,0,-1,-1,2,0,-2,0,0,0,2,2,0,-2,2,-2,1,1,-1,-1], [-2,-2,0,1,0,-1,0,2,-1,-1,0,-1,1,0,1,0,-1,1,-1,0,0,-1,-1], [-1,-3,-1,-1,0,-2,0,2,-2,-1,0,0,0,0,0,-1,-1,1,-1,0,0,0,-1], [0,-3,-1,2,0,0,1,2,-1,-1,1,0,0,1,1,0,-1,0,-1,0,1,0,-1]], [[1,4,0,-3,-1,0,-1,-3,0,1,-2,0,-1,-1,-2,0,2,-1,1,0,-1,0,1], [2,2,1,-1,0,0,0,-3,1,1,-1,1,-1,0,-1,0,1,-1,1,-1,0,0,1], [1,3,0,-1,0,1,0,-2,1,2,-1,0,-1,-1,-1,0,2,-1,1,0,-1,0,1], [0,2,0,-2,1,0,-1,-1,2,0,-1,1,1,-1,0,1,0,0,1,0,-1,0,0], [0,-1,0,0,-1,0,0,0,-1,0,0,0,-1,1,0,-1,1,0,-1,0,0,0,0], [-1,-1,0,0,-1,-1,1,0,-2,0,0,-1,0,0,-1,-1,1,0,-1,-1,0,0,0], [1,2,1,0,-1,1,-1,-1,1,1,0,0,0,0,0,0,1,0,1,0,0,0,1], [1,1,0,-1,-1,-1,0,-2,-1,0,-1,0,-1,0,-1,0,1,-1,0,-1,0,0,1], [-1,-3,-1,2,0,0,0,3,-1,-2,2,-1,1,1,2,0,-2,1,-1,1,1,0,-1], [0,-1,-1,1,1,0,1,1,-1,0,1,0,0,0,0,0,-1,0,0,1,1,0,-1], [1,-1,1,1,0,0,0,0,0,0,0,0,-1,1,0,0,-1,0,0,0,1,0,0], [0,1,1,-1,1,0,0,-1,2,1,-1,1,1,-1,0,1,0,0,1,-1,-1,0,0], [-1,-2,0,1,0,0,0,2,0,-1,1,0,1,1,1,0,-1,1,-1,1,0,0,-1], [0,-3,-1,1,0,-1,1,1,-2,-1,1,0,-1,1,0,-1,-1,0,-1,0,1,0,-1], [1,4,1,-2,0,1,-1,-3,2,2,-2,1,-1,-1,-1,0,2,0,1,0,-1,-1,1], [0,0,0,1,-1,0,0,1,-1,0,0,-1,0,0,0,0,0,0,0,0,1,0,0], [0,1,-1,-2,-1,0,-1,0,0,0,-1,0,0,-1,0,0,1,0,0,0,-1,0,0], [2,1,1,-2,-1,-1,-1,-1,0,0,-1,1,0,0,-1,0,0,-1,1,-1,0,1,1], [0,0,0,-1,1,-1,-1,0,1,-1,-1,1,0,0,0,1,-1,0,0,0,-1,0,0], [-1,1,0,1,1,2,0,1,2,1,1,0,1,-1,1,1,0,0,1,1,-1,0,0], [-1,-3,-1,3,0,1,1,3,-1,-1,2,-1,1,1,2,0,-1,1,-1,1,1,0,-1], [0,0,0,1,0,1,0,1,1,0,1,0,1,0,1,0,0,0,0,0,0,0,0], [-1,-3,1,2,-1,0,0,2,-1,-1,1,0,0,2,1,0,-1,1,-1,0,1,0,0]]]], [ # Z-class [23][28] [[24], [-12,24], [12,-12,24], [-6,12,-12,20], [-6,-6,6,-10,20], [-6,-6,6,-6,6,24], [-6,-6,0,-2,10,0,20], [6,0,6,4,-8,6,-10,20], [6,6,-6,10,-8,-6,-10,2,20], [12,0,6,-4,-4,-6,-2,-2,4,20], [-6,12,-12,14,-4,-12,4,-2,4,2,23], [-6,6,-12,10,-2,0,2,2,2,-8,10,20], [-6,-6,6,-8,10,12,2,2,-10,-8,-8,2,20], [12,-6,12,0,0,0,-6,12,6,0,-6,0,0,24], [-6,0,-6,-4,8,-6,10,-8,-8,-4,2,4,4,-6,20], [-6,-6,6,-2,10,6,8,-4,-4,-8,-2,-4,8,0,-2,20], [12,-12,0,-2,-8,-6,-4,2,2,-2,-5,2,-4,6,-2,-4,23], [6,0,6,0,-6,-6,-6,6,0,0,-3,-6,0,6,0,0,3,15], [12,-6,12,-2,-2,-6,-4,2,2,4,-2,-4,-4,12,-8,2,8,6,20], [12,-12,0,-2,-2,0,-4,2,8,4,-5,2,2,6,-2,-4,11,-3,2,23], [-12,6,0,6,6,6,0,6,0,-6,6,0,6,0,0,6,-12,0,-6,-6,24], [-12,12,-6,6,0,6,0,0,0,-6,3,6,0,-6,0,0,-9,-3,-6,-9,6,15], [6,-12,12,-4,2,6,-2,10,-2,-4,-10,-8,4,12,-4,4,4,6,4,4,6,-6,20]], [[[0,0,1,0,-1,1,1,-1,1,-2,2,-2,1,1,0,-2,0,0,0,0,0,0,-1], [0,2,-2,1,3,1,2,3,2,2,0,-2,2,-2,1,0,3,0,2,-1,-1,0,1], [-2,-2,1,-1,-1,-1,0,0,0,-1,0,1,-1,0,-1,-1,-2,1,0,1,0,0,-1], [1,1,-1,1,1,0,0,0,-1,1,-1,0,0,0,0,1,1,0,0,0,1,0,0], [0,-1,1,0,-1,-1,-2,-1,-2,0,-1,2,-2,0,0,1,-2,0,-1,1,0,0,0], [-1,-3,1,-2,-2,-2,-2,-2,-2,-1,-1,3,-3,1,-2,1,-3,1,-2,1,1,0,-1], [0,-1,0,1,0,0,-2,0,-1,1,-1,1,-1,0,1,1,-1,0,0,0,0,0,0], [0,-1,-1,0,0,0,1,0,0,-1,1,-2,1,1,-1,-1,0,0,0,0,0,1,-1], [1,2,0,0,0,1,1,-1,0,0,0,0,0,0,0,0,1,0,0,0,1,-1,0], [0,3,0,0,1,3,3,1,3,-1,2,-3,2,-1,1,-2,2,1,2,0,-1,-1,0], [2,3,-1,2,2,2,1,1,0,0,0,-2,1,-1,1,0,2,0,1,0,0,-1,0], [1,0,0,1,1,0,-1,0,-1,0,0,0,-1,0,0,1,0,0,-1,0,0,0,0], [0,-2,0,-1,-1,-2,-1,0,-1,0,-1,2,-1,0,-1,1,-2,0,-1,0,0,1,0], [-1,-1,1,0,0,0,0,-1,-1,-1,1,0,-1,1,-1,-1,-1,1,-1,1,0,0,-1], [1,0,-1,1,0,0,-1,1,0,1,0,-1,1,0,2,1,0,-2,1,-1,-1,1,1], [0,-2,0,0,-1,-2,-2,-1,-2,1,-2,3,-1,0,-1,1,-2,0,-1,0,1,0,0], [0,0,1,0,0,0,0,-1,0,-1,1,0,0,1,-1,-1,0,0,-1,0,0,0,0], [0,-1,-1,0,0,-1,1,1,1,0,0,-1,2,0,0,-1,0,-1,1,-1,0,1,0], [-2,-1,2,0,0,-1,0,0,0,-1,0,1,-1,0,-1,-1,-1,1,-1,1,0,-1,-1], [1,1,1,0,-1,1,0,-2,0,-1,1,0,0,1,0,0,0,0,-1,0,0,0,0], [1,0,-1,0,0,-1,0,0,-2,0,-2,1,-1,0,-1,1,-1,0,0,1,1,0,-1], [-1,-1,0,0,1,-1,-1,1,0,1,-1,1,-1,-1,0,1,0,0,0,0,0,0,0], [0,-2,0,-1,-2,-1,-1,-2,-2,-1,0,1,-1,2,-1,0,-2,0,-1,1,1,1,-1]], [[0,-1,1,0,-1,1,0,-1,0,-2,2,-2,0,1,0,-1,0,0,-1,0,0,0,-1], [1,1,-3,1,2,1,1,2,2,3,0,-1,3,-1,1,0,2,-1,2,-2,-1,1,2], [-1,1,1,0,0,1,1,0,1,-1,2,-2,1,0,0,-1,1,0,0,0,-1,-1,0], [1,0,-2,0,1,0,1,2,1,1,-1,0,1,-1,0,0,0,0,1,-1,0,0,0], [-1,0,2,1,0,-1,-2,-1,-2,0,-1,2,-2,0,0,1,-1,0,-1,1,0,-1,0], [-1,0,1,-1,-1,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,-1,-1,-1,-2,0,-2,2,-2,0,0,1,-2,0,0,1,1,-1,0], [0,-1,0,-1,-1,0,0,0,1,0,1,0,1,0,0,0,0,0,0,-1,0,0,0], [1,0,-1,1,1,1,1,1,1,0,1,-2,2,0,0,-1,1,0,0,-1,-1,1,0], [0,-1,-1,1,0,1,0,0,1,0,2,-3,2,1,1,-1,1,-1,0,-1,-1,1,0], [2,-1,-2,1,0,-1,-1,0,-1,1,-2,1,0,0,0,1,-1,-1,0,-1,1,0,0], [1,-1,-1,0,0,-1,-1,0,-1,1,-2,2,-1,0,0,1,-1,0,0,-1,1,0,0], [-1,0,2,-1,0,-1,-1,-1,-1,-1,0,2,-2,0,-1,0,-1,1,-1,1,0,-1,0], [-1,-1,0,0,0,0,0,1,1,0,1,-1,1,0,0,0,0,0,0,-1,-1,0,0], [0,-1,1,0,-1,-1,-2,-2,-2,0,-1,2,-2,1,0,1,-2,0,-1,1,1,0,0], [0,1,1,0,0,-1,0,0,-1,-1,-1,1,-1,-1,-1,0,-1,0,0,1,0,-1,0], [0,-1,1,-1,-1,0,0,-1,-1,-2,0,0,-2,1,-1,0,-1,1,-1,1,1,0,-2], [0,0,0,-1,0,0,1,0,1,-1,1,-1,1,0,-1,-1,0,0,0,0,0,0,0], [0,1,-1,1,2,1,2,2,2,0,1,-3,2,-1,0,-1,2,0,1,-1,-1,0,0], [-1,-2,2,0,0,0,-1,-1,-1,-2,1,0,-2,1,-1,-1,-1,2,-2,1,0,0,-2], [0,-1,0,0,0,-2,-1,0,-1,1,-1,2,0,0,-1,1,-1,0,-1,0,0,0,0], [0,1,-1,0,1,0,1,1,1,2,-1,1,1,-1,0,0,1,0,1,-1,0,0,1], [-2,-1,2,-1,-1,-1,0,0,0,-1,0,1,-1,0,-1,0,-1,1,-1,1,0,-1,-1]]]] ]; MakeImmutable( IMFList[23].matrices ); gap-4r6p5/grp/classic.gi0000644000175000017500000017250212172557252013702 0ustar billbill############################################################################# ## #W classic.gi GAP group library Frank Celler #W & Heiko Theißen #W & Thomas Breuer ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland ## ############################################################################# ## #M SymplecticGroupCons( , , ) ## InstallMethod( SymplecticGroupCons, "matrix group for dimension and finite field size", [ IsMatrixGroup and IsFinite, IsPosInt, IsPosInt ], function( filter, d, q ) local g, f, z, o, mat1, mat2, i, size, qi, c; # the dimension must be even if d mod 2 = 1 then Error( "the dimension must be even" ); fi; f := GF(q); z := PrimitiveRoot( f ); o := One( f ); #T introduce variable d_2 = d/2 ? # if the dimension is two it is a special linear group if d = 2 then g := SL( 2, q ); #T no form for SL(2,q) if constructed like this? #T better add the form in the SL(2,q) call # construct the generators else # SP(4,2) if d = 4 and q = 2 then mat1 := [ [1,0,1,1], [1,0,0,1], [0,1,0,1], [1,1,1,1] ] * o; mat2 := [ [0,0,1,0], [1,0,0,0], [0,0,0,1], [0,1,0,0] ] * o; # SP(d,q) else mat1 := IdentityMat( d, f ); mat2 := List( 0 * mat1, ShallowCopy ); for i in [ 2 .. d/2 ] do mat2[i][i-1]:= o; od; for i in [ d/2+1 .. d-1 ] do mat2[i][i+1]:= o; od; if q mod 2 = 1 then mat1[ 1][ 1] := z; mat1[ d][ d] := z^-1; mat2[ 1][ 1] := o; mat2[ 1][d/2+1] := o; mat2[d-1][ d/2] := o; mat2[ d][ d/2] := -o; elif q <> 2 then mat1[ 1][ 1] := z; mat1[ d/2][ d/2] := z; mat1[d/2+1][d/2+1] := z^-1; mat1[ d][ d] := z^-1; mat2[ 1][d/2-1] := o; mat2[ 1][ d/2] := o; mat2[ 1][d/2+1] := o; mat2[d/2+1][ d/2] := o; mat2[ d][ d/2] := o; else mat1[ 1][ d/2] := o; mat1[ 1][ d] := o; mat1[d/2+1][ d] := o; mat2[ 1][d/2+1] := o; mat2[ d][ d/2] := o; fi; fi; mat1:=ImmutableMatrix(f,mat1,true); mat2:=ImmutableMatrix(f,mat2,true); # avoid to call 'Group' because this would check invertibility ... g := GroupWithGenerators( [ mat1, mat2 ] ); SetName( g, Concatenation("Sp(",String(d),",",String(q),")") ); SetDimensionOfMatrixGroup( g, Length( mat1 ) ); SetFieldOfMatrixGroup( g, f ); # add the size size := 1; qi := 1; for i in [ 1 .. d/2 ] do qi := qi * q^2; size := size * (qi-1); od; SetSize( g, q^((d/2)^2) * size ); fi; # construct the form c := List( 0 * One( g ), ShallowCopy ); for i in [ 1 .. d/2 ] do c[i][d-i+1] := o; c[d/2+i][d/2-i+1] := -o; od; SetInvariantBilinearForm( g, rec( matrix:= ImmutableMatrix( f, c, true ) ) ); SetIsFullSubgroupGLorSLRespectingBilinearForm(g,true); SetIsSubgroupSL(g,true); # and return return g; end ); InstallMethod( SymplecticGroupCons, "matrix group for dimension and finite field", [ IsMatrixGroup and IsFinite, IsPosInt, IsField and IsFinite ], function(filt,n,f) return SymplecticGroupCons(filt,n,Size(f)); end); ############################################################################# ## #M GeneralUnitaryGroupCons( , , ) ## InstallMethod( GeneralUnitaryGroupCons, "matrix group for dimension and finite field size", [ IsMatrixGroup and IsFinite, IsPosInt, IsPosInt ], function( filter, n, q ) local g, i, e, f, z, o, mat1, mat2, size, qi, eps, c; f:= GF( q^2 ); # Handle the trivial case first. if n = 1 then g:= GroupWithGenerators( [ [ [ PrimitiveRoot( f ) ^ (q-1) ] ] ] ); SetName( g, Concatenation("GU(1,",String(q),")") ); #T no form? return g; fi; # Construct the generators. z:= PrimitiveRoot( f ); o:= One( f ); mat1:= IdentityMat( n, f ); mat2:= List( 0 * mat1, ShallowCopy ); if n = 2 then # We use the isomorphism of 'SU(2,q)' and 'SL(2,q)': # 'e' is mapped to '-e' under the Frobenius mapping. e:= Z(q^2) - Z(q^2)^q; if q = 2 then mat1[1][1]:= z; mat1[2][2]:= z; mat1[1][2]:= z; mat2[1][2]:= o; mat2[2][1]:= o; else mat1[1][1]:= z; mat1[2][2]:= z^-q; mat2[1][1]:= -o; mat2[1][2]:= e; mat2[2][1]:= -e^-1; fi; elif n mod 2 = 0 then if q mod 2 = 1 then e:= z^( (q+1)/2 ); else e:= o; fi; mat1[1][1]:= z; mat1[n][n]:= z^-q; for i in [ 2 .. n/2 ] do mat2[ i ][ i-1 ]:= o; od; for i in [ n/2+1 .. n-1 ] do mat2[ i ][ i+1 ]:= o; od; mat2[ 1 ][ 1 ]:= o; mat2[1][n/2+1]:= e; mat2[n-1][n/2]:= e^-1; mat2[n][ n/2 ]:= -e^-1; else mat1[(n-1)/2][(n-1)/2]:= z; mat1[(n-1)/2+2][(n-1)/2+2]:= z^-q; for i in [ 1 .. (n-1)/2-1 ] do mat2[ i ][ i+1 ]:= o; od; for i in [ (n-1)/2+3 .. n ] do mat2[ i ][ i-1 ]:= o; od; mat2[(n-1)/2][ 1 ]:= -(1+z^q/z)^-1; mat2[(n-1)/2][(n-1)/2+1]:= -o; mat2[(n-1)/2][ n ]:= o; mat2[(n-1)/2+1][ 1 ]:= -o; mat2[(n-1)/2+1][(n-1)/2+1]:= -o; mat2[(n-1)/2+2][ 1 ]:= o; fi; mat1:=ImmutableMatrix(f,mat1,true); mat2:=ImmutableMatrix(f,mat2,true); # Avoid to call 'Group' because this would check invertibility ... g:= GroupWithGenerators( [ mat1, mat2 ] ); SetName( g, Concatenation("GU(",String(n),",",String(q),")") ); SetDimensionOfMatrixGroup( g, Length( mat1 ) ); SetFieldOfMatrixGroup( g, f ); # Add the size. size := q+1; qi := q; eps := 1; for i in [ 2 .. n ] do qi := qi * q; eps := -eps; size := size * (qi+eps); od; SetSize( g, q^(n*(n-1)/2) * size ); # construct the form c := Reversed( One( g ) ); SetInvariantSesquilinearForm( g, rec( matrix:= ImmutableMatrix( f, c, true ) ) ); SetIsFullSubgroupGLorSLRespectingSesquilinearForm(g,true); # Return the group. return g; end ); ############################################################################# ## #M SpecialUnitaryGroupCons( , , ) ## InstallMethod( SpecialUnitaryGroupCons, "matrix group for dimension and finite field size", [ IsMatrixGroup and IsFinite, IsPosInt, IsPosInt ], function( filter, n, q ) local g, i, e, f, z, o, mat1, mat2, size, qi, eps, c; f:= GF( q^2 ); # Handle the trivial case first. if n = 1 then g:= GroupWithGenerators( [ [ [ One( f ) ] ] ] ); SetName( g, Concatenation("SL(1,",String(q),")") ); #T no form? return g; fi; # Construct the generators. z:= PrimitiveRoot( f ); o:= One( f ); if n = 3 and q = 2 then mat1:= [ [o,z,z], [0,o,z^2], [0,0,o] ] * o; mat2:= [ [z,o,o], [o,o, 0 ], [o,0,0] ] * o; else mat1:= IdentityMat( n, f ); mat2:= List( 0 * mat1, ShallowCopy ); if n = 2 then # We use the isomorphism of 'SU(2,q)' and 'SL(2,q)': # 'e' is mapped to '-e' under the Frobenius mapping. e:= Z(q^2) - Z(q^2)^q; if q <= 3 then mat1[1][2]:= e; mat2[1][2]:= e; mat2[2][1]:= -e^-1; else mat1[1][1]:= z^(q+1); mat1[2][2]:= z^(-q-1); mat2[1][1]:= -o; mat2[1][2]:= e; mat2[2][1]:= -e^-1; fi; elif n mod 2 = 0 then mat1[1][1]:= z; mat1[n][n]:= z^-q; mat1[2][2]:= z^-1; mat1[ n-1 ][ n-1 ]:= z^q; if q mod 2 = 1 then e:= z^( (q+1)/2 ); else e:= o; fi; for i in [ 2 .. n/2 ] do mat2[ i ][ i-1 ]:= o; od; for i in [ n/2+1 .. n-1 ] do mat2[ i ][ i+1 ]:= o; od; mat2[ 1 ][ 1 ]:= o; mat2[1][n/2+1]:= e; mat2[n-1][n/2]:= e^-1; mat2[n][ n/2 ]:= -e^-1; else mat1[ (n-1)/2 ][ (n-1)/2 ]:= z; mat1[ (n-1)/2+1 ][ (n-1)/2+1 ]:= z^q/z; mat1[ (n-1)/2+2 ][ (n-1)/2+2 ]:= z^-q; for i in [ 1 .. (n-1)/2-1 ] do mat2[ i ][ i+1 ]:= o; od; for i in [ (n-1)/2+3 .. n ] do mat2[ i ][ i-1 ]:= o; od; mat2[(n-1)/2][ 1 ]:= -(1+z^q/z)^-1; mat2[(n-1)/2][(n-1)/2+1]:= -o; mat2[(n-1)/2][ n ]:= o; mat2[(n-1)/2+1][ 1 ]:= -o; mat2[(n-1)/2+1][(n-1)/2+1]:= -o; mat2[(n-1)/2+2][ 1 ]:= o; fi; fi; mat1:=ImmutableMatrix(f,mat1,true); mat2:=ImmutableMatrix(f,mat2,true); # Avoid to call 'Group' because this would check invertibility ... g:= GroupWithGenerators( [ mat1, mat2 ] ); SetName( g, Concatenation("SU(",String(n),",",String(q),")") ); SetDimensionOfMatrixGroup( g, Length( mat1 ) ); SetFieldOfMatrixGroup( g, f ); # Add the size. size := 1; qi := q; eps := 1; for i in [ 2 .. n ] do qi := qi * q; eps := -eps; size := size * (qi+eps); od; SetSize( g, q^(n*(n-1)/2) * size ); # construct the form c := Reversed( One( g ) ); SetInvariantSesquilinearForm( g, rec( matrix:= ImmutableMatrix( f, c, true ) ) ); SetIsFullSubgroupGLorSLRespectingSesquilinearForm(g,true); SetIsSubgroupSL(g,true); # Return the group. return g; end ); ############################################################################# ## #F EichlerTransformation( , , ) . . eichler trans of and ## BindGlobal( "EichlerTransformation", function( g, u, x ) local e, b, i; # construct matrix of eichler transformation in e := []; # loop over the standard vectors for b in One( g ) do i := b + (b*InvariantBilinearForm(g).matrix*x)*u - (b*InvariantBilinearForm(g).matrix*u)*x - (b*InvariantBilinearForm(g).matrix*u) *((x*InvariantQuadraticForm( g ) )*x)*u; Add( e, i ); od; # and return return e; end ); ############################################################################# ## #F Oplus45() . . . . . . . . . . . . . . . . . . . . . . . . . . . . O+_4(5) ## BindGlobal( "Oplus45", function() local f, id, tau2, tau, phi, delta, eichler, g; # identity matrix over f := GF(5); id := Immutable( IdentityMat( 4, f ) ); # construct TAU2: tau(x1-x2) tau2 := List( 0*id, ShallowCopy ); tau2[1][1] := One( f ); tau2[2][2] := One( f ); tau2[3][4] := One( f ); tau2[4][3] := One( f ); # construct TAU: tau(x1+x2) tau := List( 0*id, ShallowCopy ); tau[1][1] := One( f ); tau[2][2] := One( f ); tau[3][4] := -One( f ); tau[4][3] := -One( f ); # construct PHI: phi(2) phi := List( id, ShallowCopy ); phi[1][1] := 2*One( f ); phi[2][2] := 3*One( f ); # construct DELTA: u <-> v delta := List( id, ShallowCopy ); delta{[1,2]}{[1,2]} := [[0,1],[1,0]]*One( f ); # construct eichler transformation eichler := [[1,0,0,0],[-1,1,-1,0],[2,0,1,0],[0,0,0,1]]*One( f ); # construct the group without calling 'Group' g := [ phi*tau2, tau*eichler*delta ]; g:=List(g,i->ImmutableMatrix(f,i),true); g := GroupWithGenerators( g ); SetDimensionOfMatrixGroup( g, 4 ); SetFieldOfMatrixGroup( g, f ); # set the size SetSize( g, 28800 ); # construct the form SetInvariantBilinearForm( g, rec( matrix:= ImmutableMatrix( f, [[0,1,0,0],[1,0,0,0],[0,0,2,0],[0,0,0,2]] * One( f ), true ) ) ); # and the quadratic form SetInvariantQuadraticForm( g, rec( matrix:= ImmutableMatrix( f, [[0,1,0,0],[0,0,0,0],[0,0,1,0],[0,0,0,1]] * One( f ), true ) ) ); # and return return g; end ); ############################################################################# ## #F Opm3( , ) . . . . . . . . . . . . . . . . . . . . . . O+-_(3) ## ## must be 3, at least 6, beta is 2 ## BindGlobal( "Opm3", function( s, d ) local f, id, theta, i, theta2, phi, eichler, g, delta; # identity matrix over f := GF(3); id := Immutable( IdentityMat( d, f ) ); # construct DELTA: u <-> v, x -> x delta := List( id, ShallowCopy ); delta{[1,2]}{[1,2]} := [[0,1],[1,0]]*One( f ); # construct THETA: x2 -> ... -> xk -> x2 theta := List( 0*id, ShallowCopy ); theta[1][1] := One( f ); theta[2][2] := One( f ); theta[3][3] := One( f ); for i in [ 4 .. d-1 ] do theta[i][i+1] := One( f ); od; theta[d][4] := One( f ); # construct THETA2: x2 -> x1 -> x3 -> x2 theta2 := List( id, ShallowCopy ); theta2{[3..5]}{[3..5]} := [[0,1,1],[-1,-1,1],[1,-1,1]]*One( f ); # construct PHI: u -> au, v -> a^-1v, x -> x phi := List( id, ShallowCopy ); phi[1][1] := 2*One( f ); phi[2][2] := (2*One( f ))^-1; # construct the eichler transformation eichler := List( id, ShallowCopy ); eichler[2][1] := -One( f ); eichler[2][4] := -One( f ); eichler[4][1] := 2*One( f ); # construct the group without calling 'Group' g := [ phi*theta2, theta*eichler*delta ]; g:=List(g,i->ImmutableMatrix(f,i,true)); g := GroupWithGenerators( g ); SetDimensionOfMatrixGroup( g, d ); SetFieldOfMatrixGroup( g, f ); # construct the form delta := List( 2*id, ShallowCopy ); delta{[1,2]}{[1,2]} := [[0,1],[1,0]]*One( f ); delta[3][3] := 2*One( f )*2; SetInvariantBilinearForm( g, rec( matrix:= ImmutableMatrix( f, delta, true ) ) ); # construct quadratic form delta := List( id, ShallowCopy ); delta{[1,2]}{[1,2]} := [[0,1],[0,0]]*One( f ); delta[3][3] := One( f )*2; SetInvariantQuadraticForm( g, rec( matrix:= ImmutableMatrix( f, delta, true ) ) ); # set the size delta := 1; theta := 1; theta2 := 3^2; for i in [ 1 .. d/2-1 ] do theta := theta * theta2; delta := delta * (theta-1); od; SetSize( g, 2*3^(d/2*(d/2-1))*(3^(d/2)-s)*delta ); return g; end ); ############################################################################# ## #F OpmSmall( , , ) . . . . . . . . . . . . . . . . . O+-_() ## ## must be 3 or 5, at least 6, beta is 1 ## BindGlobal( "OpmSmall", function( s, d, q ) local f, id, theta, i, theta2, phi, eichler, g, delta; # identity matrix over f := GF(q); id := Immutable( IdentityMat( d, f ) ); # construct DELTA: u <-> v, x -> x delta := List( id, ShallowCopy ); delta{[1,2]}{[1,2]} := [[0,1],[1,0]]*One( f ); # construct THETA: x2 -> ... -> xk -> x2 theta := List( 0*id, ShallowCopy ); theta[1][1] := One( f ); theta[2][2] := One( f ); theta[3][3] := One( f ); for i in [ 4 .. d-1 ] do theta[i][i+1] := One( f ); od; theta[d][4] := One( f ); # construct THETA2: x2 -> x1 -> x3 -> x2 theta2 := List( id, ShallowCopy ); theta2{[3..5]}{[3..5]} := [[0,0,1],[1,0,0],[0,1,0]]*One( f ); # construct PHI: u -> au, v -> a^-1v, x -> x phi := List( id, ShallowCopy ); phi[1][1] := 2*One( f ); phi[2][2] := (2*One( f ))^-1; # construct the eichler transformation eichler := List( id, ShallowCopy ); eichler[2][1] := -One( f ); eichler[2][4] := -One( f ); eichler[4][1] := 2*One( f ); # construct the group without calling 'Group' g := [ phi*theta2, theta*eichler*delta ]; g:=List(g,i->ImmutableMatrix(f,i,true)); g := GroupWithGenerators( g ); SetDimensionOfMatrixGroup( g, d ); SetFieldOfMatrixGroup( g, f ); # construct the form delta := List( 2*id, ShallowCopy ); delta{[1,2]}{[1,2]} := [[0,1],[1,0]]*One( f ); delta[3][3] := 2*One( f ); SetInvariantBilinearForm( g, rec( matrix:= ImmutableMatrix( f, delta, true ) ) ); # construct quadratic form delta := List( id, ShallowCopy ); delta{[1,2]}{[1,2]} := [[0,1],[0,0]]*One( f ); delta[3][3] := One( f ); SetInvariantQuadraticForm( g, rec( matrix:= ImmutableMatrix( f, delta, true ) ) ); # set the size delta := 1; theta := 1; theta2 := q^2; for i in [ 1 .. d/2-1 ] do theta := theta * theta2; delta := delta * (theta-1); od; SetSize( g, 2*q^(d/2*(d/2-1))*(q^(d/2)-s)*delta ); return g; end ); ############################################################################# ## #F OpmOdd( , , ) . . . . . . . . . . . . . . . . . . O_() ## BindGlobal( "OpmOdd", function( s, d, q ) local f, w, beta, epsilon, id, eb1, tau, theta, i, phi, delta, eichler, g; # must be at least 4 if d mod 2 = 1 then Error( " must be even" ); fi; if d < 4 then Error( " must be at least 4" ); fi; # beta is either 1 or a generator of the field f := GF(q); w := LogFFE( -1*2^(d-2)*One( f ), PrimitiveRoot( f ) ) mod 2 = 0; beta := One( f ); if s = +1 and (d*(q-1)/4) mod 2 = 0 then if not w then beta := PrimitiveRoot( f ); fi; elif s = +1 and (d*(q-1)/4) mod 2 = 1 then if w then beta := PrimitiveRoot( f ); fi; elif s = -1 and (d*(q-1)/4) mod 2 = 1 then if not w then beta := PrimitiveRoot( f ); fi; elif s = -1 and (d*(q-1)/4) mod 2 = 0 then if w then beta := PrimitiveRoot( f ); fi; else Error( " must be -1 or +1" ); fi; # special cases if q = 3 and d = 4 and s = +1 then g := GroupWithGenerators( [ [[1,0,0,0],[0,1,2,1],[2,0,2,0],[1,0,0,1]]*One( f ), [[0,2,2,2],[0,1,1,2],[1,0,2,0],[1,2,2,0]]*One( f ) ] ); SetInvariantBilinearForm( g, rec( matrix:= ImmutableMatrix( f, [[0,1,0,0],[1,0,0,0],[0,0,1,0],[0,0,0,2]]*One( f ), true ) ) ); SetInvariantQuadraticForm( g, rec( matrix:= ImmutableMatrix( f, [[0,1,0,0],[0,0,0,0],[0,0,2,0],[0,0,0,1]]*One( f ), true ) ) ); SetSize( g, 1152 ); return g; elif q = 3 and d = 4 and s = -1 then g := GroupWithGenerators( [ [[0,2,0,0],[2,1,0,1],[0,2,0,1],[0,0,1,0]]*One( f ), [[2,0,0,0],[1,2,0,2],[1,0,0,1],[0,0,1,0]]*One( f ) ] ); SetInvariantBilinearForm( g, rec( matrix:= ImmutableMatrix( f, [[0,1,0,0],[1,0,0,0],[0,0,2,0],[0,0,0,2]]*One( f ), true ) ) ); SetInvariantQuadraticForm( g, rec( matrix:= ImmutableMatrix( f, [[0,1,0,0],[0,0,0,0],[0,0,1,0],[0,0,0,1]]*One( f ), true ) ) ); SetSize( g, 1440 ); return g; elif q = 5 and d = 4 and s = +1 then return Oplus45(); elif ( q = 3 or q = 5 ) and 4 < d and beta = One( f ) then return OpmSmall( s, d, q ); elif q = 3 and 4 < d and beta <> One( f ) then return Opm3( s, d ); fi; # find an epsilon such that (epsilon^2*beta)^2 <> 1 if beta = PrimitiveRoot( f ) then epsilon := One( f ); else epsilon := PrimitiveRoot( f ); fi; # identity matrix over id := Immutable( IdentityMat( d, f ) ); # construct the reflection TAU_epsilon*x1+x2 eb1 := epsilon^2*beta+1; tau := List( id, ShallowCopy ); tau[3][3] := 1-2*beta*epsilon^2/eb1; tau[3][4] := -2*beta*epsilon/eb1; tau[4][3] := -2*epsilon/eb1; tau[4][4] := 1-2/eb1; # construct THETA theta := List( 0*id, ShallowCopy ); theta[1][1] := One( f ); theta[2][2] := One( f ); theta[3][3] := One( f ); for i in [ 4 .. d-1 ] do theta[i][i+1] := One( f ); od; theta[d][4] := -One( f ); # construct PHI: u -> au, v -> a^-1v, x -> x phi := List( id, ShallowCopy ); phi[1][1] := PrimitiveRoot( f ); phi[2][2] := PrimitiveRoot( f )^-1; # construct DELTA: u <-> v, x -> x delta := List( id, ShallowCopy ); delta{[1,2]}{[1,2]} := [[0,1],[1,0]]*One( f ); # construct the eichler transformation eichler := List( id, ShallowCopy ); eichler[2][1] := -One( f ); eichler[2][4] := -One( f ); eichler[4][1] := 2*One( f ); # construct the group without calling 'Group' g := [ phi, theta*tau*eichler*delta ]; g:=List(g,i->ImmutableMatrix(f,i,true)); g := GroupWithGenerators( g ); SetDimensionOfMatrixGroup( g, d ); SetFieldOfMatrixGroup( g, f ); # construct the form delta := List( 2*id, ShallowCopy ); delta{[1,2]}{[1,2]} := [[0,1],[1,0]]*One( f ); delta[3][3] := 2*beta; SetInvariantBilinearForm( g, rec( matrix:= ImmutableMatrix( f, delta, true ) ) ); # construct quadratic form delta := List( id, ShallowCopy ); delta{[1,2]}{[1,2]} := [[0,1],[0,0]]*One( f ); delta[3][3] := beta; SetInvariantQuadraticForm( g, rec( matrix:= ImmutableMatrix( f, delta, true ) ) ); # set the size delta := 1; theta := 1; tau := q^2; for i in [ 1 .. d/2-1 ] do theta := theta * tau; delta := delta * (theta-1); od; SetSize( g, 2*q^(d/2*(d/2-1))*(q^(d/2)-s)*delta ); return g; end ); ############################################################################# ## #F Oplus2( ) . . . . . . . . . . . . . . . . . . . . . . . . . O+_2() ## BindGlobal( "Oplus2", function( q ) local z, f, m1, m2, g; # a field generator z := Z(q); f := GF(q); # a matrix of order q-1 m1 := [ [ z, 0*z ], [ 0*z, z^-1 ] ]; # a matrix of order 2 m2 := [ [ 0, 1 ], [ 1, 0 ] ] * z^0; m1:= ImmutableMatrix( f, m1, true ); m2:= ImmutableMatrix( f, m2, true ); # construct the group, set the order, and return g := GroupWithGenerators( [ m1, m2 ] ); SetInvariantBilinearForm(g, rec( matrix:= ImmutableMatrix( f, m2, true ) ) ); SetInvariantQuadraticForm( g, rec( matrix:= ImmutableMatrix( f, [ [ 0, 1 ], [ 0, 0 ] ] * z^0, true ) ) ); SetSize( g, 2*(q-1) ); return g; end ); ############################################################################# ## #F Oplus4Even( ) . . . . . . . . . . . . . . . . . . . . . . . O+_4() ## BindGlobal( "Oplus4Even", function( q ) local f, id, rho, delta, phi, eichler, g; # must be even if q mod 2 = 1 then Error( " must be even" ); fi; f := GF(q); # identity matrix over id := Immutable( IdentityMat( 4, f ) ); # construct RHO: x1 <-> y1 rho := List( id, ShallowCopy ); rho{[3,4]}{[3,4]} := [[0,1],[1,0]] * One( f ); # construct DELTA: u <-> v delta := List( id, ShallowCopy ); delta{[1,2]}{[1,2]} := [[0,1],[1,0]]*One( f ); # construct PHI: u -> au, v -> a^-1v, x -> x phi := List( id, ShallowCopy ); phi[1][1] := PrimitiveRoot( f ); phi[2][2] := PrimitiveRoot( f )^-1; # construct eichler transformation eichler := [[1,0,0,0],[0,1,-1,0],[0,0,1,0],[1,0,0,1]] * One( f ); # construct the group without calling 'Group' g := [ phi*rho, rho*eichler*delta ]; g:=List(g,i->ImmutableMatrix(f,i,true)); g := GroupWithGenerators( g ); SetDimensionOfMatrixGroup( g, 4 ); SetFieldOfMatrixGroup( g, f ); # set the size SetSize( g, 2*q^2*(q^2-1)^2 ); # construct the form SetInvariantBilinearForm( g, rec( matrix:= ImmutableMatrix( f, [[0,1,0,0],[1,0,0,0],[0,0,0,1],[0,0,1,0]] * One( f ), true ) ) ); # and the quadratic form SetInvariantQuadraticForm( g, rec( matrix:= ImmutableMatrix( f, [[0,1,0,0],[0,0,0,0],[0,0,0,1],[0,0,0,0]] * One( f ), true ) ) ); # and return return g; end ); ############################################################################# ## #F OplusEven( , ) . . . . . . . . . . . . . . . . . . . . O+_() ## BindGlobal( "OplusEven", function( d, q ) local f, id, k, phi, delta, theta, i, delta2, eichler, rho, g; # and must be even if d mod 2 = 1 then Error( " must be even" ); fi; if d < 6 then Error( " must be at least 6" ); fi; if q mod 2 = 1 then Error( " must be even" ); fi; f := GF(q); # identity matrix over id := Immutable( IdentityMat( d, f ) ); # V = H | H_1 | ... | H_k k := (d-2) / 2; # construct PHI: u -> au, v -> a^-1v, x -> x phi := List( id, ShallowCopy ); phi[1][1] := PrimitiveRoot( f ); phi[2][2] := PrimitiveRoot( f )^-1; # construct DELTA: u <-> v, x -> x delta := List( id, ShallowCopy ); delta{[1,2]}{[1,2]} := [[0,1],[1,0]]*One( f ); # construct THETA: x_2 -> x_3 -> .. -> x_k -> y_2 -> .. -> y_k -> x_2 theta := List( 0*id, ShallowCopy ); for i in [ 1 .. 4 ] do theta[i][i] := One( f ); od; for i in [ 2 .. k-1 ] do theta[1+2*i][3+2*i] := One( f ); theta[2+2*i][4+2*i] := One( f ); od; theta[1+2*k][6] := One( f ); theta[2+2*k][5] := One( f ); # (k even) construct DELTA2: x_i <-> y_i, 1 <= i <= k-1 if k mod 2 = 0 then delta2 := List( 0*id, ShallowCopy ); delta2{[1,2]}{[1,2]} := [[1,0],[0,1]] * One( f ); for i in [ 1 .. k ] do delta2[1+2*i][2+2*i] := One( f ); delta2[2+2*i][1+2*i] := One( f ); od; # (k odd) construct DELTA2: x_1 <-> y_1, x_i <-> x_i+1, y_i <-> y_i+1 else delta2 := List( 0*id, ShallowCopy ); delta2{[1,2]}{[1,2]} := [[1,0],[0,1]] * One( f ); delta2{[3,4]}{[3,4]} := [[0,1],[1,0]] * One( f ); for i in [ 2, 4 .. k-1 ] do delta2[1+2*i][3+2*i] := One( f ); delta2[3+2*i][1+2*i] := One( f ); delta2[2+2*i][4+2*i] := One( f ); delta2[4+2*i][2+2*i] := One( f ); od; fi; # construct eichler transformation eichler := List( id, ShallowCopy ); eichler[4][6] := One( f ); eichler[5][3] := -One( f ); # construct RHO = THETA * EICHLER rho := theta*eichler; # construct second eichler transformation eichler := List( id, ShallowCopy ); eichler[2][5] := -One( f ); eichler[6][1] := One( f ); # there seems to be something wrong in I/E for p=2 if k mod 2 = 0 then if q = 2 then g := [ phi*delta2, rho, eichler, delta ]; else g := [ phi*delta2, rho*eichler*delta, delta ]; fi; elif q = 2 then g := [ phi*delta2, rho*eichler*delta, rho*delta ]; else g := [ phi*delta2, rho*eichler*delta ]; fi; # construct the group without calling 'Group' g:=List(g,i->ImmutableMatrix(f,i,true)); g := GroupWithGenerators( g ); SetDimensionOfMatrixGroup( g, d ); SetFieldOfMatrixGroup( g, f ); # construct the form delta := List( 0*id, ShallowCopy ); for i in [ 1 .. d/2 ] do delta[2*i-1][2*i] := One( f ); delta[2*i][2*i-1] := One( f ); od; SetInvariantBilinearForm( g, rec( matrix:= ImmutableMatrix( f, delta, true ) ) ); # construct quadratic form delta := List( 0*id, ShallowCopy ); for i in [ 1 .. d/2 ] do delta[2*i-1][2*i] := One( f ); od; SetInvariantQuadraticForm( g, rec( matrix:= ImmutableMatrix( f, delta, true ) ) ); # set the size delta := 1; theta := 1; rho := q^2; for i in [ 1 .. d/2-1 ] do theta := theta * rho; delta := delta * (theta-1); od; SetSize( g, 2*q^(d/2*(d/2-1))*(q^(d/2)-1)*delta ); return g; end ); ############################################################################# ## #F Ominus2( ) . . . . . . . . . . . . . . . . . . . . . . . . O-_2() ## BindGlobal( "Ominus2", function( q ) local z, f, R, x, t, n, e, bc, m2, m1, g; # construct the root z := Z(q); # find $x^2+x+t$ that is irreducible over GF(`q') f:= GF( q ); R:= PolynomialRing( f ); x:= Indeterminate( f ); t:= z^First( [ 0 .. q-2 ], u -> Length( Factors( R, x^2+x+z^u ) ) = 1 ); # get roots in GF(q^2) n := List( Factors( PolynomialRing( GF( q^2 ) ), x^2+x+t ), x -> - CoefficientsOfLaurentPolynomial( x )[1][1] ); e := 4*t-1; # construct base change bc := [ [ n[1]/e, 1/e ], [ n[2], z^0 ] ]; # matrix of order 2 m2 := [ [ -1, 0 ], [ -1, 1 ] ] * z^0; # matrix of order q+1 (this will lie in $GF(q)^{d \times d}$) z := Z(q^2)^(q-1); m1 := bc^-1 * [[z,0*z],[0*z,z^-1]] * bc; # and return the group m1:=ImmutableMatrix(GF(q),m1,true); m2:=ImmutableMatrix(GF(q),m2,true); g := GroupWithGenerators( [ m1, m2 ] ); SetInvariantBilinearForm( g, rec( matrix:= ImmutableMatrix( f, [ [ 2, 1 ], [ 1, 2*t ] ] * z^0, true ) ) ); SetInvariantQuadraticForm( g, rec( matrix:= ImmutableMatrix( f, [ [ 1, 1 ], [ 0, t ] ] * z^0, true ) ) ); SetSize( g, 2*(q+1) ); return g; end ); ############################################################################# ## #F Ominus4Even( ) . . . . . . . . . . . . . . . . . . . . . . O-_4() ## BindGlobal( "Ominus4Even", function( q ) local f, id, rho, delta, phi, R, x, t, eichler, g; # must be even if q mod 2 = 1 then Error( " must be even" ); fi; f := GF(q); # identity matrix over id := Immutable( IdentityMat( 4, f ) ); # construct RHO: x1 <-> y1 rho := List( id, ShallowCopy ); rho{[3,4]}{[3,4]} := [[0,1],[1,0]] * One( f ); # construct DELTA: u <-> v delta := List( id, ShallowCopy ); delta{[1,2]}{[1,2]} := [[0,1],[1,0]]*One( f ); # construct PHI: u -> au, v -> a^-1v, x -> x phi := List( id, ShallowCopy ); phi[1][1] := PrimitiveRoot( f ); phi[2][2] := PrimitiveRoot( f )^-1; # find x^2+x+t that is irreducible over R:= PolynomialRing( f, 1 ); x:= Indeterminate( f ); t:= First( [ 0 .. q-2 ], u -> Length( Factors( R, x^2+x+PrimitiveRoot( f )^u ) ) = 1 ); # compute square root of t := t/2 mod (q-1); t := PrimitiveRoot( f )^t; # construct eichler transformation eichler := [[1,0,0,0],[-t,1,-1,0],[0,0,1,0],[1,0,0,1]] * One( f ); # construct the group without calling 'Group' g := [ phi*rho, rho*eichler*delta ]; g:=List(g,i->ImmutableMatrix(f,i,true)); g := GroupWithGenerators( g ); SetDimensionOfMatrixGroup( g, 4 ); SetFieldOfMatrixGroup( g, f ); # set the size SetSize( g, 2*q^2*(q^2+1)*(q^2-1) ); # construct the form SetInvariantBilinearForm( g, rec( matrix:= ImmutableMatrix( f, [[0,1,0,0],[1,0,0,0],[0,0,0,1],[0,0,1,0]] * One( f ), true ) ) ); # and the quadratic form SetInvariantQuadraticForm( g, rec( matrix:= ImmutableMatrix( f, [[0,1,0,0],[0,0,0,0],[0,0,t,1],[0,0,0,t]] * One( f ), true ) ) ); # and return return g; end ); ############################################################################# ## #F OminusEven( , ) . . . . . . . . . . . . . . . . . . . O-_() ## BindGlobal( "OminusEven", function( d, q ) local f, id, k, phi, delta, theta, i, delta2, eichler, rho, g, t, R, x; # and must be odd if d mod 2 = 1 then Error( " must be even" ); elif d < 6 then Error( " must be at least 6" ); elif q mod 2 = 1 then Error( " must be even" ); fi; f := GF(q); # identity matrix over id := Immutable( IdentityMat( d, f ) ); # V = H | H_1 | ... | H_k k := (d-2) / 2; # construct PHI: u -> au, v -> a^-1v, x -> x phi := List( id, ShallowCopy ); phi[1][1] := PrimitiveRoot( f ); phi[2][2] := PrimitiveRoot( f )^-1; # construct DELTA: u <-> v, x -> x delta := List( id, ShallowCopy ); delta{[1,2]}{[1,2]} := [[0,1],[1,0]]*One( f ); # construct THETA: x_2 -> x_3 -> .. -> x_k -> y_2 -> .. -> y_k -> x_2 theta := List( 0*id, ShallowCopy ); for i in [ 1 .. 4 ] do theta[i][i] := One( f ); od; for i in [ 2 .. k-1 ] do theta[1+2*i][3+2*i] := One( f ); theta[2+2*i][4+2*i] := One( f ); od; theta[1+2*k][6] := One( f ); theta[2+2*k][5] := One( f ); # (k even) construct DELTA2: x_i <-> y_i, 1 <= i <= k-1 if k mod 2 = 0 then delta2 := List( 0*id, ShallowCopy ); delta2{[1,2]}{[1,2]} := [[1,0],[0,1]] * One( f ); for i in [ 1 .. k ] do delta2[1+2*i][2+2*i] := One( f ); delta2[2+2*i][1+2*i] := One( f ); od; # (k odd) construct DELTA2: x_1 <-> y_1, x_i <-> x_i+1, y_i <-> y_i+1 else delta2 := List( 0*id, ShallowCopy ); delta2{[1,2]}{[1,2]} := [[1,0],[0,1]] * One( f ); delta2{[3,4]}{[3,4]} := [[0,1],[1,0]] * One( f ); for i in [ 2, 4 .. k-1 ] do delta2[1+2*i][3+2*i] := One( f ); delta2[3+2*i][1+2*i] := One( f ); delta2[2+2*i][4+2*i] := One( f ); delta2[4+2*i][2+2*i] := One( f ); od; fi; # find x^2+x+t that is irreducible over GF(`q') R:= PolynomialRing( f ); x:= Indeterminate( f ); t:= First( [ 0 .. q-2 ], u -> Length( Factors( R, x^2+x+PrimitiveRoot( f )^u ) ) = 1 ); # compute square root of t := t/2 mod (q-1); t := PrimitiveRoot( f )^t; # construct Eichler transformation eichler := List( id, ShallowCopy ); eichler[4][6] := One( f ); eichler[5][3] := -One( f ); eichler[5][6] := -t; # construct RHO = THETA * EICHLER rho := theta*eichler; # construct second eichler transformation eichler := List( id, ShallowCopy ); eichler[2][5] := -One( f ); eichler[6][1] := One( f ); # there seems to be something wrong in I/E for p=2 if k mod 2 = 0 then if q = 2 then g := [ phi*delta2, rho, eichler, delta ]; else g := [ phi*delta2, rho*eichler*delta, delta ]; fi; elif q = 2 then g := [ phi*delta2, rho*eichler*delta, rho*delta ]; else g := [ phi*delta2, rho*eichler*delta ]; fi; # construct the group without calling 'Group' g:=List(g,i->ImmutableMatrix(f,i,true)); g := GroupWithGenerators( g ); SetDimensionOfMatrixGroup( g, d ); SetFieldOfMatrixGroup( g, f ); # construct the form delta := List( 0*id, ShallowCopy ); for i in [ 1 .. d/2 ] do delta[2*i-1][2*i] := One( f ); delta[2*i][2*i-1] := One( f ); od; SetInvariantBilinearForm( g, rec( matrix:= ImmutableMatrix( f, delta, true ) ) ); # construct quadratic form delta := List( 0*id, ShallowCopy ); for i in [ 1 .. d/2 ] do delta[2*i-1][2*i] := One( f ); od; delta[3][3] := t; delta[4][4] := t; SetInvariantQuadraticForm( g, rec( matrix:= ImmutableMatrix( f, delta, true ) ) ); # set the size delta := 1; theta := 1; rho := q^2; for i in [ 1 .. d/2-1 ] do theta := theta * rho; delta := delta * (theta-1); od; SetSize( g, 2*q^(d/2*(d/2-1))*(q^(d/2)+1)*delta ); return g; end ); ############################################################################# ## #F OzeroOdd( , , ) . . . . . . . . . . . . . . . . . . O0_() ## ## 'OzeroOdd' construct the orthogonal group in odd dimension and odd ## characteristic. The discriminant of the quadratic form is -(2)^(-2) ## BindGlobal( "OzeroOdd", function( d, q, b ) local id, phi, delta, rho, i, eichler, g, s, f, q2, q2i; # and must be odd if d mod 2 = 0 then Error( " must be odd" ); elif d < 3 then Error( " must be at least 3" ); elif q mod 2 = 0 then Error( " must be odd" ); fi; f := GF(q); # identity matrix over id := Immutable( IdentityMat( d, f ) ); # construct PHI: u -> au, v -> a^-1v, x -> x phi := List( id, ShallowCopy ); phi[1][1] := PrimitiveRoot( f ); phi[2][2] := PrimitiveRoot( f )^-1; # construct DELTA: u <-> v, x -> x delta := List( id, ShallowCopy ); delta{[1,2]}{[1,2]} := [[0,1],[1,0]]*One( f ); # construct RHO: u -> u, v -> v, x_i -> x_i+1 rho := List( 0*id, ShallowCopy ); rho[1][1] := One( f ); rho[2][2] := One( f ); for i in [ 3 .. d-1 ] do rho[i][i+1] := One( f ); od; rho[d][3] := One( f ); # construct eichler transformation eichler := List( id, ShallowCopy ); eichler{[1..3]}{[1..3]} := [[1,0,0],[-b,1,-1],[2*b,0,1]] * One( f ); # construct the group without calling 'Group' g := [ phi, rho*eichler*delta ]; g:=List(g,i->ImmutableMatrix(f,i,true)); g := GroupWithGenerators( g ); SetDimensionOfMatrixGroup( g, d ); SetFieldOfMatrixGroup( g, f ); # and set its size s := 1; q2 := q^2; q2i := 1; for i in [ 1 .. (d-1)/2 ] do q2i := q2 * q2i; s := s * (q2i-1); od; SetSize( g, 2 * q^((d-1)^2/4) * s ); # construct the form s := List( 2*b*id, ShallowCopy ); s{[1,2]}{[1,2]} := [[0,1],[1,0]]*One( f ); SetInvariantBilinearForm( g, rec( matrix:= ImmutableMatrix( f, s, true ) ) ); # and the quadratic form s := List( b*id, ShallowCopy ); s{[1,2]}{[1,2]} := [[0,1],[0,0]]*One( f ); SetInvariantQuadraticForm( g, rec( matrix:= ImmutableMatrix( f, s, true ) ) ); # and return return g; end ); ############################################################################# ## #F OzeroEven( , ) . . . . . . . . . . . . . . . . . . . . O0_() ## ## 'OzeroEven' constructs the orthogonal group in odd dimension and even ## characteristic. ## The generators are constructed via the isomorphism with the symplectic ## group in dimension $-1$ over the field with elements. ## ## Removing the first row and the first column from the matrices defines the ## isomorphism to the symplectic group. ## This group is *not* equal to the symplectic group constructed with the ## function `Sp', ## since the bilinear form of the orthogonal group is the one used in the ## book of Carter and not the one used for `SP'. ## (Note that our matrices are transposed, relative to the ones given by ## Carter, because the group shall act on a *row* space.) ## ## The generators of the orthogonal groups can be computed as those matrices ## that project onto the generators of the symplectic group and satisfy the ## quadratic form ## $f(x) = x_0^2 + x_1 x_{-1} + x_2 x_{-2} + \cdots + x_l x_{-l}$. ## This condition results in a quadratic equation system that can be ## interpreted as a linear equation system because taking square roots is ## one-to-one in characteristic $2$. ## BindGlobal( "OzeroEven", function( d, q ) local f, z, o, n, mat1, mat2, i, g, size, qi, c, s; # must be odd, must be even if d mod 2 = 0 then Error( " must be odd" ); elif d < 3 then Error( " must be at least 3" ); elif q mod 2 = 1 then Error( " must be even" ); fi; f:= GF(q); z:= PrimitiveRoot( f ); o:= One( f ); n:= Zero( f ); if d = 3 then # The isomorphic symplectic group is $SL(2,)$. if q = 2 then mat1:= ImmutableMatrix( f, [ [o,n,n], [o,o,o], [n,n,o] ],true ); mat2:= ImmutableMatrix( f, [ [o,n,n], [n,n,o], [n,o,n] ],true ); else mat1:= ImmutableMatrix( f, [ [o,n,n], [n,z,n], [n,n,z^-1] ],true ); mat2:= ImmutableMatrix( f, [ [o,n,n], [o,o,o], [n,o,n] ],true ); fi; elif d = 5 and q = 2 then # The isomorphic symplectic group is $SP(4,2)$. mat1:= ImmutableMatrix( f, [ [o,n,n,n,n], [o,n,o,n,o], [o,n,o,o,o], [n,o,n,n,o], [n,o,o,o,o] ],true ); mat2:= ImmutableMatrix( f, [ [o,n,n,n,n], [n,n,o,n,n], [n,n,n,o,n], [n,n,n,n,o], [n,o,n,n,n] ],true ); else mat1:= IdentityMat( d, f ); mat2:= List( 0 * mat1, ShallowCopy ); mat2[1][1]:= o; mat2[d][2]:= o; for i in [ 2 .. d-1 ] do mat2[i][i+1]:= o; od; if q = 2 then mat1[(d+1)/2][ 1]:= o; mat1[(d+1)/2][ 2]:= o; mat1[(d+1)/2][ d]:= o; mat1[(d+3)/2][ d]:= o; else mat1[ 2][ 2]:= z; mat1[(d+1)/2][(d+1)/2]:= z; mat1[(d+3)/2][(d+3)/2]:= z^-1; mat1[ d][ d]:= z^-1; mat2[(d+1)/2][ 1]:= o; mat2[(d+1)/2][ 2]:= o; mat2[(d+1)/2][ 3]:= o; mat2[(d+3)/2][ 2]:= o; fi; fi; mat1:= ImmutableMatrix( f, mat1,true ); mat2:= ImmutableMatrix( f, mat2,true ); # avoid to call 'Group' because this would check invertibility ... g:= GroupWithGenerators( [ mat1, mat2 ] ); SetDimensionOfMatrixGroup( g, Length( mat1 ) ); SetFieldOfMatrixGroup( g, f ); # add the size size := 1; qi := 1; for i in [ 1 .. (d-1)/2 ] do qi := qi * q^2; size := size * (qi-1); od; SetSize( g, q^(((d-1)/2)^2) * size ); # construct the form c := List( 0 * One( g ), ShallowCopy ); for i in [ 2 .. (d+1)/2 ] do c[(d-1)/2+i][i] := o; c[i][(d-1)/2+i] := o; od; SetInvariantBilinearForm( g, rec( matrix:= ImmutableMatrix( f, c, true ) ) ); SetIsSubgroupSL( g, true ); # and the quadratic form s := List( 0 * One( g ), ShallowCopy ); s[1][1]:= o; for i in [ 2 .. (d+1)/2 ] do s[(d-1)/2+i][i]:= o; od; SetInvariantQuadraticForm( g, rec( matrix:= ImmutableMatrix( f, s, true ) ) ); # and return return g; end ); ############################################################################# ## #M GeneralOrthogonalGroupCons( , , ) . . . . . . . GO_() ## InstallMethod( GeneralOrthogonalGroupCons, "matrix group for , dimension, and finite field size", [ IsMatrixGroup and IsFinite, IsInt, IsPosInt, IsPosInt ], function( filter, e, d, q ) local g, i; # must be -1, 0, +1 if e <> -1 and e <> 0 and e <> +1 then Error( "sign must be -1, 0, +1\n" ); fi; # if = 0 then must be odd if e = 0 and d mod 2 = 0 then Error( "sign = 0 but dimension is even\n" ); # if <> 0 then must be even elif e <> 0 and d mod 2 = 1 then Error( "sign <> 0 but dimension is odd\n" ); fi; # construct the various orthogonal groups if e = 0 and q mod 2 <> 0 then g := OzeroOdd( d, q, 1 ); elif e = 0 then g := OzeroEven( d, q ); # O+(2,q) = D_2(q-1) elif e = +1 and d = 2 then g := Oplus2(q); # if = 4 and even use 'Oplus4Even' elif e = +1 and d = 4 and q mod 2 = 0 then g := Oplus4Even(q); # if is even use 'OplusEven' elif e = +1 and q mod 2 = 0 then g := OplusEven( d, q ); # if is odd use 'OpmOdd' elif e = +1 and q mod 2 = 1 then g := OpmOdd( +1, d, q ); # O-(2,q) = D_2(q+1) elif e = -1 and d = 2 then g := Ominus2(q); # if = 4 and even use 'Ominus4Even' elif e = -1 and d = 4 and q mod 2 = 0 then g := Ominus4Even(q); # if is even use 'OminusEven' elif e = -1 and q mod 2 = 0 then g := OminusEven( d, q ); # if is odd use 'OpmOdd' elif e = -1 and q mod 2 = 1 then g := OpmOdd( -1, d, q ); fi; # set name if e = +1 then i := "+"; else i := ""; fi; SetName( g, Concatenation( "GO(", i, String(e), ",", String(d), ",", String(q), ")" ) ); SetIsFullSubgroupGLorSLRespectingQuadraticForm( g, true ); if q mod 2 = 1 then SetIsFullSubgroupGLorSLRespectingBilinearForm( g, true ); #T in which cases does characteristic 2 imply `false'? fi; # and return return g; end ); InstallMethod( GeneralOrthogonalGroupCons, "matrix group for dimension and finite field", [ IsMatrixGroup and IsFinite, IsInt, IsPosInt, IsField and IsFinite ], function(filt,sign,n,f) return GeneralOrthogonalGroupCons(filt,sign,n,Size(f)); end); ############################################################################# ## #M SpecialOrthogonalGroupCons( , , ) . . . . . . . GO_() ## ## SO has index $1$ in GO if the characteristic is even ## and index $2$ if the characteristic is odd. ## ## In the latter case, the generators of GO are $a$ and $b$. ## When GO is constructed with `OzeroOdd', `Oplus2', and `Ominus2' then by ## construction $a$ has determinant $1$, and $b$ has determinant $-1$. ## The group $\langle a, b^{-1} a b, b^2 \rangle$ is therefore equal to SO. ## (Note that it is clearly contained in SO, and each word in terms of $a$ ## and $b$ can be written as a word in terms of the three generators above ## or $b$ times such a word.) ## So the case `OpmOdd' is left, which deals with three exceptions ## $(s,d,q) \in \{ (1,4,3), (-1,4,3), (1,4,5) \}$, two series for small $q$ ## (via `OpmSmall' and `Opm3'), and the generic remainder; ## exactly in the two of the three exceptional cases where $s = 1$ holds, ## the determinant of the first generator is $-1$; in these cases, the ## determinant of the second generator is $1$, so we get the generating set ## $\{ a^2, a^{-1} b a, b \}$. ## InstallMethod( SpecialOrthogonalGroupCons, "matrix group for , dimension, and finite field size", [ IsMatrixGroup and IsFinite, IsInt, IsPosInt, IsPosInt ], function( filter, e, d, q ) local G, gens, U, i; G:= GeneralOrthogonalGroupCons( filter, e, d, q ); if q mod 2 = 1 then # Deal with the special cases. gens:= GeneratorsOfGroup( G ); if e = 1 and d = 4 and q in [ 3, 5 ] then gens:= Reversed( gens ); fi; Assert( 1, Length( gens ) = 2 and IsOne( DeterminantMat( gens[1] ) ) ); # Construct the group. U:= GroupWithGenerators( [ gens[1], gens[1]^gens[2], gens[2]^2 ] ); # Set the group order. SetSize( U, Size( G ) / 2 ); # Set the name. if e = +1 then i := "+"; else i := ""; fi; SetName( U, Concatenation( "SO(", i, String(e), ",", String(d), ",", String(q), ")" ) ); # Set the invariant quadratic form and the symmetric bilinear form. SetInvariantBilinearForm( U, InvariantBilinearForm( G ) ); SetInvariantQuadraticForm( U, InvariantQuadraticForm( G ) ); SetIsFullSubgroupGLorSLRespectingQuadraticForm( U, true ); if q mod 2 = 1 then SetIsFullSubgroupGLorSLRespectingBilinearForm( U, true ); fi; G:= U; fi; return G; end ); InstallMethod( SpecialOrthogonalGroupCons, "matrix group for dimension and finite field", [ IsMatrixGroup and IsFinite, IsInt, IsPosInt, IsField and IsFinite ], function(filt,sign,n,f) return SpecialOrthogonalGroupCons(filt,sign,n,Size(f)); end); ############################################################################# ## #F WallForm(

, ) . . . . . . . . . . . . . compute the wall of ## BindGlobal( "WallForm", function( form, m ) local id, w, b, p, i, x, j; # first argument should really be something useful id := One( m ); # compute a base for Image(id-m), use the most stupid algorithm w := id - m; b := []; p := []; for i in [ 1 .. Length(w) ] do if Length(b) = 0 then if w[i] <> 0*w[i] then Add( b, w[i] ); Add( p, i ); fi; elif RankMat(b) <> RankMat(Concatenation(b,[w[i]])) then Add( b, w[i] ); Add( p, i ); fi; od; # compute the form x := List( b, x -> [] ); for i in [ 1 .. Length(b) ] do for j in [ 1 .. Length(b) ] do x[i][j] := id[p[i]] * form * b[j]; od; od; # and return return rec( base := b, pos := p, form := x ); end ); ############################################################################# ## #F SpinorNorm( , ) . . . . . . . . compute the spinor norm of ## BindGlobal( "SpinorNorm", function( form, m ) if IsOne(m) then return One(m[1][1]); fi; return DeterminantMat( WallForm(form,m).form ); end ); ############################################################################# ## #F OmegaZero( , ) . . . . . . . . . . . . . . . . \Omega^0_{}() ## BindGlobal( "OmegaZero", function( d, q ) local f, o, m, mo, n, i, x1, x2, x, g, xi, h, s, q2, q2i; # must be odd if d mod 2 = 0 then Error( " must be odd" ); elif d < 3 then Error( " must be at least 3" ); fi; f:= GF(q); o:= One( f ); m:= ( d-1 ) / 2; if d = 5 and q = 2 then # The matrices given in [RylandsTalor98] generate only A6 not S6. # So we take the isomorphic group SO( 5, 2 ) instead. return SO( 5, 2 ); elif 3 < d then # Omega(0,d,q) for d=2m+1, m >= 2, Section 4.5 if d mod 4 = 3 then mo:= -o; # (-1)^m else mo:= o; fi; n:= NullMat( d, d, f ); n[ m+2 ][1]:= mo; n[m][d]:= mo; n[ m+1 ][ m+1 ]:= -o; for i in [ 1 .. m-1 ] do n[i][i+1]:= o; n[ d+1-i ][ d-i ]:= o; od; if q mod 2 = 0 then # $x = x_{\epsilon_1 - \epsilon_m}(1) x_{-\alpha_1}(1)$ x1:= IdentityMat( d, f ); x1[1][m]:= o; x1[ m+2 ][d]:= o; x2:= IdentityMat( d, f ); x2[ m+1 ][m]:= o; x2[ m+2 ][m]:= o; x:= x1 * x2; else # $x = x_{\alpha_1}(1)$ x:= IdentityMat( d, f ); x[m][ m+1 ]:= 2*o; x[ m+1 ][ m+2 ]:= -o; x[m][ m+2 ]:= -o; fi; if q <= 3 then # the matrices $x$ and $n$ g:= [ x, n ]; else # the matrices $h$ and $x n$ xi:= Z(q); h:= IdentityMat( d, f ); h[1][1]:= xi; h[m][m]:= xi; h[ m+2 ][ m+2 ]:= xi^-1; h[d][d]:= xi^-1; g:= [ h, x*n ]; fi; else # Omega(0,3,q), Section 4.6 if q <= 3 then # the matrices $x$ and $n$ g:= [ [[1,0,0],[1,1,0],[-1,-2,1]], [[0,0,-1],[0,-1,0],[-1,0,0]] ] * o; else # the matrices $n x$ and $h$ xi:= Z(q); g:= [ [[1,2,-1],[-1,-1,0],[-1,0,0]], [[xi^-2,0,0],[0,1,0],[0,0,xi^2]] ] * o; fi; fi; # construct the group without calling 'Group' g:= List( g, i -> ImmutableMatrix( f, i, true ) ); g:= GroupWithGenerators( g ); SetDimensionOfMatrixGroup( g, d ); SetFieldOfMatrixGroup( g, f ); # and set its size s := 1; q2 := q^2; q2i:= 1; for i in [ 1 .. m ] do q2i:= q2 * q2i; s := s * (q2i-1); od; if q mod 2 = 1 then s:= s/2; fi; SetSize( g, q^(m^2) * s ); # construct the bilinear form #T add the form! # and the quadratic form #T add the form! # and return return g; end ); ############################################################################# ## #F OmegaPlus( , ) . . . . . . . . . . . . . . . . \Omega^-_{}() ## BindGlobal( "OmegaPlus", function( d, q ) local f, o, m, xi, g, a, mo, n, i, x1, x2, x, h, s, q2, q2i; # must be even if d mod 2 = 1 then Error( " must be even" ); fi; f:= GF(q); o:= One( f ); m:= d / 2; xi:= Z(q); if m = 1 then # Omega(+1,2,q), Section 4.4 g:= [ [[xi^2,0],[0,xi^-2]] ] * o; elif m = 2 then # Omega(+1,4,q), Section 4.3 xi:= Z(q^2)^(q-1); a:= xi + xi^-1; g:= [ [[0,-1,0,-1],[1,a,-1,a],[0,0,0,1],[0,0,-1,a]], [[0,0,1,-1],[0,0,0,-1],[-1,-1,a,-a],[0,1,0,a]] ] * o; else # Omega(+1,d,q) for d=2m, Sections 4.1 and 4.2 if d mod 4 = 2 then mo:= -o; # (-1)^m else mo:= o; fi; n:= NullMat( d, d, f ); n[ m+2 ][1]:= mo; n[ m-1 ][d]:= mo; n[m][ m+1 ]:= o; n[ m+1 ][m]:= o; for i in [ 1 .. m-2 ] do n[i][ i+1 ]:= o; n[ d+1-i ][ d-i ]:= o; od; if m mod 2 = 0 then x1:= IdentityMat( d, f ); if q = 2 then x1[ m-1 ][ m+1 ]:= -o; x1[m][ m+2 ]:= o; else x1[ m+2 ][m]:= o; x1[ m+1 ][ m-1 ]:= -o; fi; x2:= IdentityMat( d, f ); x2[ m-2 ][ m-1 ]:= o; x2[ m+2 ][ m+3 ]:= -o; x:= x1 * x2; else x:= IdentityMat( d, f ); x[ m-1 ][ m+1 ]:= -o; x[m][ m+2 ]:= o; fi; if ( m mod 2 = 0 and q = 2 ) or ( m mod 2 = 1 and q <= 3 ) then # the matrices $x$ and $n$ g:= [ x, n ]; else # the matrices $h$ and $x n$ h:= IdentityMat( d, f ); h[ m-1 ][ m-1 ]:= xi; h[ m+2 ][ m+2 ]:= xi^-1; if m mod 2 = 0 then h[ m ][ m ]:= xi^-1; h[ m+1 ][ m+1 ]:= xi; else h[ m ][ m ]:= xi; h[ m+1 ][ m+1 ]:= xi^-1; fi; g:= [ h, x*n ]; fi; fi; # construct the group without calling 'Group' g:= List( g, i -> ImmutableMatrix( f, i, true ) ); g:= GroupWithGenerators( g ); SetDimensionOfMatrixGroup( g, d ); SetFieldOfMatrixGroup( g, f ); # and set its size s := 1; q2 := q^2; q2i:= 1; for i in [ 1 .. m-1 ] do q2i:= q2 * q2i; s := s * (q2i-1); od; if q mod 2 = 1 then s:= s/2; fi; SetSize( g, q^(m*(m-1)) * (q^m-1) * s ); # construct the bilinear form #T add the form! # and the quadratic form #T add the form! # and return return g; end ); ############################################################################# ## #F OmegaMinus( , ) . . . . . . . . . . . . . . . \Omega^-_{}() ## BindGlobal( "OmegaMinus", function( d, q ) local f, o, m, xi, mo, nu, nubar, h, x, n, i, g, s,q2, q2i; # must be even if d mod 2 = 1 then Error( " must be even" ); elif d < 4 then # The construction in the paper does not apply to the case d = 2 Error( " = 2 is not supported" ); fi; f:= GF(q); o:= One( f ); m:= d / 2 - 1; xi:= Z(q); if d mod 4 = 2 then mo:= -o; # (-1)^(m-1) else mo:= o; fi; nu:= Z(q^2); nubar:= nu^q; h:= IdentityMat( d, f ); h[m][m]:= nu * nubar; h[ m+3 ][ m+3 ]:= (nu * nubar)^-1; h{ [ m+1 .. m+2 ] }{ [ m+1 .. m+2 ] }:= [ [-1,nu^-1 + nubar^-1], [-nu-nubar, 1 + nu*nubar^-1 + nu^-1*nubar]] * o; x:= IdentityMat( d, f ); x{ [ m .. m+3 ] }{ [ m .. m+3 ] }:= [[1,1,0,1],[0,1,0,2], [0,0,1,nu+nubar], [0,0,0,1]] * o; n:= NullMat( d, d, f ); n[ m+3 ][1]:= mo; n[m][d]:= mo; n[ m+1 ][ m+1 ]:= -o; n[ m+2 ][ m+1 ]:= -nu - nubar; n[ m+2 ][ m+2 ]:= o; for i in [ 1 .. m-1 ] do n[i][ i+1 ]:= o; n[ d+1-i ][ d-i ]:= o; od; g:= [ h, x*n ]; # construct the group without calling 'Group' g:= List( g, i -> ImmutableMatrix( f, i, true ) ); g:= GroupWithGenerators( g ); SetDimensionOfMatrixGroup( g, d ); SetFieldOfMatrixGroup( g, f ); # and set its size m:= d/2; s := 1; q2 := q^2; q2i:= 1; for i in [ 1 .. m-1 ] do q2i:= q2 * q2i; s := s * (q2i-1); od; if q mod 2 = 1 then s:= s/2; fi; SetSize( g, q^(m*(m-1)) * (q^m+1) * s ); # construct the bilinear form #T add the form! # and the quadratic form #T add the form! # and return return g; end ); ############################################################################# ## #M OmegaCons( , , , ) . . . . . . . . . orthogonal group ## InstallMethod( OmegaCons, "matrix group for , dimension, and finite field size", [ IsMatrixGroup and IsFinite, IsInt, IsPosInt, IsPosInt ], function( filter, e, d, q ) local g, i; # if = 0 then must be odd if e = 0 and d mod 2 = 0 then Error( "sign = 0 but dimension is even\n" ); # if <> 0 then must be even elif e <> 0 and d mod 2 = 1 then Error( "sign <> 0 but dimension is odd\n" ); fi; # construct the various orthogonal groups if e = 0 then g:= OmegaZero( d, q ); elif e = 1 then g:= OmegaPlus( d, q ); elif e = -1 then g:= OmegaMinus( d, q ); else Error( "sign must be -1, 0, +1" ); fi; # set name if e = +1 then i := "+"; else i := ""; fi; SetName( g, Concatenation( "Omega(", i, String(e), ",", String(d), ",", String(q), ")" ) ); # and return return g; end ); ############################################################################# ## #M Omega( [, ][, ], ) ## InstallMethod( Omega, [ IsPosInt, IsPosInt ], function( d, q ) return OmegaCons( IsMatrixGroup, 0, d, q ); end ); InstallMethod( Omega, [ IsInt, IsPosInt, IsPosInt ], function( e, d, q ) return OmegaCons( IsMatrixGroup, e, d, q ); end ); InstallMethod( Omega, [ IsFunction, IsPosInt, IsPosInt ], function( filt, d, q ) return OmegaCons( filt, 0, d, q ); end ); InstallMethod( Omega, [ IsFunction, IsInt, IsPosInt, IsPosInt ], OmegaCons ); ############################################################################# ## #F WreathProductOfMatrixGroup( ,

) . . . . . . . . . wreath product ## BindGlobal( "WreathProductOfMatrixGroup", function( M, P ) local m, d, id, gens, b, ran, raN, mat, gen, G; m := DimensionOfMatrixGroup( M ); d := LargestMovedPoint( P ); id := IdentityMat( m * d, DefaultFieldOfMatrixGroup( M ) ); gens := [ ]; for b in [ 1 .. d ] do ran := ( b - 1 ) * m + [ 1 .. m ]; for mat in GeneratorsOfGroup( M ) do gen := StructuralCopy( id ); gen{ ran }{ ran } := mat; Add( gens, gen ); od; od; for gen in GeneratorsOfGroup( P ) do mat := StructuralCopy( id ); for b in [ 1 .. d ] do ran := ( b - 1 ) * m + [ 1 .. m ]; raN := ( b^gen - 1 ) * m + [ 1 .. m ]; mat{ ran } := id{ raN }; od; Add( gens, mat ); od; G := GroupWithGenerators( gens ); if HasName( M ) and HasName( P ) then SetName( G, Concatenation( Name( M ), " wr ", Name( P ) ) ); fi; return G; end ); ############################################################################# ## #F TensorWreathProductOfMatrixGroup( ,

) . . . tensor wreath product ## BindGlobal( "TensorWreathProductOfMatrixGroup", function( M, P ) local m, n, one, id, a, gens, b, ran, mat, gen, list, p, q, adic, i, G; m := DimensionOfMatrixGroup( M ); one := One( FieldOfMatrixGroup( M ) ); a := LargestMovedPoint( P ); n := m ^ a; id := Immutable( IdentityMat( n, one ) ); gens := [ ]; for b in [ 1 .. a ] do for mat in GeneratorsOfGroup( M ) do gen := KroneckerProduct ( IdentityMat( m ^ ( b - 1 ), one ), mat ); gen := KroneckerProduct ( gen, IdentityMat( m ^ ( a - b ), one ) ); Add( gens, gen ); od; od; for gen in GeneratorsOfGroup( SymmetricGroup( a ) ) do list := [ ]; for p in [ 0 .. n - 1 ] do adic := [ ]; for i in [ 0 .. a - 1 ] do adic[ ( a - i ) ^ gen ] := p mod m; p := QuoInt( p, m ); od; q := 0; for i in adic do q := q * m + i; od; Add( list, q ); od; Add( gens, id{ list + 1 } ); od; G := GroupWithGenerators( gens ); if HasName( M ) and HasName( P ) then SetName( G, Concatenation( Name( M ), " twr ", Name( P ) ) ); fi; return G; end ); ############################################################################# ## #F CentralProductOfMatrixGroups( , ) . . . . . . . . central product ## BindGlobal( "CentralProductOfMatrixGroups", function( M, N ) local gens, id, mat, G; gens := [ ]; id := One( N ); for mat in GeneratorsOfGroup( M ) do Add( gens, KroneckerProduct( mat, id ) ); od; id := One( M ); for mat in GeneratorsOfGroup( N ) do Add( gens, KroneckerProduct( id, mat ) ); od; G := GroupWithGenerators( gens ); if HasName( M ) and HasName( N ) then SetName( G, Concatenation( Name( M ), " o ", Name( N ) ) ); fi; return G; end ); # Permutation constructors by using `IsomorphismPermGroup' PermConstructor(GeneralLinearGroupCons,[IsPermGroup,IsInt,IsObject], IsMatrixGroup and IsFinite); PermConstructor(GeneralOrthogonalGroupCons,[IsPermGroup,IsInt,IsInt,IsObject], IsMatrixGroup and IsFinite); PermConstructor(GeneralUnitaryGroupCons,[IsPermGroup,IsInt,IsObject], IsMatrixGroup and IsFinite); PermConstructor(SpecialLinearGroupCons,[IsPermGroup,IsInt,IsObject], IsMatrixGroup and IsFinite); PermConstructor(SpecialOrthogonalGroupCons,[IsPermGroup,IsInt,IsInt,IsObject], IsMatrixGroup and IsFinite); PermConstructor(SpecialUnitaryGroupCons,[IsPermGroup,IsInt,IsObject], IsMatrixGroup and IsFinite); PermConstructor(SymplecticGroupCons,[IsPermGroup,IsInt,IsObject], IsMatrixGroup and IsFinite); PermConstructor(OmegaCons,[IsPermGroup,IsInt,IsObject], IsMatrixGroup and IsFinite); ############################################################################# ## #E gap-4r6p5/grp/imf.gi0000644000175000017500000004574612172557252013045 0ustar billbill############################################################################# ## #W imf.gi GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland ## ## This file contains the library functions for the GAP library of ## irreducible maximal finite integral matrix groups. ## ############################################################################# ## #F BaseShortVectors( ) . . . . . . . . . . . . . . . . . . . . . . . ## InstallGlobalFunction( "BaseShortVectors", function ( orbit ) local base, count, dim, i, j, nums, vector; dim := Length( orbit[1] ); base := ListWithIdenticalEntries( dim, 0 ); nums := ListWithIdenticalEntries( dim, 0 ); count := 0; i := 0; while count < dim do i := i + 1; vector := orbit[i]; j := 0; while j < dim do j := j + 1; if vector[j] <> 0 then if nums[j] <> 0 then vector := vector - vector[j] * base[j]; else base[j] := vector / vector[j]; nums[j] := i; count := count + 1; j := dim; fi; fi; od; od; base := List( nums, i -> orbit[i] ); return [ nums, base^-1 ]; end ); ############################################################################# ## #F DisplayImfInvariants( , ) . . . . . . . . . . . . . . . . . . . #F DisplayImfInvariants( , , ) . . . . . . . . . . . . . . . . . ## InstallGlobalFunction( "DisplayImfInvariants", function ( arg ) local dim, dims, hyphens, linelength, q, qq, z; # load the imf main list if it is not yet available if not IsBound( IMFList ) then IMFLoad( 0 ); fi; # get the arguments dim := arg[1]; q := arg[2]; if Length( arg ) > 2 then z := arg[3]; else z := 1; fi; # get the range of dimensions to be handled if dim = 0 then dims := [ 1 .. IMFRec.maximalDimension ]; else # check the given dimension for being in range if dim < 0 or IMFRec.maximalDimension < dim then Error( "dimension out of range" ); fi; dims := [ dim ]; fi; # loop over all dimensions in that range for dim in dims do # handle the cases q = 0 and q > 0 differently if q = 0 then linelength := Minimum( SizeScreen()[1], 76 ); hyphens := Concatenation( List( [ 1 .. linelength - 5 ], i -> "-" ) ); # loop over the Q-classes of dimension dim for qq in [ 1 .. IMFRec.numberQClasses[dim] ] do # print a line of separators Print( "#I ", hyphens, "\n" ); # check the Z-class number for being in range if z < 0 or Length( IMFRec.bNumbers[dim][qq] ) < z then Error( "Z-class number out of range" ); fi; # display the specified Z-classes in the Q-class DisplayImfReps( dim, qq, z ); od; # print a line of separators Print( "#I ", hyphens, "\n" ); else # check the given Q-class number for being in range if q < 1 or IMFRec.numberQClasses[dim] < q then Error( "Q-class number out of range" ); fi; # check the Z-class number for being in range if z < 0 or Length( IMFRec.bNumbers[dim][q] ) < z then Error( "Z-class number out of range" ); fi; # display the specified Z-classes in the Q-class DisplayImfReps( dim, q, z ); fi; od; end ); ############################################################################# ## #F DisplayImfReps( , , ) . . . . . . . . . . . . . . . . . . . . ## InstallGlobalFunction( "DisplayImfReps", function ( dim, q, z ) local bound, degree, degs, eldivs, i, leng, mult, n, norm, qmax, size, solvable, type, znums; # get the position numbers of the groups to be handled znums := IMFRec.bNumbers[dim][q]; if z = 0 then z := 1; bound := Length( znums ); else bound := z; fi; # loop over the classes to be displayed while z <= bound do n := znums[z]; type := IMFList[dim].isomorphismType[n]; size := IMFList[dim].size[n]; solvable := IMFList[dim].isSolvable[n]; eldivs := IMFList[dim].elementaryDivisors[n]; degs := IMFList[dim].degrees[n]; norm := IMFList[dim].minimalNorm[n]; # print a class number if IMFRec.repsAreZReps[dim] then Print( "#I Z-class ", dim, ".", q, ".", z ); else Print( "#I Q-class ", dim, ".", q ); fi; # print solvability and group size if solvable then Print( ": Solvable, size = " ); else Print( ": Size = " ); fi; PrintFactorsInt( size ); Print( "\n" ); # print the isomorphism type Print( "#I isomorphism type = " ); Print( type, "\n" ); # print the elementary divisors Print( "#I elementary divisors = " ); Print( eldivs[1] ); if eldivs[2] > 1 then Print( "^", eldivs[2] ); fi; leng := Length( eldivs ); i := 3; while i < leng do Print( "*", eldivs[i] ); if eldivs[i+1] > 1 then Print( "^", eldivs[i+1] ); fi; i := i + 2; od; Print( "\n" ); # print the orbit size Print( "#I orbit size = " ); if IsInt( degs ) then Print( degs ); leng := 1; else leng := Length( degs ); i := 0; while i < leng do i := i + 1; degree := degs[i]; mult := 1; while i < leng and degs[i+1] = degree do mult := mult + 1; i := i + 1; od; if mult > 1 then Print( mult, "*" ); fi; Print( degree ); if i < leng then Print( " + " ); fi; od; fi; # print the minimal norm Print( ", minimal norm = ", norm, "\n" ); # print a message if the group is not imf in Q qmax := IMFRec.maximalQClasses[dim][q]; if qmax <> q then Print( "#I not maximal finite in GL(", dim, ",Q), rational imf class is ", dim, ".", qmax, "\n" ); fi; z := z + 1; od; end ); ############################################################################# ## #F ImfInvariants( , ) . . . . . . . . . . . . . . . . . . . . . . . #F ImfInvariants( , , ) . . . . . . . . . . . . . . . . . . . . ## InstallGlobalFunction( "ImfInvariants", function ( arg ) local dim, eldivs, flat, i, infrec, j, leng, n, q, qmax, sizes; # check the arguments and get the position number of the class to be # handled n := ImfPositionNumber( arg ); dim := arg[1]; q := arg[2]; # get the size of the orbits of short vectors sizes := IMFList[dim].degrees[n]; if IsInt( sizes ) then sizes := [ sizes ]; fi; # get the elementary divisors flat := IMFList[dim].elementaryDivisors[n]; leng := Length( flat ); eldivs := [ ]; i := 1; while i < leng do for j in [ 1 .. flat[i+1] ] do Add( eldivs, flat[i] ); od; i := i + 2; od; # get the Q-class number of the corresponding rational imf class qmax := IMFRec.maximalQClasses[dim][q]; # create the information record and return it infrec := rec( size := IMFList[dim].size[n], isSolvable := IMFList[dim].isSolvable[n], isomorphismType := IMFList[dim].isomorphismType[n], elementaryDivisors := eldivs, minimalNorm := IMFList[dim].minimalNorm[n], sizesOrbitsShortVectors := sizes ); if qmax <> q then infrec.maximalQClass := qmax; fi; return infrec; end ); ############################################################################# ## #F IMFLoad( ) . . . . . . . . load a secondary file of the imf library ## InstallGlobalFunction( "IMFLoad", function ( dim ) local d, maxdim, name; # initialize the imf main list if it is not yet available if not IsBound( IMFList ) then name := "imf.grp"; Info( InfoImf, 2, "loading secondary file ", name ); if not ReadGrp( name, "imf" ) then Error( "cannot load secondary file ", name ); fi; fi; # check whether we actually need to load a matrix file if dim > 0 and not IsBound( IMFList[dim].matrices ) then # load the file if dim < 10 then name := "imf1to9.grp"; else name := Concatenation( "imf", String( dim ), ".grp" ); fi; Info( InfoImf, 2, "loading secondary file ", name ); if not ReadGrp( name, "imf" ) then Error( "cannot load secondary file ", name ); fi; fi; return; end ); ############################################################################# ## #F ImfMatrixGroup( , ) . . . . . . . . . . . . . . . . . . . . . . #F ImfMatrixGroup( , , ) . . . . . . . . . . . . . . . . . . . . ## InstallGlobalFunction( "ImfMatrixGroup", function ( arg ) local degrees, dim, form, gens, i, imfM, j, M, mats, n, name, q, qmax, reps, z; # check the arguments and get the position number of the class to be # handled n := ImfPositionNumber( arg ); # get dimension, Q-class number, and Z-class number dim := arg[1]; q := arg[2]; z := arg[3]; # load the appropriate imf matrix file if it is not yet available if not IsBound( IMFList[dim].matrices ) then IMFLoad( dim ); fi; # construct the matrix group mats := IMFList[dim].matrices[n]; gens := mats[2]; M := Group( gens, gens[1] * gens[1]^-1 ); # construct the group name if IMFRec.repsAreZReps[dim] then name := Concatenation( "ImfMatrixGroup(", String( dim ), ",", String( q ), ",", String( z ), ")" ); else name := Concatenation( "ImfMatrixGroup(", String( dim ), ",", String( q ), ")" ); fi; # get the associated Gram matrix form := List( mats[1], ShallowCopy ); for i in [ 1 .. dim - 1 ] do for j in [ i + 1 .. dim ] do form[i][j] := form[j][i]; od; od; # get the representatives and sizes of the orbits of short vectors reps := IMFList[dim].orbitReps[n]; degrees := IMFList[dim].degrees[n]; if IsInt( degrees ) then degrees := [ degrees ]; reps := [ reps ]; fi; # get the Q-class number of the corresponding rational imf class qmax := IMFRec.maximalQClasses[dim][q]; # define an approriate imf record imfM := rec( ); imfM.isomorphismType := IMFList[dim].isomorphismType[n]; imfM.elementaryDivisors := ElementaryDivisorsMat( form ); imfM.form := form; imfM.minimalNorm := IMFList[dim].minimalNorm[n]; imfM.repsOrbitsShortVectors := reps; imfM.sizesOrbitsShortVectors := degrees; if qmax <> q then imfM.maximalQClass := qmax; fi; # define some approriate group attributes SetFilterObj( M, IsImfMatrixGroup ); SetName( M, name ); SetSize( M, IMFList[dim].size[n] ); SetIsSolvableGroup( M, IMFList[dim].isSolvable[n] ); SetImfRecord( M, imfM ); return M; end ); ############################################################################# ## #F ImfNumberQClasses( ) . . . . . . . . . . . . . . . . . . . . . . . ## InstallGlobalFunction( "ImfNumberQClasses", function ( dim ) # load the imf main list if it is not yet available if not IsBound( IMFList ) then IMFLoad( 0 ); fi; # check the given dimension for being in range if dim < 0 or IMFRec.maximalDimension < dim then Error( "dimension out of range" ); fi; return IMFRec.numberQClasses[dim]; end ); ############################################################################# ## #F ImfNumberQQClasses( ) . . . . . . . . . . . . . . . . . . . . . . . ## InstallGlobalFunction( "ImfNumberQQClasses", function ( dim ) # load the imf main list if it is not yet available if not IsBound( IMFList ) then IMFLoad( 0 ); fi; # check the given dimension for being in range if dim < 0 or IMFRec.maximalDimension < dim then Error( "dimension out of range" ); fi; return IMFRec.numberQQClasses[dim]; end ); ############################################################################# ## #F ImfNumberZClasses( , ) . . . . . . . . . . . . . . . . . . . . . ## InstallGlobalFunction( "ImfNumberZClasses", function ( dim, q ) local num; # load the imf main list if it is not yet available if not IsBound( IMFList ) then IMFLoad( 0 ); fi; # check the dimension for being in range if dim < 1 or IMFRec.maximalDimension < dim then Error( "dimension out of range" ); fi; # check the Q-class number for being in range if q < 1 or IMFRec.numberQClasses[dim] < q then Error( "Q-class number out of range" ); fi; # return the number of class representatives in the given Q-class return Length( IMFRec.bNumbers[dim][q] ); end ); ############################################################################# ## #F ImfPositionNumber( [ , ] ) . . . . . . . . . . . . . . . . . . . #F ImfPositionNumber( [ , , ] ) . . . . . . . . . . . . . . . . ## InstallGlobalFunction( "ImfPositionNumber", function ( args ) local dim, n, q, z, znums; # load the imf main list if it is not yet available if not IsBound( IMFList ) then IMFLoad( 0 ); fi; # check the dimension for being in range dim := args[1]; if dim < 1 or IMFRec.maximalDimension < dim then Error( "dimension out of range" ); fi; # check the Q-class number for being in range q := args[2]; if q < 1 or IMFRec.numberQClasses[dim] < q then Error( "Q-class number out of range" ); fi; znums := IMFRec.bNumbers[dim][q]; # get the Z-class number and check it for being in range if Length( args ) = 2 then z := 1; args[3] := 1; else z := args[3]; if z < 1 or Length( znums ) < z then Error( "Z-class number out of range" ); fi; fi; # return the position number of the class to be handled return znums[z]; end ); ############################################################################# ## #F IsomorphismPermGroupImfGroup( ) . . . . . . . . . . . . . . . . . . . #F IsomorphismPermGroupImfGroup( , ) . . . . . . . . . . . . . . . . ## InstallGlobalFunction( "IsomorphismPermGroupImfGroup", function ( arg ) local base, degrees, gens, id, imfM, imfP, M, n, orbit, P, perms, phi, reps, vec; # check the given group for being an imf matrix group M := arg[1]; if not IsImfMatrixGroup( M ) then Error( "the given group is not an imf matrix group" ); fi; imfM := ImfRecord( M ); # check the given orbit number for being in range degrees := imfM.sizesOrbitsShortVectors; reps := imfM.repsOrbitsShortVectors; if Length( arg ) = 1 then n := 1; else n := arg[2]; if not n in [ 1 .. Length( reps ) ] then Error( "orbit number out of range" ); fi; fi; # compute the specified orbit of short vectors gens := GeneratorsOfGroup( M ); orbit := OrbitShortVectors( gens, reps[n] ); # check the orbit size if Length( orbit ) <> degrees[n] then Error( "inconsistent orbit size" ); fi; # construct the associated permutation group perms := List( gens, g -> PermList( List( orbit, vec -> PositionSorted( orbit, vec * g ) ) ) ); id := perms[1]^0; P := Group( perms, id ); # define an approriate imf record imfP := rec( ); # define some appropriate group attributes SetSize( P, Size( M ) ); SetIsSolvableGroup( P, IsSolvableGroup( M ) ); SetLargestMovedPoint( P, degrees[n] ); SetImfRecord( P, imfP ); # if IsBound( imfM.isomorphismType ) then # imfP.isomorphismType := imfM.isomorphismType; # fi; # imfP.matGroup := M; # compute the information which will be needed to reconvert permutations # to matrices base := BaseShortVectors( orbit ); imfP.orbitShortVectors := orbit; imfP.baseVectorPositions := base[1]; imfP.baseChangeMatrix := base[2]; # construct the associated isomorphism from M to P phi := GroupHomomorphismByFunction( M, P, function ( mat ) local imf; imf := ImfRecord( P ); return PermList( List( imf.orbitShortVectors, v -> PositionSorted( imf.orbitShortVectors, v*mat ) ) ); end, function ( perm ) local imf; imf := ImfRecord( P ); return imf.baseChangeMatrix * List( imf.baseVectorPositions, i -> imf.orbitShortVectors[i^perm] ); end ); SetIsBijective( phi, true ); # if n = 1, save a nice monomorphism of M if n = 1 and not HasNiceMonomorphism( M ) then SetNiceMonomorphism( M, phi ); fi; return phi; end ); ############################################################################# ## #M IsomorphismPermGroup( ) ## InstallMethod( IsomorphismPermGroup, "imf matrix groups", [IsMatrixGroup and IsFinite and IsImfMatrixGroup], IsomorphismPermGroupImfGroup ); ############################################################################# ## #F OrbitShortVectors( , ) . . . . . . . . . . . . . . . . . . . ## InstallGlobalFunction( "OrbitShortVectors", function ( gens, rep ) local generator, images, new, nextvec, null, orbit, vector; orbit := [ ]; null := ListWithIdenticalEntries( Length( rep ), 0 ); if rep > null then images := [ Immutable( rep ) ]; else images := [ Immutable( -rep ) ]; fi; while images <> [ ] do Append( orbit, images ); new := [ ]; for generator in gens do for vector in images do nextvec := vector * generator; if nextvec > null then Add( new, nextvec ); else Add( new, -nextvec ); fi; od; od; new := Set( new ); SubtractSet( new, orbit ); images := new; od; Append( orbit, -orbit ); # The function Immutable in the following statement essentially speeds # up the function PositionSorted in IsomorphismPermGroupImfGroup. return Immutable( Set( orbit ) ); end ); ############################################################################# ## #E gap-4r6p5/grp/perf9.grp0000644000175000017500000011461312172557252013476 0ustar billbill############################################################################# ## #W perf9.grp GAP Groups Library Volkmar Felsch ## Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains the perfect groups of sizes 190080-345600 ## All data is based on Holt/Plesken: Perfect Groups, OUP 1989 ## PERFGRP[159]:=[# 190080.1 [[1,"abd", function(a,b,d) return [[a^2,b^3,(a*b)^11*d^-1,(a^-1*b^-1*a*b)^6, (a*b*a*b*a*b^-1)^6*d^-1, (a*b*a*b*a*b^-1*a*b^-1)^5,d^2, a^-1*d*a*d^-1,b^-1*d*b*d^-1], [[a,b*a*b^-1*a*(b^-1*a*b*a)^2]]]; end, [24]], "M12 2^1",28,-2, 31,24] ]; PERFGRP[160]:=[# 192000.1 [[4,7680,4,3000,2,120,4,1], "A5 # 2^7 5^2 [1]",6,4, 1,[24,64,25]], # 192000.2 [[4,7680,5,3000,2,120,5,1], "A5 # 2^7 5^2 [2]",6,4, 1,[24,24,25]] ]; PERFGRP[161]:=[# 194472.1 [[1,"abc", function(a,b,c) return [[c^36,c*b^25*c^-1*b^-1,b^73,a^2,c*a*c*a^-1 ,(b*a)^3, c^(-1*10)*b^2*c*b*c*a*b*c^2*b*a*b^2*c*b*a], [[b,c]]]; end, [74],[0,3,5,3]], "L2(73)",22,-1, 39,74] ]; PERFGRP[162]:=[# 201720.1 [[1,"abyz", function(a,b,y,z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,y^41,z^41,y^-1 *z^-1*y*z,a^-1*y*a*z^-1, a^-1*z*a*y, b^-1*y*b*(y^-1*z^(-1*16))^-1, b^-1*z*b*y^(-1*18)],[[a*b,a^2,y]]]; end, [492],[0,0,2,2]], "A5 2^1 41^2",[5,2,1],1, 1,492] ]; PERFGRP[163]:=[# 205200.1 [[2,60,1,3420,1], "A5 x L2(19)",40,1, [1,9],[5,20]] ]; PERFGRP[164]:=[# 205320.1 [[1,"abc", function(a,b,c) return [[c^29*a^2,c*b^4*c^-1*b^-1,b^59,a^4,a^2*b^(-1 *1)*a^2*b,a^2*c^-1*a^2*c, c*a*c*a^-1,(b*a)^3],[[b,c^2]]]; end, [120]], "L2(59) 2^1 = SL(2,59)",22,-2, 32,120] ]; PERFGRP[165]:=[# 216000.1 [[2,60,1,3600,1], "A5 x A5 x A5",40,1, [1,1,1],[5,5,5]] ]; PERFGRP[166]:=[# 221760.1 [[2,336,1,660,1], "( L3(2) x L2(11) ) 2^1 [1]",[39,1,1],2, [2,5],[16,11]], # 221760.2 [[2,168,1,1320,1], "( L3(2) x L2(11) ) 2^1 [2]",[39,1,2],2, [2,5],[7,24]], # 221760.3 [[3,336,1,1320,1,"d1","d2"], "( L3(2) x L2(11) ) 2^1 [3]",[39,1,3],2, [2,5],192] ]; PERFGRP[167]:=[# 223608.1 [[1,"abxyz", function(a,b,x,y,z) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,x^11,y^11, z^11,x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*x*a*z^-1, a^-1*y*a*y,a^-1*z*a*x^-1, b^-1*x*b*(y^4*z^-1)^-1, b^-1*y*b*(x^5*y*z^(-1*5))^-1, b^-1*z*b*(x^(-1*5)*y^3*z^-1)^-1], [[b*a*b^-1,b^-1*a*b,z]]]; end, [231]], "L3(2) 11^3",[11,3,1],1, 2,231] ]; PERFGRP[168]:=[# 225792.1 [[2,168,1,1344,1], "( L3(2) x L3(2) ) # 2^3 [1]",[34,3,1],1, [2,2],[7,8]], # 225792.2 [[2,168,1,1344,2], "( L3(2) x L3(2) ) # 2^3 [2]",[34,3,2],1, [2,2],[7,14]] ]; PERFGRP[169]:=[# 226920.1 [[1,"abc", function(a,b,c) return [[c^30*a^2,c*b^4*c^-1*b^-1,b^61,a^4,a^2*b^(-1 *1)*a^2*b,a^2*c^-1*a^2*c, c*a*c*a^-1,(b*a)^3, c^(-1*4)*(b*c)^3*c*a*b^2*a*c*b^2*a],[[b,c^4]]]; end, [248]], "L2(61) 2^1 = SL(2,61)",22,-2, 33,248] ]; PERFGRP[170]:=[# 230400.1 [[2,1920,1,120,1], "( A5 x A5 ) # 2^6 [1]",[29,6,1],4, [1,1],[12,24]], # 230400.2 [[2,1920,2,120,1], "( A5 x A5 ) # 2^6 [2]",[29,6,2],4, [1,1],[24,24]], # 230400.3 [[2,1920,3,120,1], "( A5 x A5 ) # 2^6 [3]",[29,6,3],4, [1,1],[16,24,24]], # 230400.4 [[2,1920,4,120,1], "( A5 x A5 ) # 2^6 [4]",[29,6,4],2, [1,1],[80,24]], # 230400.5 [[2,1920,5,120,1], "( A5 x A5 ) # 2^6 [5]",[29,6,5],4, [1,1],[10,24,24]], # 230400.6 [[2,1920,6,120,1], "( A5 x A5 ) # 2^6 [6]",[29,6,6],4, [1,1],[80,24]], # 230400.7 [[2,1920,7,120,1], "( A5 x A5 ) # 2^6 [7]",[29,6,7],4, [1,1],[32,24]], # 230400.8 [[2,3840,1,60,1], "( A5 x A5 ) # 2^6 [8]",[29,6,8],4, [1,1],[64,5]], # 230400.9 [[2,3840,2,60,1], "( A5 x A5 ) # 2^6 [9]",[29,6,9],4, [1,1],[64,5]], # 230400.10 [[2,3840,3,60,1], "( A5 x A5 ) # 2^6 [10]",[29,6,10],4, [1,1],[24,5]], # 230400.11 [[2,3840,4,60,1], "( A5 x A5 ) # 2^6 [11]",[29,6,11],4, [1,1],[48,5]], # 230400.12 [[2,3840,5,60,1], "( A5 x A5 ) # 2^6 [12]",[29,6,12],4, [1,1],[24,12,5]], # 230400.13 [[2,3840,6,60,1], "( A5 x A5 ) # 2^6 [13]",[29,6,13],2, [1,1],[48,5]], # 230400.14 [[2,3840,7,60,1], "( A5 x A5 ) # 2^6 [14]",[29,6,14],4, [1,1],[32,24,5]], # 230400.15 [[3,3840,1,120,1,"e1","e1","d2"], "( A5 x A5 ) # 2^6 [15]",[29,6,15],4, [1,1],768], # 230400.16 [[3,3840,2,120,1,"e1","e1","d2"], "( A5 x A5 ) # 2^6 [16]",[29,6,16],4, [1,1],768], # 230400.17 [[3,3840,3,120,1,"e1","d2"], "( A5 x A5 ) # 2^6 [17]",[29,6,17],4, [1,1],288], # 230400.18 [[3,3840,4,120,1,"e1","d2"], "( A5 x A5 ) # 2^6 [18]",[29,6,18],4, [1,1],576], # 230400.19 [[3,3840,4,120,1,"d1","d2"], "( A5 x A5 ) # 2^6 [19]",[29,6,19],4, [1,1],576], # 230400.20 [[3,3840,5,120,1,"d1","d2"], "( A5 x A5 ) # 2^6 [20]",[29,6,20],4, [1,1],[288,144]], # 230400.21 [[3,3840,5,120,1,"e1","d2"], "( A5 x A5 ) # 2^6 [21]",[29,6,21],4, [1,1],[288,144]], # 230400.22 [[3,3840,5,120,1,"d1","e1","d2"], "( A5 x A5 ) # 2^6 [22]",[29,6,22],4, [1,1],[288,144]], # 230400.23 [[3,3840,6,120,1,"e1","d2"], "( A5 x A5 ) # 2^6 [23]",[29,6,23],2, [1,1],576], # 230400.24 [[3,3840,7,120,1,"d1","d2"], "( A5 x A5 ) # 2^6 [24]",[29,6,24],4, [1,1],[384,288]], # 230400.25 [[3,3840,7,120,1,"e1","d2"], "( A5 x A5 ) # 2^6 [25]",[29,6,25],4, [1,1],[384,288]], # 230400.26 [[3,3840,7,120,1,"d1","e1","d2"], "( A5 x A5 ) # 2^6 [26]",[29,6,26],4, [1,1],[384,288]] ]; PERFGRP[171]:=[# 232320.1 [[4,1920,3,14520,2,120,3,1], "A5 # 2^5 11^2 [1]",6,1, 1,[16,24,121]], # 232320.2 [[4,1920,4,14520,2,120,4,1], "A5 # 2^5 11^2 [2]",6,1, 1,[80,121]], # 232320.3 [[4,1920,5,14520,2,120,5,1], "A5 # 2^5 11^2 [3]",6,1, 1,[10,24,121]] ]; PERFGRP[172]:=[# 233280.1 [[1,"abwxyzrstuv", function(a,b,w,x,y,z,r,s,t,u,v) return [[a^2,b^3,(a*b)^5,w^2,x^2,y^2,z^2,w^-1*x^-1*w *x,w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*w*a*z^-1, a^-1*x*a*x^-1,a^-1*y*a*(w*x*y*z)^-1 ,a^-1*z*a*w^-1,b^-1*w*b*x^-1, b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1,r^3,s^3,t^3,u^3,v^3, r^-1*s^-1*r*s,r^-1*t^-1*r*t, r^-1*u^-1*r*u,r^-1*v^-1*r*v, s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, a^-1*r*a*u^-1,a^-1*s*a*s^-1, a^-1*t*a*v^-1,a^-1*u*a*r^-1, a^-1*v*a*t^-1,b^-1*r*b*s^-1, b^-1*s*b*t^-1,b^-1*t*b*r^-1, b^-1*u*b*u^-1,b^-1*v*b*v^-1, w^-1*r*w*r^-1,w^-1*s*w*s, w^-1*t*w*t,w^-1*u*w*u,w^-1*v*w*v, x^-1*r*x*r,x^-1*s*x*s^-1, x^-1*t*x*t,x^-1*u*x*u,x^-1*v*x*v, y^-1*r*y*r,y^-1*s*y*s, y^-1*t*y*t^-1,y^-1*u*y*u, y^-1*v*y*v,z^-1*r*z*r,z^-1*s*z*s, z^-1*t*z*t,z^-1*u*z*u^-1, z^-1*v*z*v],[[b,a*b*a*b^-1*a,w,r]]]; end, [15]], "A5 2^4' 3^5",[7,5,2],1, 1,15], # 233280.2 [[4,960,1,14580,1,60], "A5 # 2^4 3^5 [1]",6,3, 1,[16,18]], # 233280.3 [[4,960,2,14580,1,60], "A5 # 2^4 3^5 [2]",6,3, 1,[10,18]] ]; PERFGRP[173]:=[# 237600.1 [[2,360,1,660,1], "A6 x L2(11)",40,1, [3,5],[6,11]] ]; PERFGRP[174]:=[# 240000.1 [[4,1920,1,7500,1,60], "A5 # 2^5 5^3 [1]",6,2, 1,[12,30]], # 240000.2 [[4,1920,2,7500,1,60], "A5 # 2^5 5^3 [2]",6,2, 1,[24,30]], # 240000.3 [[4,1920,3,7500,1,60], "A5 # 2^5 5^3 [3]",6,2, 1,[16,24,30]], # 240000.4 [[4,1920,4,7500,1,60], "A5 # 2^5 5^3 [4]",6,1, 1,[80,30]], # 240000.5 [[4,1920,5,7500,1,60], "A5 # 2^5 5^3 [5]",6,2, 1,[10,24,30]], # 240000.6 [[4,1920,6,7500,1,60], "A5 # 2^5 5^3 [6]",6,2, 1,[80,30]], # 240000.7 [[4,1920,7,7500,1,60], "A5 # 2^5 5^3 [7]",6,2, 1,[32,30]], # 240000.8 [[4,1920,1,7500,2,60], "A5 # 2^5 5^3 [8]",6,2, 1,[12,30]], # 240000.9 [[4,1920,2,7500,2,60], "A5 # 2^5 5^3 [9]",6,2, 1,[24,30]], # 240000.10 [[4,1920,3,7500,2,60], "A5 # 2^5 5^3 [10]",6,2, 1,[16,24,30]], # 240000.11 [[4,1920,4,7500,2,60], "A5 # 2^5 5^3 [11]",6,1, 1,[80,30]], # 240000.12 [[4,1920,5,7500,2,60], "A5 # 2^5 5^3 [12]",6,2, 1,[10,24,30]], # 240000.13 [[4,1920,6,7500,2,60], "A5 # 2^5 5^3 [13]",6,2, 1,[80,30]], # 240000.14 [[4,1920,7,7500,2,60], "A5 # 2^5 5^3 [14]",6,2, 1,[32,30]], # 240000.15 [[4,1920,3,15000,4,120,3,3], "A5 # 2^5 5^3 [15]",6,5, 1,[16,24,125]], # 240000.16 [[4,1920,4,15000,4,120,4,3], "A5 # 2^5 5^3 [16]",6,5, 1,[80,125]], # 240000.17 [[4,1920,5,15000,4,120,5,3], "A5 # 2^5 5^3 [17]",6,5, 1,[10,24,125]] ]; PERFGRP[175]:=[# 241920.1 [[1,"abdwxyz", function(a,b,d,w,x,y,z) return [[a^6*d^-1,b^4*d^-1,(a*b)^7,(a*b)^2*a*b^2*( a*b*a*b^-1)^2*(a*b)^2 *(a*b^-1)^2*a*b*a*b^-1*a^2*d, a^2*d*b*(a^2*d)^-1*b^-1,d^2, d^-1*a^-1*d*a,d^-1*b^-1*d*b,w^2, x^2,y^2,z^2,w*x*w*x,w*y*w*y,w*z*w*z,x*y*x*y, x*z*x*z,y*z*y*z,a^-1*w*a*y^-1, a^-1*x*a*z^-1,a^-1*y*a*w^-1, a^-1*z*a*x^-1,b^-1*w*b*(w*x*y*z)^-1 ,b^-1*x*b*y^-1,b^-1*y*b*(w*x)^-1, b^-1*z*b*(w*z)^-1], [[a^3,(b^-1*a)^2*(b*a)^2*b^2*a*b*a,w],[a,b], [a*b, b*a*b*a*b^2*a*b^-1*a*b*a*b^-1*a*b*a *b^2*d,a^2*d,w]]]; end, [45,16,240]], "A7 3^1 x 2^1 x 2^4",[23,5,1],6, 8,[45,16,240]], # 241920.2 [[1,"abdef", function(a,b,d,e,f) return [[a^2,b^4,(a*b)^7*d^-1*e,(a^-1*b^-1*a*b)^5, (a*b^2)^5*(e*f)^-1,(a*b*a*b*a*b^3)^5*f, (a*b*a*b*a*b^2*a*b^-1)^5*d^(-1*2),d^3, a^-1*d*a*d^-1,b^-1*d*b*d^-1,e^2, f^2,e^-1*f^-1*e*f,a^-1*e*a*e^-1, a^-1*f*a*f^-1,b^-1*e*b*e^-1, b^-1*f*b*f^-1], [[a*b*a,b^2*a*b^-1*a*b*a*b^2*a*b*d], [a*e,b*a*b*a*b^-1*a*b^2*f^-1]]]; end, [63,224],[[1,2]]], "L3(4) 3^1 x 2^1 x 2^1",[27,2,1],-12, 20,[63,224]], # 241920.3 [[1,"abdf", function(a,b,d,f) return [[a^2,b^4*f^(-1*2),(a*b)^7*d^-1,(a^-1*b^-1*a *b)^5*f^(-1*2),(a*b^2)^5*f^-1, (a*b*a*b*a*b^3)^5*f, (a*b*a*b*a*b^2*a*b^-1)^5*d^(-1*2),d^3, a^-1*d*a*d^-1,b^-1*d*b*d^-1,f^4, a^-1*f*a*f^-1,b^-1*f*b*f^-1], [[a*b*a,b^2*a*b^-1*a*b*a*b^2*a*b*d], [a,b*a*b*a*b^-1*a*b^2*f^-1]]]; end, [63,224],[[1,2]]], "L3(4) 3^1 x 2^1 A 2^1 I",[27,2,2],-12, 20,[63,224]], # 241920.4 [[1,"abde", function(a,b,d,e) return [[a^2,b^4*e^(-1*2),(a*b)^7*d^-1*e,(a^-1*b^-1 *a*b)^5*e^(-1*2),(a*b^2)^5*e^-1, (a*b*a*b*a*b^3)^5*e^(-1*2), (a*b*a*b*a*b^2*a*b^-1)^5*d^(-1*2),d^3, a^-1*d*a*d^-1,b^-1*d*b*d^-1, a^-1*e*a*e^-1,b^-1*e*b*e^-1], [[a*b*a,b^2*a*b^-1*a*b*a*b^2*a*b*d], [a*e^2,b^-1*a*b^-1*a*b*a*b^2]]]; end, [63,224],[[1,2]]], "L3(4) 3^1 x 2^1 A 2^1 II",[27,2,3],-12, 20,[63,224]], # 241920.5 [[2,336,1,720,1], "( L3(2) x A6 ) 2^2",[37,2,1],4, [2,3],[16,80]] ]; PERFGRP[176]:=[# 243000.1 [[4,9720,4,3000,2,120,3,1], "A5 2^1 # 3^4 5^2",6,1, 1,[45,25]] ]; PERFGRP[177]:=[# 244800.1 [[2,60,1,4080,1], "A5 x L2(16)",40,1, [1,10],[5,17]] ]; PERFGRP[178]:=[# 244944.1 [[1,"abuvwxyz", function(a,b,u,v,w,x,y,z) return [[a^4,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4*a^2,a^2*b *a^2*b^-1,u^3,v^3,w^3,x^3,y^3,z^3, u^-1*v^-1*u*v,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z, a^-1*u*a*(x*y^-1*z^-1)^-1, a^-1*v*a*(w*x^-1*y^-1)^-1, a^-1*w*a*(u*w^-1*x*y^-1*z^-1)^-1 ,a^-1*x*a*(v*w*x*y^-1)^-1, a^-1*y*a*(u*v*w*z^-1)^-1, a^-1*z*a*(u*x*y^-1*z)^-1, b^-1*u*b*(v*w^-1*x^-1)^-1, b^-1*v*b*(u*v^-1*w^-1)^-1, b^-1*w*b*(u^-1*v*w^-1*x^-1*z^-1) ^-1,b^-1*x*b*(u*v*w^-1*y^-1*z) ^-1,b^-1*y*b*(u*x^-1*y)^-1, b^-1*z*b*(v*w^-1*x*z)^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,u], [a,b^-1*a*b,z]]]; end, [16,63]], "L3(2) 2^1 x 3^6",[9,6,1],2, 2,[16,63]], # 244944.2 [[1,"abuvwxyz", function(a,b,u,v,w,x,y,z) return [[a^4,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4*a^2,a^2*b *a^2*b^-1,u^3,v^3,w^3,x^3,y^3,z^3, u^-1*v^-1*u*v,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*u*a*w^-1, a^-1*v*a*v^-1,a^-1*w*a*u^-1, a^-1*x*a*z^-1,a^-1*y*a*y^-1, a^-1*z*a*x^-1,b^-1*u*b*v^-1, b^-1*v*b *(u^-1*v^-1*w^-1*x^-1*y^-1 *z^-1)^-1,b^-1*w*b*x^-1, b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,u], [b,a*b^-1*a*b*a,x*y^-1*z]]]; end, [16,21]], "L3(2) 2^1 x 3^6'",[9,6,2],2, 2,[16,21]] ]; PERFGRP[179]:=fail; PERFGRP[180]:=[# 246480.1 [[1,"abc", function(a,b,c) return [[c^39,c*b^9*c^-1*b^-1,b^79,a^2,c*a*c*a^-1, (b*a)^3],[[b,c]]]; end, [80],[0,3,3,4,0,2]], "L2(79)",22,-1, 40,80] ]; PERFGRP[181]:=[# 254016.1 [[2,504,1,504,1], "L2(8) x L2(8)",40,1, [4,4],[9,9]] ]; PERFGRP[182]:=[# 258048.1 [[1,"abcuvwxyzdef", function(a,b,c,u,v,w,x,y,z,d,e,f) return [[a^2,b^3,(a*b)^7,b^-1*(a*b)^3*c^-1,c*b^-1 *c*b*a^-1*b^-1*c^-1*b *c^-1*a,u^2,v^2,w^2,x^2,y^2,z^2,d^2,e^2, f^2,u^-1*v^-1*u*v,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,u^-1*d^-1*u*d, u^-1*e^-1*u*e,u^-1*f^-1*u*f, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, v^-1*d^-1*v*d,v^-1*e^-1*v*e, v^-1*f^-1*v*f,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, w^-1*d^-1*w*d,w^-1*e^-1*w*e, w^-1*f^-1*w*f,x^-1*y^-1*x*y, x^-1*z^-1*x*z,x^-1*d^-1*x*d, x^-1*e^-1*x*e,x^-1*f^-1*x*f, y^-1*z^-1*y*z,y^-1*d^-1*y*d, y^-1*e^-1*y*e,y^-1*f^-1*y*f, z^-1*d^-1*z*d,z^-1*e^-1*z*e, z^-1*f^-1*z*f,d^-1*e^-1*d*e, d^-1*f^-1*d*f,e^-1*f^-1*e*f, a^-1*u*a*(u*x)^-1,a^-1*v*a*(v*y)^-1, a^-1*w*a*(w*z)^-1,a^-1*x*a*x^-1, a^-1*y*a*y^-1,a^-1*z*a*z^-1, a^-1*d*a*d^-1,a^-1*e*a*e^-1, a^-1*f*a*f^-1,b^-1*u*b*(x*y*d)^-1, b^-1*v*b*(y*z*e)^-1, b^-1*w*b*(x*y*z*f)^-1, b^-1*x*b*(v*w*x)^-1, b^-1*y*b*(u*v*w*y)^-1, b^-1*z*b*(u*w*z)^-1,b^-1*d*b*d^-1, b^-1*e*b*e^-1,b^-1*f*b*f^-1, c^-1*u*c*(v*d*f)^-1, c^-1*v*c*(w*d)^-1, c^-1*w*c*(u*v*e)^-1, c^-1*x*c*(x*z*d)^-1, c^-1*y*c*(x*e)^-1,c^-1*z*c*(y*f)^-1, c^-1*d*c*d^-1,c^-1*e*c*e^-1, c^-1*f*c*f^-1], [[b^-1*c,u*d,e,f],[b^-1*c,u*e,d,f], [b^-1*c,u*f,d,e]]]; end, [112,112,112],[[1,2]]], "L2(8) 2^6 E ( 2^1 x 2^1 x 2^1 )",[16,9,1],8, 4,[112,112,112]], # 258048.2 [[1,"abcuvwxyzdf", function(a,b,c,u,v,w,x,y,z,d,f) return [[a^2*f,b^3,(a*b)^7,b^-1*(a*b)^3*c^-1,b^-1 *c^-1*b*c^-1*a^-1*c *b^-1*c*b*a*(y*z*d*f^2)^-1,d^2,f^4, u^2,v^2*f^2,w^2,x^2*f^2,y^2,z^2*f^2, u^-1*v^-1*u*v,u^-1*w^-1*u*w, u^-1*x^-1*u*x*f^2,u^-1*y^-1*u*y *f^2,u^-1*z^-1*u*z,u^-1*d^-1*u*d, u^-1*f^-1*u*f,v^-1*w^-1*v*w, v^-1*x^-1*v*x*f^2,v^-1*y^-1*v*y, v^-1*z^-1*v*z,v^-1*d^-1*v*d, v^-1*f^-1*v*f,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z*f^2, w^-1*d^-1*w*d,w^-1*f^-1*w*f, x^-1*y^-1*x*y,x^-1*z^-1*x*z, x^-1*d^-1*x*d,x^-1*f^-1*x*f, y^-1*z^-1*y*z,y^-1*d^-1*y*d, y^-1*f^-1*y*f,z^-1*d^-1*z*d, z^-1*f^-1*z*f,a^-1*u*a*(u*x)^-1, a^-1*v*a*(v*y*f^2)^-1, a^-1*w*a*(w*z)^-1, a^-1*x*a*(x*f^2)^-1,a^-1*y*a*y^-1, a^-1*z*a*(z*f^2)^-1,a^-1*d*a*d^-1, a^-1*f*a*f^-1, b^-1*u*b*(x*y*f^-1)^-1, b^-1*v*b*(y*z*f^2)^-1, b^-1*w*b*(x*y*z*d*f^2)^-1, b^-1*x*b*(v*w*x)^-1, b^-1*y*b*(u*v*w*y*d*f^2)^-1, b^-1*z*b*(u*w*z*f^-1)^-1, b^-1*d*b*d^-1,b^-1*f*b*f^-1, c^-1*u*c*(v*d*f^-1)^-1, c^-1*v*c*(w*d*f^-1)^-1, c^-1*w*c*(u*v*f)^-1, c^-1*x*c*(x*z*d*f)^-1, c^-1*y*c*(x*d*f)^-1, c^-1*z*c*(y*f^-1)^-1, c^-1*d*c*d^-1,c^-1*f*c*f^-1], [[c^-1*x^-1*a, c*b]]]; end, [576],[[1,2],[11,11]]], "L2(8) N ( 2^6 E ( 2^1 x 2^1 A ) ) C 2^1",[16,9,2],8, 4,[576]], # 258048.3 [[1,"abcuvwxyzdef", function(a,b,c,u,v,w,x,y,z,d,e,f) return [[a^2*(e*f^-1)^-1,b^3,(a*b)^7,b^-1*(a*b)^3 *c^-1, b^-1*c^-1*b*c^-1*a^-1*c*b^-1*c *b*a*(y*z*d)^-1,d^2,e^2,f^2,u^2,v^2,w^2, x^2,y^2,z^2,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, u^-1*d^-1*u*d,u^-1*e^-1*u*e, u^-1*f^-1*u*f,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,v^-1*d^-1*v*d, v^-1*e^-1*v*e,v^-1*f^-1*v*f, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,w^-1*d^-1*w*d, w^-1*e^-1*w*e,w^-1*f^-1*w*f, x^-1*y^-1*x*y,x^-1*z^-1*x*z, x^-1*d^-1*x*d,x^-1*e^-1*x*e, x^-1*f^-1*x*f,y^-1*z^-1*y*z, y^-1*d^-1*y*d,y^-1*e^-1*y*e, y^-1*f^-1*y*f,z^-1*d^-1*z*d, z^-1*e^-1*z*e,z^-1*f^-1*z*f, a^-1*u*a*(u*x)^-1,a^-1*v*a*(v*y)^-1, a^-1*w*a*(w*z)^-1,a^-1*x*a*x^-1, a^-1*y*a*y^-1,a^-1*z*a*z^-1, a^-1*d*a*d^-1,a^-1*e*a*e^-1, a^-1*f*a*f^-1, b^-1*u*b*(x*y*e*f^-1)^-1, b^-1*v*b*(y*z*e)^-1, b^-1*w*b*(x*y*z*d*e)^-1, b^-1*x*b*(v*w*x*e)^-1, b^-1*y*b*(u*v*w*y*d*e)^-1, b^-1*z*b*(u*w*z*f^-1)^-1, b^-1*d*b*d^-1,b^-1*e*b*e^-1, b^-1*f*b*f^-1, c^-1*u*c*(v*d*e*f^-1)^-1, c^-1*v*c*(w*d*f^-1)^-1, c^-1*w*c*(u*v*e*f)^-1, c^-1*x*c*(x*z*d*e*f)^-1, c^-1*y*c*(x*d*f)^-1, c^-1*z*c*(y*e*f^-1)^-1, c^-1*d*c*d^-1,c^-1*e*c*e^-1, c^-1*f*c*f^-1], [[b^-1*c,u*f,d,e],[b^-1*c*d,u*d,e,f], [b^-1*c*e,u,d,f]]]; end, [112,112,112],[[1,2]]], "L2(8) N 2^6 E ( 2^1 x 2^1 x 2^1 )",[16,9,3],8, 4,[112,112,112]], # 258048.4 [[1,"abcstuvwxyzd", function(a,b,c,s,t,u,v,w,x,y,z,d) return [[a^2,b^3,(a*b)^7,b^-1*(a*b)^3*c^-1,b^-1*c ^-1*b*c^-1*a^-1*c*b^-1 *c*b*a,d^2,s^2,t^2,u^2,v^2,w^2,x^2,y^2,z^2, d^-1*s^-1*d*s,d^-1*t^-1*d*t, d^-1*u^-1*d*u,d^-1*v^-1*d*v, d^-1*w^-1*d*w,d^-1*x^-1*d*x, d^-1*y^-1*d*y,d^-1*z^-1*d*z, s^-1*t^-1*s*t*d,s^-1*u^-1*s*u*d, s^-1*v^-1*s*v*d,s^-1*w^-1*s*w*d, s^-1*x^-1*s*x*d,s^-1*y^-1*s*y*d, s^-1*z^-1*s*z*d,t^-1*u^-1*t*u*d, t^-1*v^-1*t*v*d,t^-1*w^-1*t*w*d, t^-1*x^-1*t*x*d,t^-1*y^-1*t*y*d, t^-1*z^-1*t*z*d,u^-1*v^-1*u*v*d, u^-1*w^-1*u*w*d,u^-1*x^-1*u*x*d, u^-1*y^-1*u*y*d,u^-1*z^-1*u*z*d, v^-1*w^-1*v*w*d,v^-1*x^-1*v*x*d, v^-1*y^-1*v*y*d,v^-1*z^-1*v*z*d, w^-1*x^-1*w*x*d,w^-1*y^-1*w*y*d, w^-1*z^-1*w*z*d,x^-1*y^-1*x*y*d, x^-1*z^-1*x*z*d,y^-1*z^-1*y*z*d, a^-1*s*a*s^-1,a^-1*t*a*v^-1, a^-1*u*a*y^-1,a^-1*v*a*t^-1, a^-1*w*a*x^-1,a^-1*x*a*w^-1, a^-1*y*a*u^-1, a^-1*z*a*(s*t*u*v*w*x*y*z)^-1, a^-1*d*a*d^-1,b^-1*s*b*u^-1, b^-1*t*b*s^-1,b^-1*u*b*t^-1, b^-1*v*b*x^-1,b^-1*w*b*v^-1, b^-1*x*b*w^-1,b^-1*y*b*z^-1, b^-1*z*b*(s*t*u*v*w*x*y*z)^-1, b^-1*d*b*d^-1,c^-1*s*c*s^-1, c^-1*t*c*t^-1,c^-1*u*c*y^-1, c^-1*v*c*w^-1,c^-1*w*c*u^-1, c^-1*x*c*z^-1, c^-1*y*c*(s*t*u*v*w*x*y*z)^-1, c^-1*z*c*v^-1,c^-1*d*c*d^-1], [[a,b]]]; end, [512]], "L2(8) 2^8 C 2^1",[16,9,4],2, 4,512] ]; PERFGRP[183]:=[# 259200.1 [[2,120,1,2160,1], "( A5 x A6 3^1 ) 2^2",[33,2,1],12, [1,3],[24,18,80]], # 259200.2 [[2,360,1,720,1], "( A6 x A6 ) 2^1 [1]",40,2, [3,3],[6,80]], # 259200.3 [[3,720,1,720,1,"d1","d2"], "( A6 x A6 ) 2^1 [2]",40,2, [3,3],3200] ]; PERFGRP[184]:=[# 262080.1 [[1,"abc", function(a,b,c) return [[c^63,b^2,c^(-1*7)*b*c^2*b*c^2*b*c^3*b,c^(-1*6)*b*c *b*c^3*b*c*b*c*b,a^2,c*a*c*a^-1, (a*b)^3, c^3*a*(b*c*b*c^2)^2*b*c^-1*b*c^(-1*2)*b*a], [[b,c]]]; end, [65]], "L2(64)",22,-1, 41,65], # 262080.2 [[2,120,1,2184,1], "( A5 x L2(13) ) 2^2",40,4, [1,6],[24,56]] ]; PERFGRP[185]:=[# 262440.1 [[1,"abuvwxyzd", function(a,b,u,v,w,x,y,z,d) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,d^3,a^-1*d*a *d^-1,b^-1*d*b*d^-1, u^-1*d*u*d^-1,v^-1*d*v*d^-1, w^-1*d*w*d^-1,x^-1*d*x*d^-1, y^-1*d*y*d^-1,z^-1*d*z*d^-1,u^3, v^3,w^3,x^3,y^3,z^3,u^-1*v^-1*u*v*d^-1, u^-1*w^-1*u*w*d,u^-1*x^-1*u*x, u^-1*y^-1*u*y*d^-1, u^-1*z^-1*u*z*d,v^-1*w^-1*v*w, v^-1*x^-1*v*x*d^-1, v^-1*y^-1*v*y*d,v^-1*z^-1*v*z *d^-1,w^-1*x^-1*w*x, w^-1*y^-1*w*y*d,w^-1*z^-1*w*z *d^-1,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z*d, a^-1*u*a*(v*d^-1)^-1, a^-1*v*a*(u^-1*d)^-1, a^-1*w*a*(u^-1*x*d^-1)^-1, a^-1*x*a*(v*w^-1)^-1, a^-1*y*a*(u*w^-1*x^-1*y^-1*z^-1) ^-1, a^-1*z*a*(w^-1*y^-1*z*d^-1)^-1, b^-1*u*b*(u^-1*v^-1*w)^-1, b^-1*v*b*(u^-1*v*w)^-1, b^-1*w*b*u^-1,b^-1*x*b*(w*y)^-1, b^-1*y*b*(u^-1*w*x*y*z)^-1, b^-1*z*b*(w*y*z^-1)^-1],[[a,b]]]; end, [2187]], "A5 2^1 3^6' C 3^1",[2,7,1],3, 1,2187], # 262440.2 [[1,"abcuvwxyz", function(a,b,c,u,v,w,x,y,z) return [[a^2,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1*b^-1*c *b*c*b^-1*c*b*c^-1,u^3,v^3,w^3, x^3,y^3,z^3,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*u*a*(u^2*v*w^2*x^2*y)^-1, a^-1*v*a*(u*v*w^2*z)^-1, a^-1*w*a*(u^2*w*x*y^2*z^2)^-1, a^-1*x*a*(v^2*w*y^2)^-1, a^-1*y*a*(u*v^2*w^2*y^2*z)^-1, a^-1*z*a*(u^2*v^2*x^2*y*z)^-1, b^-1*u*b*(u*w^2*y)^-1, b^-1*v*b*(v*x^2*z)^-1, b^-1*w*b*(w*y)^-1,b^-1*x*b*(x*z)^-1, b^-1*y*b*y^-1,b^-1*z*b*z^-1, c^-1*u*c*u^-1,c^-1*v*c*v^-1, c^-1*w*c*(v*w)^-1, c^-1*x*c*(u*v^2*x)^-1, c^-1*y*c*(u*v^2*x^2*y)^-1, c^-1*z*c*(u^2*v^2*w^2*x*z)^-1], [[b,c*a*b*c,y,z,w,x]]]; end, [90]], "A6 3^6",[14,6,1],1, 3,90], # 262440.3 [[1,"abcuvwxyz", function(a,b,c,u,v,w,x,y,z) return [[a^2*(v^-1*w*x*y^-1)^-1,b^3*z^-1,c^3*v ,(b*c)^4*(v*x^-1*y^-1)^-1, (b*c^-1)^5*(v*x^-1*y)^-1, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,u^3, v^3,w^3,x^3,y^3,z^3,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*u*a*(u^-1*v*w^-1*x^-1*y)^-1 ,a^-1*v*a*(u*v*w^-1*z)^-1, a^-1*w*a*(u^-1*w*x*y^-1*z^-1)^-1 ,a^-1*x*a*(v^-1*w*y^-1)^-1, a^-1*y*a*(u*v^-1*w^-1*y^-1*z)^-1 ,a^-1*z*a*(u^-1*v^-1*x^-1*y*z) ^-1,b^-1*u*b*(u*w^-1*y)^-1, b^-1*v*b*(v*x^-1*z)^-1, b^-1*w*b*(w*y)^-1,b^-1*x*b*(x*z)^-1, b^-1*y*b*y^-1,b^-1*z*b*z^-1, c^-1*u*c*u^-1,c^-1*v*c*v^-1, c^-1*w*c*(v*w)^-1, c^-1*x*c*(u*v^-1*x)^-1, c^-1*y*c*(u*v^-1*x^-1*y)^-1, c^-1*z*c*(u^-1*v^-1*w^-1*x*z)^-1 ],[[b,c*a*b*c,y,z,w,x]]]; end, [90]], "A6 N 3^6",[14,6,2],1, 3,90], # 262440.4 [[1,"abcdwxyze", function(a,b,c,d,w,x,y,z,e) return [[a^2*d^-1,b^3,c^3*(w*x*y^-1)^-1,(b*c)^4, (b*c^-1)^5,a^-1*b^-1*c*b*c*b^-1*c*b *c^-1,e^3,a^-1*e*a*e^-1, b^-1*e*b*e^-1,c^-1*e*c*e^-1, d^-1*e*d*e^-1,w^-1*e*w*e^-1, x^-1*e*x*e^-1,y^-1*e*y*e^-1, z^-1*e*z*e^-1,d^3*e^-1,w^3,x^3,y^3, z^3,d^-1*w^-1*d*w,d^-1*x^-1*d*x, d^-1*y^-1*d*y,d^-1*z^-1*d*z, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*d*a*d^-1,a^-1*w*a*z^-1, a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*d*b*(d*w*y^-1*z*e)^-1, b^-1*w*b*(x*e)^-1, b^-1*x*b*(y*e^-1)^-1, b^-1*y*b*w^-1, b^-1*z*b*(z*e^-1)^-1, c^-1*d*c*(d*x^-1*z^-1*e)^-1, c^-1*w*c*(w^-1*x*y^-1*z^-1*e^-1) ^-1,c^-1*x*c*(x^-1*z*e^-1)^-1, c^-1*y*c*(w*x^-1*e)^-1, c^-1*z*c*(x^-1*e)^-1], [[a*b,b*a*b*a*b^-1*a*b^-1,w*e]]]; end, [324]], "A6 ( 3^1 E 3^4' E 3^1 ) A",[14,6,3],3, 3,324], # 262440.5 [[1,"abcwxyzef", function(a,b,c,w,x,y,z,e,f) return [[a^2,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1*b^-1*c *b*c*b^-1*c*b*c^-1,w^3,x^3,y^3, z^3,e^3,f^3,w^-1*e^-1*w*e, x^-1*e^-1*x*e,y^-1*e^-1*y*e, z^-1*e^-1*z*e,w^-1*f^-1*w*f, x^-1*f^-1*x*f,y^-1*f^-1*y*f, z^-1*f^-1*z*f,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*w*a*z^-1, a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, a^-1*e*a*e^-1,a^-1*f*a*f^-1, b^-1*w*b*x^-1, b^-1*x*b*(y*e^-1)^-1, b^-1*y*b*(w*e)^-1,b^-1*z*b*(z*e)^-1, b^-1*e*b*e^-1,b^-1*f*b*f^-1, c^-1*w*c*(w^-1*x*y^-1*z^-1*f)^-1 ,c^-1*x*c*(x^-1*z*f)^-1, c^-1*y*c*(w*x^-1*f)^-1, c^-1*z*c*(x^-1*f^-1)^-1, c^-1*e*c*e^-1,c^-1*f*c*f^-1], [[a,b,w],[a,c,w]]]; end, [18,18]], "A6 3^4' E ( 3^1 x 3^1 )",[14,6,4],9, 3,[18,18]], # 262440.6 [[1,"abcwxyzdf", function(a,b,c,w,x,y,z,d,f) return [[a^2*d^-1,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1 *b^-1*c*b*c*b^-1*c*b*c^-1, b^-1*d^-1*b*d,c^-1*d^-1*c*d,w^3, x^3,y^3,z^3,d^3,f^3,w^-1*d^-1*w*d, x^-1*d^-1*x*d,y^-1*d^-1*y*d, z^-1*d^-1*z*d,d^-1*f^-1*d*f, w^-1*f^-1*w*f,x^-1*f^-1*x*f, y^-1*f^-1*y*f,z^-1*f^-1*z*f, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, a^-1*f*a*f^-1,b^-1*w*b*x^-1, b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1,b^-1*f*b*f^-1, c^-1*w*c*(w^-1*x*y^-1*z^-1*f)^-1 ,c^-1*x*c*(x^-1*z*f)^-1, c^-1*y*c*(w*x^-1*f)^-1, c^-1*z*c*(x^-1*f^-1)^-1, c^-1*f*c*f^-1],[[a,b,w],[a*d,c*d,w]]]; end, [18,18]], "A6 3^1 x ( 3^4' E 3^1 ) I",[14,6,5],9, 3,[18,18]], # 262440.7 [[1,"abcwxyzde", function(a,b,c,w,x,y,z,d,e) return [[a^2*d^-1,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1 *b^-1*c*b*c*b^-1*c*b*c^-1, b^-1*d^-1*b*d,c^-1*d^-1*c*d,d^3, w^3,x^3,y^3,z^3,e^3,w^-1*d^-1*w*d, x^-1*d^-1*x*d,y^-1*d^-1*y*d, z^-1*d^-1*z*d,e^-1*d^-1*e*d, w^-1*e^-1*w*e,x^-1*e^-1*x*e, y^-1*e^-1*y*e,z^-1*e^-1*z*e, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, a^-1*e*a*e^-1,b^-1*w*b*x^-1, b^-1*x*b*(y*e^-1)^-1, b^-1*y*b*(w*e)^-1,b^-1*z*b*(z*e)^-1, b^-1*e*b*e^-1, c^-1*w*c*(w^-1*x*y^-1*z^-1*e^-1) ^-1,c^-1*x*c*(x^-1*z*e^-1)^-1, c^-1*y*c*(w*x^-1*e^-1)^-1, c^-1*z*c*(x^-1*e)^-1, c^-1*e*c*e^-1], [[a*b,b*a*b*a*b^-1*a*b^-1,w*e,d], [a*d,c*d,w]]]; end, [108,18]], "A6 3^1 x ( 3^4' E 3^1 ) II",[14,6,6],9, 3,[108,18]] ]; PERFGRP[186]:=[# 263424.1 [[4,5376,1,16464,2,336,1,1], "L3(2) # 2^5 7^2",12,2, 2,[16,16,49]] ]; PERFGRP[187]:=[# 265680.1 [[1,"abc", function(a,b,c) return [[c^40,b^3,c^(-1*12)*b*c*b*c^11*b^-1,c^20*b*c^20 *b^(-1*2),a^2,c*a*c*a^-1,(b*a)^3, c^2*b^2*c^2*b*c*a*b*a*c^3*b*c*a*b^(-1*2) *c^(-1*2)*b^-1*a],[[b,c]]]; end, [82],[0,0,3,2]], "L2(81)",22,-1, 42,82] ]; PERFGRP[188]:=[# 276480.1 [[4,92160,1,1080,2,360,1,1], "A6 3^1 x 2^4 x 2^4",[13,8,1],3, 3,[16,16,18]], # 276480.2 [[4,92160,2,1080,2,360,2,1], "A6 3^1 x 2^4 x 2^4'",[13,8,2],3, 3,[16,16,18]] ]; PERFGRP[189]:=[# 285852.1 [[1,"abc", function(a,b,c) return [[c^41,c*b^4*c^-1*b^-1,b^83,a^2,c*a*c*a^-1, (b*a)^3],[[b,c]]]; end, [84]], "L2(83)",22,-1, 43,84] ]; PERFGRP[190]:=[# 288120.1 [[1,"abwxyz", function(a,b,w,x,y,z) return [[a^4,b^3,(a*b)^5,a^2*b*a^2*b^-1,w^7,x^7,y^7,z^7, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*w*x*y*z,a^-1*z*a*w^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1], [[a*b,w],[b,a*b*a*b^-1*a,w*x^-1]]]; end, [24,35]], "A5 2^1 x 7^4",[4,4,1],2, 1,[24,35]], # 288120.2 [[1,"abwxyz", function(a,b,w,x,y,z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,w^7,x^7,y^7,z^7, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*(w^(-1*3)*x)^-1, a^-1*x*a*(w^(-1*3)*x^3)^-1, a^-1*y*a*(w^(-1*2)*x*y^(-1*2)*z^3)^-1, a^-1*z*a*(x^(-1*2)*y^3*z^2)^-1, b^-1*w*b*(w^(-1*3)*y^2)^-1, b^-1*x*b*(w^(-1*3)*x^-1*y^(-1*3))^-1, b^-1*y*b*(w^2*x*y^(-1*3))^-1, b^-1*z*b*(w^2*x*y^3*z)^-1], [[b,a*b*a*b^-1*a,y*z^-1]]]; end, [245]], "A5 2^1 7^4'",[4,4,2],1, 1,245], # 288120.3 [[1,"abwxyz", function(a,b,w,x,y,z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,w^7,x^7,y^7,z^7, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*y,a^-1*x*a*z, a^-1*y*a*w^-1,a^-1*z*a*x^-1, b^-1*w*b*w^(-1*2),b^-1*x*b*x^(-1*2), b^-1*y*b*(w^3*x^(-1*2)*y^(-1*3))^-1, b^-1*z*b*(w^-1*x^(-1*2)*z^(-1*3))^-1], [[b,a*b*a*b^-1*a,w]]]; end, [245]], "A5 2^1 7^4''",[4,4,3],1, 1,245] ]; PERFGRP[191]:=[# 291600.1 [[2,60,1,4860,1], "( A5 x A5 ) # 3^4 [1]",[30,4,1],1, [1,1],[5,15]], # 291600.2 [[2,60,1,4860,2], "( A5 x A5 ) # 3^4 [2]",[30,4,2],1, [1,1],[5,60]] ]; PERFGRP[192]:=[# 293760.1 [[2,60,1,4896,1], "( A5 x L2(17) ) 2^1 [1]",40,2, [1,7],[5,288]], # 293760.2 [[2,120,1,2448,1], "( A5 x L2(17) ) 2^1 [2]",40,2, [1,7],[24,18]], # 293760.3 [[3,120,1,4896,1,"d1","d2"], "( A5 x L2(17) ) 2^1 [3]",40,2, [1,7],3456] ]; PERFGRP[193]:=[# 300696.1 [[1,"abc", function(a,b,c) return [[c^33*a^2,c*b^4*c^-1*b^-1,b^67,a^4,a^2*b^(-1 *1)*a^2*b,a^2*c^-1*a^2*c, c*a*c*a^-1,(b*a)^3],[[b,c^2]]]; end, [136]], "L2(67) 2^1 = SL(2,67)",22,-2, 35,136] ]; PERFGRP[194]:=[# 302400.1 [[2,60,1,5040,1], "( A5 x A7 ) 2^1 [1]",40,2, [1,8],[5,240]], # 302400.2 [[2,120,1,2520,1], "( A5 x A7 ) 2^1 [2]",40,2, [1,8],[24,7]], # 302400.3 [[3,120,1,5040,1,"d1","d2"], "( A5 x A7 ) 2^1 [3]",40,2, [1,8],2880] ]; PERFGRP[195]:=[# 311040.1 [[1,"abdwxyzstuv", function(a,b,d,w,x,y,z,s,t,u,v) return [[a^4,b^3,(a*b)^5,a^2*b*a^2*b^-1,d^2,a^-1*d ^-1*a*d,b^-1*d^-1*b*d, d^-1*w^-1*d*w,d^-1*x^-1*d*x, d^-1*y^-1*d*y,d^-1*z^-1*d*z,w^2, x^2,y^2,z^2,(w*x)^2*d,(w*y)^2*d,(w*z)^2*d, (x*y)^2*d,(x*z)^2*d,(y*z)^2*d,a^-1*w*a*z^-1 ,a^-1*x*a*x^-1, a^-1*y*a*(w*x*y*z)^-1,a^-1*z*a*w^-1 ,b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1,s^3, t^3,u^3,v^3,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^-1*s*a*(s*t*u*v)^-1 ,a^-1*t*a*(s^-1*t*u*v^-1)^-1, a^-1*u*a*(s^-1*u^-1*v)^-1, a^-1*v*a*(t*u^-1*v^-1)^-1, b^-1*s*b*(s^-1*t^-1*u*v^-1)^-1, b^-1*t*b*(s^-1*v^-1)^-1, b^-1*u*b*(s*t^-1*u^-1*v^-1)^-1, b^-1*v*b*(t^-1*u^-1)^-1, d^-1*s*d*s,d^-1*t*d*t,d^-1*u*d*u, d^-1*v*d*v,w^-1*s*w*s^-1, w^-1*t*w*(s^-1*t*v)^-1, w^-1*u*w*(s*t*u^-1*v^-1)^-1, w^-1*v*w*(s^-1*v^-1)^-1, x^-1*s*x*(s*t*u*v^-1)^-1, x^-1*t*x*t^-1, x^-1*u*x*(s^-1*v^-1)^-1, x^-1*v*x*(s^-1*t^-1*u*v)^-1, y^-1*s*y*(s*v^-1)^-1, y^-1*t*y*(t*u*v^-1)^-1,y^-1*u*y*u, y^-1*v*y*v, z^-1*s*z*(s*t^-1*u^-1*v^-1)^-1, z^-1*t*z*(s*u*v)^-1, z^-1*u*z*(t*u^-1*v)^-1, z^-1*v*z*(s^-1*t*u^-1)^-1], [[a*b,w,s],[a,b,w]]]; end, [24,81]], "A5 2^1 x ( 2^4' C 2^1 ) 3^4",[7,4,1],2, 1,[24,81]], # 311040.2 [[4,3840,1,4860,1,60], "A5 # 2^6 3^4 [1]",6,4, 1,[64,15]], # 311040.3 [[4,3840,2,4860,1,60], "A5 # 2^6 3^4 [2]",6,4, 1,[64,15]], # 311040.4 [[4,3840,3,4860,1,60], "A5 # 2^6 3^4 [3]",6,4, 1,[24,15]], # 311040.5 [[4,3840,4,4860,1,60], "A5 # 2^6 3^4 [4]",6,4, 1,[48,15]], # 311040.6 [[4,3840,5,4860,1,60], "A5 # 2^6 3^4 [5]",6,4, 1,[24,12,15]], # 311040.7 [[4,3840,6,4860,1,60], "A5 # 2^6 3^4 [6]",6,2, 1,[48,15]], # 311040.8 [[4,3840,7,4860,1,60], "A5 # 2^6 3^4 [7]",6,4, 1,[32,24,15]], # 311040.9 [[4,3840,1,4860,2,60], "A5 # 2^6 3^4 [8]",6,4, 1,[64,60]], # 311040.10 [[4,3840,2,4860,2,60], "A5 # 2^6 3^4 [9]",6,4, 1,[64,60]], # 311040.11 [[4,3840,3,4860,2,60], "A5 # 2^6 3^4 [10]",6,4, 1,[24,60]], # 311040.12 [[4,3840,4,4860,2,60], "A5 # 2^6 3^4 [11]",6,4, 1,[48,60]], # 311040.13 [[4,3840,5,4860,2,60], "A5 # 2^6 3^4 [12]",6,4, 1,[24,12,60]], # 311040.14 [[4,3840,6,4860,2,60], "A5 # 2^6 3^4 [13]",6,2, 1,[48,60]], # 311040.15 [[4,3840,7,4860,2,60], "A5 # 2^6 3^4 [14]",6,4, 1,[32,24,60]], # 311040.16 [[4,3840,5,9720,4,120,5,3], "A5 # 2^6 3^4 [15]",6,2, 1,[24,12,45]], # 311040.17 [[4,3840,6,9720,4,120,6,3], "A5 # 2^6 3^4 [16]",6,2, 1,[48,45]], # 311040.18 [[4,3840,7,9720,4,120,7,3], "A5 # 2^6 3^4 [17]",6,2, 1,[32,24,45]] ]; PERFGRP[196]:=[# 320760.1 [[1,"abvwxyz", function(a,b,v,w,x,y,z) return [[a^4,b^3,(a*b)^11,(a*b)^4*(a*b^-1)^5*(a*b)^4*(a *b^-1)^5*a^2,a^2*b*a^2*b^-1,v^3,w^3, x^3,y^3,z^3,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*v*a*v^-1, a^-1*w*a*w^-1, a^-1*x*a*(v^2*x^2*y)^-1, a^-1*y*a*y^-1,a^-1*z*a*(w*y*z^2)^-1 ,b^-1*v*b*w^-1,b^-1*w*b*x^-1, b^-1*x*b*v^-1,b^-1*y*b*(y^2*z)^-1, b^-1*z*b*y^(-1*2)], [[a*b,(b*a)^2*(b^-1*a)^4*b^-1*a^2,v], [b,a*b*a*b^-1*a,y*z]]]; end, [24,33]], "L2(11) 2^1 3^5",[18,5,1],2, 5,[24,33]] ]; PERFGRP[197]:=[# 322560.1 [[1,"abduvwxyz", function(a,b,d,u,v,w,x,y,z) return [[a^2*d^-1,b^4*d^-1,(a*b)^7,(a*b)^2*a*b^2*( a*b*a*b^-1)^2*(a*b)^2 *(a*b^-1)^2*a*b*a*b^-1,d^2, a^-1*d*a*d^-1,b^-1*d*b*d^-1, u^-1*d*u*d^-1,v^-1*d*v*d^-1, w^-1*d*w*d^-1,x^-1*d*x*d^-1, y^-1*d*y*d^-1,z^-1*d*z*d^-1,u^2, v^2,w^2,x^2,y^2,z^2,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*u*a*u^-1,a^-1*v*a*v^-1, a^-1*w*a*y^-1,a^-1*x*a*x^-1, a^-1*y*a*w^-1, a^-1*z*a*(u*v*w*x*y*z)^-1, b^-1*u*b*w^-1,b^-1*v*b*z^-1, b^-1*w*b*v^-1,b^-1*x*b*y^-1, b^-1*y*b*x^-1,b^-1*z*b*u^-1], [[b^2*a*b^-1*(a*b*a*b*b)^2*(a*b)^2, b*(a*b^-1)^2*a*b^2*(a*b)^2,y*z], [a*b,b*a*b*a*b^2*a*b^-1*a*b*a*b^-1*a*b *a*b^2*d,u]]]; end, [14,240],[[1,-2]]], "A7 2^1 x 2^6",[23,7,1],2, 8,[14,240]], # 322560.2 [[1,"abuvwxyze", function(a,b,u,v,w,x,y,z,e) return [[a^2,b^4,(a*b)^7,(a*b)^2*a*b^2*(a*b*a*b^-1)^2 *(a*b)^2*(a*b^-1)^2*a*b*a*b^-1,e^2, u^-1*e*u*e^-1,v^-1*e*v*e^-1, w^-1*e*w*e^-1,x^-1*e*x*e^-1, y^-1*e*y*e^-1,z^-1*e*z*e^-1, u^2*e^-1,v^2*e^-1,w^2*e^-1, x^2*e^-1,y^2*e^-1,z^2*e^-1, u^-1*v^-1*u*v*e^-1, u^-1*w^-1*u*w*e^-1, u^-1*x^-1*u*x*e^-1, u^-1*y^-1*u*y*e^-1, u^-1*z^-1*u*z*e^-1, v^-1*w^-1*v*w*e^-1, v^-1*x^-1*v*x*e^-1, v^-1*y^-1*v*y*e^-1, v^-1*z^-1*v*z*e^-1, w^-1*x^-1*w*x*e^-1, w^-1*y^-1*w*y*e^-1, w^-1*z^-1*w*z*e^-1, x^-1*y^-1*x*y*e^-1, x^-1*z^-1*x*z*e^-1, y^-1*z^-1*y*z*e^-1, a^-1*u*a*u^-1,a^-1*v*a*v^-1, a^-1*w*a*(y*e)^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*e)^-1, a^-1*z*a*(u*v*w*x*y*z*e)^-1, a^-1*e*a*e^-1,b^-1*u*b*w^-1, b^-1*v*b*z^-1,b^-1*w*b*v^-1, b^-1*x*b*(y*e)^-1,b^-1*y*b*(x*e)^-1, b^-1*z*b*u^-1,b^-1*e*b*e^-1], [[a,b]]]; end, [128]], "A7 2^6 C 2^1",[23,7,2],2, 8,128], # 322560.3 [[1,"abduvwxyz", function(a,b,d,u,v,w,x,y,z) return [[a^2*d^-1,b^4*d^-1,(a*b)^7,(a*b)^2*a*b^2*( a*b*a*b^-1)^2*(a*b)^2 *(a*b^-1)^2*a*b*a*b^-1,d^2, a^-1*d*a*d^-1,b^-1*d*b*d^-1, u^-1*d*u*d^-1,v^-1*d*v*d^-1, w^-1*d*w*d^-1,x^-1*d*x*d^-1, y^-1*d*y*d^-1,z^-1*d*z*d^-1, u^2*d^-1,v^2*d^-1,w^2*d^-1, x^2*d^-1,y^2*d^-1,z^2*d^-1, u^-1*v^-1*u*v*d^-1, u^-1*w^-1*u*w*d^-1, u^-1*x^-1*u*x*d^-1, u^-1*y^-1*u*y*d^-1, u^-1*z^-1*u*z*d^-1, v^-1*w^-1*v*w*d^-1, v^-1*x^-1*v*x*d^-1, v^-1*y^-1*v*y*d^-1, v^-1*z^-1*v*z*d^-1, w^-1*x^-1*w*x*d^-1, w^-1*y^-1*w*y*d^-1, w^-1*z^-1*w*z*d^-1, x^-1*y^-1*x*y*d^-1, x^-1*z^-1*x*z*d^-1, y^-1*z^-1*y*z*d^-1, a^-1*u*a*u^-1,a^-1*v*a*v^-1, a^-1*w*a*(y*d)^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*d)^-1, a^-1*z*a*(u*v*w*x*y*z*d)^-1, b^-1*u*b*w^-1,b^-1*v*b*z^-1, b^-1*w*b*v^-1,b^-1*x*b*(y*d)^-1, b^-1*y*b*(x*d)^-1,b^-1*z*b*u^-1], [[a*b, b*a*b*a*b^2*a*b^-1*a*b*a*b^-1*a*b*a *b^2*d,x*y*z*d]]]; end, [1920]], "A7 2^6 C N 2^1",[23,7,3],2, 8,1920], # 322560.4 [[1,"abwxyz", function(a,b,w,x,y,z) return [[a^2,b^4,(a*b)^15,(a*b^2)^6,(a*b)^2*(a*b^-1*a*b^2) ^2*a*b^-1*(a*b)^2*(a*b^-1)^7, a*b*a*b^-1*a*b*a*b^2*(a*b^-1)^5*a*b^2 *(a*b^-1)^5*a*b^2,w^2,x^2,y^2,z^2, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*y^-1,a^-1*x*a*z^-1, a^-1*y*a*w^-1,a^-1*z*a*x^-1, b^-1*w*b*(w*x)^-1,b^-1*x*b*(w*z)^-1, b^-1*y*b*(w*x*y*z)^-1, b^-1*z*b*w^-1],[[a,b]]]; end, [16]], "A8 2^4",[26,4,1],1, 19,16], # 322560.5 [[1,"abwxyz", function(a,b,w,x,y,z) return [[a^2*(x*z)^-1,b^4*(w*x*z)^-1,(a*b)^15,(a*b^2)^6 ,(a*b)^2*(a*b^-1*a*b^2)^2*a*b^-1*(a*b)^2 *(a*b^-1)^7*(y*z)^-1, a*b*a*b^-1*a*b*a*b^2*(a*b^-1)^5*a*b^2 *(a*b^-1)^5*a*b^2*y^-1,w^2,x^2,y^2, z^2,w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*y^-1,a^-1*x*a*z^-1, a^-1*y*a*w^-1,a^-1*z*a*x^-1, b^-1*w*b*(w*x)^-1,b^-1*x*b*(w*z)^-1, b^-1*y*b*(w*x*y*z)^-1, b^-1*z*b*w^-1], [[b*z,(a*b)^2*(a*b^-1)^2*a*z,y*z]]]; end, [30],[[1,2],[7,7]]], "A8 N 2^4",[26,4,2],1, 19,30], # 322560.6 [[1,"abef", function(a,b,e,f) return [[a^2,b^4*(e^2*f^2)^-1,(a*b)^7*e,(a*b^2)^5*(e*f) ^-1,(a^-1*b^-1*a*b)^5*(e^2*f^2)^-1 ,(a*b*a*b*a*b^3)^5*(e^2*f^-1)^-1, (a*b*a*b*a*b^2*a*b^-1)^5,e^4,f^4, e^-1*f^-1*e*f,a^-1*e*a*e^-1, a^-1*f*a*f^-1,b^-1*e*b*e^-1, b^-1*f*b*f^-1], [[a,b*a*b*a*b^-1*a*b^2*f^-1], [a*e^2,b^-1*a*b^-1*a*b*a*b^2]]]; end, [224,224],[[1,2]]], "L3(4) ( 2^1 A 2^1 ) x ( 2^1 A 2^1 )",[27,4,1],-16, 20,[224,224]], # 322560.7 [[2,60,1,5376,1], "( A5 x L3(2) ) # 2^5 [1]",[31,5,1],4, [1,2],[5,16,16]], # 322560.8 [[2,120,1,2688,1], "( A5 x L3(2) ) # 2^5 [2]",[31,5,2],4, [1,2],[24,8,16]], # 322560.9 [[2,120,1,2688,2], "( A5 x L3(2) ) # 2^5 [3]",[31,5,3],4, [1,2],[24,16]], # 322560.10 [[2,120,1,2688,3], "( A5 x L3(2) ) # 2^5 [4]",[31,5,4],4, [1,2],[24,16,14]], # 322560.11 [[3,120,1,5376,1,"d1","d2"], "( A5 x L3(2) ) # 2^5 [5]",[31,5,5],4, [1,2],[192,192]], # 322560.12 [[3,120,1,5376,1,"d1","e2"], "( A5 x L3(2) ) # 2^5 [6]",[31,5,6],4, [1,2],[192,192]], # 322560.13 [[2,1920,1,168,1], "( A5 x L3(2) ) # 2^5 [7]",[31,5,7],2, [1,2],[12,7]], # 322560.14 [[2,1920,2,168,1], "( A5 x L3(2) ) # 2^5 [8]",[31,5,8],2, [1,2],[24,7]], # 322560.15 [[2,1920,3,168,1], "( A5 x L3(2) ) # 2^5 [9]",[31,5,9],2, [1,2],[16,24,7]], # 322560.16 [[2,1920,4,168,1], "( A5 x L3(2) ) # 2^5 [10]",[31,5,10],1, [1,2],[80,7]], # 322560.17 [[2,1920,5,168,1], "( A5 x L3(2) ) # 2^5 [11]",[31,5,11],2, [1,2],[10,24,7]], # 322560.18 [[2,1920,6,168,1], "( A5 x L3(2) ) # 2^5 [12]",[31,5,12],2, [1,2],[80,7]], # 322560.19 [[2,1920,7,168,1], "( A5 x L3(2) ) # 2^5 [13]",[31,5,13],2, [1,2],[32,7]], # 322560.20 [[2,960,1,336,1], "( A5 x L3(2) ) # 2^5 [14]",[31,5,14],2, [1,2],[16,16]], # 322560.21 [[2,960,2,336,1], "( A5 x L3(2) ) # 2^5 [15]",[31,5,16],2, [1,2],[10,16]], # 322560.22 [[3,1920,1,336,1,"e1","d2"], "( A5 x L3(2) ) # 2^5 [16]",[31,5,16],2, [1,2],96], # 322560.23 [[3,1920,2,336,1,"d1","d2"], "( A5 x L3(2) ) # 2^5 [17]",[31,5,17],2, [1,2],192], # 322560.24 [[3,1920,3,336,1,"d1","d2"], "( A5 x L3(2) ) # 2^5 [18]",[31,5,18],2, [1,2],[128,192]], # 322560.25 [[3,1920,5,336,1,"d1","d2"], "( A5 x L3(2) ) # 2^5 [19]",[31,5,19],2, [1,2],[80,192]], # 322560.26 [[3,1920,6,336,1,"d1","d2"], "( A5 x L3(2) ) # 2^5 [20]",[31,5,20],2, [1,2],640], # 322560.27 [[3,1920,7,336,1,"e1","d2"], "( A5 x L3(2) ) # 2^5 [21]",[31,5,21],2, [1,2],256] ]; PERFGRP[198]:=[# 332640.1 [[2,504,1,660,1], "L2(8) x L2(11)",40,1, [4,5],[9,11]] ]; PERFGRP[199]:=[# 336960.1 [[2,60,1,5616,1], "A5 x L3(3)",40,1, [1,11],[5,13]] ]; PERFGRP[200]:=fail; PERFGRP[201]:=[# 345600.1 [[2,60,1,5760,1], "( A5 x A6 ) # 2^4 [1]",[33,4,1],1, [1,3],[5,16]], # 345600.2 [[2,960,1,360,1], "( A5 x A6 ) # 2^4 [2]",[33,4,2],1, [1,3],[16,6]], # 345600.3 [[2,960,2,360,1], "( A5 x A6 ) # 2^4 [3]",[33,4,3],1, [1,3],[10,6]] ]; ############################################################################# ## #E perf9.grp . . . . . . . . . . . . . . . . . . . . . . . . . ends here ## gap-4r6p5/grp/imf18.grp0000644000175000017500000012461412172557252013377 0ustar billbill############################################################################# ## #A imf18.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Q-class representative of the irreducible ## maximal finite integral matrix groups of dimension 18, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Q-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 18. ## IMFList[18].matrices := [ [ # Q-class [18][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[[0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [18][02] [[3], [1,3], [0,1,3], [1,1,0,3], [1,1,0,1,3], [0,1,1,1,1,3], [1,0,1,1,1,1,3], [1,0,1,0,0,0,1,3], [1,1,1,0,0,1,0,1,3], [1,1,1,1,0,0,0,0,1,3], [1,0,1,0,1,0,1,0,0,1,3], [1,1,0,1,0,1,0,1,1,0,-1,3], [1,0,0,1,0,1,1,0,0,1,0,1,3], [1,1,0,0,1,0,1,1,0,0,0,1,1,3], [0,0,0,1,1,1,0,1,1,0,0,1,0,0,3], [1,0,1,1,0,0,1,1,0,0,0,1,0,0,0,3], [1,1,1,0,0,0,0,0,0,1,1,0,1,1,-1,0,3], [1,1,0,0,0,-1,0,1,0,1,0,0,0,1,0,0,0,3]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,1,-1,0,0,0,0,-1,0,1,0,1,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [-1,1,-1,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0], [0,-1,0,0,0,1,0,0,0,1,0,0,-1,1,0,0,0,0], [0,-1,0,0,0,1,0,0,0,0,0,0,-1,0,0,0,1,1], [1,0,0,-1,0,1,0,0,-1,1,-1,0,-1,0,0,0,0,0], [-1,1,-1,-1,0,0,1,0,0,1,0,0,0,0,0,1,0,0], [-1,1,-1,0,0,0,0,1,0,0,0,-1,1,0,0,1,0,0], [-1,1,-1,0,0,0,-1,1,0,0,1,-1,1,0,0,1,0,0], [-1,-1,0,0,1,0,0,0,1,0,0,1,0,0,-1,0,0,1], [0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,-1,-1,1,0,1,0,0,0,0,1,0,-1,0,0,1,1], [0,1,0,-1,0,0,0,1,-1,1,0,0,0,0,0,0,-1,-1], [0,-1,1,1,1,0,-1,0,1,-1,0,0,0,0,-1,0,0,1], [0,1,-1,-1,0,0,0,0,0,0,0,-1,1,0,1,1,0,0], [1,0,1,0,0,0,0,0,-1,0,-1,0,0,0,0,-1,0,0]], [[-2,0,-1,0,1,0,-1,1,1,0,1,0,1,0,-1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [-1,0,0,0,1,-1,1,0,0,0,0,1,0,-1,0,0,1,0], [0,-1,0,1,0,1,-1,0,0,0,0,0,-1,1,-1,0,0,0], [1,-2,1,1,0,1,-1,0,0,0,0,0,-1,1,-1,-1,0,0], [0,-1,1,1,0,0,0,0,0,0,0,1,-1,0,-1,-1,0,0], [-1,-2,0,1,1,0,0,0,1,0,0,1,-1,0,-1,0,1,1], [-1,-1,0,0,1,0,0,0,0,0,0,1,0,-1,0,0,1,1], [-1,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0], [1,0,1,0,0,0,-1,0,-1,0,0,0,0,1,0,0,-1,-1], [-1,0,0,1,1,-1,-1,1,1,-1,1,0,1,0,-1,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,1,0,0,-1,0,0,0,0,0,0,1,-1,0,-1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,1,1,-1,1,-1,0,-1,0,0,0,-1,1,0,-1,0,0], [-2,1,-2,-1,1,0,1,1,0,1,0,0,0,-1,0,1,1,0], [-2,1,-1,0,1,-1,0,1,1,-1,1,0,2,-1,-1,1,0,0], [1,0,0,-1,0,0,0,0,-1,1,-1,0,0,0,1,0,0,-1]]]], [ # Q-class [18][03] [[2], [-1,2], [0,-1,2], [0,0,-1,2], [0,0,0,-1,2], [0,0,-1,0,0,2], [0,0,0,0,0,0,2], [0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,-1,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,2,2,1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-2,-2,-1,-1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0]], [[-1,-2,-3,-2,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [18][04] [[4], [2,4], [-2,-2,4], [-2,0,1,4], [-2,-2,2,2,4], [0,-1,1,1,2,4], [0,-1,-1,0,1,0,4], [0,-1,1,1,1,0,1,4], [-2,-2,1,1,1,0,1,0,4], [1,-1,-1,-1,-1,0,0,1,1,4], [-2,0,0,0,0,0,0,-2,0,-2,4], [-2,0,2,2,2,0,0,0,0,-2,1,4], [-2,0,2,2,2,0,-1,1,1,-1,0,2,4], [-2,-1,2,0,0,-1,-2,-1,1,0,1,1,1,4], [2,2,-2,-1,-2,-2,0,1,-2,1,-1,-1,-1,-1,4], [-2,0,0,1,0,-2,0,-1,2,0,1,1,1,2,0,4], [2,1,0,-2,-2,-1,0,1,-1,1,-1,-1,-1,0,2,-1,4], [2,2,-2,-2,-2,0,-1,-1,-1,1,0,-2,-1,-1,1,-1,1,4]], [[[-2,-1,-2,-1,-1,2,-1,0,1,-2,-2,1,0,0,1,0,1,0], [0,0,1,0,0,0,0,-1,1,0,0,0,0,0,1,-1,0,0], [1,2,1,0,1,-1,0,1,0,1,1,0,-1,0,-1,0,-1,0], [2,-1,0,1,0,0,1,0,0,0,1,0,1,1,0,0,0,1], [1,-1,0,1,-1,0,1,0,-1,0,0,0,1,0,-1,1,0,1], [0,-2,-2,0,-2,2,0,1,0,-2,-1,1,1,1,0,1,0,1], [0,-2,-2,0,-1,1,0,0,-1,-1,-1,0,1,0,-1,1,1,0], [1,-3,-3,0,-2,2,0,1,0,-2,-1,2,1,1,0,1,1,1], [0,3,1,-1,2,-1,0,1,0,2,1,-1,-1,0,-1,0,-1,-1], [-1,-1,-2,-1,0,1,-1,1,0,-1,-1,1,0,0,0,1,1,0], [1,0,2,1,0,-1,1,-1,-1,1,1,-1,0,0,0,0,-1,0], [2,0,2,2,1,-2,1,-1,-1,1,1,-1,0,0,-1,0,0,1], [2,0,2,1,0,-1,1,0,0,1,1,0,0,0,0,0,-1,1], [0,4,3,0,3,-3,0,0,0,3,2,-1,-2,-1,-1,-1,-1,-1], [0,-2,-1,0,-1,1,0,-1,0,-1,-1,1,1,0,1,0,1,0], [0,4,4,0,3,-3,1,-1,-1,4,2,-2,-1,-1,-1,-1,-1,-1], [-1,1,-1,-2,0,1,-1,1,1,-1,-1,1,-1,0,0,0,0,-1], [-1,-1,-1,-1,-1,1,-1,0,1,-1,-1,1,0,0,1,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,1,1,-1,0,1,-1,-1,0,-1,0,0,0,0,0,0,1], [-2,1,0,-1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [-1,-1,0,0,-1,0,1,-1,-1,0,-1,0,1,0,0,0,0,0], [1,-2,1,1,-1,-1,1,-1,-1,0,0,0,1,0,0,0,0,1], [-1,4,2,-2,2,-1,0,0,1,2,1,-1,-1,-1,0,-1,-1,-2], [-2,3,2,-1,1,-1,0,0,0,2,0,-1,-1,-1,0,-1,-1,-1], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [1,-1,-1,0,0,0,-1,1,1,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [-2,1,1,0,0,0,1,-1,-1,0,-1,-1,0,0,0,0,0,0], [-1,-1,0,1,-1,0,1,-1,-1,0,-1,0,1,0,0,0,0,1], [0,-3,-2,1,-1,1,-1,0,0,-2,-1,1,0,0,0,1,1,1], [-1,2,-1,-1,1,0,-1,1,1,0,0,0,-1,0,0,-1,0,-1], [-1,2,-1,-1,1,0,-1,1,1,0,0,0,-1,0,-1,0,0,-1], [0,1,1,0,0,0,0,0,1,0,0,0,-1,0,1,-1,-1,0], [2,-1,0,1,-1,0,0,0,0,0,1,0,1,0,0,0,0,0]]]], [ # Q-class [18][05] [[2], [1,2], [0,0,2], [0,0,1,2], [0,0,0,0,2], [0,0,0,0,1,2], [0,0,0,0,0,0,2], [0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0]], [[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [18][06] [[3], [1,3], [0,1,3], [-1,1,1,3], [1,0,1,-1,3], [-1,-1,1,0,1,3], [0,0,0,0,0,0,3], [0,0,0,0,0,0,1,3], [0,0,0,0,0,0,0,1,3], [0,0,0,0,0,0,-1,1,1,3], [0,0,0,0,0,0,1,0,1,-1,3], [0,0,0,0,0,0,-1,-1,1,0,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,3], [0,0,0,0,0,0,0,0,0,0,0,0,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,-1,3], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,1,0,1,3]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [18][07] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [18][08] [[5], [0,5], [0,0,5], [1,-1,0,5], [-1,0,-1,1,5], [0,-1,1,1,1,5], [-1,-1,1,-1,-1,-1,5], [1,-1,0,0,-1,-1,-1,5], [-1,-1,-1,-1,-1,1,-1,0,5], [1,1,-1,-1,1,-1,0,0,0,5], [1,-1,-1,-1,1,0,-1,1,-1,-1,5], [-1,-1,-1,0,1,-1,-1,-1,0,-1,1,5], [-1,0,-1,0,0,-1,1,-1,-1,1,-1,0,5], [0,0,0,-1,1,1,0,-1,-1,0,1,-1,1,5], [0,0,0,-1,-1,1,-1,-1,1,1,0,1,-1,0,5], [1,-1,0,0,1,0,1,0,1,1,0,-1,-1,-1,-1,5], [1,-1,0,0,0,-1,1,0,-1,-1,1,1,1,-1,-1,0,5], [-1,0,-1,-1,0,0,-1,1,1,-1,0,-1,0,1,-1,0,1,5]], [[[-1,-1,-1,-1,-1,0,-2,-1,-1,0,-1,-1,-1,0,-1,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,1,0,1,-1,1,1,0,0,1,1,1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,1,0,1,0,0,1,0,1,0,1,0,0,0,0,0,0,0], [1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,-1,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,-1,0,0,0,-1,0,-1,0,0,1,0,0,0], [0,-1,-1,-1,0,0,-1,0,-1,-1,-1,-1,0,0,0,0,0,-1], [-1,0,0,0,-1,0,-1,0,0,1,0,0,-1,1,-1,0,1,-1], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,1,0,1,0,1,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [-1,0,-1,0,-1,0,-1,0,-1,0,-1,0,-1,1,0,1,1,-1], [-1,-1,0,0,-1,0,-1,-1,-1,1,0,0,-1,0,-1,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,-1,1,0,0,0,0,-1,0,0,1,-1,0,0,-1,0], [1,1,1,1,1,0,2,1,1,0,1,1,1,0,1,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,1,-1,0,0,0,0,1,1,0,0,0,0,0,0,0], [1,0,0,0,1,0,1,0,1,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,-1,-1,-1,0,0,-1,0,-1,-1,-1,-1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-2,0,-1,0,-2,1,-1,0,-1,1,0,0,-1,1,-1,1,1,-1], [-1,0,0,0,-1,0,-1,0,0,0,0,0,0,1,0,1,1,-1], [0,-1,0,-1,0,0,-1,0,-1,0,-1,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,1,-1,1,1,0,0,1,1,1,0,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [1,0,0,0,1,0,1,0,1,0,0,0,0,0,0,-1,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,1,-1,0,0,0,0,1,1,0,0,0,0,0,0,0], [1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,-1,0,-1,1,-1,-1,0,0,-1,-1,-1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [-1,1,0,1,-1,1,0,1,0,1,0,1,0,1,0,1,1,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,-1,0,0,0,-1,-1,-1,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [18][09] [[6], [0,6], [0,0,6], [0,0,-2,6], [-2,0,-2,0,6], [0,0,0,-2,0,6], [-2,0,0,0,0,-2,6], [0,-2,-2,0,-2,1,1,6], [-2,0,1,0,0,1,0,0,6], [0,-2,1,0,0,0,1,0,-2,6], [1,-2,0,-2,1,-2,0,0,0,-2,6], [0,-2,0,0,1,1,0,0,1,0,0,6], [1,0,-2,0,0,1,0,0,-3,1,0,-2,6], [0,0,0,-2,1,0,1,0,0,1,0,-2,0,6], [-2,1,0,-2,0,0,0,1,-2,0,0,0,1,-2,6], [-2,-2,1,1,0,0,-2,0,0,0,0,-2,0,0,0,6], [0,1,0,0,-2,-2,0,0,1,0,0,-3,1,1,0,1,6], [0,0,0,1,0,-3,1,-2,-2,0,1,1,1,0,0,0,1,6]], [[[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1]], [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,1,-1,1,-1,0,1,0,-1,-1,0,1,-1,-1,0,0,0], [0,0,-1,-2,0,-1,0,0,0,0,-1,0,0,-1,-1,0,0,0], [-1,2,0,1,-1,0,0,0,0,1,2,2,1,1,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,0], [0,-2,0,0,0,0,0,-1,0,-1,-1,-1,0,0,0,-1,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [1,-1,0,2,0,2,1,-1,0,0,1,0,-1,1,2,0,1,0], [-2,-1,1,0,0,0,-1,0,-2,-1,0,0,0,0,-1,-2,1,-1], [1,0,-1,0,0,0,0,0,2,1,0,-1,0,0,1,0,-1,1], [0,0,0,0,0,0,0,0,-1,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,1,0,0,0,0,0,-2,-1,-1,0,-1,0,1], [2,0,0,0,1,0,1,0,1,0,-1,0,0,0,1,1,0,0], [0,1,-1,0,-1,0,0,-1,0,1,1,1,0,0,0,1,0,-1], [-1,0,1,0,1,0,-1,1,-1,0,0,0,0,-1,-1,-1,1,0], [0,2,0,0,0,0,0,1,0,1,1,1,0,0,-1,1,0,0]], [[1,1,0,1,0,1,1,0,1,1,1,0,0,0,1,1,0,0], [1,-1,-1,0,0,1,1,-1,0,0,0,-1,-1,0,1,0,0,0], [0,0,0,-1,0,-1,0,0,1,0,-1,0,1,0,0,0,-1,0], [-1,0,0,1,0,1,0,0,-1,0,1,0,-1,0,0,-1,1,0], [-1,-1,0,-1,0,-1,-1,0,-1,-1,-1,-1,0,-1,-1,-1,0,0], [1,-1,0,-1,1,0,0,0,1,0,-1,-1,0,-1,0,0,0,1], [-1,0,0,1,-1,0,0,-1,-1,0,1,1,0,1,0,0,0,-1], [1,1,0,1,0,0,0,0,1,1,1,1,0,1,1,1,0,0], [0,-1,1,0,1,0,0,0,-1,-1,-1,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,-1,1], [-1,1,1,0,0,-1,-1,1,-1,0,0,1,1,0,-1,0,0,-1], [0,0,0,-1,0,-1,0,0,0,0,-1,0,0,-1,-1,0,0,0], [0,0,0,1,0,1,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,1,-1,1,0,-1,0,0,1,0,0,1,1,0,0,0], [1,0,-1,-1,0,-1,0,0,1,0,-1,0,0,0,0,1,-1,0], [-1,1,0,-1,0,-1,-1,1,0,0,0,1,1,0,-1,0,0,0], [1,1,0,1,0,1,1,0,0,0,1,1,0,1,1,1,0,0], [-1,1,0,0,-1,0,0,0,-1,0,1,1,0,0,-1,0,0,-1]]]], [ # Q-class [18][10] [[4], [2,4], [2,2,4], [2,2,2,4], [2,2,2,2,4], [2,2,2,2,2,4], [2,2,2,2,2,2,4], [2,2,2,2,2,2,2,4], [2,2,2,2,2,2,2,2,4], [2,1,1,1,1,1,1,1,1,4], [1,2,1,1,1,1,1,1,1,2,4], [1,1,2,1,1,1,1,1,1,2,2,4], [1,1,1,2,1,1,1,1,1,2,2,2,4], [1,1,1,1,2,1,1,1,1,2,2,2,2,4], [1,1,1,1,1,2,1,1,1,2,2,2,2,2,4], [1,1,1,1,1,1,2,1,1,2,2,2,2,2,2,4], [1,1,1,1,1,1,1,2,1,2,2,2,2,2,2,2,4], [1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,-1,1], [0,0,1,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,1], [0,0,0,1,0,0,0,0,-1,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,-1,0,1], [0,1,0,0,0,0,0,0,-1,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,1,0,0,-1,0,0,0,0,0,-1,0,0,1], [1,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,1], [0,0,0,0,1,0,0,0,-1,0,0,0,0,-1,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1], [0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0], [0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0]]]], [ # Q-class [18][11] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [0,0,0,0,0,0,2], [0,0,0,0,0,0,1,2], [0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0]], [[-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [18][12] [[4], [0,4], [2,-2,4], [2,1,1,4], [1,-1,1,2,4], [0,-1,2,1,2,4], [0,0,0,0,0,0,4], [0,0,0,0,0,0,0,4], [0,0,0,0,0,0,2,-2,4], [0,0,0,0,0,0,2,1,1,4], [0,0,0,0,0,0,1,-1,1,2,4], [0,0,0,0,0,0,0,-1,2,1,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,0,0,2,-2,4], [0,0,0,0,0,0,0,0,0,0,0,0,2,1,1,4], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,2,4], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2,1,2,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [18][13] [[6], [2,6], [2,2,6], [2,2,2,6], [2,1,2,2,6], [2,2,1,2,2,6], [0,-1,2,2,1,0,6], [2,2,2,1,2,0,0,6], [1,0,2,2,2,2,0,2,6], [1,2,0,2,2,2,2,0,-2,6], [2,2,-2,0,0,1,-1,2,0,2,6], [2,2,1,2,0,-2,1,2,0,0,1,6], [1,2,2,0,2,0,2,2,-2,2,0,2,6], [-1,0,1,0,2,2,2,-1,1,1,0,-1,0,6], [0,2,2,0,2,1,2,1,0,2,-1,1,2,2,6], [-1,0,0,1,2,-1,2,2,1,0,1,2,1,2,1,6], [0,2,0,2,2,1,2,1,0,2,2,0,2,1,0,2,6], [2,1,0,0,2,0,0,0,-2,2,2,2,2,2,1,2,1,6]], [[[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1]], [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,1,0,0,0,-1,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [-1,0,0,0,1,0,1,0,0,-1,1,0,0,-1,0,-1,0,1], [1,-1,1,-1,0,0,-1,-1,0,1,0,1,0,0,0,1,1,-1], [1,-1,0,0,0,0,-1,0,-1,0,0,1,0,1,0,0,1,-1], [-1,2,-1,-1,1,0,2,0,1,0,0,0,0,-1,-1,-1,-1,1], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,1,0,1,0,-1,-1,-1,0,1,1,0,0,0,0,0,-1], [0,0,0,0,1,0,0,0,-1,0,0,0,-1,0,0,0,0,0], [-1,1,0,0,1,0,1,0,0,-1,1,-1,0,-1,0,0,-1,1], [0,1,0,-1,1,0,1,0,0,0,0,0,0,0,-1,0,-1,0], [2,-1,0,0,-1,-1,-2,-1,0,1,0,0,1,1,1,1,1,-2], [1,0,0,0,0,0,-1,-1,0,0,0,0,1,0,0,1,0,-1], [0,1,0,-1,1,0,1,0,0,0,0,0,-1,-1,0,0,0,0], [-1,2,-1,-1,2,0,3,0,0,-1,0,0,-1,-1,-1,-1,-1,1], [1,-1,1,0,0,0,-1,-1,-1,0,1,0,0,0,1,1,0,-1]], [[-2,1,0,-1,1,1,2,1,0,0,0,1,-1,-1,-1,-1,-1,1], [0,1,-1,-1,-1,0,1,1,1,1,-2,0,0,0,-1,0,0,1], [1,-2,1,0,-1,0,-2,0,-1,1,0,1,0,1,1,1,1,-2], [0,1,-1,0,0,-1,1,0,1,0,0,-1,1,0,0,0,-1,0], [0,-1,1,-1,0,0,-1,0,0,1,0,1,0,0,0,0,1,-1], [0,0,0,0,-1,0,0,0,1,0,0,0,1,0,0,0,0,0], [1,-1,1,1,0,-1,-2,-1,-1,0,1,0,1,1,1,1,0,-2], [0,1,0,-1,0,0,1,1,0,1,-1,0,-1,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [-1,2,-1,0,0,0,2,1,1,0,-1,-1,0,-1,-1,-1,-1,2], [-1,2,-1,-1,1,0,2,1,0,0,-1,0,-1,0,-1,-1,-1,1], [1,-1,1,-1,-1,0,-2,0,0,2,-1,1,0,1,0,1,1,-1], [1,-1,0,1,-1,-1,-2,0,0,0,0,0,1,1,1,0,1,-1], [0,-1,1,0,0,0,-1,0,-1,0,0,1,0,1,0,0,1,-1], [0,1,0,0,0,-1,0,0,0,0,0,-1,0,0,0,0,0,0], [1,0,0,0,-1,-1,-1,0,1,1,-1,-1,1,0,0,1,0,0], [-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,1]]]], [ # Q-class [18][14] [[9], [1,9], [2,3,9], [3,3,1,9], [3,3,3,3,9], [3,3,1,2,3,9], [3,3,3,0,3,-1,9], [0,-1,3,1,1,2,1,9], [1,2,3,3,3,3,1,1,9], [0,3,1,3,0,0,3,3,2,9], [1,1,3,1,2,3,3,3,3,3,9], [3,3,0,1,-1,1,3,1,0,3,3,9], [0,1,3,3,3,0,3,3,1,3,2,2,9], [3,2,3,2,1,1,3,2,1,3,3,1,1,9], [1,0,-1,3,3,3,0,3,1,3,3,2,1,1,9], [3,3,1,1,1,3,3,3,-1,1,2,2,-1,3,0,9], [3,0,3,3,2,1,0,3,-1,-1,1,3,3,3,3,2,9], [2,1,1,3,1,0,1,3,-1,3,-3,-1,1,-1,1,0,-1,9]], [[[-3,-3,2,1,2,1,0,-2,0,0,-1,3,-1,1,0,1,-1,1], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,1], [0,0,-1,-1,0,0,0,-1,1,0,1,0,0,0,0,0,1,1], [-2,-2,1,2,1,2,2,0,-1,1,-1,1,-2,0,-1,-1,0,-1], [0,0,0,-1,0,-1,-1,-1,1,-1,1,0,1,0,1,1,0,1], [-1,-1,0,0,0,1,1,-1,0,0,0,0,0,0,0,0,1,1], [1,2,-2,-1,-1,-1,0,0,1,0,2,-2,0,-1,0,0,2,1], [0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,1], [-1,-2,1,2,1,1,1,0,-1,0,-1,1,-1,0,0,0,-1,-1], [-2,-2,1,1,1,0,0,-1,0,-1,0,2,0,1,0,1,-1,1], [1,1,-1,-1,-1,-1,0,0,1,-1,1,-1,1,0,1,0,0,1], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,1,1,1,1,0,-1,0,0,1,-1,0,-1,-1,0,0], [-2,-2,1,0,1,1,0,-2,0,0,0,1,0,1,0,1,0,1], [-1,-1,0,0,1,0,0,-1,0,0,0,1,0,1,0,0,0,1], [-1,-1,1,0,0,1,0,-1,0,0,0,1,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,1,1,0,0,1,-1,0,-1,1,-1,0,0,-1,-1,-1], [2,3,-2,-2,-1,-2,-1,0,1,-1,2,-2,1,0,1,0,1,1], [0,-1,1,1,1,1,1,1,-1,1,-2,1,-1,0,0,-1,-1,-2], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,1,1,0,0,0,-1,0,-1,1,0,0,0,0,-1,-1], [1,1,-1,-1,0,-1,-1,0,1,0,1,-1,0,0,0,0,1,1], [1,1,-1,0,0,-1,0,1,0,0,0,-1,0,0,0,0,0,-1], [-1,-1,0,0,1,0,0,-1,0,0,0,1,0,1,0,0,0,1], [0,0,0,1,0,0,1,1,0,0,-1,0,-1,0,0,-1,0,-1], [0,0,0,-1,0,-1,-1,-1,1,-1,0,0,1,1,1,1,0,1], [-1,-2,2,2,1,1,0,0,-1,0,-2,2,-1,1,0,0,-2,-1], [1,1,-1,0,0,0,0,1,0,0,0,-1,0,0,0,-1,0,-1], [2,2,-1,-1,-1,-2,-1,1,1,-1,1,-1,1,0,1,0,0,0], [-1,-2,2,2,1,1,1,0,-1,1,-2,1,-1,0,0,0,-1,-2], [0,-1,1,1,1,0,0,1,-1,0,-1,1,-1,0,0,0,-1,-1], [1,0,1,1,0,0,0,1,-1,0,-1,0,0,0,1,0,-2,-2], [1,1,-1,0,0,0,1,1,0,1,0,-1,-1,-1,-1,-1,1,-1]]]], [ # Q-class [18][15] [[6], [1,6], [1,3,6], [-3,0,0,6], [3,-1,0,-1,6], [0,-1,1,1,-1,6], [-1,2,1,0,-2,0,6], [0,1,0,-1,0,1,-1,6], [1,0,-1,-1,1,1,1,-1,6], [-2,1,0,1,-3,0,3,0,-2,6], [-2,0,1,-1,-3,-1,1,0,0,1,6], [1,-2,-3,-1,-1,-1,-1,1,0,0,1,6], [-1,-2,-3,-1,0,0,0,0,-1,0,-1,1,6], [1,3,1,1,-2,-1,1,-1,0,1,1,1,-1,6], [2,3,2,-1,-1,0,3,0,0,2,0,-1,-1,2,6], [2,1,1,1,1,0,0,1,1,0,-1,0,-3,1,1,6], [1,3,2,0,0,-1,-1,0,1,0,0,-1,-3,2,1,2,6], [2,2,1,1,1,-1,-2,-1,0,-1,-1,0,-1,3,1,1,3,6]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,1,1,-1,-1,-1,0,1,1,0,0,1,-1,0,0,0,0], [0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [-1,1,-1,-1,1,1,0,-1,-1,0,0,0,-1,0,0,0,0,0], [1,0,0,1,-1,0,0,0,0,0,0,0,0,-1,0,0,0,0], [-1,1,0,-1,0,0,-1,-1,0,0,0,0,0,0,0,1,-1,0], [-1,1,0,0,1,1,0,-1,0,0,0,1,0,0,0,0,0,0], [1,0,0,0,-1,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,-1,-1,0,0,0,0,0,0,0,0], [1,0,0,1,0,0,0,0,0,0,1,0,1,-1,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,-1,0,0,0,1], [-2,1,0,-1,1,1,-1,-1,0,0,0,1,0,0,1,1,0,0], [0,0,1,0,0,0,-1,0,1,1,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0]], [[-2,1,0,-1,1,1,0,-1,-1,0,0,1,0,0,0,1,0,0], [-1,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [-1,1,0,-1,1,1,0,-1,-1,0,0,1,0,0,0,1,0,0], [-1,0,-1,-1,0,1,1,0,-1,-1,0,0,-1,0,0,0,0,1], [1,0,-1,1,0,0,0,0,0,0,1,-1,0,0,0,0,0,0], [-1,0,0,-1,0,0,0,0,0,0,-1,0,-1,1,0,0,-1,0], [0,1,-1,0,1,1,0,0,-1,0,1,0,0,0,0,0,0,0], [1,-1,0,1,-1,-1,0,1,1,0,0,-1,0,0,0,0,0,0], [2,-1,0,1,-1,-1,0,1,1,1,0,-1,0,0,-1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-2,2,0,-1,1,1,-1,-1,0,0,0,1,0,0,0,1,-1,0], [-1,1,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0], [-1,0,1,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0]]]], [ # Q-class [18][16] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]]]], [ # Q-class [18][17] [[10], [2,10], [4,2,10], [3,4,2,10], [2,2,2,0,10], [0,4,2,4,1,10], [4,2,4,2,2,-2,10], [2,2,2,3,4,1,4,10], [1,2,1,2,2,4,0,3,10], [4,3,2,2,2,-2,4,2,2,10], [2,3,-2,2,4,3,2,4,2,-2,10], [3,4,1,2,1,2,3,3,4,2,1,10], [4,2,4,0,4,3,2,2,3,4,2,1,10], [3,2,2,2,-2,2,2,2,4,3,2,2,1,10], [4,1,2,2,4,2,2,2,2,-2,4,3,-1,2,10], [0,3,2,2,2,2,4,4,2,4,2,-2,2,2,-2,10], [1,4,2,-2,0,2,3,0,2,2,1,4,3,4,2,2,10], [2,2,3,0,2,2,2,2,0,2,3,-1,2,4,2,3,4,10]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,-1,2,-1,0,2,0,1,1,2,2,-2,-3,-1,-2,-2,2,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,1,-1,0,1,0,0,0,1,1,0,-1,0,-1,-1,0,0], [1,-2,3,-1,0,4,1,2,1,5,4,-4,-6,-2,-3,-5,4,-2], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,1,-1,0,2,1,1,0,2,1,-2,-2,0,-1,-2,1,-1], [1,0,1,-1,0,2,1,1,1,2,2,-3,-3,-1,-2,-3,2,-1], [1,0,0,0,0,1,0,1,0,0,0,-1,-1,0,-1,-1,1,0], [-1,0,1,-1,-1,0,0,0,0,1,1,0,0,0,1,0,-1,0], [1,-1,1,-1,0,3,1,1,1,3,2,-3,-3,-1,-2,-3,2,-1], [0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,-1,1,0], [-1,1,-1,0,-1,-2,-1,-1,-1,-2,-1,2,3,1,2,3,-2,1], [-1,0,0,0,-1,-1,0,-1,0,0,0,1,1,0,1,1,-1,1], [1,0,1,-1,0,1,0,1,0,1,1,-1,-2,0,-1,-1,1,-1], [0,0,0,0,-1,-1,-1,0,0,0,0,0,1,0,1,1,0,0], [-1,1,-1,0,-1,-2,-1,-1,-1,-2,-2,2,3,1,3,3,-2,1]], [[-2,1,-2,1,-1,-3,0,-1,-1,-3,-3,3,5,1,3,3,-3,2], [0,0,0,0,1,1,1,0,0,0,0,0,-1,0,-1,-1,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [1,-1,1,0,1,2,1,1,1,2,1,-2,-3,-1,-2,-3,2,-1], [-1,1,-1,0,-1,-2,0,-1,0,-2,-1,2,3,0,2,2,-2,1], [1,-1,1,0,1,2,1,1,1,1,1,-2,-3,-1,-2,-2,2,-1], [-1,1,-1,0,0,-2,0,-1,-1,-2,-2,2,3,1,2,2,-2,1], [-1,0,0,0,0,-1,0,-1,0,0,0,1,1,0,1,1,-1,0], [0,0,1,-1,0,2,1,1,1,2,1,-2,-2,-1,-1,-2,1,-1], [-1,0,1,0,0,0,0,0,0,1,1,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [-1,1,-1,0,0,-1,1,-1,0,-2,-2,1,2,1,1,1,-2,1], [-1,0,1,0,-1,0,0,0,0,1,1,0,0,-1,1,0,0,0], [1,-2,3,-1,1,4,1,2,1,5,4,-4,-6,-2,-4,-5,4,-2], [0,0,-1,0,0,0,1,0,0,-1,-1,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,1,1,0,0,0,0,-1,-1,0,-1,-1,1,0], [0,0,0,1,1,-1,0,0,0,-1,0,0,0,0,-1,0,1,0]]]] ]; MakeImmutable( IMFList[18].matrices ); gap-4r6p5/grp/perf.grp0000644000175000017500000005444212172557252013410 0ustar billbill############################################################################# ## #W perf.grp GAP Groups Library Alexander Hulpke ## Volkmar Felsch ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains the access functions for the Holt/Plesken library ## ############################################################################# ## #F PerfGrpLoad() force loading of secondary files, return index ## InstallGlobalFunction( PerfGrpLoad, function(sz) local p,sel,i,pos; if PERFRec=fail then ReadGrp("perf0.grp"); fi; # get the index pos:=PositionSet(PERFRec.sizes,sz); if pos=fail then return fail; fi; if PERFSELECT[pos] then return pos; fi; # get the file number p:=PositionSorted(PERFRec.covered,pos); if SizeBlist(PERFSELECT)>50 then # throw away old to free memory sel:=Filtered([1..PERFRec.length],i->PERFSELECT[i]); sel:=sel{[1..Length(sel)-25]}; for i in sel do Unbind(PERFGRP[i]); PERFSELECT[i]:=false; od; fi; ReadGrp(Concatenation("perf",String(p),".grp")); # store loaded info if p=1 then p:=[0,PERFRec.covered[p]]; else p:=PERFRec.covered{[p-1,p]}; fi; for i in [p[1]+1..p[2]] do PERFSELECT[i]:=true; od; return pos; end ); ############################################################################# ## #F SizesPerfectGroups( ) ## ## `SizesPerfectGroups' returns an ordered list of all integers that occur ## as group sizes in the library of perfect groups. ## InstallGlobalFunction( SizesPerfectGroups, function ( ) PerfGrpLoad(0); # return the requested list. return ShallowCopy( PERFRec.sizes ); end ); ############################################################################# ## #F NumberPerfectGroups( size ) ## ## `NumberPerfectGroups' returns the number of nonisomorphic perfect groups ## of size size for 1 <= size <= 1 000 000. ## ## Exception: The number of perfect groups is not yet known for the eight ## sizes 61440, 122880, 172032, 245760, 344064, 491520, 688128, and 983040. ## ## If size is one of these exceptions or if size is out of range, the value ## fail will be returned. ## InstallGlobalFunction( NumberPerfectGroups, function ( size ) PerfGrpLoad(0); # get the number and return it. if not size in [ 1 .. 1000000 ] or size in PERFRec.notKnown then return fail; elif not size in PERFRec.sizes then return 0; else return PERFRec.number[ PositionSorted( PERFRec.sizes, size ) ]; fi; end ); ############################################################################# ## #F NumberPerfectLibraryGroups( size ) ## ## `NumberPerfectLibraryGroups' returns the number of nonisomorphic perfect ## groups of size size for 1 <= size <= 1 000 000 which are available in the ## perfect groups library. ## InstallGlobalFunction( NumberPerfectLibraryGroups, function ( size ) local sizenum; # get the number and return it. sizenum := PerfGrpLoad( size ); if sizenum = fail or size in PERFRec.notAvailable or size = 1 then return 0; else return PERFRec.number[sizenum]; fi; end ); ############################################################################# ## #F PerfectCentralProduct( ) . . . . . . . . . . . . . . local ## ## `PerfectCentralProduct' returns, generators, relators and subgroup ## information for ## the direct product of two perfect groups or their central product modulo ## some given central element. ## ## It is expected that grpdata[1] is either of the form ## [ 2, , , , ] ## or [ 3, , , , , , ... ] ## ## In the first case, the resulting group G is just the direct product D of ## the n1-th group of size size1, G1, and the n2-th group of size size2, G2, ## from the perfect groups library. ## ## In the second case, the string entries are expected to be the names of ## suitable generators of D such that their product is the central element ## to be factored out in D to contain G. ## ## Note: This function is an internal function, hence the arguments are not ## checked to be in range. In particular, the first source entry which is ## expected to be 2 or 3 is neither checked nor used. Moreover, the perfect ## groups record PERFRec is expected to be already loaded. ## PerfectCentralProduct := function ( grpdata ) local source,orbsize,nargs,grp1,grp2,names1,names2,names,F,fgens, gens1,ngens1,gens2,words1,words2,rels,sub,i,j; # get the arguments. source:=grpdata[1]; orbsize:=grpdata[6]; nargs := Length( source ); grp1:=PERFGRP[PerfGrpLoad(source[2])][source[3]]; grp2:=PERFGRP[PerfGrpLoad(source[4])][source[5]]; # construct names for the generators of the group G to be constructed. names1:=List(grp1[1][2],i->Concatenation([i],"1")); names2:=List(grp2[1][2],i->Concatenation([i],"2")); names := Concatenation( names1, names2 ); # get the associated free group generators. F := FreeGroup( names ); fgens:=GeneratorsOfGroup(F); ngens1 := Length( names1 ); gens1 := fgens{[1..ngens1]}; gens2 := fgens{[ngens1+1..Length(names)]}; # get relators and subgroup words words1:=CallFuncList(grp1[1][3],gens1); words2:=CallFuncList(grp2[1][3],gens2); # common relations rels:=Concatenation(words1[1],words2[1]); # commuting relations for i in gens1 do for j in gens2 do Add(rels,Comm(i,j)); od; od; sub:=[]; # in case of a central product compute additional relations and store # suitable subgroups for a faithful permutation representation. if Length(source)>5 then Add(rels,Product(List(source{[6..Length(source)]}, i->fgens[Position(names,i)]))); for i in words1[2] do for j in words2[2] do Add(sub,Concatenation(i,j)); od; od; fi; # return the result return [F,fgens,rels,sub]; end; ############################################################################# ## #F PerfectSubdirectProduct( ) . . . . . . . . . . . . . . . . local ## ## `PerfectSubdirectProduct' returns, in form of a finitely presented group, ## the subdirect product of two perfect groups. ## ## It expects the associated source entry to be of the form ## [ 4, , , , , ] ## or [ 4, , , , , , , ] ## ## The resulting group G is the subdirect product of the n1-th group of size ## size1, G1, and the n2-th group of size size2, G2, from the perfect groups ## library over the perfect group G0 of size over. ## ## Note: This function is an internal function, hence the arguments are not ## checked to be in range. In particular, the first source entry which is ## expected to be 4 is neither checked nor used. Moreover, the perfect ## groups record PERFRec is expected to be already loaded. ## ## Warning: The method used here is n o t a general method to construct ## subdirect products. It is only guaranteed that it works correctly for the ## given set of examples. ## PerfectSubdirectProduct := function (grpdata) local source,grp1,grp2,grp0,ngens0,ngens1,ngens2,gens0,gens1,gens2,nrels0, names0,names1,names2,names,F,fgens,ngens,rels,rels0,rels1,rels2,i,j; # get the arguments. source:=grpdata[1]; grp1:=PERFGRP[PerfGrpLoad(source[2])][source[3]]; grp2:=PERFGRP[PerfGrpLoad(source[4])][source[5]]; grp0:=PERFGRP[PerfGrpLoad(source[6])][1]; # construct names for the generators of the group G to be constructed. ngens0:=Length(grp0[1][2]); ngens1:=Length(grp1[1][2]); ngens2:=Length(grp2[1][2]); names0:=List(grp0[1][2],i->[i]); names1:=List(grp1[1][2]{[ngens0+1..ngens1]},i->Concatenation([i],"1")); names2:=List(grp2[1][2]{[ngens0+1..ngens2]},i->Concatenation([i],"2")); names := Concatenation(names0,names1,names2); # get the associated free group generators. F := FreeGroup( names ); fgens:=GeneratorsOfGroup(F); ngens:=Length(fgens); gens0 := fgens{[1..ngens0]}; gens1 := fgens{[ngens0+1..ngens1]}; gens2 := fgens{[ngens1+1..ngens]}; # initialize relations rels:=[]; for i in gens1 do for j in gens2 do Add(rels,Comm(i,j)); od; od; gens1:=Concatenation(gens0,gens1); gens2:=Concatenation(gens0,gens2); # get relators rels0:=CallFuncList(grp0[1][3],gens0)[1]; rels1:=CallFuncList(grp1[1][3],gens1)[1]; rels2:=CallFuncList(grp2[1][3],gens2)[1]; # construct defining relators for G. nrels0:=Length(rels0); rels:=Concatenation(rels,rels1{[nrels0+1..Length(rels1)]}); rels:=Concatenation(rels,rels2{[nrels0+1..Length(rels2)]}); for i in [ 1 .. ngens0 ] do gens1[i] := One(F); gens2[i] := One(F); od; rels1:=CallFuncList(grp1[1][3],gens1)[1]; rels2:=CallFuncList(grp2[1][3],gens2)[1]; for i in [ 1 .. nrels0 ] do Add(rels,rels0[i]*rels1[i]*rels2[i]); od; return [F,fgens,rels]; end; ############################################################################# ## #M PerfGrpConst(,) ## InstallMethod(PerfGrpConst,"fp grp",true,[IsSubgroupFpGroup,IsList],0, function(filter,l) local G,n; if Length(l)=0 then G:=FreeGroup(1); return G/GeneratorsOfGroup(G); fi; n:=l[1][1]; if n=1 then G:=FreeGroup(List(l[1][2],i->[i])); G:=Concatenation([G,GeneratorsOfGroup(G)], CallFuncList(l[1][3],GeneratorsOfGroup(G))); elif n in [2,3] then G:=PerfectCentralProduct(l); elif n=4 then G:=PerfectSubdirectProduct(l); else Error("not supported"); fi; G:=G[1]/G[3]; if Length(l)>1 then SetName(G,l[2]); fi; return G; end); ############################################################################# ## #M PerfGrpConst(,) ## InstallMethod(PerfGrpConst,"perm grp",true,[IsPermGroup,IsList],0, function(filter,l) local G,i,j,g1,g2,gl,e1,e2,gens,rels,subs,pgens,deg,ind,ct,fp,extend,num; if Length(l)=0 then # special treatment for the trivial group G:= GroupByGenerators( [], () ); return G; fi; if l[1][1]=1 then gl:=List(l[1][2],i->[i]); if Length(l[1])>4 then # we have auxiliary generators extend:=l[1][5]; for i in [1..Length(extend)] do if extend[i]<>0 then Add(gl,Concatenation("aux",String(i))); fi; od; else extend:=false; fi; gens:=GeneratorsOfGroup(FreeGroup(gl)); num:=Length(l[1][2]); rels:=CallFuncList(l[1][3],gens{[1..num]}); subs:=rels[2]; rels:=rels[1]; if extend<>false then # add the further generators in the `auxiliary' component. for i in [1..Length(extend)] do if extend[i]<>0 then num:=num+1; if IsInt(extend[i]) then Add(rels,gens[i]^extend[i]/gens[num]); else g1:=One(gens[1]); for j in extend[i] do if j>0 then g1:=g1*gens[j]; else g1:=g1/gens[-j];fi; od; Add(rels,g1/gens[num]); fi; fi; od; # Tietze extend:=PresentationFpGroup(Group(gens)/rels); TzOptions(extend).generatorsLimit:=Length(gens); TzOptions(extend).printLevel:=0; TzGo(extend); G:=FpGroupPresentation(extend); gl:=gens; gens:=FreeGeneratorsOfFpGroup(G); rels:=RelatorsOfFpGroup(G); subs:=List(subs,i->List(i,j->MappedWord(j,gl,gens))); fi; elif l[1][1] in [2,4] then g1:=PerfGrpConst(IsPermGroup,PERFGRP[PerfGrpLoad(l[1][2])][l[1][3]]); g2:=PerfGrpConst(IsPermGroup,PERFGRP[PerfGrpLoad(l[1][4])][l[1][5]]); G:=DirectProduct(g1,g2); if Length(l[1])>5 then gl:=Length(PERFGRP[PerfGrpLoad(l[1][6])][1][1][2]); e1:=Embedding(G,1); e2:=Embedding(G,2); g1:=GeneratorsOfGroup(g1); g2:=GeneratorsOfGroup(g2); gens:=List([1..gl],i->Image(e1,g1[i])*Image(e2,g2[i])); for i in [gl+1..Length(g1)] do Add(gens,Image(e1,g1[i])); od; for i in [gl+1..Length(g2)] do Add(gens,Image(e2,g2[i])); od; G:=Subgroup(G,gens); fi; if Length(l)>1 then SetName(G,l[2]); fi; return G; elif l[1][1]=3 then gens:=PerfectCentralProduct(l); rels:=gens[3]; subs:=gens[4]; gens:=gens[2]; else Error("not supported"); fi; pgens:=List(gens,i->()); deg:=0; if IsBound(l[6]) then ind:=l[6]; else ind:=l[1][4]; fi; if not IsList(ind) then ind:=[ind]; fi; for i in [1..Length(subs)] do ct:=CosetTableFromGensAndRels(gens,rels,subs[i]); ct:=ct{[1,3..Length(ct)-1]}; # avoid inverses if Length(ct[1])<>ind[i] then Error("index!"); fi; ct:=List(ct,i->Concatenation([1..deg],i+deg)); #shift ct:=List(ct,PermList); # make perms pgens:=List([1..Length(gens)],i->pgens[i]*ct[i]); deg:=deg+ind[i]; od; G:= GroupByGenerators( pgens, () ); # # store the presentation # fp:=Group(gens,gens[1]^0)/rels; # SetIsomorphismFpGroup(G,GroupHomomorphismByImages(G,fp,pgens, # GeneratorsOfGroup(fp))); # SetIsomorphismPermGroup(fp,GroupHomomorphismByImages(fp,G, # GeneratorsOfGroup(fp),pgens)); if Length(l)>1 then SetName(G,l[2]); fi; return G; end); ############################################################################# ## #F PerfectGroup([,],) . . . . Access perfect groups library ## InstallGlobalFunction( PerfectGroup, function(arg) local func,sz,p; PerfGrpLoad(0); # force loading if not IsFunction(arg[1]) then func:=IsSubgroupFpGroup; sz:=arg; else func:=arg[1]; sz:=arg{[2..Length(arg)]}; fi; # list given if Length(sz)=1 then if not IsList(sz[1]) then sz:=[sz[1],1]; else sz:=sz[1]; fi; fi; if sz[1] in PERFRec.notKnown then Error("Perfect groups of size ",sz[1]," not known"); elif sz[1] in PERFRec.notAvailable then Error("Perfect groups of size ",sz[1]," not available"); elif sz[1]=1 then Error("The trivial group is not considered to be part of this library"); fi; p:=PerfGrpLoad(sz[1]); if p=fail or sz[2]>PERFRec.number[p] then Error("PerfectGroup(",sz[1],",",sz[2],") does not exist !"); fi; p:=PerfGrpConst(func,PERFGRP[p][sz[2]]); SetSize(p,sz[1]); SetPerfectIdentification(p,ShallowCopy(sz)); SetIsPerfectGroup(p,true); SetFilterObj(p,IsPerfectLibraryGroup); return p; end ); ############################################################################# ## #F DisplayInformationPerfectGroups( ) . . . . . . . . . . . . . . . . #F DisplayInformationPerfectGroups( , ) . . . . . . . . . . . . . #F DisplayInformationPerfectGroups( [ , ] ) . . . . . . . . . . . ## ## `DisplayInformationPerfectGroups' displays some invariants of the n-th ## group of size size from the perfect groups library. ## ## If no value of n has been specified, the invariants will be displayed for ## all groups of size size available in the library. ## InstallGlobalFunction( DisplayInformationPerfectGroups, function ( arg ) local size,i,nr,n,leng,sizenum,hpnum,description,centre,orbsize; if IsInt(arg[1]) then size:=arg[1]; if Length(arg)=1 then nr:=[1..NumberPerfectLibraryGroups(size)]; else nr:=arg[2]; fi; else size:=arg[1][1]; nr:=arg[1][2]; fi; if IsInt(nr) then nr:=[nr]; fi; sizenum:=PerfGrpLoad(size); if size in PERFRec.notAvailable then Print("#I no information available about size ",size,"\n"); return; elif size in PERFRec.notKnown then Print("#I no information known about size ",size,"\n"); return; fi; # loop over the given range. for n in nr do # get the required data from main list. description := PERFGRP[sizenum][n][2]; hpnum := PERFGRP[sizenum][n][3]; centre := PERFGRP[sizenum][n][4]; orbsize := PERFGRP[sizenum][n][6]; # print the group number. Print( "#I Perfect group ", size ); if Length(nr) > 1 then Print( ".", n ); fi; Print( ": " ); # print a message if the group is simple or quaqsisimple. if centre = -1 then if size = 1 then Print( "trivial group " ); else Print( "simple group " ); fi; elif centre < -1 then Print( "quasisimple group " ); centre := -centre; fi; # print the Holt-Plesken description. Print( description, "\n#I " ); # print the size of the centre. if centre > 1 then Print( " centre = ", centre ); fi; # print the group size. Print( " size = " ); PrintFactorsInt( size ); # print the orbit sizes of the available permutation representations. if IsInt( orbsize ) then Print( " orbit size = ", orbsize, "\n" ); else orbsize := ShallowCopy( orbsize ); Sort( orbsize ); Print( " orbit sizes = ", orbsize[1] ); for i in [ 2 .. Length( orbsize ) ] do Print( " + ", orbsize[i] ); od; Print( "\n" ); fi; # print the Holt-Plesken classes and numbers. if IsInt( hpnum ) then Print( "#I Holt-Plesken class ", hpnum ); else Print( "#I Holt-Plesken class ", hpnum[1] ); Print( " (", hpnum[2], ",", hpnum[3], ")" ); leng := Length( hpnum ); if leng > 3 then if leng = 4 then Print( " (occurs also in class ", hpnum[4] ); else Print( " (occurs also in classes ", hpnum[4] ); for i in [ 5 .. leng ] do Print( ", ", hpnum[i] ); od; fi; Print( ")" ); fi; fi; Print( "\n" ); od; end ); ############################################################################# ## #F SizeNumbersPerfectGroups( , ..., ) . . . . . . . . . . . ## ## `SizeNumbersPerfectGroups' returns a list of the size numbers of all ## perfect library groups whose composition factors cover the given factors. ## Each argument must be one of the valid names of simple factors or a ## positive integer. ## ## The size number of a group from the perfect groups library is a pair of ## the form [ size, n ], where size is the group size and n is the number of ## the group within the list of all library groups of that size. ## InstallGlobalFunction( SizeNumbersPerfectGroups, function ( arg ) local a6a6, a6a6a6, empty, factor, minsize, minsizenum, n, nn, num, pos, simple, simple2, size, sizenum, sizenums; # load the perfect groups record PERFRec if it is not yet available. PerfGrpLoad( 0 ); # get and check the arguments, and get the minimal group size. simple := [ ]; minsize := 1; for factor in arg do if IsInt( factor ) then if factor < 1 then Error( "illegal order of abelian factor" ); fi; minsize := minsize * factor; else pos := Position( PERFRec.nameSimpleGroup, factor ); if pos = fail then Error( "illegal name of simple factor" ); fi; num := PERFRec.numberSimpleGroup[pos]; sizenum := PERFRec.sizeNumberSimpleGroup[num]; minsize := minsize * sizenum[1]; Add( simple, num ); fi; od; empty := simple = [ ]; if not empty then if Length( simple ) = 1 then simple := simple[1]; else Sort( simple ); fi; fi; # initialize the resulting list of size numbers; sizenums := [ ]; a6a6 := [1,1]; a6a6a6 := [1,1,1]; # get the first size to be handled. minsizenum := Maximum(2,PositionSorted( PERFRec.sizes, minsize )); # loop over all library groups of size >= minsize. for sizenum in [ minsizenum .. Length( PERFRec.sizes ) ] do # check the size for being a multiple of minsize. if PERFRec.sizes[sizenum] mod minsize = 0 then # loop over the library groups of size size. size := PERFRec.sizes[sizenum]; PerfGrpLoad(size); nn := PERFRec.number[sizenum]; for n in [ 1 .. nn ] do if PERFGRP[sizenum][n]<>fail then simple2 := PERFGRP[sizenum][n][5]; if simple = simple2 or empty or IsList( simple2 ) and ( simple in simple2 or ( simple2 = a6a6 and simple = a6a6a6 ) ) then # add the pair [size,n] to the list of size numbers. Add( sizenums, [ size, n ] ); fi; fi; od; fi; od; # return the list of size numbers. return sizenums; end ); ############################################################################# ## #M PerfectIdentification() . . . . . . . . . . . . id. for perfect groups ## InstallMethod(PerfectIdentification,"id. for perfect groups",true, [IsGroup],0, function(G) local s,l; if not IsPerfectGroup(G) then return fail; fi; s:=Size(G); PerfGrpLoad(0); if s>=10^6 or s in PERFRec.notAvailable or s in PERFRec.notKnown then Print("#W No information about size ",s," available\n"); return fail; fi; l:=NumberPerfectLibraryGroups(s); while l>1 do if IsomorphismGroups(G,PerfectGroup(IsPermGroup,s,l))<>fail then return [s,l]; fi; l:=l-1; od; return [s,1]; end); ############################################################################# ## #M IsomorphismFpGroup for perfect library groups ## InstallMethod(IsomorphismFpGroup,"perfect library groups",true, [IsPerfectLibraryGroup],100, function(G) local H,hom,permgens,fpgens; H:=PerfectGroup(IsSubgroupFpGroup,PerfectIdentification(G)); permgens:=GeneratorsOfGroup(G); fpgens:=GeneratorsOfGroup(H); if Length(permgens)<>Length(fpgens) then # remove auxiliary gens hom:=GroupHomomorphismByImagesNC(G,H,permgens{[1..Length(fpgens)]},fpgens); else hom:=GroupHomomorphismByImagesNC(G,H,permgens,fpgens); fi; SetIsInjective(hom,true); SetIsSurjective(hom,true); return hom; end); ############################################################################# ## #M IsomorphismPermGroup for perfect library groups ## InstallMethod(IsomorphismPermGroup,"perfect library groups",true, [IsPerfectLibraryGroup],100, function(G) local H,hom,permgens,fpgens; H:=PerfectGroup(IsPermGroup,PerfectIdentification(G)); fpgens:=GeneratorsOfGroup(G); permgens:=GeneratorsOfGroup(H); if Length(permgens)<>Length(fpgens) then # remove auxiliary gens hom:=GroupHomomorphismByImagesNC(G,H,fpgens,permgens{[1..Length(fpgens)]}); else hom:=GroupHomomorphismByImagesNC(G,H,fpgens,permgens); fi; SetIsInjective(hom,true); SetIsSurjective(hom,true); return hom; end); ############################################################################# ## #E perf.grp . . . . . . . . . . . . . . . . . . . . . . . . . ends here ## gap-4r6p5/grp/perf4.grp0000644000175000017500000010247212172557252013471 0ustar billbill############################################################################# ## #W perf4.grp GAP Groups Library Volkmar Felsch ## Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains the perfect groups of sizes 30720-30720 ## All data is based on Holt/Plesken: Perfect Groups, OUP 1989 ## PERFGRP[71]:=[# 30720.1 [[1,"abdstuvef", function(a,b,d,s,t,u,v,e,f) return [[a^2*d,b^3,(a*b)^5,d^2,d^-1*b^-1*d*b,e^4,f^4, d^-1*a^-1*d*a,d^-1*s^-1*d*s, d^-1*t^-1*d*t,d^-1*u^-1*d*u, d^-1*v^-1*d*v,d^-1*e^-1*d*e, d^-1*f^-1*d*f,e^-1*a^-1*e*a, e^-1*b^-1*e*b,e^-1*s^-1*e*s, e^-1*t^-1*e*t,e^-1*u^-1*e*u, e^-1*v^-1*e*v,e^-1*f^-1*e*f, f^-1*a^-1*f*a,f^-1*b^-1*f*b, f^-1*s^-1*f*s,f^-1*t^-1*f*t, f^-1*u^-1*f*u,f^-1*v^-1*f*v,s^2, t^2,u^2,v^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u*e^2,s^-1*v^-1*s*v *f^2,t^-1*u^-1*t*u*f^2, t^-1*v^-1*t*v*e^2*f^2,u^-1*v^-1*u *v,a^-1*s*a*u^-1*f^2, a^-1*t*a*v^-1,a^-1*u*a*s^-1*f^2, a^-1*v*a*t^-1, b^-1*s*b*(t*v*e*f^-1)^-1, b^-1*t*b*(s*t*u*v*f)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1 *f^2],[[a*b,s,e,f],[a,b,e],[a,b,f]]]; end, [24,64,64]], "A5 2^1 x ( 2^4 E ( 2^1 A x 2^1 A ) ) C ( 2^1 x 2^1 )",[1,9,1],32, 1,[24,64,64]], # 30720.2 [[1,"abstuveSTUV", function(a,b,s,t,u,v,e,S,T,U,V) return [[a^2,b^3,(a*b)^5,s^2*S^-1,t^2*T^-1,u^2*U^(-1 *1),v^2*V^-1,e^2,s^-1*t^-1*s*t, u^-1*v^-1*u*v,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,S^2,T^2,U^2,V^2, S^-1*T^-1*S*T,S^-1*U^-1*S*U, S^-1*V^-1*S*V,T^-1*U^-1*T*U, T^-1*V^-1*T*V,U^-1*V^-1*U*V, a^-1*S*a*U^-1,a^-1*T*a*V^-1, a^-1*U*a*S^-1,a^-1*V*a*T^-1, b^-1*S*b*(T*V)^-1, b^-1*T*b*(S*T*U*V)^-1, b^-1*U*b*(U*V)^-1,b^-1*V*b*U^-1, s^-1*S*s*S^-1,s^-1*T*s*T^-1, s^-1*U*s*U^-1,s^-1*V*s*V^-1, t^-1*S*t*S^-1,t^-1*T*t*T^-1, t^-1*U*t*U^-1,t^-1*V*t*V^-1, u^-1*S*u*S^-1,u^-1*T*u*T^-1, u^-1*U*u*U^-1,u^-1*V*u*V^-1, v^-1*S*v*S^-1,v^-1*T*v*T^-1, v^-1*U*v*U^-1,v^-1*V*v*V^-1, e^-1*S*e*S^-1,e^-1*T*e*T^-1, e^-1*U*e*U^-1,e^-1*V*e*V^-1, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, b^-1*s*b*(t*v*e)^-1*U^-1*S^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1*(U*V)^-1, b^-1*v*b*u^-1,e^-1*a^-1*e*a, e^-1*b^-1*e*b*(U*V)^-1, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v], [[s,t,u,e]]]; end, [240]], "A5 ( 2^4 E 2^1 E 2^4 ) A",[1,9,2],1, 1,240], # 30720.3 [[1,"abstuveSTUV", function(a,b,s,t,u,v,e,S,T,U,V) return [[a^2*e^-1,b^3,(a*b)^5,s^2*S^-1,t^2*T^-1, u^2*U^-1,v^2*V^-1,e^2,s^-1*t^-1*s*t ,u^-1*v^-1*u*v,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,S^2,T^2,U^2,V^2, S^-1*T^-1*S*T,S^-1*U^-1*S*U, S^-1*V^-1*S*V,T^-1*U^-1*T*U, T^-1*V^-1*T*V,U^-1*V^-1*U*V, a^-1*S*a*U^-1,a^-1*T*a*V^-1, a^-1*U*a*S^-1,a^-1*V*a*T^-1, b^-1*S*b*(T*V)^-1, b^-1*T*b*(S*T*U*V)^-1, b^-1*U*b*(U*V)^-1,b^-1*V*b*U^-1, s^-1*S*s*S^-1,s^-1*T*s*T^-1, s^-1*U*s*U^-1,s^-1*V*s*V^-1, t^-1*S*t*S^-1,t^-1*T*t*T^-1, t^-1*U*t*U^-1,t^-1*V*t*V^-1, u^-1*S*u*S^-1,u^-1*T*u*T^-1, u^-1*U*u*U^-1,u^-1*V*u*V^-1, v^-1*S*v*S^-1,v^-1*T*v*T^-1, v^-1*U*v*U^-1,v^-1*V*v*V^-1, e^-1*S*e*S^-1,e^-1*T*e*T^-1, e^-1*U*e*U^-1,e^-1*V*e*V^-1, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, b^-1*s*b*(t*v*e)^-1*U^-1*S^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1*(U*V)^-1, b^-1*v*b*u^-1,e^-1*a^-1*e*a, e^-1*b^-1*e*b*(U*V)^-1, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v], [[s,t,u,e]]]; end, [240]], "A5 ( 2^4 E N 2^1 E 2^4 ) A",[1,9,3],1, 1,240], # 30720.4 [[1,"abdstuvSTUV", function(a,b,d,s,t,u,v,S,T,U,V) return [[a^2*d^-1,b^3,(a*b)^5,d^2,b^-1*d*b*d^-1, s^2*S^-1,t^2*T^-1,u^2*U^-1, v^2*V^-1,S^2,T^2,U^2,V^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,d^-1*s*d*s, d^-1*t*d*t,d^-1*u*d*u,d^-1*v*d*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s,a^-1*v*a*t, b^-1*s*b*(t*v*T*U)^-1, b^-1*t*b*(s*t*u*v*T*U*V)^-1, b^-1*u*b*(u*v*U)^-1,b^-1*v*b*u], [[s,t,u,d]]]; end, [240]], "A5 2^1 ( 2^4 A 2^4 )",[1,9,4],1, 1,240], # 30720.5 [[1,"abstuvSTUVj", function(a,b,s,t,u,v,S,T,U,V,j) return [[a^2,b^3,(a*b)^5,j^2,j^-1*a^-1*j*a,j^-1 *b^-1*j*b,j^-1*s^-1*j*s, j^-1*t^-1*j*t,j^-1*u^-1*j*u, j^-1*v^-1*j*v,j^-1*S^-1*j*S, j^-1*T^-1*j*T,j^-1*U^-1*j*U, j^-1*V^-1*j*V,s^2,t^2,u^2,v^2,S^2,T^2,U^2, V^2,s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, S^-1*T^-1*S*T,S^-1*U^-1*S*U, S^-1*V^-1*S*V,T^-1*U^-1*T*U, T^-1*V^-1*T*V,U^-1*V^-1*U*V, s^-1*S^-1*s*S,s^-1*T^-1*s*T, s^-1*U^-1*s*U,s^-1*V^-1*s*V*j, t^-1*S^-1*t*S,t^-1*T^-1*t*T, t^-1*U^-1*t*U*j,t^-1*V^-1*t*V*j, u^-1*S^-1*u*S,u^-1*T^-1*u*T*j, u^-1*U^-1*u*U,u^-1*V^-1*u*V, v^-1*S^-1*v*S*j,v^-1*T^-1*v*T*j, v^-1*U^-1*v*U,v^-1*V^-1*v*V, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, a^-1*S*a*U^-1,a^-1*T*a*V^-1, a^-1*U*a*S^-1,a^-1*V*a*T^-1, b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*S*b*(T*V)^-1, b^-1*T*b*(S*T*U*V)^-1, b^-1*U*b*(U*V)^-1,b^-1*V*b*U^-1], [[a,b,s]]]; end, [32]], "A5 ( 2^4 x 2^4 ) C 2^1",[1,9,5],2, 1,32], # 30720.6 [[1,"abstuvSTUVd", function(a,b,s,t,u,v,S,T,U,V,d) return [[a^2*d^-1,b^3,(a*b)^5,d^2,d^-1*a^-1*d*a, d^-1*b^-1*d*b,d^-1*s^-1*d*s, d^-1*t^-1*d*t,d^-1*u^-1*d*u, d^-1*v^-1*d*v,d^-1*S^-1*d*S, d^-1*T^-1*d*T,d^-1*U^-1*d*U, d^-1*V^-1*d*V,s^2,t^2,u^2,v^2,S^2,T^2,U^2, V^2,s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, S^-1*T^-1*S*T,S^-1*U^-1*S*U, S^-1*V^-1*S*V,T^-1*U^-1*T*U, T^-1*V^-1*T*V,U^-1*V^-1*U*V, s^-1*S^-1*s*S,s^-1*T^-1*s*T, s^-1*U^-1*s*U,s^-1*V^-1*s*V*d, t^-1*S^-1*t*S,t^-1*T^-1*t*T, t^-1*U^-1*t*U*d,t^-1*V^-1*t*V*d, u^-1*S^-1*u*S,u^-1*T^-1*u*T*d, u^-1*U^-1*u*U,u^-1*V^-1*u*V, v^-1*S^-1*v*S*d,v^-1*T^-1*v*T*d, v^-1*U^-1*v*U,v^-1*V^-1*v*V, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, a^-1*S*a*U^-1,a^-1*T*a*V^-1, a^-1*U*a*S^-1,a^-1*V*a*T^-1, b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*S*b*(T*V)^-1, b^-1*T*b*(S*T*U*V)^-1, b^-1*U*b*(U*V)^-1,b^-1*V*b*U^-1], [[a*b,s]]]; end, [384]], "A5 ( 2^4 x 2^4 ) C N 2^1",[1,9,6],2, 1,384], # 30720.7 [[1,"abstuvSTUVg", function(a,b,s,t,u,v,S,T,U,V,g) return [[a^2,b^3,(a*b)^5,g^2,g^-1*a^-1*g*a,g^-1 *b^-1*g*b,g^-1*s^-1*g*s, g^-1*t^-1*g*t,g^-1*u^-1*g*u, g^-1*v^-1*g*v,g^-1*S^-1*g*S, g^-1*T^-1*g*T,g^-1*U^-1*g*U, g^-1*V^-1*g*V,s^2,t^2,u^2,v^2,S^2,T^2,U^2, V^2,s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, S^-1*T^-1*S*T,S^-1*U^-1*S*U, S^-1*V^-1*S*V,T^-1*U^-1*T*U, T^-1*V^-1*T*V,U^-1*V^-1*U*V, s^-1*S^-1*s*S,s^-1*T^-1*s*T, s^-1*U^-1*s*U,s^-1*V^-1*s*V, t^-1*S^-1*t*S,t^-1*T^-1*t*T, t^-1*U^-1*t*U,t^-1*V^-1*t*V, u^-1*S^-1*u*S,u^-1*T^-1*u*T, u^-1*U^-1*u*U,u^-1*V^-1*u*V, v^-1*S^-1*v*S,v^-1*T^-1*v*T, v^-1*U^-1*v*U,v^-1*V^-1*v*V, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, a^-1*S*a*U^-1,a^-1*T*a*V^-1, a^-1*U*a*S^-1,a^-1*V*a*T^-1, b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*S*b*(T*V*g)^-1, b^-1*T*b*(S*T*U*V)^-1, b^-1*U*b*(U*V)^-1,b^-1*V*b*U^-1], [[a,b,S],[a*b,b*a*b*a*b^-1*a*b^-1,S,s]]]; end, [16,12]], "A5 2^4 x ( 2^4 E 2^1 )",[1,9,7],2, 1,[16,12]], # 30720.8 [[1,"abstuvSTUVd", function(a,b,s,t,u,v,S,T,U,V,d) return [[a^2*d^-1,b^3,(a*b)^5,d^2,d^-1*a^-1*d*a, d^-1*b^-1*d*b,d^-1*s^-1*d*s, d^-1*t^-1*d*t,d^-1*u^-1*d*u, d^-1*v^-1*d*v,d^-1*S^-1*d*S, d^-1*T^-1*d*T,d^-1*U^-1*d*U, d^-1*V^-1*d*V,s^2,t^2,u^2,v^2,S^2,T^2,U^2, V^2,s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, S^-1*T^-1*S*T,S^-1*U^-1*S*U, S^-1*V^-1*S*V,T^-1*U^-1*T*U, T^-1*V^-1*T*V,U^-1*V^-1*U*V, s^-1*S^-1*s*S,s^-1*T^-1*s*T, s^-1*U^-1*s*U,s^-1*V^-1*s*V, t^-1*S^-1*t*S,t^-1*T^-1*t*T, t^-1*U^-1*t*U,t^-1*V^-1*t*V, u^-1*S^-1*u*S,u^-1*T^-1*u*T, u^-1*U^-1*u*U,u^-1*V^-1*u*V, v^-1*S^-1*v*S,v^-1*T^-1*v*T, v^-1*U^-1*v*U,v^-1*V^-1*v*V, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, a^-1*S*a*U^-1,a^-1*T*a*V^-1, a^-1*U*a*S^-1,a^-1*V*a*T^-1, b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*S*b*(T*V*d)^-1, b^-1*T*b*(S*T*U*V)^-1, b^-1*U*b*(U*V)^-1,b^-1*V*b*U^-1], [[a,b,S],[a*b,S,s]]]; end, [16,24]], "A5 2^4 x ( 2^4 E N 2^1 )",[1,9,8],2, 1,[16,24]], # 30720.9 [[1,"abdstuvSTUV", function(a,b,d,s,t,u,v,S,T,U,V) return [[a^2*d^-1,b^3,(a*b)^5,d^2,d^-1*b^-1*d*b, d^-1*a^-1*d*a,d^-1*s^-1*d*s, d^-1*t^-1*d*t,d^-1*u^-1*d*u, d^-1*v^-1*d*v,d^-1*S^-1*d*S, d^-1*T^-1*d*T,d^-1*U^-1*d*U, d^-1*V^-1*d*V,s^2,t^2,u^2,v^2, s^-1*t^-1*s*t,u^-1*v^-1*u*v, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, S^2,T^2,U^2,V^2,S^-1*T^-1*S*T, S^-1*U^-1*S*U,S^-1*V^-1*S*V, T^-1*U^-1*T*U,T^-1*V^-1*T*V, U^-1*V^-1*U*V,a^-1*S*a*U^-1, a^-1*T*a*V^-1,a^-1*U*a*S^-1, a^-1*V*a*T^-1,b^-1*S*b*(T*V)^-1, b^-1*T*b*(S*T*U*V)^-1, b^-1*U*b*(U*V)^-1,b^-1*V*b*U^-1, s^-1*S*s*S^-1,s^-1*T*s*T^-1, s^-1*U*s*U^-1,s^-1*V*s*V^-1, t^-1*S*t*S^-1,t^-1*T*t*T^-1, t^-1*U*t*U^-1,t^-1*V*t*V^-1, u^-1*S*u*S^-1,u^-1*T*u*T^-1, u^-1*U*u*U^-1,u^-1*V*u*V^-1, v^-1*S*v*S^-1,v^-1*T*v*T^-1, v^-1*U*v*U^-1,v^-1*V*v*V^-1], [[a,b,S],[a,b,s],[a*b,s,S]]]; end, [16,16,24]], "A5 2^1 x 2^4 x 2^4",[1,9,9],2, 1,[16,16,24]], # 30720.10 [[1,"abdstuvSTUV", function(a,b,d,s,t,u,v,S,T,U,V) return [[a^2*d^-1,b^3,(a*b)^5,d^2,b^-1*d*b*(d*U*V) ^-1,d^-1*a^-1*d*a,d^-1*s^-1*d *s,d^-1*t^-1*d*t,d^-1*u^-1*d*u, d^-1*v^-1*d*v,d^-1*S^-1*d*S, d^-1*T^-1*d*T,d^-1*U^-1*d*U, d^-1*V^-1*d*V,s^2,t^2,u^2,v^2, s^-1*t^-1*s*t,u^-1*v^-1*u*v, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, S^2,T^2,U^2,V^2,S^-1*T^-1*S*T, S^-1*U^-1*S*U,S^-1*V^-1*S*V, T^-1*U^-1*T*U,T^-1*V^-1*T*V, U^-1*V^-1*U*V,a^-1*S*a*U^-1, a^-1*T*a*V^-1,a^-1*U*a*S^-1, a^-1*V*a*T^-1,b^-1*S*b*(T*V)^-1, b^-1*T*b*(S*T*U*V)^-1, b^-1*U*b*(U*V)^-1,b^-1*V*b*U^-1, s^-1*S*s*S^-1,s^-1*T*s*T^-1, s^-1*U*s*U^-1,s^-1*V*s*V^-1, t^-1*S*t*S^-1,t^-1*T*t*T^-1, t^-1*U*t*U^-1,t^-1*V*t*V^-1, u^-1*S*u*S^-1,u^-1*T*u*T^-1, u^-1*U*u*U^-1,u^-1*V*u*V^-1, v^-1*S*v*S^-1,v^-1*T*v*T^-1, v^-1*U*v*U^-1,v^-1*V*v*V^-1], [[a,b,S],[b,d,s,u]]]; end, [16,80]], "A5 2^4 x ( 2^1 E 2^4 )",[1,9,10],1, 1,[16,80]], # 30720.11 [[1,"abdstuvSTUV", function(a,b,d,s,t,u,v,S,T,U,V) return [[a^2*d^-1,b^3,(a*b)^5,d^2,b^-1*d*b*(d*u*v*T *U)^-1,s^2*S^-1,t^2*T^-1, u^2*U^-1,v^2*V^-1,S^2,T^2,U^2,V^2, s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, d^-1*s*d*s,d^-1*t*d*t,d^-1*u*d*u, d^-1*v*d*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s, a^-1*v*a*t,b^-1*s*b*(t*v*T*U)^-1, b^-1*t*b*(s*t*u*v*T*U*V)^-1, b^-1*u*b*(u*v*U)^-1,b^-1*v*b*u], [[s,t,u,d]]]; end, [240]], "A5 2^1 E 2^4 A 2^4",[1,9,11],1, 1,240], # 30720.12 [[1,"abstuvewxyz", function(a,b,s,t,u,v,e,w,x,y,z) return [[a^2,b^3,(a*b)^5,e^2,e^-1*a^-1*e*a,e^-1 *b^-1*e*b,e^-1*s^-1*e*s, e^-1*t^-1*e*t,e^-1*u^-1*e*u, e^-1*v^-1*e*v,e^-1*w^-1*e*w, e^-1*x^-1*e*x,e^-1*y^-1*e*y, e^-1*z^-1*e*z,w^2,w*s^-1*w*s, w*t^-1*w*t,w*u^-1*w*u,w*v^-1*w*v, s^2*w,t^2*w,u^2*z,v^2*z,s^-1*t^-1*s*t*w, s^-1*u^-1*s*u*w*x*z, s^-1*v^-1*s*v*x*y, t^-1*u^-1*t*u*w*y*z, t^-1*v^-1*t*v*w*x*z,u^-1*v^-1*u*v *z,a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, a^-1*w*a*z,a^-1*x*a*x,a^-1*y*a*w*x*y *z,a^-1*z*a*w,b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v*y*z)^-1, b^-1*u*b*(u*v*w*x*y)^-1, b^-1*v*b*u^-1,b^-1*w*b*x, b^-1*x*b*y,b^-1*y*b*w,b^-1*z*b*z], [[b,a*b*a*b^-1*a,v*w,w*x,e], [a*b,b*a*b*a*b^-1*a*b^-1,s,w]]]; end, [40,12]], "A5 2^4 ( E 2^1 x C 2^4' )",[1,9,12],2, 1,[40,12]], # 30720.13 [[1,"abstuvewxyz", function(a,b,s,t,u,v,e,w,x,y,z) return [[a^2*e^-1,b^3,(a*b)^5,e^2,e^-1*a^-1*e*a, e^-1*b^-1*e*b,e^-1*s^-1*e*s, e^-1*t^-1*e*t,e^-1*u^-1*e*u, e^-1*v^-1*e*v,e^-1*w^-1*e*w, e^-1*x^-1*e*x,e^-1*y^-1*e*y, e^-1*z^-1*e*z,w^2,w*s^-1*w*s, w*t^-1*w*t,w*u^-1*w*u,w*v^-1*w*v, s^2*w,t^2*w,u^2*z,v^2*z,s^-1*t^-1*s*t*w, s^-1*u^-1*s*u*w*x*z, s^-1*v^-1*s*v*x*y, t^-1*u^-1*t*u*w*y*z, t^-1*v^-1*t*v*w*x*z,u^-1*v^-1*u*v *z,a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, a^-1*w*a*z,a^-1*x*a*x,a^-1*y*a*w*x*y *z,a^-1*z*a*w,b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v*y*z)^-1, b^-1*u*b*(u*v*w*x*y)^-1, b^-1*v*b*u^-1,b^-1*w*b*x, b^-1*x*b*y,b^-1*y*b*w,b^-1*z*b*z], [[b,a*b*a*b^-1*a,v*w,w*x,e],[a*b,s]]]; end, [40,24]], "A5 2^4 ( E N 2^1 x C 2^4' )",[1,9,13],2, 1,[40,24]], # 30720.14 [[1,"abdstuvwxyz", function(a,b,d,s,t,u,v,w,x,y,z) return [[a^2*d^-1,b^3,(a*b)^5,d^2,d^-1*b^-1*d*b, d^-1*a^-1*d*a,d^-1*s^-1*d*s, d^-1*t^-1*d*t,d^-1*u^-1*d*u, d^-1*v^-1*d*v,d^-1*w^-1*d*w, d^-1*x^-1*d*x,d^-1*y^-1*d*y, d^-1*z^-1*d*z,w^2,w*s^-1*w*s, w*t^-1*w*t,w*u^-1*w*u,w*v^-1*w*v, s^2*w,t^2*w,u^2*z,v^2*z,s^-1*t^-1*s*t*w, s^-1*u^-1*s*u*w*x*z, s^-1*v^-1*s*v*x*y, t^-1*u^-1*t*u*w*y*z, t^-1*v^-1*t*v*w*x*z,u^-1*v^-1*u*v *z,a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, a^-1*w*a*z,a^-1*x*a*x,a^-1*y*a*w*x*y *z,a^-1*z*a*w,b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v*y*z)^-1, b^-1*u*b*(u*v*w*x*y)^-1, b^-1*v*b*u^-1,b^-1*w*b*x, b^-1*x*b*y,b^-1*y*b*w,b^-1*z*b*z], [[b,a*b*a*b^-1*a,v*w,w*x],[a*b,s,w]]]; end, [40,24]], "A5 2^1 x ( 2^4 C 2^4' )",[1,9,14],2, 1,[40,24]], # 30720.15 [[1,"abstuvewxyz", function(a,b,s,t,u,v,e,w,x,y,z) return [[a^2,b^3,(a*b)^5,e^2,e^-1*a^-1*e*a,e^-1 *b^-1*e*b,e^-1*s^-1*e*s, e^-1*t^-1*e*t,e^-1*u^-1*e*u, e^-1*v^-1*e*v,e^-1*w^-1*e*w, e^-1*x^-1*e*x,e^-1*y^-1*e*y, e^-1*z^-1*e*z,w^2,w^-1*s^-1*w*s, w^-1*t^-1*w*t,w^-1*u^-1*w*u, w^-1*v^-1*w*v,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,y^-1*z^-1*y*z, x^-1*z^-1*x*z,s^2,t^2,u^2,v^2, s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, a^-1*w*a*z,a^-1*x*a*x,a^-1*y*a*w*x*y *z,a^-1*z*a*w,b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*x,b^-1*x*b*y,b^-1*y*b*w, b^-1*z*b*z], [[b,a*b*a*b^-1*a,w*x,s],[a*b,b*a*b*a*b^-1*a *b^-1,s,w]]]; end, [10,12]], "A5 ( 2^4 E 2^1 ) x 2^4'",[1,9,15],2, 1,[10,12]], # 30720.16 [[1,"abstuvewxyz", function(a,b,s,t,u,v,e,w,x,y,z) return [[a^2*e^-1,b^3,(a*b)^5,e^2,e^-1*a^-1*e*a, e^-1*b^-1*e*b,e^-1*s^-1*e*s, e^-1*t^-1*e*t,e^-1*u^-1*e*u, e^-1*v^-1*e*v,e^-1*w^-1*e*w, e^-1*x^-1*e*x,e^-1*y^-1*e*y, e^-1*z^-1*e*z,w^2,w^-1*s^-1*w*s, w^-1*t^-1*w*t,w^-1*u^-1*w*u, w^-1*v^-1*w*v,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,y^-1*z^-1*y*z, x^-1*z^-1*x*z,s^2,t^2,u^2,v^2, s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, a^-1*w*a*z,a^-1*x*a*x,a^-1*y*a*w*x*y *z,a^-1*z*a*w,b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*x,b^-1*x*b*y,b^-1*y*b*w, b^-1*z*b*z], [[b,a*b*a*b^-1*a,w*x,s],[a*b,s,w]]]; end, [10,24]], "A5 ( 2^4 E N 2^1 ) x 2^4'",[1,9,16],2, 1,[10,24]], # 30720.17 [[1,"abstuvewxyz", function(a,b,s,t,u,v,e,w,x,y,z) return [[a^2,b^3,(a*b)^5,e^2,e^-1*a^-1*e*a,e^-1 *b^-1*e*b,e^-1*s^-1*e*s, e^-1*t^-1*e*t,e^-1*u^-1*e*u, e^-1*v^-1*e*v,e^-1*w^-1*e*w, e^-1*x^-1*e*x,e^-1*y^-1*e*y, e^-1*z^-1*e*z,w^2,w^-1*s^-1*w*s, w^-1*t^-1*w*t,w^-1*u^-1*w*u, w^-1*v^-1*w*v,w^-1*x^-1*w*x *e^-1,w^-1*y^-1*w*y*e^-1, w^-1*z^-1*w*z*e^-1, x^-1*y^-1*x*y*e^-1, x^-1*z^-1*x*z*e^-1, y^-1*z^-1*y*z*e^-1,s^2,t^2,u^2,v^2, s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, a^-1*w*a*z,a^-1*x*a*x,a^-1*y*a*w*x*y *z,a^-1*z*a*w,b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*x,b^-1*x*b*y,b^-1*y*b*w, b^-1*z*b*z],[[a*b,s]]]; end, [384]], "A5 ( 2^4 E x 2^4' C ) 2^1",[1,9,17],2, 1,384], # 30720.18 [[1,"abdstuvwxyz", function(a,b,d,s,t,u,v,w,x,y,z) return [[a^2*d^-1,b^3,(a*b)^5,d^2,d^-1*b^-1*d*b, d^-1*a^-1*d*a,d^-1*s^-1*d*s, d^-1*t^-1*d*t,d^-1*u^-1*d*u, d^-1*v^-1*d*v,d^-1*w^-1*d*w, d^-1*x^-1*d*x,d^-1*y^-1*d*y, d^-1*z^-1*d*z,w^2,w^-1*s^-1*w*s, w^-1*t^-1*w*t,w^-1*u^-1*w*u, w^-1*v^-1*w*v,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,y^-1*z^-1*y*z, x^-1*z^-1*x*z,s^2,t^2,u^2,v^2, s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, a^-1*w*a*z,a^-1*x*a*x,a^-1*y*a*w*x*y *z,a^-1*z*a*w,b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*x,b^-1*x*b*y,b^-1*y*b*w, b^-1*z*b*z], [[b,a*b*a*b^-1*a,w*x,s],[a,b,w],[a*b,s,w]]]; end, [10,16,24]], "A5 2^1 x 2^4 x 2^4'",[1,9,18],2, 1,[10,16,24]], # 30720.19 [[1,"abstuvewxyz", function(a,b,s,t,u,v,e,w,x,y,z) return [[a^2*e^-1,b^3,(a*b)^5,e^2,e^-1*a^-1*e*a, e^-1*b^-1*e*b,e^-1*s^-1*e*s, e^-1*t^-1*e*t,e^-1*u^-1*e*u, e^-1*v^-1*e*v,e^-1*w^-1*e*w, e^-1*x^-1*e*x,e^-1*y^-1*e*y, e^-1*z^-1*e*z,w^2,w^-1*s^-1*w*s, w^-1*t^-1*w*t,w^-1*u^-1*w*u, w^-1*v^-1*w*v,w^-1*x^-1*w*x *e^-1,w^-1*y^-1*w*y*e^-1, w^-1*z^-1*w*z*e^-1, x^-1*y^-1*x*y*e^-1, x^-1*z^-1*x*z*e^-1, y^-1*z^-1*y*z*e^-1,s^2,t^2,u^2,v^2, s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, a^-1*w*a*z,a^-1*x*a*x,a^-1*y*a*w*x*y *z,a^-1*z*a*w,b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*x,b^-1*x*b*y,b^-1*y*b*w, b^-1*z*b*z],[[a*b,s]]]; end, [384]], "A5 ( 2^4 E x 2^4' C ) N 2^1",[1,9,19],2, 1,384], # 30720.20 [[1,"abstuvwxyzg", function(a,b,s,t,u,v,w,x,y,z,g) return [[a^2*g^-1,b^3,(a*b)^5,g^2,g^-1*a^-1*g*a, g^-1*b^-1*g*b,g^-1*s^-1*g*s, g^-1*t^-1*g*t,g^-1*u^-1*g*u, g^-1*v^-1*g*v,g^-1*w^-1*g*w, g^-1*x^-1*g*x,g^-1*y^-1*g*y, g^-1*z^-1*g*z,w^2,w^-1*s^-1*w*s, w^-1*t^-1*w*t,w^-1*u^-1*w*u, w^-1*v^-1*w*v,w^-1*x^-1*w*x *g^-1,w^-1*y^-1*w*y*g^-1, w^-1*z^-1*w*z*g^-1, x^-1*y^-1*x*y*g^-1, x^-1*z^-1*x*z*g^-1, y^-1*z^-1*y*z*g^-1,s^2,t^2,u^2,v^2, s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, a^-1*w*a*z,a^-1*x*a*x,a^-1*y*a*w*x*y *z,a^-1*z*a*w,b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*x,b^-1*x*b*y,b^-1*y*b*w, b^-1*z*b*z], [[a,b,w],[b,a*b*a*b^-1*a^-1*w*x,s]]]; end, [16,80]], "A5 2^4 x ( 2^4' C N 2^1 )",[1,9,20],2, 1,[16,80]], # 30720.21 [[1,"abstuvwxyzg", function(a,b,s,t,u,v,w,x,y,z,g) return [[a^2,b^3,(a*b)^5,g^2,g^-1*a^-1*g*a,g^-1 *b^-1*g*b,g^-1*s^-1*g*s, g^-1*t^-1*g*t,g^-1*u^-1*g*u, g^-1*v^-1*g*v,g^-1*w^-1*g*w, g^-1*x^-1*g*x,g^-1*y^-1*g*y, g^-1*z^-1*g*z,w^2,w^-1*s^-1*w*s, w^-1*t^-1*w*t,w^-1*u^-1*w*u, w^-1*v^-1*w*v,w^-1*x^-1*w*x *g^-1,w^-1*y^-1*w*y*g^-1, w^-1*z^-1*w*z*g^-1, x^-1*y^-1*x*y*g^-1, x^-1*z^-1*x*z*g^-1, y^-1*z^-1*y*z*g^-1,s^2,t^2,u^2,v^2, s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, a^-1*w*a*z,a^-1*x*a*x,a^-1*y*a*w*x*y *z,a^-1*z*a*w,b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*x,b^-1*x*b*y,b^-1*y*b*w, b^-1*z*b*z],[[a,b,w],[a,b,s]]]; end, [16,32]], "A5 2^4 x ( 2^4' C 2^1 )",[1,9,21],2, 1,[16,32]], # 30720.22 [[1,"abdstuvwxyz", function(a,b,d,s,t,u,v,w,x,y,z) return [[a^2*d^-1,b^3,(a*b)^5,d^2*w*z,b^-1*d*b*(d*u *v*y)^-1,d^-1*a^-1*d*a, d^-1*s^-1*d*s*x*y, d^-1*t^-1*d*t*w*y*z, d^-1*u^-1*d*u*w*y*z, d^-1*v^-1*d*v*x*y,d^-1*w^-1*d*w, d^-1*x^-1*d*x,d^-1*y^-1*d*y, d^-1*z^-1*d*z,w^2,w^-1*s^-1*w*s, w^-1*t^-1*w*t,w^-1*u^-1*w*u, w^-1*v^-1*w*v,s^2*w,t^2*w,u^2*z,v^2*z, s^-1*t^-1*s*t*w,s^-1*u^-1*s*u*w*x *z,s^-1*v^-1*s*v*x*y, t^-1*u^-1*t*u*w*y*z, t^-1*v^-1*t*v*w*x*z,u^-1*v^-1*u*v *z,a^-1*s*a*(u*x)^-1, a^-1*t*a*(v*x*z)^-1, a^-1*u*a*(s*y)^-1, a^-1*v*a*(t*x*y*z)^-1,a^-1*w*a*z, a^-1*x*a*x,a^-1*y*a*w*x*y*z, a^-1*z*a*w,b^-1*s*b*(t*v*x)^-1, b^-1*t*b*(s*t*u*v*x*z)^-1, b^-1*u*b*(u*v*w*x*y)^-1, b^-1*v*b*(u*w*x*y)^-1,b^-1*w*b*x, b^-1*x*b*y,b^-1*y*b*w,b^-1*z*b*z], [[b,d*t]]]; end, [160]], "A5 2^1 E 2^4 C 2^4'",[1,9,22],1, 1,160], # 30720.23 [[1,"abdstuvwxyz", function(a,b,d,s,t,u,v,w,x,y,z) return [[a^2*d^-1,b^3,(a*b)^5,d^2,b^-1*d*b*(d*u*v) ^-1,d^-1*a^-1*d*a,d^-1*s^-1*d *s,d^-1*t^-1*d*t,d^-1*u^-1*d*u, d^-1*v^-1*d*v,d^-1*w^-1*d*w, d^-1*x^-1*d*x,d^-1*y^-1*d*y, d^-1*z^-1*d*z,w^2,w^-1*s^-1*w*s, w^-1*t^-1*w*t,w^-1*u^-1*w*u, w^-1*v^-1*w*v,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,y^-1*z^-1*y*z, x^-1*z^-1*x*z,s^2,t^2,u^2,v^2, s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, a^-1*w*a*z,a^-1*x*a*x,a^-1*y*a*w*x*y *z,a^-1*z*a*w,b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*x,b^-1*x*b*y,b^-1*y*b*w, b^-1*z*b*z], [[b,a*b*a*b^-1*a,w*x,s],[b,d,w,z]]]; end, [10,80]], "A5 ( 2^1 E 2^4 ) x 2^4'",[1,9,23],1, 1,[10,80]], # 30720.24 [[1,"abwxyzdstuv", function(a,b,w,x,y,z,d,s,t,u,v) return [[a^2*d^-1,b^3,(a*b)^5,v^2,(v*s)^2,(y*v)^2,(z*v)^2, (x*v)^2,(w*v)^2,a*d*a^-1*d,a*s*a^-1*u, a*v*a^-1*t,a*u*a^-1*s,a*v*a^-1*t, b^-1*d*b*d*u*v,b^-1*s*b*t*v, b^-1*t*b*s*t*u*v,b^-1*u*b*u*v, b^-1*v*b*u,z^2,y^2,x^2,w^2,(z*y)^2*d*u, (z*x)^2*d*u*v,(x*y)^2*d*s*v,(z*w)^2*d, (y*w)^2*d*t,(x*w)^2*d*s*t,b^-1*z*b*z*t*u, b^-1*y*b*w,b^-1*x*b*y,b^-1*w*b*x, a^-1*z*a*w,a^-1*y*a*(w*x*y*z*s)^-1, a^-1*w*a*z,a^-1*x*a*x],[[b,w]]]; end, [160]], "A5 2^4' C N 2^1 E 2^4",[1,9,24],1, 1,160], # 30720.25 [[1,"abwxyzdstuv", function(a,b,w,x,y,z,d,s,t,u,v) return [[a^2,b^3,(a*b)^5,v^2,(v*s)^2,(y*v)^2,(z*v)^2,(x*v)^2, (w*v)^2,a*d*a^-1*d,a*s*a^-1*u, a*v*a^-1*t,a*u*a^-1*s,a*v*a^-1*t, b^-1*d*b*d*u*v,b^-1*s*b*t*v, b^-1*t*b*s*t*u*v,b^-1*u*b*u*v, b^-1*v*b*u,z^2,y^2,x^2,w^2,(z*y)^2*d*u, (z*x)^2*d*u*v,(x*y)^2*d*s*v,(z*w)^2*d, (y*w)^2*d*t,(x*w)^2*d*s*t,b^-1*z*b*z*t*u, b^-1*y*b*w,b^-1*x*b*y,b^-1*w*b*x, a^-1*z*a*w,a^-1*y*a*(w*x*y*z*s)^-1, a^-1*w*a*z,a^-1*x*a*x],[[b,w]]]; end, [160]], "A5 2^4' C 2^1 E 2^4",[1,9,25],1, 1,160], # 30720.26 [[1,"abdwxyzWXYZ", function(a,b,d,w,x,y,z,W,X,Y,Z) return [[a^2*d^-1,b^3,(a*b)^5,d^2,d^-1*b^-1*d*b, d^-1*a^-1*d*a,d^-1*w^-1*d*w, d^-1*x^-1*d*x,d^-1*y^-1*d*y, d^-1*z^-1*d*z,d^-1*W^-1*d*W, d^-1*X^-1*d*X,d^-1*Y^-1*d*Y, d^-1*Z^-1*d*Z,w^2,x^2,y^2,z^2, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*x*y*z)^-1,a^-1*z*a*w^-1 ,b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1,W^2, X^2,Y^2,Z^2,W^-1*X^-1*W*X, W^-1*Y^-1*W*Y,W^-1*Z^-1*W*Z, X^-1*Y^-1*X*Y,X^-1*Z^-1*X*Z, Y^-1*Z^-1*Y*Z,a^-1*W*a*Z^-1, a^-1*X*a*X^-1,a^-1*Y*a*(W*X*Y*Z)^-1 ,a^-1*Z*a*W^-1,b^-1*W*b*X^-1, b^-1*X*b*Y^-1,b^-1*Y*b*W^-1, b^-1*Z*b*Z^-1,w^-1*W*w*W^-1, w^-1*X*w*X^-1,w^-1*Y*w*Y^-1, w^-1*Z*w*Z^-1,x^-1*W*x*W^-1, x^-1*X*x*X^-1,x^-1*Y*x*Y^-1, x^-1*Z*x*Z^-1,y^-1*W*y*W^-1, y^-1*X*y*X^-1,y^-1*Y*y*Y^-1, y^-1*Z*y*Z^-1,z^-1*W*z*W^-1, z^-1*X*z*X^-1,z^-1*Y*z*Y^-1, z^-1*Z*z*Z^-1], [[a*b*a*b^-1*a,b,w*x,W], [a*b*a*b^-1*a,b,W*X,w],[a*b,w,W]]]; end, [10,10,24]], "A5 2^1 x 2^4' x 2^4'",[1,9,26],2, 1,[10,10,24]], # 30720.27 [[1,"abdwxyzWXYZ", function(a,b,d,w,x,y,z,W,X,Y,Z) return [[a^2*d^-1,b^3,(a*b)^5,d^2,d^-1*a^-1*d*a, d^-1*b^-1*d*b,d^-1*w^-1*d*w, d^-1*x^-1*d*x,d^-1*y^-1*d*y, d^-1*z^-1*d*z,d^-1*W^-1*d*W, d^-1*X^-1*d*X,d^-1*Y^-1*d*Y, d^-1*Z^-1*d*Z,w^2,x^2,y^2,z^2, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*x*y*z)^-1,a^-1*z*a*w^-1 ,b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1,W^2, X^2,Y^2,Z^2,W^-1*X^-1*W*X*d, W^-1*Y^-1*W*Y*d,W^-1*Z^-1*W*Z*d, X^-1*Y^-1*X*Y*d,X^-1*Z^-1*X*Z*d, Y^-1*Z^-1*Y*Z*d,a^-1*W*a*Z^-1, a^-1*X*a*X^-1,a^-1*Y*a*(W*X*Y*Z)^-1 ,a^-1*Z*a*W^-1,b^-1*W*b*X^-1, b^-1*X*b*Y^-1,b^-1*Y*b*W^-1, b^-1*Z*b*Z^-1,w^-1*W*w*W^-1, w^-1*X*w*X^-1,w^-1*Y*w*Y^-1, w^-1*Z*w*Z^-1,x^-1*W*x*W^-1, x^-1*X*x*X^-1,x^-1*Y*x*Y^-1, x^-1*Z*x*Z^-1,y^-1*W*y*W^-1, y^-1*X*y*X^-1,y^-1*Y*y*Y^-1, y^-1*Z*y*Z^-1,z^-1*W*z*W^-1, z^-1*X*z*X^-1,z^-1*Y*z*Y^-1, z^-1*Z*z*Z^-1], [[a*b*a*b^-1*a,b,w*x,W], [b,a*b*a*b^-1*a^-1*W*X,w]]]; end, [10,80]], "A5 2^4' x ( 2^4' C N 2^1 )",[1,9,27],2, 1,[10,80]], # 30720.28 [[1,"abfwxyzWXYZ", function(a,b,f,w,x,y,z,W,X,Y,Z) return [[a^2,b^3,(a*b)^5,f^2,f^-1*a^-1*f*a,f^-1 *b^-1*f*b,f^-1*w^-1*f*w, f^-1*x^-1*f*x,f^-1*y^-1*f*y, f^-1*z^-1*f*z,f^-1*W^-1*f*W, f^-1*X^-1*f*X,f^-1*Y^-1*f*Y, f^-1*Z^-1*f*Z,w^2,x^2,y^2,z^2, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*x*y*z)^-1,a^-1*z*a*w^-1 ,b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1,W^2, X^2,Y^2,Z^2,W^-1*X^-1*W*X*f, W^-1*Y^-1*W*Y*f,W^-1*Z^-1*W*Z*f, X^-1*Y^-1*X*Y*f,X^-1*Z^-1*X*Z*f, Y^-1*Z^-1*Y*Z*f,a^-1*W*a*Z^-1, a^-1*X*a*X^-1,a^-1*Y*a*(W*X*Y*Z)^-1 ,a^-1*Z*a*W^-1,b^-1*W*b*X^-1, b^-1*X*b*Y^-1,b^-1*Y*b*W^-1, b^-1*Z*b*Z^-1,w^-1*W*w*W^-1, w^-1*X*w*X^-1,w^-1*Y*w*Y^-1, w^-1*Z*w*Z^-1,x^-1*W*x*W^-1, x^-1*X*x*X^-1,x^-1*Y*x*Y^-1, x^-1*Z*x*Z^-1,y^-1*W*y*W^-1, y^-1*X*y*X^-1,y^-1*Y*y*Y^-1, y^-1*Z*y*Z^-1,z^-1*W*z*W^-1, z^-1*X*z*X^-1,z^-1*Y*z*Y^-1, z^-1*Z*z*Z^-1], [[a*b*a*b^-1*a,b,w*x,W],[a,b,w]]]; end, [10,32]], "A5 2^4' x ( 2^4' C 2^1 )",[1,9,28],2, 1,[10,32]], # 30720.29 [[1,"abewxyzWXYZ", function(a,b,e,w,x,y,z,W,X,Y,Z) return [[a^2,b^3,(a*b)^5,e^2,e^-1*a^-1*e*a,e^-1 *b^-1*e*b,e^-1*w^-1*e*w, e^-1*x^-1*e*x,e^-1*y^-1*e*y, e^-1*z^-1*e*z,e^-1*W^-1*e*W, e^-1*X^-1*e*X,e^-1*Y^-1*e*Y, e^-1*Z^-1*e*Z,w^2,x^2,y^2,z^2, w^-1*x^-1*w*x*e,w^-1*y^-1*w*y*e, w^-1*z^-1*w*z*e,x^-1*y^-1*x*y*e, x^-1*z^-1*x*z*e,y^-1*z^-1*y*z*e, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*x*y*z)^-1,a^-1*z*a*w^-1 ,b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1,W^2, X^2,Y^2,Z^2,W^-1*X^-1*W*X*e, W^-1*Y^-1*W*Y*e,W^-1*Z^-1*W*Z*e, X^-1*Y^-1*X*Y*e,X^-1*Z^-1*X*Z*e, Y^-1*Z^-1*Y*Z*e,a^-1*W*a*Z^-1, a^-1*X*a*X^-1,a^-1*Y*a*(W*X*Y*Z)^-1 ,a^-1*Z*a*W^-1,b^-1*W*b*X^-1, b^-1*X*b*Y^-1,b^-1*Y*b*W^-1, b^-1*Z*b*Z^-1,w^-1*W*w*W^-1, w^-1*X*w*X^-1,w^-1*Y*w*Y^-1, w^-1*Z*w*Z^-1,x^-1*W*x*W^-1, x^-1*X*x*X^-1,x^-1*Y*x*Y^-1, x^-1*Z*x*Z^-1,y^-1*W*y*W^-1, y^-1*X*y*X^-1,y^-1*Y*y*Y^-1, y^-1*Z*y*Z^-1,z^-1*W*z*W^-1, z^-1*X*z*X^-1,z^-1*Y*z*Y^-1, z^-1*Z*z*Z^-1],[[a,b,w*W]]]; end, [32]], "A5 ( 2^4' C x 2^4' C ) 2^1",[1,9,29],2, 1,32], # 30720.30 [[1,"abewxyzWXYZ", function(a,b,e,w,x,y,z,W,X,Y,Z) return [[a^2*e^-1,b^3,(a*b)^5,e^2,e^-1*a^-1*e*a, e^-1*b^-1*e*b,e^-1*w^-1*e*w, e^-1*x^-1*e*x,e^-1*y^-1*e*y, e^-1*z^-1*e*z,e^-1*W^-1*e*W, e^-1*X^-1*e*X,e^-1*Y^-1*e*Y, e^-1*Z^-1*e*Z,w^2,x^2,y^2,z^2, w^-1*x^-1*w*x*e,w^-1*y^-1*w*y*e, w^-1*z^-1*w*z*e,x^-1*y^-1*x*y*e, x^-1*z^-1*x*z*e,y^-1*z^-1*y*z*e, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*x*y*z)^-1,a^-1*z*a*w^-1 ,b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1,W^2, X^2,Y^2,Z^2,W^-1*X^-1*W*X*e, W^-1*Y^-1*W*Y*e,W^-1*Z^-1*W*Z*e, X^-1*Y^-1*X*Y*e,X^-1*Z^-1*X*Z*e, Y^-1*Z^-1*Y*Z*e,a^-1*W*a*Z^-1, a^-1*X*a*X^-1,a^-1*Y*a*(W*X*Y*Z)^-1 ,a^-1*Z*a*W^-1,b^-1*W*b*X^-1, b^-1*X*b*Y^-1,b^-1*Y*b*W^-1, b^-1*Z*b*Z^-1,w^-1*W*w*W^-1, w^-1*X*w*X^-1,w^-1*Y*w*Y^-1, w^-1*Z*w*Z^-1,x^-1*W*x*W^-1, x^-1*X*x*X^-1,x^-1*Y*x*Y^-1, x^-1*Z*x*Z^-1,y^-1*W*y*W^-1, y^-1*X*y*X^-1,y^-1*Y*y*Y^-1, y^-1*Z*y*Z^-1,z^-1*W*z*W^-1, z^-1*X*z*X^-1,z^-1*Y*z*Y^-1, z^-1*Z*z*Z^-1],[[a*b,w*W]]]; end, [384]], "A5 ( 2^4' C x 2^4' C ) N 2^1",[1,9,30],2, 1,384], # 30720.31 [[1,"abgwxyzWXYZ", function(a,b,g,w,x,y,z,W,X,Y,Z) return [[a^2,b^3,(a*b)^5,g^2,g^-1*a^-1*g*a,g^-1 *b^-1*g*b,g^-1*w^-1*g*w, g^-1*x^-1*g*x,g^-1*y^-1*g*y, g^-1*z^-1*g*z,g^-1*W^-1*g*W, g^-1*X^-1*g*X,g^-1*Y^-1*g*Y, g^-1*Z^-1*g*Z,w^2,x^2,y^2,z^2, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*x*y*z)^-1,a^-1*z*a*w^-1 ,b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1,W^2, X^2,Y^2,Z^2,W^-1*X^-1*W*X, W^-1*Y^-1*W*Y,W^-1*Z^-1*W*Z, X^-1*Y^-1*X*Y,X^-1*Z^-1*X*Z, Y^-1*Z^-1*Y*Z,a^-1*W*a*Z^-1, a^-1*X*a*X^-1,a^-1*Y*a*(W*X*Y*Z)^-1 ,a^-1*Z*a*W^-1,b^-1*W*b*X^-1, b^-1*X*b*Y^-1,b^-1*Y*b*W^-1, b^-1*Z*b*Z^-1,w^-1*W*w*W^-1, w^-1*X*w*X^-1*g,w^-1*Y*w*Y^-1*g, w^-1*Z*w*Z^-1*g,x^-1*W*x*W^-1*g, x^-1*X*x*X^-1,x^-1*Y*x*Y^-1*g, x^-1*Z*x*Z^-1*g,y^-1*W*y*W^-1*g, y^-1*X*y*X^-1*g,y^-1*Y*y*Y^-1, y^-1*Z*y*Z^-1*g,z^-1*W*z*W^-1*g, z^-1*X*z*X^-1*g,z^-1*Y*z*Y^-1*g, z^-1*Z*z*Z^-1],[[a,b,w]]]; end, [32]], "A5 ( 2^4' x 2^4' ) C 2^1",[1,9,31],2, 1,32], # 30720.32 [[1,"abgwxyzWXYZ", function(a,b,g,w,x,y,z,W,X,Y,Z) return [[a^2*g^-1,b^3,(a*b)^5,g^2,g^-1*a^-1*g*a, g^-1*b^-1*g*b,g^-1*w^-1*g*w, g^-1*x^-1*g*x,g^-1*y^-1*g*y, g^-1*z^-1*g*z,g^-1*W^-1*g*W, g^-1*X^-1*g*X,g^-1*Y^-1*g*Y, g^-1*Z^-1*g*Z,w^2,x^2,y^2,z^2, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*x*y*z)^-1,a^-1*z*a*w^-1 ,b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1,W^2, X^2,Y^2,Z^2,W^-1*X^-1*W*X, W^-1*Y^-1*W*Y,W^-1*Z^-1*W*Z, X^-1*Y^-1*X*Y,X^-1*Z^-1*X*Z, Y^-1*Z^-1*Y*Z,a^-1*W*a*Z^-1, a^-1*X*a*X^-1,a^-1*Y*a*(W*X*Y*Z)^-1 ,a^-1*Z*a*W^-1,b^-1*W*b*X^-1, b^-1*X*b*Y^-1,b^-1*Y*b*W^-1, b^-1*Z*b*Z^-1,w^-1*W*w*W^-1, w^-1*X*w*X^-1*g,w^-1*Y*w*Y^-1*g, w^-1*Z*w*Z^-1*g,x^-1*W*x*W^-1*g, x^-1*X*x*X^-1,x^-1*Y*x*Y^-1*g, x^-1*Z*x*Z^-1*g,y^-1*W*y*W^-1*g, y^-1*X*y*X^-1*g,y^-1*Y*y*Y^-1, y^-1*Z*y*Z^-1*g,z^-1*W*z*W^-1*g, z^-1*X*z*X^-1*g,z^-1*Y*z*Y^-1*g, z^-1*Z*z*Z^-1],[[a*b,w]]]; end, [384]], "A5 ( 2^4' x 2^4' ) C N 2^1",[1,9,32],2, 1,384], # 30720.33 [[1,"abdwxyzWXYZ", function(a,b,d,w,x,y,z,W,X,Y,Z) return [[a^2*d^-1,b^3,(a*b)^5,d^2,d^-1*b^-1*d*b, d^-1*a^-1*d*a,d^-1*w^-1*d*w, d^-1*x^-1*d*x,d^-1*y^-1*d*y, d^-1*z^-1*d*z,w^2*W^-1,x^2*X^-1, y^2*Y^-1,z^2*Z^-1,W^2,X^2,Y^2,Z^2, w*x*w^-1*x^-1,w*y*w^-1*y^-1, w*z*w^-1*z^-1,x*y*x^-1*y^-1, x*z*x^-1*z^-1,y*z*y^-1*z^-1, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*x*y*z*W*X*Y*Z)^-1, a^-1*z*a*w^-1,b^-1*w*b*x^-1, b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1], [[a*b,w],[a*b*a*b^-1*a,b,w*x^-1]]]; end, [24,20]], "A5 2^1 x ( 2^4' A 2^4' )",[1,9,33],2, 1,[24,20]], # 30720.34 [[1,"abdwxyzWXYZ", function(a,b,d,w,x,y,z,W,X,Y,Z) return [[a^2*d,b^3,(a*b)^5,d^2,d^-1*a^-1*d*a,d^-1 *b^-1*d*b,d^-1*w^-1*d*w, d^-1*x^-1*d*x,d^-1*y^-1*d*y, d^-1*z^-1*d*z,w^2*W^-1,x^2*X^-1, y^2*Y^-1,z^2*Z^-1,W^2,X^2,Y^2,Z^2, w*x*w^-1*x^-1*d,w*y*w^-1*y^-1*d, w*z*w^-1*z^-1*d,x*y*x^-1*y^-1*d, x*z*x^-1*z^-1*d,y*z*y^-1*z^-1*d, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*x*y*z*W*X*Y*Z)^-1, a^-1*z*a*w^-1,b^-1*w*b*x^-1, b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1], [[b,a*b*a*b^-1*a^-1*w*x], [a*b*a*b^-1*a,b,w*x^-1]]]; end, [80,20]], "A5 ( 2^4' C N 2^1 ) A 2^4'",[1,9,34],2, 1,[80,20]], # 30720.35 [[1,"abdwxyzWXYZ", function(a,b,d,w,x,y,z,W,X,Y,Z) return [[a^2,b^3,(a*b)^5,d^2,d^-1*a^-1*d*a,d^-1 *b^-1*d*b,d^-1*w^-1*d*w, d^-1*x^-1*d*x,d^-1*y^-1*d*y, d^-1*z^-1*d*z,w^2*W^-1,x^2*X^-1, y^2*Y^-1,z^2*Z^-1,W^2,X^2,Y^2,Z^2, w*x*w^-1*x^-1*d,w*y*w^-1*y^-1*d, w*z*w^-1*z^-1*d,x*y*x^-1*y^-1*d, x*z*x^-1*z^-1*d,y*z*y^-1*z^-1*d, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*x*y*z*W*X*Y*Z)^-1, a^-1*z*a*w^-1,b^-1*w*b*x^-1, b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1], [[a,b,W],[a*b*a*b^-1*a,b,w*x^-1]]]; end, [32,20]], "A5 ( 2^4' C 2^1 ) A 2^4'",[1,9,35],2, 1,[32,20]], # 30720.36 [[1,"abdwxyzWXYZ", function(a,b,d,w,x,y,z,W,X,Y,Z) return [[a^2*d,b^3,(a*b)^5,d^2,b^-1*d^-1*b*d,w^2*W ^-1,x^2*X^-1,y^2*Y^-1,z^2*Z^-1, w*x*w^-1*x^-1,w*y*w^-1*y^-1, w*z*w^-1*z^-1,x*y*x^-1*y^-1, x*z*x^-1*z^-1,y*z*y^-1*z^-1, a^-1*w*a*(z*Z)^-1, a^-1*x*a*(x*W*X*Y)^-1, a^-1*y*a*(w*x*y*z*W*Z)^-1, a^-1*z*a*w^-1,b^-1*w*b*x^-1, b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1,d^-1*w*d*w, d^-1*x*d*x,d^-1*y*d*y,d^-1*z*d*z], [[b,d,w]]]; end, [80]], "A5 2^1 ( 2^4' A 2^4' )",[1,9,36],1, 1,80], # 30720.37 [[1,"abdwxyzWXYZ", function(a,b,d,w,x,y,z,W,X,Y,Z) return [[a^2*d^-1,b^3,(a*b)^5,d^2,d^-1*b^-1*d*b, w^2,x^2,y^2,z^2,w*x*w*x,w*y*w*y,w*z*w*z, x*y*x*y,x*z*x*z,y*z*y*z,W^2,X^2,Y^2,Z^2, W*X*W*X,W*Y*W*Y,W*Z*W*Z,X*Y*X*Y,X*Z*X*Z, Y*Z*Y*Z,w*W*w*W,w*X*w*X,w*Y*w*Y,w*Z*w*Z, a^-1*w*a*z*Z,a^-1*x*a*x*W*X*Y, a^-1*y*a*w*x*y*z*X*Y,a^-1*z*a*w, b^-1*w*b*x,b^-1*x*b*y,b^-1*y*b*w, b^-1*z*b*z,a^-1*W*a*Z,a^-1*X*a*X, a^-1*Y*a*W*X*Y*Z,a^-1*Z*a*W, b^-1*W*b*X,b^-1*X*b*Y,b^-1*Y*b*W, b^-1*Z*b*Z],[[b,d,w]]]; end, [80]], "A5 2^1 ( 2^4' E 2^4' )",[1,9,37],1, 1,80] ]; ############################################################################# ## #E perf4.grp . . . . . . . . . . . . . . . . . . . . . . . . . ends here ## gap-4r6p5/grp/imf17.grp0000644000175000017500000013431712172557252013377 0ustar billbill############################################################################# ## #A imf17.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Z-class representative of the irreducible ## maximal finite integral matrix groups of dimension 17, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Z-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 17. ## IMFList[17].matrices := [ [ # Z-class [17][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]]]], [ # Z-class [17][02] [[2], [0,2], [1,0,2], [0,1,0,2], [0,0,1,0,2], [0,0,0,1,0,2], [0,0,0,0,1,0,2], [0,0,0,0,0,1,0,2], [0,0,0,0,0,0,1,0,2], [0,0,0,0,0,0,0,1,0,2], [0,0,0,0,0,0,0,0,1,0,2], [0,0,0,0,0,0,0,0,0,1,0,2], [0,0,0,0,0,0,0,0,0,0,1,0,2], [0,0,0,0,0,0,0,0,0,0,0,1,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,2], [1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,2], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0]], [[-1,-1,0,1,0,-1,0,1,0,-1,-1,1,1,-1,-1,1,1], [0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0], [0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0], [0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,-1,1,1,0,-1,0,1,0,-1,0,1,0,-1,0,1], [0,1,0,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1]]]], [ # Z-class [17][03] [[17], [-15,17], [13,-15,17], [-11,13,-15,17], [9,-11,13,-15,17], [-7,9,-11,13,-15,17], [5,-7,9,-11,13,-15,17], [-3,5,-7,9,-11,13,-15,17], [1,-3,5,-7,9,-11,13,-15,17], [1,1,-3,5,-7,9,-11,13,-15,17], [-3,1,1,-3,5,-7,9,-11,13,-15,17], [5,-3,1,1,-3,5,-7,9,-11,13,-15,17], [-7,5,-3,1,1,-3,5,-7,9,-11,13,-15,17], [9,-7,5,-3,1,1,-3,5,-7,9,-11,13,-15,17], [-11,9,-7,5,-3,1,1,-3,5,-7,9,-11,13,-15,17], [13,-11,9,-7,5,-3,1,1,-3,5,-7,9,-11,13,-15,17], [-15,13,-11,9,-7,5,-3,1,1,-3,5,-7,9,-11,13,-15,17]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,0], [0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0], [0,0,0,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,0], [0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,0,0], [0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,-1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,-1], [1,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1], [-1,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,-1], [1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1], [-1,0,0,0,0,0,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1], [1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1], [-1,0,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]]]], [ # Z-class [17][04] [[17], [-1,17], [-1,-1,17], [-1,-1,-1,17], [-1,-1,-1,-1,17], [-1,-1,-1,-1,-1,17], [-1,-1,-1,-1,-1,-1,17], [-1,-1,-1,-1,-1,-1,-1,17], [-1,-1,-1,-1,-1,-1,-1,-1,17], [-1,-1,-1,-1,-1,-1,-1,-1,-1,17], [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,17], [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,17], [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,17], [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,17], [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,17], [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,17], [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,17]], [[[0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Z-class [17][05] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]]]], [ # Z-class [17][06] [[16], [7,16], [-2,7,16], [-2,-2,7,16], [-2,-2,-2,7,16], [-2,-2,-2,-2,7,16], [-2,-2,-2,-2,-2,7,16], [-2,-2,-2,-2,-2,-2,7,16], [-2,-2,-2,-2,-2,-2,-2,7,16], [-2,-2,-2,-2,-2,-2,-2,-2,7,16], [-2,-2,-2,-2,-2,-2,-2,-2,-2,7,16], [-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,7,16], [-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,7,16], [-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,7,16], [-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,7,16], [-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,7,16], [7,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,7,16]], [[[0,-1,0,-1,0,-1,0,-1,0,-1,0,-1,0,-1,0,-1,0], [0,-1,0,-1,0,-1,0,-1,0,-1,0,-1,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1]]]], [ # Z-class [17][07] [[9], [7,9], [5,7,9], [3,5,7,9], [1,3,5,7,9], [-1,1,3,5,7,9], [-3,-1,1,3,5,7,9], [-5,-3,-1,1,3,5,7,9], [-7,-5,-3,-1,1,3,5,7,9], [-7,-7,-5,-3,-1,1,3,5,7,9], [-5,-7,-7,-5,-3,-1,1,3,5,7,9], [-3,-5,-7,-7,-5,-3,-1,1,3,5,7,9], [-1,-3,-5,-7,-7,-5,-3,-1,1,3,5,7,9], [1,-1,-3,-5,-7,-7,-5,-3,-1,1,3,5,7,9], [3,1,-1,-3,-5,-7,-7,-5,-3,-1,1,3,5,7,9], [5,3,1,-1,-3,-5,-7,-7,-5,-3,-1,1,3,5,7,9], [7,5,3,1,-1,-3,-5,-7,-7,-5,-3,-1,1,3,5,7,9]], [[[-1,0,-1,-1,0,1,1,1,-1,-1,0,-1,0,0,1,1,0], [-1,0,0,-1,0,1,1,0,-1,-1,0,0,0,0,1,1,-1], [-1,0,0,0,0,1,1,-1,-1,-1,0,0,1,0,1,0,-1], [-1,0,0,0,1,1,0,-1,-1,-1,0,0,1,1,1,-1,-1], [-1,0,0,1,1,1,-1,-1,-1,-1,0,1,1,1,0,-1,-1], [-1,0,1,1,1,0,-1,-1,-1,-1,1,1,1,1,-1,-1,-1], [-1,1,1,1,1,-1,-1,-1,-1,0,1,1,1,0,-1,-1,-1], [0,1,1,1,0,-1,-1,-1,0,0,1,1,0,0,-1,-1,-1], [0,1,1,1,0,-1,-1,-1,1,0,1,1,0,0,-1,-1,0], [1,1,0,1,0,-1,-1,-1,1,1,1,0,0,0,-1,-1,0], [1,1,0,0,0,-1,-1,0,1,1,1,0,-1,0,-1,-1,1], [1,1,0,0,-1,-1,-1,1,1,1,1,0,-1,-1,-1,0,1], [1,1,0,-1,-1,-1,0,1,1,1,1,-1,-1,-1,-1,1,1], [1,1,-1,-1,-1,-1,1,1,1,1,0,-1,-1,-1,0,1,1], [1,0,-1,-1,-1,0,1,1,1,0,0,-1,-1,-1,1,1,1], [0,0,-1,-1,-1,1,1,1,0,0,0,-1,-1,0,1,1,1], [0,0,-1,-1,0,1,1,1,-1,0,0,-1,0,0,1,1,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,1,0]]]], [ # Z-class [17][08] [[4], [3,4], [2,3,4], [1,2,3,4], [0,1,2,3,4], [-1,0,1,2,3,4], [-2,-1,0,1,2,3,4], [-2,-2,-1,0,1,2,3,4], [-2,-2,-2,-1,0,1,2,3,4], [-2,-2,-2,-2,-1,0,1,2,3,4], [-2,-2,-2,-2,-2,-1,0,1,2,3,4], [-2,-2,-2,-2,-2,-2,-1,0,1,2,3,4], [-1,-2,-2,-2,-2,-2,-2,-1,0,1,2,3,4], [0,-1,-2,-2,-2,-2,-2,-2,-1,0,1,2,3,4], [1,0,-1,-2,-2,-2,-2,-2,-2,-1,0,1,2,3,4], [2,1,0,-1,-2,-2,-2,-2,-2,-2,-1,0,1,2,3,4], [3,2,1,0,-1,-2,-2,-2,-2,-2,-2,-1,0,1,2,3,4]], [[[-1,1,-1,1,1,-2,0,0,0,1,0,-2,1,-1,1,1,-1], [-1,1,-1,1,0,-1,0,0,0,1,-1,-1,1,-1,1,0,0], [-1,0,0,1,0,-1,0,-1,1,1,-1,-1,0,0,1,0,0], [0,0,0,1,-1,-1,1,-1,1,0,-1,0,0,0,1,-1,0], [0,0,-1,1,-1,0,1,-1,0,0,0,0,0,0,0,-1,1], [1,-1,-1,1,-1,1,1,-2,0,0,0,1,0,-1,0,-1,1], [1,-1,0,1,-1,1,1,-1,0,0,0,1,0,0,0,-1,1], [1,-1,0,0,0,1,1,-1,0,-1,1,1,0,0,-1,0,1], [1,0,0,-1,0,1,1,0,-1,-1,1,1,1,0,-2,0,1], [1,0,0,-2,1,1,1,0,-1,-1,1,1,1,0,-2,0,1], [1,0,1,-2,0,1,1,0,0,-1,0,1,1,0,-1,0,0], [0,1,1,-2,0,1,0,1,0,-1,0,1,0,1,-1,0,0], [0,1,1,-2,0,0,0,1,0,-1,0,0,0,1,-1,0,-1], [0,1,0,-1,0,0,0,1,-1,0,0,0,0,0,0,0,-1], [-1,1,0,0,0,0,-1,1,0,0,0,-1,0,0,1,0,-1], [-1,1,0,1,0,-1,-1,1,0,1,-1,-1,0,0,1,1,-2], [-2,1,0,1,1,-2,-1,1,0,1,0,-2,0,0,1,1,-1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,2,-1,0,0,0,0,1,-1,0,0,0,1,0], [0,0,0,0,1,-1,1,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,1,-1,0,1,0,0,0,0,0,0,0,1,-1], [0,0,0,0,1,-1,0,0,1,0,0,0,0,0,0,1,-1], [0,0,0,0,1,-1,0,0,0,1,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,-1,1,0,0,0,0,0,1,0,0,0,-1,1], [0,0,0,0,-1,1,0,0,0,0,0,0,1,0,0,-1,1], [0,0,0,0,-1,1,0,0,0,0,0,0,0,1,0,-1,1], [0,0,0,0,-1,1,0,0,0,0,0,0,0,0,1,-1,1], [0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Z-class [17][09] [[5], [3,5], [1,3,5], [-1,1,3,5], [-1,-1,1,3,5], [-1,-1,-1,1,3,5], [-1,-1,-1,-1,1,3,5], [-1,-1,-1,-1,-1,1,3,5], [-1,-1,-1,-1,-1,-1,1,3,5], [-1,-1,-1,-1,-1,-1,-1,1,3,5], [-1,-1,-1,-1,-1,-1,-1,-1,1,3,5], [-1,-1,-1,-1,-1,-1,-1,-1,-1,1,3,5], [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,3,5], [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,3,5], [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,3,5], [1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,3,5], [3,1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,1,3,5]], [[[0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0], [0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1,1,-1], [0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-2,1,0,-1,1,-1,0,1,-1,0,1,-2,1,1,-2,1,1], [-1,1,1,-1,1,0,0,1,0,0,1,-1,1,1,-1,1,1], [0,0,1,-1,1,0,0,1,0,0,1,0,0,1,0,0,1], [0,0,1,-1,1,1,-1,1,0,0,1,0,0,1,0,0,1], [0,0,0,-1,1,0,-1,1,-1,0,1,-1,0,1,-1,0,0], [0,0,0,0,0,0,0,0,-1,1,0,-1,1,0,-1,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,-1,0,0,0,0], [1,-1,0,1,-1,0,0,0,0,0,-1,1,-1,0,1,-1,0], [1,-2,1,1,-2,1,0,-1,1,-1,0,1,-2,1,1,-2,1], [1,-1,0,1,-2,1,0,-1,1,-1,0,1,-1,0,1,-1,0], [0,0,-1,1,-1,0,1,-1,0,0,0,0,0,0,0,0,0], [-1,1,-1,0,0,0,0,0,0,0,0,-1,1,0,-1,1,0]]]], [ # Z-class [17][10] [[5], [1,5], [2,1,5], [0,2,1,5], [1,0,2,1,5], [0,1,0,2,1,5], [-2,0,1,0,2,1,5], [-2,-2,0,1,0,2,1,5], [-2,-2,-2,0,1,0,2,1,5], [-2,-2,-2,-2,0,1,0,2,1,5], [-2,-2,-2,-2,-2,0,1,0,2,1,5], [-2,-2,-2,-2,-2,-2,0,1,0,2,1,5], [0,-2,-2,-2,-2,-2,-2,0,1,0,2,1,5], [1,0,-2,-2,-2,-2,-2,-2,0,1,0,2,1,5], [0,1,0,-2,-2,-2,-2,-2,-2,0,1,0,2,1,5], [2,0,1,0,-2,-2,-2,-2,-2,-2,0,1,0,2,1,5], [1,2,0,1,0,-2,-2,-2,-2,-2,-2,0,1,0,2,1,5]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,-1,1,1,-1,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,1,0,0,1,-1,0,1,0,0,1,0,0,0], [0,0,0,0,1,0,0,1,0,-1,1,0,0,1,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,-1,0,0,-1,1,1,-1,0,0,-1,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,0,0,-1,1,1,-1,0,0,-1,0,0,0]], [[-2,0,1,-1,0,1,0,0,0,0,0,-1,1,1,-1,1,1], [-1,0,0,0,1,1,0,0,-1,-1,0,0,1,1,0,0,0], [-2,0,1,-1,1,1,-1,0,0,-1,0,0,0,1,0,0,0], [0,0,0,0,1,0,-1,1,0,-2,1,1,-1,1,1,-1,0], [-1,1,1,-1,1,0,-1,1,0,0,1,0,0,1,-1,0,1], [0,0,1,0,0,1,-1,-1,1,-1,0,2,0,0,0,-1,0], [0,1,0,0,1,0,-1,0,0,0,0,1,0,0,0,0,-1], [1,0,0,0,0,0,-1,0,1,-1,0,2,-1,-1,1,-1,-1], [1,0,-1,0,0,-1,0,1,0,0,0,0,-1,0,0,0,0], [1,0,0,0,-1,0,0,-1,1,1,-1,1,0,-2,0,0,0], [1,0,-1,1,-1,-1,1,-1,0,1,-1,0,0,-1,0,0,-1], [1,1,-1,0,0,-1,0,0,0,1,0,0,0,-2,0,1,-1], [1,-1,-1,1,-1,-1,2,0,-1,1,0,-1,0,0,0,0,0], [0,0,-1,0,0,0,1,0,0,1,-1,-1,1,-1,0,2,0], [0,-1,0,1,-1,0,2,-1,-1,1,-1,-1,1,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,1,1,-1,0,1,-1,0,1,0,0,1]]]], [ # Z-class [17][11] [[6], [0,6], [3,0,6], [-2,3,0,6], [2,-2,3,0,6], [-1,2,-2,3,0,6], [1,-1,2,-2,3,0,6], [-2,1,-1,2,-2,3,0,6], [-2,-2,1,-1,2,-2,3,0,6], [-2,-2,-2,1,-1,2,-2,3,0,6], [-2,-2,-2,-2,1,-1,2,-2,3,0,6], [1,-2,-2,-2,-2,1,-1,2,-2,3,0,6], [-1,1,-2,-2,-2,-2,1,-1,2,-2,3,0,6], [2,-1,1,-2,-2,-2,-2,1,-1,2,-2,3,0,6], [-2,2,-1,1,-2,-2,-2,-2,1,-1,2,-2,3,0,6], [3,-2,2,-1,1,-2,-2,-2,-2,1,-1,2,-2,3,0,6], [0,3,-2,2,-1,1,-2,-2,-2,-2,1,-1,2,-2,3,0,6]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,1,0,-1,1,0,0,0,-1,0,0,0,0], [1,0,0,0,0,0,0,1,0,0,0,0,0,-1,1,0,0], [0,1,0,-1,0,1,-1,0,1,0,0,0,0,-1,0,1,-1], [1,0,1,-1,1,0,-1,1,-1,1,0,0,1,-1,1,-1,0], [-1,1,0,-1,1,0,0,-1,0,1,-1,0,0,0,0,0,0], [1,-1,1,0,0,0,0,0,-1,1,-1,0,1,-1,1,-1,0], [-1,1,-1,0,0,0,1,-1,0,0,-1,0,0,0,0,1,-1], [1,-1,1,0,0,0,-1,1,-1,0,0,0,1,-1,1,-1,-1], [-1,1,-1,0,1,0,0,0,0,-1,0,0,0,1,0,1,-1], [1,-1,1,1,0,0,-1,0,-1,0,1,0,1,0,0,-1,-1], [-1,1,-1,1,0,-1,1,-1,0,0,0,0,0,1,-1,1,0], [0,-1,1,1,-1,0,0,-1,0,0,0,1,0,0,0,-1,0], [-1,0,-1,1,0,0,1,0,0,-1,0,0,0,1,0,1,0], [1,-1,0,1,-1,1,-1,0,1,-1,1,0,0,0,0,0,-1], [0,1,-1,1,0,0,0,0,1,-1,1,0,0,1,-1,1,0], [0,0,1,0,-1,1,-1,-1,1,0,1,0,0,0,-1,0,0]], [[-2,0,0,0,0,0,1,-1,0,0,-1,0,0,1,-1,0,1], [0,1,-1,0,0,-2,1,0,0,1,0,0,-1,0,-1,0,1], [-1,0,-1,0,0,0,1,-1,1,0,-1,0,-1,1,0,0,1], [0,2,-1,0,0,-1,0,0,1,0,1,0,-1,0,-1,1,0], [-1,0,-1,0,0,1,0,0,1,-2,0,0,-1,1,0,1,0], [0,1,0,-1,0,0,-1,1,0,0,1,-1,0,0,-1,1,0], [0,-1,0,0,-1,1,0,0,1,-1,0,0,-1,1,0,0,1], [1,0,1,-1,-1,0,-1,1,0,1,1,-1,0,-1,0,0,0], [1,-1,0,0,-1,1,0,0,1,-1,0,0,-1,0,1,0,0], [1,0,1,-1,0,1,-2,1,0,0,1,-1,1,-1,0,0,-1], [1,-1,0,0,0,1,0,1,0,-1,0,0,0,0,1,0,0], [0,-1,2,-1,0,1,-1,1,-1,1,0,-1,2,-1,0,0,0], [1,-1,0,1,-1,0,1,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,0,0,0,0,-1,1,0,-1,1,0,0,-1,0], [1,0,-1,1,0,-1,1,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,1,0,0,0,0,0,-1,0,1,0,0,0,0], [0,1,-1,1,0,-1,1,0,0,0,0,0,0,0,-1,1,0]]]], [ # Z-class [17][12] [[17], [-3,17], [1,-3,17], [5,1,-3,17], [-3,5,1,-3,17], [1,-3,5,1,-3,17], [-7,1,-3,5,1,-3,17], [5,-7,1,-3,5,1,-3,17], [-7,5,-7,1,-3,5,1,-3,17], [-7,-7,5,-7,1,-3,5,1,-3,17], [5,-7,-7,5,-7,1,-3,5,1,-3,17], [-7,5,-7,-7,5,-7,1,-3,5,1,-3,17], [1,-7,5,-7,-7,5,-7,1,-3,5,1,-3,17], [-3,1,-7,5,-7,-7,5,-7,1,-3,5,1,-3,17], [5,-3,1,-7,5,-7,-7,5,-7,1,-3,5,1,-3,17], [1,5,-3,1,-7,5,-7,-7,5,-7,1,-3,5,1,-3,17], [-3,1,5,-3,1,-7,5,-7,-7,5,-7,1,-3,5,1,-3,17]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-2,1,-1,1,-2,1,-1,1,-1,0,0,0,0,-1,1,-1,1], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1], [0,0,0,0,-1,1,-1,1,-2,1,-1,1,-2,1,-1,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,1,0,1,0,0,0,1,0,0,0,0,1,0,0,0,1], [0,1,-1,0,-1,1,-1,0,-1,1,0,0,-1,0,0,-1,0], [0,0,0,0,1,-1,1,-1,1,-1,1,-1,1,-1,1,0,0], [-1,0,0,0,-1,-1,0,0,0,-1,0,-1,0,-1,0,-1,0], [1,0,0,0,1,0,0,0,1,1,0,0,0,1,0,0,0], [0,-1,0,-1,1,-1,0,-1,0,-1,0,-1,0,0,-1,0,-1], [0,-1,0,-1,0,-1,0,-1,1,-1,0,-1,0,-1,0,-1,0], [0,0,0,1,1,0,0,0,1,0,0,0,1,0,0,0,1], [0,-1,0,-1,0,0,0,-1,-1,0,0,0,-1,0,-1,0,-1], [1,-1,1,-1,1,-1,1,-1,1,0,0,0,0,0,0,1,-1], [-1,0,0,1,-1,0,-1,1,-1,0,-1,1,0,0,-1,0,0], [1,0,0,0,0,1,0,0,0,1,0,1,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]]]], [ # Z-class [17][13] [[8], [-4,8], [5,-4,8], [-4,5,-4,8], [5,-4,5,-4,8], [-2,5,-4,5,-4,8], [3,-2,5,-4,5,-4,8], [-1,3,-2,5,-4,5,-4,8], [2,-1,3,-2,5,-4,5,-4,8], [2,2,-1,3,-2,5,-4,5,-4,8], [-1,2,2,-1,3,-2,5,-4,5,-4,8], [3,-1,2,2,-1,3,-2,5,-4,5,-4,8], [-2,3,-1,2,2,-1,3,-2,5,-4,5,-4,8], [5,-2,3,-1,2,2,-1,3,-2,5,-4,5,-4,8], [-4,5,-2,3,-1,2,2,-1,3,-2,5,-4,5,-4,8], [5,-4,5,-2,3,-1,2,2,-1,3,-2,5,-4,5,-4,8], [-4,5,-4,5,-2,3,-1,2,2,-1,3,-2,5,-4,5,-4,8]], [[[1,1,0,0,0,-1,-2,0,0,-1,0,0,0,0,1,1,0], [-1,-1,0,0,-1,1,1,0,1,1,1,0,0,0,-1,0,0], [1,0,0,-1,0,-1,-2,0,-1,0,0,0,1,0,2,1,0], [-1,-1,-1,0,-1,1,1,0,1,0,1,0,0,1,-1,0,0], [0,1,0,0,0,-1,-1,-1,0,0,-1,0,0,0,1,1,0], [-1,0,-1,0,-1,0,1,0,1,0,1,1,0,1,-1,0,0], [0,0,0,-1,1,-1,-1,0,0,1,-1,1,0,-1,2,0,0], [0,0,-1,0,-1,1,0,0,1,-1,1,0,0,1,-1,1,0], [-1,0,1,-1,1,0,-1,0,0,1,-1,0,0,-1,1,0,0], [0,1,-1,0,-1,0,0,0,1,-1,1,0,0,1,-1,1,0], [-1,-1,1,-1,0,0,0,0,0,2,-1,0,1,-1,1,0,0], [1,0,-1,0,-1,0,-1,0,0,-1,1,0,1,1,0,1,0], [-1,-1,0,0,0,1,0,0,1,1,0,0,0,-1,0,0,-1], [1,1,-1,0,-1,-1,-1,0,0,-1,1,0,0,1,0,1,0], [-2,-1,0,-1,0,0,1,0,1,2,0,1,0,0,0,-1,0], [1,1,-1,0,0,-1,-1,0,0,-1,0,0,0,1,1,1,0], [-2,-1,0,0,0,1,1,0,1,1,0,0,0,0,-1,0,0]], [[-1,1,0,-1,1,1,-1,-1,1,0,-1,1,0,-1,0,1,0], [1,-1,0,1,-1,0,-1,1,0,-1,2,-1,0,1,0,0,-1], [-1,0,0,-1,1,1,0,0,1,1,-1,0,0,-1,0,0,0], [1,-1,0,1,-2,0,0,0,0,0,2,-1,0,1,-1,0,0], [-1,0,0,-1,1,0,0,-1,0,1,-1,1,0,0,1,0,1], [0,0,0,1,-1,0,0,0,1,-1,1,0,-1,1,-1,0,0], [-1,0,0,-1,1,0,0,0,0,1,-1,0,0,0,1,0,0], [0,0,0,1,-2,1,0,-1,1,-1,1,-1,0,1,-2,1,0], [0,-1,0,0,1,0,0,0,-1,1,0,0,0,0,1,-1,0], [0,0,0,0,-1,1,-1,0,1,-1,1,0,0,0,-1,1,0], [0,-1,1,0,1,0,0,1,-1,1,0,-1,0,0,1,-1,0], [-1,1,0,0,-1,1,0,-1,2,0,0,0,0,0,-2,1,0], [0,-1,0,0,0,-1,0,0,-1,1,1,0,0,1,1,-1,0], [-1,1,-1,0,0,1,0,-1,2,-1,0,1,-1,0,-1,1,0], [1,-1,0,1,0,-1,0,1,-1,0,1,-1,-1,1,1,-1,0], [-1,1,0,-1,0,1,0,-1,1,0,-1,0,0,0,-1,1,1], [1,-1,1,1,-1,0,0,0,-1,0,1,-1,0,1,0,-1,0]]]], [ # Z-class [17][14] [[52], [25,52], [16,25,52], [7,16,25,52], [-20,7,16,25,52], [-20,-20,7,16,25,52], [-11,-20,-20,7,16,25,52], [-20,-11,-20,-20,7,16,25,52], [-2,-20,-11,-20,-20,7,16,25,52], [-2,-2,-20,-11,-20,-20,7,16,25,52], [-20,-2,-2,-20,-11,-20,-20,7,16,25,52], [-11,-20,-2,-2,-20,-11,-20,-20,7,16,25,52], [-20,-11,-20,-2,-2,-20,-11,-20,-20,7,16,25,52], [-20,-20,-11,-20,-2,-2,-20,-11,-20,-20,7,16,25,52], [7,-20,-20,-11,-20,-2,-2,-20,-11,-20,-20,7,16,25,52], [16,7,-20,-20,-11,-20,-2,-2,-20,-11,-20,-20,7,16,25,52], [25,16,7,-20,-20,-11,-20,-2,-2,-20,-11,-20,-20,7,16,25,52]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-2,-1,0,0,-1,-1,0,-1,-1,0,0,-1,-1,-1,0,0,0], [-1,1,0,0,-1,0,1,-1,0,0,0,0,0,0,0,0,0], [-1,1,1,0,-1,-1,0,1,0,0,-1,0,0,0,1,0,-1], [-1,1,0,0,0,-1,0,0,1,0,-1,0,0,0,0,0,0], [0,2,1,0,0,0,1,1,1,0,-1,1,1,1,0,0,0], [0,1,1,0,1,0,0,1,1,0,0,1,0,0,1,1,0], [0,0,1,0,1,1,0,0,1,1,0,0,1,0,0,1,1], [1,0,0,0,1,2,0,0,0,0,1,1,1,-1,0,1,1], [0,-1,0,0,0,1,-1,0,0,0,0,0,0,-1,0,1,0], [0,-1,-1,0,1,1,-1,-1,0,1,0,0,0,-1,0,0,1], [1,0,-1,0,0,1,-1,0,0,0,0,0,0,0,0,0,-1], [0,-1,-1,0,0,-1,-2,0,0,0,-1,-1,-1,0,0,-1,-1], [1,0,-1,0,0,0,0,0,0,0,0,0,0,1,-1,-1,0], [1,0,0,0,0,-1,0,1,0,-1,0,0,0,1,0,-1,-1], [0,-1,0,1,0,-1,0,0,0,0,1,-1,-1,1,0,0,0], [0,-1,0,0,0,0,1,-1,-1,0,1,0,0,0,-1,0,1], [0,0,0,0,-1,0,1,0,-1,-1,1,0,0,0,0,0,0]]]], [ # Z-class [17][15] [[4], [0,4], [0,0,4], [1,0,0,4], [-2,1,0,0,4], [0,-2,1,0,0,4], [0,0,-2,1,0,0,4], [-1,0,0,-2,1,0,0,4], [1,-1,0,0,-2,1,0,0,4], [1,1,-1,0,0,-2,1,0,0,4], [-1,1,1,-1,0,0,-2,1,0,0,4], [0,-1,1,1,-1,0,0,-2,1,0,0,4], [0,0,-1,1,1,-1,0,0,-2,1,0,0,4], [-2,0,0,-1,1,1,-1,0,0,-2,1,0,0,4], [1,-2,0,0,-1,1,1,-1,0,0,-2,1,0,0,4], [0,1,-2,0,0,-1,1,1,-1,0,0,-2,1,0,0,4], [0,0,1,-2,0,0,-1,1,1,-1,0,0,-2,1,0,0,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,0,-1,1,0,0,0,0,0,0,1,-1,0,-1,1,-1,1], [-1,1,-1,0,0,0,0,-1,1,-1,1,-1,1,-1,1,-1,1], [0,0,0,0,0,0,1,-1,0,-1,1,-1,1,-1,0,-1,1], [-1,1,-1,1,-1,1,-1,1,-1,1,-1,0,0,0,0,-1,1], [0,0,1,-1,0,-1,1,-1,1,-1,0,-1,1,0,0,0,0], [0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,1,-1,1,-1,1,-1,2,-1,1,-1,1,-1,1,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [1,-1,2,-1,1,-1,1,-1,1,0,0,0,0,1,-1,1,-1], [0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0], [-1,1,-1,1,-1,0,-1,1,0,0,0,0,0,0,1,-1,0], [1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,0,0,0,0,-1]]]], [ # Z-class [17][16] [[6], [2,6], [-1,2,6], [1,-1,2,6], [2,1,-1,2,6], [1,2,1,-1,2,6], [-1,1,2,1,-1,2,6], [-1,-1,1,2,1,-1,2,6], [3,-1,-1,1,2,1,-1,2,6], [3,3,-1,-1,1,2,1,-1,2,6], [-1,3,3,-1,-1,1,2,1,-1,2,6], [-1,-1,3,3,-1,-1,1,2,1,-1,2,6], [1,-1,-1,3,3,-1,-1,1,2,1,-1,2,6], [2,1,-1,-1,3,3,-1,-1,1,2,1,-1,2,6], [1,2,1,-1,-1,3,3,-1,-1,1,2,1,-1,2,6], [-1,1,2,1,-1,-1,3,3,-1,-1,1,2,1,-1,2,6], [2,-1,1,2,1,-1,-1,3,3,-1,-1,1,2,1,-1,2,6]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,-1,0,0,1,0,0,-1,0,1,0,0,-1,0,0,1,1], [0,0,-1,0,0,0,1,-1,0,0,0,1,-1,1,-2,1,0], [1,0,-1,0,-1,1,0,1,-1,0,0,1,0,0,-1,0,0], [0,0,0,0,-1,1,-1,1,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,1,0,-1,1,-1,1,0,0,0,-1,1,0], [1,-1,0,0,0,1,0,0,0,0,0,0,0,0,-1,1,-1], [2,-1,1,-1,-1,1,0,1,-1,0,0,0,1,0,-1,0,-1], [1,0,0,0,-1,1,0,0,0,-1,1,0,1,0,-1,0,0], [0,-1,0,1,0,1,-1,0,0,0,1,-1,0,0,0,1,0], [0,-1,0,1,0,0,0,-1,1,0,1,-1,-1,1,-1,2,-1], [1,-1,0,0,0,0,0,0,0,0,1,0,0,0,-1,1,-1], [1,-1,0,0,0,1,-1,1,-1,0,1,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,1,-1,1,-1,0,0,0,0,0], [0,-1,0,0,1,0,0,-1,1,0,1,-1,0,-1,0,1,0], [1,-2,1,-1,1,0,0,0,-1,1,0,0,0,-1,0,0,0], [1,0,0,-1,0,0,1,0,-1,0,0,1,0,0,-1,-1,1]], [[-2,0,0,1,0,0,-1,0,0,2,-1,0,-1,0,1,0,1], [0,-1,1,0,0,0,-1,1,0,1,0,-1,0,0,1,0,0], [1,0,0,0,-1,0,0,1,0,0,0,0,0,1,-1,0,-1], [-1,1,-1,0,1,-1,1,-1,0,1,-1,2,-2,1,-1,0,1], [-1,0,-1,0,1,0,0,-1,-1,1,0,1,-1,0,0,0,2], [0,0,-1,1,-1,1,-1,0,0,0,1,-1,0,0,0,1,0], [0,0,0,1,0,-1,0,0,1,0,0,-1,-1,1,0,1,-1], [-1,0,0,0,1,-2,1,-1,1,0,0,0,-1,1,0,0,0], [-2,1,0,0,0,-1,0,0,0,1,-1,0,0,0,1,-1,1], [-1,0,1,0,0,0,-1,1,0,1,-1,-1,0,0,1,0,0], [1,-1,1,-1,0,0,0,1,0,0,0,-1,1,0,0,0,-1], [0,1,0,-1,0,-1,2,0,0,0,-1,1,0,1,-1,-1,0], [-1,1,0,-1,1,-1,1,0,-1,1,-2,2,-1,1,0,-1,1], [0,-1,0,0,0,1,-1,0,-1,1,0,0,0,0,0,1,0], [0,0,0,1,-1,0,0,0,1,0,0,-1,0,1,0,1,-1], [0,0,1,0,0,-2,1,0,1,0,-1,0,-1,2,0,0,-1], [-1,0,0,0,0,-1,0,0,0,1,-1,1,-1,1,0,0,0]]]], [ # Z-class [17][17] [[11], [2,11], [2,2,11], [-4,2,2,11], [-4,-4,2,2,11], [-7,-4,-4,2,2,11], [-1,-7,-4,-4,2,2,11], [2,-1,-7,-4,-4,2,2,11], [5,2,-1,-7,-4,-4,2,2,11], [5,5,2,-1,-7,-4,-4,2,2,11], [2,5,5,2,-1,-7,-4,-4,2,2,11], [-1,2,5,5,2,-1,-7,-4,-4,2,2,11], [-7,-1,2,5,5,2,-1,-7,-4,-4,2,2,11], [-4,-7,-1,2,5,5,2,-1,-7,-4,-4,2,2,11], [-4,-4,-7,-1,2,5,5,2,-1,-7,-4,-4,2,2,11], [2,-4,-4,-7,-1,2,5,5,2,-1,-7,-4,-4,2,2,11], [2,2,-4,-4,-7,-1,2,5,5,2,-1,-7,-4,-4,2,2,11]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,2,1,-1,-1,1,2,1,0,-1,0,1,1,1,0,-1,0], [-1,-2,-1,1,2,1,-1,-2,0,2,2,0,-2,-2,1,2,1], [1,-1,-1,-1,1,2,1,-1,-2,0,1,2,0,-2,-1,0,2], [1,0,-1,-1,-1,0,1,0,-1,-1,-1,1,1,-1,-1,-1,0], [0,1,0,-1,-1,-1,1,1,0,-1,-2,0,1,1,-1,-2,-1], [0,0,0,0,0,-1,-1,0,0,0,-1,-1,0,0,0,0,-1], [0,1,1,0,-1,-1,0,1,1,0,-1,-1,1,2,0,-1,-1], [-1,1,2,1,-1,-2,-1,1,2,0,-1,-2,0,2,2,0,-2], [-1,0,1,1,1,0,-1,0,1,2,1,-1,-1,1,2,1,0], [0,-1,0,1,1,1,0,-1,0,1,2,1,-1,-1,1,2,1], [1,-1,-2,-1,1,2,1,-1,-2,0,2,2,0,-2,-1,0,2], [1,0,-1,-1,0,1,1,0,-1,-1,0,2,1,-1,-1,0,1], [0,-1,-1,0,0,0,0,0,-1,0,0,0,0,-1,-1,0,0], [1,1,-1,-1,-1,0,1,0,-1,-2,-1,1,1,0,-2,-1,0], [0,1,0,-1,-1,-1,0,1,0,-1,-1,-1,1,1,-1,-1,-1], [-1,1,2,1,-1,-1,-1,1,2,0,-1,-2,0,2,1,0,-2], [-2,-1,1,2,1,-1,-2,-1,1,2,1,-2,-2,0,2,2,0]]]], [ # Z-class [17][18] [[3], [0,3], [0,0,3], [0,0,0,3], [-1,0,0,0,3], [0,-1,0,0,0,3], [-1,0,-1,0,0,0,3], [1,-1,0,-1,0,0,0,3], [1,1,-1,0,-1,0,0,0,3], [1,1,1,-1,0,-1,0,0,0,3], [1,1,1,1,-1,0,-1,0,0,0,3], [-1,1,1,1,1,-1,0,-1,0,0,0,3], [0,-1,1,1,1,1,-1,0,-1,0,0,0,3], [-1,0,-1,1,1,1,1,-1,0,-1,0,0,0,3], [0,-1,0,-1,1,1,1,1,-1,0,-1,0,0,0,3], [0,0,-1,0,-1,1,1,1,1,-1,0,-1,0,0,0,3], [0,0,0,-1,0,-1,1,1,1,1,-1,0,-1,0,0,0,3]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,-1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,-1], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,1,0,0,0,0,0,0,-1,-1,-1,0,0], [0,0,0,-1,0,0,1,0,1,-1,1,0,1,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,1,0,1,-1,1,0,1,0,0,-1,0,0,0,0,-1,0], [1,0,0,0,0,0,0,-1,-1,-1,0,0,0,0,0,0,1], [-1,-1,0,1,0,0,-1,0,0,1,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,-1,0,0,1,0,-1,-1,0,1,0,0,-1,0,0,1,0], [-1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,-1,-1], [1,0,1,-1,1,0,1,0,0,-1,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,1,0,0,-1,0,0,0,0,-1,0,0,1,0,1,-1,1], [0,0,1,1,0,0,0,0,0,0,-1,-1,-1,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,-1,-1,0,0,0,0,0,0,1,1]]]], [ # Z-class [17][19] [[4], [0,4], [-1,0,4], [1,-1,0,4], [2,1,-1,0,4], [1,2,1,-1,0,4], [-1,1,2,1,-1,0,4], [1,-1,1,2,1,-1,0,4], [1,1,-1,1,2,1,-1,0,4], [1,1,1,-1,1,2,1,-1,0,4], [1,1,1,1,-1,1,2,1,-1,0,4], [-1,1,1,1,1,-1,1,2,1,-1,0,4], [1,-1,1,1,1,1,-1,1,2,1,-1,0,4], [2,1,-1,1,1,1,1,-1,1,2,1,-1,0,4], [1,2,1,-1,1,1,1,1,-1,1,2,1,-1,0,4], [-1,1,2,1,-1,1,1,1,1,-1,1,2,1,-1,0,4], [0,-1,1,2,1,-1,1,1,1,1,-1,1,2,1,-1,0,4]], [[[-1,-1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,-1], [0,0,0,0,-1,0,1,1,1,0,-1,0,0,0,0,-1,-1], [0,1,0,0,0,0,0,1,0,0,0,-1,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [-1,-1,-1,0,0,1,0,0,0,0,0,0,0,0,1,0,0], [0,0,1,0,-1,0,0,1,1,0,-1,0,0,1,0,-1,-1], [0,1,0,0,-1,-1,0,1,1,0,0,-1,0,0,0,0,0], [-1,0,0,0,1,0,0,0,0,0,1,-1,0,0,0,0,0], [0,0,0,0,-1,1,0,0,0,0,0,1,0,0,0,-1,0], [0,0,0,0,-1,0,0,1,1,0,-1,-1,0,0,1,0,0], [-1,0,1,0,0,-1,0,1,1,0,0,-1,0,1,0,0,-1], [0,1,0,0,0,0,0,0,0,0,1,0,0,-1,-1,-1,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,-1,0,0,0,1,0,0,0,0,0,1,0,0], [-1,0,0,0,0,-1,0,1,1,1,0,-1,0,0,0,0,-1], [0,1,1,1,0,0,0,0,0,0,0,0,0,0,-1,-1,-1], [0,0,-1,0,0,1,0,0,0,0,1,0,0,-1,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,-1,1,0,0,0,0,0,1,0,0,0], [0,0,1,0,0,0,-1,-1,0,0,1,1,0,0,-1,-1,0], [0,0,0,0,-1,0,0,0,1,0,0,0,0,0,1,-1,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,-1,0,0,-1,0,0,0,1,0,0,0], [-1,-1,0,0,0,0,-1,0,1,1,1,0,-1,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,1,1,1,0,0,-1,0], [0,0,0,0,0,0,0,0,0,-1,-1,0,0,1,1,0,0], [0,0,1,0,1,0,-1,0,0,0,1,0,-1,0,-1,0,0], [0,0,0,0,-1,-1,-1,0,1,1,1,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,-1,-1], [1,0,1,0,0,0,0,-1,0,-1,0,1,0,0,0,-1,0], [0,0,0,0,0,0,0,1,1,0,0,-1,-1,0,0,0,0], [0,0,0,0,0,0,-1,0,0,1,1,1,0,0,-1,0,0], [0,0,0,-1,-1,0,0,0,0,-1,0,1,1,1,0,-1,0], [0,0,1,0,0,0,0,0,1,0,0,0,-1,0,0,-1,0]]]], [ # Z-class [17][20] [[4], [1,4], [1,1,4], [-1,1,1,4], [-1,-1,1,1,4], [-2,-1,-1,1,1,4], [0,-2,-1,-1,1,1,4], [1,0,-2,-1,-1,1,1,4], [2,1,0,-2,-1,-1,1,1,4], [2,2,1,0,-2,-1,-1,1,1,4], [1,2,2,1,0,-2,-1,-1,1,1,4], [0,1,2,2,1,0,-2,-1,-1,1,1,4], [-2,0,1,2,2,1,0,-2,-1,-1,1,1,4], [-1,-2,0,1,2,2,1,0,-2,-1,-1,1,1,4], [-1,-1,-2,0,1,2,2,1,0,-2,-1,-1,1,1,4], [1,-1,-1,-2,0,1,2,2,1,0,-2,-1,-1,1,1,4], [1,1,-1,-1,-2,0,1,2,2,1,0,-2,-1,-1,1,1,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-2,-1,1,2,1,-1,-2,-1,1,2,0,-2,-2,0,2,1,0], [0,1,1,0,-1,-1,0,1,1,0,-2,-1,1,1,0,-1,-1], [-2,0,1,1,0,-1,-1,0,1,1,0,-1,-1,0,1,1,-1], [0,2,1,-1,-2,-1,1,2,1,-1,-2,0,1,2,0,-2,-2], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [2,0,-2,-2,0,2,2,0,-2,-2,1,3,1,-1,-3,-1,2], [0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,1], [1,-1,-2,0,1,1,0,-1,-1,0,1,1,0,-1,-1,0,2], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,-1,0,0,0,0,0], [-2,1,2,1,-1,-3,-1,1,2,1,-2,-2,0,2,2,0,-2], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0], [1,0,-1,-1,0,1,1,0,-2,-1,1,2,0,-1,-1,0,1], [0,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1], [1,-2,-2,0,2,2,0,-2,-2,0,2,2,-1,-3,-1,1,3]], [[-3,-2,1,3,2,-2,-3,-1,2,3,0,-2,-3,0,3,2,0], [-1,-1,0,1,1,-1,-1,-1,1,2,0,-1,-1,0,1,1,0], [0,-1,0,1,1,0,-1,-1,1,1,0,-1,-1,0,1,0,0], [1,0,-1,-1,0,1,1,-1,-1,0,1,1,0,-1,0,0,0], [1,0,-1,-1,0,2,1,-1,-1,-1,1,1,0,-1,-1,0,1], [3,0,-3,-2,0,3,2,-1,-3,-2,2,3,1,-2,-3,0,2], [0,1,0,0,-1,0,0,0,0,-1,0,0,0,1,0,0,0], [-1,0,0,1,0,-1,0,0,0,0,0,0,-1,0,0,1,0], [-1,0,1,1,0,-1,-1,0,1,1,-1,-1,-1,1,1,0,0], [-2,-1,1,2,1,-2,-2,0,2,2,0,-2,-2,1,2,1,-1], [-1,1,2,1,-1,-2,0,1,2,1,-2,-2,0,2,2,-1,-2], [0,-1,-1,0,1,1,0,-1,0,1,1,0,-1,-1,0,0,0], [2,2,0,-2,-2,1,2,1,0,-2,-1,1,2,1,-1,-2,-1], [2,1,-2,-2,0,2,2,0,-2,-2,1,2,1,-1,-2,-1,1], [1,1,-1,-1,-1,1,1,0,-1,-1,0,1,1,0,-1,0,0], [0,0,-1,0,0,0,0,0,0,-1,0,1,0,0,-1,0,1], [0,1,0,0,0,-1,0,0,0,0,-1,0,0,1,0,0,0]]]], [ # Z-class [17][21] [[7], [1,7], [-3,1,7], [-1,-3,1,7], [-1,-1,-3,1,7], [1,-1,-1,-3,1,7], [3,1,-1,-1,-3,1,7], [1,3,1,-1,-1,-3,1,7], [-3,1,3,1,-1,-1,-3,1,7], [-3,-3,1,3,1,-1,-1,-3,1,7], [1,-3,-3,1,3,1,-1,-1,-3,1,7], [3,1,-3,-3,1,3,1,-1,-1,-3,1,7], [1,3,1,-3,-3,1,3,1,-1,-1,-3,1,7], [-1,1,3,1,-3,-3,1,3,1,-1,-1,-3,1,7], [-1,-1,1,3,1,-3,-3,1,3,1,-1,-1,-3,1,7], [-3,-1,-1,1,3,1,-3,-3,1,3,1,-1,-1,-3,1,7], [1,-3,-1,-1,1,3,1,-3,-3,1,3,1,-1,-1,-3,1,7]], [[[-3,2,-2,2,-1,0,0,-1,1,-2,2,-2,3,-3,3,-3,3], [-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,0,0,1], [3,-2,2,-2,1,-1,0,0,-1,2,-2,2,-3,3,-3,3,-3], [0,1,-1,1,-1,1,-1,1,-1,1,0,0,0,0,0,0,0], [0,0,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,1,-1,1,-1,1,-1,1,-1,1,-1,0], [-2,2,-2,2,-2,2,-2,1,-2,1,-1,1,0,0,1,-1,1], [1,-1,0,0,0,0,-1,1,-1,1,-2,2,-2,2,-2,2,-1], [2,-2,1,-2,1,-1,1,0,0,1,-1,1,-2,2,-2,2,-2], [1,0,0,0,0,1,-1,1,-1,2,-1,1,-1,1,-1,0,-1], [-1,1,-1,2,-1,1,-1,1,0,0,0,0,1,-1,0,-1,1], [-2,1,-1,1,0,0,1,-1,1,-2,1,-2,2,-2,2,-2,2], [-2,2,-2,1,-1,1,-1,0,0,0,0,-1,1,-1,2,-2,2], [0,1,-1,1,-2,1,-2,2,-2,2,-2,2,-2,1,-1,1,0], [1,-1,1,-1,1,-1,1,0,0,0,0,0,-1,0,-1,1,-1], [0,0,0,0,0,1,0,1,0,1,0,0,0,0,0,0,0], [0,0,0,1,-1,1,-1,1,-1,1,-1,1,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,-1,1,-1,2,-2,2,-2,2,-2,1,-2,1,-1,0], [-2,1,-1,1,-2,1,-1,1,-1,0,0,0,0,-1,1,-1,1], [1,-1,1,0,0,0,-1,1,-2,1,-2,2,-2,2,-2,2,-1], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [-3,3,-3,3,-2,2,-1,1,0,0,1,-1,2,-2,3,-3,3], [-1,2,-1,1,-1,0,0,-1,1,-1,2,-2,2,-2,2,-2,2], [1,-1,1,-2,1,-1,1,-2,1,-1,1,-1,0,0,0,0,-1], [0,-1,1,-1,1,-1,1,-1,1,-1,0,0,0,0,0,0,0], [0,0,0,1,-1,1,-2,2,-2,2,-2,2,-1,1,-1,1,0], [0,1,-2,2,-2,3,-3,3,-3,3,-3,2,-2,2,-1,1,0], [-2,2,-2,1,0,0,1,-1,2,-2,2,-3,3,-3,3,-3,3], [-1,1,0,0,0,0,1,-1,1,-1,2,-2,2,-2,2,-2,1], [1,-1,1,-1,0,0,0,0,0,0,0,0,-1,1,-1,1,-1], [1,-2,1,-1,1,-1,0,0,0,0,-1,1,-1,1,-2,1,-1], [-1,1,-1,2,-1,2,-2,2,-2,2,-2,2,-1,1,-1,0,0], [-2,3,-3,3,-3,3,-3,3,-2,2,-1,1,0,0,1,-1,2]]]], [ # Z-class [17][22] [[10], [-2,10], [-5,-2,10], [1,-5,-2,10], [4,1,-5,-2,10], [1,4,1,-5,-2,10], [-5,1,4,1,-5,-2,10], [1,-5,1,4,1,-5,-2,10], [1,1,-5,1,4,1,-5,-2,10], [1,1,1,-5,1,4,1,-5,-2,10], [1,1,1,1,-5,1,4,1,-5,-2,10], [-5,1,1,1,1,-5,1,4,1,-5,-2,10], [1,-5,1,1,1,1,-5,1,4,1,-5,-2,10], [4,1,-5,1,1,1,1,-5,1,4,1,-5,-2,10], [1,4,1,-5,1,1,1,1,-5,1,4,1,-5,-2,10], [-5,1,4,1,-5,1,1,1,1,-5,1,4,1,-5,-2,10], [-2,-5,1,4,1,-5,1,1,1,1,-5,1,4,1,-5,-2,10]], [[[-1,-1,-1,0,0,0,0,0,0,0,-1,-1,-1,0,1,1,0], [0,1,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0], [0,0,0,1,1,0,0,-1,-1,0,0,0,0,-1,0,0,0], [0,0,0,0,-1,0,-1,0,0,0,-1,0,-1,0,0,0,0], [-1,0,0,0,0,0,0,1,1,0,0,-1,0,1,1,0,0], [0,0,1,0,1,0,0,0,0,0,1,0,0,0,-1,0,0], [1,0,-1,0,0,0,0,-1,-1,0,0,0,0,-1,0,1,1], [0,1,0,0,-1,0,0,1,0,0,-1,0,0,0,0,-1,0], [-1,-1,0,0,0,0,-1,0,1,1,1,0,-1,0,0,0,0], [0,0,0,0,1,0,1,0,0,0,0,-1,0,0,0,1,0], [1,1,0,0,0,0,0,0,-1,0,0,1,1,0,-1,0,0], [0,0,-1,0,-1,0,0,0,0,0,0,0,0,-1,0,-1,0], [-1,-1,0,0,1,1,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0], [1,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,-1,-1,-1,0,1,1,0,-1,-1,-1,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,-1,0,0,0,0,0,-1,0,0,0,1,0,0,0,0], [0,0,0,-1,-1,0,0,1,1,0,0,0,0,1,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,-1,-1,-1,0,0], [-1,0,0,1,1,0,0,0,0,0,0,-1,0,0,1,0,0], [0,1,0,0,-1,0,0,0,0,0,0,1,1,0,0,-1,0], [0,-1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,1,0,0,0,0,1,1,0,0,-1,-1,0,0,0,0], [0,0,0,1,0,0,0,-1,0,0,0,0,0,-1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [-1,-1,0,0,0,0,-1,0,0,0,0,-1,-1,0,0,0,0], [1,1,1,0,-1,-1,0,0,1,0,0,0,0,0,0,-1,0], [0,0,0,1,1,0,0,-1,-1,0,0,1,1,0,0,0,-1], [-1,0,0,0,0,0,0,1,0,0,-1,-1,0,1,1,1,0], [0,0,0,-1,-1,0,0,0,0,-1,0,0,0,0,-1,-1,0]]]], [ # Z-class [17][23] [[17], [-1,17], [-1,-1,17], [-1,-1,-1,17], [-7,-1,-1,-1,17], [-1,-7,-1,-1,-1,17], [-7,-1,-7,-1,-1,-1,17], [5,-7,-1,-7,-1,-1,-1,17], [5,5,-7,-1,-7,-1,-1,-1,17], [5,5,5,-7,-1,-7,-1,-1,-1,17], [5,5,5,5,-7,-1,-7,-1,-1,-1,17], [-7,5,5,5,5,-7,-1,-7,-1,-1,-1,17], [-1,-7,5,5,5,5,-7,-1,-7,-1,-1,-1,17], [-7,-1,-7,5,5,5,5,-7,-1,-7,-1,-1,-1,17], [-1,-7,-1,-7,5,5,5,5,-7,-1,-7,-1,-1,-1,17], [-1,-1,-7,-1,-7,5,5,5,5,-7,-1,-7,-1,-1,-1,17], [-1,-1,-1,-7,-1,-7,5,5,5,5,-7,-1,-7,-1,-1,-1,17]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,1,1,0,0,0,1,1,0,0,0,0,1,1], [0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,1,1,1], [1,0,0,-1,0,1,1,0,-1,0,0,1,0,0,-1,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,-1,0,0,0,-1,-1,-1,-1,0,0,0,-1], [-1,0,0,0,-1,0,0,1,0,0,-1,0,0,0,-1,-1,-1], [0,0,-1,-1,-1,-1,0,0,0,-1,0,0,1,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [-1,0,0,1,0,0,-1,0,1,1,0,-1,0,0,1,0,0], [1,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,1,1], [0,0,0,0,1,1,0,0,0,1,1,1,0,0,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,-1,0,-1,0,-1,0,-1,0,-1], [0,0,1,0,0,-1,0,1,1,0,-1,0,0,1,0,0,-1], [0,1,0,0,-1,0,1,1,0,-1,0,0,1,0,0,-1,0], [-1,0,-1,0,-1,0,-1,0,0,0,0,0,0,0,0,-1,0]]]], [ # Z-class [17][24] [[8], [-1,8], [2,-1,8], [-1,2,-1,8], [-1,-1,2,-1,8], [-1,-1,-1,2,-1,8], [-1,-1,-1,-1,2,-1,8], [-1,-1,-1,-1,-1,2,-1,8], [2,-1,-1,-1,-1,-1,2,-1,8], [2,2,-1,-1,-1,-1,-1,2,-1,8], [-1,2,2,-1,-1,-1,-1,-1,2,-1,8], [-1,-1,2,2,-1,-1,-1,-1,-1,2,-1,8], [-1,-1,-1,2,2,-1,-1,-1,-1,-1,2,-1,8], [-1,-1,-1,-1,2,2,-1,-1,-1,-1,-1,2,-1,8], [-1,-1,-1,-1,-1,2,2,-1,-1,-1,-1,-1,2,-1,8], [2,-1,-1,-1,-1,-1,2,2,-1,-1,-1,-1,-1,2,-1,8], [-1,2,-1,-1,-1,-1,-1,2,2,-1,-1,-1,-1,-1,2,-1,8]], [[[1,1,0,0,0,-1,0,2,0,-1,0,0,0,1,1,-1,-1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [1,0,0,0,-1,0,2,0,-1,0,0,0,1,1,-1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,-1,0,2,0,-1,0,0,0,1,1,-1,-1,1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [-1,0,2,0,-1,0,0,0,1,1,-1,-1,1,1,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [-1,0,1,0,0,0,-1,-1,1,1,-1,-1,0,0,0,1,0], [0,0,0,-1,-1,1,1,-1,-1,0,0,0,1,0,-1,0,1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,-1,1,1,-1,-1,0,0,0,1,0,-1,0,1,0,0], [1,1,-1,-1,0,0,0,1,0,-1,0,1,0,0,0,-1,-1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,1,1,-1,-1,1,1,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,1,0,-2,0,1,0,0,0,-1,-1,1,1,-1,-1], [1,-1,-1,1,1,0,0,0,-1,0,1,0,-1,0,0,0,1], [0,1,0,0,0,-1,-1,1,1,-1,-1,0,0,0,1,0,-2], [-1,-1,1,1,0,0,0,-1,0,1,0,-1,0,0,0,1,1], [-1,0,0,0,1,0,-2,0,1,0,0,0,-1,-1,1,1,-1], [-1,-1,0,0,0,1,0,-2,0,1,0,0,0,-1,-1,1,1], [0,0,-1,0,1,0,-1,0,0,0,1,1,-1,-1,1,1,0], [0,0,0,-1,-1,1,1,-1,-1,0,0,0,1,0,-2,0,1], [0,-1,0,1,0,-1,0,0,0,1,1,-1,-1,1,1,0,0], [1,-1,-1,0,0,0,1,0,-2,0,1,0,0,0,-1,-1,1]]]] ]; MakeImmutable( IMFList[17].matrices ); gap-4r6p5/grp/glzmodmz.gi0000644000175000017500000003013112172557252014113 0ustar billbill############################################################################# ## #W glzmodmz.gi GAP library Stefan Kohl #W Alexander Hulpke ## ## #Y Copyright (C) 2011 The GAP Group ## ## This file contains the functionality for constructing clasical groups over ## residue class rings. ## ############################################################################# ## #F SizeOfGLdZmodmZ( , ) . . . . . . Size of the group GL(,Z/Z) ## ## Computes the order of the group `GL( , Integers mod )' for ## positive integers and > 1. ## InstallGlobalFunction( SizeOfGLdZmodmZ, function ( d, m ) local size, pow, p, q, k, i; if not (IsPosInt(d) and IsInt(m) and m > 1) then Error("GL(",d,",Integers mod ",m,") is not a well-defined group, ", "resp. not supported.\n"); fi; size := 1; for pow in Collected(Factors(m)) do p := pow[1]; k := pow[2]; q := p^k; size := size * Product([d*k - d .. d*k - 1], i -> q^d - p^i); od; return size; end ); ############################################################################# ## #M SpecialLinearGroupCons( IsNaturalSL, , Integers mod ) ## InstallMethod( SpecialLinearGroupCons, "natural SL for dimension and residue class ring", [ IsMatrixGroup and IsFinite, IsPosInt, IsRing and IsFinite and IsZmodnZObjNonprimeCollection ], function ( filter, d, R ) local G, gens, g, m, T; m := Size(R); if R <> Integers mod m or m = 1 then TryNextMethod(); fi; if IsPrime(m) then return SpecialLinearGroupCons(IsMatrixGroup,d,m); fi; if d = 1 then gens := [IdentityMat(d,R)]; else gens := List(GeneratorsOfGroup(SymmetricGroup(d)), g -> PermutationMat(g,d) * One(R)); for g in gens do if DeterminantMat(g) <> One(R) then g[1] := -g[1]; fi; od; T := IdentityMat(d,R); T[1][2] := One(R); Add(gens,T); fi; G := GroupByGenerators(gens); SetName(G,Concatenation("SL(",String(d),",Z/",String(m),"Z)")); SetIsNaturalSL(G,true); SetDimensionOfMatrixGroup(G,d); SetIsFinite(G,true); SetSize(G,SizeOfGLdZmodmZ(d,m)/Phi(m)); return G; end ); ############################################################################# ## #M GeneralLinearGroupCons( IsNaturalGL, , Integers mod ) ## InstallMethod( GeneralLinearGroupCons, "natural GL for dimension and residue class ring", [ IsMatrixGroup and IsFinite, IsPosInt, IsRing and IsFinite and IsZmodnZObjNonprimeCollection ], function ( filter, d, R ) local G, gens, g, m, T, D; m := Size(R); if R <> Integers mod m or m = 1 then TryNextMethod(); fi; if IsPrime(m) then return GeneralLinearGroupCons(IsMatrixGroup,d,m); fi; if d = 1 then gens := List(GeneratorsOfGroup(Units(R)), g -> [[g]]); else gens := List(GeneratorsOfGroup(SymmetricGroup(d)), g -> PermutationMat(g,d) * One(R)); T := IdentityMat(d,R); T[1][2] := One(R); Add(gens,T); for g in GeneratorsOfGroup(Units(R)) do D := IdentityMat(d,R); D[1][1] := g; Add(gens,D); od; fi; G := GroupByGenerators(gens); SetName(G,Concatenation("GL(",String(d),",Z/",String(m),"Z)")); SetIsNaturalGL(G,true); SetDimensionOfMatrixGroup(G,d); SetIsFinite(G,true); SetSize(G,SizeOfGLdZmodmZ(d,m)); return G; end ); BindGlobal("OrderMatrixIntegerResidue",function(p,a,M) local f,M2,o,e,MM,i; MM:=M; f:=GF(p); M2:=ImmutableMatrix(f,List(M,x->List(x,y->Int(y)*One(f)))); o:=Order(M2); M:=M^o; e:=p; i:=1; while iForAny(x,x->Int(x) mod e<>0)) then o:=o*p; M:=M^p; fi; od; Assert(1,IsOne(M)); return o; end); InstallGlobalFunction("ConstructFormPreservingGroup",function(arg) local oper,n,R,o,nrit, q,p,field,zero,one,oner,a,f,pp,b,d,fb,btf,eq,r,i,j,e,k,ogens,gens,gensi, bp,sol, g,prev,proper,fp,ho,evrels,hom,bas,basm,em,ngens,addmat,sub,transpose; oper:=arg[1]; R:=arg[Length(arg)]; n:=arg[Length(arg)-1]; q:=Size(R); if not IsPrimePowerInt(q) then TryNextMethod(); fi; p:=Factors(q)[1]; if p=2 then return fail;fi; field:=GF(p); zero:=Zero(field); one:=One(field); if Length(arg)=3 then g:=oper(n,p); else g:=oper(arg[2],n,p); fi; # get the form and get the correct -1's f:=InvariantBilinearForm(g).matrix; transpose:=not ForAll(GeneratorsOfGroup(g), x->TransposedMat(x)*f*x=f); if transpose then Info(InfoGroup,1,"transpose!"); if HasSize(g) then e:=Size(g); else e:=fail; fi; g:=Group(List(GeneratorsOfGroup(g),TransposedMat)); if e<>fail then SetSize(g,e); fi; fi; #IsomorphismFpGroup(g); # force hom for next steps f:=List(f,r->List(r,Int)); for i in [1..n] do for j in [1..n] do if f[i][j]=p-1 then f[i][j]:=-1; fi; od; od; nrit:=0; pp:=p; # previous p while ppList(PreImagesRepresentative(hom,x))); else fp:=fail; ogens:=GeneratorsOfGroup(prev); fi; ogens:=List(ogens,x->List(x,r->List(r,Int))); gens:=[]; for bp in [1..Length(ogens)+1] do if bp<=Length(ogens) then b:=ogens[bp]; else b:=One(ogens[1]); fi; d:=(TransposedMat(b)*f*b-f)*1/pp; # solve D+E^T*F*B+B^T*F*E=0 fb:=f*b; btf:=TransposedMat(b)*f; eq:=[]; r:=[]; for i in [1..n] do for j in [1..n] do # eq for entry i,j e:=ListWithIdenticalEntries(n^2,zero); for k in [1..n] do e[(k-1)*n+i]:=e[(k-1)*n+i]+fb[k][j]; e[(k-1)*n+j]:=e[(k-1)*n+j]+btf[i][k]; od; Add(eq,e); #RHS is -d entry Add(r,-d[i][j]*one); od; od; eq:=TransposedMat(eq); # columns were corresponding to variables if bp<=Length(ogens) then # lift generator sol:=SolutionMat(eq,r); # matrix from it sol:=List([1..n],x->sol{[(x-1)*n+1..x*n]}); sol:=List(sol,x->List(x,Int)); Add(gens,b+pp*sol); else # we know all gens oner:=One(Integers mod (pp*p)); gens:=List(gens,x->x*oner); g:=Group(gens); # d will be zero, so homogeneous sol:=NullspaceMat(eq); #Info(InfoGroup,1,"extend by dim",Length(sol)); proper:=p^Length(sol)*Size(prev); # proper order of group if ValueOption("avoidkerneltest")<>true then # vector space in kernel that is generated bas:=[]; basm:=[]; sub:=VectorSpace(field,bas,Zero(e)); addmat:=function(em) local c; e:=List(em,r->List(r,Int))-b; e:=1/pp*e; e:=Concatenation(e)*one; if p<257 then ConvertToVectorRep(e,p); fi; if not e in sub then Add(bas,e); Add(basm,em); sub:=VectorSpace(field,bas); fi; end; if fp<>fail then # evaluate relators evrels:=RelatorsOfFpGroup(fp); i:=1; while i<=Length(evrels) and Length(bas)e{[(x-1)*n+1..x*n]}); addmat(e); if e=basm[Length(basm)] then # was added Add(ngens,e); g:=Group(ngens); Info(InfoGroup,1,"added generator"); fi; od; fi; if fp <>fail then # extend presentation bas:=Basis(sub,bas); RUN_IN_GGMBI:=true; hom:=GroupGeneralMappingByImagesNC(g,fp,gens,GeneratorsOfGroup(fp)); hom:=LiftFactorFpHom(hom,g,"M",SubgroupNC(g,basm),rec( pcgs:=basm, prime:=p, decomp:=function(em) local e; e:=List(em,r->List(r,Int))-b; e:=1/pp*e; e:=Concatenation(e)*one; return List(Coefficients(bas,e),Int); end )); RUN_IN_GGMBI:=false; #simplify Image to avoid explosion of generator number fp:=Range(hom); if true then # remove redundant generators e:=PresentationFpGroup(fp); TzOptions(e).printLevel:=0; j:=Filtered(Reversed([1..Length(e!.generators)]), x->not MappingGeneratorsImages(hom)[1][x] in ngens); j:=e!.generators{j}; TzInitGeneratorImages(e); for i in j do TzEliminate(e,i); od; fp:=FpGroupPresentation(e); j:=MappingGeneratorsImages(hom); k:=TzPreImagesNewGens(e); k:=List(k,x->j[1][Position(OldGeneratorsOfPresentation(e),x)]); RUN_IN_GGMBI:=true; hom:=GroupHomomorphismByImagesNC(g,fp, k, GeneratorsOfGroup(fp)); RUN_IN_GGMBI:=false; fi; SetIsomorphismFpGroup(g,hom); fi; fi; SetSize(g,Size(prev)*Size(field)^Length(sol)); fi; od; pp:=pp*p; od; if transpose then e:=Size(g); g:=Group(List(GeneratorsOfGroup(g),TransposedMat)); SetSize(g,e); fi; SetInvariantBilinearForm(g,rec(matrix:=f*oner)); return g; end); ############################################################################# ## #M SymplecticGroupCons( , , Integers mod ) ## InstallOtherMethod( SymplecticGroupCons, "symplectic group for dimension and residue class ring for prime powers", [ IsMatrixGroup and IsFinite, IsPosInt, IsRing and IsFinite and IsZmodnZObjNonprimeCollection ], function ( filter, n, R ) local g; g:=ConstructFormPreservingGroup(SP,n,R); SetName(g,Concatenation("Sp(",String(n),",Z/",String(Size(R)),"Z)")); return g; end); ############################################################################# ## #M GeneralOrthogonalGroupCons ( , , Integers mod ) ## InstallOtherMethod( GeneralOrthogonalGroupCons, "GO for dimension and residue class ring for prime powers", [ IsMatrixGroup and IsFinite, IsInt,IsPosInt, IsRing and IsFinite and IsZmodnZObjNonprimeCollection ], function ( filter, sign,n, R ) local g; if sign=0 then g:=ConstructFormPreservingGroup(GO,n,R); SetName(g,Concatenation("GO(",String(n),",Z/",String(Size(R)),"Z)")); else g:=ConstructFormPreservingGroup(GO,sign,n,R); SetName(g,Concatenation("GO(",String(sign),",",String(n), ",Z/",String(Size(R)),"Z)")); fi; return g; end); ############################################################################# ## #M SpecialOrthogonalGroupCons( , , Integers mod ) ## InstallOtherMethod( SpecialOrthogonalGroupCons, "GO for dimension and residue class ring for prime powers", [ IsMatrixGroup and IsFinite, IsInt,IsPosInt, IsRing and IsFinite and IsZmodnZObjNonprimeCollection ], function ( filter, sign,n, R ) local g; if sign=0 then g:=ConstructFormPreservingGroup(SO,n,R); if g=fail then TryNextMethod();fi; SetName(g,Concatenation("SO(",String(n),",Z/",String(Size(R)),"Z)")); else g:=ConstructFormPreservingGroup(SO,sign,n,R); if g=fail then TryNextMethod();fi; SetName(g,Concatenation("SO(",String(sign),",",String(n), ",Z/",String(Size(R)),"Z)")); fi; return g; end); ############################################################################# ## #E glzmodmz.gi . . . . . . . . . . . . . . . . . . . . . . . . . . ends here gap-4r6p5/grp/imf.grp0000644000175000017500000016645312172557252013235 0ustar billbill############################################################################# ## #W imf.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y Copyright (C) 2000, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This is the main secondary file of the GAP library of irreducible maximal ## finite (imf) integral matrix groups. It contains a list IMFList of length ## 31 and a record IMFRec. ## ## Each entry IMFList[dim] of IMFList is a record which contains information ## about the Z-class representative groups (in case dim < 12 or dim in ## {13,17,19,23}, or about the Q-class representative groups (in case dim in ## {12,14,15,16,18,20,21,22,24,25,26,27,28,29,30,31}) of diminsion dim. More ## precisely, each of these records contains the following components: ## ## IMFList[dim].size the group size, ## IMFList[dim].isomorphismType the isomorphism type, ## IMFList[dim].isSolvable true, if the group is solvable, or false, ## else, ## IMFList[dim].elementaryDivisors the elementary divisors of the quadratic ## form, ## IMFList[dim].minimalNorm the norm of the "short vectors", ## IMFList[dim].orbitReps representatives of the orbits of short ## vectors, ## IMFList[dim].degrees sizes of the orbits of short vectors, ## i. e., the degrees of permutation ## representations on the orbits of the ## short vectors. ## ## Additional lists with the associated Gram matrices and matrix generators ## are provided in the files imf1to9.grp to imf31.grp of this library and ## will be loaded only if necessary. ## ## The record IMFRec contains the following components: ## ## IMFRec.maximalDimension the maximal dimension covered by the library, ## i.e., 31, ## IMFRec.numberQQClasses a list containing for each dimension dim the ## number of Q-classes of imf subgroups of ## GL(dim,Q), ## IMFRec.numberQClasses a list containing for each dimension dim the ## number of Q-classes of imf subgroups of dimension ## dim available in the library, i. e., the number ## of Q-classes of imf subgroups of GL(dim,Z), if ## dim is at most 11 or a prime at most 23, or the ## number of Q-classes of imf subgroups of ## GL(dim,Q), else, ## IMFRec.repsAreZReps a list containing for each dimension dim a flag ## which is true, if dim is at most 11 or a prime at ## most 23, or false, else, ## IMFRec.bNumbers a list containing for each dimension dim a list ## of lists which, for each available Q-class, give ## the list of the position numbers of its ## representatives with respect to the lists in ## IMFList, ## IMFRec.maximalQClasses a list containing for each dimension dim a list ## of lists which, for each available Q-class, give ## the Q-class number of the corresponding rational ## imf class. ## ############################################################################# ## ## BindGlobal( "IMFRec", rec( ) ); IMFRec.maximalDimension := 31; IMFRec.numberQQClasses := [1,2,1,3,2,6,2,9,2,8,2,19,4,12,6,31,3,17,2,31,8,12,4,65,5,16,5,37,2,33,4]; IMFRec.numberQClasses := [1,2,1,5,2,9,3,16,8,21,2,19,4,12,6,31,6,17,2,31,8,12,7,65,5,16,5,37,2,33,4]; IMFRec.repsAreZReps := [true,true,true,true,true,true,true,true,true,true,true,false,true,false, false,false,true,false,true,false,false,false,true,false,false,false, false,false,false,false,false]; IMFRec.bNumbers := [ [[1]], [[1],[2]], [[1..3]], [[2],[3],[5,6],[1],[4]], [[1..3],[4..7]], [[1..3],[7],[8,9],[12,13],[14],[15..17],[4,5],[6],[10,11]], [[1..3],[6,7],[4,5]], [[1..3],[4],[5],[6],[7],[14,15],[16],[18,19],[23..26],[11,12],[20,21],[22], [8,9],[10],[13],[17]], [[1..3],[15..18],[4..7],[8,9],[10,11],[12,13],[14],[19,20]], [[1..3],[14..19],[25],[32,33],[38..41],[42,43],[44,45],[46],[4],[5],[6,7], [8,9],[10,11],[12,13],[20..22],[23,24],[26,27],[28],[29,30],[31],[34..37]], [[1..3],[4..9]], [[1],[2],[3],[4],[5],[6],[7],[8],[9],[10],[11],[12],[13],[14],[15],[16], [17],[18],[19]], [[1..3],[4..7],[8..13],[14..17]], [[1],[2],[3],[4],[5],[6],[7],[8],[9],[10],[11],[12]], [[1],[2],[3],[4],[5],[6]], [[1],[2],[3],[4],[5],[6],[7],[8],[9],[10],[11],[12],[13],[14],[15],[16], [17],[18],[19],[20],[21],[22],[23],[24],[25],[26],[27],[28],[29],[30], [31]], [[1..3],[4..9],[17..24],[10,11],[12,13],[14..16]], [[1],[2],[3],[4],[5],[6],[7],[8],[9],[10],[11],[12],[13],[14],[15],[16], [17]], [[1..3],[4..9]], [[1],[2],[3],[4],[5],[6],[7],[8],[9],[10],[11],[12],[13],[14],[15],[16], [17],[18],[19],[20],[21],[22],[23],[24],[25],[26],[27],[28],[29],[30], [31]], [[1],[2],[3],[4],[5],[6],[7],[8]], [[1],[2],[3],[4],[5],[6],[7],[8],[9],[10],[11],[12]], [[1..8],[9..11],[22..24],[25..28],[16..21],[12,13],[14,15]], [[1],[2],[3],[4],[5],[6],[7],[8],[9],[10],[11],[12],[13],[14],[15],[16], [17],[18],[19],[20],[21],[22],[23],[24],[25],[26],[27],[28],[29],[30],[31], [32],[33],[34],[35],[36],[37],[38],[39],[40],[41],[42],[43],[44],[45],[46], [47],[48],[49],[50],[51],[52],[53],[54],[55],[56],[57],[58],[59],[60],[61], [62],[63],[64],[65]], [[1],[2],[3],[4],[5]], [[1],[2],[3],[4],[5],[6],[7],[8],[9],[10],[11],[12],[13],[14],[15],[16]], [[1],[2],[3],[4],[5]], [[1],[2],[3],[4],[5],[6],[7],[8],[9],[10],[11],[12],[13],[14],[15],[16], [17],[18],[19],[20],[21],[22],[23],[24],[25],[26],[27],[28],[29],[30],[31], [32],[33],[34],[35],[36],[37]], [[1],[2]], [[1],[2],[3],[4],[5],[6],[7],[8],[9],[10],[11],[12],[13],[14],[15],[16], [17],[18],[19],[20],[21],[22],[23],[24],[25],[26],[27],[28],[29],[30],[31], [32],[33]], [[1],[2],[3],[4]]]; IMFRec.maximalQClasses := [ [1], [1,2], [1], [1,2,3,1,2], [1,2], [1,2,3,4,5,6,1,1,2], [1,2,2], [1,2,3,4,5,6,7,8,9,3,4,4,5,5,5,6], [1,2,1,1,1,1,1,2], [1,2,3,4,5,6,7,8,1,1,1,1,1,1,2,2,3,3,3,4,4], [1,2], [1..19], [1..4], [1..12], [1..6], [1..31], [1,2,3,1,1,2], [1..17], [1,2], [1..31], [1..8], [1..12], [1,2,3,4,1,2,2], [1..65], [1..5], [1..16], [1..5], [1..37], [1,2], [1..33], [1..4]]; if IsBound( i ) then IMFRec.i := i; fi; BindGlobal( "IMFList", [ ] ); for i in [ 1 .. 31 ] do IMFList[i] := rec( ); od; ############################################################################# ## ## Sizes of the class representatives of the irreducible maximal finite ## integral matrix groups. ## IMFList[1].size := [ # Z-classes of dimension 1 2]; IMFList[2].size := [ # Z-classes of dimension 2 8, 12]; IMFList[3].size := [ # Z-classes of dimension 3 48, 48, 48]; IMFList[4].size := [ # Z-classes of dimension 4 384, 1152, 288, 144, 240, 240]; IMFList[5].size := [ # Z-classes of dimension 5 3840, 3840, 3840, 1440, 1440, 1440, 1440]; IMFList[6].size := [ # Z-classes of dimension 6 46080, 46080, 46080, 4608, 4608, 23040, 10368, 103680, 103680, 288, 288, 10080, 10080, 672, 240, 240, 240]; IMFList[7].size := [ # Z-classes of dimension 7 645120, 645120, 645120, 80640, 80640, 2903040, 2903040]; IMFList[8].size := [ # Z-classes of dimension 8 10321920, 10321920, 10321920, 2654208, 696729600, 6912, 497664, 62208, 62208, 41472, 725760, 725760, 2592, 115200, 115200, 28800, 57600, 1440, 1440, 1152, 1152, 3456, 672, 672, 672, 672]; IMFList[9].size := [ # Z-classes of dimension 9 185794560, 185794560, 185794560, 663552, 663552, 663552, 663552, 36864, 36864, 2304, 2304, 165888, 165888, 1152, 7257600, 7257600, 7257600, 7257600, 1440, 1440]; IMFList[10].size := [ # Z-classes of dimension 10 3715891200, 3715891200, 3715891200, 1857945600, 737280, 29491200, 29491200, 122880, 122880, 7680, 7680, 23040, 23040, 4147200, 4147200, 4147200, 4147200, 4147200, 4147200, 2073600, 2073600, 2073600, 480, 480, 29859840, 1866240, 1866240, 38880, 23040, 23040, 103680, 311040, 311040, 8640, 8640, 8640, 8640, 1440, 1440, 1440, 1440, 79833600, 79833600, 2640, 2640, 2640]; IMFList[11].size := [ # Z-classes of dimension 11 81749606400, 81749606400, 81749606400, 958003200, 958003200, 958003200, 958003200, 958003200, 958003200]; IMFList[12].size := [ # Q-classes of dimension 12 1961990553600, 9172942848, 21499084800, 2149908480, 78382080, 31104, 115200, 82944000, 2400, 2880, 1440, 8640, 203212800, 903168, 2688, 2688, 60480, 4032, 12454041600]; IMFList[13].size := [ # Z-classes of dimension 13 51011754393600, 51011754393600, 51011754393600, 174356582400, 174356582400, 174356582400, 174356582400, 22464, 22464, 22464, 22464, 22464, 22464, 31200, 31200, 31200, 31200]; IMFList[14].size := [ # Q-classes of dimension 14 1428329123020800, 16855282483200, 180592312320, 8491392, 48384, 17418240, 2615348736000, 10080, 80640, 4368, 2184, 4368]; IMFList[15].size := [ # Q-classes of dimension 15 42849873690624000, 41845579776000, 103680, 2903040, 17915904000, 10080]; IMFList[16].size := [ # Q-classes of dimension 16 1371195958099968000, 970864271032320000, 42268920643584, 89181388800, 17336861982720, 1036800, 4180377600, 95551488, 3732480, 79626240000, 288000, 57600, 1658880000, 3628800, 138240, 230400, 4147200, 172800, 86400, 2880, 17280, 960, 4032, 4032, 60480, 4032, 903168, 240, 240, 711374856192000, 9792]; IMFList[17].size := [ # Z-classes of dimension 17 46620662575398912000, 46620662575398912000, 46620662575398912000, 12804747411456000, 12804747411456000, 12804747411456000, 12804747411456000, 12804747411456000, 12804747411456000, 17825792, 17825792, 69632, 69632, 4896, 4896, 4896, 32640, 32640, 32640, 32640, 32640, 32640, 32640, 32640]; IMFList[18].size := [ # Q-classes of dimension 18 1678343852714360832000, 3916800, 6687075336192000, 50388480, 1872381094133760, 82944000, 105345515520000, 28800, 8640, 43545600, 6145155072000, 1820786688, 225792, 9792, 4896, 243290200817664000, 13680]; IMFList[19].size := [ # Z-classes of dimension 19 63777066403145711616000, 63777066403145711616000, 63777066403145711616000, 4865804016353280000, 4865804016353280000, 4865804016353280000, 4865804016353280000, 4865804016353280000, 4865804016353280000]; IMFList[20].size := [ # Q-classes of dimension 20 2551082656125828464640000, 243468982907043840, 656916480, 380160, 11520, 224685731296051200, 193491763200, 103195607040000, 829440, 103680, 4147200, 311040, 95551488000000, 120000, 172800, 161280, 1774080, 10080, 102181884343418880000, 483840, 80640, 12746807377920000, 15840, 13939200, 13939200, 15840, 31680, 479001600, 15840, 15840, 13680]; IMFList[21].size := [ # Q-classes of dimension 21 107145471557284795514880000, 146794677780086784000, 2903040, 52254720, 2903040, 1512000, 10080, 2248001455555215360000]; IMFList[22].size := [ # Q-classes of dimension 22 4714400748520531002654720000, 110361968640, 29658516531078758400, 1835540262420480000, 5748019200, 177408000, 3592512000, 51704033477769953280000, 12144, 12144, 24288, 24288]; IMFList[23].size := [ # Z-classes of dimension 23 1240896803466478878720000, 1240896803466478878720000, 1240896803466478878720000, 1240896803466478878720000, 1240896803466478878720000, 1240896803466478878720000, 1240896803466478878720000, 1240896803466478878720000, 216862434431944426122117120000, 216862434431944426122117120000, 216862434431944426122117120000, 85571854663680, 85571854663680, 41783132160, 41783132160, 489646080, 489646080, 489646080, 489646080, 489646080, 489646080, 84610842624000, 84610842624000, 84610842624000, 991533312000, 991533312000, 991533312000, 991533312000]; IMFList[24].size := [ # Q-classes of dimension 24 10409396852733332453861621760000, 2029289625631919702016000000, 8315553613086720000, 1728000, 1682857609853487022080, 940584960, 2773263883425546240000, 103680, 67184640, 4270826380475341209600, 12287500930252800, 59719680, 1934917632, 34560, 1981355655168, 1935360, 1161216, 31022420086661971968000000, 137594142720000000, 79626240000, 143327232000000, 145152000, 11520000, 16588800, 230400, 1728000, 138240, 311040, 4147200, 149299200, 17280, 247772652503040000, 387072, 4894274617344, 387072, 14450688, 5806080, 14450688, 387072, 52416, 112896, 30240, 103680, 5760, 34560, 7315660800, 32514048, 16128, 16128, 310206304349061120000, 134784, 74724249600, 1872, 12441600, 17915904000, 86400, 14400, 103680, 8064, 5376, 1820786688, 1209600, 80640, 31680, 2640]; IMFList[25].size := [ # Q-classes of dimension 25 520469842636666622693081088000000, 743008370688000000, 2073600, 235200, 806582922253211271168000000]; IMFList[26].size := [ # Q-classes of dimension 26 27064431817106664380040216576000000, 666248915354153228697600, 1009262592, 1946880000, 60800435652415979520000, 18720000, 1268047872, 24261120, 55024220160, 18720000, 62400, 31200, 31200, 187200, 1046139494400, 21777738900836704321536000000]; IMFList[27].size := [ # Q-classes of dimension 27 1461479318123759876522171695104000000, 2293666840313856000000, 725760, 22464, 609776689223427721003008000000]; IMFList[28].size := [ # Q-classes of dimension 28 81842841814930553085241614925824000000, 111929817779497742421196800, 13570563765858519346053120, 231158159769600000000, 1704603285530812549693440000, 606790169395200, 144207476195328, 203212800, 13005619200, 4682022912, 38158848, 9539712, 38158848, 13680098021793595392000000, 55024220160, 29030400, 2090188800, 349440, 1672151040, 2419200, 101896704, 1161216, 290304, 504000, 348364800, 80640, 2419200, 60480, 15692092416000, 483840, 52416, 26208, 26208, 26208, 26208, 48720, 17683523987479403909087232000000]; IMFList[29].size := [ # Q-classes of dimension 29 4746884825265972078944013665697792000000, 530505719624382117272616960000000]; IMFList[30].size := [ # Q-classes of dimension 30 284813089515958324736640819941867520000000, 20147367200309593635815424000, 6419592322744320000000, 1437659997167803170816000000, 12487741686153216000000, 16444762714275840, 95551488000000, 180551034077184000, 17915904000, 3052870564457742336000000, 110398464000, 110398464000, 16855282483200, 21499084800, 203212800, 3502105093579160420352000000, 103680, 78382080, 251073478656000, 67184640, 8640, 74649600, 483840, 17418240, 172800, 60480, 30240, 7257600, 483840, 48720, 29760, 59520, 16445677308355845635451125760000000]; IMFList[31].size := [ # Q-classes of dimension 31 17658411549989416133671730836395786240000000, 327360, 1488000, 526261673867387060334436024320000000]; ############################################################################# ## ## Elementary divisors of the quadratic forms associated to the class ## representatives of the irreducible maximal finite integral matrix groups, ## given in form of lists [ d1, exp1, d2, exp2, ... ]. ## IMFList[1].elementaryDivisors := [ # Z-classes of dimension 1 [1,1]]; IMFList[2].elementaryDivisors := [ # Z-classes of dimension 2 [1,2], [1,1,3,1]]; IMFList[3].elementaryDivisors := [ # Z-classes of dimension 3 [1,3], [1,1,4,2], [1,2,4,1]]; IMFList[4].elementaryDivisors := [ # Z-classes of dimension 4 [1,4], [1,2,2,2], [1,2,3,2], [1,1,3,2,9,1], [1,3,5,1], [1,1,5,3]]; IMFList[5].elementaryDivisors := [ # Z-classes of dimension 5 [1,5], [1,4,4,1], [1,1,4,4], [1,1,6,4], [1,4,6,1], [1,1,3,3,6,1], [1,1,2,3,6,1]]; IMFList[6].elementaryDivisors := [ # Z-classes of dimension 6 [1,6], [1,4,2,2], [1,2,2,4], [1,4,4,2], [1,2,4,4], [1,1,2,4,4,1], [1,3,3,3], [1,5,3,1], [1,1,3,5], [1,3,3,1,12,2], [1,2,4,1,12,3], [1,1,7,5], [1,5,7,1], [1,3,7,3], [1,3,5,3], [1,3,5,1,10,2], [1,2,2,1,10,3]]; IMFList[7].elementaryDivisors := [ # Z-classes of dimension 7 [1,7], [1,6,4,1], [1,1,4,6], [1,1,8,6], [1,6,8,1], [1,6,2,1], [1,1,2,6]]; IMFList[8].elementaryDivisors := [ # Z-classes of dimension 8 [1,8], [1,6,2,2], [1,2,2,6], [1,4,2,4], [1,8], [1,4,6,4], [1,4,3,4], [1,3,3,4,9,1], [1,1,3,4,9,3], [1,2,3,4,9,2], [1,7,9,1], [1,1,9,7], [1,1,3,3,9,3,27,1], [1,6,5,2], [1,2,5,6], [1,4,5,4], [1,1,5,6,25,1], [1,2,5,2,15,4], [1,4,3,2,15,2], [1,2,2,2,6,4], [1,4,3,2,6,2], [1,2,2,2,6,2,12,2], [1,1,3,4,21,3], [1,3,7,4,21,1], [1,5,7,2,21,1], [1,1,3,2,21,5]]; IMFList[9].elementaryDivisors := [ # Z-classes of dimension 9 [1,9], [1,8,4,1], [1,1,4,8], [1,6,4,3], [1,3,4,6], [1,7,4,2], [1,2,4,7], [1,5,4,4], [1,4,4,5], [1,4,4,4,16,1], [1,1,4,4,16,4], [1,2,4,6,16,1], [1,1,4,6,16,2], [1,2,4,5,16,2], [1,1,10,8], [1,8,10,1], [1,1,5,7,10,1], [1,1,2,7,10,1], [1,1,5,3,10,1,20,4], [1,4,2,1,4,3,20,1]]; IMFList[10].elementaryDivisors := [ # Z-classes of dimension 10 [1,10], [1,8,2,2], [1,2,2,8], [1,1,2,8,4,1], [1,4,2,2,4,4], [1,8,4,2], [1,2,4,8], [1,6,4,4], [1,4,4,6], [1,4,4,4,8,2], [1,2,2,4,8,4], [1,4,2,1,4,4,8,1], [1,1,2,4,4,1,8,4], [1,8,3,2], [1,2,3,8], [1,8,6,2], [1,2,6,8], [1,2,2,6,6,2], [1,2,3,6,6,2], [1,1,3,8,9,1], [1,1,3,7,6,1,18,1], [1,1,3,1,6,7,18,1], [1,4,2,2,4,2,12,2], [1,2,3,2,6,2,12,4], [1,5,3,5], [1,4,3,5,9,1], [1,1,3,5,9,4], [1,1,3,4,9,4,27,1], [1,5,3,3,12,2], [1,2,4,3,12,5], [1,5,3,5], [1,5,3,3,6,2], [1,2,2,3,6,5], [1,4,3,4,6,1,18,1], [1,1,3,1,6,4,18,4], [1,2,2,2,6,5,18,1], [1,1,3,5,9,2,18,2], [1,6,6,4], [1,4,6,6], [1,4,2,2,6,4], [1,4,3,2,6,4], [1,9,11,1], [1,1,11,9], [1,7,11,3], [1,3,11,7], [1,5,11,5]]; IMFList[11].elementaryDivisors := [ # Z-classes of dimension 11 [1,11], [1,10,4,1], [1,1,4,10], [1,1,12,10], [1,1,3,10], [1,1,4,9,12,1], [1,1,3,9,12,1], [1,10,3,1], [1,10,12,1]]; IMFList[12].elementaryDivisors := [ # Q-classes of dimension 12 [1,12], [1,6,2,6], [1,10,3,2], [1,6,3,6], [1,6,3,6], [1,6,2,2,6,4], [1,6,5,6], [1,9,5,3], [1,8,2,1,10,3], [1,8,5,2,10,2], [1,6,15,6], [1,6,15,6], [1,10,7,2], [1,6,7,6], [1,6,2,4,14,2], [1,6,14,6], [1,6,3,4,21,2], [1,6,21,6], [1,11,13,1]]; IMFList[13].elementaryDivisors := [ # Z-classes of dimension 13 [1,13], [1,12,4,1], [1,1,4,12], [1,1,14,12], [1,12,14,1], [1,1,7,11,14,1], [1,1,2,11,14,1], [1,6,3,7], [1,7,3,6], [1,7,3,5,12,1], [1,6,3,6,12,1], [1,1,4,5,12,7], [1,1,4,6,12,6], [1,1,2,8,10,4], [1,9,5,3,10,1], [1,1,2,3,10,9], [1,4,5,8,10,1]]; IMFList[14].elementaryDivisors := [ # Q-classes of dimension 14 [1,14], [1,12,2,2], [1,7,3,7], [1,7,3,7], [1,8,2,4,6,2], [1,7,3,5,6,2], [1,13,15,1], [1,8,5,5,15,1], [1,8,2,5,30,1], [1,7,13,7], [1,7,3,4,39,3], [1,9,13,4,39,1]]; IMFList[15].elementaryDivisors := [ # Q-classes of dimension 15 [1,15], [1,14,16,1], [1,10,3,5], [1,9,2,5,6,1], [1,12,6,3], [1,10,7,5]]; IMFList[16].elementaryDivisors := [ # Q-classes of dimension 16 [1,16], [1,16], [1,8,2,8], [1,8,2,8], [1,8,3,8], [1,8,3,8], [1,8,3,8], [1,8,6,8], [1,8,6,8], [1,12,5,4], [1,4,5,12], [1,10,5,6], [1,8,5,8], [1,8,5,8], [1,8,2,4,10,4], [1,8,10,8], [1,8,3,4,15,4], [1,8,15,8], [1,8,15,8], [1,8,15,8], [1,8,30,8], [1,8,6,4,30,4], [1,8,3,4,21,4], [1,8,3,2,21,6], [1,8,21,8], [1,8,21,8], [1,10,7,4,21,2], [1,12,11,4], [1,12,55,4], [1,15,17,1], [1,11,17,5]]; IMFList[17].elementaryDivisors := [ # Z-classes of dimension 17 [1,17], [1,16,4,1], [1,1,4,16], [1,1,18,16], [1,16,18,1], [1,1,9,15,18,1], [1,1,2,15,18,1], [1,16,2,1], [1,1,2,16], [1,9,4,8], [1,8,4,9], [1,1,4,8,16,8], [1,8,4,8,16,1], [1,1,9,7,18,1,36,8], [1,8,2,1,4,8], [1,8,2,1,4,7,36,1], [1,1,3,8,6,8], [1,9,2,7,6,1], [1,8,2,8,12,1], [1,8,2,8,6,1], [1,1,2,8,4,7,12,1], [1,1,3,7,6,9], [1,1,6,8,12,8], [1,1,3,7,6,8,12,1]]; IMFList[18].elementaryDivisors := [ # Q-classes of dimension 18 [1,18], [1,10,2,8], [1,15,3,3], [1,13,3,5], [1,9,3,9], [1,9,5,9], [1,16,10,2], [1,9,5,1,10,8], [1,9,3,3,15,6], [1,9,3,7,30,2], [1,15,7,3], [1,9,7,9], [1,9,7,9], [1,9,17,9], [1,8,2,5,34,5], [1,17,19,1], [1,9,19,9]]; IMFList[19].elementaryDivisors := [ # Z-classes of dimension 19 [1,19], [1,1,4,18], [1,18,4,1], [1,1,20,18], [1,18,20,1], [1,18,5,1], [1,1,5,17,20,1], [1,1,4,17,20,1], [1,1,5,18]]; IMFList[20].elementaryDivisors := [ # Q-classes of dimension 20 [1,20], [1,10,2,10], [1,10,2,10], [1,10,2,10], [1,12,3,8], [1,10,3,10], [1,10,3,6,6,4], [1,16,6,4], [1,8,2,8,6,2,12,2], [1,14,6,5,54,1], [1,12,6,8], [1,10,3,2,6,8], [1,15,5,5], [1,17,5,3], [1,15,5,1,30,4], [1,10,7,10], [1,10,7,10], [1,10,7,10], [1,19,21,1], [1,18,2,1,42,1], [1,13,3,1,6,5,42,1], [1,18,11,2], [1,18,11,2], [1,14,11,6], [1,10,11,10], [1,10,11,10], [1,10,2,6,22,4], [1,10,3,8,33,2], [1,10,3,4,33,6], [1,10,33,10], [1,13,19,6,57,1]]; IMFList[21].elementaryDivisors := [ # Q-classes of dimension 21 [1,21], [1,18,2,3], [1,15,2,6], [1,19,3,2], [1,14,6,6,12,1], [1,1,2,1,10,19], [1,13,5,2,15,5,30,1], [1,20,22,1]]; IMFList[22].elementaryDivisors := [ # Q-classes of dimension 22 [1,22], [1,1,3,19,6,2], [1,11,3,11], [1,20,12,2], [1,10,3,10,12,1,36,1], [1,21,5,1], [1,1,5,20,15,1], [1,21,23,1], [1,19,23,3], [1,17,23,5], [1,15,23,7], [1,11,23,11]]; IMFList[23].elementaryDivisors := [ # Z-classes of dimension 23 [1,1,24,22], [1,22,24,1], [1,22,6,1], [1,1,3,21,24,1], [1,1,2,21,6,1], [1,1,3,21,6,1], [1,1,8,21,24,1], [1,1,6,22], [1,23], [1,22,4,1], [1,1,4,22], [1,1,2,22], [1,22,2,1], [1,1,8,22], [1,22,8,1], [1,1,12,22], [1,22,12,1], [1,1,3,21,12,1], [1,22,3,1], [1,1,3,22], [1,1,4,21,12,1], [1,23], [1,22,4,1], [1,1,4,22], [1,1,2,21,6,1], [1,22,6,1], [1,1,3,21,6,1], [1,1,6,22]]; IMFList[24].elementaryDivisors := [ # Q-classes of dimension 24 [1,24], [1,24], [1,24], [1,16,2,8], [1,12,2,12], [1,12,2,12], [1,20,3,4], [1,20,3,4], [1,16,3,8], [1,12,3,12], [1,12,3,12], [1,12,2,8,6,4], [1,12,2,4,6,8], [1,12,2,4,6,8], [1,12,6,12], [1,12,6,12], [1,12,6,12], [1,23,25,1], [1,18,5,6], [1,12,5,12], [1,12,5,12], [1,12,5,12], [1,16,2,2,10,6], [1,16,5,4,10,4], [1,16,10,8], [1,12,5,4,10,8], [1,12,10,12], [1,12,5,4,15,8], [1,12,15,12], [1,12,15,12], [1,12,3,4,15,4,30,4], [1,20,7,4], [1,20,7,4], [1,12,7,12], [1,12,7,12], [1,12,2,8,14,4], [1,12,2,8,14,4], [1,12,14,12], [1,12,14,12], [1,12,13,12], [1,18,2,6], [1,12,2,12], [1,12,10,12], [1,12,15,4,30,8], [1,12,30,12], [1,12,3,8,21,4], [1,12,21,12], [1,12,6,8,42,4], [1,12,42,12], [1,22,13,2], [1,22,13,2], [1,12,3,10,39,2], [1,12,3,10,39,2], [1,18,5,2,15,4], [1,12,3,6,15,6], [1,12,3,6,15,6], [1,12,3,4,6,2,30,6], [1,14,3,2,6,7,30,1], [1,20,7,4], [1,18,2,2,14,4], [1,15,7,6,21,3], [1,18,5,2,35,4], [1,12,7,6,35,6], [1,12,22,12], [1,16,11,7,55,1]]; IMFList[25].elementaryDivisors := [ # Q-classes of dimension 25 [1,25], [1,20,6,5], [1,16,6,8,36,1], [1,16,7,8,14,1], [1,24,26,1]]; IMFList[26].elementaryDivisors := [ # Q-classes of dimension 26 [1,26], [1,13,3,13], [1,12,3,14], [1,2,2,16,10,8], [1,24,14,2], [1,26], [1,1,3,25], [1,19,3,7], [1,13,3,13], [1,13,5,13], [1,16,5,9,15,1], [1,12,2,8,10,6], [1,13,3,3,15,10], [1,13,3,5,15,6,30,2], [1,13,3,11,42,2], [1,25,27,1]]; IMFList[27].elementaryDivisors := [ # Q-classes of dimension 27 [1,27], [1,24,10,3], [1,19,7,7,28,1], [1,16,13,10,52,1], [1,26,28,1]]; IMFList[28].elementaryDivisors := [ # Q-classes of dimension 28 [1,28], [1,14,3,14], [1,14,2,14], [1,21,5,7], [1,24,2,4], [1,14,3,10,6,4], [1,14,3,14], [1,16,5,10,15,2], [1,16,2,10,30,2], [1,16,2,8,6,4], [1,14,13,14], [1,14,3,8,39,6], [1,18,13,8,39,2], [1,26,15,2], [1,2,2,26], [1,2,2,26], [1,2,2,26], [1,2,2,26], [1,12,2,14,4,2], [1,2,3,26], [1,14,3,14], [1,4,3,22,6,2], [1,12,3,4,6,10,18,2], [1,19,5,9], [1,21,5,3,10,4], [1,21,5,1,10,6], [1,1,3,13,15,13,45,1], [1,13,3,3,15,11,45,1], [1,13,3,13,15,1,45,1], [1,2,5,10,10,1,30,14,90,1], [1,20,13,6,26,2], [1,14,3,8,39,6], [1,13,3,5,39,9,117,1], [1,14,39,14], [1,4,2,10,78,14], [1,9,29,19], [1,27,29,1]]; IMFList[29].elementaryDivisors := [ # Q-classes of dimension 29 [1,29], [1,28,30,1]]; IMFList[30].elementaryDivisors := [ # Q-classes of dimension 30 [1,30], [1,15,3,15], [1,6,6,24], [1,25,3,5], [1,5,7,25], [1,15,7,15], [1,15,5,15], [1,15,3,9,6,6], [1,18,6,12], [1,27,11,3], [1,21,11,9], [1,15,11,15], [1,18,2,10,6,2], [1,20,3,10], [1,20,7,10], [1,28,16,2], [1,24,4,1,12,5], [1,15,3,15], [1,15,3,13,48,2], [1,24,2,1,6,5], [1,12,2,11,6,7], [1,20,3,4,6,5,18,1], [1,12,2,3,6,15], [1,14,3,4,6,11,18,1], [1,15,5,9,30,6], [1,15,3,5,21,10], [1,15,3,3,21,12], [1,24,6,1,42,5], [1,15,7,9,42,6], [1,15,29,15], [1,23,31,7], [1,15,31,15], [1,29,31,1]]; IMFList[31].elementaryDivisors := [ # Q-classes of dimension 31 [1,31], [1,20,2,10,4,1], [1,19,5,12], [1,30,32,1]]; ############################################################################# ## ## Solvability of the class representatives of the irreducible maximal ## finite integral matrix groups. ## IMFList[1].isSolvable := [ # Z-classes of dimension 1 true]; IMFList[2].isSolvable := [ # Z-classes of dimension 2 true, true]; IMFList[3].isSolvable := [ # Z-classes of dimension 3 true, true, true]; IMFList[4].isSolvable := [ # Z-classes of dimension 4 true, true, true, true, false, false]; IMFList[5].isSolvable := # Z-classes of dimension 5 ListWithIdenticalEntries( 7, false ); IMFList[6].isSolvable := [ # Z-classes of dimension 6 false, false, false, true, true, false, true, false, false, true, true, false, false, false, false, false, false]; IMFList[7].isSolvable := # Z-classes of dimension 7 ListWithIdenticalEntries( 7, false ); IMFList[8].isSolvable := [ # Z-classes of dimension 8 false, false, false, true, false, true, true, true, true, true, false, false, true, false, false, false, false, false, false, true, true, true, false, false, false, false]; IMFList[9].isSolvable := [ # Z-classes of dimension 9 false, false, false, true, true, true, true, true, true, true, true, true, true, true, false, false, false, false, false, false]; IMFList[10].isSolvable := # Z-classes of dimension 10 ListWithIdenticalEntries( 46, false ); IMFList[11].isSolvable := # Z-classes of dimension 11 ListWithIdenticalEntries( 9, false ); IMFList[12].isSolvable := [ # Q-classes of dimension 12 false, true, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false]; IMFList[13].isSolvable := # Z-classes of dimension 13 ListWithIdenticalEntries( 17, false ); IMFList[14].isSolvable := # Q-classes of dimension 14 ListWithIdenticalEntries( 12, false ); IMFList[15].isSolvable := # Q-classes of dimension 15 ListWithIdenticalEntries( 6, false ); IMFList[16].isSolvable := [ # Q-classes of dimension 16 false, false, true, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, true, true, false, false]; IMFList[17].isSolvable := [ # Z-classes of dimension 17 false, false, false, false, false, false, false, false, false, true, true, true, true, false, false, false, false, false, false, false, false, false, false, false]; IMFList[18].isSolvable := # Q-classes of dimension 18 ListWithIdenticalEntries( 17, false ); IMFList[19].isSolvable := # Z-classes of dimension 19 ListWithIdenticalEntries( 9, false ); IMFList[20].isSolvable := # Q-classes of dimension 20 ListWithIdenticalEntries( 31, false ); IMFList[21].isSolvable := # Q-classes of dimension 21 ListWithIdenticalEntries( 8, false ); IMFList[22].isSolvable := # Q-classes of dimension 22 ListWithIdenticalEntries( 12, false ); IMFList[23].isSolvable := # Z-classes of dimension 23 ListWithIdenticalEntries( 28, false ); IMFList[24].isSolvable := [ # Q-classes of dimension 24 false, false, false, false, false, false, false, false, false, false, false, false, true, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false]; IMFList[25].isSolvable := # Q-classes of dimension 25 ListWithIdenticalEntries( 5, false ); IMFList[26].isSolvable := # Q-classes of dimension 26 ListWithIdenticalEntries( 16, false ); IMFList[27].isSolvable := # Q-classes of dimension 27 ListWithIdenticalEntries( 5, false ); IMFList[28].isSolvable := # Q-classes of dimension 28 ListWithIdenticalEntries( 37, false ); IMFList[29].isSolvable := # Q-classes of dimension 29 ListWithIdenticalEntries( 2, false ); IMFList[30].isSolvable := # Q-classes of dimension 30 ListWithIdenticalEntries( 33, false ); IMFList[31].isSolvable := # Q-classes of dimension 31 ListWithIdenticalEntries( 4, false ); ############################################################################# ## ## Descriptions of the isomorphism types of the class representatives of the ## irreducible maximal finite integral matrix groups. ## IMFList[1].isomorphismType := [ # Z-classes of dimension 1 "C2"]; IMFList[2].isomorphismType := [ # Z-classes of dimension 2 "C2 wr C2 = D8", "C2 x S3 = C2 x W(A2) = D12"]; IMFList[3].isomorphismType := [ # Z-classes of dimension 3 "C2 wr S3 = C2 x S4 = W(B3)", "C2 wr S3 = C2 x S4 = C2 x W(A3)", "C2 wr S3 = C2 x S4 = C2 x W(A3)"]; IMFList[4].isomorphismType := [ # Z-classes of dimension 4 "C2 wr S4 = W(B4)", "W(F4)", "D12 wr C2 = (C2 x W(A2)) wr C2", "(D12 Y D12):C2", "C2 x S5 = C2 x W(A4)", "C2 x S5 = C2 x W(A4)"]; IMFList[5].isomorphismType := [ # Z-classes of dimension 5 "C2 wr S5 = W(B5)", "C2 wr S5 = C2 x W(D5)", "C2 wr S5 = C2 x W(D5)", "C2 x S6", "C2 x S6", "C2 x S6", "C2 x S6"]; IMFList[6].isomorphismType := [ # Z-classes of dimension 6 "C2 wr S6 = W(B6)", "C2 wr S6 = C2 x W(D6)", "C2 wr S6 = C2 x W(D6)", "(C2 x S4) wr C2 = (C2 x W(A3)) wr C2", "(C2 x S4) wr C2 = (C2 x W(A3)) wr C2", "subgroup of index 2 of C2 wr S6", "(C2 x S3) wr S3 = (C2 x W(A2)) wr S3 = D12 wr S3", "C2 x W(E6)", "C2 x W(E6)", "C2 x S3 x S4 = D12 x S4 = C2 x W(A2) x W(A3)", "C2 x S3 x S4 = D12 x S4 = C2 x W(A2) x W(A3)", "C2 x S7 = C2 x W(A6)", "C2 x S7 = C2 x W(A6)", "C2 x PGL(2,7)", "C2 x S5", "C2 x S5", "C2 x S5"]; IMFList[7].isomorphismType := [ # Z-classes of dimension 7 "C2 wr S7 = W(B7)", "C2 wr S7 = C2 x W(D7)", "C2 wr S7 = C2 x W(D7)", "C2 x S8 = C2 x W(A7)", "C2 x S8 = C2 x W(A7)", "W(E7)", "W(E7)"]; IMFList[8].isomorphismType := [ # Z-classes of dimension 8 "C2 wr S8 = W(B8)", "C2 wr S8 = C2 x W(D8)", "C2 wr S8 = C2 x W(D8)", "W(F4) wr C2", "W(E8)", "S3 x W(F4) = W(A2) x W(F4)", "D12 wr S4 = (W(A2) x C2) wr S4", "C2 x (S3 wr S4)", "C2 x (S3 wr S4)", "(C2 x (S3 wr C2)) wr C2", "C2 x S9 = C2 x W(A8)", "C2 x S9 = C2 x W(A8)", "C2 x (S3 wr S3)", "(C2 x S5) wr C2", "(C2 x S5) wr C2", "(SL(2,5) Y SL(2,5)):(C2 x C2)", "C2 x (S5 wr C2)", "C2 x S5 x S3", "C2 x S5 x S3", "W(F4)", "W(F4)", "S3 subd W(F4) = (C3 x (SL(2,3) Y SL(2,3)):C2).C2", "C2 x PGL(2,7)", "C2 x PGL(2,7)", "C2 x PGL(2,7)", "C2 x PGL(2,7)"]; IMFList[9].isomorphismType := [ # Z-classes of dimension 9 "C2 wr S9", "C2 wr S9", "C2 wr S9", "(C2 wr S3) wr S3", "(C2 wr S3) wr S3", "(C2 wr S3) wr S3", "(C2 wr S3) wr S3", "C2^9:(S3 wr C2)", "C2^9:(S3 wr C2)", "C2 x (S4 wr C2)", "C2 x (S4 wr C2)", "C2 x (S4 wr S3)", "C2 x (S4 wr S3)", "C2 x S4 x S4", "C2 x S10", "C2 x S10", "C2 x S10", "C2 x S10", "C2 x S6", "C2 x S6"]; IMFList[10].isomorphismType := [ # Z-classes of dimension 10 "C2 wr S10", "C2 wr S10", "C2 wr S10", "C2^9:S10", "C2^10:S6", "C2^10:(S5 wr C2)", "C2^10:(S5 wr C2)", "C2^10:S5", "C2^10:S5", "C2^6:S5", "C2^6:S5", "C2^5:S6", "C2^5:S6", "(C2 x S6) wr C2", "(C2 x S6) wr C2", "(C2 x S6) wr C2", "(C2 x S6) wr C2", "(C2 x S6) wr C2", "(C2 x S6) wr C2", "C2 x (S6 wr C2)", "C2 x (S6 wr C2)", "C2 x (S6 wr C2)", "(C2^2 x A5):C2", "(C2^2 x A5):C2", "(C2 x S3) wr S5", "C2 x (S3 wr S5)", "C2 x (S3 wr S5)", "C2 x (C3^4:C2):S5", "S3 x (C2 wr S5)", "S3 x (C2 wr S5)", "C2 x SU(4,2):C2", "(C6 x SU(4,2)):C2", "(C6 x SU(4,2)):C2", "D12 x S6", "D12 x S6", "D12 x S6", "D12 x S6", "C2 x S6", "C2 x S6", "C2 x S6", "C2 x S6", "C2 x S11", "C2 x S11", "C2 x PGL(2,11)", "C2 x PGL(2,11)", "C2 x PGL(2,11)"]; IMFList[11].isomorphismType := [ # Z-classes of dimension 11 "C2 wr S11 = W(B11)", "C2 wr S11 = C2 x W(D11)", "C2 wr S11 = C2 x W(D11)", "C2 x S12 = C2 x W(A11)", "C2 x S12 = C2 x W(A11)", "C2 x S12 = C2 x W(A11)", "C2 x S12 = C2 x W(A11)", "C2 x S12 = C2 x W(A11)", "C2 x S12 = C2 x W(A11)"]; IMFList[12].isomorphismType := [ # Q-classes of dimension 12 "C2 wr S12 = W(B12)", "W(F4) wr S3", "(C2 x W(E6)) wr C2", "D12 wr S6 = (C2 x S3) wr S6 = (C2 x W(A2)) wr S6", "C6.PSU(4,3).(C2 x C2)", "((3+^(1+2):SL(2,3)) x SL(2,3)).C2", "(C2 x S5) wr C2", "(C2 x S5) wr S3 = (C2 x W(A4)) wr S3", "(C2 x D10 x A5):C2", "(SL(2,5) Y SL(2,3)).C2", "C2 x S3 x S5", "(C2 x C3.A6).(C2 x C2)", "(C2 x S7) wr C2 = (C2 x W(A6)) wr C2", "(C2 x PGL(2,7)) wr C2", "(PSL(2,7) x D8):C2", "(PSL(2,7) x D8):C2", "C2 x S3 x S7 = C2 x W(A2) x W(A6)", "C2 x S3 x PGL(2,7)", "C2 x S13 = C2 x W(A12)"]; IMFList[13].isomorphismType := [ # Z-classes of dimension 13 "C2 wr S13 = W(B13)", "C2 wr S13 = C2 x W(D13)", "C2 wr S13 = C2 x W(D13)", "C2 x S14 = C2 x W(A13)", "C2 x S14 = C2 x W(A13)", "C2 x S14 = C2 x W(A13)", "C2 x S14 = C2 x W(A13)", "C2 x SL(3,3):C2", "C2 x SL(3,3):C2", "C2 x SL(3,3):C2", "C2 x SL(3,3):C2", "C2 x SL(3,3):C2", "C2 x SL(3,3):C2", "C2 x PSL(2,25):C2", "C2 x PSL(2,25):C2", "C2 x PSL(2,25):C2", "C2 x PSL(2,25):C2"]; IMFList[14].isomorphismType := [ # Q-classes of dimension 14 "C2 wr S14 = W(B14)", "W(E7) wr C2", "(C2 x S3) wr S7 = D12 wr S7 = (C2 x W(A2)) wr S7", "C2 x G2(3)", "(SU(3,3) x C4).C2", "S3 x W(E7) = W(A2) x W(E7)", "C2 x S15 = C2 x W(A14)", "C2 x S7", "C2 x S8", "C2 x PGL(2,13)", "C2 x PSL(2,13)", "C2 x PGL(2,13)"]; IMFList[15].isomorphismType := [ # Q-classes of dimension 15 "C2 wr S15 = W(B15)", "C2 x S16 = C2 x W(A15)", "C2 x W(E6)", "C2 x Sp(6,2)", "(C2 x S6) wr S3 = (C2 x W(A5)) wr S3", "C2 x S7"]; IMFList[16].isomorphismType := [ # Q-classes of dimension 16 "C2 wr S16 = W(B16)", "W(E8) wr C2", "W(F4) wr S4", "2+^(1+8).O+(8,2)", "(C2 x S3) wr S8 = (C2 x W(A2)) wr S8", "(SL(2,9) Y SL(2,9)).(C2 x C2)", "W(E8) x W(A2)", "(S3 x W(F4)) wr C2 = (W(A2) x W(F4)) wr C2", "((Sp(4,3) x C3) Y SL(2,3)).C2", "(C2 x S5) wr S4 = (C2 x W(A4)) wr S4", "(((SL(2,5) Y SL(2,5)):C2) x D10):C2", "C2 x (S5 x S5):C2", "((SL(2,5) Y SL(2,5)):(C2 x C2)) wr C2", "C2.A10", "S5 x W(F4)", "(SL(2,5) Y (D8 Y Q8).A5).C2", "(C2 x S3 x S5) wr C2", "S3 x (SL(2,5) Y SL(2,5)):(C2 x C2)", "(SL(2,5) Y SL(2,9)):C2", "(C2 x A6).(C2 x C2)", "(SL(2,5) Y ((SL(2,3) x C3).C2)).C2", "D120.(C4 x C2)", "(SL(2,7) Y C2.S3).C2", "C2 x S3 x PGL(2,7)", "(C2.A7 Y C2.S3).C2", "(SL(2,7) Y C2.S3).C2", "(C2 x PGL(2,7)) wr C2", "D120.C2", "D120.C2", "C2 x S17 = C2 x W(A16)", "C2 x PGL(2,17)"]; IMFList[17].isomorphismType := [ # Z-classes of dimension 17 "C2 wr S17", "C2 wr S17", "C2 wr S17", "C2 x S18", "C2 x S18", "C2 x S18", "C2 x S18", "C2 x S18", "C2 x S18", "C2^17:(C17:C8)", "C2^17:(C17:C8)", "C2^9:(C17:C8)", "C2^9:(C17:C8)", "C2 x PSL(2,17)", "C2 x PSL(2,17)", "C2 x PSL(2,17)", "C2 x SL(2,16):C4", "C2 x SL(2,16):C4", "C2 x SL(2,16):C4", "C2 x SL(2,16):C4", "C2 x SL(2,16):C4", "C2 x SL(2,16):C4", "C2 x SL(2,16):C4", "C2 x SL(2,16):C4"]; IMFList[18].isomorphismType := [ # Q-classes of dimension 18 "C2 wr S18 = W(B18)", "(C2 x Sp(4,4)).C2", "(C2 x W(E6)) wr S3", "(C2 x 3+^(1+4):Sp(4,3)).C2", "(C2 x S3) wr S9 = (C2 x W(A2)) wr S9", "(C2 x S5) wr S3", "(C2 x S10) wr C2 = (C2 x W(A9)) wr C2", "(C2 x A5 x A5).(C2 x C2)", "(C2 x C3.A6).(C2 x C2)", "C2 x S3 x S10 = C2 x W(A2) x W(A9)", "(C2 x S7) wr S3 = (C2 x W(A6)) wr S3", "(C2 x PGL(2,7)) wr S3", "(C2 x PSL(2,7) x PSL(2,7)).(C2 x C2)", "C2 x PGL(2,17)", "C2 x PSL(2,17)", "C2 x S19 = C2 x W(A18)", "C2 x PGL(2,19)"]; IMFList[19].isomorphismType := [ # Z-classes of dimension 19 "C2 wr S19", "C2 wr S19", "C2 wr S19", "C2 x S20", "C2 x S20", "C2 x S20", "C2 x S20", "C2 x S20", "C2 x S20"]; IMFList[20].isomorphismType := [ # Q-classes of dimension 20 "C2 wr S20", "W(F4) wr S5", "(SU(5,2) x SL(2,3)).C2", "C2.M12.C2", "(D8 x S6).C2", "(C2 x S3) wr S10 = (C2 x W(A2)) wr S10", "((SU(4,2) x C6):C2) wr C2", "(C2 x S6) wr S4 = (C2 x W(A5)) wr S4", "W(F4) x S6 = W(F4) x W(A5)", "(C2 x SU(4,2)).C2", "(C2 x S6) wr C2", "(SU(4,2) x C6).C2", "(C2 x S5) wr S5 = (C2 x W(A4)) wr S5", "C2 x 5+^(1+2):GL(2,5)", "C2 x S5 x S6 = C2 x W(A4) x W(A5)", "(C2.PSL(3,4)).(C2 x C2)", "C2.M22.C2", "C2 x S7", "C2 x S21 = C2 x W(A20)", "(C2 x PSL(3,4)).(C2 x S3)", "C2 x S8", "(C2 x S11) wr C2 = (C2 x W(A10)) wr C2", "(PSL(2,11) x D12).C2", "(C2 x PGL(2,11)) wr C2", "(C2 x PGL(2,11)) wr C2", "(PSL(2,11) x D12).C2", "(SL(2,11) Y SL(2,3)).C2", "C2 x S3 x S11 = C2 x W(A2) x W(A10)", "C2 x S3 x PGL(2,11)", "C2 x S3 x PGL(2,11)", "C2 x PGL(2,19)"]; IMFList[21].isomorphismType := [ # Q-classes of dimension 21 "C2 wr S21", "W(E7) wr S3", "W(E7)", "(C2 x PSU(4,3)).D8", "C2 x Sp(6,2)", "(C2 x PSU(3,5)).S3", "C2 x S7", "C2 x S22 = C2 x W(A21)"]; IMFList[22].isomorphismType := [ # Q-classes of dimension 22 "C2 wr S22 = W(B22)", "(C2 x PSU(6,2)).S3", "(C2 x S3) wr S11 = (C2 x W(A2)) wr S11", "(C2 x S12) wr C2 = (C2 x W(A11)) wr C2", "C2 x S3 x S12 = C2 x W(A2) x W(A11)", "(C2 x HS).C2", "(C2 x Mc).C2", "C2 x S23 = C2 x W(A22)", "C2 x PSL(2,23)", "C2 x PSL(2,23)", "C2 x PGL(2,23)", "C2 x PGL(2,23)"]; IMFList[23].isomorphismType := [ # Z-classes of dimension 23 "C2 x S24", "C2 x S24", "C2 x S24", "C2 x S24", "C2 x S24", "C2 x S24", "C2 x S24", "C2 x S24", "C2 wr S23", "C2 wr S23", "C2 wr S23", "C2 wr M23", "C2 wr M23", "C2^12:M23", "C2^12:M23", "C2 x M24", "C2 x M24", "C2 x M24", "C2 x M24", "C2 x M24", "C2 x M24", "C2 x Co2", "C2 x Co2", "C2 x Co2", "C2 x Co3", "C2 x Co3", "C2 x Co3", "C2 x Co3"]; IMFList[24].isomorphismType := [ # Q-classes of dimension 24 "C2 wr S24 = W(B24)", "W(E8) wr S3", "C2.Co1", "(((SL(2,5) Y SL(2,5)):C2) x A5).C2", "W(F4) wr S6", "(C6 x PSU(4,3).C2 Y SL(2,3)).C2", "(C2 x W(E6)) wr S4", "((C2 x C3.A6).C2 Y SL(2,3)).C2", "(Sp(4,3) x 3+^(1+2):SL(2,3)).C2", "(C2 x S3) wr S12 = (C2 x W(A2)) wr S12", "(C6.PSU(4,3).(C2 x C2)) wr C2", "W(F4) x W(E6)", "((3+^(1+2):SL(2,3) x SL(2,3)).C2) wr C2", "(C3.S6 x D8).C2", "(S3 x W(F4)) wr S3", "(C6.PSL(3,4).C2 Y D8).C2", "((SL(2,3) Y C4).C2 x PSU(3,3)).C2", "C2 x S25 = C2 x W(A24)", "(C2 x S5) wr S6 = (C2 x W(A4)) wr S6", "(C2 x S5) wr S4", "((SL(2,5) Y SL(2,5)):(C2 x C2)) wr S3", "(C2.J2 Y SL(2,5)):C2", "((C2 x D10 x A5).C2) wr C2", "((SL(2,5) Y SL(2,3)).C2) wr C2", "(SL(2,5) Y (D8 Y Q8).A5).C2", "(((SL(2,5) Y SL(2,5)):C2) x A5):C2", "W(F4) x S5", "(SL(2,5) Y (C2 x 3+^(1+2)).GL(2,3)).C2", "(C2 x S3 x S5) wr C2", "((C2 x C3.A6).(C2 x C2)) wr C2", "S3 x (SL(2,5) Y SL(2,3)).C2", "(C2 x S7) wr S4 = (C2 x W(A6)) wr S4", "(PSL(2,7) x W(F4)).C2", "(C2 x PGL(2,7)) wr S4", "(PSL(2,7) x W(F4)).C2", "((PSL(2,7) x D8).C2) wr C2", "W(F4) x S7 = W(F4) x W(A6)", "((PSL(2,7) x D8).C2) wr C2", "W(F4) x PGL(2,7)", "(SL(2,13) Y SL(2,3)).C2", "(SL(2,7) x PSL(2,7)).C2", "C6.A7:C2", "(C3.M10 x SL(2,3)).C2", "(A5 x ((C3 x D8).C2)).C2", "(C3.M10 x D8).C2", "(C2 x S3 x S7) wr C2 = (C2 x W(A2) x W(A6)) wr C2", "(C2 x S3 x PGL(2,7)) wr C2", "S3 x ((PSL(2,7) x D8).C2)", "S3 x ((PSL(2,7) x D8).C2)", "(C2 x S13) wr C2 = (C2 x W(A12)) wr C2", "((C2 x PSL(3,3)).C2 x C3).C2", "C2 x S3 x S13 = C2 x W(A2) x W(A12)", "(C2 x D78).C12", "C2 x S5 x W(E6) = C2 x W(A4) x W(E6)", "(C2 x S3 x S5) wr S3 = ((C2 x W(A2)) x W(A4)) wr S3", "(C2 x C3.PGL(2,9) x D10).C2", "S3 x (C2 x D10 x A5).C2", "(C2 x PSU(4,2)).C2", "SL(2,7) Y (C2.S4)", "(SL(2,7) Y Q16).C2", "(C2 x PGL(2,7)) wr S3", "C2 x S5 x S7 = C2 x W(A4) x W(A6)", "C2 x S5 x PGL(2,7)", "(SL(2,11) Y SL(2,3)).C2", "C2 x PSL(2,11):C2"]; IMFList[25].isomorphismType := [ # Q-classes of dimension 25 "C2 wr S25 = W(B25)", "(C2 x W(A5)) wr S5 = (C2 x S6) wr S5", "C2 x (S6 x S6):C2", "C2 x PGL(2,49)", "C2 x S26 = C2 x W(A25)"]; IMFList[26].isomorphismType := [ # Q-classes of dimension 26 "C2 wr S26 = W(B26)", "(C2 x S3) wr S13 = (C2 x W(A2)) wr S13", "(C2 x PGL(3,3):C2) wr C2", "(C2 x PSL(2,25):C2) wr C2", "(C2 x S14) wr C2 = (C2 x W(A13)) wr C2", "(C2 x PSp(4,5)).C2", "C2 x 3D4(2):C3", "C2 x PGL(4,3)", "(C2 x PSp(6,3) x C3).C2", "C2 x PSp(4,5):C2", "C2 x PGL(2,25):C2", "C2 x PSL(2,25):C2", "C2 x PSL(2,25):C2", "C2 x S3 x PSL(2,25):C2", "C2 x S3 x S14 = C2 x W(A2) x W(A13)", "C2 x S27 = C2 x W(A26)"]; IMFList[27].isomorphismType := [ # Q-classes of dimension 27 "C2 wr S27 = W(B27)", "(C2 x S10) wr S3 = (C2 x W(A9)) wr S3", "C2 x S9", "C2 x PGL(3,3):C2", "C2 x S28 = C2 x W(A27)"]; IMFList[28].isomorphismType := [ # Q-classes of dimension 28 "C2 wr S28 = W(B28)", "(C2 x S3) wr S14 = (C2 x W(A2)) wr S14", "W(F4) wr S7", "(C2 x S5) wr S7 = (C2 x W(A4)) wr S7", "W(E7) wr S4", "(W(A2) x W(E7)) wr C2", "(C2 x G2(3)) wr C2", "(C2 x S7) wr C2", "(C2 x S8) wr C2", "((SU(3,3) x C4).C2) wr C2", "(C2 x PGL(2,13)) wr C2", "(C2 x PSL(2,13)) wr C2", "(C2 x PGL(2,13)) wr C2", "(C2 x S15) wr C2 = (C2 x W(A14)) wr C2", "(Sp(6,3) x C3).C2", "(C2.J2 Y SL(2,3)).C2", "(C2 x PO+(8,2)):S3", "Sz(8):C3 x C4", "W(F4) Y W(E7)", "(C2 x J2).C2", "(C2 x S3 x G2(3)).C2", "(PSU(3,3) x (Q8 Y C4).S3).C2", "S3 x (PSU(3,3) x C4).C2", "C2 x PSU(3,5):C2", "W(A4) x W(E7)", "C2 x S8", "C2 x J2:C2", "C2 x W(A2) x S7", "C2 x W(A2) x W(A14)", "C2 x W(A2) x S8", "(SL(2,13) Y SL(2,3)).C2", "(C2 x W(A2) x PSL(2,13)).C2", "C2 x W(A2) x PGL(2,13)", "C2 x W(A2) x PGL(2,13)", "(C2 x PSL(2,13) x S3).C2", "C2 x PGL(2,29)", "C2 x S29 = C2 x W(A28)"]; IMFList[29].isomorphismType := [ # Q-classes of dimension 29 "C2 wr S29 = W(B29)", "C2 x S30 = C2 x W(A29)"]; IMFList[30].isomorphismType := [ # Q-classes of dimension 30 "C2 wr S30 = W(B30)", "(C2 x W(A2)) wr S15", "(C2 x W(A5)) wr S6", "(C2 x W(E6)) wr S5", "(C2 x W(A6)) wr S5", "(C2 x PGL(2,7)) wr S5", "(C2 x S5) wr S5", "((C6 x PSU(4,2)).C2) wr S3", "(C2 x S6) wr S3", "(C2 x W(A10)) wr S3", "(C2 x PGL(2,11)) wr S3", "(C2 x PGL(2,11)) wr S3", "(C2 x Sp(6,2)) wr C2", "(C2 x W(E6)) wr C2", "(C2 x W(A6)) wr C2", "(C2 x W(A15)) wr C2", "(C2 x PSU(4,2)):C2", "(C2 x C3.PSU(4,3)).(C2 x C2)", "C2 x W(A2) x W(A15)", "(C2 x PSU(4,2) x 3+^(1+2):SL(2,3)).C2", "(C2 x C3.S6).C2", "C2 x W(A5) x W(E6)", "(C2 x C3.PSL(3,4)).(C2 x C2)", "C2 x W(A2) x Sp(6,2)", "C2 x W(A5) x S5", "C2 x W(A2) x W(A6)", "C2 x C3.S7", "C2 x W(A5) x W(A6)", "C2 x W(A5) x PGL(2,7)", "C2 x PGL(2,29)", "C2 x PSL(2,31)", "C2 x PGL(2,31)", "C2 x S31 = C2 x W(A30)"]; IMFList[31].isomorphismType := [ # Q-classes of dimension 31 "C2 wr S31 = W(B31)", "C2 x PSL(2,32):C5", "C2 x PSL(3,5):C2", "C2 x S32 = C2 x W(A31)"]; ############################################################################# ## ## Norms of the short vectors for the class representatives of the ## irreducible maximal finite integral matrix groups. ## IMFList[1].minimalNorm := [ # Z-classes of dimension 1 1]; IMFList[2].minimalNorm := [ # Z-classes of dimension 2 1,2]; IMFList[3].minimalNorm := [ # Z-classes of dimension 3 1,3,2]; IMFList[4].minimalNorm := [ # Z-classes of dimension 4 1,2,2,4,2,4]; IMFList[5].minimalNorm := [ # Z-classes of dimension 5 1,2,4,5,2,4,3]; IMFList[6].minimalNorm := [ # Z-classes of dimension 6 1,2,2,2,3,3,2,2,4,4,6,6,2,4,3,4,5]; IMFList[7].minimalNorm := [ # Z-classes of dimension 7 1,2,4,7,2,2,3]; IMFList[8].minimalNorm := [ # Z-classes of dimension 8 1,2,2,2,2,4,2,4,6,4,2,8,8,2,4,4,8,8,4,4,3,6,8,6,4,14]; IMFList[9].minimalNorm := [ # Z-classes of dimension 9 1,2,4,2,3,2,4,3,4,4,9,6,8,6,9,2,8,4,12,4]; IMFList[10].minimalNorm := [ # Z-classes of dimension 10 1,2,2,4,4,2,4,3,4,4,5,4,5,2,4,2,5,3,4,5,6,9,4,8,2,4,6,10,4,8,3,4,6,4,10,6,8, 3,4,4,4,2,10,4,10,6]; IMFList[11].minimalNorm := [ # Z-classes of dimension 11 1,2,4,11,5,8,6,2,2]; IMFList[12].minimalNorm := [ # Q-classes of dimension 12 1,2,2,2,4,4,3,2,4,4,6,8,2,4,4,8,4,8,2]; IMFList[13].minimalNorm := [ # Z-classes of dimension 13 1,2,4,13,2,12,4,3,3,4,4,12,12,5,4,12,6]; IMFList[14].minimalNorm := [ # Q-classes of dimension 14 1,2,2,4,3,4,2,4,4,7,6,6]; IMFList[15].minimalNorm := [ # Q-classes of dimension 15 1,2,3,3,2,3]; IMFList[16].minimalNorm := [ # Q-classes of dimension 16 1,2,2,4,2,4,4,4,6,2,8,4,4,6,4,8,4,8,10,8,12,8,6,8,12,10,4,4,6,2,6]; IMFList[17].minimalNorm := [ # Z-classes of dimension 17 1,2,4,17,2,16,4,2,4,4,4,16,6,34,4,6,8,3,4,4,7,10,17,8]; IMFList[18].minimalNorm := [ # Q-classes of dimension 18 1,3,2,4,2,3,2,5,6,4,2,4,6,9,6,2,10]; IMFList[19].minimalNorm := [ # Z-classes of dimension 19 1,4,2,19,2,2,10,8,9]; IMFList[20].minimalNorm := [ # Q-classes of dimension 20 1,2,4,4,3,2,4,2,4,4,3,6,2,4,4,5,8,4,2,4,4,2,4,4,6,8,6,4,8,12,8]; IMFList[21].minimalNorm := [ # Q-classes of dimension 21 1,2,3,3,4,21,6,2]; IMFList[22].minimalNorm := [ # Q-classes of dimension 22 1,8,2,2,4,3,12,2,4,6,8,12]; IMFList[23].minimalNorm := [ # Z-classes of dimension 23 23,2,2,6,4,6,16,11,1,2,4,4,2,16,4,23,4,8,3,8,12,3,4,12,5,4,10,15]; IMFList[24].minimalNorm := [ # Q-classes of dimension 24 1,2,4,4,2,4,2,4,4,2,4,4,4,4,4,8,8,2,2,3,4,8,4,4,6,8,6,8,6,8,8,2,4,4,8,4,4,8, 8,12,4,4,8,10,16,4,8,8,16,2,4,4,6,4,4,8,8,6,4,4,4,4,8,12,6]; IMFList[25].minimalNorm := [ # Q-classes of dimension 25 1,2,4,6,2]; IMFList[26].minimalNorm := [ # Q-classes of dimension 26 1,2,3,5,2,3,8,4,6,5,6,4,6,8,4,2]; IMFList[27].minimalNorm := [ # Q-classes of dimension 27 1,2,4,6,2]; IMFList[28].minimalNorm := [ # Q-classes of dimension 28 1,2,2,2,2,4,4,4,4,3,7,6,6,2,6,6,6,6,4,8,6,8,6,4,4,4,16,8,4,24,6,8,12,14,26, 28,2]; IMFList[29].minimalNorm := [ # Q-classes of dimension 29 1,2]; IMFList[30].minimalNorm := [ # Q-classes of dimension 30 1,2,5,2,6,4,3,4,3,2,4,6,3,3,3,2,3,6,4,4,4,4,8,6,6,6,10,4,8,15,8,16,2]; IMFList[31].minimalNorm := [ # Q-classes of dimension 31 1,4,5,2]; ############################################################################# ## ## Degrees, i.e. orbit sizes of short vectors, for the class representatives ## of the irreducible maximal finite integral matrix groups. ## IMFList[1].degrees := [ # Z-classes of dimension 1 2]; IMFList[2].degrees := [ # Z-classes of dimension 2 4, 6]; IMFList[3].degrees := [ # Z-classes of dimension 3 6, 8, 12]; IMFList[4].degrees := [ # Z-classes of dimension 4 8, 24, 12, 18, 20, 10]; IMFList[5].degrees := [ # Z-classes of dimension 5 10, 40, 10, 12, 30, 30, 20]; IMFList[6].degrees := [ # Z-classes of dimension 6 12, 60, 12, 24, 16, 32, 18, 72, 54, 36, 24, 14, 42, 42, 20, 30, 24]; IMFList[7].degrees := [ # Z-classes of dimension 7 14, 84, 14, 16, 56, 126, 56]; IMFList[8].degrees := [ # Z-classes of dimension 8 16, 112, 16, 48, 240, 72, 24, 108, 24, 36, 72, 18, 54, 40, 20, 120, 50, 30, 60, 24, 32, 96, 42, 56, 84, 48]; IMFList[9].degrees := [ # Z-classes of dimension 9 18, 144, 18, 36, 24, 36, 18, 48, [18,144], 72, 32, 96, 36, 48, 20, 90, 90, 90, 30, 90]; IMFList[10].degrees := [ # Z-classes of dimension 10 20, 180, 20, 180, [20,240], 80, 20, 80, [20,80], 40, 64, 120, 32, 60, 60, 60, 24, 40, 60, 72, 60, 40, 60, 60, 30, 180, 30, 162, 120, 30, 80, 270, 240, 90, 36, 60, 90, 40, 30, 90, 30, 110, 22, [110,110], 132, 110]; IMFList[11].degrees := [ # Z-classes of dimension 11 22, 220, 22, 24, 132, 132, 132, 132, 132]; IMFList[12].degrees := [ # Q-classes of dimension 12 24, 72, 144, 36, 756, 216, 40, 60, [120,300], 360, 60, 270, 84, 84, [168,168], [168,168], 126, 126, 156]; IMFList[13].degrees := [ # Z-classes of dimension 13 26, 312, 26, 28, 182, 182, 182, 52, 104, 468, 234, 52, 104, 52, [130,650], 130, 130]; IMFList[14].degrees := [ # Q-classes of dimension 14 28, 252, 42, 756, 112, 378, 210, 210, [420,840], 156, 182, [182,364]]; IMFList[15].degrees := [ # Q-classes of dimension 15 30, 240, 240, 240, 90, 70]; IMFList[16].degrees := [ # Q-classes of dimension 16 32, 480, 96, 4320, 48, 720, 720, 144, 960, 80, 600, [200,240], 240, 2400, 240, 1200, 120, 360, 1440, 180, 480, [120,240], 336, [168,252], 1680, 336, 168, [120,120,120,120], [120,120,120], 272, [272,816]]; IMFList[17].degrees := [ # Z-classes of dimension 17 34, 544, 34, 36, 306, 306, 306, 306, 306, 34, 34, 34, 2176, 36, 204, [816,1224], 102, 136, [510,816], 2040, 816, 1020, 240, 102]; IMFList[18].degrees := [ # Q-classes of dimension 18 36, 240, 216, 6480, 54, 60, 180, 72, 180, 270, 126, 126, 336, 272, 204, 342, 342]; IMFList[19].degrees := [ # Z-classes of dimension 19 38, 38, 684, 40, 380, 380, 380, 380, 380]; IMFList[20].degrees := [ # Q-classes of dimension 20 40, 120, 3960, 3960, 80, 60, 540, 120, 360, 540, 80, 1440, 100, [300,6000,6000], 300, 112, [1540,4620], 70, 420, [840,6720,7560], 420, 220, [660,660,660,1980,1980,2640,3960], [220,220], 220, 660, 1320, 330, [330,330], 330, [570,1710]]; IMFList[21].degrees := [ # Q-classes of dimension 21 42, 378, 672, 1680, 630, 300, [210,210], 462]; IMFList[22].degrees := [ # Q-classes of dimension 22 44, 1782, 66, 264, 396, 2200, 550, 506, [506,506,506], [506,506,1012,2024], [506,1518,2024], 506]; IMFList[23].degrees := [ # Z-classes of dimension 23 48, 552, 552, 552, 552, 552, 552, 552, 46, 1012, 46, 46, 46, 46, [1012,64768], 48, [552,53130], 1518, 2576, 1518, 2576, 4600, 93150, 4600, 552, 75900, 22356, 552]; IMFList[24].degrees := [ # Q-classes of dimension 24 48, 720, 196560, [3600,8640], 144, 3024, 288, [2160,6480,12960], 2160, 72, 1512, 864, 432, 144, 216, [3024,7560], [4536,6048], 600, 120, 80, 360, 37800, [240,600], 720, 2400, 1800, 240, 1080, 120, 540, 1080, 168, [1008,3024], 168, [1008,3024], [336,336], 504, [336,336], 504, [2184,2184,8736], [2352,8064,14112], 3024, 1080, 144, [1080,1080], 252, 252, [504,504], [504,504], 312, [936,5616,8424], 468, [624,936], 720, 180, [1080,2160,2700], [360,900], [240,1440], [1008,1008,2016], 336, 252, 420, 420, 1320, [220,220,660]]; IMFList[25].degrees := [ # Q-classes of dimension 25 50, 150, 450, [350,2450], 650]; IMFList[26].degrees := [ # Q-classes of dimension 26 52, 78, 104, 104, 364, 3120, 1638, 4212, 21840, 312, [2600,3900], 130, 130, [390,1950], 546, 702]; IMFList[27].degrees := [ # Q-classes of dimension 27 54, 270, 756, 468, 756]; IMFList[28].degrees := [ # Q-classes of dimension 28 56, 84, 168, 140, 504, 756, 1512, 420, [840,1680], 224, 312, 364, [364,728], 420, 6720, 6720, 6720, 6720, 1512, 1260, 17472, 1512, 336, 350, 1260, 1260, 630, 630, 630, 210, 2184, 1092, [546,1092], 468, 168, 870, 812]; IMFList[29].degrees := [ # Q-classes of dimension 29 58, 870]; IMFList[30].degrees := [ # Q-classes of dimension 30 60, 90, 72, 360, 70, 210, 100, 810, 120, 330, [330,330], 330, 480, 480, 140, 480, 240, [3240,10080], 720, 3240, 180, 1080, 3780, 720, 300, 210, 630, 630, 630, 812, [930,1860,3720,3720,7440], 930, 930]; IMFList[31].degrees := [ # Q-classes of dimension 31 62, 2046, 372, 992]; ############################################################################# ## ## Orbit representatives of short vectors for the class representatives of ## the irreducible maximal finite integral matrix groups. ## i := IdentityMat( 1 ); IMFList[1].orbitReps := [ # Z-classes of dimension 1 i[1]]; i := IdentityMat( 2 ); IMFList[2].orbitReps := [ # Z-classes of dimension 2 i[1], i[1]]; i := IdentityMat( 3 ); IMFList[3].orbitReps := [ # Z-classes of dimension 3 i[1], i[1], i[1]]; i := IdentityMat( 4 ); IMFList[4].orbitReps := [ # Z-classes of dimension 4 i[1], i[1], i[1], i[1], i[1], i[1]]; i := IdentityMat( 5 ); IMFList[5].orbitReps := [ # Z-classes of dimension 5 i[1], i[1], i[1], i[1], i[1], i[1], i[1]]; i := IdentityMat( 6 ); IMFList[6].orbitReps := [ # Z-classes of dimension 6 i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1]]; i := IdentityMat( 7 ); IMFList[7].orbitReps := [ # Z-classes of dimension 7 i[1], i[1], i[1], i[1], i[1], i[1], i[1]]; i := IdentityMat( 8 ); IMFList[8].orbitReps := [ # Z-classes of dimension 8 i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1]]; i := IdentityMat( 9 ); IMFList[9].orbitReps := [ # Z-classes of dimension 9 i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], [i[7]-i[8]+i[9],i[1]], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1]]; i := IdentityMat( 10 ); IMFList[10].orbitReps := [ # Z-classes of dimension 10 i[1], i[1], i[1], i[1], [i[1],i[2]], i[1], i[1], i[1], [i[1],i[2]], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], [i[1],i[2]], i[1], i[1]]; i := IdentityMat( 11 ); IMFList[11].orbitReps := [ # Z-classes of dimension 11 i[1], i[1], i[1]+i[2], i[1], i[1], i[1]-i[2], i[1]-i[2], i[1]-i[2], i[1]]; i := IdentityMat( 12 ); IMFList[12].orbitReps := [ # Q-classes of dimension 12 i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], [i[4],i[1]], i[1], i[1], i[1], i[1], i[1], [i[1],i[7]], [i[1],i[6]], i[1], i[1], i[1]]; i := IdentityMat( 13 ); IMFList[13].orbitReps := [ # Z-classes of dimension 13 i[1], i[1], i[1]+i[2], i[1], i[1], i[1], i[1]-i[2], i[1]-i[3]+i[6], i[1], i[1], i[1], i[1]+i[2]+i[3]-i[6], i[1]+i[3], i[1], [i[1]+i[2],i[1]], i[1]+i[2], i[1]]; i := IdentityMat( 14 ); IMFList[14].orbitReps := [ # Q-classes of dimension 14 i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], [i[1],i[6]], i[1], i[1], [i[2],i[1]]]; i := IdentityMat( 15 ); IMFList[15].orbitReps := [ # Q-classes of dimension 15 i[1], i[1], i[1], i[1], i[1], i[1]]; i := IdentityMat( 16 ); IMFList[16].orbitReps := [ # Q-classes of dimension 16 i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], [i[1],i[7]], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], [i[4],i[1]], i[1], [i[9],i[1]], i[1], i[1], i[1], [i[1],i[2],i[4],i[5]], [i[1],i[3],i[7]], i[1], [i[3],i[1]]]; i := IdentityMat( 17 ); IMFList[17].orbitReps := [ # Z-classes of dimension 17 i[1], i[1], i[1]+i[2], i[1], i[1], i[1], i[1]-i[2], i[1]-i[2], i[1]-i[2], i[1]-i[2]-i[3]+i[4]+i[7]+i[15], i[1]-i[2]-i[5]+i[6]-i[12], i[1]+i[3]-i[4]+i[5]+i[7]-i[8]+i[9]+i[11], i[1]-i[3], i[1]-i[3]+i[6]-i[9]+i[11], i[1], [i[1]-i[9],i[1]], i[1]+i[6], i[1], [i[1],i[1]-i[5]], i[1], i[1], i[1], i[1], i[1]]; i := IdentityMat( 18 ); IMFList[18].orbitReps := [ # Q-classes of dimension 18 i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1]]; i := IdentityMat( 19 ); IMFList[19].orbitReps := [ # Z-classes of dimension 19 i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1]]; i := IdentityMat( 20 ); IMFList[20].orbitReps := [ # Q-classes of dimension 20 i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], [i[6]-i[7],i[1],i[2]], i[1], i[1], [i[1],i[2]], i[1], i[1], [i[20],i[5],i[1]], i[1], i[1], [i[1],i[8],i[10],i[12],i[13],i[3],i[2]], [i[1],i[2]], i[1], i[1], i[1], i[1], [i[1],i[3]], i[1], [i[5],i[1]]]; i := IdentityMat( 21 ); IMFList[21].orbitReps := [ # Q-classes of dimension 21 i[1], i[1], i[1], i[1], i[1], i[1], [i[1],i[1]+i[15]+i[20]], i[1]]; i := IdentityMat( 22 ); IMFList[22].orbitReps := [ # Q-classes of dimension 22 i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], [i[1],i[2],i[3]], [i[1],i[16],i[3],i[4]], [i[4],i[1],i[2]], i[1]]; i := IdentityMat( 23 ); IMFList[23].orbitReps := [ # Z-classes of dimension 23 i[1], i[1], i[1], i[1], i[1], i[1], i[2], i[1], i[1], i[1], i[1], i[1], i[1], i[12], [i[12],i[1]], i[1], [i[10],i[1]], i[14], i[11], i[6], i[12], i[1], i[2], i[2], i[7], i[1], i[6], i[18]]; i := IdentityMat( 24 ); IMFList[24].orbitReps := [ # Q-classes of dimension 24 i[1], i[1], i[1], [i[2],i[1]], i[1], i[1], i[1], [i[1],i[18],i[13]], i[1], i[1], i[1], i[1], i[1], i[1], i[1], [i[1],i[2]], [i[2],i[1]], i[1], i[1], i[1], i[1], i[1], [i[4],i[1]], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], [i[10],i[1]], i[1], [i[7],i[1]], [i[1],i[7]], i[1], [i[1],i[6]], i[1], [i[5],i[9],i[1]], [i[1],i[11],i[6]], i[1], i[1], i[1], [i[1],i[4]], i[1], i[1], [i[1],i[7]], [i[1],i[6]], i[1], [i[3],i[10],i[1]], i[1], [i[11],i[1]], i[1], i[1], [i[4]-i[23]-i[24],i[1],i[2]], [i[4],i[1]], [i[10],i[1]], [i[1],i[14],i[2]], i[1], i[1], i[1], i[1], i[1], [i[2],i[3],i[1]]]; i := IdentityMat( 25 ); IMFList[25].orbitReps := [ # Q-classes of dimension 25 i[1], i[1], i[1], [i[23],i[1]], i[1]]; i := IdentityMat( 26 ); IMFList[26].orbitReps := [ # Q-classes of dimension 26 i[1], i[1], i[1]-i[3]+i[6], i[1], i[1], i[1], i[1], i[1], i[1], i[1], [i[1],i[2]], i[1], i[1], [i[22]+i[23]+i[26],i[1]], i[1], i[1]]; i := IdentityMat( 27 ); IMFList[27].orbitReps := [ # Q-classes of dimension 27 i[1], i[1], i[1], i[1], i[1]]; i := IdentityMat( 28 ); IMFList[28].orbitReps := [ # Q-classes of dimension 28 i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], [i[1],i[28]], i[1], i[1], i[1], [i[2],i[1]], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], [i[1],i[28]], i[1], i[1], i[1], i[1]]; i := IdentityMat( 29 ); IMFList[29].orbitReps := [ # Q-classes of dimension 29 i[1], i[1]]; i := IdentityMat( 30 ); IMFList[30].orbitReps := [ # Q-classes of dimension 30 i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], [i[1],i[2]], i[1], i[1], i[1], i[1], i[1], i[1], [i[28],i[1]], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], i[1], [i[5],i[1],i[2],i[7],i[3]], i[1], i[1]]; i := IdentityMat( 31 ); IMFList[31].orbitReps := [ # Q-classes of dimension 31 i[1], i[1], i[1], i[1]]; for i in [ 1 .. 31 ] do MakeImmutable( IMFList[i].size ); MakeImmutable( IMFList[i].elementaryDivisors ); MakeImmutable( IMFList[i].isSolvable ); MakeImmutable( IMFList[i].isomorphismType ); MakeImmutable( IMFList[i].minimalNorm); MakeImmutable( IMFList[i].degrees ); MakeImmutable( IMFList[i].orbitReps ); od; if IsBound( IMFRec.i ) then i := IMFRec.i; Unbind( IMFRec.i ); else Unbind( i ); fi; ############################################################################# ## #E gap-4r6p5/grp/imf20.grp0000644000175000017500000027077412172557252013401 0ustar billbill############################################################################# ## #A imf20.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Q-class representative of the irreducible ## maximal finite integral matrix groups of dimension 20, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Q-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 20. ## IMFList[20].matrices := [ [ # Q-class [20][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[[0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [20][02] [[2], [0,2], [-1,1,2], [-1,1,1,2], [0,0,0,0,2], [0,0,0,0,0,2], [0,0,0,0,-1,1,2], [0,0,0,0,-1,1,1,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,-1,1,2], [0,0,0,0,0,0,0,0,-1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,-1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0]], [[-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [20][03] [[4], [-1,4], [0,0,4], [0,-2,0,4], [0,2,-2,-1,4], [0,1,-1,-2,0,4], [1,-1,-1,1,0,-1,4], [0,0,1,-1,-1,2,-2,4], [-1,0,0,-1,-1,1,-2,1,4], [0,0,-1,2,1,-1,1,-2,-2,4], [1,1,0,-1,0,1,1,0,-1,0,4], [-2,-1,0,1,-1,0,-1,1,2,0,-2,4], [1,-1,0,0,-1,1,1,0,-2,1,2,-1,4], [0,0,-2,-1,1,1,1,0,1,-1,1,0,0,4], [-1,0,1,-1,-1,0,-1,1,0,-1,0,1,1,-1,4], [-1,-1,2,0,-2,0,0,0,0,0,0,1,1,-2,1,4], [1,0,-1,-1,1,1,1,0,-1,0,1,-2,1,2,-2,-1,4], [1,1,-1,-1,2,-1,1,-1,-1,0,1,-1,0,1,1,-2,0,4], [-1,-1,1,1,-2,0,0,1,-1,0,0,0,1,-2,1,2,-1,-2,4], [-1,0,1,0,-1,-1,0,-1,-1,1,0,0,1,-2,2,2,-1,0,1,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,-1,0,-1,0,0,1,1,0,1,0,-1,0,0,0,-1,-1,-1,-1,0], [-1,0,-1,-1,-1,-1,0,1,-1,0,0,-1,1,-1,0,0,-1,-1,-2,-1], [0,0,0,1,0,0,0,1,1,0,0,-1,0,0,0,1,0,1,0,0], [0,-1,1,-1,0,1,0,-1,-1,0,1,2,-1,0,-1,-2,0,0,1,1], [0,0,-1,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [1,0,2,1,2,1,1,-2,2,-1,1,2,0,-1,1,-2,2,0,2,1], [-1,0,-2,-1,-1,-1,0,1,-1,0,0,-1,0,-1,0,1,-1,-1,-2,-1], [1,1,0,1,1,0,0,0,1,0,-1,0,1,1,0,1,0,0,1,0], [0,0,0,0,-1,0,0,1,0,1,0,-1,-1,1,0,1,0,1,0,0], [0,0,1,0,2,0,1,0,2,0,0,0,1,0,0,-1,0,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1], [0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,1,1,2,0,1,-1,2,-1,0,2,1,0,0,-1,1,0,2,1], [-1,-1,0,-1,0,0,0,0,-1,0,0,0,0,-1,0,0,0,0,-1,-1], [0,0,0,-1,-1,0,-1,-1,-1,0,0,0,0,0,0,0,0,0,0,-1], [0,1,-1,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,2,0,2,1,1,-1,1,0,1,2,0,-1,0,-2,1,0,1,1], [0,0,-1,0,-1,0,-1,0,-1,0,0,-1,-1,0,1,1,0,0,-1,-1], [-1,0,0,0,-1,0,0,1,0,1,-1,-2,0,0,0,1,0,1,-1,-1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,1,0,0,0,1,1,1,-1,-2,0,1,1,1,0,0,0,0], [1,1,0,1,0,0,0,0,1,0,-1,0,0,1,0,1,1,1,1,1], [1,-1,2,0,2,1,0,-2,0,-1,1,3,0,0,0,-2,1,0,2,1], [0,0,0,-1,0,0,0,0,-1,0,0,0,0,0,0,-1,-1,-1,0,0], [-1,0,-1,0,0,-1,1,2,1,1,0,-2,0,-1,1,1,0,-1,-2,-1], [-1,-1,0,-1,-1,0,0,0,-1,1,0,-1,0,0,0,0,-1,0,-1,-1], [1,1,0,1,1,0,1,0,2,0,0,1,0,-1,1,0,2,0,1,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,0,0,0,0,1,-1,0,0,-1,0,0,0,0,-1,0,-1,0], [-1,0,0,0,-1,0,0,1,0,1,-1,-2,0,0,0,1,0,1,-1,-1], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [-1,0,-1,0,-1,-1,0,1,-1,0,0,-1,0,-1,0,1,0,0,-2,-1], [-1,-1,0,-2,-1,0,0,-1,-1,0,1,1,0,-2,0,-2,0,-1,-1,-1], [0,2,-2,1,-2,-1,-1,1,-1,0,-1,-1,0,1,0,3,0,1,-1,-1], [-1,0,-1,0,-1,-1,0,2,0,1,-1,-2,0,1,-1,2,-1,1,-1,0], [-1,-1,0,-1,0,0,1,0,0,0,1,0,0,-2,0,-2,0,-1,-1,0], [0,1,-1,0,-2,0,-1,0,-2,0,-1,-1,0,1,0,1,-1,0,-1,-1], [0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,1,1,1,1,0], [-1,1,-1,1,-1,-1,0,2,0,0,-1,-2,1,1,-1,2,-1,1,-1,0]]]], [ # Q-class [20][04] [[4], [-2,4], [1,-1,4], [0,0,0,4], [1,-2,2,-1,4], [1,-1,0,0,0,4], [0,0,2,-1,2,-1,4], [-1,0,2,0,1,-1,1,4], [0,-1,2,0,2,0,1,2,4], [-2,2,0,1,-1,-2,0,1,1,4], [-1,2,0,1,-1,0,0,0,-1,1,4], [-2,2,-2,1,-2,-1,0,-1,-2,1,0,4], [2,-2,1,0,2,-1,0,0,0,-1,0,-2,4], [-1,-1,-1,-1,1,-1,0,-1,0,0,-2,1,0,4], [-1,0,-2,0,-1,0,-1,-1,-1,-1,-1,2,-1,1,4], [-2,0,0,-1,0,0,-1,1,1,1,-1,0,-1,2,0,4], [-1,0,0,-1,0,-2,1,0,-1,0,-1,1,0,2,0,1,4], [-1,1,-1,-1,0,-2,0,1,-1,1,1,0,1,0,-1,0,1,4], [0,1,1,0,0,-1,0,1,1,1,0,-1,0,0,-2,1,1,1,4], [-1,0,1,-2,1,-2,2,1,1,1,-1,0,0,1,0,1,2,1,0,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-2,-2,-1,-1,1,-2,-1,0,-1,-1,0,1,-1,-1,-2,-1,-1,-2,1,0], [1,0,0,0,-1,2,1,0,1,1,1,0,1,1,1,0,1,1,0,0], [1,1,-1,1,-1,1,2,1,0,0,0,-1,1,1,1,1,0,0,0,0], [1,0,0,0,0,1,0,0,1,1,1,0,0,0,1,0,1,1,0,0], [1,1,1,0,-2,1,1,0,1,0,0,0,1,1,1,0,0,1,0,0], [0,-2,0,-1,1,0,-1,0,0,1,1,1,-1,0,0,-1,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,1,0,0,1,0,1,0,0,0,1,0,1,1,0,0], [-1,-1,-1,0,1,0,0,0,-1,0,0,0,0,-1,0,0,0,-1,1,0], [0,-1,0,0,0,-1,1,-1,0,0,0,0,-1,-1,0,1,0,0,0,-1], [-1,-1,-1,-1,1,-1,-1,1,-1,0,0,1,0,0,-1,-1,-1,-2,1,0], [1,1,0,1,0,1,1,0,0,1,0,-1,0,0,1,1,1,1,-1,0], [0,1,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,-1,0,0,0,0,-1,-1,0,0,0,0,0,0,-1,-1], [0,1,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,1,0,-1,0,0,0,0,1,0,0,-1,0,0,0,0,0], [-1,-1,0,0,1,-1,-1,0,-1,0,0,0,-1,-1,-1,0,0,-1,0,0], [-1,0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,1,1,-1,0,0,1,0,0,0,0,0,-1,1,0,0,0]], [[-2,-2,-1,-1,2,-2,-2,0,-1,-1,0,1,-1,-2,-2,-1,-1,-2,1,1], [2,2,0,1,-2,2,1,1,1,1,0,-1,1,2,1,0,1,1,-1,0], [-1,0,0,0,0,0,0,0,-1,0,-1,-1,0,0,0,-1,0,0,0,0], [-1,-1,0,-1,0,0,-1,0,0,0,0,1,0,0,-1,-1,0,-1,1,0], [-1,1,1,1,0,0,0,-1,0,-1,-1,-1,0,0,0,0,0,1,-1,0], [-1,1,0,1,0,0,1,0,-1,0,-1,-2,0,0,0,0,0,0,0,0], [0,1,0,1,-1,1,1,0,0,0,-1,-1,1,1,0,0,0,1,-1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,1,0,-1,0,-1,-1,-1,-1,-1,-1,0,0,0,-1,1,0,0], [1,0,1,0,-1,1,0,0,0,1,0,0,0,1,1,0,0,1,0,0], [0,1,0,0,0,0,0,0,0,1,-1,-1,0,0,0,0,1,0,-1,-1], [2,1,0,0,-2,3,1,1,2,1,1,1,2,2,1,0,1,1,0,0], [-1,-1,0,-1,2,-2,-2,-1,0,-1,0,1,-1,-2,-1,0,0,-1,0,0], [1,0,1,0,0,1,0,0,1,0,1,1,0,1,1,0,0,1,0,0], [1,0,0,0,-1,1,1,0,2,0,1,1,1,0,1,1,1,1,0,-1], [1,0,1,0,0,0,0,0,0,0,1,0,-1,1,1,0,0,1,0,0], [1,-1,0,-1,0,0,0,0,1,0,1,2,0,0,0,0,0,0,0,0], [1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0], [0,0,0,0,0,-1,-1,1,-1,-1,0,0,-1,1,-1,-1,-1,-1,0,1], [1,0,1,0,-1,0,1,-1,1,0,0,0,0,0,1,1,0,2,-1,-1]]]], [ # Q-class [20][05] [[3], [0,3], [1,1,3], [0,0,1,3], [1,0,0,1,3], [0,0,0,0,0,3], [0,1,0,1,0,0,3], [0,0,0,0,0,1,0,3], [0,0,0,0,0,1,1,0,3], [1,0,0,0,0,0,0,0,0,3], [0,0,0,0,0,-1,1,0,0,1,3], [0,0,0,0,0,1,0,0,0,1,0,3], [0,0,1,0,0,1,0,0,0,-1,0,0,3], [0,0,1,0,-1,0,0,0,0,0,0,0,0,3], [0,0,0,-1,0,0,0,1,0,0,1,0,0,0,3], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,-1,3], [0,0,0,-1,0,0,0,-1,1,0,0,0,-1,1,0,0,3], [0,0,-1,0,0,1,1,0,0,0,0,0,0,0,-1,0,0,3], [0,-1,0,0,0,0,0,-1,0,0,0,1,1,-1,0,1,0,-1,3], [0,0,0,0,1,0,1,0,0,-1,0,0,0,0,1,0,1,0,1,3]], [[[-1,-1,1,-1,1,0,1,-1,0,1,-1,0,0,0,1,1,-1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [1,1,-1,1,-2,0,-2,0,1,0,1,0,0,0,-1,-1,-1,0,0,2], [0,1,0,0,0,0,-1,0,1,0,0,-1,-1,1,0,-1,-1,1,2,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,-1,0,0,-1,0,1,0,0,1,1,-1], [-1,-1,1,-1,1,1,1,-1,0,0,0,0,-1,0,0,1,-1,-1,-1,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,-1,1,1,1,0,-1,0,0,-1,-1,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,1,0,-1,0,1,0,0,-1,0,0,0,1,0,1,1,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,1,0,0,0,0,0,1,0,0,0,-1,-1,1,0,-1,0,1,3,-1]], [[1,2,-2,3,-2,-1,-3,1,1,0,1,0,1,0,0,-1,1,1,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,1,-1,1,1,0,0,0,-1,1,-1,-2,1,0,0,-1,1,2,-1], [0,2,0,0,1,0,-2,1,1,-1,1,-1,-2,2,0,-1,-1,2,4,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,-1,0,0,-1,0,1,0,0,1,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,1,-1,0,1,0,0,0,-1,1,0,-2,0,-1,-1,-1,0,1,0], [0,0,0,1,-1,0,-1,0,0,1,0,0,1,-1,0,0,1,0,-1,1], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,1,0,-1,0,0,1,1,-1,0,1,1,-1,-2,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,1,1,-1,-1,0,0,0,0,0,0,0,0,-1,-1,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,1,0,-1,0,1,0,0,-1,0,0,0,1,0,1,1,1,-1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,1,0,0,0,0,-1,0,0,-1,1,1,0,0,1,2,-2]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [1,0,-1,1,-1,0,0,0,0,0,0,0,1,-1,0,0,1,-1,-1,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [-1,-1,2,-2,1,0,1,0,0,0,0,0,-1,0,-1,0,-1,0,0,0], [0,0,1,0,0,0,0,0,0,-1,0,0,-1,0,1,0,0,1,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [1,1,-1,1,-2,0,-2,0,1,0,1,0,0,0,-1,-1,-1,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,-1,1,0,1,0,0,-1,0,0,-1,1,0,0,-1,0,1,-1], [0,-1,0,0,-1,0,0,0,0,1,0,0,1,-1,-1,0,0,-1,-2,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [20][06] [[2], [1,2], [0,0,2], [0,0,1,2], [0,0,0,0,2], [0,0,0,0,1,2], [0,0,0,0,0,0,2], [0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2]], [[[0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [20][07] [[4], [-1,4], [1,1,4], [2,0,2,4], [-2,2,1,-1,4], [-2,2,1,0,1,4], [-1,2,1,1,2,1,4], [1,-2,-2,-1,-2,-1,-1,4], [-1,2,-1,-2,2,0,0,-1,4], [2,-2,1,0,-1,-2,-2,1,-1,4], [0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,-1,4], [0,0,0,0,0,0,0,0,0,0,1,1,4], [0,0,0,0,0,0,0,0,0,0,2,0,2,4], [0,0,0,0,0,0,0,0,0,0,-2,2,1,-1,4], [0,0,0,0,0,0,0,0,0,0,-2,2,1,0,1,4], [0,0,0,0,0,0,0,0,0,0,-1,2,1,1,2,1,4], [0,0,0,0,0,0,0,0,0,0,1,-2,-2,-1,-2,-1,-1,4], [0,0,0,0,0,0,0,0,0,0,-1,2,-1,-2,2,0,0,-1,4], [0,0,0,0,0,0,0,0,0,0,2,-2,1,0,-1,-2,-2,1,-1,4]], [[[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,1,-1,1,1,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,-1,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,-1,0,-1,-1,0,0,0,0,0,0,0,0,0,0], [-1,1,0,1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,1,1,0,1,1,0,0,0,0,0,0,0,0,0,0], [1,1,-1,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,-1,0,1,-1,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,1,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,1,1,-1,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,0,0,-2,1,1,1,0,-1,-1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1,0,1,0,1,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,1,-1,-1,-1,0,1,1,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,1,1,0,-1,-1,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [20][08] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [0,0,0,0,0,2], [0,0,0,0,0,1,2], [0,0,0,0,0,1,1,2], [0,0,0,0,0,1,1,1,2], [0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [20][09] [[4], [0,4], [-2,2,4], [-2,2,2,4], [2,0,-1,-1,4], [0,2,1,1,0,4], [-1,1,2,1,-2,2,4], [-1,1,1,2,-2,2,2,4], [2,0,-1,-1,2,0,-1,-1,4], [0,2,1,1,0,2,1,1,0,4], [-1,1,2,1,-1,1,2,1,-2,2,4], [-1,1,1,2,-1,1,1,2,-2,2,2,4], [2,0,-1,-1,2,0,-1,-1,2,0,-1,-1,4], [0,2,1,1,0,2,1,1,0,2,1,1,0,4], [-1,1,2,1,-1,1,2,1,-1,1,2,1,-2,2,4], [-1,1,1,2,-1,1,1,2,-1,1,1,2,-2,2,2,4], [2,0,-1,-1,2,0,-1,-1,2,0,-1,-1,2,0,-1,-1,4], [0,2,1,1,0,2,1,1,0,2,1,1,0,2,1,1,0,4], [-1,1,2,1,-1,1,2,1,-1,1,2,1,-1,1,2,1,-2,2,4], [-1,1,1,2,-1,1,1,2,-1,1,1,2,-1,1,1,2,-2,2,2,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,0,1,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,-1,1,-1,0,0,0,0,0,1,-1,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0,1,-1,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,0]], [[-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,0,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,1,0,0,1,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,1,0,1,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,-1], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [20][10] [[4], [2,4], [2,2,4], [2,2,2,4], [2,2,2,2,4], [1,2,1,1,1,4], [1,1,1,2,1,2,4], [1,1,2,1,1,2,2,4], [1,1,1,1,2,2,2,2,4], [2,1,1,1,1,1,1,1,1,4], [1,1,1,1,2,1,1,1,2,2,4], [1,2,1,1,1,1,2,1,1,2,2,4], [2,1,1,1,1,1,1,1,1,2,1,1,4], [2,1,1,1,1,2,2,2,2,2,1,1,2,4], [1,2,1,1,1,1,1,2,1,1,1,2,1,1,4], [1,2,1,1,1,2,1,1,1,2,1,1,1,1,1,4], [1,2,1,1,1,2,1,1,1,1,1,1,2,1,1,2,4], [1,1,1,2,1,1,1,2,1,1,1,1,2,1,2,1,2,4], [1,1,2,1,1,1,1,1,1,1,2,1,1,2,1,1,1,1,4], [1,1,1,2,1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,1,1,-1,0,0,1,-1,-1,0,1,-1,0,1,0,0,-1,1,-1,0], [0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,-1,-1,1,0,0,1,0,0,0,0,-1,0], [0,1,1,-1,0,0,1,-1,-1,0,1,-1,-1,1,0,0,0,1,-1,0], [0,0,0,0,0,0,0,0,-1,0,1,0,0,1,0,0,0,0,-1,0], [-1,0,1,0,0,0,0,0,-1,0,1,0,0,1,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0], [0,0,1,-1,0,0,1,-1,-1,0,1,0,-1,1,0,0,0,1,-1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,1,-1,0,0,1,-1,-1,0,1,-1,-1,1,0,0,0,1,-1,0], [-1,1,1,-1,0,0,1,-1,-1,0,1,-1,0,1,0,0,-1,1,-1,0], [0,-1,0,0,0,0,-1,0,0,-1,0,1,0,1,0,1,0,0,0,1], [0,-1,0,0,0,1,-1,0,0,0,0,1,0,0,0,0,0,0,0,1], [0,1,0,-1,0,0,1,0,-1,0,1,-1,0,0,0,0,-1,1,0,0], [0,0,1,-1,0,0,1,-1,-1,0,1,-1,0,1,1,0,0,0,-1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,-1,1,0,0,1,0,0,0,0,0,0], [0,-1,0,0,1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,-1,1,0,0,0,0,0,0,0,0,0,-1,0,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,-1,0,0,0,0,-1,1,0,0,0,1,-1,0], [0,1,1,-1,0,0,1,-1,-1,0,1,-1,-1,1,0,0,0,1,-1,0], [1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,1,0,0,0,0,-1,0,-1,1,0,0,1,0,0,0,0,-1,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,-1]]]], [ # Q-class [20][11] [[3], [1,3], [1,1,3], [1,1,1,3], [-1,1,0,0,3], [-1,0,1,0,1,3], [-1,0,0,1,1,1,3], [0,-1,1,0,-1,1,0,3], [0,-1,0,1,-1,0,1,1,3], [0,0,-1,1,0,-1,1,-1,1,3], [0,0,0,0,0,0,0,0,0,0,3], [0,0,0,0,0,0,0,0,0,0,1,3], [0,0,0,0,0,0,0,0,0,0,1,1,3], [0,0,0,0,0,0,0,0,0,0,1,1,1,3], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,3], [0,0,0,0,0,0,0,0,0,0,-1,0,1,0,1,3], [0,0,0,0,0,0,0,0,0,0,-1,0,0,1,1,1,3], [0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,1,0,3], [0,0,0,0,0,0,0,0,0,0,0,-1,0,1,-1,0,1,1,3], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,1,-1,1,3]], [[[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,1,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,-1,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [20][12] [[6], [2,6], [3,3,6], [2,2,2,6], [3,2,3,2,6], [3,3,3,1,3,6], [2,3,3,2,2,3,6], [2,1,2,1,2,1,2,6], [2,3,3,1,2,3,0,2,6], [1,3,1,2,1,2,2,1,2,6], [2,2,2,3,0,1,1,2,2,2,6], [1,1,2,2,2,1,2,3,2,1,2,6], [2,2,1,1,1,-1,1,3,1,2,1,3,6], [2,1,2,2,2,1,-1,1,2,2,1,1,2,6], [2,2,1,1,2,2,2,1,0,0,0,-1,1,1,6], [3,2,1,3,2,2,0,0,2,1,2,0,0,2,1,6], [2,2,2,3,1,1,0,1,3,0,2,2,1,2,0,3,6], [3,2,3,1,0,3,2,1,2,2,3,2,1,1,0,2,2,6], [1,2,0,3,0,0,0,-1,1,2,2,1,2,2,2,3,3,2,6], [2,3,1,3,0,2,2,1,2,3,3,0,0,1,1,2,2,2,2,6]], [[[-1,-1,2,-1,-1,1,-2,-1,-2,2,0,2,1,-1,2,2,1,-1,-2,1], [-1,-1,2,-1,0,1,-1,0,-1,1,0,0,1,-1,0,1,0,-1,0,1], [-2,-2,0,-1,1,1,1,-1,0,0,1,-1,2,0,0,1,1,0,-1,1], [0,-1,2,-1,-1,0,-2,-1,-1,2,0,2,0,-1,2,1,1,-1,-2,1], [-1,-1,1,-1,0,1,-1,-1,-1,1,0,1,1,-1,1,1,1,-1,-1,1], [-1,-1,1,-1,0,1,0,0,-1,0,0,0,1,0,0,1,0,-1,0,1], [-1,-1,1,-1,0,1,0,0,0,0,0,0,1,0,0,1,0,-1,0,1], [-2,-2,0,0,1,1,1,-2,1,-1,1,-1,3,0,0,1,0,0,-1,1], [-2,-2,0,0,1,2,1,-1,0,-1,1,-2,3,0,-1,0,0,0,0,1], [0,-1,2,-1,-1,1,-1,0,-1,1,0,1,1,-1,0,1,0,-2,0,1], [-1,-2,2,-1,0,1,-1,-1,-1,1,1,0,2,-1,1,1,1,-1,-1,1], [-2,-2,0,0,1,1,1,-1,1,-1,1,-1,2,0,0,0,0,0,0,1], [-1,-1,1,0,0,0,-1,-1,0,1,0,1,1,-1,1,1,0,0,-1,1], [-1,-1,1,0,0,0,-1,-1,-1,1,0,1,1,-1,1,1,1,0,-2,1], [0,0,1,0,0,0,-2,0,-1,1,-1,1,0,-1,1,1,0,0,-1,1], [0,0,2,-1,-1,0,-2,-1,-2,2,0,2,0,-1,2,1,1,-1,-2,1], [-2,-1,0,0,1,1,0,-1,0,-1,1,-1,2,0,0,0,0,1,-1,1], [-1,-1,1,-1,0,1,0,0,-1,0,1,0,1,0,0,1,0,-1,0,1], [0,0,1,0,0,0,-2,0,-1,1,0,1,0,-1,1,0,0,0,-1,1], [0,-1,3,-1,-1,2,-2,0,-2,1,0,1,1,-1,0,1,0,-2,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,0,1,-1,0,-1,0,0,0,1,-1,0,0,0,0,0,1], [0,-1,1,-1,0,0,-1,-1,-1,1,0,1,1,-1,1,1,1,0,-1,1], [1,0,2,-1,-1,1,-2,0,-2,1,0,2,0,-1,0,1,0,-2,0,1], [1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,-1,0,1,0,1,-1,1,-1,1,-1,2,0,0,0,0,1,-1,1], [1,0,1,-1,-1,-1,-1,0,-1,2,0,2,-1,-1,2,1,1,-1,-1,0], [2,0,2,-1,-2,-1,-2,0,-2,3,-1,3,-2,-1,2,1,1,-1,-1,0], [1,-1,2,-1,-1,1,-1,0,-1,1,0,1,0,-1,0,0,0,-2,1,1], [0,-1,2,-1,-1,2,-1,0,-2,1,0,1,1,-1,0,1,1,-2,0,1], [0,-1,2,-1,-1,-1,-1,-1,-1,2,0,2,0,-1,2,2,1,-1,-2,1], [0,-1,2,-1,0,0,-1,0,-1,1,0,1,0,-1,1,1,0,-1,0,1], [1,-1,2,-1,-1,1,-1,0,-1,1,0,1,0,-1,0,1,0,-2,1,0], [0,0,0,0,0,1,0,1,0,-1,0,-1,1,0,-1,0,-1,0,1,0], [1,0,1,0,-1,1,-1,0,-1,0,0,1,0,0,0,0,0,-1,0,0], [1,0,2,-1,-1,0,-2,0,-2,2,0,2,-1,-1,1,1,1,-1,-1,0], [0,-1,2,-1,-1,1,-1,-1,-1,1,0,1,1,-1,1,1,1,-1,-1,1], [0,-1,3,-1,-1,2,-2,0,-2,1,0,1,1,-1,0,1,0,-2,0,1], [1,0,1,0,-1,1,-1,0,-1,1,0,1,0,-1,0,0,0,-1,0,0]]]], [ # Q-class [20][13] [[2], [1,2], [1,1,2], [1,1,1,2], [0,0,0,0,2], [0,0,0,0,1,2], [0,0,0,0,1,1,2], [0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0]], [[-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [20][14] [[4], [-1,4], [1,1,4], [-1,0,1,4], [-1,2,1,2,4], [1,0,-1,-2,0,4], [0,1,-1,-2,-1,2,4], [-2,1,1,1,0,-2,0,4], [-2,2,1,1,2,0,1,2,4], [-1,2,0,0,1,-1,0,0,0,4], [1,1,0,0,0,-1,-1,-1,-1,2,4], [-1,-1,-2,0,-1,1,0,-1,-1,-1,-1,4], [-1,-1,1,1,1,-1,-2,1,1,0,0,-1,4], [-2,-1,-1,1,-1,-2,0,2,1,0,0,0,1,4], [-1,2,2,1,2,0,-1,1,2,1,0,-1,1,-1,4], [-2,1,0,2,2,-2,-1,1,1,2,0,0,1,1,1,4], [-1,2,2,0,1,0,0,2,2,1,0,-1,1,0,2,0,4], [2,-2,1,0,-1,-1,-1,-1,-2,0,1,-1,1,0,-1,0,-1,4], [1,1,2,-1,1,0,-1,-1,0,1,1,-1,1,-2,1,0,1,1,4], [1,1,2,1,0,-2,0,1,0,0,1,-2,-1,0,0,0,0,1,0,4]], [[[-2,-2,0,1,-1,1,1,0,-1,-2,2,-2,-1,-1,0,2,1,-1,1,0], [1,1,-1,0,1,-1,1,-1,-1,0,-1,1,1,1,1,-1,1,0,0,1], [1,0,-2,1,0,1,1,0,-2,0,-1,0,1,2,1,0,1,-1,2,2], [1,1,0,0,-1,1,-1,0,1,2,-1,1,1,1,0,-1,-1,0,0,1], [1,1,-1,0,0,0,0,0,0,1,-1,1,1,1,1,-1,0,0,0,1], [-1,-1,0,0,0,-1,1,0,-1,-2,1,-1,-1,-1,1,1,1,0,0,-1], [0,0,0,-1,0,-1,0,-1,0,-1,0,0,0,-1,0,1,1,0,-1,0], [2,2,-1,0,0,0,-1,-1,0,1,-2,1,1,2,0,-1,0,0,0,1], [2,1,-2,0,0,-1,0,-1,0,1,-2,1,1,1,1,-1,1,0,0,1], [0,1,0,0,1,-1,1,0,-1,0,0,1,1,0,0,-1,0,0,0,0], [-1,-1,0,0,1,-1,1,0,0,0,1,0,0,-1,0,-1,0,0,0,0], [-1,1,2,0,-1,0,-1,0,1,0,0,-1,-1,-1,-1,0,-1,1,-1,-2], [1,1,-2,1,0,-1,1,0,-1,0,-1,0,1,1,1,-1,0,0,1,0], [1,1,0,-1,0,0,-2,0,2,2,-1,1,0,0,-1,-1,-1,1,-1,0], [2,0,-2,1,1,-1,2,0,-2,0,-1,1,1,2,2,-1,1,-1,2,1], [1,2,0,0,0,0,0,0,0,1,-1,1,1,1,0,-1,-1,0,0,0], [1,2,-2,1,0,0,0,-1,-2,0,-2,0,1,2,1,-1,1,0,1,1], [-1,-1,0,0,0,0,1,0,-1,-1,1,-1,0,0,0,1,0,-1,1,0], [-1,0,-1,1,0,0,1,0,-1,-1,0,-1,0,0,0,0,1,0,1,0], [1,-1,0,-1,1,1,0,0,0,1,0,1,1,1,0,0,0,-1,0,2]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,1,-1,0,1,-1,-2,-2,0,-1,1,1,1,1,1,-1,1,0], [0,0,-1,1,0,-1,2,0,-2,-2,1,-1,0,0,1,1,1,0,1,-1], [-1,0,1,0,0,0,0,0,1,0,1,0,0,-1,-1,0,0,1,-1,-1], [-1,2,0,1,-1,1,-1,0,0,-1,0,-1,0,0,-1,0,0,1,0,-1], [1,1,-1,0,0,1,-1,0,0,0,-1,0,0,1,0,0,0,0,0,1], [1,0,-2,1,0,-1,2,-1,-2,-1,-1,0,1,1,2,0,1,-1,1,1], [-1,0,-1,1,-1,0,1,-1,-1,-1,0,-1,0,0,1,1,1,0,1,0], [0,2,-2,2,-1,0,1,-1,-2,-1,-1,-1,1,1,1,0,1,0,1,0], [0,0,0,0,-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0], [0,0,2,-2,1,0,-1,0,1,1,0,1,0,0,-1,0,-1,0,-2,0], [-1,1,0,1,-1,0,-1,0,1,0,0,-1,-1,-1,-1,0,0,1,0,-1], [0,-1,0,0,1,-1,1,0,0,1,0,1,0,0,1,-1,0,0,0,0], [0,1,-1,1,-1,1,0,0,-1,-1,0,-1,0,1,0,1,1,0,1,0], [-1,1,1,0,-1,0,-1,0,1,0,0,0,0,-1,-1,0,0,1,-1,-1], [0,1,-1,1,-1,1,0,0,-1,-1,0,-1,0,1,1,1,0,0,1,0], [0,-2,1,0,1,-1,1,1,0,0,1,0,-1,-1,0,0,0,0,0,-1], [0,1,0,0,0,-1,0,0,-1,-1,0,-1,0,0,0,0,0,0,0,-1], [-1,-2,0,1,0,-1,3,0,-2,-2,2,-1,0,-1,1,1,1,-1,1,-1]]]], [ # Q-class [20][15] [[4], [2,4], [2,2,4], [2,2,2,4], [2,1,1,1,4], [1,2,1,1,2,4], [1,1,2,1,2,2,4], [1,1,1,2,2,2,2,4], [2,1,1,1,2,1,1,1,4], [1,2,1,1,1,2,1,1,2,4], [1,1,2,1,1,1,2,1,2,2,4], [1,1,1,2,1,1,1,2,2,2,2,4], [2,1,1,1,2,1,1,1,2,1,1,1,4], [1,2,1,1,1,2,1,1,1,2,1,1,2,4], [1,1,2,1,1,1,2,1,1,1,2,1,2,2,4], [1,1,1,2,1,1,1,2,1,1,1,2,2,2,2,4], [2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,4], [1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,2,4], [1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,2,2,4], [1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,2,2,2,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,-1,0,-1,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,-1,-1,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,1,-1,0,0,0,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,1,0,-1,0,0,0,0,0,-1,0,1,0,0,0,0], [0,0,0,0,1,0,0,-1,0,0,0,0,-1,0,0,1,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,1,-1,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0], [0,1,0,-1,0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0], [1,0,0,-1,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1], [-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0], [-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0,1,0,-1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0,1,0,0,-1], [0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,1,-1,0,0], [0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,1,0,-1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,1,0,0,-1], [0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,1,-1,0,0], [0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,1,0,-1,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1]]]], [ # Q-class [20][16] [[5], [0,5], [-1,0,5], [0,1,1,5], [0,1,1,1,5], [0,1,-1,1,1,5], [1,1,1,1,-1,-1,5], [1,1,-1,-1,-1,1,1,5], [1,1,0,-1,0,1,1,1,5], [0,1,0,1,1,1,-1,1,1,5], [1,-1,1,1,-1,1,1,1,1,1,5], [0,1,1,1,1,1,0,-1,0,1,0,5], [1,1,-1,1,-1,0,1,0,0,0,0,-1,5], [-1,1,1,-1,-1,-1,1,1,1,0,0,1,-1,5], [1,1,0,0,-1,1,0,1,1,1,0,-1,1,-1,5], [0,1,-1,1,1,1,-1,0,-1,1,0,1,-1,1,-1,5], [0,1,-1,1,1,1,1,1,1,1,-1,1,1,1,1,1,5], [1,1,1,-1,1,0,1,-1,1,-1,1,0,1,1,-1,1,-1,5], [1,1,1,1,0,-1,1,1,1,-1,1,-1,1,1,0,0,1,0,5], [-1,1,1,0,1,-1,1,1,1,0,-1,-1,-1,1,-1,-1,1,0,1,5]], [[[-1,-1,-1,0,1,0,1,0,0,0,0,1,0,0,1,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [1,0,0,-2,2,1,1,-2,0,-1,2,0,3,2,1,2,-2,-4,-1,2], [0,0,0,1,-1,0,-1,0,0,0,0,0,-1,0,0,-1,1,1,0,0], [0,-1,0,-1,1,1,1,-1,0,0,0,0,1,1,1,1,-1,-1,0,1], [0,0,0,0,-1,0,0,0,0,0,0,0,-1,-1,0,0,1,1,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,-1,0,0,1,-1,1,0,1,0,0,1,0,-1,-1,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,-2,2,0,1,-1,1,-2,2,1,3,1,1,3,-2,-4,-1,2], [0,1,1,0,-1,0,-1,0,0,0,0,-1,-1,-1,-1,-1,2,1,0,-1], [0,0,1,0,0,0,0,0,1,-1,0,0,1,0,0,1,0,-1,-1,0], [0,0,0,-1,0,1,1,-1,-1,1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,1,0,0,0,0,-1,1,0,1,1,0,0,0,-1,-1,0], [0,0,0,1,-1,0,0,0,0,1,-1,-1,-1,0,-1,-1,1,1,0,-1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,1,1,-1,-1,1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,1,1,0,0,1,-1,0,0,0,0,0,-1,0,1,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,1,0,2,-3,0,-1,1,-1,2,-2,-1,-4,-2,-2,-3,3,4,1,-2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,2,-2,0,-1,1,0,1,-2,0,-2,-1,-1,-2,1,3,1,-1], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0]]]], [ # Q-class [20][17] [[8], [4,8], [-2,0,8], [2,2,2,8], [1,2,4,4,8], [0,3,-2,2,-1,8], [-4,-4,2,-4,-2,-4,8], [4,4,0,2,2,0,-4,8], [4,4,-2,4,2,2,-4,4,8], [1,3,3,2,2,2,-3,3,-1,8], [-4,-4,4,0,2,-4,4,-4,-4,-1,8], [-4,-4,0,-4,-2,-2,4,-4,-4,-1,4,8], [-4,-4,3,0,0,0,4,-4,-4,1,4,4,8], [-4,-4,4,-1,0,-2,4,-4,-4,1,4,4,4,8], [0,-1,0,-3,0,-3,2,2,-1,0,-1,1,0,2,8], [-2,0,-1,-1,-4,4,0,-2,-2,2,-2,1,2,2,1,8], [0,4,2,1,0,1,-1,2,0,3,0,-2,-2,0,-1,2,8], [0,-4,-1,-4,-2,-4,2,-1,-4,-1,2,4,0,2,3,-1,-2,8], [-4,-2,4,2,3,0,0,0,-1,2,2,0,2,4,0,0,0,-1,8], [4,4,-2,0,-2,2,-4,4,0,3,-4,-4,-4,-4,0,2,4,0,-3,8]], [[[-3,2,-1,-1,1,-2,-1,2,1,-1,0,-2,2,3,-2,1,-1,1,-2,1], [-2,0,0,-1,1,-1,0,0,3,0,0,0,1,2,-1,0,-1,0,-1,3], [0,0,1,1,0,1,1,0,0,0,0,1,-1,0,0,0,-1,0,0,1], [-1,1,-1,0,1,0,1,1,1,0,1,-1,0,2,-1,1,-1,1,-1,1], [-1,1,0,0,0,0,0,1,1,0,1,-1,0,1,-1,1,-1,1,-1,0], [1,-1,0,0,0,0,1,-1,1,1,1,1,-1,-1,1,0,0,-1,1,1], [2,-1,1,1,-1,1,0,-1,-2,0,-1,2,-1,-2,1,-1,1,-1,1,-1], [-2,1,0,-1,1,-1,0,0,2,0,0,-1,1,1,-1,1,-1,1,-1,1], [-1,0,0,-1,1,-1,0,0,2,0,0,-1,1,1,-1,1,0,1,-1,1], [-1,1,0,0,0,0,0,0,1,0,1,0,0,1,0,0,-1,0,0,1], [1,0,0,1,-1,1,0,1,-2,0,0,0,-1,0,0,0,0,0,0,-2], [2,-1,1,1,-2,1,-1,-1,-2,0,0,1,-1,-2,2,-1,1,-1,1,-2], [2,0,0,1,-1,1,0,0,-2,0,1,1,-1,-1,1,0,0,-1,1,-1], [1,0,1,1,-1,1,0,-1,-1,0,0,1,-1,-1,1,-1,0,0,1,0], [-1,2,0,-1,0,-1,-1,0,1,-1,0,-1,2,1,-1,0,-1,1,0,1], [1,0,0,0,0,0,0,-1,0,0,0,1,0,0,1,-1,0,-1,1,1], [-1,0,0,-1,1,0,0,1,1,0,0,0,0,2,-1,0,-1,0,-1,1], [0,1,0,0,-1,0,-1,1,-2,-1,0,-1,0,0,0,0,0,0,0,-2], [1,-1,1,1,0,1,1,-2,0,1,0,1,-2,-2,1,0,0,0,1,0], [-2,1,-1,-1,1,-1,0,1,1,0,0,-1,1,2,-1,0,-1,0,-1,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0], [0,0,0,-1,0,0,-1,0,1,0,1,0,1,0,0,0,0,0,0,1], [0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,-1,0,0,0,0,0,-1], [0,0,0,1,0,0,1,-1,0,0,-1,1,0,-1,1,-1,0,0,1,1], [-1,0,0,0,0,0,0,-1,1,0,-1,0,1,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,-1], [-1,0,0,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0,-1,-1], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [20][18] [[4], [1,4], [1,1,4], [1,1,1,4], [-1,1,0,0,4], [-1,0,1,0,1,4], [-1,0,0,1,1,1,4], [0,-1,1,0,-1,1,0,4], [0,-1,0,1,-1,0,1,1,4], [0,0,-1,1,0,-1,1,-1,1,4], [1,-1,0,0,1,0,0,0,0,0,4], [1,0,-1,0,0,1,0,0,0,0,1,4], [1,0,0,-1,0,0,1,0,0,0,1,1,4], [0,1,-1,0,0,0,0,1,0,0,-1,1,0,4], [0,1,0,-1,0,0,0,0,1,0,-1,0,1,1,4], [0,0,1,-1,0,0,0,0,0,1,0,-1,1,-1,1,4], [0,0,0,0,1,-1,0,1,0,0,1,-1,0,1,0,0,4], [0,0,0,0,1,0,-1,0,1,0,1,0,-1,0,1,0,1,4], [0,0,0,0,0,1,-1,0,0,1,0,1,-1,0,0,1,-1,1,4], [0,0,0,0,0,0,0,1,-1,1,0,0,0,1,-1,1,1,-1,1,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,-1,0,0,0,1], [0,0,0,0,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0,-1,0,0,1,0], [0,0,0,0,0,-1,1,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,-1,1,0,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,1,0,-1,0,0,1,0,0], [0,0,0,0,-1,0,1,0,-1,0,0,0,0,0,0,0,0,1,0,0], [0,-1,0,1,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0], [-1,0,0,1,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0]], [[-1,0,1,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,1,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,0,0,1,0,0,0], [0,0,0,0,0,1,-1,0,0,1,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,0,-1,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,1,-1,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,-1,1,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [1,0,0,-1,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,1,-1,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0], [0,1,0,-1,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0], [0,0,1,-1,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,1,-1,0,1,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,1,0,-1,0,1,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,1,-1,0,0,1,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,1,-1,1,0,0,0,0,0,0,0,0,0,-1]]]], [ # Q-class [20][19] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]]]], [ # Q-class [20][20] [[4], [0,4], [-2,1,4], [-1,-2,-1,4], [-1,1,0,-1,4], [-2,0,0,0,2,4], [0,2,1,0,-1,0,4], [-2,0,2,1,-1,1,1,4], [2,1,-1,-2,0,-1,0,-1,4], [1,1,0,-2,1,-1,0,-1,1,4], [2,1,-1,0,0,-1,0,0,1,0,4], [-2,-1,1,0,0,2,0,2,-1,-1,-1,4], [-2,1,2,-1,0,0,1,1,0,0,-1,1,4], [-1,-2,-1,1,0,2,-1,1,-1,0,-1,2,-1,4], [2,2,-1,-2,1,-1,1,-2,2,2,1,-1,0,-1,4], [-2,-2,0,1,1,2,-2,0,-2,-1,-2,1,0,2,-2,4], [-2,1,1,-1,1,2,1,1,-1,1,-2,2,1,1,0,1,4], [-2,1,0,1,2,2,1,1,0,-1,0,1,1,0,0,0,1,4], [-2,-1,2,0,-1,0,0,2,0,0,-2,2,2,1,-1,1,1,0,4], [1,1,0,-2,1,1,1,0,1,2,1,1,0,1,2,-1,1,0,0,4]], [[[-5,-3,-2,-4,-1,-2,1,1,-1,-1,1,-2,-2,-1,1,0,0,1,0,1], [0,1,0,0,0,-1,-1,1,0,-1,-1,0,0,0,0,0,0,0,-1,1], [5,3,2,4,0,1,-2,-1,1,0,-1,1,2,1,-1,0,1,0,0,0], [1,0,0,0,0,2,0,-1,-1,1,1,0,0,0,0,-1,0,0,2,-1], [0,1,-1,-1,1,-2,1,1,0,0,-1,1,0,1,-1,1,-1,0,-1,0], [0,0,-1,-1,1,-1,1,1,0,0,-1,1,0,0,0,1,-1,0,-1,0], [0,0,0,0,0,0,-1,0,0,-1,0,-1,0,0,0,-1,1,0,0,1], [4,2,2,3,-1,2,-2,-1,0,1,-1,1,1,0,0,0,0,1,0,0], [-3,-2,0,-2,-2,-1,0,1,0,0,0,-1,-1,-1,1,1,0,1,-2,1], [0,0,0,0,1,-1,0,0,0,-1,0,-1,0,1,-1,-1,1,0,0,0], [-3,-1,-1,-3,-2,-1,0,1,-1,0,0,-1,-2,-1,1,1,-1,2,0,1], [2,1,1,2,0,1,0,0,1,1,-1,1,1,0,0,1,-1,0,-1,0], [3,3,2,4,0,1,-1,-1,2,1,-1,2,1,0,-1,1,0,-1,-1,0], [0,-1,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-3,-1,-1,-2,0,-2,1,1,0,-1,0,-1,-1,0,0,0,0,0,-1,1], [2,1,0,1,2,0,1,-1,0,0,0,1,1,1,-1,0,0,-1,1,-1], [2,1,0,1,2,0,0,0,0,-1,-1,0,1,1,-1,-1,0,-1,0,0], [1,1,0,0,0,0,0,1,0,1,-1,1,0,0,0,1,-1,0,-1,0], [5,2,3,4,0,2,-1,-2,1,1,0,1,2,1,-1,0,1,0,0,-1], [-2,-1,-1,-2,0,-2,1,1,0,-1,0,-1,-1,0,0,1,0,1,-1,1]], [[-5,-3,-2,-4,-1,-1,1,1,-1,-1,1,-2,-2,-1,1,0,0,0,0,1], [1,1,0,0,1,-2,0,0,0,-1,-1,0,0,1,-1,0,0,0,0,1], [5,2,2,3,1,1,-1,-1,0,0,0,0,2,2,-1,-1,1,0,1,-1], [-1,-1,-1,-1,0,0,1,1,0,1,0,1,0,-1,1,1,-1,0,-1,-1], [1,1,0,1,1,-1,0,0,0,0,-1,1,0,0,-1,0,0,0,0,1], [1,2,1,2,0,0,0,0,1,1,-1,2,0,0,0,1,-1,0,-1,0], [1,0,1,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,0,-1], [2,1,1,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,-1], [-2,-1,-1,-2,0,-1,0,0,-1,-2,0,-2,-1,0,0,-1,1,0,1,1], [0,-1,1,0,0,0,-1,0,0,-1,0,-1,0,0,0,-1,1,0,0,1], [-4,-2,-3,-4,1,-3,2,2,-1,-1,0,-1,-2,-1,0,1,-1,0,0,1], [2,2,2,3,0,1,-1,-1,1,1,0,1,1,1,0,0,0,0,0,-1], [4,2,1,2,1,1,-1,-1,0,0,0,0,1,1,-1,-1,1,0,2,-1], [-1,0,1,1,-1,1,0,0,1,1,0,1,0,-1,1,1,-1,0,-1,0], [-2,-1,-1,-2,0,-1,0,0,-1,-1,0,-1,-1,0,0,-1,0,0,1,1], [2,2,1,3,-1,2,-1,0,1,2,-1,2,1,-1,0,1,-1,0,-1,0], [3,2,3,3,-1,1,-2,-1,1,1,-1,1,1,1,0,0,0,1,-1,0], [1,1,0,1,1,-1,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [4,2,2,3,0,2,-2,-1,0,0,0,0,2,1,0,-1,1,0,1,-1], [-2,-1,0,-1,0,-1,0,1,0,-1,0,-1,-1,0,1,0,0,0,0,1]], [[-3,-1,-2,-2,1,-2,2,1,0,-1,0,0,-1,-1,0,1,-1,-1,0,1], [1,0,1,1,-1,0,-1,0,0,0,-1,0,1,0,0,0,0,1,-1,1], [4,2,3,4,0,2,-2,-2,1,1,0,1,2,1,-1,-1,1,0,0,-1], [-1,-1,-1,-1,0,0,0,1,0,0,0,0,-1,-1,1,0,0,0,0,0], [0,1,0,0,-1,0,0,0,0,1,-1,1,0,0,0,1,-1,1,-1,0], [1,0,0,-1,0,0,0,0,-1,0,0,0,0,1,0,0,0,1,0,-1], [1,-1,1,1,0,1,-1,0,0,-1,0,-1,1,0,1,-1,1,0,0,0], [2,0,1,1,1,0,-1,0,0,0,0,0,1,1,0,-1,1,0,0,-1], [-1,0,-1,-1,0,-1,1,1,0,0,0,0,0,0,0,1,-1,0,0,0], [-1,-1,0,-1,0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0], [-3,-1,-2,-2,1,-3,1,2,0,-1,-1,0,-1,-1,0,1,-1,0,-1,2], [2,1,1,2,1,1,-1,0,0,0,0,0,1,1,0,-1,1,-1,0,-1], [2,1,2,2,-1,1,-2,-1,0,0,0,-1,1,1,0,-1,1,1,0,0], [-2,-2,-1,-3,0,0,1,1,-1,0,1,-1,-1,0,1,0,0,0,0,-1], [-1,0,0,0,-1,0,0,1,0,0,-1,0,0,-1,1,1,-1,0,-1,1], [0,0,0,-1,-1,1,0,-1,-1,1,1,0,-1,0,0,0,0,1,1,-1], [2,0,1,1,0,2,-1,-1,-1,0,0,-1,1,1,0,-2,1,0,1,-1], [0,0,0,0,-1,0,-1,1,0,0,-1,0,0,0,1,0,0,1,-1,0], [3,1,2,2,0,2,-1,-1,0,1,1,0,1,1,0,-1,1,0,1,-2], [-1,-1,-1,-2,1,-1,1,1,-1,-1,0,-1,0,0,0,0,0,0,0,0]]]], [ # Q-class [20][21] [[4], [-1,4], [-2,2,4], [-1,0,0,4], [-1,-1,1,0,4], [-2,0,0,1,0,4], [-1,-1,1,-1,2,-1,4], [-1,-1,1,0,2,0,2,4], [-1,2,1,-1,-1,0,-1,-2,4], [-1,0,0,2,-1,1,0,0,-1,4], [-2,1,1,-1,0,1,0,0,1,0,4], [-1,2,1,0,0,0,0,1,1,0,1,4], [0,0,1,1,-1,0,0,0,-1,2,0,0,4], [1,0,-1,1,-2,0,-1,-1,-1,2,0,0,2,4], [2,0,0,-1,1,-2,0,0,0,-1,-1,0,0,0,4], [1,0,0,-2,1,-1,0,0,0,-1,1,0,0,0,2,4], [-2,-1,1,1,2,1,2,2,-1,1,0,0,0,-1,-1,-1,4], [-1,1,0,2,0,1,0,0,-1,2,0,1,1,1,-1,-1,1,4], [-1,-1,0,2,1,1,1,1,-2,2,0,0,1,1,-1,-1,2,2,4], [-1,-1,-1,-1,0,1,0,0,0,0,2,0,0,0,-1,1,0,0,0,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0], [0,1,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,1,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,0,0,0,0,0,-1,-1,0,0,1,0,0,0,0,0,0,-1,-1], [0,0,0,1,-1,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,-1,0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0], [-1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1,0,0,0], [1,0,0,1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,-1,0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,-1,0,0], [-1,-1,0,0,-1,0,0,-1,-1,0,0,1,0,-1,0,1,0,0,0,-1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [1,1,0,1,0,1,1,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,1,-1,0,0,0,0,1,1,0,0,-1,0,0,0,0,0,0,1,0], [0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0], [0,1,-1,0,1,0,0,0,0,0,0,0,1,0,-1,0,0,-1,0,0], [-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,1,0,0,-1,0,0,0,0,0,0,0,0], [0,1,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,-1,0,0], [0,1,-1,0,1,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0], [1,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0], [0,0,0,-1,1,-1,-1,0,0,1,0,0,0,0,0,-1,0,0,0,0], [-1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,-1,0,0], [-1,1,-1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,-1,0,0], [-1,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [20][22] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [20][23] [[4], [-1,4], [-1,0,4], [-2,1,2,4], [-1,-1,2,2,4], [1,1,-2,0,-2,4], [-1,-1,2,0,2,-2,4], [0,-1,1,1,0,0,0,4], [-2,0,0,1,1,-1,1,-1,4], [1,0,-2,-1,-2,1,-2,-1,1,4], [2,-1,1,-1,1,-1,1,1,-2,-1,4], [1,-2,-1,0,0,1,-1,2,0,1,0,4], [2,0,-2,-2,-2,1,-2,-1,0,2,0,0,4], [-1,2,1,1,1,0,0,-1,-1,-1,0,-1,-1,4], [-1,-1,2,0,0,-2,1,0,0,0,0,-1,-1,0,4], [1,-1,-1,0,-1,2,-1,2,-2,0,0,2,0,0,-1,4], [-2,2,2,2,1,-1,1,-1,2,0,-1,-2,-1,1,1,-2,4], [-1,2,-1,0,-2,1,-2,-1,1,2,-2,-1,1,0,0,-1,1,4], [2,-2,0,-1,1,-1,1,1,-1,0,2,1,0,-1,0,1,-1,-2,4], [1,-2,-1,0,0,1,-1,2,-1,0,1,2,0,-2,-1,2,-2,-1,1,4]], [[[1,-2,0,0,-2,0,-1,1,1,-1,0,-1,-1,1,-1,-1,1,0,0,0], [-1,-1,0,0,0,0,-1,0,-1,1,0,-1,-1,-1,-1,0,0,-1,0,-1], [0,-1,1,0,-1,0,-1,0,1,1,0,-1,-1,1,-1,-1,-1,-1,0,0], [-1,-1,1,0,0,0,0,-1,-1,1,0,0,0,0,-1,0,0,0,0,0], [0,0,0,1,0,-1,1,-1,-1,0,0,1,1,0,0,0,0,1,0,0], [-1,-1,0,0,-1,0,0,0,-1,0,0,0,0,0,-1,0,1,0,0,0], [0,0,0,1,-1,0,0,0,1,0,0,0,0,1,0,-1,-1,0,1,0], [0,0,1,-1,1,1,0,1,0,1,-1,-1,0,1,0,-1,-1,0,0,1], [0,1,1,0,0,0,0,-1,1,0,0,0,0,0,0,1,-1,0,1,0], [1,0,0,-1,0,0,-1,0,1,-1,0,0,-1,0,0,1,1,0,0,0], [1,-1,0,0,-1,0,-1,1,1,0,0,-1,-1,1,0,-1,0,0,0,0], [0,1,1,-1,1,0,1,0,-1,0,-1,1,1,0,0,0,0,1,0,1], [1,0,0,0,-1,0,-1,0,2,-1,1,-1,-1,0,0,1,0,0,0,0], [0,0,-2,2,0,-2,2,-1,-3,0,0,2,1,-1,0,0,1,1,-1,0], [1,1,-1,0,1,0,1,0,0,0,0,1,0,0,1,0,0,0,-1,0], [0,-1,-1,1,-1,0,1,0,-1,-1,0,1,1,1,0,-1,1,1,0,1], [0,-1,0,0,0,0,-1,0,0,1,0,-1,-1,0,-1,0,0,-1,0,-1], [0,0,0,-1,0,0,-1,0,1,0,0,-1,-1,0,0,1,0,-1,0,0], [1,-1,-1,0,0,0,0,1,0,-1,0,0,0,1,0,-1,1,1,0,0], [0,-1,1,-1,0,1,-1,1,1,0,0,-1,0,1,0,0,0,0,0,0]], [[0,-1,2,0,-2,0,-2,0,2,0,0,-1,-1,1,-1,-1,-1,-1,1,0], [1,-2,-1,1,-1,0,1,0,0,-1,0,0,0,1,0,0,1,1,0,0], [0,2,0,-1,2,0,1,0,0,1,0,0,0,-1,1,1,-1,0,-1,0], [0,1,0,-1,2,0,1,0,-1,1,0,0,0,-1,0,1,0,0,-1,0], [-1,2,1,-2,2,0,0,0,0,1,0,0,0,-1,0,1,-1,0,0,0], [1,-2,0,0,-1,0,-1,1,0,0,-1,-1,-1,1,-1,-1,1,-1,0,0], [0,2,-1,-1,3,0,2,1,-2,1,-1,1,1,-1,1,0,0,1,-1,0], [0,2,1,-1,1,1,0,0,1,1,0,0,0,0,1,0,-1,-1,0,1], [0,2,-2,1,2,-1,3,-1,-3,-1,0,3,2,-2,1,1,1,2,-1,0], [1,-1,-1,2,-2,-1,0,-1,0,-2,1,1,0,0,0,0,1,1,0,0], [-1,1,3,-2,0,1,-2,0,2,1,0,-1,-1,0,0,0,-2,-1,1,0], [0,1,1,-1,0,0,-1,0,1,0,0,0,0,0,0,0,0,-1,0,1], [0,0,1,1,-1,0,-1,-1,1,-1,0,0,0,0,0,0,-1,0,1,0], [1,-1,0,-1,0,0,-1,1,2,0,0,-2,-1,1,0,1,0,0,0,0], [0,1,-1,0,1,0,0,0,0,0,1,0,0,-1,1,1,0,0,-1,-1], [1,0,0,0,0,0,0,1,0,1,-1,-1,0,1,0,-1,0,-1,0,1], [1,1,-2,1,1,-1,3,-1,-2,-1,0,2,1,-1,1,1,1,2,-1,0], [1,-2,-2,3,-3,-1,1,-1,0,-2,1,1,0,1,0,0,1,1,0,0], [0,1,1,0,-1,0,0,0,1,0,0,0,0,1,0,-1,-1,0,1,1], [-1,0,2,-1,-1,1,-2,0,1,1,0,-1,-1,0,-1,-1,-1,-2,1,0]]]], [ # Q-class [20][24] [[4], [1,4], [-2,0,4], [-2,1,1,4], [-2,1,2,1,4], [-2,1,2,2,1,4], [-2,0,1,2,0,2,4], [-2,1,2,2,2,1,0,4], [-2,1,0,1,1,1,2,1,4], [1,2,1,-1,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,0,1,4], [0,0,0,0,0,0,0,0,0,0,-2,0,4], [0,0,0,0,0,0,0,0,0,0,-2,1,1,4], [0,0,0,0,0,0,0,0,0,0,-2,1,2,1,4], [0,0,0,0,0,0,0,0,0,0,-2,1,2,2,1,4], [0,0,0,0,0,0,0,0,0,0,-2,0,1,2,0,2,4], [0,0,0,0,0,0,0,0,0,0,-2,1,2,2,2,1,0,4], [0,0,0,0,0,0,0,0,0,0,-2,1,0,1,1,1,2,1,4], [0,0,0,0,0,0,0,0,0,0,1,2,1,-1,0,0,0,0,0,4]], [[[-2,1,0,0,-1,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,1,-1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,1,0,0,-1,-1,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-2,1,0,0,-1,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,-1,0,-1,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,1,1,-1,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,-1,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [2,-1,1,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [-1,1,1,-1,-1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [20][25] [[6], [-2,6], [0,-1,6], [0,0,-2,6], [2,-2,-2,-1,6], [2,2,1,0,-2,6], [-2,-1,2,-2,0,0,6], [-1,3,1,-2,0,2,2,6], [-3,2,-2,-2,0,-1,2,3,6], [-2,-2,2,1,0,-2,0,-2,-1,6], [0,0,0,0,0,0,0,0,0,0,6], [0,0,0,0,0,0,0,0,0,0,-2,6], [0,0,0,0,0,0,0,0,0,0,0,-1,6], [0,0,0,0,0,0,0,0,0,0,0,0,-2,6], [0,0,0,0,0,0,0,0,0,0,2,-2,-2,-1,6], [0,0,0,0,0,0,0,0,0,0,2,2,1,0,-2,6], [0,0,0,0,0,0,0,0,0,0,-2,-1,2,-2,0,0,6], [0,0,0,0,0,0,0,0,0,0,-1,3,1,-2,0,2,2,6], [0,0,0,0,0,0,0,0,0,0,-3,2,-2,-2,0,-1,2,3,6], [0,0,0,0,0,0,0,0,0,0,-2,-2,2,1,0,-2,0,-2,-1,6]], [[[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,-1,-1,-1,-1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,-1,-1,0,0,1,-1,1,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,1,1,0,-1,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0], [-1,-1,1,1,1,1,-1,0,1,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,-1,1,0,1,1,-1,-1,1,-1,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,1,0,1,0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,-2,-1,-1,0,0,1,-1,1,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,-1,-1,-1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,-1,-1,0,1,-1,0,0,0,0,0,0,0,0,0,0,0], [1,1,-1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [20][26] [[8], [2,8], [-2,2,8], [1,0,0,8], [-2,0,0,-2,8], [-1,4,2,0,2,8], [-1,-1,0,0,3,0,8], [1,-1,-2,0,2,0,-2,8], [1,-2,1,1,0,1,-1,1,8], [0,-2,2,-2,2,0,0,1,0,8], [-2,2,1,0,0,2,0,0,0,-3,8], [2,0,0,0,1,-1,2,1,0,-1,2,8], [0,2,1,-2,3,2,4,0,2,0,0,0,8], [-1,0,3,2,0,2,2,2,3,-1,2,2,3,8], [0,1,3,-2,2,0,0,2,0,2,-2,2,1,1,8], [1,-1,2,2,0,0,0,2,2,0,0,2,1,4,4,8], [3,0,2,2,0,1,0,2,2,2,0,2,0,2,2,4,8], [2,1,2,-1,0,0,-2,0,2,2,-2,0,1,0,4,1,-1,8], [1,1,3,4,-1,1,0,-2,3,0,0,2,0,4,-1,2,2,0,8], [2,2,2,-1,1,2,1,0,0,3,-2,-1,3,0,2,1,0,4,0,8]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,1,0,0,-1,-1,0,0,0,0,1,1,1,-1,0,-1,-1,0], [4,-5,0,3,2,1,-5,-4,-2,0,2,0,3,3,5,-4,-1,-3,-1,1], [-2,3,0,-2,-1,0,3,2,1,0,-1,0,-2,-1,-3,2,1,2,0,-1], [-1,1,0,-1,-1,0,2,2,0,0,0,0,0,-2,-2,1,1,2,1,-1], [-1,0,0,-1,-1,1,2,2,-1,-1,0,-1,0,-2,-1,1,1,2,2,-1], [0,0,1,-1,-1,1,2,2,0,0,0,0,0,-2,-1,1,-1,1,1,-1], [-2,1,0,-1,-1,0,1,1,0,0,-1,1,0,-1,-2,1,1,1,0,0], [-1,1,0,0,-1,0,1,1,1,0,0,0,0,-1,0,0,0,0,0,0], [-3,4,0,-2,-1,-1,3,2,1,0,-2,1,-2,-1,-5,3,1,3,0,-1], [-4,6,0,-2,-1,-1,4,2,2,1,-3,1,-3,-1,-6,4,1,3,-1,-1], [-1,0,0,-2,-2,1,3,3,-1,-1,0,-1,0,-3,-1,1,1,2,3,-1], [0,-1,0,0,-1,1,1,1,-1,0,0,0,1,-1,0,0,0,1,1,-1], [-1,2,1,-1,-1,0,3,2,1,0,-1,0,-1,-2,-2,2,0,1,0,-1], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,1,0,-1,0,1,1,0,0,0,0,0,-1,0,0,0,0,0,0], [1,-1,-1,2,1,0,-3,-3,0,1,0,1,1,3,2,-2,0,-2,-2,1], [1,-2,1,0,-1,1,1,2,-1,-1,1,-1,1,-2,1,-1,0,0,2,0]], [[-6,8,0,-3,-1,-2,5,3,3,1,-4,2,-4,-2,-8,5,2,4,-1,-1], [-2,2,1,-2,-1,0,3,3,0,-1,-1,0,-1,-3,-3,2,1,3,2,-1], [2,-4,0,1,0,1,-1,0,-2,-1,2,-1,2,-1,3,-2,0,0,2,0], [3,-3,0,2,2,0,-4,-3,-1,0,1,0,2,2,3,-2,-1,-3,-1,1], [0,-1,1,-1,-1,1,2,2,-1,-1,0,-1,0,-2,0,0,0,1,2,-1], [1,-2,0,0,0,1,0,0,-1,-1,1,-1,1,-1,2,-1,0,0,2,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [-1,2,1,-1,-1,0,3,2,1,0,-1,0,-1,-2,-2,2,0,1,0,-1], [2,-2,-1,2,1,0,-3,-3,0,1,1,0,1,2,4,-2,-1,-3,-1,1], [0,-1,0,0,-1,1,1,1,-1,0,0,0,1,-1,0,0,0,1,1,-1], [2,-1,0,1,1,0,-1,-1,0,0,1,-1,0,1,2,-1,-1,-1,0,0], [-2,2,1,-1,-1,0,3,3,1,0,-1,0,-1,-3,-3,2,0,2,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0], [2,-2,0,2,1,0,-2,-2,0,0,1,0,1,1,3,-2,-1,-2,-1,1], [-2,1,1,-2,-2,1,4,4,0,-1,-1,0,-1,-4,-3,2,1,3,2,-1], [1,-1,0,1,1,0,-1,-1,0,0,0,0,0,1,1,-1,0,-1,-1,1], [0,0,0,0,0,0,1,1,0,0,0,0,0,-1,0,0,0,0,1,0], [-3,3,0,-2,-1,0,3,2,1,0,-2,1,-2,-2,-4,3,1,3,0,-1], [2,-3,0,2,1,0,-3,-2,-1,0,1,0,2,1,3,-2,-1,-2,0,1], [-2,2,0,-2,-1,0,3,2,0,0,-1,0,-1,-2,-3,2,1,3,1,-1]]]], [ # Q-class [20][27] [[6], [-2,6], [1,0,6], [-2,2,1,6], [1,-1,0,1,6], [-2,2,1,1,-3,6], [-2,3,1,3,1,2,6], [0,-1,-2,-3,1,-3,-3,6], [-1,2,-2,0,-1,1,2,-1,6], [1,-1,-2,-2,-2,1,-2,1,0,6], [1,2,-2,1,-1,1,1,-2,2,2,6], [2,2,1,-2,-1,0,-1,0,1,-1,0,6], [-3,0,2,1,-2,3,2,-1,-1,0,-1,-3,6], [1,2,-2,-2,0,0,1,1,1,2,1,1,-1,6], [-1,-1,-3,1,-1,0,0,0,0,3,1,-2,0,0,6], [1,2,2,1,-2,2,0,-1,-2,2,2,1,1,0,0,6], [-1,1,-2,1,-2,2,-1,0,2,1,2,-1,0,-1,0,0,6], [-1,0,2,2,-1,2,1,-1,1,-2,-2,-1,2,-2,-1,-1,2,6], [1,-2,0,0,0,-3,-1,1,-2,-2,-2,-1,0,-1,0,-1,-1,1,6], [1,2,0,1,-1,-1,1,0,2,-2,0,2,-1,1,-1,0,0,2,2,6]], [[[0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0], [0,0,-1,-1,0,0,1,0,-1,0,0,0,0,-1,0,0,0,0,-1,1], [-1,0,1,0,1,1,0,0,0,1,1,1,0,0,0,-1,0,0,1,0], [0,0,-1,-1,0,-1,0,-1,0,-1,0,0,0,0,0,1,0,1,-1,0], [0,1,1,-1,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0], [1,0,-2,1,0,0,1,0,0,1,-1,1,1,-1,-1,0,0,0,0,0], [0,0,1,-1,1,1,0,0,0,-1,0,0,0,0,1,0,1,-1,0,1], [0,1,0,0,0,0,-1,0,0,0,0,-1,0,0,0,0,-1,0,0,0], [1,0,0,0,0,1,0,1,0,-1,0,0,0,0,1,0,0,0,0,0], [1,1,-1,0,0,-1,0,-1,0,1,-1,0,1,-1,0,0,0,0,0,0], [1,0,-1,0,-1,-1,1,0,0,0,-1,0,0,-1,0,0,0,0,-1,0], [-1,-1,1,0,0,1,1,1,-1,1,1,0,-1,0,0,-1,0,0,0,1], [0,0,0,1,1,1,-1,0,1,0,0,1,1,0,0,0,0,-1,1,0], [0,0,1,-1,1,0,0,0,0,0,0,0,1,0,1,0,1,-1,0,1], [1,0,-1,0,-1,-1,0,-1,0,-1,-1,-1,0,0,0,1,0,0,-1,0], [-1,0,0,-1,1,0,0,-1,0,1,0,0,0,-1,0,0,0,0,0,1], [2,1,-3,1,-1,-1,0,0,0,0,-1,0,1,-1,-1,0,-1,1,-1,-1], [1,0,-2,1,0,0,0,0,0,0,0,1,1,0,-1,0,-1,1,0,-1], [-1,-1,1,0,0,0,-1,0,0,-1,1,0,0,1,0,0,0,0,0,0], [-1,-1,1,-1,1,1,-1,0,0,-1,1,0,0,1,1,0,0,0,0,1]], [[-2,-2,2,-1,1,0,0,0,0,-1,1,0,-1,1,1,1,1,0,0,1], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0,0,0,0,0], [1,1,-1,0,0,1,-1,0,0,-1,0,-1,0,0,0,0,-1,0,0,0], [-1,0,3,-1,2,2,-2,0,1,-1,1,-1,-1,1,2,0,1,-1,1,1], [1,0,-2,1,-1,-1,1,0,0,0,-1,1,1,0,-1,0,0,0,0,-1], [1,0,0,1,0,2,0,1,0,0,0,0,0,0,0,-1,0,-1,1,0], [-1,0,1,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,0], [0,0,0,-1,0,0,1,0,-1,0,0,0,0,0,0,0,1,0,0,0], [-1,-1,-1,0,0,-1,1,0,0,1,0,1,0,0,-1,1,0,1,0,0], [0,-1,-1,0,0,0,1,0,0,0,0,0,0,0,-1,1,0,0,0,0], [-1,-1,1,-1,0,-1,0,-1,0,-1,0,0,0,1,1,1,1,0,0,0], [2,1,-2,2,-1,0,1,1,0,1,-1,1,1,-1,-1,-1,-1,0,0,-1], [-1,-1,1,0,1,1,0,0,0,1,0,1,0,0,0,0,1,-1,1,1], [0,0,-1,0,0,0,0,0,0,1,0,0,0,0,-1,0,-1,1,0,0], [0,-1,-2,1,-1,-1,1,0,0,0,0,1,0,0,-1,1,-1,1,0,-1], [0,0,-1,0,-1,-1,1,0,-1,0,0,0,0,0,-1,0,0,0,-1,0], [0,1,0,0,0,0,0,0,-1,0,0,0,0,0,0,-1,0,0,0,0], [0,0,1,1,0,1,-1,1,0,0,1,0,0,0,0,-1,-1,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [20][28] [[4], [2,4], [2,2,4], [2,2,2,4], [2,2,2,2,4], [2,2,2,2,2,4], [2,2,2,2,2,2,4], [2,2,2,2,2,2,2,4], [2,2,2,2,2,2,2,2,4], [2,2,2,2,2,2,2,2,2,4], [2,1,1,1,1,1,1,1,1,1,4], [1,2,1,1,1,1,1,1,1,1,2,4], [1,1,2,1,1,1,1,1,1,1,2,2,4], [1,1,1,2,1,1,1,1,1,1,2,2,2,4], [1,1,1,1,2,1,1,1,1,1,2,2,2,2,4], [1,1,1,1,1,2,1,1,1,1,2,2,2,2,2,4], [1,1,1,1,1,1,2,1,1,1,2,2,2,2,2,2,4], [1,1,1,1,1,1,1,2,1,1,2,2,2,2,2,2,2,4], [1,1,1,1,1,1,1,1,2,1,2,2,2,2,2,2,2,2,4], [1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,1,0,0,0,0,-1,0,0,0,0,-1,0,0,0,0,1], [0,0,0,1,0,0,0,0,0,-1,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,-1,0,1], [0,0,1,0,0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0,-1,0,0,1], [0,1,0,0,0,0,0,0,0,-1,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,-1,0,0,0,1], [1,0,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,-1], [-1,0,0,0,1,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0], [-1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,-1,0,0,0,0], [-1,1,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,0,-1,0,0,0], [-1,0,1,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,-1,0,0], [-1,0,0,1,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,-1]]]], [ # Q-class [20][29] [[8], [4,8], [2,1,8], [1,2,4,8], [-4,-2,0,0,8], [-2,-4,0,0,4,8], [-4,-2,2,1,2,1,8], [-2,-4,1,2,1,2,4,8], [-4,-2,2,1,4,2,2,1,8], [-2,-4,1,2,2,4,1,2,4,8], [-4,-2,2,1,4,2,4,2,2,1,8], [-2,-4,1,2,2,4,2,4,1,2,4,8], [-4,-2,0,0,2,1,4,2,0,0,4,2,8], [-2,-4,0,0,1,2,2,4,0,0,2,4,4,8], [-4,-2,2,1,4,2,4,2,4,2,2,1,0,0,8], [-2,-4,1,2,2,4,2,4,2,4,1,2,0,0,4,8], [-4,-2,2,1,0,0,2,1,2,1,2,1,4,2,2,1,8], [-2,-4,1,2,0,0,1,2,1,2,1,2,2,4,1,2,4,8], [2,1,4,2,2,1,-2,-1,0,0,0,0,0,0,0,0,0,0,8], [1,2,2,4,1,2,-1,-2,0,0,0,0,0,0,0,0,0,0,4,8]], [[[-2,0,1,0,0,0,0,0,-1,0,0,0,-1,0,-1,0,0,0,0,0], [-2,2,1,-1,0,0,0,0,-1,1,0,0,-1,1,-1,1,0,0,0,0], [0,0,0,0,1,0,0,0,-1,0,0,0,-1,0,0,0,1,0,0,0], [0,0,0,0,1,-1,0,0,-1,1,0,0,-1,1,0,0,1,-1,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,1,0,1,0,-1,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,1,-1,1,-1,-1,1,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [1,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,-1,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,-1,0,0,0,0,0,1,0,1,0,0,0,0,0], [1,-1,0,0,0,0,-1,1,0,0,0,0,1,-1,1,-1,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0], [1,-1,0,0,0,0,0,0,0,0,0,0,1,-1,1,-1,0,0,0,0], [1,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [1,-1,-1,1,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0], [2,0,-1,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0], [2,-2,-1,1,1,-1,1,-1,0,0,0,0,0,0,0,0,1,-1,0,0], [-1,0,1,0,1,0,-1,0,-1,0,0,0,0,0,0,0,0,0,-1,0], [-1,1,1,-1,1,-1,-1,1,-1,1,0,0,0,0,0,0,0,0,-1,1]], [[0,-1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,-1,0,0,0,-1,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,-1,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,-1,0,-1,0,0,0,0,0], [0,0,0,1,0,1,0,0,0,-1,0,-1,0,0,0,0,0,0,0,-1], [0,0,1,0,1,0,0,0,-1,0,-1,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [-1,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,1,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1,0,0], [-1,0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,1], [0,0,-1,0,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,-1,0,0,0,0,0,1,0,1,0,0,0,-1,0], [0,1,0,0,0,0,0,-1,0,0,0,0,0,1,0,1,0,0,0,-1], [-1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,0,0,0,-1,0,0,0,0,0,1,0,0,0,-1,0,-1,0], [0,-1,0,1,0,0,0,-1,0,0,0,0,0,1,0,0,0,-1,0,-1], [0,0,0,0,0,0,-1,0,0,0,0,0,1,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0,1,0,0,0,0], [-1,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,-1,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,-1], [-1,0,1,0,1,0,0,0,0,0,-1,0,0,0,-1,0,0,0,-1,0], [0,-1,0,1,0,1,0,0,0,0,0,-1,0,0,0,-1,0,0,0,-1], [-1,0,0,0,-1,0,-1,0,0,0,0,0,1,0,1,0,-1,0,0,0], [0,-1,0,0,0,-1,0,-1,0,0,0,0,0,1,0,1,0,-1,0,0], [-1,0,1,0,1,0,0,0,-1,0,-1,0,0,0,0,0,0,0,-1,0], [0,-1,0,1,0,1,0,0,0,-1,0,-1,0,0,0,0,0,0,0,-1], [1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0]]]], [ # Q-class [20][30] [[12], [6,12], [-4,-2,12], [-2,-4,6,12], [0,0,-2,-1,12], [0,0,-1,-2,6,12], [0,0,0,0,-4,-2,12], [0,0,0,0,-2,-4,6,12], [4,2,-4,-2,-4,-2,-2,-1,12], [2,4,-2,-4,-2,-4,-1,-2,6,12], [4,2,4,2,2,1,0,0,-4,-2,12], [2,4,2,4,1,2,0,0,-2,-4,6,12], [-4,-2,-2,-1,4,2,-4,-2,0,0,0,0,12], [-2,-4,-1,-2,2,4,-2,-4,0,0,0,0,6,12], [-2,-1,6,3,2,1,-4,-2,0,0,4,2,4,2,12], [-1,-2,3,6,1,2,-2,-4,0,0,2,4,2,4,6,12], [-6,-3,4,2,-4,-2,-4,-2,0,0,-2,-1,4,2,6,3,12], [-3,-6,2,4,-2,-4,-2,-4,0,0,-1,-2,2,4,3,6,6,12], [-4,-2,-4,-2,4,2,2,1,0,0,-4,-2,0,0,-4,-2,-2,-1,12], [-2,-4,-2,-4,2,4,1,2,0,0,-2,-4,0,0,-2,-4,-1,-2,6,12]], [[[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1]], [[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,-1,0,-1,0,-1,0,-1,0,0,0,1,0,-1,0,0], [0,0,0,0,1,-1,1,-1,1,-1,1,-1,0,0,-1,1,1,-1,0,0], [0,-1,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,0], [1,-1,0,0,0,0,0,0,-1,1,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,-1,0,-1,0,0,0,0,0,1,0,-1,0,1], [0,0,0,0,1,-1,1,-1,1,-1,0,0,0,0,-1,1,1,-1,-1,1], [0,-1,0,0,0,1,0,0,0,1,0,1,0,0,0,-1,0,0,0,-1], [1,-1,0,0,-1,1,0,0,-1,1,-1,1,0,0,1,-1,0,0,1,-1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,-1,0,1,0,-1], [0,0,0,0,-1,1,0,0,0,0,0,0,0,0,1,-1,-1,1,1,-1], [0,-1,0,-1,0,1,0,1,0,1,0,1,0,-1,0,0,0,1,0,-1], [1,-1,1,-1,-1,1,-1,1,-1,1,-1,1,1,-1,0,0,-1,1,1,-1]], [[-2,2,-1,1,1,-1,0,0,1,-1,1,-1,-1,1,0,0,0,0,-1,1], [0,2,0,1,0,-1,0,0,0,-1,0,-1,0,1,0,0,0,0,0,1], [1,-1,0,0,-2,2,-1,1,-1,1,-1,1,1,-1,1,-1,-1,1,1,-1], [0,-1,0,0,0,2,0,1,0,1,0,1,0,-1,0,-1,0,1,0,-1], [0,0,1,-1,1,-1,0,0,1,-1,0,0,0,0,-1,1,0,0,0,0], [0,0,0,-1,0,-1,0,0,0,-1,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,1,-1,1,2,-2,1,-1,1,-1,1,-1,-1,1,-1,1,2,-2,-1,1], [0,1,0,1,0,-2,0,-1,0,-1,0,-1,0,1,0,1,0,-2,0,1], [-1,1,0,0,-1,1,-1,1,0,0,0,0,0,0,0,0,-1,1,0,0], [0,1,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,1,-1,1,-1,1,-1,1,-1,0,0,0,0,-1,1,1,-1,0,0], [0,0,0,-1,0,-1,0,-1,0,-1,0,0,0,0,0,1,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [1,-1,0,0,-1,1,0,0,-1,1,-1,1,0,0,1,-1,0,0,1,-1], [0,-1,0,0,0,1,0,0,0,1,0,1,0,0,0,-1,0,0,0,-1], [1,-1,1,-1,1,-1,0,0,0,0,0,0,0,0,-1,1,1,-1,0,0], [0,-1,0,-1,0,-1,0,0,0,0,0,0,0,0,0,1,0,-1,0,0]]]], [ # Q-class [20][31] [[8], [3,8], [2,4,8], [3,4,2,8], [3,4,1,3,8], [2,3,4,4,2,8], [4,2,1,2,4,1,8], [1,4,4,3,3,4,2,8], [3,3,4,3,3,2,4,4,8], [2,3,1,4,4,1,3,4,2,8], [3,2,3,2,1,4,2,2,2,1,8], [4,2,2,4,2,3,4,2,4,2,4,8], [4,3,4,2,2,3,3,3,4,2,4,4,8], [3,1,0,4,3,2,3,2,1,4,2,3,1,8], [2,4,4,2,2,3,1,3,3,1,4,3,1,0,8], [0,4,3,3,3,4,1,3,1,4,3,0,1,1,2,8], [3,2,2,2,3,2,3,1,2,4,2,3,4,3,0,4,8], [4,2,3,1,1,4,4,4,2,1,4,4,4,1,4,0,1,8], [4,2,4,4,2,3,0,1,3,1,2,2,2,0,3,2,2,1,8], [4,4,2,2,3,2,3,0,0,1,3,2,2,3,1,2,2,2,0,8]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,1,0,0,0,1,1,1,-1,0,1,0,-1,-1,0,-2,1,-1,0,0], [0,0,0,0,0,0,1,1,-1,-1,0,1,0,0,0,0,0,-1,0,0], [1,0,0,0,0,1,1,1,-1,0,0,0,0,-1,1,-1,1,-2,-1,0], [0,0,0,0,0,0,0,1,0,0,0,0,-1,-1,0,-1,1,0,0,1], [1,-1,0,1,0,0,1,1,-1,-1,0,0,0,-1,1,0,1,-1,-1,0], [1,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,-1,0], [0,0,0,0,0,0,1,1,-1,-1,0,0,0,0,1,-1,1,-1,0,0], [1,0,1,0,0,1,1,1,-1,0,1,0,-1,-1,0,-2,1,-2,-1,0], [0,1,0,0,0,0,0,0,0,0,0,0,-1,0,0,-1,1,0,0,0], [0,0,0,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [1,0,0,0,0,0,1,1,-1,-1,0,0,0,0,0,0,0,-1,0,0], [0,-1,-2,-1,-2,1,2,2,-1,0,-2,0,2,0,3,0,0,-3,1,2], [-1,1,0,0,0,0,0,0,0,0,1,0,-1,0,-1,-1,1,1,0,0], [0,1,1,1,1,0,0,-1,0,0,1,0,-2,-1,-1,-1,1,1,-1,-1], [0,1,0,0,0,0,0,-1,1,0,0,0,-1,0,-1,0,0,1,0,0], [0,0,0,0,0,-1,0,0,0,-1,0,0,0,1,0,1,0,1,0,0], [0,0,1,1,1,0,0,0,0,0,1,0,-1,-1,-1,-1,1,0,-1,0], [0,0,-1,-1,-1,0,1,1,-1,0,-1,1,1,0,1,1,-1,-1,1,1]], [[-2,0,-1,-1,-1,0,1,0,0,0,-1,0,1,1,1,0,0,0,2,1], [0,-1,0,0,-1,0,1,1,-1,0,-1,0,1,0,2,0,0,-2,0,1], [0,0,1,0,0,0,1,0,-1,0,0,0,0,0,0,0,0,-1,0,0], [-1,0,0,0,0,-1,-1,-2,1,0,-1,0,1,1,0,2,-1,2,0,0], [0,0,0,0,-1,0,1,0,0,0,0,0,0,0,1,0,0,-1,0,0], [-1,0,-1,-1,-1,0,1,0,0,0,-1,0,2,1,1,1,-1,-1,1,1], [0,0,0,0,-1,1,1,0,0,0,0,-1,0,0,1,-1,1,-1,0,0], [0,0,1,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,1,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,-1,-1], [-1,-1,-2,-1,-2,1,2,2,-1,0,-1,0,2,0,2,0,0,-3,2,2], [-1,0,-1,-1,-1,1,1,0,0,0,-1,0,1,0,1,0,0,-1,1,1], [-1,0,0,-1,-1,1,1,0,0,1,0,0,0,0,0,-1,0,-1,1,1], [-1,0,0,1,0,0,0,-1,1,0,0,-1,0,0,0,0,0,1,0,0], [0,-1,-1,-1,-1,0,1,1,-1,-1,-2,1,2,1,2,2,-1,-2,1,1], [0,0,0,0,-1,0,1,1,-1,0,0,0,1,0,1,0,0,-2,0,0], [-1,1,0,-1,-1,1,1,0,0,1,0,0,0,0,0,-1,0,-1,1,0], [-1,0,-1,-1,-1,1,1,0,0,0,-1,0,1,1,1,0,0,-1,1,1], [-1,0,0,-1,0,-1,0,-1,0,0,-1,1,1,1,0,2,-1,1,1,0], [-1,0,-1,0,-1,0,1,1,0,0,0,-1,0,0,1,-1,1,-1,1,1]]]] ]; MakeImmutable( IMFList[20].matrices ); gap-4r6p5/grp/perf6.grp0000644000175000017500000006236312172557252013477 0ustar billbill############################################################################# ## #W perf6.grp GAP Groups Library Volkmar Felsch ## Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains the perfect groups of sizes 43200-87480 ## All data is based on Holt/Plesken: Perfect Groups, OUP 1989 ## PERFGRP[81]:=[# 43200.1 [[1,"abcde", function(a,b,c,d,e) return [[a^2,b^3,(a*b)^5,c^4,d^3,e^3,(d*e)^4*c^2,(d*e^-1) ^5,c^2*d*c^2*d^-1,c^2*e*c^2*e^-1, c^-1*d^-1*e*d*e*d^-1*e*d*e^-1, a^-1*d^-1*a*d,a^-1*e^-1*a*e, b^-1*d^-1*b*d,b^-1*e^-1*b*e], [[b,a*b*a*b^-1*a,d,e],[a,b,e*d*c^-1,d]]]; end, [5,80]], "A5 x A6 2^1",[33,1,1],2, [1,3],[5,80]], # 43200.2 [[1,"abcde", function(a,b,c,d,e) return [[a^4,b^3,(a*b)^5,a^2*b*a^2*b^-1,c^2,d^3,e^3,(d*e) ^4,(d*e^-1)^5, c^-1*d^-1*e*d*e*d^-1*e*d*e^-1, a^-1*d^-1*a*d,a^-1*e^-1*a*e, b^-1*d^-1*b*d,b^-1*e^-1*b*e], [[a*b,d,e],[a,b,c,d]]]; end, [24,6]], "A5 2^1 x A6",[33,1,2],2, [1,3],[24,6]], # 43200.3 [[1,"abcde", function(a,b,c,d,e) return [[a^4,b^3,(a*b)^5,c^2*a^2,d^3,e^3,(d*e)^4*c^2,(d*e ^-1)^5,c^-1*d^-1*e*d*e*d^-1*e*d *e^-1,a^-1*d^-1*a*d, a^-1*e^-1*a*e,b^-1*d^-1*b*d, b^-1*e^-1*b*e],[[a*b,e*d*c^-1,d]]]; end, [960]], "( A5 x A6 ) 2^1",[33,1,3],2, [1,3],960] ]; PERFGRP[82]:=[# 43320.1 [[1,"abyz", function(a,b,y,z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,y^19,z^19,y^-1 *z^-1*y*z,a^-1*y*a*z^-1, a^-1*z*a*y, b^-1*y*b*(y^(-1*6)*z^(-1*9))^-1, b^-1*z*b*(y^(-1*5)*z^5)^-1],[[a,b]]]; end, [361],[0,0,2,2,2,2]], "A5 2^1 19^2",[5,2,1],1, 1,361], # 43320.2 (otherpres.) [[1,"abdyz", function(a,b,d,y,z) return [[a^2*d^-1,b^3,(a*b)^5,d^2,d^-1*b^-1*d*b, y^19,z^19,y^-1*z^-1*y*z, a^-1*y*a*z^-1,a^-1*z*a*y, b^-1*y*b*(y^(-1*6)*z^(-1*9))^-1, b^-1*z*b*(y^(-1*5)*z^5)^-1],[[a,b]]]; end, [361],[0,0,2,2,2,2]]] ]; PERFGRP[83]:=[# 43740.1 [[1,"abuvwxyz", function(a,b,u,v,w,x,y,z) return [[a^2,b^3,(a*b)^5,u^3,v^3,w^3,x^3,y^3,z^3,u^-1*v ^-1*u*v,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z, a^-1*u*a*(u^-1*v*w^-1*x^-1*y)^-1 ,a^-1*v*a*(u*v*w^-1*z)^-1, a^-1*w*a*(u^-1*w*x*y^-1*z^-1)^-1 ,a^-1*x*a*(v^-1*w*y^-1)^-1, a^-1*y*a*(u*v^-1*w^-1*y^-1*z)^-1 ,a^-1*z*a*(u^-1*v^-1*x^-1*y*z) ^-1,b^-1*u*b*(u*w^-1*y)^-1, b^-1*v*b*(v*x^-1*z)^-1, b^-1*w*b*(w*y)^-1,b^-1*x*b*(x*z)^-1, b^-1*y*b*y^-1,b^-1*z*b*z^-1], [[a*b,b*a*b*a*b^-1*a*b^-1,z]]]; end, [18]], "A5 3^6",[2,6,1],1, 1,18] ]; PERFGRP[84]:=[# 46080.1 [[1,"abcdstuve", function(a,b,c,d,s,t,u,v,e) return [[a^2*d^-1,b^3,c^3,(b*c)^4*d^-1,(b*c^-1)^5, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,d^2, d^-1*b^-1*d*b,d^-1*c^-1*d*c, d^-1*e^-1*d*e,e^4,e^-1*s^-1*e*s, e^-1*t^-1*e*t,e^-1*u^-1*e*u, e^-1*v^-1*e*v,s^2,t^2,u^2,v^2, s^-1*t^-1*s*t,s^-1*u^-1*s*u*e^2, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v*e^2,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u*e)^-1, c^-1*v*c*(s*t*u*v*e^2)^-1], [[b,c],[c*b*a*d,b,s,e]]]; end, [64,80]], "A6 2^1 x ( 2^4 E 2^1 A ) C 2^1",[13,7,1],8, 3,[64,80]] ]; PERFGRP[85]:=[# 48000.1 [[4,1920,3,3000,2,120,3,1], "A5 # 2^5 5^2 [1]",6,1, 1,[16,24,25]], # 48000.2 [[4,1920,4,3000,2,120,4,1], "A5 # 2^5 5^2 [2]",6,1, 1,[80,25]], # 48000.3 [[4,1920,5,3000,2,120,5,1], "A5 # 2^5 5^2 [3]",6,1, 1,[10,24,25]] ]; PERFGRP[86]:=[# 50616.1 [[1,"abc", function(a,b,c) return [[c^18*a^2,c*b^4*c^-1*b^-1,b^37,a^4,a^2*b^(-1 *1)*a^2*b,a^2*c^-1*a^2*c, c*a*c*a^-1,(b*a)^3, c^(-1*2)*b*c^2*b^3*a*b^2*a*c*b^2*a],[[b,c^4]]] ; end, [152]], "L2(37) 2^1 = SL(2,37)",22,-2, 21,152] ]; PERFGRP[87]:=[# 51840.1 [[1,"abd", function(a,b,d) return [[a^2,b^5,(a*b)^9,(a^-1*b^-1*a*b)^3,(b*a*b*a *b^-1*a*b^-1*a)^2*d^-1,d^2, a^-1*d*a*d^-1,b^-1*d*b*d^-1], [[b^-1*a*b*a*(b^3*a)^2*b*a*b^3*a*b^-1, a*b^3*a*b*a*b^2*a*b*a*b^3*(a*b^-1)^2*d] ]]; end, [80]], "U4(2) 2^1",28,-2, 22,80] ]; PERFGRP[88]:=[# 51888.1 [[1,"abc", function(a,b,c) return [[c^23,c*b^(-1*22)*c^-1*b^-1,b^47,a^2,c*a*c*a ^-1,(b*a)^3],[[b,c]]]; end, [48],[0,2,2]], "L2(47)",22,-1, 27,48] ]; PERFGRP[89]:=[# 56448.1 [[2,168,1,336,1], "( L3(2) x L3(2) ) 2^1 [1]",[34,1,1],2, [2,2],[7,16]], # 56448.2 [[3,336,1,336,1,"d1","d2"], "( L3(2) x L3(2) ) 2^1 [2]",[34,1,2],2, [2,2],128] ]; PERFGRP[90]:=[# 57600.1 [[2,960,1,60,1], "A5 x A5 # 2^4 [1]",[29,4,1],1, [1,1],[16,5]], # 57600.2 [[2,960,2,60,1], "A5 x A5 # 2^4 [2]",[29,4,2],1, [1,1],[10,5]] ]; PERFGRP[91]:=[# 57624.1 [[1,"abxyz", function(a,b,x,y,z) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,x^7,y^7, z^7,x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*x*a*z^-1, a^-1*y*a*y,a^-1*z*a*x^-1, b^-1*x*b*z^-1, b^-1*y*b*(y^-1*z^-1)^-1, b^-1*z*b*(x*y^2*z)^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,y]]]; end, [56]], "L3(2) 7^3",[10,3,1],1, 2,56], # 57624.2 [[1,"abxyz", function(a,b,x,y,z) return [[a^2,b^3,(a*b)^7*z^-1,(a^-1*b^-1*a*b)^4, x^7,y^7,z^7,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*x*a*z^-1,a^-1*y*a*y, a^-1*z*a*x^-1,b^-1*x*b*z^-1, b^-1*y*b*(y^-1*z^-1)^-1, b^-1*z*b*(x*y^2*z)^-1], [[a*b*x^2,b*a*b^-1*a*b^-1*a*b*a*b^-1,y ]]]; end, [56]], "L3(2) N 7^3",[10,3,2],1, 2,56] ]; PERFGRP[92]:=[# 58240.1 [[1,"abd", function(a,b,d) return [[a^2,b^4,(a*b)^5,(a^-1*b^-1*a*b)^7*d,(a*b^2) ^13, a*b^-1*a*b^2*a*b^2*(a*b^-1*a*b*a*b^2)^2 *a*b^2*a*b*(a*b^2)^4,d^2, a^-1*d*a*d^-1,b^-1*d*b*d^-1], [[a*b^2,(a*b*a*b^2)^2*a*b^2*a*b^-1 *(a*b^2*a*b*a*b^2)^2]]]; end, [1120]], "Sz(8) 2^1",28,-2, 23,1120] ]; PERFGRP[93]:=[# 58320.1 [[1,"abcwxyz", function(a,b,c,w,x,y,z) return [[a^4,b^3,c^3,(b*c)^4*a^2,(b*c^-1)^5,a^2*b*a^2 *b^-1,a^2*c*a^2*c^-1, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,w^3, x^3,y^3,z^3,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*w*a*z^-1, a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1, c^-1*w*c*(w^-1*x*y^-1*z^-1)^-1, c^-1*x*c*(x^-1*z)^-1, c^-1*y*c*(w*x^-1)^-1, c^-1*z*c*x], [[c*b*a^-1,b,w],[b,c*a*b*c,z]]]; end, [80,30]], "A6 2^1 x 3^4'",[14,4,1],2, 3,[80,30]], # 58320.2 [[1,"abcstuv", function(a,b,c,s,t,u,v) return [[a^4,b^3,c^3,(b*c)^4*a^(-1*2),(b*c^-1)^5,a^-1 *b^-1*c*b*c*b^-1*c*b*c^-1, a^(-1*2)*b^-1*a^2*b,a^(-1*2)*c^-1*a^2*c, s^3,t^3,u^3,v^3,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s, a^-1*v*a*t,b^-1*s*b*(s*v^-1)^-1, b^-1*t*b*(t*u^-1*v)^-1, b^-1*u*b*u^-1,b^-1*v*b*v^-1, c^-1*s*c*(s^-1*t*u^-1*v)^-1, c^-1*t*c*(s*t*u*v)^-1, c^-1*u*c*(s^-1*v^-1)^-1, c^-1*v*c*(t^-1*u^-1*v)^-1], [[a,b,c]]]; end, [81]], "A6 2^1 3^4",[14,4,2],1, 3,81], # 58320.3 (otherpres.) [[1,"abcdstuv", function(a,b,c,d,s,t,u,v) return [[a^2*d^-1,b^3,c^3,(b*c)^4*d^-1,(b*c^-1)^5, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,d^2, d^-1*b^-1*d*b,d^-1*c^-1*d*c,s^3, t^3,u^3,v^3,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s, a^-1*v*a*t,b^-1*s*b*(s*v^-1)^-1, b^-1*t*b*(t*u^-1*v)^-1, b^-1*u*b*u^-1,b^-1*v*b*v^-1, c^-1*s*c*(s^-1*t*u^-1*v)^-1, c^-1*t*c*(s*t*u*v)^-1, c^-1*u*c*(s^-1*v^-1)^-1, c^-1*v*c*(t^-1*u^-1*v)^-1], [[a,b,c]]]; end, [81]]] ]; PERFGRP[94]:=[# 58800.1 [[1,"abc", function(a,b,c) return [[c^24,b^7,c^(-1*8)*b^2*c^8*b^-1,c*b^3*c*b^2*c ^(-1*2)*b^(-1*3),a^2,c*a*c*a^-1,(b*a)^3, c^2*b*c*b^2*a*b*a*c*a*b^2*a*b^-1*c^(-1*3) *b^-1*a],[[b,c]]]; end, [50]], "L2(49)",22,-1, 28,50] ]; PERFGRP[95]:=[# 60480.1 [[1,"abd", function(a,b,d) return [[a^2,b^4,(a*b)^7*d^-1,(a^-1*b^-1*a*b)^5, (a*b^2)^5,(a*b*a*b*a*b^3)^5, (a*b*a*b*a*b^2*a*b^-1)^5*d^(-1*2),d^3, a^-1*d*a*d^-1,b^-1*d*b*d^-1], [[a*b*a,b^2*a*b^-1*a*b*a*b^2*a*b*d]]]; end, [63]], "L3(4) 3^1",[27,0,1],-3, 20,63], # 60480.2 [[2,120,1,504,1], "A5 2^1 x L2(8)",[35,1,1],2, [1,4],[24,9]], # 60480.3 [[2,168,1,360,1], "L3(2) x A6",[37,0,1],1, [2,3],[7,6]] ]; PERFGRP[96]:=fail; PERFGRP[97]:=[# 62400.1 [[1,"ab", function(a,b) return [[a^2,b^3,(a*b)^15,(a^-1*b^-1*a*b)^5,(a*b*a*b*a *b*a*b^-1*a*b^-1*a*b^-1)^3, (a*b^-1*a*b*a*b*a*b*a*b*a*b)^4], [[(a*b)^5*a,b*a*b^-1*(a*b)^6]]]; end, [65]], "U3(4)",28,-1, 29,65] ]; PERFGRP[98]:=[# 64512.1 [[1,"abcuvwxyzd", function(a,b,c,u,v,w,x,y,z,d) return [[a^2,b^3,(a*b)^7,b^-1*(a*b)^3*c^-1,c*b^-1 *c*b*a^-1*b^-1*c^-1*b *c^-1*a,u^2,v^2,w^2,x^2,y^2,z^2,d^2, u^-1*v^-1*u*v,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,u^-1*d^-1*u*d, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, v^-1*d^-1*v*d,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, w^-1*d^-1*w*d,x^-1*y^-1*x*y, x^-1*z^-1*x*z,x^-1*d^-1*x*d, y^-1*z^-1*y*z,y^-1*d^-1*y*d, z^-1*d^-1*z*d,a^-1*u*a*(u*x)^-1, a^-1*v*a*(v*y)^-1,a^-1*w*a*(w*z)^-1, a^-1*x*a*x^-1,a^-1*y*a*y^-1, a^-1*z*a*z^-1,a^-1*d*a*d^-1, b^-1*u*b*(x*y*d)^-1, b^-1*v*b*(y*z)^-1, b^-1*w*b*(x*y*z)^-1, b^-1*x*b*(v*w*x)^-1, b^-1*y*b*(u*v*w*y)^-1, b^-1*z*b*(u*w*z)^-1,b^-1*d*b*d^-1, c^-1*u*c*(v*d)^-1,c^-1*v*c*(w*d)^-1, c^-1*w*c*(u*v)^-1, c^-1*x*c*(x*z*d)^-1,c^-1*y*c*x^-1, c^-1*z*c*y^-1,c^-1*d*c*d^-1], [[b^-1*c,u*d]]]; end, [112]], "L2(8) 2^6 E 2^1",[16,7,1],2, 4,112], # 64512.2 [[1,"abcuvwxyzf", function(a,b,c,u,v,w,x,y,z,f) return [[a^2*f,b^3,(a*b)^7,b^-1*(a*b)^3*c^-1,b^-1 *c^-1*b*c^-1*a^-1*c *b^-1*c*b*a*(y*z)^-1,f^2,u^2,v^2, w^2,x^2,y^2,z^2,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, u^-1*f^-1*u*f,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,v^-1*f^-1*v*f, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,w^-1*f^-1*w*f, x^-1*y^-1*x*y,x^-1*z^-1*x*z, x^-1*f^-1*x*f,y^-1*z^-1*y*z, y^-1*f^-1*y*f,z^-1*f^-1*z*f, a^-1*u*a*(u*x)^-1,a^-1*v*a*(v*y)^-1, a^-1*w*a*(w*z)^-1,a^-1*x*a*x^-1, a^-1*y*a*y^-1,a^-1*z*a*z^-1, a^-1*f*a*f^-1, b^-1*u*b*(x*y*f^-1)^-1, b^-1*v*b*(y*z)^-1, b^-1*w*b*(x*y*z)^-1, b^-1*x*b*(v*w*x)^-1, b^-1*y*b*(u*v*w*y)^-1, b^-1*z*b*(u*w*z*f^-1)^-1, b^-1*f*b*f^-1, c^-1*u*c*(v*f^-1)^-1, c^-1*v*c*(w*f^-1)^-1, c^-1*w*c*(u*v*f)^-1, c^-1*x*c*(x*z*f)^-1, c^-1*y*c*(x*f)^-1, c^-1*z*c*(y*f^-1)^-1, c^-1*f*c*f^-1],[[b^-1*c,u*f]]]; end, [112]], "L2(8) N 2^6 E 2^1 I",[16,7,2],2, 4,112], # 64512.3 [[1,"abcuvwxyzd", function(a,b,c,u,v,w,x,y,z,d) return [[a^2,b^3,(a*b)^7,b^-1*(a*b)^3*c^-1,b^-1*c ^-1*b*c^-1*a^-1*c*b^-1 *c*b*a*(y*z*d)^-1,d^2,u^2,v^2,w^2,x^2, y^2,z^2,u^-1*v^-1*u*v,u^-1*w^-1*u*w ,u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,u^-1*d^-1*u*d, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, v^-1*d^-1*v*d,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, w^-1*d^-1*w*d,x^-1*y^-1*x*y, x^-1*z^-1*x*z,x^-1*d^-1*x*d, y^-1*z^-1*y*z,y^-1*d^-1*y*d, z^-1*d^-1*z*d,a^-1*u*a*(u*x)^-1, a^-1*v*a*(v*y)^-1,a^-1*w*a*(w*z)^-1, a^-1*x*a*x^-1,a^-1*y*a*y^-1, a^-1*z*a*z^-1,a^-1*d*a*d^-1, b^-1*u*b*(x*y)^-1,b^-1*v*b*(y*z)^-1, b^-1*w*b*(x*y*z*d)^-1, b^-1*x*b*(v*w*x)^-1, b^-1*y*b*(u*v*w*y*d)^-1, b^-1*z*b*(u*w*z)^-1,b^-1*d*b*d^-1, c^-1*u*c*(v*d)^-1,c^-1*v*c*(w*d)^-1, c^-1*w*c*(u*v)^-1, c^-1*x*c*(x*z*d)^-1, c^-1*y*c*(x*d)^-1,c^-1*z*c*y^-1, c^-1*d*c*d^-1],[[b^-1*c*d,u*d]]]; end, [112]], "L2(8) N 2^6 E 2^1 II",[16,7,3],2, 4,112], # 64512.4 [[1,"abcuvwxyzd", function(a,b,c,u,v,w,x,y,z,d) return [[a^2*d,b^3,(a*b)^7,b^-1*(a*b)^3*c^-1,b^-1 *c^-1*b*c^-1*a^-1*c *b^-1*c*b*a*(y*z*d)^-1,d^2,u^2,v^2, w^2,x^2,y^2,z^2,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, u^-1*d^-1*u*d,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,v^-1*d^-1*v*d, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,w^-1*d^-1*w*d, x^-1*y^-1*x*y,x^-1*z^-1*x*z, x^-1*d^-1*x*d,y^-1*z^-1*y*z, y^-1*d^-1*y*d,z^-1*d^-1*z*d, a^-1*u*a*(u*x)^-1,a^-1*v*a*(v*y)^-1, a^-1*w*a*(w*z)^-1,a^-1*x*a*x^-1, a^-1*y*a*y^-1,a^-1*z*a*z^-1, a^-1*d*a*d^-1,b^-1*u*b*(x*y*d)^-1, b^-1*v*b*(y*z)^-1, b^-1*w*b*(x*y*z*d)^-1, b^-1*x*b*(v*w*x)^-1, b^-1*y*b*(u*v*w*y*d)^-1, b^-1*z*b*(u*w*z*d)^-1,b^-1*d*b*d^-1 ,c^-1*u*c*v^-1,c^-1*v*c*w^-1, c^-1*w*c*(u*v*d)^-1, c^-1*x*c*(x*z)^-1,c^-1*y*c*x^-1, c^-1*z*c*(y*d)^-1,c^-1*d*c*d^-1], [[b^-1*c*d,u]]]; end, [112]], "L2(8) N 2^6 E 2^1 III",[16,7,4],2, 4,112] ]; PERFGRP[99]:=[# 64800.1 [[2,60,1,1080,1], "A5 x A6 3^1",[33,0,1],3, [1,3],[5,18]] ]; PERFGRP[100]:=[# 65520.1 [[2,60,1,1092,1], "A5 x L2(13)",40,1, [1,6],[5,14]] ]; PERFGRP[101]:=[# 68880.1 [[1,"abc", function(a,b,c) return [[c^20*a^2,c*b^8*c^-1*b^-1,b^41,a^4,a^2*b^(-1 *1)*a^2*b,a^2*c^-1*a^2*c, c*a*c*a^-1,(b*a)^3,c^-1*(b*c*a)^4*b*a], [[b,c^8]]]; end, [336]], "L2(41) 2^1 = SL(2,41)",22,-2, 25,336] ]; PERFGRP[102]:=[# 69120.1 [[4,23040,1,1080,2,360,1,1], "A6 3^1 x ( 2^4 E 2^1 A ) C 2^1",[13,6,1],12, 3,[64,18]], # 69120.2 [[4,23040,2,1080,2,360,2,1], "A6 3^1 x ( 2^4 E 2^1 A ) C N 2^1",[13,6,2],12, 3,[384,18]], # 69120.3 [[4,23040,3,1080,2,360,3,1], "A6 3^1 x 2^1 x ( 2^4 E 2^1 )",[13,6,3],12, 3,[12,80,18]], # 69120.4 [[1,"abcuvwxyz", function(a,b,c,u,v,w,x,y,z) return [[a^6,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1*b^-1*c *b*c*b^-1*c*b*c^-1,u^2,v^2,w^2, x^2,y^2,z^2,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*u*a*(v*x)^-1, a^-1*v*a*(u*v*w*x)^-1,a^-1*w*a*x^-1 ,a^-1*x*a*(w*x)^-1, a^-1*y*a*(x*z)^-1, a^-1*z*a*(w*x*y*z)^-1,b^-1*u*b*u^-1 ,b^-1*v*b*v^-1,b^-1*w*b*(u*x)^-1, b^-1*x*b*(v*w*x)^-1, b^-1*y*b*(u*y*z)^-1, b^-1*z*b*(v*y)^-1,c^-1*u*c*w^-1, c^-1*v*c*x^-1,c^-1*w*c*(y*z)^-1, c^-1*x*c*y^-1,c^-1*y*c*v^-1, c^-1*z*c*(u*v)^-1],[[b,c]]]; end, [64]], "A6 3^1 # 2^6 [4]",[13,6,4],1, 3,64] ]; PERFGRP[103]:=[# 74412.1 [[1,"abc", function(a,b,c) return [[c^26,c*b^4*c^-1*b^-1,b^53,a^2,c*a*c*a^-1, (b*a)^3,c^(-1*3)*b*c*b*c^2*a*b^2*a*c*b^2*a], [[b,c]]]; end, [54]], "L2(53)",22,-1, 30,54] ]; PERFGRP[104]:=[# 75000.1 [[1,"abxyzd", function(a,b,x,y,z,d) return [[a^4,b^3,(a*b)^5,a^2*b*a^2*b^-1,x^5,y^5,z^5,d^5, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,x^-1*d^-1*x*d, y^-1*d^-1*y*d,z^-1*d^-1*z*d, a^-1*d^-1*a*d,b^-1*d^-1*b*d, a^-1*x*a*z^-1*d,a^-1*y*a*y*d^-1, a^-1*z*a*x^-1*d^-1, b^-1*x*b*z^-1, b^-1*y*b*(y^-1*z)^-1, b^-1*z*b*(x*y^(-1*2)*z)^-1], [[a*b,x],[b,a*b*a*b^-1*a,x]]]; end, [24,25]], "A5 2^1 x 5^3 E 5^1",[3,4,1],10, 1,[24,25]], # 75000.2 [[1,"abwxyz", function(a,b,w,x,y,z) return [[w^5,x^5,y^5,z^5,w^-1*x^-1*w*x,w^-1*y^(-1 *1)*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*w*a*z^-1, a^-1*x*a*y,a^-1*y*a*x^-1, a^-1*z*a*w,b^-1*w*b*z, b^-1*x*b*(y*z^-1)^-1, b^-1*y*b*(x^-1*y^2*z^-1)^-1, b^-1*z*b*(w*x^2*y^(-1*2)*z^-1)^-1,a^4, b^3,(a*b)^5,a^2*b^-1*a^2*b], [[a*b,b*a*b*a*b^-1*a*b^-1,x]]]; end, [30]], "A5 2^1 5^4",[3,4,2],1, 1,30], # 75000.3 [[1,"abyzYZ", function(a,b,y,z,Y,Z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,y^5,z^5,Y^5,Z^5, y^-1*z^-1*y*z,y^-1*Y^-1*y*Y, y^-1*Z^-1*y*Z,z^-1*Y^-1*z*Y, z^-1*Z^-1*z*Z,Y^-1*Z^-1*Y*Z, a^-1*y*a*z^-1,a^-1*z*a*y, a^-1*Y*a*Z^-1,a^-1*Z*a*Y, b^-1*y*b*z,b^-1*z*b*(y*z^-1)^-1, b^-1*Y*b*Z,b^-1*Z*b*(Y*Z^-1)^-1], [[a,b,y],[a,b,Y]]]; end, [25,25]], "A5 2^1 5^2 x 5^2",[3,4,3],1, 1,[25,25]], # 75000.4 [[1,"abyzYZ", function(a,b,y,z,Y,Z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,y^5,z^5,Y^5,Z^5, y^-1*z^-1*y*z,y^-1*Y^-1*y*Y, y^-1*Z^-1*y*Z,z^-1*Y^-1*z*Y, z^-1*Z^-1*z*Z,Y^-1*Z^-1*Y*Z, a^-1*y*a*(z*Y^-1)^-1, a^-1*z*a*(y^-1*Z)^-1, a^-1*Y*a*Z^-1,a^-1*Z*a*Y, b^-1*y*b*(z^-1*Y^-1*Z)^-1, b^-1*z*b*(y*z^-1*Z)^-1,b^-1*Y*b*Z, b^-1*Z*b*(Y*Z^-1)^-1], [[b,a*b*a*b^-1*a,y*Y^-1*Z^-1]]]; end, [125]], "A5 2^1 5^2 E 5^2",[3,4,4],1, 1,125] ]; PERFGRP[105]:=[# 77760.1 [[4,960,1,4860,1,60], "A5 # 2^4 3^4 [1]",6,1, 1,[16,15]], # 77760.2 [[4,960,2,4860,1,60], "A5 # 2^4 3^4 [2]",6,1, 1,[10,15]], # 77760.3 [[4,960,1,4860,2,60], "A5 # 2^4 3^4 [3]",6,1, 1,[16,60]], # 77760.4 [[4,960,2,4860,2,60], "A5 # 2^4 3^4 [4]",6,1, 1,[10,60]] ]; PERFGRP[106]:=[# 79200.1 [[2,120,1,660,1], "( A5 x L2(11) ) 2^1 [1]",[36,1,1],2, [1,5],[24,11]], # 79200.2 [[2,60,1,1320,1], "( A5 x L2(11) ) 2^1 [2]",[36,1,2],2, [1,5],[5,24]], # 79200.3 [[3,120,1,1320,1,"d1","d2"], "( A5 x L2(11) ) 2^1 [3]",[36,1,3],2, [1,5],288] ]; PERFGRP[107]:=[# 79464.1 [[1,"abc", function(a,b,c) return [[c^21*a^2,c*b^9*c^-1*b^-1,b^43,a^4,a^2*b^(-1 *1)*a^2*b,a^2*c^-1*a^2*c, c*a*c*a^-1,(b*a)^3],[[b,c^2]]]; end, [88],[0,0,2]], "L2(43) 2^1 = SL(2,43)",22,-2, 26,88] ]; PERFGRP[108]:=[# 79860.1 [[1,"abxyz", function(a,b,x,y,z) return [[a^2,b^3,(a*b)^5,x^11,y^11,z^11,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*x*a*z^-1,a^-1*y*a*y, a^-1*z*a*x^-1, b^-1*x*b*(x*y^(-1*5)*z^(-1*2))^-1, b^-1*y*b*(x^(-1*4)*y^-1)^-1, b^-1*z*b*x^(-1*5)], [[a*b,b*a*b*a*b^-1*a*b^-1,y*z^5]]]; end, [66]], "A5 11^3",[5,3,1],1, 1,66] ]; PERFGRP[109]:=[# 80640.1 [[1,"abdwxyz", function(a,b,d,w,x,y,z) return [[a^2*d^-1,b^4*d^-1,(a*b)^7,(a*b)^2*a*b^2*( a*b*a*b^-1)^2*(a*b)^2 *(a*b^-1)^2*a*b*a*b^-1,d^2, d^-1*a^-1*d*a,d^-1*b^-1*d*b,w^2, x^2,y^2,z^2,w*x*w*x,w*y*w*y,w*z*w*z,x*y*x*y, x*z*x*z,y*z*y*z,a^-1*w*a*y^-1, a^-1*x*a*z^-1,a^-1*y*a*w^-1, a^-1*z*a*x^-1,b^-1*w*b*(w*x*y*z)^-1 ,b^-1*x*b*y^-1,b^-1*y*b*(w*x)^-1, b^-1*z*b*(w*z)^-1], [[a,b],[a*b,b*a*b*a*b^2*a*b^-1*a*b*a*b^-1 *a*b*a*b^2*d,w]]]; end, [16,240]], "A7 2^1 x 2^4",[23,5,1],2, 8,[16,240]], # 80640.2 [[1,"abef", function(a,b,e,f) return [[a^2,b^4,(a*b)^7*e,(a*b^2)^5*(e*f)^-1,(a^-1*b ^-1*a*b)^5,(a*b*a*b*a*b^3)^5*f, (a*b*a*b*a*b^2*a*b^-1)^5,e^2,f^2, e^-1*f^-1*e*f,a^-1*e*a*e^-1, a^-1*f*a*f^-1,b^-1*e*b*e^-1, b^-1*f*b*f^-1], [[a*e,b*a*b*a*b^-1*a*b^2*f^-1]]]; end, [224]], "L3(4) 2^1 x 2^1",[27,2,1],-4, 20,224], # 80640.3 [[1,"abf", function(a,b,f) return [[a^2,b^4*f^(-1*2),(a*b)^7,(a*b^2)^5*f^-1,(a^-1 *b^-1*a*b)^5*f^(-1*2),(a*b*a*b*a*b^3)^5 *f,(a*b*a*b*a*b^2*a*b^-1)^5,f^4, a^-1*f*a*f^-1,b^-1*f*b*f^-1], [[a,b*a*b*a*b^-1*a*b^2*f^-1]]]; end, [224]], "L3(4) 2^1 A 2^1 I",[27,2,2],-4, 20,224], # 80640.4 [[1,"abe", function(a,b,e) return [[a^2,b^4*e^(-1*2),(a*b)^7*e,(a*b^2)^5*e^-1,(a^(-1 *1)*b^-1*a*b)^5*e^(-1*2), (a*b*a*b*a*b^3)^5*e^(-1*2), (a*b*a*b*a*b^2*a*b^-1)^5, a^-1*e*a*e^-1,b^-1*e*b*e^-1], [[a*e^2,b^-1*a*b^-1*a*b*a*b^2]]]; end, [224]], "L3(4) 2^1 A 2^1 II",[27,2,3],-4, 20,224], # 80640.5 [[2,60,1,1344,1], "( A5 x L3(2) ) # 2^3 [1]",[31,3,1],1, [1,2],[5,8]], # 80640.6 [[2,60,1,1344,2], "( A5 x L3(2) ) # 2^3 [2]",[31,3,2],1, [1,2],[5,14]] ]; PERFGRP[110]:=[# 84672.1 [[2,168,1,504,1], "L3(2) x L2(8)",[38,0,1],1, [2,4],[7,9]] ]; PERFGRP[111]:=[fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail, fail]; PERFGRP[112]:=[# 86400.1 [[2,120,1,720,1], "( A5 x A6 ) 2^2",[33,2,1],4, [1,3],[24,80]] ]; PERFGRP[113]:=[# 87480.1 [[1,"abuvwxyz", function(a,b,u,v,w,x,y,z) return [[a^4,b^3,(a*b)^5,a^2*b*a^2*b^-1,u^3,v^3,w^3,x^3, y^3,z^3,u^-1*v^-1*u*v,u^-1*w^-1*u*w ,u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z, a^-1*u*a*(u^-1*v*w^-1*x^-1*y)^-1 ,a^-1*v*a*(u*v*w^-1*z)^-1, a^-1*w*a*(u^-1*w*x*y^-1*z^-1)^-1 ,a^-1*x*a*(v^-1*w*y^-1)^-1, a^-1*y*a*(u*v^-1*w^-1*y^-1*z)^-1 ,a^-1*z*a*(u^-1*v^-1*x^-1*y*z) ^-1,b^-1*u*b*(u*w^-1*y)^-1, b^-1*v*b*(v*x^-1*z)^-1, b^-1*w*b*(w*y)^-1,b^-1*x*b*(x*z)^-1, b^-1*y*b*y^-1,b^-1*z*b*z^-1], [[a*b,u,v],[a*b,b*a*b*a*b^-1*a*b^-1,z]]]; end, [24,18]], "A5 2^1 x 3^6",[2,6,1],2, 1,[24,18]], # 87480.2 [[1,"abuvwxyz", function(a,b,u,v,w,x,y,z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,u^3,v^3,w^3,x^3, y^3,z^3,u^-1*v^-1*u*v,u^-1*w^-1*u*w ,u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*u*a*v^-1, a^-1*v*a*u,a^-1*w*a*(u^-1*x)^-1, a^-1*x*a*(v*w^-1)^-1, a^-1*y*a*(u*w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*(w^-1*y^-1*z)^-1, b^-1*u*b*(u^-1*v^-1*w)^-1, b^-1*v*b*(u^-1*v*w)^-1, b^-1*w*b*u^-1,b^-1*x*b*(w*y)^-1, b^-1*y*b*(u^-1*w*x*y*z)^-1, b^-1*z*b*(w*y*z^-1)^-1],[[a^2,a*b,u]]]; end, [36]], "A5 2^1 3^6'",[2,6,2],1, 1,36], # 87480.3 [[1,"abstuvde", function(a,b,s,t,u,v,d,e) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,d^3,d^-1*a ^-1*d*a,d^-1*b^-1*d*b, d^-1*s^-1*d*s,e^3,e^-1*a^-1*e*a, e^-1*b^-1*e*b,e^-1*s^-1*e*s, d^-1*e^-1*d*e,s^3,t^3,u^3,v^3, s^-1*t^-1*s*t,s^-1*u^-1*s*u *d^-1,s^-1*v^-1*s*v*e^-1, t^-1*u^-1*t*u*e^-1, t^-1*v^-1*t*v*(d*e^-1)^-1, u^-1*v^-1*u*v, a^-1*s*a*(u*e^-1)^-1, a^-1*t*a*(v*e)^-1, a^-1*u*a*(s^-1*d)^-1, a^-1*v*a*(t^-1*d)^-1, b^-1*s*b*(s*v^-1*d^-1)^-1, b^-1*t*b*(t*u^-1*v*d*e^-1)^-1, b^-1*u*b*u^-1,b^-1*v*b*v^-1], [[a,b,d],[a,b,e]]]; end, [243,243]], "A5 2^1 3^4 C ( 3^1 x 3^1 )",[2,6,3],9, 1,[243,243]], # 87480.4 [[1,"abcdwxyz", function(a,b,c,d,w,x,y,z) return [[a^2*d^-1,b^3,c^3*(w*x*y^-1)^-1,(b*c)^4, (b*c^-1)^5,a^-1*b^-1*c*b*c*b^-1*c*b *c^-1,d^3,w^3,x^3,y^3,z^3,d^-1*w^-1*d *w,d^-1*x^-1*d*x,d^-1*y^-1*d*y, d^-1*z^-1*d*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*d*a*d^-1, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*d*b*(d*w*y^-1*z)^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1, c^-1*d*c*(d*x^-1*z^-1)^-1, c^-1*w*c*(w^-1*x*y^-1*z^-1)^-1, c^-1*x*c*(x^-1*z)^-1, c^-1*y*c*(w*x^-1)^-1,c^-1*z*c*x], [[b,c*a*b*c,d*y^-1*z]]]; end, [30]], "A6 3^1 E 3^4' I",[14,5,1],1, 3,30], # 87480.5 [[1,"abcdwxyz", function(a,b,c,d,w,x,y,z) return [[a^2*d^-1,b^3*(w*x*y*z^-1)^-1,c^3*(w*y ^-1*z^-1)^-1,(b*c)^4,(b*c^-1)^5, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,d^3, w^3,x^3,y^3,z^3,d^-1*w^-1*d*w, d^-1*x^-1*d*x,d^-1*y^-1*d*y, d^-1*z^-1*d*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*d*a*d^-1, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*d*b*(d*w*x^-1*z)^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1, c^-1*d*c*(d*x)^-1, c^-1*w*c*(w^-1*x*y^-1*z^-1)^-1, c^-1*x*c*(x^-1*z)^-1, c^-1*y*c*(w*x^-1)^-1,c^-1*z*c*x], [[b*w^-1,c*a*b*c]]]; end, [30]], "A6 3^1 E 3^4' II",[14,5,2],1, 3,30], # 87480.6 [[1,"abcwxyzf", function(a,b,c,w,x,y,z,f) return [[a^2,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1*b^-1*c *b*c*b^-1*c*b*c^-1,w^3,x^3,y^3, z^3,f^3,w^-1*f^-1*w*f,x^-1*f^-1*x*f ,y^-1*f^-1*y*f,z^-1*f^-1*z*f, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, a^-1*f*a*f^-1,b^-1*w*b*x^-1, b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1,b^-1*f*b*f^-1, c^-1*w*c*(w^-1*x*y^-1*z^-1*f)^-1 ,c^-1*x*c*(x^-1*z*f)^-1, c^-1*y*c*(w*x^-1*f)^-1, c^-1*z*c*(x^-1*f^-1)^-1, c^-1*f*c*f^-1],[[a,b,w]]]; end, [18]], "A6 3^4' E 3^1 I",[14,5,3],3, 3,18], # 87480.7 [[1,"abcwxyze", function(a,b,c,w,x,y,z,e) return [[a^2,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1*b^-1*c *b*c*b^-1*c*b*c^-1,w^3,x^3,y^3, z^3,e^3,w^-1*e^-1*w*e,x^-1*e^-1*x*e ,y^-1*e^-1*y*e,z^-1*e^-1*z*e, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, a^-1*e*a*e^-1,b^-1*w*b*x^-1, b^-1*x*b*(y*e^-1)^-1, b^-1*y*b*(w*e)^-1,b^-1*z*b*(z*e)^-1, b^-1*e*b*e^-1, c^-1*w*c*(w^-1*x*y^-1*z^-1*e^-1) ^-1,c^-1*x*c*(x^-1*z*e^-1)^-1, c^-1*y*c*(w*x^-1*e^-1)^-1, c^-1*z*c*(x^-1*e)^-1, c^-1*e*c*e^-1], [[a*b,b*a*b*a*b^-1*a*b^-1,w*e]]]; end, [108]], "A6 3^4' E 3^1 II",[14,5,4],3, 3,108], # 87480.8 [[1,"abcwxyzd", function(a,b,c,w,x,y,z,d) return [[a^2*d^-1,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1 *b^-1*c*b*c*b^-1*c*b*c^-1, d^3,b^-1*d*b*d^-1,c^-1*d*c*d^-1, w^3,x^3,y^3,z^3,w^-1*d^-1*w*d, x^-1*d^-1*x*d,y^-1*d^-1*y*d, z^-1*d^-1*z*d,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*w*a*z^-1, a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1, c^-1*w*c*(w^-1*x*y^-1*z^-1)^-1, c^-1*x*c*(x^-1*z)^-1, c^-1*y*c*(w*x^-1)^-1, c^-1*z*c*x], [[a*d,c*d,w],[b,c*a*b*c,z]]]; end, [18,30]], "A6 3^1 x 3^4'",[14,5,5],3, 3,[18,30]] ]; ############################################################################# ## #E perf6.grp . . . . . . . . . . . . . . . . . . . . . . . . . ends here ## gap-4r6p5/grp/classic.gd0000644000175000017500000010660112172557252013672 0ustar billbill############################################################################# ## #W classic.gd GAP Library Frank Celler ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains the operations for the construction of the classical ## group types. ## ############################################################################# ## ## <#GAPDoc Label="[1]{classic}"> ## The following functions return classical groups. ## For the linear, symplectic, and unitary groups (the latter in dimension ## at least 3), ## the generators are taken from . ## For the unitary groups in dimension 2, the isomorphism of ## SU(2,q) and SL(2,q) is used, ## see for example . ## The generators of the general and special orthogonal groups are taken ## from  and ## , ## except that the generators of the groups in odd dimension in even ## characteristic are constructed via the isomorphism to a symplectic group, ## see for example . ## The generators of the groups \Omega^\epsilon(d, q) are taken ## from , ## except that the generators of SO(5, 2) are taken for ## \Omega(5, 2). ## The generators for the semilinear groups are constructed from the ## generators of the corresponding linear groups plus one additional ## generator that describes the action of the group of field automorphisms; ## for prime integers p and positive integers f, ## this yields the matrix groups GammaL(d, p^f) and ## SigmaL(d, p^f) as groups of d f \times df matrices ## over the field with p elements. ##

## For symplectic and orthogonal matrix groups returned by the functions ## described below, the invariant bilinear form is stored as the value of ## the attribute . ## Analogously, the invariant sesquilinear form defining the unitary groups ## is stored as the value of the attribute ## ). ## The defining quadratic form of orthogonal groups is stored as the value ## of the attribute . ##

## Note that due to the different sources for the generators, ## the invariant forms for the groups \Omega(e,d,q) are in general ## different from the forms for SO(e,d,q) and GO(e,d,q). ## ## <#/GAPDoc> ## ############################################################################# ## #O GeneralLinearGroupCons( , , ) ## ## ## ## ## ## ## ## DeclareConstructor( "GeneralLinearGroupCons", [ IsGroup, IsPosInt, IsRing ] ); ############################################################################# ## #F GeneralLinearGroup( [, ], ) . . . . . general linear group #F GL( [, ], ) #F GeneralLinearGroup( [, ], ) #F GL( [, ], ) ## ## <#GAPDoc Label="GeneralLinearGroup"> ## ## GeneralLinearGroup ## ## ## ## ## ## ## The first two forms construct a group isomorphic to the general linear ## group GL( d, R ) of all d \times d ## matrices that are invertible over the ring R, ## in the category given by the filter filt. ##

## The third and the fourth form construct the general linear group over the ## finite field with q elements. ##

## If filt is not given it defaults to , ## and the returned group is the general linear group as a matrix group in ## its natural action (see also , ## ). ##

## Currently supported rings R are finite fields, ## the ring , ## and residue class rings Integers mod m, ## see . ##

## GL(4,3); ## GL(4,3) ## gap> GL(2,Integers); ## GL(2,Integers) ## gap> GL(3,Integers mod 12); ## GL(3,Z/12Z) ## ]]> ##

## OnLines ## Using the operation it is possible to obtain the ## corresponding projective groups in a permutation action: ##

## g:=GL(4,3);;Size(g); ## 24261120 ## gap> pgl:=Action(g,Orbit(g,Z(3)^0*[1,0,0,0],OnLines),OnLines);; ## gap> Size(pgl); ## 12130560 ## ]]> ##

## If you are interested only in the projective group as a permutation group ## and not in the correspondence between its moved points and the points in ## the projective space, you can also use . ## ## ## <#/GAPDoc> ## BindGlobal( "GeneralLinearGroup", function ( arg ) if Length( arg ) = 2 then if IsRing( arg[2] ) then return GeneralLinearGroupCons( IsMatrixGroup, arg[1], arg[2] ); elif IsPrimePowerInt( arg[2] ) then return GeneralLinearGroupCons( IsMatrixGroup, arg[1], GF( arg[2] ) ); fi; elif Length( arg ) = 3 and IsOperation( arg[1] ) then if IsRing( arg[3] ) then return GeneralLinearGroupCons( arg[1], arg[2], arg[3] ); elif IsPrimePowerInt( arg[3] ) then return GeneralLinearGroupCons( arg[1], arg[2], GF( arg[3] ) ); fi; fi; Error( "usage: GeneralLinearGroup( [, ], )" ); end ); DeclareSynonym( "GL", GeneralLinearGroup ); ############################################################################# ## #O GeneralOrthogonalGroupCons( , , , ) ## ## ## ## ## ## ## ## DeclareConstructor( "GeneralOrthogonalGroupCons", [ IsGroup, IsInt, IsPosInt, IsPosInt ] ); DeclareConstructor( "GeneralOrthogonalGroupCons", [ IsGroup, IsInt, IsPosInt, IsRing ] ); ############################################################################# ## #F GeneralOrthogonalGroup( [, ][, ], ) . gen. orthog. group #F GO( [, ][, ], ) ## ## <#GAPDoc Label="GeneralOrthogonalGroup"> ## ## ## ## ## ## constructs a group isomorphic to the ## general orthogonal group GO( e, d, q ) of those ## d \times d matrices over the field with q ## elements that respect a non-singular quadratic form ## (see ) specified by e, ## in the category given by the filter filt. ##

## The value of e must be 0 for odd d (and can ## optionally be omitted in this case), respectively one of 1 or ## -1 for even d. ## If filt is not given it defaults to , ## and the returned group is the general orthogonal group itself. ##

## ## Note that in , ## GO is defined as the stabilizer ## \Delta(V, F, \kappa) of the quadratic form, up to scalars, ## whereas our GO is called I(V, F, \kappa) there. ## ## ## <#/GAPDoc> ## BindGlobal( "GeneralOrthogonalGroup", function ( arg ) if Length( arg ) = 2 then return GeneralOrthogonalGroupCons( IsMatrixGroup, 0, arg[1], arg[2] ); elif Length( arg ) = 3 and IsInt(arg[1]) and IsInt(arg[2]) and (IsInt(arg[3]) or IsRing(arg[3])) then return GeneralOrthogonalGroupCons( IsMatrixGroup,arg[1],arg[2],arg[3] ); elif IsOperation( arg[1] ) then if Length( arg ) = 3 then return GeneralOrthogonalGroupCons( arg[1], 0, arg[2], arg[3] ); elif Length( arg ) = 4 then return GeneralOrthogonalGroupCons( arg[1], arg[2], arg[3], arg[4] ); fi; fi; Error( "usage: GeneralOrthogonalGroup( [, ][, ], )" ); end ); DeclareSynonym( "GO", GeneralOrthogonalGroup ); ############################################################################# ## #O GeneralUnitaryGroupCons( , , ) ## ## ## ## ## ## ## ## DeclareConstructor( "GeneralUnitaryGroupCons", [ IsGroup, IsPosInt, IsPosInt ] ); ############################################################################# ## #F GeneralUnitaryGroup( [, ], ) . . . . . general unitary group #F GU( [, ], ) ## ## <#GAPDoc Label="GeneralUnitaryGroup"> ## ## ## ## ## ## constructs a group isomorphic to the general unitary group ## GU( d, q ) of those d \times d ## matrices over the field with q^2 elements ## that respect a fixed nondegenerate sesquilinear form, ## in the category given by the filter filt. ##

## If filt is not given it defaults to , ## and the returned group is the general unitary group itself. ##

## ## GeneralUnitaryGroup( 3, 5 ); ## GU(3,5) ## ]]> ## ## ## <#/GAPDoc> ## BindGlobal( "GeneralUnitaryGroup", function ( arg ) if Length( arg ) = 2 then return GeneralUnitaryGroupCons( IsMatrixGroup, arg[1], arg[2] ); elif IsOperation( arg[1] ) then if Length( arg ) = 3 then return GeneralUnitaryGroupCons( arg[1], arg[2], arg[3] ); fi; fi; Error( "usage: GeneralUnitaryGroup( [, ], )" ); end ); DeclareSynonym( "GU", GeneralUnitaryGroup ); ############################################################################# ## #O SpecialLinearGroupCons( , , ) ## ## ## ## ## ## ## ## DeclareConstructor( "SpecialLinearGroupCons", [ IsGroup, IsInt, IsRing ] ); ############################################################################# ## #F SpecialLinearGroup( [, ], ) . . . . . special linear group #F SL( [, ], ) #F SpecialLinearGroup( [, ], ) #F SL( [, ], ) ## ## <#GAPDoc Label="SpecialLinearGroup"> ## ## SpecialLinearGroup ## ## ## ## ## ## ## The first two forms construct a group isomorphic to the special linear ## group SL( d, R ) of all those ## d \times d matrices over the ring R whose ## determinant is the identity of R, ## in the category given by the filter filt. ##

## The third and the fourth form construct the special linear group over the ## finite field with q elements. ##

## If filt is not given it defaults to , ## and the returned group is the special linear group as a matrix group in ## its natural action (see also , ## ). ##

## Currently supported rings R are finite fields, ## the ring , ## and residue class rings Integers mod m, ## see . ##

## SpecialLinearGroup(2,2); ## SL(2,2) ## gap> SL(3,Integers); ## SL(3,Integers) ## gap> SL(4,Integers mod 4); ## SL(4,Z/4Z) ## ]]> ## ## ## <#/GAPDoc> ## BindGlobal( "SpecialLinearGroup", function ( arg ) if Length( arg ) = 2 then if IsRing( arg[2] ) then return SpecialLinearGroupCons( IsMatrixGroup, arg[1], arg[2] ); elif IsPrimePowerInt( arg[2] ) then return SpecialLinearGroupCons( IsMatrixGroup, arg[1], GF( arg[2] ) ); fi; elif Length( arg ) = 3 and IsOperation( arg[1] ) then if IsRing( arg[3] ) then return SpecialLinearGroupCons( arg[1], arg[2], arg[3] ); elif IsPrimePowerInt( arg[3] ) then return SpecialLinearGroupCons( arg[1], arg[2], GF( arg[3] ) ); fi; fi; Error( "usage: SpecialLinearGroup( [, ], )" ); end ); DeclareSynonym( "SL", SpecialLinearGroup ); ############################################################################# ## #O SpecialOrthogonalGroupCons( , , , ) ## ## ## ## ## ## ## ## DeclareConstructor( "SpecialOrthogonalGroupCons", [ IsGroup, IsInt, IsPosInt, IsPosInt ] ); DeclareConstructor( "SpecialOrthogonalGroupCons", [ IsGroup, IsInt, IsPosInt, IsRing ] ); ############################################################################# ## #F SpecialOrthogonalGroup( [, ][, ], ) . spec. orthog. group #F SO( [, ][, ], ) ## ## <#GAPDoc Label="SpecialOrthogonalGroup"> ## ## ## ## ## ## returns a group isomorphic to the ## special orthogonal group SO( e, d, q ), ## which is the subgroup of all those matrices in the general orthogonal ## group (see ) that have ## determinant one, in the category given by the filter filt. ## (The index of SO( e, d, q ) in ## GO( e, d, q ) is 2 if q is ## odd, and 1 if q is even.) ## Also interesting is the group Omega( e, d, q ), ## see , ## which is always of index 2 in SO( e, d, q ). ##

## If filt is not given it defaults to , ## and the returned group is the special orthogonal group itself. ##

## ## GeneralOrthogonalGroup( 3, 7 ); ## GO(0,3,7) ## gap> GeneralOrthogonalGroup( -1, 4, 3 ); ## GO(-1,4,3) ## gap> SpecialOrthogonalGroup( 1, 4, 4 ); ## GO(+1,4,4) ## ]]> ## ## ## <#/GAPDoc> ## BindGlobal( "SpecialOrthogonalGroup", function ( arg ) if Length( arg ) = 2 then return SpecialOrthogonalGroupCons( IsMatrixGroup, 0, arg[1], arg[2] ); elif Length( arg ) = 3 and IsInt(arg[1]) and IsInt(arg[2]) and (IsInt(arg[3]) or IsRing(arg[3])) then return SpecialOrthogonalGroupCons( IsMatrixGroup,arg[1],arg[2],arg[3] ); elif IsOperation( arg[1] ) then if Length( arg ) = 3 then return SpecialOrthogonalGroupCons( arg[1], 0, arg[2], arg[3] ); elif Length( arg ) = 4 then return SpecialOrthogonalGroupCons( arg[1], arg[2], arg[3], arg[4] ); fi; fi; Error( "usage: SpecialOrthogonalGroup( [, ][, ], )" ); end ); DeclareSynonym( "SO", SpecialOrthogonalGroup ); ############################################################################# ## #O SpecialUnitaryGroupCons( , , ) ## ## ## ## ## ## ## ## DeclareConstructor( "SpecialUnitaryGroupCons", [ IsGroup, IsPosInt, IsPosInt ] ); ############################################################################# ## #F SpecialUnitaryGroup( [, ], ) . . . . . general unitary group #F SU( [, ], ) ## ## <#GAPDoc Label="SpecialUnitaryGroup"> ## ## ## ## ## ## constructs a group isomorphic to the special unitary group ## GU(d, q) of those d \times d matrices ## over the field with q^2 elements ## whose determinant is the identity of the field and that respect a fixed ## nondegenerate sesquilinear form, ## in the category given by the filter filt. ##

## If filt is not given it defaults to , ## and the returned group is the special unitary group itself. ##

## ## SpecialUnitaryGroup( 3, 5 ); ## SU(3,5) ## ]]> ## ## ## <#/GAPDoc> ## BindGlobal( "SpecialUnitaryGroup", function ( arg ) if Length( arg ) = 2 then return SpecialUnitaryGroupCons( IsMatrixGroup, arg[1], arg[2] ); elif IsOperation( arg[1] ) then if Length( arg ) = 3 then return SpecialUnitaryGroupCons( arg[1], arg[2], arg[3] ); fi; fi; Error( "usage: SpecialUnitaryGroup( [, ], )" ); end ); DeclareSynonym( "SU", SpecialUnitaryGroup ); ############################################################################# ## #O SymplecticGroupCons( , , ) ## ## ## ## ## ## ## ## DeclareConstructor( "SymplecticGroupCons", [ IsGroup, IsPosInt, IsPosInt ] ); DeclareConstructor( "SymplecticGroupCons", [ IsGroup, IsPosInt, IsRing ] ); ############################################################################# ## #F SymplecticGroup( [, ], ) . . . . . . . . . symplectic group #F Sp( [, ], ) #F SP( [, ], ) ## ## <#GAPDoc Label="SymplecticGroup"> ## ## SymplecticGroup ## ## ## ## ## ## ## ## ## constructs a group isomorphic to the symplectic group ## Sp( d, q ) of those d \times d ## matrices over the field with q elements (respectively the ring ## ring) ## that respect a fixed nondegenerate symplectic form, ## in the category given by the filter filt. ##

## If filt is not given it defaults to , ## and the returned group is the symplectic group itself. ##

## At the moment finite fields or residue class rings ## Integers mod q, with q an odd prime power are ## supported. ## ## SymplecticGroup( 4, 2 ); ## Sp(4,2) ## gap> g:=SymplecticGroup(6,Integers mod 9); ## Sp(6,Z/9Z) ## gap> Size(g); ## 95928796265538862080 ## ]]> ## ## ## <#/GAPDoc> ## BindGlobal( "SymplecticGroup", function ( arg ) if Length( arg ) = 2 then return SymplecticGroupCons( IsMatrixGroup, arg[1], arg[2] ); elif IsOperation( arg[1] ) then if Length( arg ) = 3 then return SymplecticGroupCons( arg[1], arg[2], arg[3] ); fi; fi; Error( "usage: SymplecticGroup( [, ], )" ); end ); DeclareSynonym( "Sp", SymplecticGroup ); DeclareSynonym( "SP", SymplecticGroup ); ############################################################################# ## #O OmegaCons( , , , ) . . . . . . . . . orthogonal group ## ## ## ## ## ## ## ## DeclareConstructor( "OmegaCons", [ IsGroup, IsInt, IsPosInt, IsPosInt ] ); ############################################################################# ## #O Omega( [, ][, ], ) ## ## <#GAPDoc Label="Omega_orthogonal_groups"> ## ## ## ## ## constructs a group isomorphic to the ## group \Omega( e, d, q ) of those ## d \times d matrices over the field with q ## elements that respect a non-singular quadratic form ## (see ) specified by e, ## and that have square spinor norm in odd characteristic ## or Dickson invariant 0 in even characteristic, respectively, ## in the category given by the filter filt. ## This group has always index two in SO( e, d, q ), ## see . ##

## The value of e must be 0 for odd d (and can ## optionally be omitted in this case), respectively one of 1 or ## -1 for even d. ## If filt is not given it defaults to , ## and the returned group is the group ## \Omega( e, d, q ) itself. ##

## ## g:= Omega( 3, 5 ); StructureDescription( g ); ## Omega(0,3,5) ## "A5" ## gap> g:= Omega( 1, 4, 4 ); StructureDescription( g ); ## Omega(+1,4,4) ## "A5 x A5" ## gap> g:= Omega( -1, 4, 3 ); StructureDescription( g ); ## Omega(-1,4,3) ## "A6" ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "Omega", [ IsPosInt, IsPosInt ] ); DeclareOperation( "Omega", [ IsInt, IsPosInt, IsPosInt ] ); DeclareOperation( "Omega", [ IsFunction, IsPosInt, IsPosInt ] ); DeclareOperation( "Omega", [ IsFunction, IsInt, IsPosInt, IsPosInt ] ); ############################################################################# ## #O GeneralSemilinearGroupCons( , , ) ## ## ## ## ## ## ## ## DeclareConstructor( "GeneralSemilinearGroupCons", [ IsGroup, IsPosInt, IsPosInt ] ); ############################################################################# ## #F GeneralSemilinearGroup( [, ], ) . general semilinear group #F GammaL( [, ], ) ## ## <#GAPDoc Label="GeneralSemilinearGroup"> ## ## ## ## ## ## returns a group isomorphic to the ## general semilinear group \GammaL( d, q ) of ## semilinear mappings of the vector space ## GF( q )^d. ##

## If filt is not given it defaults to , ## and the returned group consists of matrices of dimension ## d f over the field with p elements, ## where q = p^f, for a prime integer p. ## ## ## <#/GAPDoc> ## BindGlobal( "GeneralSemilinearGroup", function( arg ) if Length( arg ) = 2 then return GeneralSemilinearGroupCons( IsMatrixGroup, arg[1], arg[2] ); elif Length( arg ) = 3 and IsOperation( arg[1] ) then return GeneralSemilinearGroupCons( arg[1], arg[2], arg[3] ); fi; Error( "usage: GeneralSemilinearGroup( [, ], )" ); end ); DeclareSynonym( "GammaL", GeneralSemilinearGroup ); ############################################################################# ## #O SpecialSemilinearGroupCons( , , ) ## ## ## ## ## ## ## ## DeclareConstructor( "SpecialSemilinearGroupCons", [ IsGroup, IsPosInt, IsPosInt ] ); ############################################################################# ## #F SpecialSemilinearGroup( [, ], ) . special semilinear group #F SigmaL( [, ], ) ## ## <#GAPDoc Label="SpecialSemilinearGroup"> ## ## ## ## ## ## returns a group isomorphic to the ## special semilinear group \SigmaL( d, q ) of those ## semilinear mappings of the vector space ## GF( q )^d ## (see ) ## whose linear part has determinant one. ##

## If filt is not given it defaults to , ## and the returned group consists of matrices of dimension ## d f over the field with p elements, ## where q = p^f, for a prime integer p. ## ## ## <#/GAPDoc> ## BindGlobal( "SpecialSemilinearGroup", function( arg ) if Length( arg ) = 2 then return SpecialSemilinearGroupCons( IsMatrixGroup, arg[1], arg[2] ); elif Length( arg ) = 3 and IsOperation( arg[1] ) then return SpecialSemilinearGroupCons( arg[1], arg[2], arg[3] ); fi; Error( "usage: SpecialSemilinearGroup( [, ], )" ); end ); DeclareSynonym( "SigmaL", SpecialSemilinearGroup ); ############################################################################# ## #F DECLARE_PROJECTIVE_GROUPS_OPERATION( ... ) ## BindGlobal("DECLARE_PROJECTIVE_GROUPS_OPERATION", # (,,,) function(nam,abbr,extdeg,szf) local pnam,cons,opr; opr:=VALUE_GLOBAL(nam); pnam:=Concatenation("Projective",nam); cons:=NewConstructor(Concatenation(pnam,"Cons"),[IsGroup,IsInt,IsInt]); BindGlobal(Concatenation(pnam,"Cons"),cons); BindGlobal(pnam,function(arg) if Length(arg) = 2 then return cons( IsPermGroup, arg[1], arg[2] ); elif IsOperation(arg[1]) then if Length(arg) = 3 then return cons( arg[1], arg[2], arg[3] ); fi; fi; Error( "usage: ",pnam,"( [, ], )" ); end ); DeclareSynonym(Concatenation("P",abbr),VALUE_GLOBAL(pnam)); # install a method to get the permutation action on lines InstallMethod( cons,"action on lines", [ IsPermGroup, IsPosInt,IsPosInt ], function(fil,n,q) local g,f,p; g:=opr(IsMatrixGroup,n,q); f:=GF(q^extdeg); p:=ProjectiveActionOnFullSpace(g,f,n); if szf<>fail then SetSize(p,szf(n,q,g)); fi; return p; end); end); ############################################################################# ## #F ProjectiveGeneralLinearGroup( [, ], ) #F PGL( [, ], ) ## ## <#GAPDoc Label="ProjectiveGeneralLinearGroup"> ## ## ## ## ## ## constructs a group isomorphic to the projective general linear group ## PGL( d, q ) of those d \times d ## matrices over the field with q elements, modulo the ## centre, in the category given by the filter filt. ##

## If filt is not given it defaults to , ## and the returned group is the action on lines of the underlying vector ## space. ##

## ## ## <#/GAPDoc> ## DECLARE_PROJECTIVE_GROUPS_OPERATION("GeneralLinearGroup","GL",1, # size function function(n,q,g) return Size(g)/(q-1); end); ############################################################################# ## #F ProjectiveSpecialLinearGroup( [, ], ) #F PSL( [, ], ) ## ## <#GAPDoc Label="ProjectiveSpecialLinearGroup"> ## ## ## ## ## ## constructs a group isomorphic to the projective special linear group ## PSL( d, q ) of those d \times d ## matrices over the field with q elements whose determinant is the ## identity of the field, modulo the centre, ## in the category given by the filter filt. ##

## If filt is not given it defaults to , ## and the returned group is the action on lines of the underlying vector ## space. ## ## ## <#/GAPDoc> ## DECLARE_PROJECTIVE_GROUPS_OPERATION("SpecialLinearGroup","SL",1, # size function function(n,q,g) return Size(g)/Gcd(n,q-1); end); ############################################################################# ## #F ProjectiveGeneralUnitaryGroup( [, ], ) #F PGU( [, ], ) ## ## <#GAPDoc Label="ProjectiveGeneralUnitaryGroup"> ## ## ## ## ## ## constructs a group isomorphic to the projective general unitary group ## PGU( d, q ) of those d \times d ## matrices over the field with q^2 elements that respect ## a fixed nondegenerate sesquilinear form, ## modulo the centre, in the category given by the filter filt. ##

## If filt is not given it defaults to , ## and the returned group is the action on lines of the underlying vector ## space. ## ## ## <#/GAPDoc> ## DECLARE_PROJECTIVE_GROUPS_OPERATION("GeneralUnitaryGroup","GU",2, # size function function(n,q,g) return Size(g)/(q+1); end); ############################################################################# ## #F ProjectiveSpecialUnitaryGroup( [, ], ) #F PSU( [, ], ) ## ## <#GAPDoc Label="ProjectiveSpecialUnitaryGroup"> ## ## ## ## ## ## constructs a group isomorphic to the projective special unitary group ## PSU( d, q ) of those d \times d ## matrices over the field with q^2 elements that respect ## a fixed nondegenerate sesquilinear form and have determinant 1, ## modulo the centre, in the category given by the filter filt. ##

## If filt is not given it defaults to , ## and the returned group is the action on lines of the underlying vector ## space. ## ## ## <#/GAPDoc> ## DECLARE_PROJECTIVE_GROUPS_OPERATION("SpecialUnitaryGroup","SU",2, # size function function(n,q,g) return Size(g)/Gcd(n,q+1); end); ############################################################################# ## #F ProjectiveSymplecticGroup( [, ], ) #F PSP( [, ], ) #F PSp( [, ], ) ## ## <#GAPDoc Label="ProjectiveSymplecticGroup"> ## ## ## ## ## ## ## constructs a group isomorphic to the projective symplectic group ## PSp(d,q) of those d \times d matrices ## over the field with q elements that respect a fixed nondegenerate ## symplectic form, modulo the centre, ## in the category given by the filter filt. ##

## If filt is not given it defaults to , ## and the returned group is the action on lines of the underlying vector ## space. ## ## ## <#/GAPDoc> ## DECLARE_PROJECTIVE_GROUPS_OPERATION("SymplecticGroup","SP",1, # size function function(n,q,g) return Size(g)/Gcd(2,q-1); end); DeclareSynonym( "PSp", PSP ); ############################################################################# ## #O ProjectiveOmegaCons( , , , ) #F ProjectiveOmega( [, ][, ], ) #F POmega( [, ][, ], ) ## ## <#GAPDoc Label="ProjectiveOmega"> ## ## ## ## ## ## constructs a group isomorphic to the projective group ## P\Omega( e, d, q ) ## of \Omega( e, d, q ), ## modulo the centre ## (see ), ## in the category given by the filter filt. ##

## If filt is not given it defaults to , ## and the returned group is the action on lines of the underlying vector ## space. ## ## ## <#/GAPDoc> ## DeclareConstructor( "ProjectiveOmegaCons", [ IsGroup, IsInt, IsInt, IsInt ] ); BindGlobal( "ProjectiveOmega", function( arg ) if Length( arg ) = 2 then return ProjectiveOmegaCons( IsPermGroup, 0, arg[1], arg[2] ); elif Length( arg ) = 3 and IsInt( arg[1] ) then return ProjectiveOmegaCons( IsPermGroup, arg[1], arg[2], arg[3] ); elif Length( arg ) = 3 and IsOperation( arg[1] ) then return ProjectiveOmegaCons( arg[1], 0, arg[2], arg[3] ); elif IsOperation( arg[1] ) and Length( arg ) = 4 then return ProjectiveOmegaCons( arg[1], arg[2], arg[3], arg[4] ); fi; Error( "usage: ProjectiveOmega( [, ][, ], )" ); end ); DeclareSynonym( "POmega", ProjectiveOmega ); InstallMethod( ProjectiveOmegaCons, "action on lines", [ IsPermGroup, IsInt, IsPosInt, IsPosInt ], function( filter, e, n, q ) local g, p; g:= Omega( IsMatrixGroup, e, n, q ); p:= ProjectiveActionOnFullSpace( g, GF( q ), n ); if n mod 2 = 0 and ( q^(n/2) - e ) mod 4 = 0 then SetSize( p, Size( g ) / 2 ); else SetSize( p, Size( g ) ); fi; return p; end); ############################################################################# ## #E gap-4r6p5/grp/imf29.grp0000644000175000017500000002401412172557252013372 0ustar billbill############################################################################# ## #A imf29.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Q-class representative of the irreducible ## maximal finite integral matrix groups of dimension 29, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Q-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 29. ## IMFList[29].matrices := [ [ # Q-class [29][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]]], [ # Q-class [29][02] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]] ]; MakeImmutable( IMFList[29].matrices ); gap-4r6p5/grp/perf3.grp0000644000175000017500000006006612172557252013472 0ustar billbill############################################################################# ## #W perf3.grp GAP Groups Library Volkmar Felsch ## Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains the perfect groups of sizes 21504-30240 ## All data is based on Holt/Plesken: Perfect Groups, OUP 1989 ## PERFGRP[60]:=[# 21504.1 [[1,"abdxyzXYZ", function(a,b,d,x,y,z,X,Y,Z) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *d^-1,d^2,d^-1*b^-1*d*b,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,X^2,Y^2,Z^2, X^-1*Y^-1*X*Y,X^-1*Z^-1*X*Z, Y^-1*Z^-1*Y*Z,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,a^-1*X*a*Z^-1, a^-1*Y*a*(X*Y*Z)^-1,a^-1*Z*a*X^-1, b^-1*X*b*Y^-1,b^-1*Y*b*(X*Y)^-1, b^-1*Z*b*Z^-1,x^-1*X*x*X^-1, x^-1*Y*x*Y^-1,x^-1*Z*x*Z^-1, y^-1*X*y*X^-1,y^-1*Y*y*Y^-1, y^-1*Z*y*Z^-1,z^-1*X*z*X^-1, z^-1*Y*z*Y^-1,z^-1*Z*z*Z^-1], [[a,b,X],[a,b,x], [a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,x,X]] ]; end, [8,8,16]], "L3(2) 2^7",[8,7,1],2, 2,[8,8,16]], # 21504.2 [[1,"abxyzXYZf", function(a,b,x,y,z,X,Y,Z,f) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,x^2,y^2, z^2,x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,X^2,Y^2,Z^2, X^-1*Y^-1*X*Y,X^-1*Z^-1*X*Z, Y^-1*Z^-1*Y*Z,f^2,f^-1*x^-1*f*x, f^-1*y^-1*f*y,f^-1*z^-1*f*z, f^-1*X^-1*f*X,f^-1*Y^-1*f*Y, f^-1*Z^-1*f*Z,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,a^-1*X*a*(Z*f)^-1, a^-1*Y*a*(X*Y*Z)^-1, a^-1*Z*a*(X*f)^-1,a^-1*f^-1*a*f, b^-1*X*b*Y^-1,b^-1*Y*b*(X*Y)^-1, b^-1*Z*b*Z^-1,b^-1*f^-1*b*f, x^-1*X*x*X^-1,x^-1*Y*x*Y^-1, x^-1*Z*x*Z^-1,y^-1*X*y*X^-1, y^-1*Y*y*Y^-1,y^-1*Z*y*Z^-1, z^-1*X*z*X^-1,z^-1*Y*z*Y^-1, z^-1*Z*z*Z^-1],[[a,b,x],[a,b,X]]]; end, [16,8]], "L3(2) 2^7",[8,7,2],2, 2,[16,8]], # 21504.3 [[1,"abdxyzXYZ", function(a,b,d,x,y,z,X,Y,Z) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *(d*Y*Z)^-1,d^2,d^-1*b^-1*d*b,x^2,y^2, z^2,x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,X^2,Y^2,Z^2, X^-1*Y^-1*X*Y,X^-1*Z^-1*X*Z, Y^-1*Z^-1*Y*Z,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,a^-1*X*a*Z^-1, a^-1*Y*a*(X*Y*Z)^-1,a^-1*Z*a*X^-1, b^-1*X*b*Y^-1,b^-1*Y*b*(X*Y)^-1, b^-1*Z*b*Z^-1,x^-1*X*x*X^-1, x^-1*Y*x*Y^-1,x^-1*Z*x*Z^-1, y^-1*X*y*X^-1,y^-1*Y*y*Y^-1, y^-1*Z*y*Z^-1,z^-1*X*z*X^-1, z^-1*Y*z*Y^-1,z^-1*Z*z*Z^-1], [[a,b,X],[b,a*b*a*b^-1*a,x,z,X], [a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,x,X]] ]; end, [8,14,16]], "L3(2) 2^7",[8,7,3],2, 2,[8,14,16]], # 21504.4 [[1,"abxyzXYZe", function(a,b,x,y,z,X,Y,Z,e) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4*(Y*Z)^-1 ,x^2,y^2,z^2,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z,X^2, Y^2,Z^2,X^-1*Y^-1*X*Y,X^-1*Z^-1*X*Z ,Y^-1*Z^-1*Y*Z,e^2,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z, e^-1*X^-1*e*X,e^-1*Y^-1*e*Y, e^-1*Z^-1*e*Z,a^-1*x*a*(z*e)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e)^-1,b^-1*x*b*y^-1, b^-1*y*b*(x*y)^-1,b^-1*z*b*z^-1, a^-1*X*a*Z^-1,a^-1*Y*a*(X*Y*Z)^-1, a^-1*Z*a*X^-1,a^-1*e^-1*a*e, b^-1*X*b*Y^-1,b^-1*Y*b*(X*Y)^-1, b^-1*Z*b*Z^-1,b^-1*e^-1*b*e, x^-1*X*x*X^-1,x^-1*Y*x*Y^-1, x^-1*Z*x*Z^-1,y^-1*X*y*X^-1, y^-1*Y*y*Y^-1,y^-1*Z*y*Z^-1, z^-1*X*z*X^-1,z^-1*Y*z*Y^-1, z^-1*Z*z*Z^-1], [[b,a*b*a*b^-1*a,x,z,X],[a,b,X]]]; end, [14,16]], "L3(2) 2^7",[8,7,4],2, 2,[14,16]], # 21504.5 [[1,"abdxyzXYZ", function(a,b,d,x,y,z,X,Y,Z) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *d^-1,d^2,b^-1*d^-1*b*d,x^2*X^-1, y^2*Y^-1,z^2*Z^-1,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*x*a*(z*Y)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*X*Y*Z)^-1, b^-1*x*b*(y*X)^-1, b^-1*y*b*(x*y*Z)^-1, b^-1*z*b*(z*X*Y)^-1,a^-1*X*a*Z^-1, a^-1*Y*a*(X*Y*Z)^-1,a^-1*Z*a*X^-1, b^-1*X*b*Y^-1,b^-1*Y*b*(X*Y)^-1, b^-1*Z*b*Z^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,x], [b,a*b*a*b^-1*a,x*Z]]]; end, [16,28]], "L3(2) 2^7",[8,7,5],2, 2,[16,28]], # 21504.6 [[1,"abxyzeXYZ", function(a,b,x,y,z,e,X,Y,Z) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,e^2,x^2*X ^-1,y^2*Y^-1,z^2*Z^-1, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,e^2,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z, a^-1*x*a*(z*e*Y)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e*X*Y*Z)^-1, a^-1*e^-1*a*e,b^-1*x*b*(y*X)^-1, b^-1*y*b*(x*y*Z)^-1, b^-1*z*b*(z*X*Y)^-1,b^-1*e^-1*b*e, a^-1*X*a*Z^-1,a^-1*Y*a*(X*Y*Z)^-1, a^-1*Z*a*X^-1,b^-1*X*b*Y^-1, b^-1*Y*b*(X*Y)^-1,b^-1*Z*b*Z^-1], [[a,b,X],[b,a*b*a*b^-1*a,x*Z]]]; end, [16,28]], "L3(2) 2^7",[8,7,6],2, 2,[16,28]], # 21504.7 [[1,"abdxyzXYZ", function(a,b,d,x,y,z,X,Y,Z) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *d^-1,d^2,x^2*X^-1,y^2*Y^-1, z^2*Z^-1,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z,d^2, d^-1*x^-1*d*x,d^-1*y^-1*d*y, d^-1*z^-1*d*z,a^-1*x*a*(z*d*Y)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*d*X*Y*Z)^-1, a^-1*d^-1*a*d,b^-1*x*b*(y*X)^-1, b^-1*y*b*(x*y*Z)^-1, b^-1*z*b*(z*X*Y)^-1,b^-1*d^-1*b*d, a^-1*X*a*Z^-1,a^-1*Y*a*(X*Y*Z)^-1, a^-1*Z*a*X^-1,b^-1*X*b*Y^-1, b^-1*Y*b*(X*Y)^-1,b^-1*Z*b*Z^-1], [[a*y*z,b,X],[b,a*b*a*b^-1*a,x*Z]]]; end, [16,28]], "L3(2) 2^7",[8,7,7],2, 2,[16,28]], # 21504.8 [[1,"abdxyzXYZ", function(a,b,d,x,y,z,X,Y,Z) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *(d*y*z*X*Z)^-1,d^2,d^-1*b^-1*d*b, x^2*X^-1,y^2*Y^-1,z^2*Z^-1, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*x*a*(z*Y)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*X*Y*Z)^-1, b^-1*x*b*(y*X)^-1, b^-1*y*b*(x*y*Z)^-1, b^-1*z*b*(z*X*Y)^-1,a^-1*X*a*Z^-1, a^-1*Y*a*(X*Y*Z)^-1,a^-1*Z*a*X^-1, b^-1*X*b*Y^-1,b^-1*Y*b*(X*Y)^-1, b^-1*Z*b*Z^-1], [[b,a*b*a*b*a*b^-1*a*b*a*b*a,x*Z], [a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,x, a^2*d^-1]]]; end, [112,16]], "L3(2) 2^7",[8,7,8],2, 2,[112,16]], # 21504.9 [[1,"abxyzuvwg", function(a,b,x,y,z,u,v,w,g) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,u^2,v^2, w^2,u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,g^2,g^-1*x^-1*g*x, g^-1*y^-1*g*y,g^-1*z^-1*g*z, g^-1*u^-1*g*u,g^-1*v^-1*g*v, g^-1*w^-1*g*w,a^-1*u*a*(v*w)^-1, a^-1*v*a*v^-1,a^-1*w*a*(u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, a^-1*g*a*g^-1,b^-1*x*b*y^-1, b^-1*y*b*(x*y)^-1,b^-1*z*b*z^-1, b^-1*g*b*g^-1,u^-1*x*u*x^-1 *g^-1,u^-1*y*u*y^-1, u^-1*z*u*z^-1,v^-1*x*v*x^-1, v^-1*y*v*y^-1*g^-1, v^-1*z*v*z^-1,w^-1*x*w*x^-1, w^-1*y*w*y^-1,w^-1*z*w*z^-1 *g^-1],[[a,b,x]]]; end, [16]], "L3(2) ( 2^3 x 2^3' ) C 2^1",[8,7,9],2, 2,16], # 21504.10 [[1,"abxyzuvwf", function(a,b,x,y,z,u,v,w,f) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,u^2,v^2, w^2,u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,f^2,f^-1*x^-1*f*x, f^-1*y^-1*f*y,f^-1*z^-1*f*z, f^-1*u^-1*f*u,f^-1*v^-1*f*v, f^-1*w^-1*f*w,a^-1*u*a*(v*w)^-1, a^-1*v*a*(v*f)^-1, a^-1*w*a*(u*v*f)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, a^-1*f*a*f^-1,b^-1*x*b*y^-1, b^-1*y*b*(x*y)^-1,b^-1*z*b*z^-1, b^-1*f*b*f^-1,u^-1*x*u*x^-1, u^-1*y*u*y^-1,u^-1*z*u*z^-1, v^-1*x*v*x^-1,v^-1*y*v*y^-1, v^-1*z*v*z^-1,w^-1*x*w*x^-1, w^-1*y*w*y^-1,w^-1*z*w*z^-1], [[a,b,x],[a,b,u]]]; end, [16,8]], "L3(2) 2^3 x ( 2^3' E 2^1 )",[8,7,10],2, 2,[16,8]], # 21504.11 [[1,"abdxyzuvw", function(a,b,d,x,y,z,u,v,w) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *d^-1,d^2,d^-1*b^-1*d*b,u^2,v^2,w^2, u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*u*a*(v*w)^-1, a^-1*v*a*v^-1,a^-1*w*a*(u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,u^-1*x*u*x^-1, u^-1*y*u*y^-1,u^-1*z*u*z^-1, v^-1*x*v*x^-1,v^-1*y*v*y^-1, v^-1*z*v*z^-1,w^-1*x*w*x^-1, w^-1*y*w*y^-1,w^-1*z*w*z^-1], [[a,b,u],[a,b,x], [a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,u,x]] ]; end, [8,8,16]], "L3(2) 2^7",[8,7,11],2, 2,[8,8,16]], # 21504.12 [[1,"abxyzeuvw", function(a,b,x,y,z,e,u,v,w) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,u^2,v^2, w^2,u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,e^2,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z, e^-1*u^-1*e*u,e^-1*v^-1*e*v, e^-1*w^-1*e*w,a^-1*u*a*(v*w)^-1, a^-1*v*a*(v*e)^-1, a^-1*w*a*(u*v*e)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,a^-1*x*a*(z*e)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e)^-1,a^-1*e*a*e^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,b^-1*e*b*e^-1, u^-1*x*u*x^-1,u^-1*y*u*y^-1, u^-1*z*u*z^-1,v^-1*x*v*x^-1, v^-1*y*v*y^-1,v^-1*z*v*z^-1, w^-1*x*w*x^-1,w^-1*y*w*y^-1, w^-1*z*w*z^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,z,w]]]; end, [16]], "L3(2) 2^7",[8,7,12],2, 2,16], # 21504.13 [[1,"abdxyzuvw", function(a,b,d,x,y,z,u,v,w) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *d^-1,d^2,d^-1*b^-1*d*b,u^2,v^2,w^2, u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*u*a*(v*w)^-1, a^-1*v*a*v^-1,a^-1*w*a*(u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,u^-1*x*u*x^-1 *d^-1,u^-1*y*u*y^-1, u^-1*z*u*z^-1,v^-1*x*v*x^-1, v^-1*y*v*y^-1*d^-1, v^-1*z*v*z^-1,w^-1*x*w*x^-1, w^-1*y*w*y^-1,w^-1*z*w*z^-1 *d^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,u]]]; end, [128]], "L3(2) 2^7",[8,7,13],2, 2,128], # 21504.14 [[1,"abdxyzuvw", function(a,b,d,x,y,z,u,v,w) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *(d*u*v*w)^-1,d^2,d^-1*b^-1*d*b,u^2, v^2,w^2,u^-1*v^-1*u*v,u^-1*w^-1*u*w ,v^-1*w^-1*v*w,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*u*a*(v*w)^-1, a^-1*v*a*v^-1,a^-1*w*a*(u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,u^-1*x*u*x^-1, u^-1*y*u*y^-1,u^-1*z*u*z^-1, v^-1*x*v*x^-1,v^-1*y*v*y^-1, v^-1*z*v*z^-1,w^-1*x*w*x^-1, w^-1*y*w*y^-1,w^-1*z*w*z^-1], [[a,b,u],[b,a*b^-1*a*b*a,x,z,u], [a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,u,x]] ]; end, [8,14,16]], "L3(2) 2^7",[8,7,14],2, 2,[8,14,16]], # 21504.15 [[1,"abxyzeuvw", function(a,b,x,y,z,e,u,v,w) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4*(u*v*w)^(-1 *1),u^2,v^2,w^2,u^-1*v^-1*u*v, u^-1*w^-1*u*w,v^-1*w^-1*v*w,x^2, y^2,z^2,x^-1*y^-1*x*y,x^-1*z^-1*x*z ,y^-1*z^-1*y*z,e^2,e^-1*u^-1*e*u, e^-1*v^-1*e*v,e^-1*w^-1*e*w, e^-1*x^-1*e*x,e^-1*y^-1*e*y, e^-1*z^-1*e*z,a^-1*u*a*(v*w)^-1, a^-1*v*a*v^-1,a^-1*w*a*(u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,a^-1*x*a*(z*e)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e)^-1,a^-1*e*a*e^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,b^-1*e*b*e^-1, u^-1*x*u*x^-1,u^-1*y*u*y^-1, u^-1*z*u*z^-1,v^-1*x*v*x^-1, v^-1*y*v*y^-1,v^-1*z*v*z^-1, w^-1*x*w*x^-1,w^-1*y*w*y^-1, w^-1*z*w*z^-1], [[a,b,u],[b,a*b^-1*a*b*a,x,z,u]]]; end, [16,14]], "L3(2) 2^7",[8,7,15],2, 2,[16,14]], # 21504.16 [[1,"abdxyzuvw", function(a,b,d,x,y,z,u,v,w) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *(d*y*z*u*v*w)^-1,d^2,d^-1*b^-1*d*b, u^2,v^2,w^2,u^-1*v^-1*u*v, u^-1*w^-1*u*w,v^-1*w^-1*v*w,x^2, y^2,z^2,x^-1*y^-1*x*y,x^-1*z^-1*x*z ,y^-1*z^-1*y*z,a^-1*u*a*(v*w)^-1, a^-1*v*a*v^-1,a^-1*w*a*(u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,u^-1*x*u*x^-1, u^-1*y*u*y^-1,u^-1*z*u*z^-1, v^-1*x*v*x^-1,v^-1*y*v*y^-1, v^-1*z*v*z^-1,w^-1*x*w*x^-1, w^-1*y*w*y^-1,w^-1*z*w*z^-1], [[b,a*b*a*b^-1*a,x,u,w], [b,a*b^-1*a*b*a,x,z,u], [a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,x,u]] ]; end, [14,14,16]], "L3(2) 2^7",[8,7,16],2, 2,[14,14,16]], # 21504.17 [[1,"abdxyzuvw", function(a,b,d,x,y,z,u,v,w) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *d^-1,d^2,d^-1*b^-1*d*b,u^2,v^2,w^2, u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, b^-1*x*b*(y*w)^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*(z*u)^-1,a^-1*u*a*(v*w)^-1, a^-1*v*a*v^-1,a^-1*w*a*(u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,u^-1*x*u*x^-1, u^-1*y*u*y^-1,u^-1*z*u*z^-1, v^-1*x*v*x^-1,v^-1*y*v*y^-1, v^-1*z*v*z^-1,w^-1*x*w*x^-1, w^-1*y*w*y^-1,w^-1*z*w*z^-1], [[b,a*b*a*b^-1*a,x,w], [a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,x,u]] ]; end, [56,16]], "L3(2) 2^7",[8,7,17],2, 2,[56,16]], # 21504.18 [[1,"abxyzeuvw", function(a,b,x,y,z,e,u,v,w) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,u^2,v^2, w^2,u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,e^2,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z, e^-1*u^-1*e*u,e^-1*v^-1*e*v, e^-1*w^-1*e*w,a^-1*x*a*(z*e)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e)^-1,a^-1*e*a*e^-1, b^-1*x*b*(y*w)^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*(z*u)^-1,b^-1*e*b*e^-1, a^-1*u*a*(v*w)^-1,a^-1*v*a*v^-1, a^-1*w*a*(u*v)^-1,b^-1*u*b*(u*v)^-1, b^-1*v*b*u^-1,b^-1*w*b*w^-1, u^-1*x*u*x^-1,u^-1*y*u*y^-1, u^-1*z*u*z^-1,v^-1*x*v*x^-1, v^-1*y*v*y^-1,v^-1*z*v*z^-1, w^-1*x*w*x^-1,w^-1*y*w*y^-1, w^-1*z*w*z^-1], [[b,a*b*a*b^-1*a,x,w],[a,b,u]]]; end, [56,16]], "L3(2) 2^7",[8,7,18],2, 2,[56,16]], # 21504.19 [[1,"abdxyzuvw", function(a,b,d,x,y,z,u,v,w) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *d^-1,u^2,v^2,w^2,u^-1*v^-1*u*v, u^-1*w^-1*u*w,v^-1*w^-1*v*w,x^2, y^2,z^2,x^-1*y^-1*x*y,x^-1*z^-1*x*z ,y^-1*z^-1*y*z,d^2,d^-1*x^-1*d*x, d^-1*y^-1*d*y,d^-1*z^-1*d*z, d^-1*u^-1*d*u,d^-1*v^-1*d*v, d^-1*w^-1*d*w,a^-1*x*a*(z*d)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*d)^-1,a^-1*d*a*d^-1, b^-1*x*b*(y*w)^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*(z*u)^-1,b^-1*d*b*d^-1, a^-1*u*a*(v*w)^-1,a^-1*v*a*v^-1, a^-1*w*a*(u*v)^-1,b^-1*u*b*(u*v)^-1, b^-1*v*b*u^-1,b^-1*w*b*w^-1, u^-1*x*u*x^-1,u^-1*y*u*y^-1, u^-1*z*u*z^-1,v^-1*x*v*x^-1, v^-1*y*v*y^-1,v^-1*z*v*z^-1, w^-1*x*w*x^-1,w^-1*y*w*y^-1, w^-1*z*w*z^-1], [[b,a*b*a*b^-1*a,x,w],[a*y*z,b,u]]]; end, [56,16]], "L3(2) 2^7",[8,7,19],2, 2,[56,16]], # 21504.20 [[1,"abxyzuvwf", function(a,b,x,y,z,u,v,w,f) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,u^2,v^2, w^2,u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2*f^-1,y^2*f^-1, z^2*f^-1,x^-1*y^-1*x*y*f^-1, x^-1*z^-1*x*z*f^-1,y^-1*z^-1*y *z,f^2,f^-1*x^-1*f*x,f^-1*y^-1*f*y ,f^-1*z^-1*f*z,f^-1*u^-1*f*u, f^-1*v^-1*f*v,f^-1*w^-1*f*w, a^-1*x*a*z^-1,a^-1*y*a*(x*y*z)^-1, a^-1*z*a*x^-1,a^-1*f*a*f^-1, b^-1*x*b*(y*w)^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*(z*u)^-1,b^-1*f*b*f^-1, a^-1*u*a*(v*w)^-1,a^-1*v*a*(v*f)^-1, a^-1*w*a*(u*v*f)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,u^-1*x*u*x^-1 *f^-1,u^-1*y*u*y^-1, u^-1*z*u*z^-1,v^-1*x*v*x^-1, v^-1*y*v*y^-1*f^-1, v^-1*z*v*z^-1,w^-1*x*w*x^-1, w^-1*y*w*y^-1,w^-1*z*w*z^-1 *f^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,u]]]; end, [128]], "L3(2) 2^7",[8,7,20],2, 2,128], # 21504.21 [[1,"abxyzuvwe", function(a,b,x,y,z,u,v,w,e) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,u^2,v^2, w^2,u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2*e^-1,y^2*e^-1, z^2*e^-1,x^-1*y^-1*x*y*e^-1, x^-1*z^-1*x*z*e^-1,y^-1*z^-1*y *z,e^2,e^-1*x^-1*e*x,e^-1*y^-1*e*y ,e^-1*z^-1*e*z,e^-1*u^-1*e*u, e^-1*v^-1*e*v,e^-1*w^-1*e*w, a^-1*x*a*(z*e)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e)^-1,a^-1*e*a*e^-1, b^-1*x*b*(y*w)^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*(z*u)^-1,b^-1*e*b*e^-1, a^-1*u*a*(v*w)^-1,a^-1*v*a*(v*e)^-1, a^-1*w*a*(u*v*e)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,u^-1*x*u*x^-1 *e^-1,u^-1*y*u*y^-1, u^-1*z*u*z^-1,v^-1*x*v*x^-1, v^-1*y*v*y^-1*e^-1, v^-1*z*v*z^-1,w^-1*x*w*x^-1, w^-1*y*w*y^-1,w^-1*z*w*z^-1 *e^-1],[[a*y*z,b,u]]]; end, [16]], "L3(2) 2^7",[8,7,21],2, 2,16], # 21504.22 [[1,"abdxyzuvw", function(a,b,d,x,y,z,u,v,w) return [[a^2*(d*u*w)^-1,b^3,(a*b)^7,d^2,d^-1*b^-1 *d*b,(a^-1*b^-1*a*b)^4*(d*y*z*v)^-1, u^2,v^2,w^2,u^-1*v^-1*u*v, u^-1*w^-1*u*w,v^-1*w^-1*v*w,x^2, y^2,z^2,x^-1*y^-1*x*y,x^-1*z^-1*x*z ,y^-1*z^-1*y*z,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, b^-1*x*b*(y*w)^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*(z*u)^-1,a^-1*u*a*(v*w)^-1, a^-1*v*a*v^-1,a^-1*w*a*(u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,u^-1*x*u*x^-1, u^-1*y*u*y^-1,u^-1*z*u*z^-1, v^-1*x*v*x^-1,v^-1*y*v*y^-1, v^-1*z*v*z^-1,w^-1*x*w*x^-1, w^-1*y*w*y^-1,w^-1*z*w*z^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1*x*y*u, x*u*w,d], [a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,x,u]] ]; end, [64,16]], "L3(2) 2^1 x ( N 2^3 E 2^3' )",[8,7,22],2, 2,[64,16]] ]; PERFGRP[61]:=[# 21600.1 [[1,"abcde", function(a,b,c,d,e) return [[a^2,b^3,(a*b)^5,c^2,d^3,e^3,(d*e)^4,(d*e^-1)^5, c^-1*d^-1*e*d*e*d^-1*e*d*e^-1, a^-1*d^-1*a*d,a^-1*e^-1*a*e, b^-1*d^-1*b*d,b^-1*e^-1*b*e], [[b,a*b*a*b^-1*a,d,e],[a,b,c,d]]]; end, [5,6]], "A5 x A6",[33,0,1],1, [1,3],[5,6]] ]; PERFGRP[62]:=[# 23040.1 [[1,"abcstuve", function(a,b,c,s,t,u,v,e) return [[a^2,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1*b^-1*c *b*c*b^-1*c*b*c^-1,e^4, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v,s^2, t^2,u^2,v^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u*e^2,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v*e^2, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u*e)^-1, c^-1*v*c*(s*t*u*v*e^2)^-1],[[b,c]]]; end, [64]], "A6 ( 2^4 E 2^1 A ) C 2^1",[13,6,1],4, 3,64], # 23040.2 [[1,"abcstuve", function(a,b,c,s,t,u,v,e) return [[a^2*e^2,b^3,c^3,(b*c)^4*e^2,(b*c^-1)^5,a^-1 *b^-1*c*b*c*b^-1*c*b*c^-1, e^4,e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v,s^2, t^2,u^2,v^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u*e^2,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v*e^2, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u*e)^-1, c^-1*v*c*(s*t*u*v*e^2)^-1], [[a*e^-1,b*u]]]; end, [384]], "A6 ( 2^4 E 2^1 A ) C N 2^1",[13,6,2],4, 3,384], # 23040.3 [[1,"abcdstuve", function(a,b,c,d,s,t,u,v,e) return [[a^2*d^-1,b^3,c^3,(b*c)^4*d^-1,(b*c^-1)^5, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,d^2, d^-1*b^-1*d*b,d^-1*c^-1*d*c,e^2, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v,s^2, t^2,u^2,v^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u*e)^-1, c^-1*v*c*(s*t*u*v)^-1], [[a,c,v],[c*b*a*d,b,s,e]]]; end, [12,80]], "A6 2^1 x ( 2^4 E 2^1 )",[13,6,3],4, 3,[12,80]] ]; PERFGRP[63]:=[# 24360.1 [[1,"abc", function(a,b,c) return [[c^14*a^2,c*b^4*c^-1*b^-1,b^29,a^4,a^2*b^(-1 *1)*a^2*b,a^2*c^-1*a^2*c, c*a*c*a^-1,(b*a)^3, c^(-1*5)*b*c^2*b*c^3*a*b^2*a*c*b^2*a], [[b,c^4]]]; end, [120]], "L2(29) 2^1 = SL(2,29)",22,-2, 17,120] ]; PERFGRP[64]:=[# 25308.1 [[1,"abc", function(a,b,c) return [[c^18,c*b^4*c^-1*b^-1,b^37,a^2,c*a*c*a^-1, (b*a)^3,c^(-1*2)*b*c^2*b^3*a*b^2*a*c*b^2*a], [[b,c]]]; end, [38]], "L2(37)",22,-1, 21,38] ]; PERFGRP[65]:=[# 25920.1 [[1,"ab", function(a,b) return [[a^2,b^5,(a*b)^9,(a^-1*b^-1*a*b)^3,(b*a*b*a *b^-1*a*b^-1*a)^2], [[a*b*a*b^-1*a*b^-1*a,b]]]; end, [27]], "U4(2)",28,-1, 22,27] ]; PERFGRP[66]:=[# 28224.1 [[1,"abcd", function(a,b,c,d) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,c^2,d^3, (c*d)^7,(c^-1*d^-1*c*d)^4, a^-1*c^-1*a*c,a^-1*d^-1*a*d, b^-1*c^-1*b*c,b^-1*d^-1*b*d], [[b,a*b*a*b^-1*a,c,d],[a,b,c*d*c*d^-1*c,d]]] ; end, [7,7]], "L3(2) x L3(2)",[34,0,1],1, [2,2],[7,7]] ]; PERFGRP[67]:=[# 29120.1 [[1,"ab", function(a,b) return [[a^2,b^4,(a*b)^5,(a^-1*b^-1*a*b)^7,(a*b^2)^13, a*b^-1*a*b^2*a*b^2*(a*b^-1*a*b*a*b^2)^2 *a*b^2*a*b*(a*b^2)^4], [[b^-1*a*b*a*b,b*a*b*a*b^2*a*b^2*a]]]; end, [65]], "Sz(8)",28,-1, 23,65] ]; PERFGRP[68]:=[# 29160.1 [[1,"abwxyzd", function(a,b,w,x,y,z,d) return [[a^4,b^3,(a*b)^5,a^2*b*a^2*b^-1,w^3,x^3,y^3,z^3, d^3,a^-1*d*a*d^-1,b^-1*d*b*d^-1, w^-1*d^-1*w*d,x^-1*d^-1*x*d, y^-1*d^-1*y*d,z^-1*d^-1*z*d, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1*d, b^-1*y*b*w^-1*d^-1, b^-1*z*b*z^-1*d^-1], [[a*b,w],[a*b,b*a*b*a*b^-1*a*b^-1,w*d]]]; end, [24,18]], "A5 2^1 x 3^4' E 3^1",[2,5,1],6, 1,[24,18]], # 29160.2 [[1,"abstuvd", function(a,b,s,t,u,v,d) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,d^3,d^-1*a ^-1*d*a,d^-1*b^-1*d*b, d^-1*s^-1*d*s,s^3,t^3,u^3,v^3, s^-1*t^-1*s*t,s^-1*u^-1*s*u *d^-1,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v *d^-1,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*(s^-1*d)^-1, a^-1*v*a*(t^-1*d)^-1, b^-1*s*b*(s*v^-1*d^-1)^-1, b^-1*t*b*(t*u^-1*v*d)^-1, b^-1*u*b*u^-1,b^-1*v*b*v^-1], [[a,b]]]; end, [243]], "A5 2^1 3^4 C 3^1 I",[2,5,2],3, 1,243], # 29160.3 [[1,"abstuve", function(a,b,s,t,u,v,e) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,e^3,e^-1*a ^-1*e*a,e^-1*b^-1*e*b, e^-1*s^-1*e*s,s^3,t^3,u^3,v^3, s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v*e^-1, t^-1*u^-1*t*u*e^-1, t^-1*v^-1*t*v*e,u^-1*v^-1*u*v, a^-1*s*a*(u*e^-1)^-1, a^-1*t*a*(v*e)^-1,a^-1*u*a*s, a^-1*v*a*t,b^-1*s*b*(s*v^-1)^-1, b^-1*t*b*(t*u^-1*v*e^-1)^-1, b^-1*u*b*u^-1,b^-1*v*b*v^-1], [[a,b]]]; end, [243]], "A5 2^1 3^4 C 3^1 II",[2,5,3],3, 1,243], # 29160.4 [[1,"abcwxyz", function(a,b,c,w,x,y,z) return [[a^2,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1*b^-1*c *b*c*b^-1*c*b*c^-1,w^3,x^3,y^3, z^3,w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1, c^-1*w*c*(w^-1*x*y^-1*z^-1)^-1, c^-1*x*c*(x^-1*z)^-1, c^-1*y*c*(w*x^-1)^-1, c^-1*z*c*x],[[b,c*a*b*c,z]]]; end, [30]], "A6 3^4'",[14,4,1],1, 3,30], # 29160.5 (otherpres.) [[1,"abDstuvd", function(a,b,D,s,t,u,v,d) return [[a^2*D^-1,b^3,(a*b)^5,D^2,D^-1*b^-1*D*b, d^3,d^-1*a^-1*d*a,d^-1*b^-1*d*b, d^-1*s^-1*d*s,s^3,t^3,u^3,v^3, s^-1*t^-1*s*t,s^-1*u^-1*s*u *d^-1,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v *d^-1,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*(s^-1*d)^-1, a^-1*v*a*(t^-1*d)^-1, b^-1*s*b*(s*v^-1*d^-1)^-1, b^-1*t*b*(t*u^-1*v*d)^-1, b^-1*u*b*u^-1,b^-1*v*b*v^-1], [[a,b]]]; end, [243]]], # 29160.6 (otherpres.) [[1,"abdstuve", function(a,b,d,s,t,u,v,e) return [[a^2*d^-1,b^3,(a*b)^5,d^2,d^-1*b^-1*d*b, e^3,e^-1*a^-1*e*a,e^-1*b^-1*e*b, e^-1*s^-1*e*s,s^3,t^3,u^3,v^3, s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v*e^-1, t^-1*u^-1*t*u*e^-1, t^-1*v^-1*t*v*e,u^-1*v^-1*u*v, a^-1*s*a*(u*e^-1)^-1, a^-1*t*a*(v*e)^-1,a^-1*u*a*s, a^-1*v*a*t,b^-1*s*b*(s*v^-1)^-1, b^-1*t*b*(t*u^-1*v*e^-1)^-1, b^-1*u*b*u^-1,b^-1*v*b*v^-1], [[a,b]]]; end, [243]]] ]; PERFGRP[69]:=[# 29760.1 [[1,"abc", function(a,b,c) return [[c^15*a^2,c*b^9*c^-1*b^-1,b^31,a^4,a^2*b^(-1 *1)*a^2*b,a^2*c^-1*a^2*c, c*a*c*a^-1,(b*a)^3],[[b,c^2]]]; end, [64]], "L2(31) 2^1 = SL(2,31)",22,-2, 18,64] ]; PERFGRP[70]:=[# 30240.1 [[1,"abcde", function(a,b,c,d,e) return [[a^2,b^3,(a*b)^5,c^2,d^3,(c*d)^7,e^-1*d^-1* (c*d)^3, (e*d^-1*e*d)^-1*c^-1*e*d^-1*e*d*c, a^-1*c^-1*a*c,a^-1*d^-1*a*d, b^-1*c^-1*b*c,b^-1*d^-1*b*d], [[b,a*b*a*b^-1*a,c,d],[a,b,c,e]]]; end, [5,9]], "A5 x L2(8)",[35,0,1],1, [1,4],[5,9]] ]; ############################################################################# ## #E perf3.grp . . . . . . . . . . . . . . . . . . . . . . . . . ends here ## gap-4r6p5/grp/imf10.grp0000644000175000017500000012041312172557252013360 0ustar billbill############################################################################# ## #A imf10.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Z-class representative of the irreducible ## maximal finite integral matrix groups of dimension 10, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Z-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 10. ## IMFList[10].matrices := [ [ # Z-class [10][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1]], [[[0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0,0,0], [0,0,0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,1,0,0,0,0], [0,0,0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0]]]], [ # Z-class [10][02] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,0,2]], [[[-1,-1,0,0,0,0,0,0,1,1], [-1,0,0,0,0,0,0,0,1,1], [-1,0,-1,0,0,0,0,0,1,1], [-1,0,0,-1,0,0,0,0,1,1], [-1,0,0,0,-1,0,0,0,1,1], [-1,0,0,0,0,-1,0,0,1,1], [-1,0,0,0,0,0,-1,0,1,1], [-1,0,0,0,0,0,0,-1,1,1], [-1,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,0,1,0]], [[1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,1,1], [0,0,-1,0,0,0,0,0,1,1], [0,0,0,-1,0,0,0,0,1,1], [0,0,0,0,-1,0,0,0,1,1], [0,0,0,0,0,-1,0,0,1,1], [0,0,0,0,0,0,-1,0,1,1], [0,0,0,0,0,0,0,-1,1,1], [0,0,0,0,0,0,0,1,0,0]]]], [ # Z-class [10][03] [[2], [0,2], [0,0,2], [0,0,0,2], [0,0,0,0,2], [0,0,0,0,0,2], [0,0,0,0,0,0,2], [0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,2], [1,1,1,1,1,1,1,1,1,5]], [[[0,0,0,0,0,1,0,0,0,0], [-1,-1,-1,-1,-1,-1,-1,-1,-1,2], [0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0,0,0], [0,0,0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0], [1,1,1,1,1,1,1,1,1,-2], [0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0,0,0], [0,0,0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0], [1,1,1,1,1,1,1,1,1,-1]]]], [ # Z-class [10][04] [[4], [2,4], [2,2,4], [2,2,2,4], [2,0,2,2,4], [2,2,2,2,2,4], [2,2,2,2,2,2,4], [2,2,2,2,2,2,2,4], [2,2,2,2,2,2,2,2,4], [2,0,2,2,2,2,2,2,2,5]], [[[-1,4,-1,-1,3,-1,-1,-1,-1,2], [-1,3,-1,-1,2,-1,-1,-1,0,2], [-1,3,-1,-1,2,-1,-1,0,-1,2], [-1,3,-1,-1,2,-1,0,-1,-1,2], [-1,4,-1,-1,3,-1,-1,-1,-2,2], [-1,3,-1,-1,2,0,-1,-1,-1,2], [-2,4,-1,-1,3,-1,-1,-1,-1,2], [-1,4,-2,-1,3,-1,-1,-1,-1,2], [-1,3,-1,-1,3,-1,-1,-1,-1,2], [-1,2,-1,-1,2,0,0,0,-1,1]], [[0,1,0,-1,1,0,0,0,0,0], [0,0,0,-1,1,0,0,0,0,0], [0,1,-1,-1,1,0,0,0,0,0], [-1,1,0,-1,1,0,0,0,0,0], [0,1,0,-1,0,0,0,0,0,0], [-1,4,-1,-2,3,-1,-1,-1,-1,2], [0,1,0,-1,1,0,0,0,-1,0], [0,1,0,-1,1,0,-1,0,0,0], [0,1,0,-1,1,0,0,-1,0,0], [-1,4,-1,-1,3,-1,-1,-1,-1,1]]]], [ # Z-class [10][05] [[4], [2,4], [2,1,4], [2,0,0,4], [2,2,2,1,4], [2,2,2,1,1,4], [2,0,1,2,0,2,4], [2,2,0,1,0,1,0,4], [2,1,0,2,0,2,1,2,4], [2,0,2,1,0,1,2,0,0,4]], [[[-1,0,0,0,0,0,0,1,0,1], [-2,0,0,-1,1,0,1,1,1,1], [0,0,-1,0,0,1,-1,0,0,1], [-1,-1,0,0,1,0,0,1,0,1], [-2,0,0,0,1,0,0,1,1,1], [0,-1,-1,-1,1,1,0,1,0,1], [0,-1,-1,-1,1,0,0,1,0,1], [0,0,1,0,-1,0,0,0,0,0], [0,-1,0,0,0,1,0,1,-1,0], [0,0,-1,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0], [1,-1,-1,-1,1,1,0,0,0,0], [0,0,0,1,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,-1], [1,0,-1,0,0,1,0,0,-1,0], [0,0,0,0,0,0,1,0,0,0], [-1,0,0,0,1,0,0,1,0,1], [1,0,0,1,-1,1,-1,0,-1,0], [1,0,0,0,0,0,0,-1,0,0]]]], [ # Z-class [10][06] [[2], [1,2], [1,1,2], [1,1,1,2], [1,0,1,1,2], [0,0,0,0,0,2], [0,0,0,0,0,1,2], [0,0,0,0,0,1,1,2], [0,0,0,0,0,1,1,1,2], [0,0,0,0,0,1,0,1,1,2]], [[[0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,1,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,1,-1,0,1], [0,0,0,0,0,1,0,0,0,0], [-1,1,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0], [0,1,-1,0,1,0,0,0,0,0], [0,1,0,-1,1,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0]], [[0,0,0,0,0,0,1,0,-1,1], [0,0,0,0,0,-1,1,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,1,-1,0,1], [0,0,0,0,0,1,0,0,0,0], [-1,1,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0], [0,1,-1,0,1,0,0,0,0,0], [0,1,0,-1,1,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0]], [[0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,-1,1,0,0,1], [0,0,0,0,0,-1,1,-1,0,1], [0,0,0,0,0,-1,1,0,-1,1], [0,0,0,0,0,-1,0,0,0,0], [-1,1,0,0,1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0], [0,1,-1,0,1,0,0,0,0,0], [0,1,0,-1,1,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0]]]], [ # Z-class [10][07] [[4], [0,4], [0,0,4], [0,0,0,4], [2,2,2,2,5], [0,0,0,0,0,4], [0,0,0,0,0,0,4], [0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,4], [0,0,0,0,0,2,2,2,2,5]], [[[0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,-1,-1,-1,-1,2], [0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,1], [-1,-1,-1,-1,2,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0]], [[0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,-1,-1,-1,-1,2], [0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,1], [-1,-1,-1,-1,2,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0], [-1,-1,-1,-1,2,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0], [0,-1,0,0,1,0,0,0,0,0], [0,0,0,0,0,-1,-1,-1,-1,2], [0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,1]]]], [ # Z-class [10][08] [[3], [1,3], [1,1,3], [-1,1,1,3], [1,1,0,-1,3], [1,0,1,-1,1,3], [-1,-1,-1,-1,1,1,3], [0,1,1,0,1,1,0,3], [-1,-1,-1,-1,1,0,1,1,3], [-1,0,1,1,-1,-1,-1,1,0,3]], [[[1,0,-1,1,0,1,0,-1,1,1], [0,1,0,0,0,1,0,-1,1,1], [0,1,0,0,-1,1,0,-1,1,0], [-1,1,1,-1,0,0,0,-1,0,0], [1,0,-1,1,0,1,0,0,0,1], [0,0,-1,1,0,1,0,0,0,0], [0,0,-1,0,0,0,0,1,-1,0], [0,0,0,0,0,1,0,0,0,0], [0,-1,0,0,0,0,0,1,-1,0], [-1,0,1,-1,0,0,-1,0,0,-1]], [[1,1,0,0,-1,0,1,-1,1,1], [0,1,0,0,0,1,0,-1,1,1], [1,0,-1,1,0,1,0,-1,1,1], [-1,0,0,0,1,1,-1,-1,0,0], [1,0,0,0,0,0,1,0,0,1], [1,0,-1,1,0,0,1,0,0,1], [0,-1,0,0,1,-1,0,1,-1,0], [1,0,-1,1,0,1,0,0,0,1], [0,-1,0,0,0,0,0,1,-1,0], [0,0,-1,0,0,1,-1,0,0,0]]]], [ # Z-class [10][09] [[4], [2,4], [2,1,4], [2,0,1,4], [0,-1,-1,1,4], [0,1,-1,1,-1,4], [-2,-2,-1,-2,-1,-1,4], [0,1,1,-1,-2,1,1,4], [-2,-1,-2,-1,1,-1,1,-1,4], [2,1,2,1,-1,-1,-1,1,0,4]], [[[0,0,-1,0,0,0,0,0,-1,0], [1,0,-1,0,0,0,0,0,0,0], [-1,1,-1,1,0,-1,0,0,-1,0], [0,0,0,0,0,0,0,0,-1,0], [0,-1,0,0,-1,0,-1,0,0,0], [1,0,0,0,0,0,1,0,0,0], [0,0,1,0,0,0,0,0,1,-1], [0,1,0,0,0,0,1,-1,0,0], [0,0,1,0,0,1,0,0,1,0], [-1,1,0,0,1,1,1,-1,-1,1]], [[0,0,1,-1,1,2,1,-1,0,1], [0,0,0,0,1,1,1,0,0,1], [-1,1,1,0,1,1,1,-1,0,1], [0,0,0,-1,0,1,0,-1,0,1], [0,-1,0,-1,0,0,-1,0,0,0], [0,0,-1,0,0,0,0,0,-1,1], [0,0,0,1,-1,-1,0,0,0,-1], [0,0,0,1,0,0,0,0,0,0], [1,-1,0,0,-1,-1,-1,1,1,-1], [0,0,1,0,0,1,0,0,1,0]]]], [ # Z-class [10][10] [[4], [1,4], [1,-1,4], [1,1,-1,4], [0,-1,1,1,4], [1,1,1,1,-1,4], [1,-1,0,1,1,-1,4], [-1,1,-1,1,1,0,1,4], [-1,0,1,1,1,1,1,1,4], [1,-1,-1,1,-1,0,1,0,-1,4]], [[[0,1,0,-1,1,0,0,0,0,1], [0,0,-1,-1,1,1,0,0,0,0], [-1,1,1,0,0,0,0,0,0,1], [1,0,-1,-1,0,0,0,0,1,0], [1,-1,0,0,-1,-1,-1,1,1,0], [-1,1,0,-1,1,1,1,-1,0,1], [1,0,0,0,0,-1,-1,0,1,0], [1,-1,-1,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,1,0], [1,0,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0], [1,-1,-1,0,0,0,0,0,0,-1], [0,1,0,-1,1,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0], [-1,1,0,-1,1,1,1,-1,0,1], [0,0,0,0,0,0,0,0,-1,0], [0,0,1,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0], [0,0,1,1,-1,-1,0,0,0,0]]]], [ # Z-class [10][11] [[5], [2,5], [-1,-2,5], [-1,-2,-1,5], [-2,1,0,-2,5], [2,-1,2,0,-1,5], [-2,1,0,0,1,-1,5], [1,2,1,-1,0,0,2,5], [0,1,-2,2,-1,-1,-1,0,5], [1,0,1,1,-2,0,-2,1,2,5]], [[[1,-1,0,0,1,0,1,0,0,1], [1,0,1,1,1,-1,0,0,0,0], [-2,1,-1,0,-1,1,-1,1,-1,0], [0,-1,-1,-1,0,0,0,0,0,0], [0,1,1,1,0,0,-1,0,0,-1], [-1,0,-1,0,0,1,0,0,-1,1], [-1,1,0,0,0,0,-1,0,0,0], [-1,0,0,0,0,0,-1,1,0,0], [1,-1,0,0,0,-1,0,0,0,0], [0,-1,-1,0,0,0,0,1,0,0]], [[1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,-1], [0,0,0,0,0,0,0,-1,0,0], [0,-1,-1,-1,0,0,1,0,0,1], [0,0,1,0,0,0,0,0,1,-1], [1,0,0,0,0,0,1,-1,0,0], [0,0,0,0,1,0,0,0,0,0], [1,-1,0,0,1,0,0,0,0,0], [0,-1,-1,0,0,0,0,1,0,0], [1,-1,0,0,0,-1,0,0,0,0]]]], [ # Z-class [10][12] [[4], [2,4], [2,1,4], [1,2,2,4], [0,-1,1,1,4], [-2,0,-1,0,1,4], [-2,-1,0,0,-1,1,4], [-1,1,0,0,-2,1,2,4], [1,0,2,0,-1,-2,0,0,4], [1,-1,2,1,2,-1,0,-1,1,4]], [[[0,1,-1,0,0,0,0,0,0,1], [-1,1,0,0,0,0,0,0,0,1], [0,0,0,0,-1,1,-1,0,0,1], [0,0,0,0,-1,1,0,0,0,1], [0,0,0,0,-1,1,0,-1,0,0], [-1,0,1,0,-1,0,0,-1,0,0], [0,0,1,-1,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0], [1,0,-1,0,0,1,0,0,1,0]], [[-1,1,0,0,0,0,0,0,0,1], [0,0,0,0,-1,1,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,1], [0,1,0,-1,1,-1,1,0,0,0], [0,0,0,-1,0,0,0,0,0,0], [0,-1,1,0,-1,0,-1,0,-1,0], [0,-1,1,0,-1,1,-1,0,0,0], [0,-1,0,1,0,0,0,0,0,0], [0,0,0,0,1,-1,0,1,0,0]]]], [ # Z-class [10][13] [[5], [-1,5], [1,-1,5], [1,1,-1,5], [1,1,-1,-1,5], [1,1,-1,1,-1,5], [-1,1,-1,-1,-1,-1,5], [1,1,1,-1,-1,1,1,5], [1,1,1,1,1,-1,1,-1,5], [1,-1,-1,1,-1,-1,1,1,1,5]], [[[0,0,0,0,0,0,0,0,0,1], [1,0,-1,0,-1,-1,0,0,0,-1], [0,0,1,0,1,1,1,-1,-1,1], [0,0,0,1,0,0,0,0,0,0], [1,1,-1,-1,-1,-1,-1,0,0,0], [0,0,0,0,-1,0,0,0,0,0], [0,-1,-1,0,0,0,0,1,1,-1], [0,0,0,0,0,0,1,0,0,0], [1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0]], [[1,0,0,0,0,0,0,0,0,0], [-1,0,1,0,1,1,0,0,0,1], [0,-1,-1,0,0,0,0,1,1,-1], [0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0], [0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0], [1,1,0,-1,-1,0,0,-1,0,0]]]], [ # Z-class [10][14] [[2], [1,2], [-1,0,2], [-1,0,1,2], [1,0,-1,-1,2], [0,0,0,0,0,2], [0,0,0,0,0,0,2], [0,0,0,0,0,-1,-1,2], [1,1,-1,-1,0,1,1,-1,3], [1,1,-1,-1,0,-1,0,1,1,3]], [[[0,-1,1,1,1,-1,-1,0,2,0], [0,-1,1,1,1,0,0,0,1,1], [0,0,0,0,0,1,0,0,-1,1], [0,0,0,0,0,1,0,-1,-1,1], [0,0,0,0,0,0,0,1,1,-1], [1,0,1,0,0,0,0,0,0,0], [0,0,0,1,1,0,0,0,0,0], [0,0,-1,0,-1,0,0,0,0,0], [0,0,1,1,1,-1,0,0,1,0], [0,-1,0,1,0,-1,0,0,1,0]], [[0,-1,1,1,1,0,0,0,1,1], [0,-1,1,1,1,0,-1,0,1,1], [0,0,0,0,0,-1,-1,0,1,-1], [0,0,0,0,0,-1,-1,-1,0,0], [0,0,0,0,0,0,1,1,0,0], [1,0,1,0,0,0,0,0,0,0], [0,0,0,1,1,0,0,0,0,0], [0,0,-1,0,-1,0,0,0,0,0], [0,0,1,1,1,1,0,0,0,1], [0,-1,0,1,0,1,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,-1,0,0,1,-1], [0,1,-1,-1,-1,0,0,0,-1,-1], [0,-1,1,1,1,0,-1,0,1,1], [0,1,-1,-1,-1,0,0,0,0,-1], [0,0,0,0,0,0,-1,-1,0,1]]]], [ # Z-class [10][15] [[4], [1,4], [2,-1,4], [-2,-2,-1,4], [2,-1,1,-1,4], [2,2,1,-1,1,5], [2,2,1,-1,1,2,5], [2,2,1,-1,1,2,2,5], [2,2,1,-1,1,2,2,2,5], [2,2,1,-1,1,2,2,2,2,5]], [[[0,-4,-2,-2,-2,1,1,0,1,1], [0,-4,-2,-2,-2,1,1,1,0,1], [0,-2,-1,-1,-1,0,0,0,1,1], [0,2,1,1,1,0,-1,0,0,-1], [0,-2,-1,-1,-1,0,1,0,1,0], [0,-4,-2,-2,-2,1,1,1,1,1], [0,-5,-3,-2,-2,1,1,1,1,1], [-1,-5,-2,-3,-2,1,1,1,1,1], [0,-5,-2,-2,-3,1,1,1,1,1], [0,-5,-3,-3,-3,1,1,1,1,1]], [[0,-4,-2,-2,-2,1,0,1,1,1], [0,-4,-2,-2,-2,1,1,1,0,1], [0,-2,-1,-1,-1,0,0,0,1,1], [0,2,1,1,1,0,0,-1,0,-1], [0,-2,-1,-1,-1,0,0,1,1,0], [0,-4,-2,-2,-2,1,1,1,1,1], [0,-5,-3,-2,-2,1,1,1,1,1], [-1,-5,-2,-3,-2,1,1,1,1,1], [0,-5,-2,-2,-3,1,1,1,1,1], [0,-5,-3,-3,-3,1,1,1,1,1]], [[1,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0], [-1,0,0,0,1,0,0,0,0,0], [1,0,0,1,0,0,0,0,0,0], [0,-4,-2,-2,-2,1,1,1,1,1], [0,2,1,1,1,0,0,0,0,-1], [0,2,1,1,1,0,0,0,-1,0], [0,2,1,1,1,0,0,-1,0,0], [0,2,1,1,1,0,-1,0,0,0]]]], [ # Z-class [10][16] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [0,0,0,0,0,2], [0,0,0,0,0,1,2], [0,0,0,0,0,1,1,2], [0,0,0,0,0,1,1,1,2], [0,0,0,0,0,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,1,0,0,0,0,0], [-1,0,0,0,1,0,0,0,0,0], [0,-1,0,0,1,0,0,0,0,0], [0,0,-1,0,1,0,0,0,0,0], [0,0,0,-1,1,0,0,0,0,0]], [[0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,1,0,0,0,0,0], [-1,0,0,0,1,0,0,0,0,0], [0,-1,0,0,1,0,0,0,0,0], [0,0,-1,0,1,0,0,0,0,0], [0,0,0,-1,1,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,-1,1]]]], [ # Z-class [10][17] [[5], [-1,5], [-1,-1,5], [-1,-1,-1,5], [-1,-1,-1,-1,5], [0,0,0,0,0,5], [0,0,0,0,0,-1,5], [0,0,0,0,0,-1,-1,5], [0,0,0,0,0,-1,-1,-1,5], [0,0,0,0,0,-1,-1,-1,-1,5]], [[[0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,-1,-1,-1,-1,-1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1,0,0], [1,1,1,1,1,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0]], [[0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,-1,-1,-1,-1,-1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1,0,0], [1,1,1,1,1,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0]], [[0,0,0,0,0,1,1,1,1,1], [0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,-1,0,0,0], [1,1,1,1,1,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0]]]], [ # Z-class [10][18] [[3], [-1,3], [1,-1,3], [-1,-1,-1,3], [1,1,-1,-1,3], [0,0,0,0,0,3], [0,0,0,0,0,-1,3], [0,0,0,0,0,1,-1,3], [0,0,0,0,0,-1,-1,-1,3], [0,0,0,0,0,1,1,-1,-1,3]], [[[0,0,0,0,0,-1,0,1,0,1], [0,0,0,0,0,0,0,-1,-1,-1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,-1,0,-1,0], [0,0,1,1,1,0,0,0,0,0], [1,0,-1,0,-1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0], [-1,-1,0,-1,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0], [0,0,-1,-1,-1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0], [0,1,1,1,0,0,0,0,0,0], [1,0,-1,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,1,1,1], [0,0,0,0,0,1,0,-1,0,-1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,-1,0,-1,0], [0,0,0,0,0,0,0,0,1,0]], [[1,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,-1,0,1,0,1], [0,0,0,0,0,0,0,-1,-1,-1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,-1,0,-1,0]]]], [ # Z-class [10][19] [[4], [1,4], [2,-1,4], [-2,-2,-1,4], [2,-1,1,-1,4], [0,0,0,0,0,4], [0,0,0,0,0,1,4], [0,0,0,0,0,2,-1,4], [0,0,0,0,0,-2,-2,-1,4], [0,0,0,0,0,2,-1,1,-1,4]], [[[0,0,0,0,0,-1,1,0,0,1], [0,0,0,0,0,0,-1,-1,-1,0], [0,0,0,0,0,0,1,0,1,1], [0,0,0,0,0,1,0,0,0,-1], [0,0,0,0,0,-1,1,1,0,1], [-1,1,1,1,1,0,0,0,0,0], [-1,1,1,0,0,0,0,0,0,0], [0,1,0,1,1,0,0,0,0,0], [1,-1,-1,0,-1,0,0,0,0,0], [-1,0,0,0,1,0,0,0,0,0]], [[0,0,0,0,0,-1,1,1,0,1], [0,0,0,0,0,0,-1,0,-1,0], [0,0,0,0,0,-1,1,1,1,1], [0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,-1,1,0,0,1], [-1,1,1,1,1,0,0,0,0,0], [-1,1,1,0,0,0,0,0,0,0], [0,1,0,1,1,0,0,0,0,0], [1,-1,-1,0,-1,0,0,0,0,0], [-1,0,0,0,1,0,0,0,0,0]], [[0,0,0,0,0,-1,1,1,1,1], [0,0,0,0,0,-1,1,1,0,0], [0,0,0,0,0,0,1,0,1,1], [0,0,0,0,0,1,-1,-1,0,-1], [0,0,0,0,0,-1,0,0,0,1], [-1,1,1,1,1,0,0,0,0,0], [-1,1,1,0,0,0,0,0,0,0], [0,1,0,1,1,0,0,0,0,0], [1,-1,-1,0,-1,0,0,0,0,0], [-1,0,0,0,1,0,0,0,0,0]]]], [ # Z-class [10][20] [[5], [-2,5], [2,-2,5], [2,1,-1,5], [2,-2,2,-1,5], [2,1,-1,2,-1,5], [2,-2,2,-1,2,-1,5], [2,1,-1,2,-1,2,-1,5], [2,1,-1,2,-1,2,-1,2,5], [2,1,-1,2,-1,2,-1,2,2,5]], [[[-3,-1,1,0,1,1,1,1,1,1], [4,1,-1,-1,-1,-1,-1,-1,-1,-1], [-3,-1,1,1,1,0,1,1,1,1], [1,0,0,-1,-1,0,0,0,0,0], [-3,-1,1,1,1,1,1,0,1,1], [1,0,0,-1,0,0,-1,0,0,0], [-3,-1,1,1,1,1,1,1,0,1], [1,0,-1,-1,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0], [1,1,0,-1,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,1,0,0], [4,1,-1,-1,-1,-1,-1,-1,-1,-1], [0,0,0,0,0,1,0,0,0,0], [0,0,0,0,1,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0], [-4,-1,1,1,1,1,1,1,1,1], [0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,1,0], [0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1], [0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,1,0,0,0,0], [0,0,0,1,0,0,0,0,0,0]]]], [ # Z-class [10][21] [[6], [3,6], [3,3,6], [3,0,0,6], [-3,0,0,-3,6], [3,3,3,0,-3,8], [3,0,3,3,-3,4,8], [3,3,0,3,-3,4,2,8], [-3,0,-3,-3,3,-4,-5,-2,8], [3,3,0,3,-3,1,2,5,1,8]], [[[0,-1,1,0,0,0,-1,0,0,1], [0,-1,0,0,1,1,-1,-1,-1,2], [0,0,0,0,0,0,0,-1,0,1], [0,-1,1,0,0,0,0,1,1,0], [0,1,-1,-1,0,-1,1,0,-1,0], [0,-1,1,1,1,1,-1,-1,0,1], [0,0,1,1,0,0,0,0,1,0], [-1,-1,1,1,1,1,-1,0,0,1], [0,0,-1,0,0,0,0,0,-1,0], [0,-1,0,1,1,1,-1,0,0,1]], [[0,-1,0,0,1,1,0,0,0,1], [0,-1,0,0,1,1,-1,-1,-1,2], [0,-1,0,1,1,2,-1,-1,0,1], [0,-1,1,0,0,0,0,1,1,0], [0,0,0,0,0,0,-1,0,-1,0], [0,0,0,1,1,1,0,-1,0,1], [0,-1,1,1,1,1,0,0,1,0], [0,0,0,0,1,0,0,0,0,1], [1,0,-1,-1,0,-1,0,0,-1,0], [0,-1,0,0,1,0,0,0,0,1]], [[0,-1,0,0,1,1,-1,-1,-1,2], [0,-1,0,0,1,1,0,0,0,1], [0,-1,0,1,1,2,-1,-1,0,1], [0,-1,1,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,1,0,-1], [0,0,0,1,1,1,0,-1,0,1], [0,-1,1,1,1,1,-1,-1,0,1], [0,0,0,0,1,0,0,0,0,1], [1,0,-1,-1,0,-1,1,1,0,-1], [0,-1,0,0,1,0,0,0,0,1]]]], [ # Z-class [10][22] [[9], [-3,9], [3,3,9], [3,-3,3,9], [3,3,3,-3,9], [3,3,3,3,3,10], [3,3,3,3,3,4,10], [3,3,3,3,3,4,4,10], [3,3,3,3,3,4,4,4,10], [3,3,3,3,3,4,4,4,4,10]], [[[-1,-2,1,-2,-1,1,0,1,0,1], [1,2,-1,2,1,0,0,-1,-1,-1], [1,2,-1,2,1,0,-1,0,-1,-1], [-1,-2,1,-2,-1,1,0,1,1,0], [1,2,-1,2,1,0,-1,-1,-1,0], [0,0,0,0,0,1,0,0,0,0], [-1,-1,0,0,0,1,0,0,0,0], [-1,-1,1,-1,0,1,0,0,0,0], [0,-1,0,-1,0,1,0,0,0,0], [0,-1,1,-1,-1,1,0,0,0,0]], [[-1,-2,1,-2,-1,0,0,1,1,1], [1,2,-1,2,1,0,-1,0,-1,-1], [-1,-2,1,-2,-1,1,0,1,0,1], [-1,-2,1,-2,-1,1,0,0,1,1], [1,2,-1,2,1,-1,-1,0,-1,0], [0,0,0,0,0,0,-1,0,0,0], [1,1,0,0,0,0,-1,0,0,0], [1,1,-1,1,0,0,-1,0,0,0], [0,1,0,1,0,0,-1,0,0,0], [0,1,-1,1,1,0,-1,0,0,0]], [[1,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0], [2,4,-2,4,2,-1,-1,-1,-1,-1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,1,0,0,0]]]], [ # Z-class [10][23] [[4], [1,4], [0,1,4], [-1,0,-1,4], [-1,1,-1,-1,4], [2,1,0,-1,1,4], [-1,-2,-1,0,-1,-2,4], [-1,1,-1,1,2,0,-1,4], [-2,-1,0,-1,1,-1,0,0,4], [-1,-2,1,0,-1,0,1,0,1,4]], [[[-1,1,-1,-1,0,-1,-1,-1,-1,1], [0,0,0,0,0,-1,0,0,0,0], [1,0,0,0,1,-1,0,0,0,0], [0,0,1,0,-1,1,1,1,1,-1], [0,0,0,1,0,0,0,0,0,0], [0,1,-1,0,0,-1,-1,-1,0,1], [0,0,0,0,0,1,1,0,0,0], [0,0,0,0,-1,0,0,1,0,0], [1,-1,1,1,1,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0]], [[0,1,0,0,0,0,0,0,0,1], [-1,0,0,0,0,1,0,0,0,0], [-1,0,0,0,0,0,0,0,-1,0], [0,0,0,0,-1,1,1,1,1,-1], [0,-1,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,1], [1,0,0,0,1,-1,0,0,0,0], [-1,0,-1,-1,-1,0,-1,0,0,0], [0,-1,1,0,0,0,0,0,0,-1], [0,0,0,0,0,-1,0,0,0,0]]]], [ # Z-class [10][24] [[8], [3,8], [3,-2,8], [-3,1,-4,8], [1,-3,0,-3,8], [3,4,-1,2,-3,8], [-1,3,-3,0,-2,3,8], [0,2,1,-2,-3,1,0,8], [3,2,1,1,0,1,-3,2,8], [-3,1,-1,2,0,-1,0,-2,1,8]], [[[2,-1,0,1,0,-1,1,1,-1,1], [1,-1,-1,-1,-1,0,0,0,0,1], [1,0,0,1,0,-1,0,1,-1,0], [-1,1,0,-1,0,1,-1,-1,0,0], [0,0,1,1,1,0,1,1,0,0], [0,0,0,-1,-1,0,0,-1,0,0], [-1,0,0,-1,-1,0,0,-1,1,0], [1,-1,-1,0,-1,0,0,0,0,0], [2,-1,0,1,0,0,0,1,-1,1], [-1,0,0,-1,0,1,-1,0,0,0]], [[0,-1,0,0,0,0,0,0,0,0], [1,-1,0,1,0,-1,1,1,0,0], [-1,0,0,-1,0,1,-1,0,0,0], [0,0,0,0,0,0,1,0,0,0], [0,0,-1,-1,-1,0,-1,-1,0,0], [0,-1,0,0,0,0,1,0,1,0], [2,-1,0,1,0,-1,1,1,0,1], [0,0,0,1,1,0,0,1,0,0], [-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0]]]], [ # Z-class [10][25] [[2], [-1,2], [0,0,2], [0,0,-1,2], [0,0,0,0,2], [0,0,0,0,-1,2], [0,0,0,0,0,0,2], [0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,-1,2]], [[[0,0,0,0,1,1,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,1,1], [0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,1,1,0,0], [0,0,0,0,0,0,0,-1,0,0], [0,0,1,1,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0], [1,1,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0]], [[0,0,0,0,0,0,1,1,0,0], [0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,1,1], [0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,1,1,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0], [0,0,1,1,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0], [1,1,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,-1], [0,0,0,0,0,0,1,1,0,0], [0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,1,1,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0], [0,0,1,1,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0]]]], [ # Z-class [10][26] [[4], [1,4], [2,2,4], [2,2,1,4], [2,2,2,2,4], [2,2,2,2,1,4], [-2,-2,-1,-1,-2,-2,4], [2,2,2,2,2,2,-2,4], [2,2,2,2,2,2,-2,1,4], [2,-1,1,1,1,1,-1,1,1,4]], [[[0,0,-1,-1,0,1,1,1,1,0], [0,0,-1,-1,1,0,1,1,1,0], [0,1,-1,-1,0,0,1,1,1,1], [0,-1,0,0,0,0,0,1,1,-1], [0,0,-1,0,0,0,1,1,1,0], [0,0,0,-1,0,0,1,1,1,0], [0,0,1,1,0,0,-1,-1,-1,0], [1,0,-1,-1,0,0,1,1,1,0], [0,1,-1,-1,0,0,1,1,1,0], [0,0,0,0,-1,0,0,0,1,0]], [[0,1,-1,-1,1,1,1,0,0,1], [0,1,0,0,-1,0,0,0,0,1], [0,1,-1,-1,0,0,1,1,1,1], [0,1,0,0,0,0,0,-1,0,1], [0,1,0,0,0,0,1,0,0,1], [0,1,-1,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,1,-1], [-1,1,0,0,0,0,0,0,0,1], [1,2,-1,-1,0,0,1,0,0,1], [0,1,-1,-1,1,0,1,0,0,1]], [[0,1,-1,-1,0,0,1,1,1,1], [0,1,0,0,0,0,0,-1,0,1], [0,1,-1,-1,1,1,1,0,0,1], [0,1,0,0,-1,0,0,0,0,1], [0,1,0,0,0,0,1,0,0,1], [0,1,-1,0,0,0,0,0,0,1], [0,-1,0,0,0,1,0,0,0,-1], [-1,1,0,0,0,0,0,0,0,1], [1,2,-1,-1,0,0,1,0,0,1], [0,1,-1,-1,0,0,1,1,0,1]]]], [ # Z-class [10][27] [[6], [0,6], [0,0,6], [0,0,0,6], [0,0,0,0,6], [0,0,0,3,0,6], [3,0,0,0,0,0,6], [0,3,0,0,0,0,0,6], [0,0,3,0,0,0,0,0,6], [3,3,3,3,-3,3,3,3,3,10]], [[[0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,1,0,0], [-1,-1,-1,-1,2,-1,-1,-1,-1,3], [0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,1,0], [-1,0,0,0,0,0,1,0,0,0], [0,0,0,-1,0,1,0,0,0,0], [0,-1,0,0,0,0,0,1,0,0], [-1,-1,-1,-1,1,-1,-1,-1,-1,3], [-1,-1,-1,-1,1,0,0,0,-1,2]], [[0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,1,0,0,0], [-1,-1,-1,-1,2,-1,-1,-1,-1,3], [0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,1,0,0], [0,0,0,-1,0,1,0,0,0,0], [0,0,-1,0,0,0,0,0,1,0], [-1,0,0,0,0,0,1,0,0,0], [-1,-1,-1,-1,1,-1,-1,-1,-1,3], [-1,-1,-1,-1,1,0,0,-1,0,2]], [[-1,-1,-1,-1,1,-1,-1,-1,-1,3], [0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,1,0,0], [0,0,0,-1,0,1,0,0,0,0], [-1,-1,-1,-1,2,-1,-1,-1,-1,3], [-1,0,0,0,0,0,1,0,0,0], [0,0,-1,0,0,0,0,0,1,0], [-1,-1,-1,-1,1,0,0,-1,0,2]]]], [ # Z-class [10][28] [[10], [-4,10], [-4,4,10], [-4,-2,4,10], [-4,-2,-2,4,10], [1,-4,2,5,-1,10], [2,-5,-5,-2,1,2,10], [5,-2,1,1,-2,5,-2,10], [5,1,-2,-2,-2,2,-2,4,10], [-1,4,4,-2,-5,2,1,1,1,10]], [[[0,0,0,0,1,0,0,0,0,1], [-1,0,1,0,-1,-1,1,1,1,-1], [1,1,1,0,0,0,1,0,0,-1], [1,0,0,0,0,0,0,0,-1,0], [0,0,-1,-1,0,1,-1,0,-1,0], [2,0,0,0,1,1,-1,-1,-1,1], [1,0,-1,0,1,1,-2,-1,-1,1], [1,0,0,0,1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [1,1,0,1,0,0,0,0,0,0]], [[1,0,0,0,1,0,0,0,0,1], [-1,0,1,0,-1,0,1,0,1,-1], [0,1,1,0,0,0,1,0,0,-1], [0,0,0,0,0,0,0,0,-1,0], [0,0,-1,0,0,1,-1,0,-1,0], [-1,0,0,0,0,-1,1,1,0,0], [0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,1], [-1,-1,1,0,0,-1,1,1,1,0], [-1,0,1,-1,0,0,1,0,1,-1]], [[1,0,0,0,0,0,0,0,0,0], [-1,-1,1,0,0,-1,1,0,1,0], [0,-1,0,0,0,0,-1,-1,0,1], [0,0,-1,0,0,0,-1,0,-1,1], [0,1,-1,0,0,1,0,0,-1,0], [0,0,-1,0,0,0,-1,0,0,1], [0,1,0,-1,0,1,0,0,0,-1], [0,-1,-1,0,0,0,-1,0,0,1], [1,0,0,0,1,0,0,0,0,1], [-1,-1,1,-1,0,0,0,0,1,0]]]], [ # Z-class [10][29] [[4], [-2,4], [2,-1,4], [-1,2,-2,4], [2,-1,2,-1,4], [-1,2,-1,2,-2,4], [2,-1,2,-1,2,-1,4], [-1,2,-1,2,-1,2,-2,4], [2,-1,0,0,2,-1,2,-1,4], [-1,2,0,0,-1,2,-1,2,-2,4]], [[[0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,-1,0,0,0], [0,-1,0,0,0,0,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0], [0,1,0,-1,0,0,0,0,0,-1], [1,0,-1,0,0,0,0,0,-1,0]], [[-1,-1,0,0,0,0,0,0,1,1], [0,1,0,0,0,0,0,0,0,-1], [-1,-1,1,1,0,0,0,0,1,1], [0,1,0,-1,0,0,0,0,0,-1], [-1,-1,1,1,-1,-1,0,0,1,1], [0,1,0,-1,0,1,0,0,0,-1], [-1,-1,1,1,0,0,-1,-1,1,1], [0,1,0,-1,0,0,0,1,0,-1], [-1,-1,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,-1,0,1,0], [0,0,0,1,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,1], [0,0,1,0,-1,0,0,0,1,0], [0,0,0,1,0,-1,0,0,0,1], [0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,1,0,0]]]], [ # Z-class [10][30] [[8], [-4,8], [0,0,8], [0,0,4,8], [0,0,0,0,8], [4,-2,-4,-2,-2,10], [4,-2,4,2,2,-2,10], [-2,4,2,-2,-4,-1,-3,10], [4,-2,4,2,-2,-2,2,1,10], [2,-4,2,-2,4,1,3,-2,-1,10]], [[[0,1,0,0,-1,0,0,-1,0,1], [-1,-1,0,0,1,1,1,1,0,-1], [0,0,1,-1,0,0,0,-1,0,-1], [-1,0,-1,0,0,0,1,0,1,0], [1,0,0,0,-1,-1,0,0,-1,0], [0,1,-1,1,0,0,0,0,0,1], [0,1,1,-1,-1,0,0,-1,0,0], [-1,-1,1,0,1,1,0,0,0,-1], [0,0,1,-1,0,0,0,-1,0,0], [2,1,1,0,-1,-1,-1,-1,-1,0]], [[0,0,-1,1,0,0,0,1,0,1], [1,0,2,-1,0,0,-1,-1,-1,-1], [0,-1,0,0,1,0,0,1,0,-1], [1,0,0,0,0,-1,-1,0,0,0], [0,0,0,-1,0,0,0,0,0,0], [0,1,-1,1,0,0,0,0,0,1], [0,-1,0,0,1,0,0,1,0,0], [1,0,1,0,0,0,0,0,-1,-1], [0,-1,-1,1,0,0,0,1,0,0], [-1,0,-1,0,1,1,1,1,1,0]], [[-1,0,-2,1,0,0,1,1,1,1], [0,0,1,-1,0,0,0,-1,0,-1], [-1,-1,0,0,1,1,1,1,0,-1], [-1,0,0,0,0,1,1,0,0,0], [0,0,1,-1,0,0,0,0,0,0], [0,1,-1,1,0,0,0,0,1,1], [-2,-1,-1,0,1,1,1,1,1,0], [0,0,0,0,0,0,0,0,0,-1], [-1,-1,-1,1,0,0,1,1,0,0], [0,0,0,0,1,0,0,1,0,0]]]], [ # Z-class [10][31] [[3], [1,3], [0,-1,3], [1,-1,1,3], [-1,-1,-1,-1,3], [0,-1,1,0,1,3], [1,1,-1,-1,1,1,3], [-1,0,-1,-1,0,-1,-1,3], [1,0,-1,0,1,1,1,-1,3], [-1,0,-1,0,1,-1,0,1,-1,3]], [[[-1,1,1,1,0,0,1,1,1,0], [-1,1,0,1,1,0,0,0,0,-1], [0,-1,0,-1,-1,0,0,0,1,1], [0,0,1,-1,-1,0,0,0,1,1], [1,0,-1,0,0,1,-1,0,-1,0], [0,0,0,0,0,0,0,1,0,0], [0,1,0,1,1,0,0,1,0,-1], [0,0,-1,0,0,0,0,-1,-1,0], [0,1,1,1,1,0,0,1,0,0], [1,0,-1,-1,0,1,-1,-1,-1,0]], [[0,0,1,0,0,0,0,0,1,1], [-1,1,1,1,0,0,1,1,1,0], [1,-1,0,-1,-1,0,0,0,0,1], [1,0,0,-1,0,0,-1,-1,0,1], [0,0,0,0,1,0,0,0,-1,-1], [1,-1,0,-1,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0], [-1,0,0,1,0,-1,1,0,0,-1], [0,0,0,0,1,0,0,0,0,0], [0,1,0,1,1,0,0,0,-1,-1]]]], [ # Z-class [10][32] [[4], [1,4], [1,0,4], [-2,-1,1,4], [1,2,2,-1,4], [-2,1,-2,1,-1,4], [-2,0,1,2,1,0,4], [-2,0,1,1,1,1,2,4], [2,2,2,-1,2,-1,-1,-1,4], [-2,-2,1,2,0,0,1,2,-1,4]], [[[1,0,-1,0,0,0,1,0,1,1], [1,0,0,0,0,1,1,0,0,0], [-1,1,0,0,0,-1,0,0,0,0], [-1,0,0,1,1,-1,-1,0,-1,-1], [0,1,0,0,0,0,0,0,0,0], [0,0,1,0,0,1,0,-1,-1,0], [-1,0,1,0,1,0,-1,0,-1,-1], [-1,1,1,0,0,0,-1,0,-1,0], [0,0,-1,0,0,0,1,0,1,0], [-1,1,0,0,0,-1,-1,0,-1,0]], [[1,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,-1,-1,1,0,-1], [1,1,0,0,0,0,0,0,-1,1], [0,1,0,-1,-1,0,1,0,0,1], [0,1,0,1,0,-1,-1,0,-1,0], [-1,0,0,0,0,0,0,0,0,-1], [0,1,0,0,-1,0,0,0,0,1], [-1,1,1,0,0,0,-1,0,-1,0], [1,0,0,0,0,0,0,0,-1,0], [-1,1,1,-1,0,0,0,-1,-1,1]]]], [ # Z-class [10][33] [[6], [-1,6], [3,2,6], [3,1,1,6], [3,-3,1,2,6], [3,-2,2,1,1,6], [1,-3,1,-2,2,3,6], [-1,-2,0,-3,1,0,1,6], [3,-2,0,3,3,0,-1,-2,6], [2,-3,-1,-1,1,3,3,-1,1,6]], [[[0,0,0,-1,1,1,-1,-1,0,0], [-1,1,0,0,0,0,0,1,1,1], [0,0,0,0,0,0,-1,0,0,1], [0,0,0,-1,1,1,-1,0,0,0], [0,-2,1,0,0,0,-1,-1,-1,0], [1,0,0,-1,1,0,-1,-1,-1,0], [1,-1,0,0,0,-1,0,-1,-1,0], [0,-1,1,1,-1,-1,0,0,0,0], [0,0,0,0,0,1,0,0,0,0], [0,0,0,0,1,0,0,-1,-1,0]], [[-1,1,0,1,0,0,1,1,1,1], [0,0,0,0,-1,0,0,0,1,0], [-1,1,0,1,-1,0,1,1,1,1], [0,1,0,0,0,0,0,1,1,1], [0,1,0,1,0,-1,1,1,0,1], [-1,0,0,1,0,0,0,1,0,1], [-1,-1,1,1,0,-1,0,0,-1,1], [0,0,0,1,0,0,0,0,-1,0], [0,1,0,0,0,0,1,1,1,0], [-1,0,0,0,1,0,0,0,0,0]]]], [ # Z-class [10][34] [[4], [0,4], [-2,-1,4], [-2,0,0,4], [1,0,0,-2,4], [-1,2,-1,1,-2,4], [-2,-1,0,2,-1,1,4], [0,0,0,1,1,0,0,4], [2,0,0,-2,1,-1,-2,1,4], [2,0,-1,-1,2,-2,-1,0,1,4]], [[[0,0,0,0,0,0,1,0,1,0], [1,0,1,1,1,1,0,0,0,0], [0,0,0,-1,0,0,0,0,-1,0], [-1,0,0,0,0,0,-1,0,0,0], [1,1,0,0,0,-1,1,0,0,-1], [0,-1,0,1,1,1,-1,0,0,0], [-1,0,-1,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,1,0,0,0], [0,1,0,-1,-1,-1,1,1,0,0]], [[0,-1,0,0,0,1,0,0,0,1], [1,0,1,1,1,1,0,0,0,0], [0,0,0,0,0,-1,0,0,0,-1], [0,1,0,-1,-1,-1,0,1,-1,0], [0,-1,0,1,1,1,-1,-1,0,0], [1,1,1,0,0,0,1,0,0,0], [0,1,0,0,-1,-1,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0], [0,-1,0,0,0,1,0,0,0,0], [-1,-1,0,0,0,1,-1,0,0,1]], [[0,0,1,0,0,1,0,0,0,1], [0,0,0,1,0,0,0,0,1,0], [1,0,0,1,1,0,0,-1,0,-1], [-1,-1,-1,0,0,0,-1,0,0,0], [1,0,1,0,0,0,1,0,0,0], [-1,0,-1,0,0,0,0,0,1,0], [-1,0,-1,-1,-1,-1,0,0,0,0], [0,-1,0,0,0,1,0,0,0,0], [1,0,1,0,0,1,0,0,0,0], [0,0,1,0,0,0,0,0,0,0]]]], [ # Z-class [10][35] [[10], [-5,10], [-2,1,10], [1,-2,-5,10], [-2,1,-2,1,10], [1,-2,1,-2,-5,10], [-2,1,-2,1,-2,1,10], [1,-2,1,-2,1,-2,-5,10], [-2,1,-2,1,-2,1,-2,1,10], [1,-2,1,-2,1,-2,1,-2,-5,10]], [[[0,0,0,0,0,0,1,1,0,0], [0,0,0,0,0,0,0,-1,0,0], [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1], [0,1,0,1,0,1,0,1,0,1], [0,0,0,0,0,0,0,0,1,1], [0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,1,1,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0], [0,0,1,1,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0]], [[0,1,0,1,0,1,0,1,0,1], [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1], [0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,1,1], [0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,1,1,0,0], [0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,1,1,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0], [0,0,1,1,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,1], [-1,0,-1,0,-1,0,-1,0,-1,0], [0,-1,0,-1,0,-1,0,-1,0,-1], [0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,1,0,0], [0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0]]]], [ # Z-class [10][36] [[6], [-2,6], [-3,1,6], [-1,-1,2,6], [-1,3,-1,1,6], [-2,-2,1,3,-1,6], [1,1,-2,-2,-1,-1,6], [-2,2,1,-1,1,-2,-1,6], [-1,1,2,-2,-1,-1,2,-1,6], [1,1,1,1,2,-1,-3,-1,-1,6]], [[[0,0,-1,1,-1,0,0,1,1,1], [0,0,1,0,0,-1,0,-1,-1,-1], [0,1,0,0,0,0,-1,-1,0,-1], [1,1,0,0,0,1,0,0,0,0], [0,0,1,0,0,0,1,0,-1,0], [1,0,1,-1,1,1,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1], [-1,0,0,0,0,-1,0,-1,0,0], [0,0,0,1,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,1,1,0,1], [-1,0,-1,0,0,0,0,0,0,0], [0,0,1,-1,1,0,0,-1,-1,-1], [0,0,1,0,0,0,1,0,-1,0], [0,1,0,0,0,0,-1,-1,0,-1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1,0,0], [-1,0,-1,0,-1,0,0,0,0,1], [0,0,0,0,0,0,1,0,0,0]], [[1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,1,1,0,1], [0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,1,0,1,1,1], [-1,0,0,0,0,-1,0,-1,0,0], [0,-1,1,-1,1,0,1,0,-1,0], [0,0,0,0,0,1,0,0,0,0], [0,0,1,-1,0,0,0,0,-1,0], [0,0,-1,1,-1,0,0,1,1,1]]]], [ # Z-class [10][37] [[8], [-4,8], [2,-1,8], [-1,2,-4,8], [4,-2,-2,1,8], [-4,2,-4,2,-2,8], [4,-2,-2,1,2,-2,8], [-2,4,1,-2,-4,1,-1,8], [2,-4,2,-4,1,-4,1,-2,8], [-2,4,1,-2,-1,1,-4,2,-2,8]], [[[-1,-1,1,1,1,0,1,1,0,1], [0,1,0,-1,0,0,0,-1,0,-1], [0,0,-1,-1,0,-1,0,0,-1,0], [0,0,0,1,0,0,0,0,1,0], [-1,-1,1,1,1,1,1,1,1,1], [0,0,0,0,0,0,-1,0,0,-1], [-1,-1,1,1,0,0,1,0,0,1], [0,1,0,-1,0,0,0,-1,-1,-1], [0,0,0,0,0,0,0,0,0,1], [0,1,0,-1,0,0,0,0,0,-1]], [[0,-1,0,1,0,0,0,1,1,1], [1,1,-1,-1,-1,-1,-1,-1,-1,-1], [0,-1,0,1,0,0,0,1,0,0], [1,1,-1,-1,-1,0,0,-1,0,0], [0,0,0,1,0,0,0,0,1,1], [0,1,0,-1,0,0,0,-1,0,-1], [0,-1,0,0,0,0,0,0,0,1], [0,0,-1,-1,0,-1,-1,0,-1,-1], [-1,-1,1,1,1,0,1,1,0,1], [1,1,0,0,0,0,-1,0,0,-1]], [[1,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0], [1,0,-1,0,-1,-1,-1,0,0,0], [0,1,0,-1,0,0,0,-1,-1,-1], [0,0,0,0,0,0,1,0,0,0], [-1,0,0,0,1,0,0,0,0,0], [1,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,1,0,0], [0,1,0,0,0,0,0,0,1,0]]]], [ # Z-class [10][38] [[3], [1,3], [1,1,3], [1,1,1,3], [-1,1,0,0,3], [-1,0,1,0,1,3], [-1,0,0,1,1,1,3], [0,-1,1,0,-1,1,0,3], [0,-1,0,1,-1,0,1,1,3], [0,0,-1,1,0,-1,1,-1,1,3]], [[[0,0,0,0,0,1,-1,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,1,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,1,-1,1], [0,0,0,0,0,0,1,0,0,0], [1,0,0,-1,0,0,1,0,0,0], [0,0,0,0,-1,0,1,0,-1,0], [0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0], [0,-1,0,1,0,0,0,0,-1,0]], [[0,0,0,0,0,0,0,0,0,-1], [0,0,-1,1,0,0,0,0,0,-1], [0,0,0,0,0,-1,1,0,0,-1], [0,0,0,0,0,0,0,-1,1,-1], [0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,1,0], [1,0,0,-1,0,0,1,0,0,0], [0,1,0,-1,0,0,0,0,1,0], [0,0,0,0,1,0,-1,0,1,0]]]], [ # Z-class [10][39] [[4], [1,4], [0,1,4], [0,1,-1,4], [-1,1,0,0,4], [1,1,-1,-1,0,4], [0,0,0,-1,-1,0,4], [-1,0,0,0,1,1,1,4], [0,0,-1,1,0,0,1,0,4], [-1,0,0,-1,0,1,-1,-1,1,4]], [[[0,0,0,0,0,0,0,0,1,0], [1,0,0,0,0,-1,0,1,0,1], [0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,1,0,0], [1,-1,0,1,1,0,1,0,-1,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,0], [0,0,0,1,0,0,1,0,-1,1], [0,-1,1,1,0,1,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0]], [[0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,-1,0,1,0,1], [0,1,-1,-1,-1,-1,-1,1,0,0], [1,-1,0,1,1,0,1,0,-1,1], [0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,1,0], [0,1,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0], [0,0,0,-1,0,0,-1,0,1,-1]]]], [ # Z-class [10][40] [[4], [2,4], [-1,-1,4], [2,1,-2,4], [1,2,-2,2,4], [1,0,1,-1,0,4], [-1,0,2,-1,-1,-1,4], [0,-1,2,-1,-1,0,2,4], [-1,-1,-1,-1,0,-1,0,1,4], [1,1,1,1,0,-1,0,1,0,4]], [[[-1,0,-1,0,0,1,0,0,0,1], [-1,0,-1,0,0,1,1,0,0,1], [0,1,2,1,0,-1,-1,0,1,-1], [0,-1,-1,0,0,1,1,-1,0,1], [0,-1,-1,0,0,1,1,0,0,1], [-1,1,0,1,-1,0,-1,1,0,0], [0,1,1,1,0,0,0,0,1,-1], [0,1,2,1,0,0,-1,0,1,-1], [1,0,0,-1,0,0,0,0,0,0], [0,0,1,0,0,0,0,-1,1,0]], [[-1,0,-1,0,0,1,1,0,0,1], [0,0,-1,0,0,1,1,0,0,1], [1,-1,0,-1,1,-1,0,0,0,0], [-1,1,0,1,-1,1,0,0,1,0], [-1,1,-1,1,-1,1,0,1,0,0], [0,-1,-2,-1,0,0,1,0,-1,1], [1,-1,0,-1,1,0,0,0,0,0], [0,-1,0,0,1,0,0,0,0,0], [0,0,1,1,0,0,0,0,0,-1], [0,0,1,1,0,0,0,0,1,0]]]], [ # Z-class [10][41] [[4], [1,4], [-1,1,4], [1,0,-1,4], [1,0,0,-1,4], [1,-2,0,2,0,5], [1,0,-2,0,-2,-1,5], [0,2,-1,2,-2,-1,1,5], [-1,-2,1,-1,2,2,-2,-2,5], [1,-2,-1,1,2,2,-2,-2,1,5]], [[[0,0,0,-1,0,0,0,0,0,0], [1,0,0,0,-1,-1,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0], [0,0,0,-1,0,0,0,1,0,1], [0,0,1,0,0,0,0,0,0,0], [-1,0,0,-1,1,1,0,1,-1,0], [0,1,-1,0,0,0,0,-1,0,0], [1,0,-1,0,-1,-1,-1,0,1,0], [-1,1,0,0,0,1,0,0,0,0], [0,-1,1,-1,1,1,0,1,-1,0]], [[0,-1,0,0,1,0,0,0,-1,-1], [0,0,0,1,0,0,0,-1,0,-1], [0,1,-1,0,-1,0,0,-1,1,0], [0,-1,1,0,1,0,1,1,0,0], [0,0,-1,0,0,0,-1,0,0,-1], [1,-1,0,-1,0,0,0,1,0,0], [0,-1,1,0,1,0,0,0,-1,0], [0,0,1,1,1,0,1,0,0,0], [1,0,-1,0,-1,-1,-1,0,1,0], [0,0,0,-1,0,0,0,1,0,0]]]], [ # Z-class [10][42] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2]], [[[-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,-1,1]], [[0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,-1,1]]]], [ # Z-class [10][43] [[10], [-1,10], [-1,-1,10], [-1,-1,-1,10], [-1,-1,-1,-1,10], [-1,-1,-1,-1,-1,10], [-1,-1,-1,-1,-1,-1,10], [-1,-1,-1,-1,-1,-1,-1,10], [-1,-1,-1,-1,-1,-1,-1,-1,10], [-1,-1,-1,-1,-1,-1,-1,-1,-1,10]], [[[1,1,1,1,1,1,1,1,1,1], [0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0]], [[1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0], [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,1,0,0,0,0], [0,0,0,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0]]]], [ # Z-class [10][44] [[4], [1,4], [-2,0,4], [-2,1,1,4], [-2,1,2,1,4], [-2,1,2,2,1,4], [-2,1,0,1,1,1,4], [-1,1,2,0,1,2,0,4], [1,2,1,-1,0,0,0,2,4], [2,0,-2,0,-1,-1,-2,-2,-1,4]], [[[0,0,0,0,0,0,1,1,0,1], [-1,0,-1,0,0,0,0,0,0,0], [-1,1,0,0,-1,0,-1,-1,0,-1], [0,0,0,0,0,0,0,-1,0,0], [-1,0,-1,0,0,0,-1,-1,1,-1], [0,0,-1,0,0,1,-1,-1,0,-1], [0,-1,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,-1,0,0,-1], [-1,1,0,0,-1,-1,0,1,-1,0], [-1,1,0,-1,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,1,0,-1,0,-1], [0,0,1,0,0,0,0,0,0,0], [-1,0,-1,0,0,1,-1,-1,1,-1], [-1,1,1,-1,-1,0,0,0,-1,0], [-1,1,0,0,0,0,-1,-1,0,-1], [0,0,0,0,0,0,1,0,0,0], [0,0,1,0,0,0,0,-1,0,0], [2,-1,1,1,0,0,1,0,0,0], [0,0,-1,0,0,0,-1,0,0,-1]]]], [ # Z-class [10][45] [[10], [-5,10], [5,-5,10], [5,-1,4,10], [3,-4,-1,0,10], [4,-1,5,1,-3,10], [-4,3,1,-3,-1,-2,10], [4,-1,2,-1,4,3,2,10], [-4,-1,-3,-1,3,-3,-2,-1,10], [-4,5,-1,-3,-1,2,3,0,2,10]], [[[1,1,0,0,0,1,1,-1,1,-1], [-1,0,0,0,1,0,-1,0,-1,0], [1,0,0,0,-1,0,0,0,1,0], [0,0,0,1,0,0,0,0,0,0], [-1,-1,-1,1,0,1,1,0,0,0], [1,1,1,-1,0,0,0,-1,1,-1], [-1,0,0,0,0,0,-1,1,0,0], [-1,0,0,0,0,1,0,0,0,-1], [-1,-2,-1,1,-1,-1,0,1,-1,1], [0,-1,-1,0,0,0,0,0,0,0]], [[0,-1,-1,1,-1,0,0,1,0,1], [0,1,1,-1,1,1,0,-1,0,-1], [1,1,0,0,0,0,0,0,1,0], [1,0,0,0,-1,0,0,0,1,0], [0,-1,0,0,-1,-1,0,1,0,1], [1,1,0,0,0,0,0,0,0,0], [1,1,0,-1,1,1,1,-1,1,-1], [0,0,0,0,0,0,0,1,0,0], [0,0,1,0,0,-1,0,0,0,0], [1,1,1,-1,1,0,0,-1,0,0]]]], [ # Z-class [10][46] [[6], [-1,6], [1,2,6], [-3,-1,-3,6], [-2,-1,0,2,6], [-2,2,2,1,2,6], [-2,-2,0,0,3,2,6], [-2,2,-2,0,-2,-2,-1,6], [2,-3,0,-2,-2,-1,0,-2,6], [-1,2,3,-1,-2,0,-2,0,0,6]], [[[1,1,0,1,1,0,1,1,1,1], [0,0,0,0,0,0,0,0,1,0], [1,0,1,1,1,0,0,1,1,0], [-2,-1,0,-1,-1,0,-1,-1,-1,-1], [-1,-1,0,-1,0,0,-1,-1,-1,0], [0,-1,0,0,0,1,-1,0,0,0], [0,-1,0,-1,0,1,-1,0,-1,0], [0,0,-1,-1,0,0,0,0,0,0], [1,1,0,1,0,0,1,0,0,0], [0,1,1,1,0,-1,0,0,1,-1]], [[2,1,0,1,1,0,1,1,1,1], [0,-1,-1,-1,0,1,0,0,-1,1], [1,0,0,1,0,0,1,1,0,1], [-1,-1,0,-1,-1,0,-1,-1,-1,-1], [-1,0,1,0,-1,-1,0,-1,-1,-1], [0,-1,0,0,0,0,0,0,-1,0], [-1,0,1,0,0,-1,0,0,0,-1], [-1,-1,0,-1,0,1,-1,0,0,0], [1,1,0,1,1,0,0,1,1,0], [0,0,-1,0,0,0,0,0,0,1]]]] ]; MakeImmutable( IMFList[10].matrices ); gap-4r6p5/grp/perf12.grp0000644000175000017500000013106612172557252013551 0ustar billbill############################################################################# ## #W perf12.grp GAP Groups Library Volkmar Felsch ## Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains the perfect groups of sizes 787320-987840 ## All data is based on Holt/Plesken: Perfect Groups, OUP 1989 ## PERFGRP[296]:=[# 787320.1 [[1,"abwxyzWXYZ", function(a,b,w,x,y,z,W,X,Y,Z) return [[a^4,b^3,(a*b)^5,a^2*b*a^2*b^-1,w^3,x^3,y^3,z^3, W^3,X^3,Y^3,Z^3,W^-1*X^-1*W*X, W^-1*Y^-1*W*Y,W^-1*Z^-1*W*Z, X^-1*Y^-1*X*Y,X^-1*Z^-1*X*Z, Y^-1*Z^-1*Y*Z,w^-1*W*w*W^-1, w^-1*X*w*X^-1,w^-1*Y*w*Y^-1, w^-1*Z*w*Z^-1,x^-1*W*x*W^-1, x^-1*X*x*X^-1,x^-1*Y*x*Y^-1, x^-1*Z*x*Z^-1,y^-1*W*y*W^-1, y^-1*X*y*X^-1,y^-1*Y*y*Y^-1, y^-1*Z*y*Z^-1,z^-1*W*z*W^-1, z^-1*X*z*X^-1,z^-1*Y*z*Y^-1, z^-1*Z*z*Z^-1,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*w*a*z^-1, a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1, a^-1*W*a*Z^-1,a^-1*X*a*X^-1, a^-1*Y*a*(W^2*X^2*Y^2*Z^2)^-1, a^-1*Z*a*W^-1,b^-1*W*b*X^-1, b^-1*X*b*Y^-1,b^-1*Y*b*W^-1, b^-1*Z*b*Z^-1], [[a*b,w,W],[b,a*b*a*b^-1*a,w*x^-1,W], [b,a*b*a*b^-1*a,W*X^-1,w]]]; end, [24,15,15]], "A5 2^1 x 3^4' x 3^4'",[2,8,1],2, 1,[24,15,15]], # 787320.2 [[1,"abwxyz", function(a,b,w,x,y,z) return [[a^4,b^3,(a*b)^5,a^2*b*a^2*b^-1,w^9,x^9,y^9,z^9, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1], [[a*b,w],[b,a*b*a*b^-1*a,w*x^-1]]]; end, [24,45]], "A5 2^1 x 3^4' A 3^4'",[2,8,2],2, 1,[24,45]], # 787320.3 [[1,"abwxyzWXYZ", function(a,b,w,x,y,z,W,X,Y,Z) return [[a^4,b^3*Z^-1,(a*b)^5,a^2*b*a^2*b^-1,w^3,x^3, y^3,z^3,W^3,X^3,Y^3,Z^3,W^-1*X^-1*W*X, W^-1*Y^-1*W*Y,W^-1*Z^-1*W*Z, X^-1*Y^-1*X*Y,X^-1*Z^-1*X*Z, Y^-1*Z^-1*Y*Z,w^-1*W*w*W^-1, w^-1*X*w*X^-1,w^-1*Y*w*Y^-1, w^-1*Z*w*Z^-1,x^-1*W*x*W^-1, x^-1*X*x*X^-1,x^-1*Y*x*Y^-1, x^-1*Z*x*Z^-1,y^-1*W*y*W^-1, y^-1*X*y*X^-1,y^-1*Y*y*Y^-1, y^-1*Z*y*Z^-1,z^-1*W*z*W^-1, z^-1*X*z*X^-1,z^-1*Y*z*Y^-1, z^-1*Z*z*Z^-1,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*w*a*z^-1, a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1, a^-1*W*a*Z^-1,a^-1*X*a*X^-1, a^-1*Y*a*(W^2*X^2*Y^2*Z^2)^-1, a^-1*Z*a*W^-1,b^-1*W*b*X^-1, b^-1*X*b*Y^-1,b^-1*Y*b*W^-1, b^-1*Z*b*Z^-1], [[a*b,w,W],[b,a*b*a*b^-1*a,w*x^-1,W], [a^2,b,z,W*X^-1,w]]]; end, [24,15,60]], "A5 2^1 3^4' x N 3^4",[2,8,3],2, 1,[24,15,60]], # 787320.4 [[1,"abwxyz", function(a,b,w,x,y,z) return [[a^4,b^3*z^-1,(a*b)^5,a^2*b*a^2*b^-1,w^9,x^9, y^9,z^9,w^-1*x^-1*w*x,w^-1*y^-1*w*y ,w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1], [[a*b,w],[a^2,b,w*x^-1]]]; end, [24,180]], "A5 2^1 x N 3^4' A 3^4'",[2,8,4],2, 1,[24,180]], # 787320.5 [[1,"abstuvwxyz", function(a,b,s,t,u,v,w,x,y,z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,s^3,t^3,u^3,v^3, w^3,x^3,y^3,z^3,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,s^-1*w*s*w^-1, s^-1*x*s*x^-1,s^-1*y*s*y^-1, s^-1*z*s*z^-1,t^-1*w*t*w^-1, t^-1*x*t*x^-1,t^-1*y*t*y^-1, t^-1*z*t*z^-1,u^-1*w*u*w^-1, u^-1*x*u*x^-1,u^-1*y*u*y^-1, u^-1*z*u*z^-1,v^-1*w*v*w^-1, v^-1*x*v*x^-1,v^-1*y*v*y^-1, v^-1*z*v*z^-1,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s, a^-1*v*a*t,b^-1*s*b*(s*v^-1)^-1, b^-1*t*b*(t*u^-1*v)^-1, b^-1*u*b*u^-1,b^-1*v*b*v^-1, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^2*x^2*y^2*z^2)^-1, a^-1*z*a*w^-1,b^-1*w*b*x^-1, b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1], [[b,a*b*a*b^-1*a,w*x^-1,s], [b,a*b*a*b^-1*a,u,w]]]; end, [15,45]], "A5 2^1 3^4 x 3^4'",[2,8,5],1, 1,[15,45]], # 787320.6 [[1,"abstuvwxyz", function(a,b,s,t,u,v,w,x,y,z) return [[a^4,b^3*z^-1,(a*b)^5,a^2*b^-1*a^2*b,s^3,t^3, u^3,v^3,w^3,x^3,y^3,z^3,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,s^-1*w*s*w^-1, s^-1*x*s*x^-1,s^-1*y*s*y^-1, s^-1*z*s*z^-1,t^-1*w*t*w^-1, t^-1*x*t*x^-1,t^-1*y*t*y^-1, t^-1*z*t*z^-1,u^-1*w*u*w^-1, u^-1*x*u*x^-1,u^-1*y*u*y^-1, u^-1*z*u*z^-1,v^-1*w*v*w^-1, v^-1*x*v*x^-1,v^-1*y*v*y^-1, v^-1*z*v*z^-1,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s, a^-1*v*a*t,b^-1*s*b*(s*v^-1)^-1, b^-1*t*b*(t*u^-1*v)^-1, b^-1*u*b*u^-1,b^-1*v*b*v^-1, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^2*x^2*y^2*z^2)^-1, a^-1*z*a*w^-1,b^-1*w*b*x^-1, b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1], [[b,a^2,w*x^-1,s,t],[b,a*b*a*b^-1*a,u,w]]]; end, [60,45]], "A5 2^1 3^4 x N 3^4'",[2,8,6],1, 1,[60,45]], # 787320.7 [[1,"abstuvwxyz", function(a,b,s,t,u,v,w,x,y,z) return [[a^4,b^3*z^-1,(a*b)^5,a^2*b^-1*a^2*b,s^3,t^3, u^3,v^3,w^3,x^3,y^3,z^3,s^-1*t^-1*s*t *(w*y)^-1,s^-1*u^-1*s*u *(w*x^-1*z)^-1,s^-1*v^-1*s*v *(w*x*y*z^-1)^-1,t^-1*u^-1*t*u *(w*y^-1)^-1,t^-1*v^-1*t*v *(w^-1*x*z^-1)^-1,u^-1*v^-1*u*v *(w^-1*x^-1*y^-1)^-1, s^-1*w^-1*s*w,s^-1*x^-1*s*x, s^-1*y^-1*s*y,s^-1*z^-1*s*z, a^-1*s*a*(u*w)^-1, a^-1*t*a*(v*x^-1*z)^-1, a^-1*u*a*(s^-1*y^-1*z^-1)^-1, a^-1*v*a*(t^-1*z^-1)^-1, b^-1*s*b*(s*v^-1*w*x*y*z^-1)^-1, b^-1*t*b*(t*u^-1*v*y^-1)^-1, b^-1*u*b*(u*w*x^-1)^-1, b^-1*v*b*(v*w^-1*x^-1*y^-1)^-1, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1], [[b,s,u,v]]]; end, [360]], "A5 2^1 3^4 C N 3^4'",[2,8,7],1, 1,360], # 787320.8 [[1,"abstuvwxyz", function(a,b,s,t,u,v,w,x,y,z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,s^3,t^3,u^3,v^3, w^3,x^3,y^3,z^3,s^-1*t^-1*s*t*(w*y)^-1, s^-1*u^-1*s*u*(w*x^-1*z)^-1, s^-1*v^-1*s*v*(w*x*y*z^-1)^-1, t^-1*u^-1*t*u*(w*y^-1)^-1, t^-1*v^-1*t*v*(w^-1*x*z^-1)^-1, u^-1*v^-1*u*v*(w^-1*x^-1*y^-1) ^-1,s^-1*w^-1*s*w,s^-1*x^-1*s *x,s^-1*y^-1*s*y,s^-1*z^-1*s*z, a^-1*s*a*(u*w)^-1, a^-1*t*a*(v*x^-1*z)^-1, a^-1*u*a*(s^-1*y^-1*z^-1)^-1, a^-1*v*a*(t^-1*z^-1)^-1, b^-1*s*b*(s*v^-1*w*x*y*z^-1)^-1, b^-1*t*b*(t*u^-1*v*y^-1)^-1, b^-1*u*b*(u*w*x^-1)^-1, b^-1*v*b*(v*w^-1*x^-1*y^-1)^-1, a^-1*w*a*z^-1,a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, b^-1*w*b*x^-1,b^-1*x*b*y^-1, b^-1*y*b*w^-1,b^-1*z*b*z^-1], [[b,s,u,v]]]; end, [360]], "A5 2^1 3^4 C 3^4'",[2,8,8],1, 1,360], # 787320.9 [[1,"abstuvSTUV", function(a,b,s,t,u,v,S,T,U,V) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,s^3*T^-1,t^3 *(S*T^-1)^-1,u^3*V^-1, v^3*(U*V^-1)^-1,S^3,T^3,U^3,V^3, s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s,a^-1*v*a*t, b^-1*s*b*(s*v^-1*T^-1*V)^-1, b^-1*t*b *(t*u^-1*v*S^-1*T^-1*V^-1)^-1, b^-1*u*b*(u*S*U*V^-1)^-1, b^-1*v*b*(v*T*V)^-1],[[a^2,s,t,u]]]; end, [540]], "A5 2^1 3^4 A 3^4 I",[2,8,9],1, 1,540], # 787320.10 [[1,"abstuvSTUV", function(a,b,s,t,u,v,S,T,U,V) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,s^3*S^-1,t^3 *T^-1,u^3*U^-1,v^3*V^-1,S^3,T^3,U^3, V^3,s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s,a^-1*v*a*t, b^-1*s*b*(s*v^-1*S^-1*T^-1*V)^-1 , b^-1*t*b*(t*u^-1*v*S^-1*T^-1*U^(-1 *1)*V)^-1,b^-1*u*b*(u*S*T*V)^-1, b^-1*v*b*(v*S*U)^-1],[[a^2,s,t,u]]]; end, [540]], "A5 2^1 3^4 A 3^4 II",[2,8,10],1, 1,540], # 787320.11 [[1,"abstuvSTUV", function(a,b,s,t,u,v,S,T,U,V) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,s^3*S^-1,t^3 *T^-1,u^3*U^-1,v^3*V^-1,S^3,T^3,U^3, V^3,s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s,a^-1*v*a*t, b^-1*s*b*(s*v^-1*S*T^-1)^-1, b^-1*t*b*(t*u^-1*v*V)^-1, b^-1*u*b*(u*S*T*V)^-1, b^-1*v*b*(v*S*U)^-1],[[a^2,s,t,u]]]; end, [540]], "A5 2^1 3^4 A 3^4 III",[2,8,11],1, 1,540], # 787320.12 [[1,"abstuvSTUV", function(a,b,s,t,u,v,S,T,U,V) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,s^3,t^3,u^3,v^3, S^3,T^3,U^3,V^3,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,s^-1*S^-1*s*S, s^-1*T^-1*s*T,s^-1*U^-1*s*U, s^-1*V^-1*s*V,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s, a^-1*v*a*t,b^-1*s*b*(s*v^-1*S*V)^-1 , b^-1*t*b*(t*u^-1*v*S^-1*T^-1*U^(-1 *1))^-1,b^-1*u*b*u^-1, b^-1*v*b*v^-1,a^-1*S*a*U^-1, a^-1*T*a*V^-1,a^-1*U*a*S, a^-1*V*a*T,b^-1*S*b*(S*V^-1)^-1, b^-1*T*b*(T*U^-1*V)^-1, b^-1*U*b*U^-1,b^-1*V*b*V^-1], [[a^2,s,t,u,v,S,T,U]]]; end, [180]], "A5 2^1 3^4 E 3^4",[2,8,12],1, 1,180], # 787320.13 [[1,"abstuvSTUV", function(a,b,s,t,u,v,S,T,U,V) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,s^3,t^3,u^3,v^3, S^3,T^3,U^3,V^3,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,s^-1*S^-1*s*S, s^-1*T^-1*s*T,s^-1*U^-1*s*U, s^-1*V^-1*s*V,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s, a^-1*v*a*t,b^-1*s*b*(s*v^-1)^-1, b^-1*t*b*(t*u^-1*v)^-1, b^-1*u*b*u^-1,b^-1*v*b*v^-1, a^-1*S*a*U^-1,a^-1*T*a*V^-1, a^-1*U*a*S,a^-1*V*a*T, b^-1*S*b*(S*V^-1)^-1, b^-1*T*b*(T*U^-1*V)^-1, b^-1*U*b*U^-1,b^-1*V*b*V^-1], [[b,a*b*a*b^-1*a,u,S],[b,a*b*a*b^-1*a,U,s]]] ; end, [45,45]], "A5 2^1 3^4 x 3^4",[2,8,13],1, 1,[45,45]], # 787320.14 [[1,"abcduvwxyz", function(a,b,c,d,u,v,w,x,y,z) return [[a^2*d^-1,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1 *b^-1*c*b*c*b^-1*c*b*c^-1, d^3,d^-1*b^-1*d*b,d^-1*c^-1*d*c, u^3,v^3,w^3,x^3,y^3,z^3,d^-1*u^-1*d*u, d^-1*v^-1*d*v,d^-1*w^-1*d*w, d^-1*x^-1*d*x,d^-1*y^-1*d*y, d^-1*z^-1*d*z,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*u*a*(u^2*v*w^2*x^2*y)^-1, a^-1*v*a*(u*v*w^2*z)^-1, a^-1*w*a*(u^2*w*x*y^2*z^2)^-1, a^-1*x*a*(v^2*w*y^2)^-1, a^-1*y*a*(u*v^2*w^2*y^2*z)^-1, a^-1*z*a*(u^2*v^2*x^2*y*z)^-1, b^-1*u*b*(u*w^2*y)^-1, b^-1*v*b*(v*x^2*z)^-1, b^-1*w*b*(w*y)^-1,b^-1*x*b*(x*z)^-1, b^-1*y*b*y^-1,b^-1*z*b*z^-1, c^-1*u*c*u^-1,c^-1*v*c*v^-1, c^-1*w*c*(v*w)^-1, c^-1*x*c*(u*v^2*x)^-1, c^-1*y*c*(u*v^2*x^2*y)^-1, c^-1*z*c*(u^2*v^2*w^2*x*z)^-1], [[b,c*a*b*c,y,z,w,x],[a*d,c*d,u]]]; end, [90,18]], "A6 3^1 x 3^6",[14,7,1],3, 3,[90,18]], # 787320.15 [[1,"abcduvwxyz", function(a,b,c,d,u,v,w,x,y,z) return [[a^2*(d*v^2*w*x*y^2)^-1,b^3*z^-1,c^3*v^(-1 *2),(b*c)^4*(v*x^2*y^2)^-1, (b*c^-1)^5*(v*x^2*y)^-1, a^-1*b^-1*c*b*c*b^-1*c*b*c^-1,d^3, d^-1*b^-1*d*b,d^-1*c^-1*d*c,u^3, v^3,w^3,x^3,y^3,z^3,d^-1*u^-1*d*u, d^-1*v^-1*d*v,d^-1*w^-1*d*w, d^-1*x^-1*d*x,d^-1*y^-1*d*y, d^-1*z^-1*d*z,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*u*a*(u^2*v*w^2*x^2*y)^-1, a^-1*v*a*(u*v*w^2*z)^-1, a^-1*w*a*(u^2*w*x*y^2*z^2)^-1, a^-1*x*a*(v^2*w*y^2)^-1, a^-1*y*a*(u*v^2*w^2*y^2*z)^-1, a^-1*z*a*(u^2*v^2*x^2*y*z)^-1, b^-1*u*b*(u*w^2*y)^-1, b^-1*v*b*(v*x^2*z)^-1, b^-1*w*b*(w*y)^-1,b^-1*x*b*(x*z)^-1, b^-1*y*b*y^-1,b^-1*z*b*z^-1, c^-1*u*c*u^-1,c^-1*v*c*v^-1, c^-1*w*c*(v*w)^-1, c^-1*x*c*(u*v^2*x)^-1, c^-1*y*c*(u*v^2*x^2*y)^-1, c^-1*z*c*(u^2*v^2*w^2*x*z)^-1], [[b,c*a*b*c,y,z,w,x],[a*d,c*d,u]]]; end, [90,18],[0,[2,3]]], "A6 3^1 x N 3^6",[14,7,2],3, 3,[90,18]], # 787320.16 [[1,"abcdwxyzef", function(a,b,c,d,w,x,y,z,e,f) return [[a^2*d^-1,b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1 *b^-1*c*b*c*b^-1*c*b*c^-1, d^3,d^-1*b^-1*d*b,d^-1*c^-1*d*c, w^3,x^3,y^3,z^3,e^3,f^3,d^-1*w^-1*d*w, d^-1*x^-1*d*x,d^-1*y^-1*d*y, d^-1*z^-1*d*z,d^-1*e^-1*d*e, d^-1*f^-1*d*f,w^-1*e^-1*w*e, x^-1*e^-1*x*e,y^-1*e^-1*y*e, z^-1*e^-1*z*e,w^-1*f^-1*w*f, x^-1*f^-1*x*f,y^-1*f^-1*y*f, z^-1*f^-1*z*f,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*w*a*z^-1, a^-1*x*a*x^-1, a^-1*y*a*(w^-1*x^-1*y^-1*z^-1) ^-1,a^-1*z*a*w^-1, a^-1*e*a*e^-1,a^-1*f*a*f^-1, b^-1*w*b*x^-1, b^-1*x*b*(y*e^-1)^-1, b^-1*y*b*(w*e)^-1,b^-1*z*b*(z*e)^-1, b^-1*e*b*e^-1,b^-1*f*b*f^-1, c^-1*w*c*(w^-1*x*y^-1*z^-1*f)^-1 ,c^-1*x*c*(x^-1*z*f)^-1, c^-1*y*c*(w*x^-1*f)^-1, c^-1*z*c*(x^-1*f^-1)^-1, c^-1*e*c*e^-1,c^-1*f*c*f^-1], [[a,b,w,d],[a,c,w,d],[a*d,c*d,w,e]]]; end, [18,18,18]], "A6 3^1 x ( 3^4' E ( 3^1 x 3^1 ) )",[14,7,3],27, 3,[18,18,18]] ]; PERFGRP[297]:=[# 806736.1 [[1,"abyzYZ", function(a,b,y,z,Y,Z) return [[a^4,b^3,(a*b)^7,a^2*b^-1*a^2*b,(a^-1*b^-1 *a*b)^4*a^2,y^7,z^7,Y^7,Z^7, y^-1*z^-1*y*z,Y^-1*Z^-1*Y*Z, y^-1*Y^-1*y*Y,y^-1*Z^-1*y*Z, z^-1*Y^-1*z*Y,z^-1*Z^-1*z*Z, a^-1*y*a*z,a^-1*z*a*y^-1, b^-1*y*b*z^-1, b^-1*z*b*(y^-1*z^-1)^-1, a^-1*Y*a*Z,a^-1*Z*a*Y^-1, b^-1*Y*b*Z^-1, b^-1*Z*b*(Y^-1*Z^-1)^-1], [[a,b,y],[a,b,Y]]]; end, [49,49]], "L3(2) 2^1 7^2 x 7^2",[10,4,1],1, 2,[49,49]], # 806736.2 [[1,"abwxyz", function(a,b,w,x,y,z) return [[a^4,b^3,(a*b)^7,a^2*b^-1*a^2*b,(a^-1*b^-1 *a*b)^4*a^2,w^7,x^7,y^7,z^7, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*w*a*z,a^-1*x*a*y^-1, a^-1*y*a*x,a^-1*z*a*w^-1, b^-1*w*b*z^-1, b^-1*x*b*(y^-1*z^-1)^-1, b^-1*y*b*(x*y^2*z)^-1, b^-1*z*b*(w^-1*x^(-1*3)*y^(-1*3)*z^-1) ^-1], [[a^2,a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,x] ]]; end, [56]], "L3(2) 2^1 7^4",[10,4,2],1, 2,56] ]; PERFGRP[298]:=[# 816480.1 [[2,4860,1,168,1], "( A5 x L3(2) ) # 3^4 [1]",[32,4,1],1, [1,2],[15,7]], # 816480.2 [[2,4860,2,168,1], "( A5 x L3(2) ) # 3^4 [2]",[32,4,2],1, [1,2],[60,7]] ]; PERFGRP[299]:=[# 820800.1 [[2,120,1,6840,1], "( A5 x L2(19) ) 2^2",40,4, [1,9],[24,40]] ]; PERFGRP[300]:=[# 822528.1 [[2,168,1,4896,1], "( L3(2) x L2(17) ) 2^1 [1]",40,2, [2,7],[7,288]], # 822528.2 [[2,336,1,2448,1], "( L3(2) x L2(17) ) 2^1 [2]",40,2, [2,7],[16,18]], # 822528.3 [[3,336,1,4896,1,"d1","d2"], "( L3(2) x L2(17) ) 2^1 [3]",40,2, [2,7],2304] ]; PERFGRP[301]:=[# 823080.1 [[1,"abxyz", function(a,b,x,y,z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,x^19,y^19,z^19, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*x*a*z^-1, a^-1*y*a*y,a^-1*z*a*x^-1, b^-1*x*b*(x^(-1*2)*y^(-1*6)*z^5)^-1, b^-1*y*b*(x^(-1*8)*y^(-1*4)*z^(-1*7))^-1, b^-1*z*b*(x^6*y^7*z^6)^-1], [[a*b,z],[a*b,b*a*b*a*b^-1*a*b^-1, y*z^(-1*2)]]]; end, [24,114],[0,0,2,2,2,2,2,2]], "A5 2^1 19^3",[5,3,1],2, 1,[24,114]], # 823080.2 [[1,"abyzd", function(a,b,y,z,d) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,d^19,d^-1*y ^-1*d*y,d^-1*z^-1*d*z,y^19,z^19, y^-1*z^-1*y*z*d^-1, a^-1*y*a*z^-1,a^-1*z*a*y, a^-1*d*a*d^-1, b^-1*y*b*(y^(-1*6)*z^(-1*9)*d^(-1*8))^-1, b^-1*z*b*(y^(-1*5)*z^5*d^3)^-1],[[a,b]]]; end, [6859],[0,0,2,2,2,2,2,2,0,2]], "A5 2^1 19^2 C 19^1",[5,3,2],19, 1,6859] ]; PERFGRP[302]:=[# 846720.1 [[2,336,1,2520,1], "( L3(2) x A7 ) 2^1 [1]",40,2, [2,8],[16,7]], # 846720.2 [[2,168,1,5040,1], "( L3(2) x A7 ) 2^1 [2]",40,2, [2,8],[7,240]], # 846720.3 [[3,336,1,5040,1,"d1","d2"], "( L3(2) x A7 ) 2^1 [3]",40,2, [2,8],1920] ]; PERFGRP[303]:=[# 864000.1 [[2,120,1,7200,1], "( A5 x A5 x A5 ) 2^2 [1]",40,4, [1,1,1],[24,5,24]], # 864000.2 [[2,120,1,7200,2], "( A5 x A5 x A5 ) 2^2 [2]",40,4, [1,1,1],[24,288]], # 864000.3 [[3,120,1,14400,1,"d1","a2","a2","c2","c2"], "( A5 x A5 x A5 ) 2^2 [3]",40,4, [1,1,1],[288,288]] ]; PERFGRP[304]:=[# 871200.1 [[2,660,1,1320,1], "( L2(11) x L2(11) ) 2^1 [1]",40,2, [5,5],[11,24]], # 871200.2 [[3,1320,1,1320,1,"d1","d2"], "( L2(11) x L2(11) ) 2^1 [2]",40,2, [5,5],288] ]; PERFGRP[305]:=[# 874800.1 [[2,60,1,14580,1], "( A5 x A5 ) # 3^5",[30,5,1],3, [1,1],[5,18]] ]; PERFGRP[306]:=[# 878460.1 [[1,"abxyz", function(a,b,x,y,z) return [[a^2,b^3,(a*b)^11,(a*b)^4*(a*b^-1)^5*(a*b)^4*(a *b^-1)^5,x^11,y^11,z^11,x^-1*y^-1*x*y ,x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*x*a*z^-1,a^-1*y*a*y, a^-1*z*a*x^-1,b^-1*x*b*z^-1, b^-1*y*b*(y^-1*z^-1)^-1, b^-1*z*b*(x*y^2*z)^-1], [[a*b,b*a*b*a*(b^-1*a)^4*b^-1,y]]]; end, [132]], "L2(11) 11^3",[19,3,1],1, 5,132], # 878460.2 [[1,"abxyz", function(a,b,x,y,z) return [[a^2,b^3,(a*b)^11*z^-1,(a*b)^4*(a*b^-1)^5*(a*b) ^4*(a*b^-1)^5*(x^2*y^3*z^5)^-1,x^11, y^11,z^11,x^-1*y^-1*x*y,x^-1*z^-1*x *z,y^-1*z^-1*y*z,a^-1*x*a*z^-1, a^-1*y*a*y,a^-1*z*a*x^-1, b^-1*x*b*z^-1, b^-1*y*b*(y^-1*z^-1)^-1, b^-1*z*b*(x*y^2*z)^-1], [[a*b*x^(-1*3),b*a*b*a*(b^-1*a)^4*b^-1,y]]]; end, [132]], "L2(11) N 11^3",[19,3,2],1, 5,132] ]; PERFGRP[307]:=[# 881280.1 [[2,360,1,2448,1], "A6 x L2(17)",40,1, [3,7],[6,18]] ]; PERFGRP[308]:=[# 885720.1 [[1,"abc", function(a,b,c) return [[c^60,b^11,c^(-1*6)*b*c^6*b^(-1*6),c^(-1*29)*b*c*b*c ^28*b^(-1*4),a^2,c*a*c*a^-1,(b*a)^3, c*b^4*c*b^2*c*a*b^3*c*b*a*b^-1*c^-1*a *b^-1*a],[[b,c]]]; end, [122]], "L2(121)",22,-1, 54,122] ]; PERFGRP[309]:=[# 887040.1 [[1,"abe", function(a,b,e) return [[a^2,b^4,(a*b)^11,(a*b*a*b^2)^7,(a*b*a*b^-1*a*b ^-1*a*b^2*a*b)^2*b*a*b^-1 *e^-1,e^2,a^-1*e*a*e^-1, b^-1*e*b*e^-1], [[a*b*a*b^2,a*b^-1*a*b*a*b^-1*a*b*a*e]]]; end, [352]], "M22 2^1",28,-2, 46,352], # 887040.2 [[2,1344,1,660,1], "( L3(2) x L2(11) ) # 2^3 [1]",[39,3,1],1, [2,5],[8,11]], # 887040.3 [[2,1344,2,660,1], "( L3(2) x L2(11) ) # 2^3 [2]",[39,3,2],1, [2,5],[14,11]] ]; PERFGRP[310]:=[# 892800.1 [[2,60,1,14880,1], "A5 x L2(31)",40,1, [1,18],[5,32]] ]; PERFGRP[311]:=[# 900000.1 [[2,60,1,15000,1], "( A5 x A5 ) 2^1 # 5^3 [1]",[30,3,1],2, [1,1],[5,24,30]], # 900000.2 [[2,120,1,7500,1], "( A5 x A5 ) 2^1 # 5^3 [2]",[30,3,1],2, [1,1],[24,30]], # 900000.3 [[3,120,1,15000,1,"d1","a2","a2"], "( A5 x A5 ) 2^1 # 5^3 [3]",[30,3,1],2, [1,1],[288,360]], # 900000.4 [[2,60,1,15000,2], "( A5 x A5 ) 2^1 # 5^3 [4]",[30,3,2],2, [1,1],[5,24,30]], # 900000.5 [[2,120,1,7500,2], "( A5 x A5 ) 2^1 # 5^3 [5]",[30,3,2],2, [1,1],[24,30]], # 900000.6 [[3,120,1,15000,2,"d1","a2","a2"], "( A5 x A5 ) 2^1 # 5^3 [6]",[30,3,2],2, [1,1],[288,360]], # 900000.7 [[2,60,1,15000,3], "( A5 x A5 ) 2^1 # 5^3 [7]",[30,3,3],5, [1,1],[5,125]] ]; PERFGRP[312]:=[# 903168.1 [[2,168,1,5376,1], "( L3(2) x L3(2) ) # 2^5 [1]",[34,5,1],4, [2,2],[7,16,16]], # 903168.2 [[2,336,1,2688,1], "( L3(2) x L3(2) ) # 2^5 [2]",[34,5,2],4, [2,2],[16,8,16]], # 903168.3 [[2,336,1,2688,2], "( L3(2) x L3(2) ) # 2^5 [3]",[34,5,3],4, [2,2],[16,16]], # 903168.4 [[2,336,1,2688,3], "( L3(2) x L3(2) ) # 2^5 [4]",[34,5,4],4, [2,2],[16,16,14]], # 903168.5 [[3,336,1,5376,1,"d1","d2"], "( L3(2) x L3(2) ) # 2^5 [5]",[34,5,5],4, [2,2],[128,128]], # 903168.6 [[3,336,1,5376,1,"d1","e2"], "( L3(2) x L3(2) ) # 2^5 [6]",[34,5,6],4, [2,2],[128,128]] ]; PERFGRP[313]:=[# 907200.1 [[2,60,1,15120,1], "( A5 x A7 3^1 ) 2^1 [1]",40,6, [1,8],[5,45,240]], # 907200.2 [[2,120,1,7560,1], "( A5 x A7 3^1 ) 2^1 [2]",40,6, [1,8],[24,45]], # 907200.3 [[3,120,1,15120,1,"d1","d2"], "( A5 x A7 3^1 ) 2^1 [3]",40,6, [1,8],[540,2880]], # 907200.4 [[2,360,1,2520,1], "A6 x A7",40,1, [3,8],[6,7]] ]; PERFGRP[314]:=[# 912576.1 [[1,"abc", function(a,b,c) return [[c^48*a^2,c*b^25*c^-1*b^-1,b^97,a^4,a^2*b^(-1 *1)*a^2*b,a^2*c^-1*a^2*c, c*a*c*a^-1,(b*a)^3, c^10*(b*c)^2*a*b*c^2*a*b*a*b^2*c*b*a], [[b,c^32]]]; end, [3136],[0,5,2,2,3,3]], "L2(97) 2^1 = SL(2,97)",22,-2, 47,3136] ]; PERFGRP[315]:=[# 921600.1 [[1,"abcdstuvwxyz", function(a,b,c,d,s,t,u,v,w,x,y,z) return [[a^2,b^3,(a*b)^5,c^2,d^3,(c*d)^5,a^-1*c^-1*a*c ,a^-1*d^-1*a*d,b^-1*c^-1*b*c, b^-1*d^-1*b*d,s^2,t^2,u^2,v^2,w^2,x^2,y^2, z^2,s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,s^-1*w^-1*s*w, s^-1*x^-1*s*x,s^-1*y^-1*s*y, s^-1*z^-1*s*z,t^-1*u^-1*t*u, t^-1*v^-1*t*v,t^-1*w^-1*t*w, t^-1*x^-1*t*x,t^-1*y^-1*t*y, t^-1*z^-1*t*z,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*s*a*w^-1,a^-1*t*a*x^-1, a^-1*u*a*y^-1,a^-1*v*a*z^-1, a^-1*w*a*s^-1,a^-1*x*a*t^-1, a^-1*y*a*u^-1,a^-1*z*a*v^-1, b^-1*s*b*(t*x)^-1, b^-1*t*b*(s*t*w*x)^-1, b^-1*u*b*(v*z)^-1, b^-1*v*b*(u*v*y*z)^-1, b^-1*w*b*(w*x)^-1,b^-1*x*b*w^-1, b^-1*y*b*(y*z)^-1,b^-1*z*b*y^-1, c^-1*s*c*u^-1,c^-1*t*c*v^-1, c^-1*u*c*s^-1,c^-1*v*c*t^-1, c^-1*w*c*y^-1,c^-1*x*c*z^-1, c^-1*y*c*w^-1,c^-1*z*c*x^-1, d^-1*s*d*(t*v)^-1, d^-1*t*d*(s*t*u*v)^-1, d^-1*u*d*(u*v)^-1,d^-1*v*d*u^-1, d^-1*w*d*(x*z)^-1, d^-1*x*d*(w*x*y*z)^-1, d^-1*y*d*(y*z)^-1,d^-1*z*d*y^-1], [[a*b*a*b^-1*a,b,c,d,w]]]; end, [80]], "A5 x A5 2^8",[29,8,1],1, [1,1],80], # 921600.2 [[1,"abcdstuvwxyz", function(a,b,c,d,s,t,u,v,w,x,y,z) return [[a^2,b^3,(a*b)^5,c^2,d^3,(c*d)^5,a^-1*c^-1*a*c ,a^-1*d^-1*a*d,b^-1*c^-1*b*c, b^-1*d^-1*b*d*y^-1,s^2,t^2,u^2,v^2, w^2,x^2,y^2,z^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, s^-1*w^-1*s*w,s^-1*x^-1*s*x, s^-1*y^-1*s*y,s^-1*z^-1*s*z, t^-1*u^-1*t*u,t^-1*v^-1*t*v, t^-1*w^-1*t*w,t^-1*x^-1*t*x, t^-1*y^-1*t*y,t^-1*z^-1*t*z, u^-1*v^-1*u*v,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*s*a*w^-1, a^-1*t*a*x^-1,a^-1*u*a*y^-1, a^-1*v*a*z^-1,a^-1*w*a*s^-1, a^-1*x*a*t^-1,a^-1*y*a*u^-1, a^-1*z*a*v^-1,b^-1*s*b*(t*x)^-1, b^-1*t*b*(s*t*w*x)^-1, b^-1*u*b*(v*z)^-1, b^-1*v*b*(u*v*y*z)^-1, b^-1*w*b*(w*x)^-1,b^-1*x*b*w^-1, b^-1*y*b*(y*z)^-1,b^-1*z*b*y^-1, c^-1*s*c*u^-1,c^-1*t*c*v^-1, c^-1*u*c*s^-1,c^-1*v*c*t^-1, c^-1*w*c*y^-1,c^-1*x*c*z^-1, c^-1*y*c*w^-1,c^-1*z*c*x^-1, d^-1*s*d*(t*v)^-1, d^-1*t*d*(s*t*u*v)^-1, d^-1*u*d*(u*v)^-1,d^-1*v*d*u^-1, d^-1*w*d*(x*z)^-1, d^-1*x*d*(w*x*y*z)^-1, d^-1*y*d*(y*z)^-1,d^-1*z*d*y^-1], [[a*b*a*b^-1*a,b,c,d,w]]]; end, [80]], "A5 x A5 N 2^8",[29,8,2],1, [1,1],80], # 921600.3 [[2,960,1,960,1], "( A5 x A5 ) # 2^8 [3]",[29,8,3],1, [1,1],[16,16]], # 921600.4 [[2,960,1,960,2], "( A5 x A5 ) # 2^8 [4]",[29,8,4],1, [1,1],[16,10]], # 921600.5 [[2,960,2,960,2], "( A5 x A5 ) # 2^8 [5]",[29,8,5],1, [1,1],[10,10]], # 921600.6 [[2,7680,1,120,1], "( A5 x A5 ) # 2^8 [6]",[29,8,6],16, [1,1],[12,64,24]], # 921600.7 [[2,7680,2,120,1], "( A5 x A5 ) # 2^8 [7]",[29,8,7],16, [1,1],[24,64,24]], # 921600.8 [[2,7680,3,120,1], "( A5 x A5 ) # 2^8 [8]",[29,8,8],16, [1,1],[24,64,24]], # 921600.9 [[2,7680,4,120,1], "( A5 x A5 ) # 2^8 [9]",[29,8,9],16, [1,1],[24,64,24]], # 921600.10 [[2,7680,5,120,1], "( A5 x A5 ) # 2^8 [10]",[29,8,10],16, [1,1],[24,24,24]], # 921600.11 [[2,15360,1,60,1], "( A5 x A5 ) # 2^8 [11]",[29,8,11],16, [1,1],[64,64,5]], # 921600.12 [[2,15360,2,60,1], "( A5 x A5 ) # 2^8 [12]",[29,8,12],16, [1,1],[24,12,64,5]], # 921600.13 [[2,15360,3,60,1], "( A5 x A5 ) # 2^8 [13]",[29,8,13],1, [1,1],[16,16,5]], # 921600.14 [[2,15360,4,60,1], "( A5 x A5 ) # 2^8 [14]",[29,8,14],1, [1,1],[40,5]], # 921600.15 [[2,15360,5,60,1], "( A5 x A5 ) # 2^8 [15]",[29,8,15],1, [1,1],[16,10,5]], # 921600.16 [[2,15360,6,60,1], "( A5 x A5 ) # 2^8 [16]",[29,8,16],1, [1,1],[10,10,5]], # 921600.17 [[2,15360,7,60,1], "( A5 x A5 ) # 2^8 [17]",[29,8,17],1, [1,1],[20,5]], # 921600.18 [[3,15360,1,120,1,"e1","e1","d2"], "( A5 x A5 ) # 2^8 [18]",[29,8,18],16, [1,1],[768,768]], # 921600.19 [[3,15360,2,120,1,"d1","d2"], "( A5 x A5 ) # 2^8 [19]",[29,8,19],16, [1,1],[288,144,768]], # 921600.20 [[3,15360,2,120,1,"d1","f1","d2"], "( A5 x A5 ) # 2^8 [20]",[29,8,20],16, [1,1],[288,144,768]], # 921600.21 [[3,15360,2,120,1,"d1","e1","e1","f1","d2"], "( A5 x A5 ) # 2^8 [21]",[29,8,21],16, [1,1],[288,144,768]], # 921600.22 [[3,15360,2,120,1,"f1","d2"], "( A5 x A5 ) # 2^8 [22]",[29,8,22],16, [1,1],[288,144,768]], # 921600.23 [[3,15360,2,120,1,"e1","e1","d2"], "( A5 x A5 ) # 2^8 [23]",[29,8,23],16, [1,1],[288,144,768]] ]; PERFGRP[316]:=[# 921984.1 [[4,2688,1,57624,1,168], "L3(2) # 2^4 7^3 [1]",12,2, 2,[8,16,56]], # 921984.2 [[4,2688,2,57624,1,168], "L3(2) # 2^4 7^3 [2]",12,2, 2,[16,56]], # 921984.3 [[4,2688,3,57624,1,168], "L3(2) # 2^4 7^3 [3]",12,2, 2,[16,14,56]], # 921984.4 [[4,2688,1,57624,2,168], "L3(2) # 2^4 7^3 [4]",12,2, 2,[8,16,56]], # 921984.5 [[4,2688,2,57624,2,168], "L3(2) # 2^4 7^3 [5]",12,2, 2,[16,56]], # 921984.6 [[4,2688,3,57624,2,168], "L3(2) # 2^4 7^3 [6]",12,2, 2,[16,14,56]], # 921984.7 [[4,2688,1,115248,4,336,1,3], "L3(2) # 2^4 7^3 [7]",12,7, 2,[8,16,343]], # 921984.8 [[4,2688,3,115248,4,336,3,3], "L3(2) # 2^4 7^3 [8]",12,7, 2,[16,14,343]] ]; PERFGRP[317]:=[# 929280.1 [[4,7680,4,14520,2,120,4,1], "A5 # 2^7 11^2 [1]",6,4, 1,[24,64,121]], # 929280.2 [[4,7680,5,14520,2,120,5,1], "A5 # 2^7 11^2 [2]",6,4, 1,[24,24,121]] ]; PERFGRP[318]:=[# 933120.1 [[1,"abdwxyzstuve", function(a,b,d,w,x,y,z,s,t,u,v,e) return [[a^4,b^3,(a*b)^5,a^2*b*a^2*b^-1,d^2,a^-1*d ^-1*a*d,b^-1*d^-1*b*d,w^2,x^2,y^2, z^2,(w*x)^2*d,(w*y)^2*d,(w*z)^2*d,(x*y)^2*d, (x*z)^2*d,(y*z)^2*d,a^-1*w*a*z^-1, a^-1*x*a*x^-1,a^-1*y*a*(w*x*y*z)^-1 ,a^-1*z*a*w^-1,b^-1*w*b*x^-1, b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1,d^-1*w^-1*d*w, d^-1*x^-1*d*x,d^-1*y^-1*d*y, d^-1*z^-1*d*z,s^3,t^3,u^3,v^3,e^3, s^-1*t^-1*s*t*e^-1, s^-1*u^-1*s*u*e,s^-1*v^-1*s*v, t^-1*u^-1*t*u*e,t^-1*v^-1*t*v*e, u^-1*v^-1*u*v*e,s^-1*e*s*e^-1, t^-1*e*t*e^-1,u^-1*e*u*e^-1, v^-1*e*v*e^-1, a^-1*s*a*(s*t*u*v*e)^-1, a^-1*t*a*(s^-1*t*u*v^-1*e^-1)^-1 ,a^-1*u*a*(s^-1*u^-1*v)^-1, a^-1*v*a*(t*u^-1*v^-1*e)^-1, a^-1*e*a*e^-1, b^-1*s*b*(s^-1*t^-1*u*v^-1)^-1, b^-1*t*b*(s^-1*v^-1*e)^-1, b^-1*u*b*(s*t^-1*u^-1*v^-1)^-1, b^-1*v*b*(t^-1*u^-1*e)^-1, b^-1*e*b*e^-1,d^-1*s*d*s, d^-1*t*d*(t^-1*e)^-1, d^-1*u*d*(u^-1*e^-1)^-1, d^-1*v*d*(v^-1*e)^-1, d^-1*e*d*e^-1,w^-1*s*w*s^-1, w^-1*t*w*(s^-1*t*v*e^-1)^-1, w^-1*u*w*(s*t*u^-1*v^-1*e^-1)^-1 ,w^-1*v*w*(s^-1*v^-1*e)^-1, w^-1*e*w*e^-1, x^-1*s*x*(s*t*u*v^-1)^-1, x^-1*t*x*t^-1, x^-1*u*x*(s^-1*v^-1)^-1, x^-1*v*x*(s^-1*t^-1*u*v*e)^-1, x^-1*e*x*e^-1, y^-1*s*y*(s*v^-1*e^-1)^-1, y^-1*t*y*(t*u*v^-1*e^-1)^-1, y^-1*u*y*(u^-1*e^-1)^-1, y^-1*v*y*(v^-1*e)^-1, y^-1*e*y*e^-1, z^-1*s*z*(s*t^-1*u^-1*v^-1*e^-1) ^-1,z^-1*t*z*(s*u*v)^-1, z^-1*u*z*(t*u^-1*v*e^-1)^-1, z^-1*v*z*(s^-1*t*u^-1)^-1, z^-1*e*z*e^-1],[[a*b,w,s],[a,b,w]]]; end, [24,243]], "A5 2^1 x ( 2^4' C 2^1 ) 3^4 C 3^1",[7,5,1],6, 1,[24,243]], # 933120.2 [[1,"abdwxyzrstuv", function(a,b,d,w,x,y,z,r,s,t,u,v) return [[a^4,b^3,(a*b)^5,a^2*b*a^2*b^-1,d^2,a^-1*d ^-1*a*d,b^-1*d^-1*b*d, w^-1*d^-1*w*d,x^-1*d^-1*x*d, y^-1*d^-1*y*d,z^-1*d^-1*z*d,w^2, x^2,y^2,z^2,w^-1*x^-1*w*x*d, w^-1*y^-1*w*y*d,w^-1*z^-1*w*z*d, x^-1*y^-1*x*y*d,x^-1*z^-1*x*z*d, y^-1*z^-1*y*z*d,a^-1*w*a*z^-1, a^-1*x*a*x^-1,a^-1*y*a*(w*x*y*z)^-1 ,a^-1*z*a*w^-1,b^-1*w*b*x^-1, b^-1*x*b*y^-1,b^-1*y*b*w^-1, b^-1*z*b*z^-1,r^3,s^3,t^3,u^3,v^3, r^-1*s^-1*r*s,r^-1*t^-1*r*t, r^-1*u^-1*r*u,r^-1*v^-1*r*v, s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, a^-1*r*a*u^-1,a^-1*s*a*s^-1, a^-1*t*a*v^-1,a^-1*u*a*r^-1, a^-1*v*a*t^-1,b^-1*r*b*s^-1, b^-1*s*b*t^-1,b^-1*t*b*r^-1, b^-1*u*b*u^-1,b^-1*v*b*v^-1, w^-1*r*w*r^-1,w^-1*s*w*s, w^-1*t*w*t,w^-1*u*w*u,w^-1*v*w*v, x^-1*r*x*r,x^-1*s*x*s^-1, x^-1*t*x*t,x^-1*u*x*u,x^-1*v*x*v, y^-1*r*y*r,y^-1*s*y*s, y^-1*t*y*t^-1,y^-1*u*y*u, y^-1*v*y*v,z^-1*r*z*r,z^-1*s*z*s, z^-1*t*z*t,z^-1*u*z*u^-1, z^-1*v*z*v], [[a*b,w,r],[a,b,r],[b,a*b*a*b^-1*a,w,r]]]; end, [24,32,15]], "A5 2^1 x ( 2^4' C 2^1 ) 3^5",[7,5,2],4, 1,[24,32,15]], # 933120.3 [[4,3840,1,14580,1,60], "A5 # 2^6 3^5 [1]",6,12, 1,[64,18]], # 933120.4 [[4,3840,2,14580,1,60], "A5 # 2^6 3^5 [2]",6,12, 1,[64,18]], # 933120.5 [[4,3840,3,14580,1,60], "A5 # 2^6 3^5 [3]",6,12, 1,[24,18]], # 933120.6 [[4,3840,4,14580,1,60], "A5 # 2^6 3^5 [4]",6,12, 1,[48,18]], # 933120.7 [[4,3840,5,14580,1,60], "A5 # 2^6 3^5 [5]",6,12, 1,[24,12,18]], # 933120.8 [[4,3840,6,14580,1,60], "A5 # 2^6 3^5 [6]",6,6, 1,[48,18]], # 933120.9 [[4,3840,7,14580,1,60], "A5 # 2^6 3^5 [7]",6,12, 1,[32,24,18]], # 933120.10 [[4,3840,5,29160,5,120,5,2], "A5 # 2^6 3^5 [8]",6,6, 1,[24,12,243]], # 933120.11 [[4,3840,6,29160,5,120,6,2], "A5 # 2^6 3^5 [9]",6,6, 1,[48,243]], # 933120.12 [[4,3840,7,29160,5,120,7,2], "A5 # 2^6 3^5 [10]",6,6, 1,[32,24,243]], # 933120.13 [[4,3840,5,29160,6,120,5,3], "A5 # 2^6 3^5 [11]",6,6, 1,[24,12,243]], # 933120.14 [[4,3840,6,29160,6,120,6,3], "A5 # 2^6 3^5 [12]",6,6, 1,[48,243]], # 933120.15 [[4,3840,7,29160,6,120,7,3], "A5 # 2^6 3^5 [13]",6,6, 1,[32,24,243]], # 933120.16 [[4,11520,1,29160,4,360,1,1], "A6 # 2^5 3^4 [1]",15,2, 3,[12,30]], # 933120.17 [[4,11520,2,29160,4,360,2,1], "A6 # 2^5 3^4 [2]",15,2, 3,[80,30]], # 933120.18 [[4,11520,3,29160,4,360,3,1], "A6 # 2^5 3^4 [3]",15,2, 3,[16,80,30]], # 933120.19 [[4,11520,4,29160,4,360,4,1], "A6 # 2^5 3^4 [4]",15,1, 3,[80,30]], # 933120.20 [[4,11520,3,58320,3,720,3,2], "A6 # 2^5 3^4 [5]",15,1, 3,[16,80,81]], # 933120.21 [[4,11520,4,58320,3,720,4,2], "A6 # 2^5 3^4 [6]",15,1, 3,[80,81]] ]; PERFGRP[319]:=[# 936000.1 [[2,60,1,15600,1], "( A5 x L2(25) ) 2^1 [1]",40,2, [1,14],[5,208]], # 936000.2 [[2,120,1,7800,1], "( A5 x L2(25) ) 2^1 [2]",40,2, [1,14],[24,26]], # 936000.3 [[3,120,1,15600,1,"d1","a2","a2"], "( A5 x L2(25) ) 2^1 [3]",40,2, [1,14],2496] ]; PERFGRP[320]:=[# 937500.1 [[1,"abxyzXYZ", function(a,b,x,y,z,X,Y,Z) return [[a^2,b^3,(a*b)^5,x^5,y^5,z^5,X^5,Y^5,Z^5,x^-1*y ^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,X^-1*Y^-1*X*Y, X^-1*Z^-1*X*Z,Y^-1*Z^-1*Y*Z, x^-1*X*x*X^-1,x^-1*Y*x*Y^-1, x^-1*Z*x*Z^-1,y^-1*X*y*X^-1, y^-1*Y*y*Y^-1,y^-1*Z*y*Z^-1, z^-1*X*z*X^-1,z^-1*Y*z*Y^-1, z^-1*Z*z*Z^-1,a^-1*X*a*Z^-1, a^-1*Y*a*Y,a^-1*Z*a*X^-1, a^-1*x*a*z^-1,a^-1*y*a*y, a^-1*z*a*x^-1,b^-1*X*b*Z^-1, b^-1*Y*b*(Y^-1*Z)^-1, b^-1*Z*b*(X*Y^(-1*2)*Z)^-1, b^-1*x*b*z^-1, b^-1*y*b*(y^-1*z)^-1, b^-1*z*b*(x*y^(-1*2)*z)^-1], [[a*b,b*a*b*a*b^-1*a*b^-1,x,Y], [a*b,b*a*b*a*b^-1*a*b^-1,X,y]]]; end, [30,30]], "A5 5^3 x 5^3",[3,6,1],1, 1,[30,30]], # 937500.2 [[1,"abxyzXYZ", function(a,b,x,y,z,X,Y,Z) return [[a^2,b^3,(a*b)^5,x^5,y^5,z^5,X^5,Y^5,Z^5,x^-1*y ^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,X^-1*Y^-1*X*Y, X^-1*Z^-1*X*Z,Y^-1*Z^-1*Y*Z, x^-1*X*x*X^-1,x^-1*Y*x*Y^-1, x^-1*Z*x*Z^-1,y^-1*X*y*X^-1, y^-1*Y*y*Y^-1,y^-1*Z*y*Z^-1, z^-1*X*z*X^-1,z^-1*Y*z*Y^-1, z^-1*Z*z*Z^-1,a^-1*X*a*Z^-1, a^-1*Y*a*Y,a^-1*Z*a*X^-1, a^-1*x*a*(z*X^-1*Y)^-1, a^-1*y*a*(y^-1*X^2*Z^2)^-1, a^-1*z*a*(x*Y*Z)^-1,b^-1*X*b*Z^-1, b^-1*Y*b*(Y^-1*Z)^-1, b^-1*Z*b*(X*Y^(-1*2)*Z)^-1, b^-1*x*b*(z*X^-1*Y^-1*Z)^-1, b^-1*y*b*(y^-1*z*X^2*Z^(-1*2))^-1, b^-1*z*b*(x*y^(-1*2)*z*Y^-1*Z)^-1], [[a*b,b*a*b*a*b^-1*a*b^-1,x]]]; end, [30]], "A5 5^3 E 5^3",[3,6,2],1, 1,30], # 937500.3 [[1,"abxyzXYZ", function(a,b,x,y,z,X,Y,Z) return [[a^2,b^3,(a*b)^5,x^5,y^5,z^5,x^-1*y^-1*x*y *X^-1,x^-1*z^-1*x*z*Y^(-1*2), y^-1*z^-1*y*z*Z^-1,X^5,Y^5,Z^5, X^-1*Y^-1*X*Y,X^-1*Z^-1*X*Z, Y^-1*Z^-1*Y*Z,x^-1*X*x*X^-1, x^-1*Y*x*Y^-1,x^-1*Z*x*Z^-1, y^-1*X*y*X^-1,y^-1*Y*y*Y^-1, y^-1*Z*y*Z^-1,z^-1*X*z*X^-1, z^-1*Y*z*Y^-1,z^-1*Z*z*Z^-1, a^-1*x*a*(z*Y*Z^-1)^-1, a^-1*y*a*(y^-1*X^2*Z^2)^-1, a^-1*z*a*(x*X*Y)^-1,a^-1*X*a*Z^-1, a^-1*Y*a*Y,a^-1*Z*a*X^-1, b^-1*x*b*(z*Y)^-1, b^-1*y*b*(y^-1*z*X^2*Y^2)^-1, b^-1*z*b*(x*y^(-1*2)*z*X*Y^2*Z^-1)^-1, b^-1*X*b*Z^-1, b^-1*Y*b*(Y^-1*Z)^-1, b^-1*Z*b*(X*Y^(-1*2)*Z)^-1], [[a*b,b*a*b*a*b^-1*a*b^-1*x,y]]]; end, [150]], "A5 5^3 C 5^3",[3,6,3],1, 1,150], # 937500.4 [[1,"abxyzXYZ", function(a,b,x,y,z,X,Y,Z) return [[a^2,b^3,(a*b)^5*Z^-1,x^5,y^5,z^5,x^-1*y^(-1 *1)*x*y*X^-1,x^-1*z^-1*x*z *Y^(-1*2),y^-1*z^-1*y*z*Z^-1,X^5,Y^5, Z^5,X^-1*Y^-1*X*Y,X^-1*Z^-1*X*Z, Y^-1*Z^-1*Y*Z,x^-1*X*x*X^-1, x^-1*Y*x*Y^-1,x^-1*Z*x*Z^-1, y^-1*X*y*X^-1,y^-1*Y*y*Y^-1, y^-1*Z*y*Z^-1,z^-1*X*z*X^-1, z^-1*Y*z*Y^-1,z^-1*Z*z*Z^-1, a^-1*x*a*(z*Y*Z^-1)^-1, a^-1*y*a*(y^-1*X^2*Z^2)^-1, a^-1*z*a*(x*X*Y)^-1,a^-1*X*a*Z^-1, a^-1*Y*a*Y,a^-1*Z*a*X^-1, b^-1*x*b*(z*Y)^-1, b^-1*y*b*(y^-1*z*X^2*Y^2)^-1, b^-1*z*b*(x*y^(-1*2)*z*X*Y^2*Z^-1)^-1, b^-1*X*b*Z^-1, b^-1*Y*b*(Y^-1*Z)^-1, b^-1*Z*b*(X*Y^(-1*2)*Z)^-1], [[a*b,b*a*b*a*b^-1*a*b^-1*x,y]]]; end, [150]], "A5 5^3 C N 5^3 I",[3,6,4],1, 1,150], # 937500.5 [[1,"abxyzXYZ", function(a,b,x,y,z,X,Y,Z) return [[a^2,b^3,(a*b)^5*Z^(-1*2),x^5,y^5,z^5,x^-1*y^(-1 *1)*x*y*X^-1,x^-1*z^-1*x*z *Y^(-1*2),y^-1*z^-1*y*z*Z^-1,X^5,Y^5, Z^5,X^-1*Y^-1*X*Y,X^-1*Z^-1*X*Z, Y^-1*Z^-1*Y*Z,x^-1*X*x*X^-1, x^-1*Y*x*Y^-1,x^-1*Z*x*Z^-1, y^-1*X*y*X^-1,y^-1*Y*y*Y^-1, y^-1*Z*y*Z^-1,z^-1*X*z*X^-1, z^-1*Y*z*Y^-1,z^-1*Z*z*Z^-1, a^-1*x*a*(z*Y*Z^-1)^-1, a^-1*y*a*(y^-1*X^2*Z^2)^-1, a^-1*z*a*(x*X*Y)^-1,a^-1*X*a*Z^-1, a^-1*Y*a*Y,a^-1*Z*a*X^-1, b^-1*x*b*(z*Y)^-1, b^-1*y*b*(y^-1*z*X^2*Y^2)^-1, b^-1*z*b*(x*y^(-1*2)*z*X*Y^2*Z^-1)^-1, b^-1*X*b*Z^-1, b^-1*Y*b*(Y^-1*Z)^-1, b^-1*Z*b*(X*Y^(-1*2)*Z)^-1], [[a*b,b*a*b*a*b^-1*a*b^-1*x,y]]]; end, [150]], "A5 5^3 C N 5^3 II",[3,6,5],1, 1,150], # 937500.6 [[1,"abxyzXYZ", function(a,b,x,y,z,X,Y,Z) return [[a^2,b^3,(a*b)^5*z^-1,x^5,y^5,z^5,X^5,Y^5,Z^5, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,X^-1*Y^-1*X*Y, X^-1*Z^-1*X*Z,Y^-1*Z^-1*Y*Z, x^-1*X*x*X^-1,x^-1*Y*x*Y^-1, x^-1*Z*x*Z^-1,y^-1*X*y*X^-1, y^-1*Y*y*Y^-1,y^-1*Z*y*Z^-1, z^-1*X*z*X^-1,z^-1*Y*z*Y^-1, z^-1*Z*z*Z^-1,a^-1*X*a*Z^-1, a^-1*Y*a*Y,a^-1*Z*a*X^-1, a^-1*x*a*z^-1,a^-1*y*a*y, a^-1*z*a*x^-1,b^-1*X*b*Z^-1, b^-1*Y*b*(Y^-1*Z)^-1, b^-1*Z*b*(X*Y^(-1*2)*Z)^-1, b^-1*x*b*z^-1, b^-1*y*b*(y^-1*z)^-1, b^-1*z*b*(x*y^(-1*2)*z)^-1], [[a*b,b*a*b*a*b^-1*a*b^-1,x,Y], [a*b,b*a*b*a*b^-1*a*b^-1,X,y]]]; end, [30,30]], "A5 N 5^3 x 5^3",[3,6,6],1, 1,[30,30]], # 937500.7 [[1,"abxyzXYZ", function(a,b,x,y,z,X,Y,Z) return [[a^2,b^3,(a*b)^5*(z*X^(-1*2)*Y)^-1,x^5,y^5,z^5, X^5,Y^5,Z^5,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, X^-1*Y^-1*X*Y,X^-1*Z^-1*X*Z, Y^-1*Z^-1*Y*Z,x^-1*X*x*X^-1, x^-1*Y*x*Y^-1,x^-1*Z*x*Z^-1, y^-1*X*y*X^-1,y^-1*Y*y*Y^-1, y^-1*Z*y*Z^-1,z^-1*X*z*X^-1, z^-1*Y*z*Y^-1,z^-1*Z*z*Z^-1, a^-1*x*a*(z*X^-1*Y)^-1, a^-1*y*a*(y^-1*X^2*Z^2)^-1, a^-1*z*a*(x*Y*Z)^-1,a^-1*X*a*Z^-1, a^-1*Y*a*Y,a^-1*Z*a*X^-1, b^-1*x*b*(z*X^-1*Y^-1*Z)^-1, b^-1*y*b*(y^-1*z*X^2*Z^(-1*2))^-1, b^-1*z*b*(x*y^(-1*2)*z*Y^-1*Z)^-1, b^-1*X*b*Z^-1, b^-1*Y*b*(Y^-1*Z)^-1, b^-1*Z*b*(X*Y^(-1*2)*Z)^-1], [[b,a*b^-1*a*b*a*b^-1*a*b*a,z,Y*Z^2]]]; end, [50]], "A5 N 5^3 E 5^3",[3,6,7],1, 1,50], # 937500.8 [[1,"abxyzXYZ", function(a,b,x,y,z,X,Y,Z) return [[a^2,b^3,(a*b)^5*z^-1,x^5*X^-1,y^5*Y^-1, z^5*Z^-1,X^5,Y^5,Z^5,x^-1*y^-1*x*y*X, x^-1*z^-1*x*z*Y^2,y^-1*z^-1*y*z*Z, X^-1*Y^-1*X*Y,X^-1*Z^-1*X*Z, Y^-1*Z^-1*Y*Z,x^-1*X*x*X^-1, x^-1*Y*x*Y^-1,x^-1*Z*x*Z^-1, y^-1*X*y*X^-1,y^-1*Y*y*Y^-1, y^-1*Z*y*Z^-1,z^-1*X*z*X^-1, z^-1*Y*z*Y^-1,z^-1*Z*z*Z^-1, a^-1*X*a*Z^-1,a^-1*Y*a*Y, a^-1*Z*a*X^-1, a^-1*x*a*(z*X^-1*Y*Z)^-1, a^-1*y*a*(y^-1*X^-1*Z^-1)^-1, a^-1*z*a*(x*X^-1*Y*Z)^-1, b^-1*X*b*Z^-1, b^-1*Y*b*(Y^-1*Z)^-1, b^-1*Z*b*(X*Y^(-1*2)*Z)^-1, b^-1*x*b*(z*X^-1*Y^(-1*2)*Z^-1)^-1, b^-1*y*b*(y^-1*z*X^-1*Y^(-1*2))^-1, b^-1*z*b*(x*y^(-1*2)*z*X^-1*Y^(-1*2)*Z^2) ^-1], [[a*b,b*a*b*a*b^-1*a*b^-1*x^-1,y]]]; end, [150]], "A5 N 5^3 C 5^3",[3,6,8],1, 1,150] ]; PERFGRP[321]:=[# 943488.1 [[2,168,1,5616,1], "L3(2) x L3(3)",40,1, [2,11],[7,13]] ]; PERFGRP[322]:=[# 950400.1 [[2,720,1,1320,1], "( A6 x L2(11) ) 2^2",40,4, [3,5],[80,24]], # 950400.2 [[2,120,1,7920,1], "A5 2^1 x M11",40,2, [1,15],[24,11]] ]; PERFGRP[323]:=[# 950520.1 [[1,"abyz", function(a,b,y,z) return [[a^4,b^3,(a*b)^5,a^2*b^-1*a^2*b,y^89,z^89,y^-1 *z^-1*y*z,a^-1*y*a*z^-1, a^-1*z*a*y,b^-1*y*b*(y^(-1*37)*z^40)^-1, b^-1*z*b*(y^(-1*40)*z^36)^-1], [[a,y^5*z^(-1*8)]]]; end, [2670],[0,0,2,2,2,2]], "A5 2^1 89^2",[5,2,1],1, 1,2670] ]; PERFGRP[324]:=[# 960000.1 [[4,7680,1,7500,1,60], "A5 # 2^7 5^3 [1]",6,8, 1,[12,64,30]], # 960000.2 [[4,7680,2,7500,1,60], "A5 # 2^7 5^3 [2]",6,8, 1,[24,64,30]], # 960000.3 [[4,7680,3,7500,1,60], "A5 # 2^7 5^3 [3]",6,8, 1,[24,64,30]], # 960000.4 [[4,7680,4,7500,1,60], "A5 # 2^7 5^3 [4]",6,8, 1,[24,64,30]], # 960000.5 [[4,7680,5,7500,1,60], "A5 # 2^7 5^3 [5]",6,8, 1,[24,24,30]], # 960000.6 [[4,7680,1,7500,2,60], "A5 # 2^7 5^3 [6]",6,8, 1,[12,64,30]], # 960000.7 [[4,7680,2,7500,2,60], "A5 # 2^7 5^3 [7]",6,8, 1,[24,64,30]], # 960000.8 [[4,7680,3,7500,2,60], "A5 # 2^7 5^3 [8]",6,8, 1,[24,64,30]], # 960000.9 [[4,7680,4,7500,2,60], "A5 # 2^7 5^3 [9]",6,8, 1,[24,64,30]], # 960000.10 [[4,7680,5,7500,2,60], "A5 # 2^7 5^3 [10]",6,8, 1,[24,24,30]], # 960000.11 [[4,7680,4,15000,4,120,4,3], "A5 # 2^7 5^3 [11]",6,20, 1,[24,64,125]], # 960000.12 [[4,7680,5,15000,4,120,5,3], "A5 # 2^7 5^3 [12]",6,20, 1,[24,24,125]] ]; PERFGRP[325]:=[# 962280.1 [[1,"abuvwxyz", function(a,b,u,v,w,x,y,z) return [[a^4,b^3,(a*b)^11,Comm(a,b*a*b*a*b)^2/a^2, Comm(b,a^2), u^3,v^3,w^3,x^3,y^3,z^3, Comm(z,u), Comm(y,u), Comm(x,u), Comm(w,u), Comm(v,u), Comm(z,v), Comm(y,v), Comm(x,v), Comm(w,v), Comm(z,w), Comm(y,w), Comm(x,w), Comm(z,x), Comm(y,x), Comm(z,y), u^a/(v*w^2*y*z^2), v^a/(v^2*x*y^2), w^a/(w*x), x^a/(w*x^2), y^a/(v^2*w*x*y), z^a/(u*v*x), u^b/z, v^b/w, w^b/x, x^b/v, y^b/u, z^b/y], [[a^2,a*b,((b*a)^2*b)^2*a*b^2,u]]]; end, [36]], "L2(11) 2^1 3^6",[18,6,1],1, 5,[36]] ]; PERFGRP[326]:=[# 967680.1 [[1,"abduvwxyz", function(a,b,d,u,v,w,x,y,z) return [[a^6*d^-1,b^4*d^-1,(a*b)^7,(a*b)^2*a*b^2*( a*b*a*b^-1)^2*(a*b)^2 *(a*b^-1)^2*a*b*a*b^-1*a^2*d, a^2*d*b*(a^2*d)^-1*b^-1,d^2, a^-1*d*a*d^-1,b^-1*d*b*d^-1, u^-1*d*u*d^-1,v^-1*d*v*d^-1, w^-1*d*w*d^-1,x^-1*d*x*d^-1, y^-1*d*y*d^-1,z^-1*d*z*d^-1,u^2, v^2,w^2,x^2,y^2,z^2,u^-1*v^-1*u*v, u^-1*w^-1*u*w,u^-1*x^-1*u*x, u^-1*y^-1*u*y,u^-1*z^-1*u*z, v^-1*w^-1*v*w,v^-1*x^-1*v*x, v^-1*y^-1*v*y,v^-1*z^-1*v*z, w^-1*x^-1*w*x,w^-1*y^-1*w*y, w^-1*z^-1*w*z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, a^-1*u*a*u^-1,a^-1*v*a*v^-1, a^-1*w*a*y^-1,a^-1*x*a*x^-1, a^-1*y*a*w^-1, a^-1*z*a*(u*v*w*x*y*z)^-1, b^-1*u*b*w^-1,b^-1*v*b*z^-1, b^-1*w*b*v^-1,b^-1*x*b*y^-1, b^-1*y*b*x^-1,b^-1*z*b*u^-1], [[a^3,(b^-1*a)^2*(b*a)^2*b^2*a*b*a,u], [b^2*a*b^-1*(a*b*a*b*b)^2*(a*b)^2, b*(a*b^-1)^2*a*b^2*(a*b)^2,a^2*d,y*z], [a*b, b*a*b*a*b^2*a*b^-1*a*b*a*b^-1*a*b*a *b^2*d,a^2*d,u]]]; end, [45,14,240],[[1,2]]], "A7 3^1 x 2^1 x 2^6",[23,7,1],6, 8,[45,14,240]], # 967680.2 [[1,"abuvwxyze", function(a,b,u,v,w,x,y,z,e) return [[a^6,b^4,(a*b)^7,(a*b)^2*a*b^2*(a*b*a*b^-1)^2 *(a*b)^2*(a*b^-1)^2*a*b*a*b^-1 *a^2,a^2*b*a^(-1*2)*b^-1,e^2, u^-1*e*u*e^-1,v^-1*e*v*e^-1, w^-1*e*w*e^-1,x^-1*e*x*e^-1, y^-1*e*y*e^-1,z^-1*e*z*e^-1, u^2*e^-1,v^2*e^-1,w^2*e^-1, x^2*e^-1,y^2*e^-1,z^2*e^-1, u^-1*v^-1*u*v*e^-1, u^-1*w^-1*u*w*e^-1, u^-1*x^-1*u*x*e^-1, u^-1*y^-1*u*y*e^-1, u^-1*z^-1*u*z*e^-1, v^-1*w^-1*v*w*e^-1, v^-1*x^-1*v*x*e^-1, v^-1*y^-1*v*y*e^-1, v^-1*z^-1*v*z*e^-1, w^-1*x^-1*w*x*e^-1, w^-1*y^-1*w*y*e^-1, w^-1*z^-1*w*z*e^-1, x^-1*y^-1*x*y*e^-1, x^-1*z^-1*x*z*e^-1, y^-1*z^-1*y*z*e^-1, a^-1*u*a*u^-1,a^-1*v*a*v^-1, a^-1*w*a*(y*e)^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*e)^-1, a^-1*z*a*(u*v*w*x*y*z*e)^-1, a^-1*e*a*e^-1,b^-1*u*b*w^-1, b^-1*v*b*z^-1,b^-1*w*b*v^-1, b^-1*x*b*(y*e)^-1,b^-1*y*b*(x*e)^-1, b^-1*z*b*u^-1,b^-1*e*b*e^-1], [[a^3,(b^-1*a)^2*(b*a)^2*b^2*a*b*a,u],[a,b]]]; end, [45,128],[[1,2],[1,-2]]], "A7 3^1 x ( 2^6 C 2^1 )",[23,7,2],6, 8,[45,128]], # 967680.3 [[1,"abduvwxyz", function(a,b,d,u,v,w,x,y,z) return [[a^6*d^-1,b^4*d^-1,(a*b)^7,(a*b)^2*a*b^2*( a*b*a*b^-1)^2*(a*b)^2 *(a*b^-1)^2*a*b*a*b^-1*a^2*d, a^2*d*b*(a^2*d)^-1*b^-1,d^2, a^-1*d*a*d^-1,b^-1*d*b*d^-1, u^-1*d*u*d^-1,v^-1*d*v*d^-1, w^-1*d*w*d^-1,x^-1*d*x*d^-1, y^-1*d*y*d^-1,z^-1*d*z*d^-1, u^2*d^-1,v^2*d^-1,w^2*d^-1, x^2*d^-1,y^2*d^-1,z^2*d^-1, u^-1*v^-1*u*v*d^-1, u^-1*w^-1*u*w*d^-1, u^-1*x^-1*u*x*d^-1, u^-1*y^-1*u*y*d^-1, u^-1*z^-1*u*z*d^-1, v^-1*w^-1*v*w*d^-1, v^-1*x^-1*v*x*d^-1, v^-1*y^-1*v*y*d^-1, v^-1*z^-1*v*z*d^-1, w^-1*x^-1*w*x*d^-1, w^-1*y^-1*w*y*d^-1, w^-1*z^-1*w*z*d^-1, x^-1*y^-1*x*y*d^-1, x^-1*z^-1*x*z*d^-1, y^-1*z^-1*y*z*d^-1, a^-1*u*a*u^-1,a^-1*v*a*v^-1, a^-1*w*a*(y*d)^-1,a^-1*x*a*x^-1, a^-1*y*a*(w*d)^-1, a^-1*z*a*(u*v*w*x*y*z*d)^-1, b^-1*u*b*w^-1,b^-1*v*b*z^-1, b^-1*w*b*v^-1,b^-1*x*b*(y*d)^-1, b^-1*y*b*(x*d)^-1,b^-1*z*b*u^-1], [[a^3,(b^-1*a)^2*(b*a)^2*b^2*a*b*a,w], [a*b,b*a*b*a*b^2*a*b^-1*a*b*a*b^-1*a*b *a*b^2*d,a^2*d,x*y*z*d]]]; end, [45,1920],[[1,2],[1,-2]]], "A7 3^1 x ( 2^6 C N 2^1 )",[23,7,3],6, 8,[45,1920]], # 967680.4 [[1,"abdef", function(a,b,d,e,f) return [[a^2,b^4*(e^2*f^2)^-1,(a*b)^7*d^-1*e,(a^-1 *b^-1*a*b)^5*(e^2*f^2)^-1, (a*b^2)^5*(e*f)^-1,(a*b*a*b*a*b^3)^5 *(e^2*f^-1)^-1, (a*b*a*b*a*b^2*a*b^-1)^5*d^(-1*2),d^3, a^-1*d*a*d^-1,b^-1*d*b*d^-1,e^4, f^4,e^-1*f^-1*e*f,a^-1*e*a*e^-1, a^-1*f*a*f^-1,b^-1*e*b*e^-1, b^-1*f*b*f^-1], [[a*b*a,b^2*a*b^-1*a*b*a*b^2*a*b*d], [a,b*a*b*a*b^-1*a*b^2*f^-1], [a*e^2,b^-1*a*b^-1*a*b*a*b^2]]]; end, [63,224,224],[[1,2],[6,6]]], "L3(4) 3^1 x ( 2^1 A 2^1 ) x ( 2^1 A 2^1 )",[27,4,1],-48, 20,[63,224,224]], # 967680.5 [[2,1920,1,504,1], "( A5 x L2(8) ) # 2^5 [1]",[35,5,1],2, [1,4],[12,9]], # 967680.6 [[2,1920,2,504,1], "( A5 x L2(8) ) # 2^5 [2]",[35,5,2],2, [1,4],[24,9]], # 967680.7 [[2,1920,3,504,1], "( A5 x L2(8) ) # 2^5 [3]",[35,5,3],2, [1,4],[16,24,9]], # 967680.8 [[2,1920,4,504,1], "( A5 x L2(8) ) # 2^5 [4]",[35,5,4],1, [1,4],[80,9]], # 967680.9 [[2,1920,5,504,1], "( A5 x L2(8) ) # 2^5 [5]",[35,5,5],2, [1,4],[10,24,9]], # 967680.10 [[2,1920,6,504,1], "( A5 x L2(8) ) # 2^5 [6]",[35,5,6],2, [1,4],[80,9]], # 967680.11 [[2,1920,7,504,1], "( A5 x L2(8) ) # 2^5 [7]",[35,5,7],2, [1,4],[32,9]], # 967680.12 [[2,168,1,5760,1], "( L3(2) x A6 ) # 2^4 [1]",[37,4,1],1, [2,3],[7,16]], # 967680.13 [[2,2688,1,360,1], "( L3(2) x A6 ) # 2^4 [2]",[37,4,2],2, [2,3],[8,16,6]], # 967680.14 [[2,2688,2,360,1], "( L3(2) x A6 ) # 2^4 [3]",[37,4,3],2, [2,3],[16,6]], # 967680.15 [[2,2688,3,360,1], "( L3(2) x A6 ) # 2^4 [4]",[37,4,4],2, [2,3],[16,14,6]], # 967680.16 [[2,1344,1,720,1], "( L3(2) x A6 ) # 2^4 [5]",[37,4,5],2, [2,3],[8,80]], # 967680.17 [[2,1344,2,720,1], "( L3(2) x A6 ) # 2^4 [6]",[37,4,6],2, [2,3],[14,80]], # 967680.18 [[3,2688,1,720,1,"d1","d2"], "( L3(2) x A6 ) # 2^4 [7]",[37,4,7],2, [2,3],[320,640]], # 967680.19 [[3,2688,2,720,1,"e1","d2"], "( L3(2) x A6 ) # 2^4 [8]",[37,4,8],2, [2,3],640], # 967680.20 [[3,2688,3,720,1,"d1","d2"], "( L3(2) x A6 ) # 2^4 [9]",[37,4,9],2, [2,3],[640,560]] ]; PERFGRP[327]:=[# 976500.1 [[1,"abc", function(a,b,c) return [[c^62,b^5,b*c^-1*b*c*(c^-1*b*c*b)^-1,c^(-1 *3)*b*c^3 *(b^-1*c^-1*b^2*c^-1*b^-1*c^2) ^-1,a^2,c*a*c*a^-1,(b*a)^3, b^3*c*b^2*c^2*a*b^3*c*b*a*c*b^-1*c^(-1*4) *b^(-1*2)*a],[[b,c]]]; end, [126]], "L2(125)",22,-1, 55,126] ]; PERFGRP[328]:=[# 979200.1 [[1,"ab", function(a,b) return [[a^2,b^5,(a*b)^15,(a^-1*b^-1*a*b)^5,(a*b^2)^17, (a^-1*b^(-1*2)*a*b^2)^2,(a*b*a*b*a*b^(-1*2))^4, (a*b*a*b^2)^5], [[b*(b*a)^3*b^-1*a,(a*b^-1*a*b)^2*b]]]; end, [85]], "Sp4(4)",28,-1, 56,85] ]; PERFGRP[329]:=[# 979776.1 [[4,1344,1,122472,1,168], "L3(2) # 2^3 3^6 [1]",12,1, 2,[8,63]], # 979776.2 [[4,1344,2,122472,1,168], "L3(2) # 2^3 3^6 [2]",12,1, 2,[14,63]], # 979776.3 [[4,1344,1,122472,2,168], "L3(2) # 2^3 3^6 [3]",12,1, 2,[8,21]], # 979776.4 [[4,1344,2,122472,2,168], "L3(2) # 2^3 3^6 [4]",12,1, 2,[14,21]] ]; PERFGRP[330]:=fail; # 983040, A5 # 2^14 PERFGRP[331]:=[# 987840.1 [[2,60,1,16464,1], "A5 x L3(2) 2^1 # 7^2",[32,2,2],1, [1,2],[5,49]] ]; ############################################################################# ## #E perf12.grp . . . . . . . . . . . . . . . . . . . . . . . . . ends here ## gap-4r6p5/grp/perf5.grp0000644000175000017500000007467112172557252013503 0ustar billbill############################################################################# ## #W perf5.grp GAP Groups Library Volkmar Felsch ## Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains the perfect groups of sizes 32256-43008 ## All data is based on Holt/Plesken: Perfect Groups, OUP 1989 ## PERFGRP[72]:=[# 32256.1 [[1,"abcuvwxyz", function(a,b,c,u,v,w,x,y,z) return [[a^2,b^3,(a*b)^7,b^-1*(a*b)^3*c^-1,b^-1*c ^-1*b*c^-1*a^-1*c*b^-1 *c*b*a,u^2,v^2,w^2,x^2,y^2,z^2, u^-1*v^-1*u*v,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*u*a*(u*x)^-1, a^-1*v*a*(v*y)^-1,a^-1*w*a*(w*z)^-1, a^-1*x*a*x^-1,a^-1*y*a*y^-1, a^-1*z*a*z^-1,b^-1*u*b*(x*y)^-1, b^-1*v*b*(y*z)^-1, b^-1*w*b*(x*y*z)^-1, b^-1*x*b*(v*w*x)^-1, b^-1*y*b*(u*v*w*y)^-1, b^-1*z*b*(u*w*z)^-1,c^-1*u*c*v^-1, c^-1*v*c*w^-1,c^-1*w*c*(u*v)^-1, c^-1*x*c*(x*z)^-1,c^-1*y*c*x^-1, c^-1*z*c*y^-1],[[a,b]]]; end, [64]], "L2(8) 2^6",[16,6,1],1, 4,64], # 32256.2 [[1,"abcuvwxyz", function(a,b,c,u,v,w,x,y,z) return [[a^2,b^3,(a*b)^7,b^-1*(a*b)^3*c^-1,b^-1*c ^-1*b*c^-1*a^-1*c*b^-1 *c*b*a*(y*z)^-1,u^2,v^2,w^2,x^2,y^2,z^2, u^-1*v^-1*u*v,u^-1*w^-1*u*w, u^-1*x^-1*u*x,u^-1*y^-1*u*y, u^-1*z^-1*u*z,v^-1*w^-1*v*w, v^-1*x^-1*v*x,v^-1*y^-1*v*y, v^-1*z^-1*v*z,w^-1*x^-1*w*x, w^-1*y^-1*w*y,w^-1*z^-1*w*z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*u*a*(u*x)^-1, a^-1*v*a*(v*y)^-1,a^-1*w*a*(w*z)^-1, a^-1*x*a*x^-1,a^-1*y*a*y^-1, a^-1*z*a*z^-1,b^-1*u*b*(x*y)^-1, b^-1*v*b*(y*z)^-1, b^-1*w*b*(x*y*z)^-1, b^-1*x*b*(v*w*x)^-1, b^-1*y*b*(u*v*w*y)^-1, b^-1*z*b*(u*w*z)^-1,c^-1*u*c*v^-1, c^-1*v*c*w^-1,c^-1*w*c*(u*v)^-1, c^-1*x*c*(x*z)^-1,c^-1*y*c*x^-1, c^-1*z*c*y^-1],[[a*v*w,c,x]]]; end, [72]], "L2(8) N 2^6",[16,6,2],1, 4,72] ]; PERFGRP[73]:=[# 32736.1 [[1,"abc", function(a,b,c) return [[c^31,b^2,c^(-1*5)*b*c^2*b*c^3*b^-1,a^2,(a*c)^2, (a*b)^3],[[b,c]]]; end, [33]], "L2(32)",22,-1, 24,33] ]; PERFGRP[74]:=[# 34440.1 [[1,"abc", function(a,b,c) return [[c^20,c*b^8*c^-1*b^-1,b^41,a^2,c*a*c*a^-1, (b*a)^3,c^-1*(b*c*a)^4*b*a],[[b,c]]]; end, [42]], "L2(41)",22,-1, 25,42] ]; PERFGRP[75]:=[# 34560.1 [[1,"abcstuve", function(a,b,c,s,t,u,v,e) return [[b^3,c^3,(b*c)^4,(b*c^-1)^5,a^-1*b^-1*c*b *c*b^-1*c*b*c^-1,e^2, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v,s^2, t^2,u^2,v^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u*e)^-1, c^-1*v*c*(s*t*u*v)^-1], [[a^3,c*a^2,s],[a,c,v]]]; end, [18,12]], "A6 3^1 x 2^4 E 2^1",[13,5,1],6, 3,[18,12]], # 34560.2 [[1,"abcstuve", function(a,b,c,s,t,u,v,e) return [[b^3,c^3,(b*c)^4*e^-1,(b*c^-1)^5,a^-1*b^(-1 *1)*c*b*c*b^-1*c*b*c^-1,e^2, e^-1*s^-1*e*s,e^-1*t^-1*e*t, e^-1*u^-1*e*u,e^-1*v^-1*e*v,s^2, t^2,u^2,v^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,b^-1*s*b*(t*v*e)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u*e)^-1, c^-1*v*c*(s*t*u*v)^-1], [[a^3,c*a^2,s],[c*b*a*e,b,s]]]; end, [18,80]], "A6 3^1 x 2^4 E N 2^1",[13,5,2],6, 3,[18,80]], # 34560.3 [[1,"abcdstuv", function(a,b,c,d,s,t,u,v) return [[b^3,c^3,(b*c)^4*d^-1,(b*c^-1)^5,a^-1*b^(-1 *1)*c*b*c*b^-1*c*b*c^-1,d^2, d^-1*b^-1*d*b,d^-1*c^-1*d*c,s^2, t^2,u^2,v^2,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, t^-1*u^-1*t*u,t^-1*v^-1*t*v, u^-1*v^-1*u*v,a^-1*s*a*u^-1, a^-1*t*a*v^-1,a^-1*u*a*s^-1, a^-1*v*a*t^-1,b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u)^-1, c^-1*v*c*(s*t*u*v)^-1], [[a^3,c*a^2,s],[b,c],[c*b*a*d,b,s]]]; end, [18,16,80],[0,[2,3]]], "A6 3^1 x 2^1 x 2^4",[13,5,3],6, 3,[18,16,80]], # 34560.4 [[1,"abcdstuv", function(a,b,c,d,s,t,u,v) return [[b^3,c^3*(s*v)^-1,(b*c)^4*(d*s)^-1,(b*c^-1) ^5,a^-1*b^-1*c*b*c*b^-1*c*b*c^-1, d^2,b^-1*d*b*(d*u*v)^-1, c^-1*d*c*(d*t*u)^-1,s^2,t^2,u^2,v^2, s^-1*t^-1*s*t,s^-1*u^-1*s*u, s^-1*v^-1*s*v,t^-1*u^-1*t*u, t^-1*v^-1*t*v,u^-1*v^-1*u*v, a^-1*s*a*u^-1,a^-1*t*a*v^-1, a^-1*u*a*s^-1,a^-1*v*a*t^-1, b^-1*s*b*(t*v)^-1, b^-1*t*b*(s*t*u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, c^-1*s*c*(t*u)^-1,c^-1*t*c*t^-1, c^-1*u*c*(s*u)^-1, c^-1*v*c*(s*t*u*v)^-1], [[a^3,c*a^2,s],[c*b*a*u,b,c^-1*a*c*u,t]]]; end, [18,80]], "A6 3^1 x 2^1 E 2^4",[13,5,4],3, 3,[18,80]] ]; PERFGRP[76]:=[# 37500.1 [[1,"abxyzd", function(a,b,x,y,z,d) return [[a^2,b^3,(a*b)^5,x^5,y^5,z^5,d^5,x^-1*y^-1*x *y,x^-1*z^-1*x*z,y^-1*z^-1*y*z, x^-1*d^-1*x*d,y^-1*d^-1*y*d, z^-1*d^-1*z*d,a^-1*d^-1*a*d, b^-1*d^-1*b*d,a^-1*x*a*z^-1*d, a^-1*y*a*y*d^-1,a^-1*z*a*x^-1 *d^-1,b^-1*x*b*z^-1, b^-1*y*b*(y^-1*z)^-1, b^-1*z*b*(x*y^(-1*2)*z)^-1], [[b,a*b*a*b^-1*a,x]]]; end, [25]], "A5 5^3 E 5^1",[3,4,1],5, 1,25] ]; PERFGRP[77]:=[# 39600.1 [[1,"abcd", function(a,b,c,d) return [[a^2,b^3,(a*b)^5,c^2,d^3,(c*d)^11,(c*d*c*d*c*d*c*d*c *d^-1*c*d^-1*c*d^-1*c *d^-1*c*d^-1)^2,a^-1*c^-1*a*c, a^-1*d^-1*a*d,b^-1*c^-1*b*c, b^-1*d^-1*b*d], [[b,a*b*a*b^-1*a,c,d],[a,b,d,c*d*c*d^-1*c]]] ; end, [5,11]], "A5 x L2(11)",[36,0,1],1, [1,5],[5,11]] ]; PERFGRP[78]:=[# 39732.1 [[1,"abc", function(a,b,c) return [[c^21,c*b^9*c^-1*b^-1,b^43,a^2,c*a*c*a^-1, (b*a)^3],[[b,c]]]; end, [44]], "L2(43)",22,-1, 26,44] ]; PERFGRP[79]:=[# 40320.1 [[1,"abcd", function(a,b,c,d) return [[a^4,b^3,(a*b)^5,a^2*b*a^2*b^-1,c^4,d^3,(c*d)^7, (c^-1*d^-1*c*d)^4*c^2,c^2*d*c^2*d^-1, a^-1*c^-1*a*c,a^-1*d^-1*a*d, b^-1*c^-1*b*c,b^-1*d^-1*b*d], [[a*b,c,d], [a,b,c*d,d*c*d^-1*c*d^-1*c*d*c*d^-1]] ]; end, [24,16]], "A5 2^1 x L3(2) 2^1",[31,2,1],4, [1,2],[24,16]], # 40320.2 [[1,"abwxyz", function(a,b,w,x,y,z) return [[a^2,b^4,(a*b)^7,(a*b)^2*a*b^2*(a*b*a*b^-1)^2 *(a*b)^2*(a*b^-1)^2*a*b*a*b^-1,w^2, x^2,y^2,z^2,w*x*w*x,w*y*w*y,w*z*w*z,x*y*x*y, x*z*x*z,y*z*y*z,a^-1*w*a*y^-1, a^-1*x*a*z^-1,a^-1*y*a*w^-1, a^-1*z*a*x^-1,b^-1*w*b*(w*x*y*z)^-1 ,b^-1*x*b*y^-1,b^-1*y*b*(w*x)^-1, b^-1*z*b*(w*z)^-1],[[a,b]]]; end, [16]], "A7 2^4",[23,4,1],1, 8,16], # 40320.3 [[1,"abd", function(a,b,d) return [[a^2*d,b^4,(a*b)^15,(a*b^2)^6,(a*b)^2*(a*b^-1*a *b^2)^2*a*b^-1*(a*b)^2*(a*b^-1)^7, a*b*a*b^-1*a*b*a*b^2*(a*b^-1)^5*a*b^2 *(a*b^-1)^5*a*b^2,d^2,d^-1*a^-1*d*a ,d^-1*b^-1*d*b],[[b,a*b^2*a]]]; end, [240]], "A8 2^1",[26,1,1],-2, 19,240], # 40320.4 [[1,"abe", function(a,b,e) return [[a^2,b^4,(a*b)^7*e,(a*b^2)^5*e^-1,(a^-1*b^(-1 *1)*a*b)^5,(a*b*a*b*a*b^3)^5, (a*b*a*b*a*b^2*a*b^-1)^5,e^2, a^-1*e*a*e^-1,b^-1*e*b*e^-1], [[a*e,b*a*b*a*b^-1*a*b^2]]]; end, [112]], "L3(4) 2^1",[27,1,1],-2, 20,112] ]; PERFGRP[80]:=[# 43008.1 [[1,"abdxyzeXYZ", function(a,b,d,x,y,z,e,X,Y,Z) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *d^-1,d^2,x^2,y^2,z^2,e^2,X^2,Y^2,Z^2, X^-1*x^-1*X*x,X^-1*y^-1*X*y, X^-1*z^-1*X*z,X^-1*d^-1*X*d, X^-1*e^-1*X*e,Y^-1*x^-1*Y*x, Y^-1*y^-1*Y*y,Y^-1*z^-1*Y*z, Y^-1*d^-1*Y*d,Y^-1*e^-1*Y*e, Z^-1*x^-1*Z*x,Z^-1*y^-1*Z*y, Z^-1*z^-1*Z*z,Z^-1*d^-1*Z*d, Z^-1*e^-1*Z*e,X^-1*Y^-1*X*Y, X^-1*Z^-1*X*Z,Y^-1*Z^-1*Y*Z, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,x^-1*e^-1*x*e, y^-1*e^-1*y*e,z^-1*e^-1*z*e, d^-1*x*d*(x*X)^-1,d^-1*y*d*(y*Y)^-1, d^-1*z*d*(z*Z)^-1,d^-1*e^-1*d*e, a^-1*x*a*(z*e*X*Z)^-1, a^-1*y*a*(x*y*z*X*Y*Z)^-1, a^-1*z*a*(x*e*Y)^-1,a^-1*X*a*Z^-1, a^-1*Y*a*(X*Y*Z)^-1,a^-1*Z*a*X^-1, a^-1*e^-1*a*(e*Y*Z)^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,b^-1*d^-1*b*d, b^-1*e^-1*b*e,b^-1*X*b*Y^-1, b^-1*Y*b*(X*Y)^-1,b^-1*Z*b*Z^-1], [[a,b]]]; end, [128]], "L3(2) 2^1 ( 2^3 E 2^1 E 2^3 )",[8,8,1],1, 2,128], # 43008.2 [[1,"abdxyzeXYZ", function(a,b,d,x,y,z,e,X,Y,Z) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *d^-1,d^2,x^2*X^-1,y^2*Y^-1, z^2*Z^-1,e^2,X^2,Y^2,Z^2,X^-1*x^-1*X*x, X^-1*y^-1*X*y,X^-1*z^-1*X*z, X^-1*d^-1*X*d,X^-1*e^-1*X*e, Y^-1*x^-1*Y*x,Y^-1*y^-1*Y*y, Y^-1*z^-1*Y*z,Y^-1*d^-1*Y*d, Y^-1*e^-1*Y*e,Z^-1*x^-1*Z*x, Z^-1*y^-1*Z*y,Z^-1*z^-1*Z*z, Z^-1*d^-1*Z*d,Z^-1*e^-1*Z*e, X^-1*Y^-1*X*Y,X^-1*Z^-1*X*Z, Y^-1*Z^-1*Y*Z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, x^-1*e^-1*x*e,y^-1*e^-1*y*e, z^-1*e^-1*z*e,d^-1*x*d*(x*X)^-1, d^-1*y*d*(y*Y)^-1,d^-1*z*d*(z*Z)^-1, d^-1*e^-1*d*e, a^-1*x*a*(z*e*X*Y*Z)^-1, a^-1*y*a*(x*y*z*X*Y*Z)^-1, a^-1*z*a*(x*e*X*Z)^-1,a^-1*X*a*Z^-1 ,a^-1*Y*a*(X*Y*Z)^-1,a^-1*Z*a*X^-1 ,a^-1*e^-1*a*(e*Y*Z)^-1, b^-1*x*b*(y*X)^-1, b^-1*y*b*(x*y*Z)^-1, b^-1*z*b*(z*X*Y)^-1,b^-1*d^-1*b*d, b^-1*e^-1*b*e,b^-1*X*b*Y^-1, b^-1*Y*b*(X*Y)^-1,b^-1*Z*b*Z^-1], [[a,b]]]; end, [128]], "L3(2) 2^1 ( 2^3 E 2^1 E 2^3 ) A",[8,8,2],1, 2,128], # 43008.3 [[1,"abdxyzeXYZ", function(a,b,d,x,y,z,e,X,Y,Z) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *(d*Y*Z)^-1,d^2,x^2*X^-1,y^2*Y^-1, z^2*Z^-1,e^2,X^2,Y^2,Z^2,X^-1*x^-1*X*x, X^-1*y^-1*X*y,X^-1*z^-1*X*z, X^-1*d^-1*X*d,X^-1*e^-1*X*e, Y^-1*x^-1*Y*x,Y^-1*y^-1*Y*y, Y^-1*z^-1*Y*z,Y^-1*d^-1*Y*d, Y^-1*e^-1*Y*e,Z^-1*x^-1*Z*x, Z^-1*y^-1*Z*y,Z^-1*z^-1*Z*z, Z^-1*d^-1*Z*d,Z^-1*e^-1*Z*e, X^-1*Y^-1*X*Y,X^-1*Z^-1*X*Z, Y^-1*Z^-1*Y*Z,x^-1*y^-1*x*y, x^-1*z^-1*x*z,y^-1*z^-1*y*z, x^-1*e^-1*x*e,y^-1*e^-1*y*e, z^-1*e^-1*z*e,d^-1*x*d*(x*X)^-1, d^-1*y*d*(y*Y)^-1,d^-1*z*d*(z*Z)^-1, d^-1*e^-1*d*e, a^-1*x*a*(z*e*X*Y*Z)^-1, a^-1*y*a*(x*y*z*X*Y*Z)^-1, a^-1*z*a*(x*e*X*Z)^-1,a^-1*X*a*Z^-1 ,a^-1*Y*a*(X*Y*Z)^-1,a^-1*Z*a*X^-1 ,a^-1*e^-1*a*(e*Y*Z)^-1, b^-1*x*b*(y*X)^-1, b^-1*y*b*(x*y*Z)^-1, b^-1*z*b*(z*X*Y)^-1,b^-1*d^-1*b*d, b^-1*e^-1*b*e,b^-1*X*b*Y^-1, b^-1*Y*b*(X*Y)^-1,b^-1*Z*b*Z^-1], [[b,d,x*Z,e*Z]]]; end, [224]], "L3(2) 2^1 ( 2^3 E 2^1 E N 2^3 ) A",[8,8,3],1, 2,224], # 43008.4 [[1,"abdxyzXYZf", function(a,b,d,x,y,z,X,Y,Z,f) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *d^-1,d^2,d^-1*b^-1*d*b,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,X^2,Y^2,Z^2, X^-1*Y^-1*X*Y,X^-1*Z^-1*X*Z, Y^-1*Z^-1*Y*Z,f^2,f^-1*x^-1*f*x, f^-1*y^-1*f*y,f^-1*z^-1*f*z, f^-1*X^-1*f*X,f^-1*Y^-1*f*Y, f^-1*Z^-1*f*Z,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,a^-1*X*a*(Z*f)^-1, a^-1*Y*a*(X*Y*Z)^-1, a^-1*Z*a*(X*f)^-1,a^-1*f^-1*a*f, b^-1*X*b*Y^-1,b^-1*Y*b*(X*Y)^-1, b^-1*Z*b*Z^-1,b^-1*f^-1*b*f, x^-1*X*x*X^-1,x^-1*Y*x*Y^-1, x^-1*Z*x*Z^-1,y^-1*X*y*X^-1, y^-1*Y*y*Y^-1,y^-1*Z*y*Z^-1, z^-1*X*z*X^-1,z^-1*Y*z*Y^-1, z^-1*Z*z*Z^-1], [[a,b,x],[a,b,X],[a*b,b*a*b^-1*a*b^-1*a*b*a *b^-1,x,X]]]; end, [16,8,16]], "L3(2) 2^1 x 2^3 x ( 2^3 E 2^1 )",[8,8,4],4, 2,[16,8,16]], # 43008.5 [[1,"abxyzeXYZf", function(a,b,x,y,z,e,X,Y,Z,f) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,x^2,y^2, z^2,x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,X^2,Y^2,Z^2, X^-1*Y^-1*X*Y,X^-1*Z^-1*X*Z, Y^-1*Z^-1*Y*Z,e^2,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z, e^-1*X^-1*e*X,e^-1*Y^-1*e*Y, e^-1*Z^-1*e*Z,e^-1*f^-1*e*f,f^2, f^-1*x^-1*f*x,f^-1*y^-1*f*y, f^-1*z^-1*f*z,f^-1*X^-1*f*X, f^-1*Y^-1*f*Y,f^-1*Z^-1*f*Z, a^-1*x*a*(z*e)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e)^-1,a^-1*e*a*e^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,b^-1*e*b*e^-1, a^-1*X*a*(Z*f)^-1, a^-1*Y*a*(X*Y*Z)^-1, a^-1*Z*a*(X*f)^-1,a^-1*f^-1*a*f, b^-1*X*b*Y^-1,b^-1*Y*b*(X*Y)^-1, b^-1*Z*b*Z^-1,b^-1*f^-1*b*f, x^-1*X*x*X^-1,x^-1*Y*x*Y^-1, x^-1*Z*x*Z^-1,y^-1*X*y*X^-1, y^-1*Y*y*Y^-1,y^-1*Z*y*Z^-1, z^-1*X*z*X^-1,z^-1*Y*z*Y^-1, z^-1*Z*z*Z^-1],[[a,b,x],[a,b,X]]]; end, [16,16]], "L3(2) ( 2^3 E 2^1 ) x ( 2^3 E 2^1 )",[8,8,5],4, 2,[16,16]], # 43008.6 [[1,"abdxyzXYZe", function(a,b,d,x,y,z,X,Y,Z,e) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *(d*Y*Z)^-1,d^2,d^-1*b^-1*d*b,x^2,y^2, z^2,x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,X^2,Y^2,Z^2, X^-1*Y^-1*X*Y,X^-1*Z^-1*X*Z, Y^-1*Z^-1*Y*Z,e^2,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z, e^-1*X^-1*e*X,e^-1*Y^-1*e*Y, e^-1*Z^-1*e*Z,a^-1*x*a*(z*e)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e)^-1,b^-1*x*b*y^-1, b^-1*y*b*(x*y)^-1,b^-1*z*b*z^-1, a^-1*X*a*Z^-1,a^-1*Y*a*(X*Y*Z)^-1, a^-1*Z*a*X^-1,a^-1*e^-1*a*e, b^-1*X*b*Y^-1,b^-1*Y*b*(X*Y)^-1, b^-1*Z*b*Z^-1,b^-1*e^-1*b*e, x^-1*X*x*X^-1,x^-1*Y*x*Y^-1, x^-1*Z*x*Z^-1,y^-1*X*y*X^-1, y^-1*Y*y*Y^-1,y^-1*Z*y*Z^-1, z^-1*X*z*X^-1,z^-1*Y*z*Y^-1, z^-1*Z*z*Z^-1], [[b,a*b*a*b^-1*a,x,z,X],[a,b,X], [a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,x,X]] ]; end, [14,16,16]], "L3(2) 2^1 x ( 2^3 E 2^1 ) x N 2^3",[8,8,6],4, 2,[14,16,16]], # 43008.7 [[1,"abdxyzeXYZ", function(a,b,d,x,y,z,e,X,Y,Z) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *d^-1,d^2,d^-1*b^-1*d*b,e^2, x^2*X^-1,y^2*Y^-1,z^2*Z^-1, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,e^2,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z, a^-1*x*a*(z*e*Y)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e*X*Y*Z)^-1, a^-1*e^-1*a*e,b^-1*x*b*(y*X)^-1, b^-1*y*b*(x*y*Z)^-1, b^-1*z*b*(z*X*Y)^-1,b^-1*e^-1*b*e, a^-1*X*a*Z^-1,a^-1*Y*a*(X*Y*Z)^-1, a^-1*Z*a*X^-1,b^-1*X*b*Y^-1, b^-1*Y*b*(X*Y)^-1,b^-1*Z*b*Z^-1], [[a,b,X],[b,a*b*a*b^-1*a,x*Z], [a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,x, a^2*d^-1]]]; end, [16,28,16]], "L3(2) 2^1 x 2^3 ( E 2^1 x A 2^3 )",[8,8,7],4, 2,[16,28,16]], # 43008.8 [[1,"abdxyzeuvw", function(a,b,d,x,y,z,e,u,v,w) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *d^-1,d^2,d^-1*b^-1*d*b,u^2,v^2,w^2, u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,e^2,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z, e^-1*u^-1*e*u,e^-1*v^-1*e*v, e^-1*w^-1*e*w,a^-1*u*a*(v*w)^-1, a^-1*v*a*v^-1,a^-1*w*a*(u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,a^-1*x*a*(z*e)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e)^-1,a^-1*e*a*e^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,b^-1*e*b*e^-1, u^-1*x*u*x^-1,u^-1*y*u*y^-1, u^-1*z*u*z^-1,v^-1*x*v*x^-1, v^-1*y*v*y^-1,v^-1*z*v*z^-1, w^-1*x*w*x^-1,w^-1*y*w*y^-1, w^-1*z*w*z^-1], [[a,b,x],[a,b,u],[a*b,b*a*b^-1*a*b^-1*a*b*a *b^-1,x,u]]]; end, [8,16,16]], "L3(2) 2^1 x ( 2^3 E 2^1 ) x 2^3'",[8,8,8],4, 2,[8,16,16]], # 43008.9 [[1,"abxyzuvwfg", function(a,b,x,y,z,u,v,w,f,g) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,u^2,v^2, w^2,u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,f^2,f^-1*x^-1*f*x, f^-1*y^-1*f*y,f^-1*z^-1*f*z, f^-1*u^-1*f*u,f^-1*v^-1*f*v, f^-1*w^-1*f*w,g^2,g^-1*x^-1*g*x, g^-1*y^-1*g*y,g^-1*z^-1*g*z, g^-1*u^-1*g*u,g^-1*v^-1*g*v, g^-1*w^-1*g*w,a^-1*u*a*(v*w)^-1, a^-1*v*a*(v*f)^-1, a^-1*w*a*(u*v*f)^-1,a^-1*f*a*f^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,b^-1*f*b*f^-1, a^-1*x*a*z^-1,a^-1*y*a*(x*y*z)^-1, a^-1*z*a*x^-1,a^-1*g*a*g^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,b^-1*g*b*g^-1, u^-1*x*u*x^-1*g^-1, u^-1*y*u*y^-1,u^-1*z*u*z^-1, v^-1*x*v*x^-1,v^-1*y*v*y^-1 *g^-1,v^-1*z*v*z^-1, w^-1*x*w*x^-1,w^-1*y*w*y^-1, w^-1*z*w*z^-1*g^-1],[[a,b,x]]]; end, [32]], "L3(2) ( 2^3 x 2^3' E 2^1 ) C 2^1",[8,8,9],4, 2,32], # 43008.10 [[1,"abdxyzeuvw", function(a,b,d,x,y,z,e,u,v,w) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *d^-1,d^2,d^-1*b^-1*d*b,u^2,v^2,w^2, u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,e^2,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z, e^-1*u^-1*e*u,e^-1*v^-1*e*v, e^-1*w^-1*e*w,a^-1*u*a*(v*w)^-1, a^-1*v*a*(v*e)^-1, a^-1*w*a*(u*v*e)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,a^-1*x*a*(z*e)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e)^-1,a^-1*e*a*e^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,b^-1*e*b*e^-1, u^-1*x*u*x^-1,u^-1*y*u*y^-1, u^-1*z*u*z^-1,v^-1*x*v*x^-1, v^-1*y*v*y^-1,v^-1*z*v*z^-1, w^-1*x*w*x^-1,w^-1*y*w*y^-1, w^-1*z*w*z^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,z,w]]]; end, [32]], "L3(2) 2^8",[8,8,10],4, 2,32], # 43008.11 [[1,"abxyzeuvwf", function(a,b,x,y,z,e,u,v,w,f) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,u^2,v^2, w^2,u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,e^2,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z, e^-1*u^-1*e*u,e^-1*v^-1*e*v, e^-1*w^-1*e*w,f^2,f^-1*x^-1*f*x, f^-1*y^-1*f*y,f^-1*z^-1*f*z, f^-1*u^-1*f*u,f^-1*v^-1*f*v, f^-1*w^-1*f*w,a^-1*u*a*(v*w)^-1, a^-1*v*a*(v*f)^-1, a^-1*w*a*(u*v*f)^-1,a^-1*f*a*f^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,b^-1*f*b*f^-1, a^-1*x*a*(z*e)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e)^-1,a^-1*e*a*e^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,b^-1*e*b*e^-1, u^-1*x*u*x^-1*(e*f)^-1, u^-1*y*u*y^-1,u^-1*z*u*z^-1, v^-1*x*v*x^-1,v^-1*y*v*y^-1 *(e*f)^-1,v^-1*z*v*z^-1, w^-1*x*w*x^-1,w^-1*y*w*y^-1, w^-1*z*w*z^-1*(e*f)^-1], [[a,b,u],[a,b,x]]]; end, [16,16]], "L3(2) 2^8",[8,8,11],4, 2,[16,16]], # 43008.12 [[1,"abxyzeuvwf", function(a,b,x,y,z,e,u,v,w,f) return [[a^2*(e*f)^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *(e*f)^-1,u^2,v^2,w^2,u^-1*v^-1*u*v, u^-1*w^-1*u*w,v^-1*w^-1*v*w,x^2, y^2,z^2,x^-1*y^-1*x*y,x^-1*z^-1*x*z ,y^-1*z^-1*y*z,e^2,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z, e^-1*u^-1*e*u,e^-1*v^-1*e*v, e^-1*w^-1*e*w,f^2,f^-1*x^-1*f*x, f^-1*y^-1*f*y,f^-1*z^-1*f*z, f^-1*u^-1*f*u,f^-1*v^-1*f*v, f^-1*w^-1*f*w,a^-1*u*a*(v*w)^-1, a^-1*v*a*(v*f)^-1, a^-1*w*a*(u*v*f)^-1,a^-1*f*a*f^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,b^-1*f*b*f^-1, a^-1*x*a*(z*e)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e)^-1,a^-1*e*a*e^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,b^-1*e*b*e^-1, u^-1*x*u*x^-1*(e*f)^-1, u^-1*y*u*y^-1,u^-1*z*u*z^-1, v^-1*x*v*x^-1,v^-1*y*v*y^-1 *(e*f)^-1,v^-1*z*v*z^-1, w^-1*x*w*x^-1,w^-1*y*w*y^-1, w^-1*z*w*z^-1*(e*f)^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,w,z], [a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,w,f]] ]; end, [16,128]], "L3(2) 2^8",[8,8,12],4, 2,[16,128]], # 43008.13 [[1,"abdxyzuvwg", function(a,b,d,x,y,z,u,v,w,g) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *d^-1,d^2,d^-1*b^-1*d*b,u^2,v^2,w^2, u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,g^2,g^-1*x^-1*g*x, g^-1*y^-1*g*y,g^-1*z^-1*g*z, g^-1*u^-1*g*u,g^-1*v^-1*g*v, g^-1*w^-1*g*w,a^-1*u*a*(v*w)^-1, a^-1*v*a*v^-1,a^-1*w*a*(u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, a^-1*g*a*g^-1,b^-1*x*b*y^-1, b^-1*y*b*(x*y)^-1,b^-1*z*b*z^-1, b^-1*g*b*g^-1,u^-1*x*u*x^-1 *g^-1,u^-1*y*u*y^-1, u^-1*z*u*z^-1,v^-1*x*v*x^-1, v^-1*y*v*y^-1*g^-1, v^-1*z*v*z^-1,w^-1*x*w*x^-1, w^-1*y*w*y^-1,w^-1*z*w*z^-1 *g^-1], [[a,b,x],[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1 ,x,u]]]; end, [16,16]], "L3(2) 2^8",[8,8,13],4, 2,[16,16]], # 43008.14 [[1,"abxyzeuvwf", function(a,b,x,y,z,e,u,v,w,f) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,u^2,v^2, w^2,u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,e^2,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z, e^-1*u^-1*e*u,e^-1*v^-1*e*v, e^-1*w^-1*e*w,f^2,f^-1*x^-1*f*x, f^-1*y^-1*f*y,f^-1*z^-1*f*z, f^-1*u^-1*f*u,f^-1*v^-1*f*v, f^-1*w^-1*f*w,a^-1*u*a*(v*w)^-1, a^-1*v*a*(v*f)^-1, a^-1*w*a*(u*v*f)^-1,a^-1*f*a*f^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,b^-1*f*b*f^-1, a^-1*x*a*(z*e)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e)^-1,a^-1*e*a*e^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,b^-1*e*b*e^-1, u^-1*x*u*x^-1,u^-1*y*u*y^-1, u^-1*z*u*z^-1,v^-1*x*v*x^-1, v^-1*y*v*y^-1,v^-1*z*v*z^-1, w^-1*x*w*x^-1,w^-1*y*w*y^-1, w^-1*z*w*z^-1],[[a,b,u],[a,b,x]]]; end, [16,16]], "L3(2) 2^8",[8,8,14],4, 2,[16,16]], # 43008.15 [[1,"abxyzeuvwg", function(a,b,x,y,z,e,u,v,w,g) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,u^2,v^2, w^2,u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,e^2,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z, e^-1*u^-1*e*u,e^-1*v^-1*e*v, e^-1*w^-1*e*w,g^2,g^-1*x^-1*g*x, g^-1*y^-1*g*y,g^-1*z^-1*g*z, g^-1*u^-1*g*u,g^-1*v^-1*g*v, g^-1*w^-1*g*w,a^-1*u*a*(v*w)^-1, a^-1*v*a*(v*e)^-1, a^-1*w*a*(u*v*e)^-1,a^-1*g*a*g^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,b^-1*g*b*g^-1, a^-1*x*a*(z*e)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e)^-1,a^-1*e*a*e^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,b^-1*e*b*e^-1, u^-1*x*u*x^-1*g^-1, u^-1*y*u*y^-1,u^-1*z*u*z^-1, v^-1*x*v*x^-1,v^-1*y*v*y^-1 *g^-1,v^-1*z*v*z^-1, w^-1*x*w*x^-1,w^-1*y*w*y^-1, w^-1*z*w*z^-1*g^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,z,w], [a,b,x]]]; end, [16,16]], "L3(2) 2^8",[8,8,15],4, 2,[16,16]], # 43008.16 [[1,"abdxyzuvwf", function(a,b,d,x,y,z,u,v,w,f) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *d^-1,d^2,d^-1*b^-1*d*b,u^2,v^2,w^2, u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,f^2,f^-1*x^-1*f*x, f^-1*y^-1*f*y,f^-1*z^-1*f*z, f^-1*u^-1*f*u,f^-1*v^-1*f*v, f^-1*w^-1*f*w,a^-1*u*a*(v*w)^-1, a^-1*v*a*(v*f)^-1, a^-1*w*a*(u*v*f)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,a^-1*x*a*z^-1, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1, a^-1*f*a*f^-1,b^-1*x*b*y^-1, b^-1*y*b*(x*y)^-1,b^-1*z*b*z^-1, b^-1*f*b*f^-1,u^-1*x*u*x^-1 *d^-1,u^-1*y*u*y^-1, u^-1*z*u*z^-1,v^-1*x*v*x^-1, v^-1*y*v*y^-1*d^-1, v^-1*z*v*z^-1,w^-1*x*w*x^-1, w^-1*y*w*y^-1,w^-1*z*w*z^-1 *d^-1], [[a,b,x],[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1 ,f,u]]]; end, [16,128]], "L3(2) 2^8",[8,8,16],4, 2,[16,128]], # 43008.17 [[1,"abxyzeuvwf", function(a,b,x,y,z,e,u,v,w,f) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,u^2,v^2, w^2,u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,e^2,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z, e^-1*u^-1*e*u,e^-1*v^-1*e*v, e^-1*w^-1*e*w,f^2,f^-1*x^-1*f*x, f^-1*y^-1*f*y,f^-1*z^-1*f*z, f^-1*u^-1*f*u,f^-1*v^-1*f*v, f^-1*w^-1*f*w,a^-1*u*a*(v*w)^-1, a^-1*v*a*(v*f)^-1, a^-1*w*a*(u*v*f)^-1,a^-1*f*a*f^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,b^-1*f*b*f^-1, a^-1*x*a*(z*e)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e)^-1,a^-1*e*a*e^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,b^-1*e*b*e^-1, u^-1*x*u*x^-1*e^-1, u^-1*y*u*y^-1,u^-1*z*u*z^-1, v^-1*x*v*x^-1,v^-1*y*v*y^-1 *e^-1,v^-1*z*v*z^-1, w^-1*x*w*x^-1,w^-1*y*w*y^-1, w^-1*z*w*z^-1*e^-1],[[a,b,u],[a,b,x]]]; end, [16,16]], "L3(2) 2^8",[8,8,17],4, 2,[16,16]], # 43008.18 [[1,"abdxyzeuvw", function(a,b,d,x,y,z,e,u,v,w) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *(d*u*v*w)^-1,d^2,d^-1*b^-1*d*b,u^2, v^2,w^2,u^-1*v^-1*u*v,u^-1*w^-1*u*w ,v^-1*w^-1*v*w,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,e^2,e^-1*u^-1*e*u, e^-1*v^-1*e*v,e^-1*w^-1*e*w, e^-1*x^-1*e*x,e^-1*y^-1*e*y, e^-1*z^-1*e*z,a^-1*u*a*(v*w)^-1, a^-1*v*a*v^-1,a^-1*w*a*(u*v)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,a^-1*x*a*(z*e)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e)^-1,a^-1*e*a*e^-1, b^-1*x*b*y^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*z^-1,b^-1*e*b*e^-1, u^-1*x*u*x^-1,u^-1*y*u*y^-1, u^-1*z*u*z^-1,v^-1*x*v*x^-1, v^-1*y*v*y^-1,v^-1*z*v*z^-1, w^-1*x*w*x^-1,w^-1*y*w*y^-1, w^-1*z*w*z^-1], [[a,b,u],[b,a*b^-1*a*b*a,x,z,u], [a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,x,u]] ]; end, [16,14,16]], "L3(2) 2^1 x ( 2^3 E 2^1 ) x N 2^3'",[8,8,18],4, 2,[16,14,16]], # 43008.19 [[1,"abdxyzuvw", function(a,b,d,x,y,z,u,v,w) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *(d^-1*y*z*u*v*w)^-1,d^4, d^-1*b^-1*d*b,u^2,v^2,w^2, u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,a^-1*u*a*(v*w)^-1, a^-1*v*a*v^-1*d^2, a^-1*w*a*(u*v)^-1*d^2, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,a^-1*x*a*z^-1*d^2, a^-1*y*a*(x*y*z)^-1,a^-1*z*a*x^-1 *d^2,b^-1*x*b*y^-1, b^-1*y*b*(x*y)^-1,b^-1*z*b*z^-1, u^-1*x*u*x^-1,u^-1*y*u*y^-1, u^-1*z*u*z^-1,v^-1*x*v*x^-1, v^-1*y*v*y^-1,v^-1*z*v*z^-1, w^-1*x*w*x^-1,w^-1*y*w*y^-1, w^-1*z*w*z^-1],[[x,y,z,u,v,w]]]; end, [672]], "L3(2) 2^1 ( N 2^3 x N 2^3' ) E 2^1",[8,8,19],4, 2,672], # 43008.20 [[1,"abdxyzeuvw", function(a,b,d,x,y,z,e,u,v,w) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *d^-1,d^2,d^-1*b^-1*d*b,u^2,v^2,w^2, u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2,y^2,z^2, x^-1*y^-1*x*y,x^-1*z^-1*x*z, y^-1*z^-1*y*z,e^2,e^-1*x^-1*e*x, e^-1*y^-1*e*y,e^-1*z^-1*e*z, e^-1*u^-1*e*u,e^-1*v^-1*e*v, e^-1*w^-1*e*w,a^-1*x*a*(z*e)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e)^-1,a^-1*e*a*e^-1, b^-1*x*b*(y*w)^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*(z*u)^-1,b^-1*e*b*e^-1, a^-1*u*a*(v*w)^-1,a^-1*v*a*v^-1, a^-1*w*a*(u*v)^-1,b^-1*u*b*(u*v)^-1, b^-1*v*b*u^-1,b^-1*w*b*w^-1, u^-1*x*u*x^-1,u^-1*y*u*y^-1, u^-1*z*u*z^-1,v^-1*x*v*x^-1, v^-1*y*v*y^-1,v^-1*z*v*z^-1, w^-1*x*w*x^-1,w^-1*y*w*y^-1, w^-1*z*w*z^-1], [[b,a*b*a*b^-1*a,x,w],[a,b,u], [a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,x,u]] ]; end, [56,16,16]], "L3(2) 2^1 x 2^3 ( E 2^1 x E 2^3' )",[8,8,20],4, 2,[56,16,16]], # 43008.21 [[1,"abdxyzuvwf", function(a,b,d,x,y,z,u,v,w,f) return [[a^2*d^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *d^-1,d^2,d^-1*b^-1*d*b,u^2,v^2,w^2, u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2*f^-1,y^2*f^-1, z^2*f^-1,x^-1*y^-1*x*y*f^-1, x^-1*z^-1*x*z*f^-1,y^-1*z^-1*y *z,f^2,f^-1*x^-1*f*x,f^-1*y^-1*f*y ,f^-1*z^-1*f*z,f^-1*u^-1*f*u, f^-1*v^-1*f*v,f^-1*w^-1*f*w, a^-1*x*a*z^-1,a^-1*y*a*(x*y*z)^-1, a^-1*z*a*x^-1,a^-1*f*a*f^-1, b^-1*x*b*(y*w)^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*(z*u)^-1,b^-1*f*b*f^-1, a^-1*u*a*(v*w)^-1,a^-1*v*a*(v*f)^-1, a^-1*w*a*(u*v*f)^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,u^-1*x*u*x^-1 *f^-1,u^-1*y*u*y^-1, u^-1*z*u*z^-1,v^-1*x*v*x^-1, v^-1*y*v*y^-1*f^-1, v^-1*z*v*z^-1,w^-1*x*w*x^-1, w^-1*y*w*y^-1,w^-1*z*w*z^-1 *f^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,d,u], [a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,x,u]] ]; end, [128,16]], "L3(2) 2^8",[8,8,21],4, 2,[128,16]], # 43008.22 [[1,"abxyzeuvwf", function(a,b,x,y,z,e,u,v,w,f) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,u^2,v^2, w^2,u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,x^2*f^-1,y^2*f^-1, z^2*f^-1,x^-1*y^-1*x*y*f^-1, x^-1*z^-1*x*z*f^-1,y^-1*z^-1*y *z,e^2,e^-1*x^-1*e*x,e^-1*y^-1*e*y ,e^-1*z^-1*e*z,e^-1*u^-1*e*u, e^-1*v^-1*e*v,e^-1*w^-1*e*w,f^2, f^-1*x^-1*f*x,f^-1*y^-1*f*y, f^-1*z^-1*f*z,f^-1*u^-1*f*u, f^-1*v^-1*f*v,f^-1*w^-1*f*w, a^-1*u*a*(v*w)^-1,a^-1*v*a*(v*f)^-1, a^-1*w*a*(u*v*f)^-1,a^-1*f*a*f^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,b^-1*f*b*f^-1, a^-1*x*a*(z*e)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e)^-1,a^-1*e*a*e^-1, b^-1*x*b*(y*w)^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*(z*u)^-1,b^-1*e*b*e^-1, u^-1*x*u*x^-1*f^-1, u^-1*y*u*y^-1,u^-1*z*u*z^-1, v^-1*x*v*x^-1,v^-1*y*v*y^-1 *f^-1,v^-1*z*v*z^-1, w^-1*x*w*x^-1,w^-1*y*w*y^-1, w^-1*z*w*z^-1*f^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,u,e], [a*y*z,b,u]]]; end, [128,16]], "L3(2) 2^8",[8,8,22],4, 2,[128,16]], # 43008.23 [[1,"abxyzeuvwf", function(a,b,x,y,z,e,u,v,w,f) return [[a^2*e^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *e^-1,u^2,v^2,w^2,u^-1*v^-1*u*v, u^-1*w^-1*u*w,v^-1*w^-1*v*w, x^2*f^-1,y^2*f^-1,z^2*f^-1, x^-1*y^-1*x*y*f^-1, x^-1*z^-1*x*z*f^-1,y^-1*z^-1*y *z,e^2,e^-1*x^-1*e*x,e^-1*y^-1*e*y ,e^-1*z^-1*e*z,e^-1*u^-1*e*u, e^-1*v^-1*e*v,e^-1*w^-1*e*w,f^2, f^-1*x^-1*f*x,f^-1*y^-1*f*y, f^-1*z^-1*f*z,f^-1*u^-1*f*u, f^-1*v^-1*f*v,f^-1*w^-1*f*w, a^-1*u*a*(v*w)^-1,a^-1*v*a*(v*f)^-1, a^-1*w*a*(u*v*f)^-1,a^-1*f*a*f^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,b^-1*f*b*f^-1, a^-1*x*a*(z*e)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e)^-1,a^-1*e*a*e^-1, b^-1*x*b*(y*w)^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*(z*u)^-1,b^-1*e*b*e^-1, u^-1*x*u*x^-1*f^-1, u^-1*y*u*y^-1,u^-1*z*u*z^-1, v^-1*x*v*x^-1,v^-1*y*v*y^-1 *f^-1,v^-1*z*v*z^-1, w^-1*x*w*x^-1,w^-1*y*w*y^-1, w^-1*z*w*z^-1*f^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,u,e], [a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,u,z]] ]; end, [128,16]], "L3(2) 2^8",[8,8,23],4, 2,[128,16]], # 43008.24 [[1,"abxyzeuvwf", function(a,b,x,y,z,e,u,v,w,f) return [[a^2*(e*f)^-1,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4 *(e*f)^-1,u^2,v^2,w^2,u^-1*v^-1*u*v, u^-1*w^-1*u*w,v^-1*w^-1*v*w, x^2*f^-1,y^2*f^-1,z^2*f^-1, x^-1*y^-1*x*y*f^-1, x^-1*z^-1*x*z*f^-1,y^-1*z^-1*y *z,e^2,e^-1*x^-1*e*x,e^-1*y^-1*e*y ,e^-1*z^-1*e*z,e^-1*u^-1*e*u, e^-1*v^-1*e*v,e^-1*w^-1*e*w,f^2, f^-1*x^-1*f*x,f^-1*y^-1*f*y, f^-1*z^-1*f*z,f^-1*u^-1*f*u, f^-1*v^-1*f*v,f^-1*w^-1*f*w, a^-1*u*a*(v*w)^-1,a^-1*v*a*(v*f)^-1, a^-1*w*a*(u*v*f)^-1,a^-1*f*a*f^-1, b^-1*u*b*(u*v)^-1,b^-1*v*b*u^-1, b^-1*w*b*w^-1,b^-1*f*b*f^-1, a^-1*x*a*(z*e)^-1, a^-1*y*a*(x*y*z)^-1, a^-1*z*a*(x*e)^-1,a^-1*e*a*e^-1, b^-1*x*b*(y*w)^-1,b^-1*y*b*(x*y)^-1, b^-1*z*b*(z*u)^-1,b^-1*e*b*e^-1, u^-1*x*u*x^-1*f^-1, u^-1*y*u*y^-1,u^-1*z*u*z^-1, v^-1*x*v*x^-1,v^-1*y*v*y^-1 *f^-1,v^-1*z*v*z^-1, w^-1*x*w*x^-1,w^-1*y*w*y^-1, w^-1*z*w*z^-1*f^-1], [[a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,u,e], [a*b,b*a*b^-1*a*b^-1*a*b*a*b^-1,u,z]] ]; end, [128,16]], "L3(2) 2^8",[8,8,24],4, 2,[128,16]], # 43008.25 [[1,"abpqrstuvw", function(a,b,p,q,r,s,t,u,v,w) return [[a^2,b^3,(a*b)^7,(a^-1*b^-1*a*b)^4,p^2,q^2, r^2,s^2,t^2,u^2,v^2,w^2,p^-1*q^-1*p*q, p^-1*r^-1*p*r,p^-1*s^-1*p*s, p^-1*t^-1*p*t,p^-1*u^-1*p*u, p^-1*v^-1*p*v,p^-1*w^-1*p*w, q^-1*r^-1*q*r,q^-1*s^-1*q*s, q^-1*t^-1*q*t,q^-1*u^-1*q*u, q^-1*v^-1*q*v,q^-1*w^-1*q*w, r^-1*s^-1*r*s,r^-1*t^-1*r*t, r^-1*u^-1*r*u,r^-1*v^-1*r*v, r^-1*w^-1*r*w,s^-1*t^-1*s*t, s^-1*u^-1*s*u,s^-1*v^-1*s*v, s^-1*w^-1*s*w,t^-1*u^-1*t*u, t^-1*v^-1*t*v,t^-1*w^-1*t*w, u^-1*v^-1*u*v,u^-1*w^-1*u*w, v^-1*w^-1*v*w,a^-1*p*a*q^-1, a^-1*q*a*p^-1,a^-1*r*a*(p*q*s*t)^-1 ,a^-1*s*a*(p*q*s)^-1, a^-1*t*a*(r*s)^-1, a^-1*u*a*(q*r*t*w)^-1, a^-1*v*a*(q*r*t*v)^-1, a^-1*w*a*(q*r*t*u)^-1, b^-1*p*b*(p*q*r)^-1, b^-1*q*b*(p*q*s)^-1, b^-1*r*b*(r*u)^-1,b^-1*s*b*(p*r)^-1, b^-1*t*b*(p*q*s*t*u*v)^-1, b^-1*u*b*r^-1,b^-1*v*b*(v*w)^-1, b^-1*w*b*v^-1],[[b,a*b*a*b^-1*a,s*v]] ]; end, [28]], "L3(2) 2^8",[8,8,25],1, 2,28] ]; ############################################################################# ## #E perf5.grp . . . . . . . . . . . . . . . . . . . . . . . . . ends here ## gap-4r6p5/grp/basicmat.gi0000644000175000017500000004131012172557252014034 0ustar billbill############################################################################# ## #W basicmat.gi GAP Library Frank Celler ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains the methods for the construction of the basic matrix ## group types. ## ############################################################################# ## #M CyclicGroupCons( , , ) ## InstallOtherMethod( CyclicGroupCons, "matrix group for given field", true, [ IsMatrixGroup and IsFinite, IsField, IsInt and IsPosRat ], 0, function( filter, fld, n ) local o, m, i, g; o := One(fld); m := NullMat( n, n, fld ); for i in [ 1 .. n-1 ] do m[i][i+1] := o; od; m[n][1] := o; m := [ ImmutableMatrix(fld,m,true) ]; g := GroupByGenerators( m ); SetIsCyclic (g, true); SetMinimalGeneratingSet (g, m); SetSize( g, n ); return g; end ); ############################################################################# ## #M CyclicGroupCons( , ) ## InstallMethod( CyclicGroupCons, "matrix group for default field", true, [ IsMatrixGroup and IsFinite, IsInt and IsPosRat ], 0, function( filter, n ) local m, i; m := NullMat( n, n, Rationals ); for i in [ 1 .. n-1 ] do m[i][i+1] := 1; od; m[n][1] := 1; m := GroupByGenerators( [ ImmutableMatrix(Rationals,m,true) ] ); SetSize( m, n ); return m; end ); ############################################################################# ## #M QuaternionGroupCons( , ) ## InstallMethod( QuaternionGroupCons, "matrix group for default field", true, [ IsMatrixGroup and IsFinite, IsInt and IsPosRat ], 0, function( filter, n ) return QuaternionGroup( filter, Rationals, n ); end ); ############################################################################# ## #M QuaternionGroupCons( , , ) ## InstallOtherMethod( QuaternionGroupCons, "matrix group for given field", true, [ IsMatrixGroup and IsFinite, IsField, IsInt and IsPosRat ], 0, function( filter, fld, n ) local bas, grp, cyc, one; if 0 <> n mod 4 then TryNextMethod(); fi; if n = 4 then return CyclicGroup( filter, fld, n ); fi; if Characteristic( fld ) = 0 and IsAbelianNumberField( fld ) then cyc := E( n / 2 ); bas := CanonicalBasis( Field( fld, [ cyc ] ) ); one := 1; elif 0 = n mod Characteristic( fld ) then # XXX: regular rep is not minimal grp := QuaternionGroup( IsPermGroup, n ); grp := Group( List( GeneratorsOfGroup( grp ), prm -> PermutationMat( prm, NrMovedPoints( grp ), fld ) ) ); SetSize( grp, n ); return grp; elif IsFFECollection( fld ) then # XXX: If OrderMod( Size( fld ), n/2 ) is large, then this asks GAP # XXX: to compute a large conway polynomial, rather than just using # XXX: a companion polynomial directly. bas := CanonicalBasis( GF( Size( fld ), OrderMod( Size( fld ), n/2 ) ) ); cyc := Z( Size( Field( bas ) ) )^( ( Size( Field( bas ) ) - 1 ) / (n/2) ); one := One( fld ); elif Characteristic( fld ) = 0 then bas := CanonicalBasis( CF( n / 2 ) ); cyc := E( n / 2 ); one := 1; else bas := CanonicalBasis( GF( Characteristic( fld ), OrderMod( Characteristic( fld ), n/2 ) ) ); cyc := Z( Size( Field( bas ) ) )^( ( Size( Field( bas ) ) - 1 ) / (n/2) ); one := One( Field( bas ) ); fi; grp := Group( List( [[[0,1],[-1,0]],[[cyc,0],[0,1/cyc]]]*one, mat -> ImmutableMatrix( fld, BlownUpMat( bas, mat )*One(fld), true ) ) ); SetSize( grp, n ); return grp; end); ############################################################################# ## #M GeneralLinearGroupCons( , , ) ## InstallMethod( GeneralLinearGroupCons, "matrix group for dimension and finite field", [ IsMatrixGroup and IsFinite, IsInt and IsPosRat, IsField and IsFinite ], function( filter, n, f ) local q, z, o, mat1, mat2, i, g; q:= Size( f ); # small cases if q = 2 and 1 < n then #T why 1 < n? return SL( n, 2 ); fi; # construct the generators z := PrimitiveRoot( f ); o := One( f ); mat1 := IdentityMat( n, f ); mat1[1][1] := z; mat2 := List( Zero(o) * mat1, ShallowCopy ); mat2[1][1] := -o; mat2[1][n] := o; for i in [ 2 .. n ] do mat2[i][i-1]:= -o; od; mat1 := ImmutableMatrix( f, mat1,true ); mat2 := ImmutableMatrix( f, mat2,true ); g := GroupByGenerators( [ mat1, mat2 ] ); SetName( g, Concatenation("GL(",String(n),",",String(q),")") ); SetDimensionOfMatrixGroup( g, n ); SetFieldOfMatrixGroup( g, f ); SetIsNaturalGL( g, true ); SetIsFinite(g,true); if n<50 or n+q<500 then Size(g); fi; # Return the group. return g; end ); ############################################################################# ## #M SpecialLinearGroupCons( , , ) ## InstallMethod( SpecialLinearGroupCons, "matrix group for dimension and finite field", [ IsMatrixGroup and IsFinite, IsInt and IsPosRat, IsField and IsFinite ], function( filter, n, f ) local q, g, o, z, mat1, mat2, i, size, qi; q:= Size( f ); # handle the trivial case first if n = 1 then g := GroupByGenerators( [ ImmutableMatrix( f, [[One(f)]],true ) ] ); # now the general case else # construct the generators o := One(f); z := PrimitiveRoot(f); mat1 := IdentityMat( n, f ); mat2 := List( Zero(o) * mat1, ShallowCopy ); mat2[1][n] := o; for i in [ 2 .. n ] do mat2[i][i-1]:= -o; od; if q = 2 or q = 3 then mat1[1][2] := o; else mat1[1][1] := z; mat1[2][2] := z^-1; mat2[1][1] := -o; fi; mat1 := ImmutableMatrix(f,mat1,true); mat2 := ImmutableMatrix(f,mat2,true); g := GroupByGenerators( [ mat1, mat2 ] ); fi; # set name, dimension and field SetName( g, Concatenation("SL(",String(n),",",String(q),")") ); SetDimensionOfMatrixGroup( g, n ); SetFieldOfMatrixGroup( g, f ); SetIsFinite( g, true ); if q = 2 then SetIsNaturalGL( g, true ); fi; SetIsNaturalSL( g, true ); SetIsFinite(g,true); # add the size if n<50 or n+q<500 then Size(g); fi; # return the group return g; end ); ############################################################################# ## #M GeneralSemilinearGroupCons( IsMatrixGroup, , ) ## InstallMethod( GeneralSemilinearGroupCons, "matrix group for dimension and finite field size", [ IsMatrixGroup and IsFinite, IsInt and IsPosRat, IsInt and IsPosRat ], function( filter, d, q ) local p, f, field, B, gl, gens, frobact, frobmat, i, g; p:= Factors( Integers, q ); f:= Length( p ); if f = 1 then return GL( d, q ); fi; p:= p[1]; field:= GF(q); B:= Basis( field ); gl:= GL( d, q ); gens:= List( GeneratorsOfGroup( gl ), x -> BlownUpMat( B, x ) ); frobact:= List( BasisVectors( B ), x -> Coefficients( B, x^p ) ); frobmat:= NullMat( d*f, d*f, GF(p) ); for i in [ 1 .. d ] do frobmat{ [ (i-1)*f+1 .. i*f ] }{ [ (i-1)*f+1 .. i*f ] }:= frobact; od; Add( gens, frobmat ); g:= GroupWithGenerators( gens ); SetName( g, Concatenation( "GammaL(",String(d),",",String(q),")" ) ); SetDimensionOfMatrixGroup( g, d*f ); SetFieldOfMatrixGroup( g, GF(p) ); SetIsFinite( g, true ); SetSize( g, f * Size( gl ) ); return g; end ); ############################################################################# ## #M SpecialSemilinearGroupCons( IsMatrixGroup, , ) ## InstallMethod( SpecialSemilinearGroupCons, "matrix group for dimension and finite field size", [ IsMatrixGroup and IsFinite, IsInt and IsPosRat, IsInt and IsPosRat ], function( filter, d, q ) local p, f, field, B, sl, gens, frobact, frobmat, i, g; p:= Factors( Integers, q ); f:= Length( p ); if f = 1 then return SL( d, q ); fi; p:= p[1]; field:= GF(q); B:= Basis( field ); sl:= SL( d, q ); gens:= List( GeneratorsOfGroup( sl ), x -> BlownUpMat( B, x ) ); frobact:= List( BasisVectors( B ), x -> Coefficients( B, x^p ) ); frobmat:= NullMat( d*f, d*f, GF(p) ); for i in [ 1 .. d ] do frobmat{ [ (i-1)*f+1 .. i*f ] }{ [ (i-1)*f+1 .. i*f ] }:= frobact; od; Add( gens, frobmat ); g:= GroupWithGenerators( gens ); SetName( g, Concatenation( "SigmaL(",String(d),",",String(q),")" ) ); SetDimensionOfMatrixGroup( g, d*f ); SetFieldOfMatrixGroup( g, GF(p) ); SetIsFinite( g, true ); SetSize( g, f * Size( sl ) ); return g; end ); ############################################################################# ## #M GeneralSemilinearGroupCons( IsPermGroup, , ) #M SpecialSemilinearGroupCons( IsPermGroup, , ) ## PermConstructor( GeneralSemilinearGroupCons, [ IsPermGroup, IsPosInt, IsPosInt ], IsMatrixGroup and IsFinite ); PermConstructor( SpecialSemilinearGroupCons, [ IsPermGroup, IsPosInt, IsPosInt ], IsMatrixGroup and IsFinite ); ############################################################################## ## #M SylowSubgroupOp( NaturalGL, p ) ## ## Use Weir and Carter-Fong's explicit generators for Sylow p-subgroups of ## natural general linear groups. ## CallFuncList( function() # Avoid polluting the namespace with these functions of somewhat limited interest. local SylowSubgroupOfWreathProduct, MaximalUnipotentSubgroupOfNaturalGL, TorusOfNaturalGL, SylowSubgroupOfTorusOfNaturalGL, SylowSubgroupOfNaturalGL; # Return a Sylow p-subgroup of Sym(k) wreath Sym(m) SylowSubgroupOfWreathProduct := function( k, m, p ) local wr, ss, sy; wr := WreathProduct( SymmetricGroup( k ), SymmetricGroup( m ) ); ss := List( [1..m+1], i -> Image( Embedding( wr, i ), SylowSubgroup( Source( Embedding( wr, i ) ), p ) ) ); sy := Subgroup( wr, Concatenation( List( ss, GeneratorsOfGroup ) ) ); SetSize( sy, Size(ss[1])^m*Size(ss[m+1]) ); Assert( 2, Size( sy ) = Size( Subgroup( wr, GeneratorsOfGroup( sy ) ) ) ); Assert( 0, 0 <> ( Size(wr) / Size(sy) ) mod p and IsSubgroup( wr, sy ) ); return sy; end; # The following function creates the subgroup generated by the positive simple # roots (upper triangular matrices with 1s on the diagonal, and a single # non-zero entry on the first super diagonal, the non-zero entries varying over # a basis of GF(q) over GF(p)). MaximalUnipotentSubgroupOfNaturalGL := function( gl ) local n, q, o, z, u; n := DimensionOfMatrixGroup( gl ); q := Size( DefaultFieldOfMatrixGroup( gl ) ); if SizeGL( n, q ) <> Size( gl ) then q := Size( FieldOfMatrixGroup( gl ) ); fi; if IsPosInt(q) then q := GF(q); fi; o := One(q); z := Zero(q); u := Subgroup( gl, Concatenation( List( [1..n-1], r -> List( Basis( q ), b -> ImmutableMatrix( q, List( [1..n], i -> List( [1..n], function(j) if i = r and j = r+1 then return b; elif i = j then return o; else return z; fi; end ) ), true ) ) ) ) ); SetSize( u, Size(q)^Binomial(n,2) ); IsPGroup( u ); return u; end; # The conjugacy classes of maximal tori of GL are indexed by conjugacy classes # of Weyl group elements. For a given permutation, return a corresponding # torus. TorusOfNaturalGL := function( gl, pi ) local n, q, gfq, one, orbs, gens, sub; n := DimensionOfMatrixGroup( gl ); q := Size( DefaultFieldOfMatrixGroup( gl ) ); if SizeGL( n, q ) <> Size( gl ) then q := Size( FieldOfMatrixGroup( gl ) ); fi; gfq := GF(q); one := IdentityMat( n, gfq ); orbs := Cycles( pi, [1..n] ); gens := List( orbs, function( orb ) local mat; mat := MutableCopyMat( one ); # XXX: Asks GAP to compute ConwayPolynomial, but could make do with much less mat{orb}{orb} := CompanionMat( MinimalPolynomial( gfq, Z(q^Size(orb)) ) ); return ImmutableMatrix( gfq, mat, true ); end ); sub := Subgroup( gl, gens ); SetIsAbelian( sub, true ); SetAbelianInvariants( sub, AbelianInvariantsOfList( List( orbs, orb -> q^Size(orb)-1 ) ) ); SetSize( sub, Product( AbelianInvariants( sub ) ) ); return sub; end; # The Sylow p-subgroup of a direct product of cyclic groups is quite easy to # compute. SylowSubgroupOfTorusOfNaturalGL := function( gl, pi, p ) local n, q, gfq, one, orbs, gens, sub; n := DimensionOfMatrixGroup( gl ); q := Size( DefaultFieldOfMatrixGroup( gl ) ); if SizeGL( n, q ) <> Size( gl ) then q := Size( FieldOfMatrixGroup( gl ) ); fi; gfq := GF(q); one := IdentityMat( n, gfq ); orbs := Cycles( pi, [1..n] ); gens := List( orbs, function( orb ) local k, mat; k := Size(orb); mat := MutableCopyMat( one ); mat{orb}{orb} := CompanionMat( MinimalPolynomial( gfq, Z(q^k) ) )^( (q^k-1)/p^PadicValuation(q^k-1,p)); return ImmutableMatrix( gfq, mat, true ); end ); sub := Subgroup( gl, gens ); SetIsAbelian( sub, true ); SetAbelianInvariants( sub, AbelianInvariantsOfList( List( orbs, orb -> p^PadicValuation(q^Size(orb)-1,p) ) ) ); SetSize( sub, Product( AbelianInvariants( sub ) ) ); return sub; end; # The main worker. In defining characteristic, return the maximal unipotent # subgroup. In cross-characteristic, take a Sylow p-subgroup of a # as-split-possible maximal torus, and if the dimension is large enough, the # Sylow p-subgroup of the part of the Weyl group normalizing it. SylowSubgroupOfNaturalGL := function( gl, p ) local n, q, syl, s, syl2, k, sylp, pi, prm, syl1; n := DimensionOfMatrixGroup( gl ); q := Size( DefaultFieldOfMatrixGroup( gl ) ); if SizeGL( n, q ) <> Size( gl ) then q := Size( FieldOfMatrixGroup( gl ) ); fi; if p = SmallestRootInt( q ) then # unipotent sylow syl := MaximalUnipotentSubgroupOfNaturalGL( gl ); elif p = 2 then # use Carter-Fong description s := PadicValuation( q-1, 2 ); syl1 := Subgroup( GL( 1, q ), [ [ [ Z(q)^((q-1)/2^s) ] ] ] ); if 1 = q mod 4 then s := PadicValuation( q-1, 2 ); syl2 := Subgroup( GL( 2, q ), [ [[ 0, 1 ], [ 1, 0 ]], [[ Z(q)^((q-1)/2^s), 0 ], [ 0, 1 ]], [[ 1, 0 ], [ 0, Z(q)^((q-1)/2^s) ]], ]*One(GF(q)) ); else s := PadicValuation( q+1, 2 ); syl2 := Subgroup( GL( 2, q ), [ [[ 0, 1 ], [ -1, 0 ]], [[ 0, 1 ], [ 1, Z(q^2)^((q^2-1)/2^(s+1)) + Z(q^2)^(q*(q^2-1)/2^(s+1)) ]], ]*One(GF(q)) ); fi; s := 0; pi := []; repeat k := PadicValuation( n - s, 2 ); Add( pi, [s+1..s+2^k] ); s := s+2^k; until n = s; syl := Subgroup( gl, Concatenation( List( pi, function( part ) local one, prm; one := One(gl); if Size( part ) = 1 then return List( GeneratorsOfGroup( syl1 ), function( x ) local mat; mat := MutableCopyMat( one ); mat{part}{part} := x ; return mat; end ); fi; prm := SylowSubgroup( SymmetricGroup( Size( part ) / 2 ), 2 ); return Concatenation( List( GeneratorsOfGroup( prm ), function( x ) local mat; mat := MutableCopyMat( one ); mat{part}{part} := KroneckerProduct( PermutationMat( x, Size( part )/2, GF( q ) ), One( syl2 ) ); return mat; end ), List( GeneratorsOfGroup( syl2 ), function( x ) local mat; mat := MutableCopyMat( one ); mat{part{[1..2]}}{part{[1..2]}} := x; return mat; end ) ); end ) ) ); else k := OrderMod( q, p^(2/GcdInt(p-1,2)) ); pi := PermList( List( [1..n], function(i) if i > Int(n/k)*k then return i; else return (i mod k) + 1 + k*Int((i-1)/k); fi; end ) ); syl := SylowSubgroupOfTorusOfNaturalGL( gl, pi, p ); if n >= p*k or ( p = 2 and k <= n ) then # non-abelian sylow prm := SylowSubgroupOfWreathProduct( k, Int(n/k), p ); syl2 := Subgroup( gl, Concatenation( List( GeneratorsOfGroup( prm ), pi -> PermutationMat( pi, n, GF(q) ) ), GeneratorsOfGroup( syl ) ) ); SetSize( syl2, Size(prm)*Size(syl) ); syl := syl2; fi; fi; SetSize( syl, p^PadicValuation( Size(gl), p ) ); SetIsPGroup( syl, true ); SetPrimePGroup( syl, p ); Assert( 2, Size( Group( GeneratorsOfGroup( syl ) ) ) = Size( syl ) ); return syl; end; # Just install the method. InstallMethod( SylowSubgroupOp, "Direct construction for natural GL", [ IsNaturalGL and IsFinite and IsFFEMatrixGroup, IsPosInt ], SylowSubgroupOfNaturalGL ); end, [] ); ############################################################################# ## #E gap-4r6p5/grp/basicpcg.gi0000644000175000017500000002543112172557252014032 0ustar billbill############################################################################# ## #W basicpcg.gi GAP Library Frank Celler ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains the methods for the construction of the basic pc group ## types. ## ############################################################################# ## #M TrivialGroupCons( ) ## InstallMethod( TrivialGroupCons, "pc group", [ IsPcGroup and IsFinite ], function( filter ) filter:= CyclicGroup( IsPcGroup, 1 ); SetIsTrivial( filter, true ); return filter; end ); ############################################################################# ## #M AbelianGroupCons( , ) ## InstallMethod( AbelianGroupCons, "pc group", true, [ IsPcGroup and IsFinite, IsList ], 0, function( filter, ints ) local pis, f, g, r, k, pi, i, geni, j, name, ps; if not ForAll( ints, IsInt ) then Error( " must be a list of integers" ); fi; if not ForAll( ints, x -> 0 < x ) then TryNextMethod(); fi; if ForAll(ints,i->i=1) then # the stupid trivial group case return CyclicGroup( IsPcGroup, 1 ); fi; pis := List( ints, Factors ); f := FreeGroup( IsSyllableWordsFamily, Sum( List(pis{Filtered([1..Length(pis)],i->ints[i]>1)}, Length ) ) ); g := GeneratorsOfGroup(f); r := []; k := 1; geni:=[]; for pi in pis do if pi[1]=1 then Add(geni,0); else Add(geni,k); for i in [ 1 .. Length(pi)-1 ] do Add( r, g[k]^pi[i] / g[k+1] ); k := k + 1; od; Add( r, g[k]^pi[Length(pi)] ); k := k + 1; fi; od; f := PolycyclicFactorGroup( f, r ); SetSize( f, Product(ints) ); SetIsAbelian( f, true ); k:=[]; g:=GeneratorsOfGroup(f); for i in geni do if i=0 then Add(k,One(f)); else Add(k,g[i]); fi; od; k:=GroupWithGenerators(k,One(f)); SetSize(k,Size(f)); SetIsAbelian( k, true ); if Size(Set(Filtered(Flat(pis),p->p<>1))) = 1 then SetIsPGroup( k, true ); SetPrimePGroup( k, First(Flat(pis),p -> p<>1) ); fi; pis := [ ]; ps := [ ]; for i in ints do pi := PrimePowersInt( i ); for j in [ 1, 3 .. Length( pi ) - 1 ] do if pi[ j ] in ps then SetIsCyclic( k, false ); fi; AddSet( ps, pi[ j ] ); Add( pis, pi[ j ] ^ pi[ j + 1 ] ); od; od; if not HasIsCyclic( k ) then SetIsCyclic( k, true ); SetNameIsomorphismClass( k, Concatenation( "c", String( Size( f )))); return k; fi; Sort( pis ); SetAbelianInvariants( k, pis ); pis := Collected( pis ); name := ""; for i in pis do Append( name, String( i[ 1 ] ) ); if i[ 2 ] > 1 then name := Concatenation( name, "^", String( i[ 2 ] ) ); fi; Append( name, "x" ); od; Unbind( name[ Length( name ) ] ); SetNameIsomorphismClass( k, name ); return k; end ); ############################################################################# ## #M AlternatingGroupCons( , ) ## InstallMethod( AlternatingGroupCons, "pc group with degree", true, [ IsPcGroup and IsFinite, IsInt and IsPosRat ], 0, function( filter, deg ) local alt; if 4 < deg then Error( " must be at most 4" ); fi; alt := GroupByPcgs(Pcgs(AlternatingGroupCons(IsPermGroup,[1..deg]))); SetIsAlternatingGroup( alt, true ); return alt; end ); ############################################################################# ## #M CyclicGroupCons( , ) ## InstallMethod( CyclicGroupCons, "pc group", true, [ IsPcGroup and IsFinite, IsInt and IsPosRat ], 0, function( filter, n ) local pi, f, g, r, i; # Catch the case n = 1. if n = 1 then f := GroupByRws( SingleCollector( FreeGroup( 0 ), [] ) ); SetMinimalGeneratingSet (f, []); else pi := Factors( n ); f := FreeGroup( IsSyllableWordsFamily, Length(pi) ); g := GeneratorsOfGroup(f); r := []; for i in [ 1 .. Length(g)-1 ] do Add( r, g[i]^pi[i] / g[i+1] ); od; Add( r, g[Length(g)] ^ pi[Length(g)] ); f := PolycyclicFactorGroup( f, r ); if Size(Set(pi)) = 1 then SetIsPGroup( f, true ); SetPrimePGroup( f, pi[1] ); fi; SetMinimalGeneratingSet (f, [f.1]); fi; SetSize( f, n ); SetIsCyclic( f, true ); SetNameIsomorphismClass( f, Concatenation( "c", String( n ) ) ); return f; end ); ############################################################################# ## #M DihedralGroupCons( , ) ## InstallMethod( DihedralGroupCons, "pc group", true, [ IsPcGroup and IsFinite, IsInt and IsPosRat ], 0, function( filter, n ) local pi, f, g, r, i; if n mod 2 = 1 then TryNextMethod(); elif n = 2 then return CyclicGroup( IsPcGroup, 2 ); fi; pi := Factors(n/2); f := FreeGroup( IsSyllableWordsFamily, Length(pi)+1 ); g := GeneratorsOfGroup(f); r := []; for i in [ 2 .. Length(g)-1 ] do Add( r, g[i]^pi[i-1] / g[i+1] ); od; Add( r, g[Length(g)] ^ pi[Length(g)-1] ); Add( r, g[1]^2 ); for i in [ 2 .. Length(g) ] do Add( r, g[i]^g[1] * g[i] ); od; f := PolycyclicFactorGroup( f, r ); SetSize( f, n ); if n = 2^LogInt(n,2) then SetIsPGroup( f, true ); SetPrimePGroup( f, 2 ); fi; return f; end ); ############################################################################# ## #M QuaternionGroupCons( , ) ## InstallMethod( QuaternionGroupCons, "pc group", true, [ IsPcGroup and IsFinite, IsInt and IsPosRat ], 0, function( filter, n ) local k, d, relords, powers, gens, f, rels, pow; if 0 <> n mod 4 then TryNextMethod(); fi; # Hard to get a confluent RWS for a cyclic group on 2 independent generators if n = 4 then return CyclicGroup( filter, n ); fi; k := n/4; d := Factors( k ); relords := [2]; Append(relords, d); Add( relords, 2 ); powers := [0]; Append( powers, List( [0..Size(d)], i -> Product( d{[1..i]} ) ) ); gens := Concatenation( [ "x", "y" ], List( powers{[3..Size(powers)]}, d -> Concatenation( "y", String(d) ) ) ); f := FreeGroup( IsSyllableWordsFamily, gens ); pow := function( i ) local e, j; i := i mod (n/2); e := [0]; for j in [2..Size(relords)] do e[j] := i mod relords[j]; i := Int( i / relords[j] ); od; return Product([1..Size(e)],i->f.(i)^e[i]); end; rels := [ [ f.1^2, f.(Size(gens)) ], [ f.(Size(gens))^2, One(f) ] ]; Append( rels, List( [2..Size(gens)-1], i -> [ f.(i)^relords[i], f.(i+1) ] ) ); Append( rels, List( [2..Size(gens)-1], i -> [ f.(i)^f.1, pow(-powers[i]) ] ) ); Append( rels, List( Combinations( [2..Size(gens)], 2 ), ij -> [ f.(ij[2])^f.(ij[1]), f.(ij[2]) ] ) ); return PcGroupFpGroupNC( f / List( rels, rel -> rel[1]/rel[2] ) ); end ); ############################################################################# ## #M ElementaryAbelianGroupCons( , ) ## InstallMethod( ElementaryAbelianGroupCons, "pc group", true, [ IsPcGroup and IsFinite, IsInt and IsPosRat ], 0, function( filter, n ) if n = 1 then return CyclicGroupCons( IsPcGroup, 1 ); elif not IsPrimePowerInt(n) then Error( " must be a prime power" ); fi; n:= AbelianGroupCons( IsPcGroup, Factors(n) ); SetIsElementaryAbelian( n, true ); return n; end ); ############################################################################# ## #M ExtraspecialGroupCons( , , ) ## InstallMethod( ExtraspecialGroupCons, "pc group", true, [ IsPcGroup and IsFinite, IsInt, IsObject ], 0, function( filters, order, exp ) local i, # loop variable p, # divisor of group order n, # the group has order 'p'^(2*'n'+1) eps1, # constant to distinguish odd and even 'p' eps2, # constant to distinguish odd and even 'p' name, # name of generators (default is "e") z, # central element f, # free group r, # relators e; # the group generators p := Factors(order); if Length(p) = 1 or Length(p) mod 2 <> 1 or Length(Set(p)) <> 1 then Error( "order of an extraspecial group is", " a nonprime odd power of a prime" ); fi; n := ( Length(p) - 1 ) / 2; p := p[1]; # determine the required type of the group if p = 2 then if n = 1 then eps1 := 1; else eps1 := 0; fi; # central product of 'n' dihedral groups of order 8 if exp = '+' or exp = "+" then eps2 := 0; # central product of 'n'-1 dihedral groups and a quaternionic group elif exp = '-' or exp = "-" then eps2 := 1; # zap else Error( " must be '+', '-', \"+\", or \"-\"" ); fi; else if exp = p or exp = '+' or exp = "+" then eps1 := 0; elif exp = p^2 or exp = '-' or exp = "-" then eps1 := 1; else Error( " must be

,

^2, '+', '-', \"+\", or \"-\"" ); fi; eps2 := 0; fi; f := FreeGroup( IsSyllableWordsFamily, 2*n+1); e := GeneratorsOfGroup(f); z := e[ 2*n+1 ]; r := []; # power relators Add( r, e[1]^p / z^eps1 ); for i in [ 2 .. 2*n-2 ] do Add( r, e[i]^p ); od; if 1 < n then Add( r, e[2*n-1]^p / z^eps2 ); fi; Add( r, e[2*n]^p / z^eps2 ); Add( r, z^p ); # nontrivial commutator relators for i in [ 1 .. n ] do Add( r, Comm( e[2*i], e[2*i-1] ) * z ); od; # return the pc group f := PolycyclicFactorGroup( f, r ); SetIsPGroup( f, true ); SetPrimePGroup( f, p ); return f; end ); ############################################################################# ## #M SymmetricGroupCons( , ) ## InstallMethod( SymmetricGroupCons, "pc group with degree", true, [ IsPcGroup and IsFinite, IsInt and IsPosRat ], 0, function( filter, deg ) if 4 < deg then Error( " must be at most 4" ); fi; return GroupByPcgs(Pcgs(SymmetricGroupCons(IsPermGroup,[1..deg]))); end ); ############################################################################# ## #E gap-4r6p5/grp/imf16.grp0000644000175000017500000017523012172557252013375 0ustar billbill############################################################################# ## #A imf16.grp GAP group library Volkmar Felsch ## ## #Y Copyright (C) 1995, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file contains, for each Q-class representative of the irreducible ## maximal finite integral matrix groups of dimension 16, ## ## [1] a quadratic form (as lower triangle of the Gram matrix), ## [2] a list of matrix generators. ## ############################################################################# ## ## Quadratic form and matrix generators for the Q-class representatives of ## the irreducible maximal finite integral matrix groups of dimension 16. ## IMFList[16].matrices := [ [ # Q-class [16][01] [[1], [0,1], [0,0,1], [0,0,0,1], [0,0,0,0,1], [0,0,0,0,0,1], [0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[[0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [16][02] [[2], [-1,2], [0,-1,2], [0,0,-1,2], [0,0,0,-1,2], [0,0,0,0,-1,2], [0,0,0,0,0,-1,2], [0,0,-1,0,0,0,0,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,2], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,-1,-1,-2,-2,-2,-1,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,2,3,4,3,2,1,1,2], [0,0,0,0,0,0,0,0,0,-1,-2,-2,-1,0,0,-1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0]], [[-2,-4,-6,-5,-4,-3,-1,-3,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,2,2,1,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [16][03] [[2], [0,2], [-1,1,2], [-1,1,1,2], [0,0,0,0,2], [0,0,0,0,0,2], [0,0,0,0,-1,1,2], [0,0,0,0,-1,1,1,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,-1,1,2], [0,0,0,0,0,0,0,0,-1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,1,2]], [[[0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,-1,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [16][04] [[4], [2,4], [2,1,4], [1,2,2,4], [2,1,2,1,4], [1,2,1,2,2,4], [-2,-1,0,0,-2,-1,4], [-2,-1,0,0,-2,-1,2,4], [-1,-2,0,0,-1,-2,2,2,4], [-1,1,0,0,-1,1,0,0,-2,4], [0,1,-1,1,1,2,0,-2,-1,0,4], [0,-1,-1,0,1,1,0,-2,0,-1,2,4], [-1,1,-1,0,-2,-1,0,2,0,1,-1,-2,4], [2,0,0,-1,2,1,-2,-2,-1,-1,1,1,-2,4], [2,0,0,0,0,0,-2,-1,0,0,0,0,0,2,4], [2,1,2,1,2,0,-2,-1,-1,-1,-1,-1,0,0,0,4]], [[[-1,1,0,0,-1,0,1,0,1,1,0,1,0,2,0,2], [-1,1,0,0,-1,0,0,1,1,1,0,1,0,2,0,2], [-1,1,1,0,-1,0,0,0,1,1,0,1,0,1,0,1], [-1,1,1,0,-1,-1,-1,1,1,1,1,1,0,1,0,1], [0,0,0,0,0,0,1,0,0,1,0,1,1,1,0,1], [0,-1,-1,1,1,0,1,0,0,1,0,0,1,1,0,1], [0,-1,1,0,-1,1,-1,-1,0,-1,0,-1,0,-1,0,-1], [1,-1,-1,1,1,0,0,-1,0,0,-1,-1,0,-1,0,-1], [0,0,1,0,-1,0,-1,-1,0,-1,0,0,0,-1,0,-1], [-1,1,0,0,0,0,-1,1,0,0,0,0,-1,0,0,0], [0,-1,1,0,-1,0,-1,0,0,0,1,0,1,1,-1,0], [-1,0,1,-1,0,0,0,0,-1,-1,1,0,0,-1,1,0], [0,1,0,0,0,-1,-1,1,0,0,0,0,-1,0,0,0], [1,-1,-1,0,0,1,1,-1,1,1,0,0,1,1,-1,1], [0,1,0,0,-1,-1,-1,1,1,1,1,1,-1,1,-1,1], [0,1,0,0,0,-1,1,1,0,1,0,1,0,1,0,1]], [[-1,1,0,0,-1,0,0,1,1,1,0,1,0,2,0,2], [-1,1,0,0,-1,0,1,0,1,1,0,1,0,2,0,2], [0,0,0,1,0,-1,0,1,0,1,0,1,0,1,0,1], [0,0,1,0,-1,-1,0,1,0,1,1,1,0,1,0,1], [0,0,0,0,0,0,0,0,1,1,0,1,1,1,0,1], [0,-1,0,0,0,1,1,-1,1,1,0,0,1,1,0,1], [0,0,1,0,-1,0,-1,0,-1,-1,0,0,-1,-1,0,-1], [1,-1,-1,1,1,-1,0,0,-1,0,0,-1,-1,-1,0,-1], [0,0,1,0,-1,-1,-2,1,-1,-1,1,0,-1,-1,0,-1], [0,-1,-1,1,1,1,2,-2,0,0,-1,-1,1,0,0,0], [-1,1,2,-2,-2,1,-1,0,1,0,1,1,0,0,0,1], [-1,0,2,-1,-1,1,-1,-1,0,-1,0,0,1,0,0,-1], [-1,1,0,0,0,-1,0,0,0,0,0,0,-1,0,0,0], [1,-1,-1,0,0,1,0,0,1,1,0,0,1,1,-1,1], [0,0,0,0,-1,0,-1,1,1,1,1,0,0,1,-1,1], [0,1,0,0,0,-1,0,1,1,1,0,1,0,1,0,1]]]], [ # Q-class [16][05] [[2], [1,2], [0,0,2], [0,0,1,2], [0,0,0,0,2], [0,0,0,0,1,2], [0,0,0,0,0,0,2], [0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2]], [[[0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [16][06] [[4], [1,4], [2,2,4], [1,1,0,4], [1,1,1,1,4], [2,1,2,1,1,4], [1,2,2,1,1,1,4], [1,1,1,2,1,1,1,4], [1,-1,1,0,1,2,0,1,4], [1,1,1,2,0,1,2,2,1,4], [2,1,2,1,0,2,2,2,1,2,4], [1,0,1,1,0,2,1,2,2,2,2,4], [1,1,0,2,1,0,1,1,1,1,0,1,4], [2,0,1,1,2,2,0,1,2,0,0,0,1,4], [2,1,1,1,2,1,1,1,1,0,1,-1,1,2,4], [1,1,2,0,2,2,1,0,1,-1,1,1,1,1,1,4]], [[[-1,0,1,0,1,0,-1,-1,-1,-1,1,2,1,0,1,-2], [0,1,0,1,0,-1,0,-1,1,0,0,1,-1,0,0,0], [-1,0,1,0,1,0,-1,-1,-1,0,0,2,0,0,1,-1], [0,0,0,0,0,0,1,0,0,-1,0,1,0,0,0,-1], [0,-1,1,0,1,1,0,0,-1,0,0,0,1,-1,0,-1], [0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,1,0], [0,0,0,0,1,0,0,-1,0,0,0,1,0,0,0,-1], [-1,0,1,0,0,-1,0,-1,-1,0,0,2,0,1,1,-1], [0,0,0,0,0,0,0,0,-1,0,-1,1,0,0,1,0], [-1,0,0,0,0,0,0,-1,-1,0,0,2,0,1,1,-1], [-2,0,1,-1,1,0,-1,-2,-2,0,1,3,1,1,2,-2], [-1,0,0,0,0,-1,0,-1,-1,0,0,2,0,1,1,0], [1,1,-1,1,0,-1,1,0,1,-1,0,0,-1,0,-1,0], [1,0,0,0,0,0,0,1,0,0,-1,0,0,-1,0,0], [0,0,1,0,1,1,0,0,0,-1,0,0,1,-1,0,-2], [0,0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0]], [[-1,0,1,0,1,0,-1,-1,-1,0,0,2,0,0,1,-1], [0,-1,1,0,1,1,0,0,0,-1,0,0,1,-1,0,-2], [-1,0,1,0,1,0,-1,-1,-1,-1,1,2,1,0,1,-2], [0,0,0,0,0,0,0,0,0,1,-1,0,0,0,0,0], [1,1,-1,1,0,0,1,1,2,-1,-1,-1,-1,-1,-1,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,-1,1,0], [-1,0,1,0,1,0,0,-1,0,-1,1,1,1,0,0,-2], [-1,0,0,0,0,0,0,-1,-1,0,0,2,0,1,1,-1], [-1,0,0,0,0,0,0,0,-1,0,0,1,0,0,1,0], [-1,0,1,0,0,-1,0,-1,-1,0,0,2,0,1,1,-1], [-2,0,1,-1,1,0,-1,-2,-2,0,1,3,1,1,2,-2], [-1,0,0,0,0,-1,0,-1,-1,0,0,2,0,1,1,0], [-1,-1,1,0,1,1,0,0,-1,0,0,0,1,0,0,-1], [0,0,0,0,0,1,0,1,0,0,-1,0,0,-1,0,0], [0,0,0,0,1,1,0,0,0,0,0,0,0,-1,0,-1], [0,0,0,0,1,1,0,0,0,-1,0,0,1,-1,0,-1]]]], [ # Q-class [16][07] [[4], [0,4], [-2,0,4], [0,-2,-2,4], [0,0,0,-2,4], [0,0,0,0,-2,4], [0,0,0,0,0,-2,4], [0,0,0,0,0,0,-2,4], [2,0,-1,0,0,0,0,0,4], [0,2,0,-1,0,0,0,0,0,4], [-1,0,2,-1,0,0,0,0,-2,0,4], [0,-1,-1,2,-1,0,0,0,0,-2,-2,4], [0,0,0,-1,2,-1,0,0,0,0,0,-2,4], [0,0,0,0,-1,2,-1,0,0,0,0,0,-2,4], [0,0,0,0,0,-1,2,-1,0,0,0,0,0,-2,4], [0,0,0,0,0,0,-1,2,0,0,0,0,0,0,-2,4]], [[[0,0,0,0,0,0,0,0,-2,-3,-4,-6,-5,-4,-3,-1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,1,1,2,1,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,1,1,1,1,1], [2,3,4,6,5,4,3,1,-2,-3,-4,-6,-5,-4,-3,-1], [0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0], [0,-1,-1,-2,-1,0,0,0,0,1,1,2,1,0,0,0], [-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,-1,0,-1,-1,-1,-1,-1,0,1,0,1,1,1,1,1]], [[-2,-3,-4,-6,-5,-4,-3,-2,2,3,4,6,5,4,3,2], [0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0,0], [2,3,4,6,5,4,3,1,-2,-3,-4,-6,-5,-4,-3,-1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,-1,-1,-2,-2,-1,0,0,0,1,1,2,2,1,0,0], [-1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,2,3,4,6,5,4,3,2], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,-2,-3,-4,-6,-5,-4,-3,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,1,1,2,2,1,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0]]]], [ # Q-class [16][08] [[4], [0,4], [-2,2,4], [-2,2,2,4], [2,0,-1,-1,4], [0,2,1,1,0,4], [-1,1,2,1,-2,2,4], [-1,1,1,2,-2,2,2,4], [0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,-2,2,4], [0,0,0,0,0,0,0,0,-2,2,2,4], [0,0,0,0,0,0,0,0,2,0,-1,-1,4], [0,0,0,0,0,0,0,0,0,2,1,1,0,4], [0,0,0,0,0,0,0,0,-1,1,2,1,-2,2,4], [0,0,0,0,0,0,0,0,-1,1,1,2,-2,2,2,4]], [[[0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,-1,1,0,0,0,0,0,0,0,0,0], [0,0,1,-1,0,0,-1,1,0,0,0,0,0,0,0,0], [-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [-1,0,-1,0,1,0,1,0,0,0,0,0,0,0,0,0], [-1,1,-1,0,1,-1,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,-1,0,1,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0], [1,0,0,1,-1,0,0,-1,0,0,0,0,0,0,0,0], [0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0]]]], [ # Q-class [16][09] [[6], [0,6], [-1,3,6], [1,-1,-2,6], [0,0,-2,3,6], [1,-3,-3,3,2,6], [-1,3,3,0,1,0,6], [3,-1,-2,-1,-1,2,-1,6], [-2,-2,-2,1,-1,2,0,1,6], [2,-2,-2,3,3,2,0,-1,0,6], [-2,-2,-2,1,-1,2,0,-1,3,1,6], [-1,3,0,-1,0,-3,0,-2,-2,-2,-1,6], [3,3,1,2,0,-1,1,0,-1,1,-1,1,6], [3,1,-2,1,-1,1,-1,3,0,0,0,1,3,6], [3,1,0,2,-1,-1,-2,0,-1,1,-1,1,3,3,6], [-3,1,2,1,1,-2,1,-3,1,-1,0,1,0,-3,0,6]], [[[-1,1,0,1,-1,0,0,1,-1,1,0,0,-1,0,0,0], [-1,0,-1,0,-1,0,0,0,0,1,-1,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,-1,-1,-1,1,0,0,-1,1,0,0,0,0,0,1], [-1,0,-2,-1,-1,1,1,0,-1,0,-1,0,1,-1,1,0], [0,1,-1,0,-1,1,0,0,-1,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,1,0,1,-1,0,0,0,0,0,0,0,-1,0,0,0], [1,0,2,0,1,0,-1,0,1,0,1,1,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,-1,0,0,0,0,0,1,-1,1], [0,0,0,0,1,-1,0,0,1,0,0,0,0,0,0,-1], [0,1,1,1,-1,0,-1,1,0,2,0,1,-1,0,-1,0], [0,2,0,1,-1,0,-1,0,0,1,0,0,-1,0,-1,0], [-1,1,-1,0,-1,0,0,0,-1,1,0,-1,0,0,0,0], [0,-1,-1,-1,0,0,1,0,0,0,0,0,1,-1,1,0]], [[1,0,0,-1,0,1,0,-1,0,0,0,0,0,1,-1,1], [0,0,1,1,0,0,0,1,0,0,1,1,0,-1,0,-1], [-1,-1,-1,0,0,0,1,0,-1,-1,0,0,1,-1,1,-1], [1,0,1,0,0,0,-1,-1,1,0,0,0,0,1,-1,0], [1,1,1,1,0,0,-1,-1,1,0,0,0,-1,1,-1,0], [0,0,-1,0,-1,0,0,-1,0,0,-1,-1,0,1,-1,1], [0,-1,1,1,1,-1,0,0,0,-1,1,0,0,0,0,-1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,-1,0,0,0,0,0,-1,0,0,0,0], [1,0,2,0,1,0,-1,-1,1,0,0,0,-1,2,-1,0], [-1,0,1,0,0,0,-1,1,0,1,0,0,0,0,0,0], [0,0,1,0,1,0,0,1,1,0,1,1,0,-1,1,-1], [1,0,2,0,1,0,-1,0,1,0,1,1,0,0,-1,-1], [1,0,2,0,1,0,-1,1,1,0,1,1,0,0,-1,0], [0,0,0,-1,0,1,0,0,0,0,0,0,1,0,0,0], [-1,0,0,0,0,0,0,0,0,0,0,0,1,-1,1,-1]], [[0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [1,0,-1,0,0,0,0,-1,0,-1,0,-1,0,0,0,0], [1,0,-2,0,0,-1,1,-1,0,-1,0,-1,0,0,0,0], [0,-1,1,-1,1,0,0,0,0,0,0,0,0,1,0,0], [0,0,1,0,0,0,-1,0,0,0,0,0,0,1,-1,0], [0,-1,3,0,2,-1,-1,1,1,0,1,1,0,0,0,-1], [1,0,1,0,2,-1,-1,0,1,-1,1,0,0,0,0,-1], [1,0,2,0,1,0,-1,0,1,0,1,1,-1,0,0,0], [0,0,2,0,1,0,-1,1,0,1,1,1,0,0,0,0], [-1,0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0], [-1,-1,1,0,1,0,0,1,0,0,0,1,1,-1,1,-1], [0,1,-1,0,-1,1,0,-1,0,0,-1,-1,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,-1,0,1,0,0,0,0,0,0,0,-1,1,0], [0,0,-2,-1,-1,1,1,-1,-1,0,-1,-1,0,0,0,1], [1,0,0,0,0,0,0,-1,0,0,0,0,0,1,-1,0]]]], [ # Q-class [16][10] [[2], [1,2], [1,1,2], [1,1,1,2], [0,0,0,0,2], [0,0,0,0,1,2], [0,0,0,0,1,1,2], [0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,1,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2]], [[[0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0]], [[-1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]]]], [ # Q-class [16][11] [[8], [2,8], [2,3,8], [2,2,3,8], [3,2,2,3,8], [1,2,4,3,3,8], [3,3,2,2,2,2,8], [1,2,4,1,3,4,4,8], [3,2,2,1,3,4,4,4,8], [2,2,3,2,3,1,3,3,1,8], [3,3,2,3,2,4,2,2,4,2,8], [4,3,1,2,2,2,3,1,1,4,1,8], [2,4,3,2,1,3,3,3,3,2,3,2,8], [4,2,1,2,3,1,3,1,0,2,3,4,-1,8], [2,3,3,4,2,1,1,1,2,4,1,4,2,0,8], [3,4,2,2,1,3,3,2,0,-1,1,2,4,2,0,8]], [[[-3,-2,2,0,1,-3,-1,-1,3,1,2,2,-2,-1,-1,4], [-2,-1,2,0,1,-3,-1,0,2,0,2,3,-2,-2,-1,3], [-2,-1,2,0,1,-3,-1,0,2,0,2,2,-1,-1,-1,2], [1,0,0,-1,1,1,2,1,-3,-2,1,0,0,-1,1,-2], [-1,-1,1,0,0,-1,0,0,1,0,1,1,-1,-1,0,1], [-3,-2,2,0,1,-4,-1,0,3,0,2,3,-1,-1,-1,3], [-2,-1,2,0,1,-2,0,-1,2,0,1,2,-1,-1,-1,2], [-3,-2,3,0,1,-4,-1,-1,3,0,2,3,-1,-1,-1,3], [-3,-2,2,0,1,-3,-1,-1,3,0,2,3,-1,-1,-1,3], [-5,-2,4,1,1,-6,-2,-1,5,1,3,5,-3,-2,-3,5], [-3,-2,2,0,1,-3,-1,0,2,0,2,3,-1,-1,-1,3], [-4,-2,3,0,1,-5,-1,-1,4,1,3,4,-3,-2,-2,5], [-5,-3,4,1,2,-7,-2,-1,5,1,4,6,-3,-3,-3,6], [0,0,0,-1,0,1,1,0,-1,0,0,-1,0,0,1,0], [-2,-1,2,0,1,-3,0,0,1,-1,3,3,-2,-2,-1,2], [-1,-1,1,0,1,-2,0,0,1,0,1,1,-1,-1,0,2]], [[-4,-2,3,0,1,-5,-1,-1,4,1,3,4,-3,-2,-2,5], [-2,-1,2,0,1,-2,0,-1,1,0,2,2,-1,-1,-1,2], [-3,-1,2,1,1,-4,-1,-1,3,1,2,3,-2,-2,-2,4], [-2,-1,1,0,0,-2,-1,-1,2,1,1,1,-1,0,0,3], [-4,-2,3,0,1,-5,-2,-1,4,1,3,4,-2,-2,-2,5], [-2,-1,1,0,1,-2,-1,-1,2,1,1,2,-1,-1,-1,3], [-1,-1,1,0,0,-1,0,-1,1,1,1,1,-1,-1,-1,2], [-1,-1,1,0,1,-2,0,0,0,0,2,2,-1,-2,-1,2], [-2,-1,2,0,1,-3,-1,-1,2,1,2,3,-2,-2,-2,3], [0,0,0,0,0,0,0,0,0,0,1,0,-1,-1,0,1], [1,1,-1,-1,0,2,1,0,-2,0,0,-1,0,0,1,-1], [-3,-2,2,0,1,-3,-1,-1,3,1,2,2,-2,-1,-1,4], [-2,-1,1,0,1,-2,0,-1,1,0,2,2,-1,-1,-1,2], [0,0,0,-1,0,1,1,0,-1,0,0,-1,0,0,1,0], [-4,-2,3,1,1,-5,-2,-1,4,1,3,4,-3,-2,-2,5], [-3,-2,2,0,1,-3,0,-1,2,0,2,3,-1,-1,-1,3]]]], [ # Q-class [16][12] [[4], [1,4], [2,2,4], [2,1,1,4], [2,2,1,2,4], [1,2,1,1,2,4], [1,2,1,2,1,1,4], [1,2,2,2,1,1,1,4], [2,1,2,1,1,1,1,1,4], [1,1,1,2,1,1,1,2,2,4], [2,1,2,1,1,2,2,1,2,1,4], [1,2,1,1,2,2,1,1,2,2,1,4], [1,1,1,2,1,2,1,2,1,2,2,1,4], [1,2,2,1,1,1,1,2,1,1,1,1,1,4], [1,2,1,2,1,1,2,1,2,1,1,1,1,1,4], [1,1,1,1,1,2,1,1,1,1,2,1,2,2,2,4]], [[[1,-4,1,-3,1,1,1,0,-3,1,0,1,1,2,4,-3], [0,-1,0,0,0,1,0,0,0,0,0,0,0,1,0,-1], [1,-5,1,-4,2,1,1,1,-3,1,0,1,1,2,4,-3], [0,0,0,0,0,0,-1,-1,-1,1,1,0,0,1,1,-1], [0,0,0,0,0,0,0,-1,0,0,0,0,1,1,0,-1], [0,0,-1,0,0,0,0,0,0,0,1,0,0,1,0,-1], [1,-1,0,-1,0,1,0,0,-1,1,0,0,0,1,1,-1], [0,-1,0,0,0,0,-1,0,-1,0,1,1,0,1,1,-1], [1,-4,1,-4,1,1,1,1,-3,1,0,1,1,2,4,-3], [0,0,0,0,0,0,-1,0,-1,0,1,0,0,1,1,-1], [2,-4,0,-4,1,1,1,1,-3,1,0,1,1,2,4,-3], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,-1], [0,0,-1,0,0,0,-1,0,0,0,1,0,0,1,1,-1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,-1,0,-1,0,1,0,0,-1,1,0,0,0,1,1,-1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0]], [[1,-5,1,-4,2,1,1,1,-3,1,0,1,1,2,4,-3], [1,-4,1,-4,1,1,1,1,-3,1,0,1,1,1,4,-2], [1,-4,1,-4,1,1,1,1,-3,1,0,1,1,2,4,-3], [1,-4,1,-4,2,1,1,1,-3,1,0,1,1,1,4,-3], [1,-4,1,-4,2,0,1,1,-3,1,0,1,1,1,4,-2], [1,-4,1,-3,1,1,1,1,-3,1,0,1,0,1,4,-2], [1,-3,1,-3,1,1,1,0,-3,1,0,1,1,1,3,-2], [1,-4,1,-4,1,1,1,1,-3,1,0,1,1,1,4,-3], [2,-4,0,-4,1,1,1,1,-3,1,0,1,1,2,4,-3], [2,-4,1,-4,1,1,1,1,-3,1,0,1,1,1,4,-3], [1,-4,1,-3,1,1,1,0,-3,1,0,1,1,2,4,-3], [2,-4,1,-4,1,1,1,1,-3,1,-1,1,1,1,4,-2], [1,-4,1,-3,1,1,1,1,-3,1,0,1,1,1,4,-3], [1,-4,1,-4,1,1,2,1,-2,1,-1,1,1,1,3,-2], [1,-3,0,-3,1,1,1,1,-2,0,0,1,1,1,3,-2], [1,-4,1,-3,1,1,2,1,-2,0,-1,1,1,1,3,-2]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1]]]], [ # Q-class [16][13] [[4], [-2,4], [0,0,4], [1,-2,2,4], [1,-2,0,2,4], [-2,2,-1,-2,0,4], [-2,2,2,0,-1,0,4], [-1,-1,-2,-1,-1,0,-1,4], [0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,-2,4], [0,0,0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,1,-2,2,4], [0,0,0,0,0,0,0,0,1,-2,0,2,4], [0,0,0,0,0,0,0,0,-2,2,-1,-2,0,4], [0,0,0,0,0,0,0,0,-2,2,2,0,-1,0,4], [0,0,0,0,0,0,0,0,-1,-1,-2,-1,-1,0,-1,4]], [[[0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,1,-1,1,0,0,0,0,0,0,0,0,0,0,0], [0,2,1,0,1,-1,-1,1,0,0,0,0,0,0,0,0], [-1,1,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0], [0,1,1,-1,1,-1,-1,0,0,0,0,0,0,0,0,0], [0,-1,-1,1,-1,1,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,-1,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [-1,-1,-1,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0]]]], [ # Q-class [16][14] [[6], [3,6], [3,3,6], [3,3,3,6], [3,3,3,3,6], [2,-1,2,-1,2,6], [2,-1,2,-1,-1,3,6], [2,-1,2,-1,-1,3,3,6], [2,-1,2,-1,-1,3,3,3,6], [3,2,2,1,3,3,2,1,1,6], [3,2,3,2,1,2,2,3,2,3,6], [2,2,3,1,0,0,1,3,1,1,3,6], [2,1,3,3,2,2,2,1,0,1,3,0,6], [-2,-3,-3,-2,-1,-1,-2,0,-1,-1,-3,-2,-3,6], [3,3,2,1,1,1,2,0,2,3,1,0,0,-2,6], [-2,-3,-2,-3,-1,0,1,0,-1,0,-3,-2,-2,3,-1,6]], [[[-2,1,-2,1,2,-1,1,1,2,0,0,0,0,0,0,0], [-3,1,-3,1,3,0,1,0,2,-2,1,2,1,1,2,1], [-2,2,-3,1,2,0,1,0,2,-2,1,1,1,1,1,1], [-2,1,-3,1,2,0,0,1,2,-1,0,1,1,0,1,1], [-2,1,-2,1,2,0,1,1,1,-1,0,0,0,0,1,0], [0,1,0,0,0,0,1,0,0,0,0,-1,-1,0,-1,-1], [-1,2,-1,1,0,0,1,0,1,0,0,0,0,1,-1,0], [1,0,1,-1,-1,-1,0,0,0,1,0,-1,0,0,-1,-1], [1,0,1,0,-1,0,0,-1,0,0,1,-1,-1,0,-1,0], [-1,0,0,0,1,-1,1,1,0,0,0,-1,-1,0,0,-1], [-1,1,-1,0,1,0,1,0,1,-1,1,0,0,1,0,0], [-1,0,-2,0,2,-1,1,0,1,-1,1,1,1,1,1,0], [-2,3,-3,1,1,1,1,0,2,-1,0,1,1,1,0,1], [2,-2,3,-1,-2,-1,-1,1,-2,2,-1,-2,-1,-2,-1,-1], [-1,0,0,0,1,-1,0,0,1,0,0,0,0,0,0,0], [2,-1,3,-1,-2,-1,-1,1,-2,2,-1,-2,-1,-1,-1,-1]], [[-2,2,-3,1,2,1,1,-1,2,-2,1,2,1,1,1,2], [-3,2,-3,2,2,1,1,0,2,-2,1,2,1,1,1,2], [-3,3,-4,2,2,1,1,0,2,-2,1,2,1,1,1,2], [-2,2,-3,2,1,1,1,-1,2,-2,1,2,1,1,1,2], [-1,2,-2,1,0,2,0,-1,1,-2,1,2,1,1,1,2], [0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,-1,0,1,0,1,0,0,0,0,0,0,0,0,0], [-1,1,-2,0,2,-1,1,1,1,0,0,0,0,0,0,0], [0,0,0,-1,1,-1,0,0,0,0,0,0,0,0,0,0], [-1,1,-1,0,1,1,1,-1,0,-2,2,1,0,1,1,1], [-3,2,-4,1,3,0,2,0,2,-2,1,2,1,1,1,1], [-2,2,-3,1,2,0,1,0,2,-1,1,1,1,1,0,1], [-3,3,-4,2,2,1,2,0,2,-2,0,2,1,1,1,1], [3,-2,3,-1,-2,0,-1,0,-2,1,0,-2,-2,-1,-1,-1], [-1,0,0,0,1,0,0,0,0,-1,1,0,0,0,1,1], [2,-2,2,-1,-1,0,-1,0,-2,1,0,-1,-1,-1,0,-1]]]], [ # Q-class [16][15] [[4], [2,4], [2,2,4], [2,2,2,4], [2,1,1,1,4], [1,2,1,1,2,4], [1,1,2,1,2,2,4], [1,1,1,2,2,2,2,4], [0,0,0,0,2,1,1,1,4], [0,0,0,0,1,2,1,1,2,4], [0,0,0,0,1,1,2,1,2,2,4], [0,0,0,0,1,1,1,2,2,2,2,4], [0,0,0,0,2,1,1,1,0,0,0,0,4], [0,0,0,0,1,2,1,1,0,0,0,0,2,4], [0,0,0,0,1,1,2,1,0,0,0,0,2,2,4], [0,0,0,0,1,1,1,2,0,0,0,0,2,2,2,4]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,1,0,0,0,1], [0,0,0,0,0,0,1,-1,0,0,-1,1,0,0,-1,1], [0,0,0,0,0,1,0,-1,0,-1,0,1,0,-1,0,1], [0,0,0,0,1,0,0,-1,-1,0,0,1,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0], [0,0,0,1,0,0,0,-2,0,0,0,1,0,0,0,1], [0,0,-1,1,0,0,2,-2,0,0,-1,1,0,0,-1,1], [0,-1,0,1,0,2,0,-2,0,-1,0,1,0,-1,0,1], [-1,0,0,1,2,0,0,-2,-1,0,0,1,-1,0,0,1]], [[-1,0,0,0,1,0,0,0,-1,0,0,0,-1,0,0,0], [-1,0,0,1,1,0,0,-1,-1,0,0,1,-1,0,0,1], [-1,1,0,0,1,-1,0,0,-1,1,0,0,-1,1,0,0], [-1,0,1,0,1,0,-1,0,-1,0,1,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,1,1,0,0,-1,0,0,0,0], [0,0,0,0,-1,1,0,0,1,-1,0,0,0,0,0,0], [0,0,0,0,-1,0,1,0,1,0,-1,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,1,0,0,-1,0,0,0,0,-1,0,0,1], [0,0,0,0,1,-1,0,0,0,0,0,0,-1,1,0,0], [0,0,0,0,1,0,-1,0,0,0,0,0,-1,0,1,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0]]]], [ # Q-class [16][16] [[8], [1,8], [3,4,8], [4,4,2,8], [4,3,1,4,8], [4,2,1,2,3,8], [2,4,4,1,4,3,8], [3,1,4,1,2,4,2,8], [4,2,4,4,4,1,3,4,8], [4,2,3,3,1,4,1,3,2,8], [4,3,1,3,2,4,2,2,1,4,8], [3,2,1,2,4,4,4,2,1,3,4,8], [4,1,2,3,2,4,3,2,1,4,4,2,8], [4,1,2,2,1,4,3,3,3,4,4,3,4,8], [4,4,4,3,2,4,4,3,1,4,4,3,4,4,8], [4,1,3,1,2,4,2,4,3,4,0,2,0,4,4,8]], [[[-1,-1,1,0,1,0,0,-1,0,0,1,-1,0,0,0,1], [0,0,-1,-1,0,0,0,0,1,1,-1,0,0,0,1,-1], [-1,0,0,0,0,-1,0,0,0,0,0,0,1,0,0,1], [-1,0,0,-1,0,0,-1,-1,1,-1,1,0,2,-1,0,2], [-1,-1,1,-1,1,1,-1,-1,1,0,0,0,0,0,1,0], [-1,-1,0,0,0,0,0,-1,1,0,1,0,0,-1,1,1], [-1,-1,0,0,0,0,0,0,1,0,0,0,0,0,1,0], [-1,0,0,0,0,-1,0,0,0,0,1,0,1,-1,0,2], [-1,0,0,0,0,-1,0,0,0,-1,1,0,2,-1,-1,3], [0,-1,0,1,0,0,1,0,-1,1,0,-1,-1,0,0,0], [0,-1,0,0,1,0,0,0,0,1,0,-1,-1,0,1,-1], [0,-1,0,0,1,1,0,0,0,1,-1,-1,-2,1,2,-2], [-2,-1,1,0,0,0,-1,-1,1,-1,2,0,1,-1,0,2], [-1,-1,0,1,0,0,1,0,0,0,1,-1,0,-1,0,1], [0,-1,0,0,0,0,1,0,0,1,0,-1,-1,0,1,-1], [0,-1,0,1,0,0,2,0,-1,1,0,-1,-1,0,0,0]], [[1,0,0,0,1,0,0,1,-1,1,-2,0,-2,2,1,-3], [0,0,0,0,0,0,0,0,0,1,0,0,-1,1,0,-1], [0,-1,1,0,2,1,0,0,-1,2,-1,-1,-3,2,1,-3], [1,0,0,0,0,1,0,0,0,1,-2,0,-2,2,1,-3], [1,1,0,-1,0,0,-1,0,0,0,-1,1,0,1,0,-1], [1,0,-1,0,0,-1,1,1,-1,1,-1,0,-1,1,0,-1], [0,-1,1,0,1,0,0,0,-1,1,0,0,-1,1,0,-1], [0,0,0,0,1,0,0,0,-1,1,-1,0,-1,1,0,-1], [-1,0,1,-1,1,1,-2,-1,1,0,-1,1,0,1,1,-1], [1,0,-1,0,1,0,1,1,-1,2,-2,-1,-2,2,1,-3], [1,0,-1,1,0,-1,1,1,-1,1,-1,0,-1,1,0,-1], [2,0,-1,0,0,0,1,1,-1,2,-2,0,-2,1,1,-3], [1,-1,0,1,1,0,1,1,-2,1,-1,-1,-2,2,0,-2], [0,-1,0,0,1,0,0,0,0,1,-1,0,-1,1,1,-2], [1,-1,0,1,1,0,2,1,-2,2,-1,-1,-3,2,0,-3], [0,0,0,-1,1,0,0,0,0,1,-1,0,-1,1,1,-2]]]], [ # Q-class [16][17] [[4], [2,4], [2,1,4], [1,2,2,4], [2,1,2,1,4], [1,2,1,2,2,4], [2,1,2,1,2,1,4], [1,2,1,2,1,2,2,4], [0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,2,4], [0,0,0,0,0,0,0,0,2,1,4], [0,0,0,0,0,0,0,0,1,2,2,4], [0,0,0,0,0,0,0,0,2,1,2,1,4], [0,0,0,0,0,0,0,0,1,2,1,2,2,4], [0,0,0,0,0,0,0,0,2,1,2,1,2,1,4], [0,0,0,0,0,0,0,0,1,2,1,2,1,2,2,4]], [[[0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0], [0,0,0,0,1,-1,-1,1,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,1,-1,0,0,-1,1,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [1,-1,0,0,0,0,-1,1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,1,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,-1,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,1,1,-1,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,-1,1,0,0,1,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0]]]], [ # Q-class [16][18] [[8], [-4,8], [2,-1,8], [-1,2,-4,8], [4,-2,2,-1,8], [-2,4,-1,2,-4,8], [4,-2,0,0,0,0,8], [-2,4,0,0,0,0,-4,8], [4,-2,4,-2,4,-2,0,0,8], [-2,4,-2,4,-2,4,0,0,-4,8], [4,-2,4,-2,2,-1,4,-2,4,-2,8], [-2,4,-2,4,-1,2,-2,4,-2,4,-4,8], [4,-2,-2,1,4,-2,2,-1,0,0,2,-1,8], [-2,4,1,-2,-2,4,-1,2,0,0,-1,2,-4,8], [-4,2,2,-1,-4,2,-4,2,-2,1,-2,1,-4,2,8], [2,-4,-1,2,2,-4,2,-4,1,-2,1,-2,2,-4,-4,8]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,-1,0,-1,0,1,0,0,0,0], [0,0,0,0,0,0,-1,0,-1,0,1,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,1,0,0,0,0,0,1,0,-1,0,1], [0,0,-1,0,1,0,0,0,0,0,1,0,-1,0,1,0], [0,-1,0,0,0,0,0,1,0,1,0,-1,0,1,0,0], [-1,0,0,0,0,0,1,0,1,0,-1,0,1,0,0,0]], [[-1,-1,0,0,-1,-1,0,0,1,1,0,0,1,1,0,0], [1,0,0,0,1,0,0,0,-1,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,-1,0], [0,0,0,0,-1,-1,0,0,1,1,0,0,1,1,0,0], [0,0,0,0,1,0,0,0,-1,0,0,0,-1,0,0,0], [-1,-1,0,0,0,0,0,0,0,0,1,1,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,-1,-1,0,0,0,0,0,0,1,1,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,-1,0,0,0], [0,0,-1,-1,0,0,0,0,0,0,1,1,0,0,1,1], [0,0,1,0,0,0,0,0,0,0,-1,0,0,0,-1,0], [0,0,0,0,-1,-1,0,0,1,1,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,1,1,1,1,0,0,-1,-1,0,0,1,1], [0,0,0,0,-1,0,-1,0,0,0,1,0,0,0,-1,0]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,1,0,0,0,1,0,0,0], [0,0,0,0,0,-1,0,0,0,1,0,0,0,1,0,0], [0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0]]]], [ # Q-class [16][19] [[10], [3,10], [4,5,10], [-3,-5,-5,10], [-5,2,-2,3,10], [4,5,0,-5,-1,10], [-3,-3,-5,0,-2,2,10], [5,2,5,-2,-5,2,-2,10], [-2,-3,-5,0,-2,0,2,0,10], [-5,-5,-3,5,3,-5,2,-5,-2,10], [5,4,1,1,0,3,-2,0,-4,-2,10], [5,5,5,-5,0,3,-5,1,-2,-2,3,10], [3,-2,2,3,-4,-2,0,4,0,1,0,0,10], [-5,-5,-3,0,0,-2,4,-5,3,5,-5,-2,-2,10], [-1,3,-2,-3,-1,5,2,2,3,-4,-2,-2,-2,-2,10], [5,-1,3,2,-3,-1,-5,5,-1,0,3,2,5,-3,-3,10]], [[[1,0,1,1,1,-1,2,-1,0,-1,-1,1,-1,0,1,2], [1,0,2,1,0,0,1,-1,1,1,0,0,-1,0,1,1], [1,-1,3,2,1,0,2,-1,1,0,0,1,-1,0,2,1], [0,1,-1,-1,0,0,-1,0,0,0,0,-1,1,0,-1,-1], [0,1,0,0,-1,1,-1,0,1,2,0,-1,0,-1,-1,-1], [0,1,-2,-1,0,-1,0,1,-1,0,0,0,0,1,0,1], [-1,0,-2,-2,0,0,-2,2,-1,0,1,-1,1,1,-1,-1], [1,-1,1,0,2,-2,2,0,0,-1,1,1,0,1,2,1], [-1,0,-1,0,-1,-1,0,0,-1,-1,0,1,0,0,0,0], [0,0,-1,-1,0,1,-2,1,0,1,0,-1,1,0,-1,-2], [1,1,0,0,0,0,0,-1,0,0,-1,-1,0,0,0,1], [1,0,1,2,0,0,1,-1,0,0,-1,1,-1,0,1,1], [1,0,1,1,1,-1,1,0,0,-1,0,1,0,1,1,0], [-2,0,-2,-1,-1,1,-2,1,-1,0,0,0,1,0,-1,-1], [0,0,-1,-1,0,-1,0,1,0,0,1,0,0,1,0,0], [1,0,1,1,1,-1,2,-1,0,-1,-1,1,0,0,1,1]], [[0,0,1,1,0,-1,2,-1,0,-1,0,1,-1,0,1,2], [1,0,1,1,0,0,1,-1,1,0,-1,0,-1,-1,0,1], [1,0,0,0,1,-1,1,0,0,-1,0,0,0,1,1,1], [-1,0,-1,-2,0,1,-2,1,0,1,1,-1,1,0,-1,-1], [0,-1,1,0,0,2,-1,0,1,1,0,-1,0,-1,-1,-1], [0,0,0,1,-1,0,1,-1,0,0,-1,1,-1,-1,0,1], [0,0,0,0,-1,0,-1,0,0,1,0,0,0,0,0,-1], [0,1,-2,-1,0,-1,0,0,-1,-1,0,0,1,1,0,1], [-1,1,-1,1,-1,0,0,0,-1,-1,-1,1,0,0,-1,0], [0,-1,-1,-2,1,0,-2,2,0,1,2,-1,1,1,0,-2], [0,0,1,0,0,0,1,0,1,1,0,0,-1,-1,0,1], [1,-1,1,1,1,-1,2,0,0,-1,0,1,-1,0,1,1], [-1,0,-2,-2,0,-1,-1,1,-1,-1,1,0,1,1,0,0], [0,0,-1,0,0,0,-1,1,-1,0,0,0,0,1,0,-1], [0,1,-1,0,-1,0,0,-1,0,0,-1,0,0,-1,-1,0], [-1,0,-2,-2,1,-1,0,1,-1,-1,1,0,1,1,0,1]]]], [ # Q-class [16][20] [[8], [-3,8], [0,1,8], [0,-2,1,8], [-3,2,1,3,8], [-2,3,3,-3,-2,8], [1,-3,3,3,2,0,8], [0,-3,1,1,-3,-1,2,8], [0,-1,2,3,-1,2,0,-1,8], [-1,0,-1,-2,1,-2,1,2,-3,8], [2,-3,1,2,-3,-2,1,2,2,0,8], [1,1,-2,2,1,-3,-3,0,1,0,-2,8], [-3,-2,2,3,0,0,2,3,1,-2,2,-1,8], [-2,0,-1,0,1,-3,-3,1,-2,-1,1,2,3,8], [0,3,-3,-2,-2,0,-2,1,-1,3,0,2,-3,0,8], [1,3,2,-2,-2,2,0,0,-2,2,2,-3,-2,-2,2,8]], [[[0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,1,0,1,-2,0,1,-1,0,1,-1,0,0,1,-1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,1,-1,0,0], [0,-1,0,0,1,1,-1,0,-1,0,1,1,0,-1,0,0], [0,0,0,1,-1,1,0,-1,-1,1,0,0,0,0,0,-1], [0,0,0,-1,0,-1,0,0,1,0,-1,0,1,0,0,1], [1,0,-1,-1,2,1,-1,1,0,0,1,0,1,-1,0,0], [0,0,0,-1,2,0,-1,1,0,-1,1,0,0,-1,0,0], [-1,-1,0,-1,0,-1,0,0,0,-1,0,1,0,-1,0,1], [1,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,-1], [0,0,0,-1,1,0,0,1,0,-1,1,1,0,-1,0,0], [-1,-1,1,1,-1,0,0,-1,-1,0,0,0,-1,0,0,0], [0,0,0,0,1,0,-1,1,0,0,0,0,0,-1,0,0], [-1,0,1,1,-1,0,0,0,-1,0,0,0,-1,0,0,-1], [0,1,0,0,-1,0,1,0,0,0,0,0,-1,1,-1,0], [1,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0]], [[0,0,0,0,0,0,1,0,0,0,0,0,-1,1,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,1,1,0,0,0,0,1,0,0,0,0,0], [0,0,0,-1,1,-1,0,0,0,-1,0,0,1,-1,1,0], [-1,0,0,-1,0,-1,0,0,0,-1,0,0,0,-1,0,0], [0,0,0,1,-1,1,0,-1,0,1,0,0,0,1,0,0], [-1,0,0,0,-1,-1,1,-1,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,1,0,-1,0,0,0,0,-1,1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [1,0,-1,-1,2,0,0,1,1,0,0,0,1,0,0,1], [0,-1,1,0,1,0,-1,0,-1,-1,0,0,0,-1,1,0], [0,-1,0,0,1,0,-1,0,0,0,0,0,1,-1,1,0], [0,0,0,0,1,0,-1,1,0,0,0,0,0,-1,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [1,1,-1,0,0,1,1,0,1,1,0,0,0,1,-1,0]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1]]]], [ # Q-class [16][21] [[12], [6,12], [-6,-6,12], [-6,-6,0,12], [-3,-2,1,3,12], [1,3,0,-2,-6,12], [2,3,-3,-1,-6,6,12], [0,1,1,-3,-6,6,0,12], [-4,-6,6,2,4,-6,-6,-2,12], [4,6,-6,-2,0,-3,3,-3,0,12], [6,4,-2,-6,3,-1,-2,0,2,2,12], [-6,-4,2,6,6,-2,-4,0,2,-3,-3,12], [4,6,-6,-2,2,-3,-3,-1,-3,3,3,2,12], [-3,-6,3,3,0,3,-3,3,3,-6,-1,0,-6,12], [4,2,2,-2,0,3,3,-3,-4,0,2,-3,-1,-2,12], [3,0,3,-3,0,3,3,-3,-1,-2,1,0,0,0,6,12]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0], [0,0,-1,0,0,0,-1,0,0,0,0,0,-1,-1,0,0], [0,0,0,-1,-1,0,0,-1,0,0,0,1,0,1,0,-1], [0,0,0,-1,0,-1,1,0,0,0,0,1,0,1,1,-1], [0,0,-1,0,0,1,0,0,1,-1,0,0,0,-1,0,0], [0,0,0,0,0,1,0,0,1,0,0,0,1,0,0,0], [0,0,-1,0,1,1,0,0,1,-1,-1,-1,0,-1,0,0], [0,0,0,0,0,0,-1,0,-1,1,0,0,-1,0,0,0], [0,0,1,0,0,0,1,0,0,1,0,0,1,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,1,-1,-1,0,-1,1,0,1,-1,-1,1,0,1,1,-1], [0,0,1,0,0,-1,1,0,-1,0,0,0,1,1,0,0], [0,-1,-1,0,0,1,-1,0,0,0,0,0,-1,-1,0,0], [0,0,0,0,-1,0,0,-1,0,0,1,1,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0]], [[-1,-1,0,0,-1,0,-1,0,-1,1,1,0,0,0,0,0], [-1,0,-1,0,0,0,0,1,1,0,0,0,0,0,1,0], [1,0,0,0,1,0,0,0,0,0,-1,0,0,0,0,0], [1,0,1,0,0,1,0,-1,0,0,0,0,0,0,-1,0], [0,-1,0,0,1,1,0,0,0,0,0,-1,0,-1,0,0], [1,0,1,0,0,0,1,0,0,0,0,1,1,1,0,-1], [0,0,0,0,-1,0,0,0,0,0,0,1,0,0,0,0], [1,1,1,0,0,-1,1,0,0,0,0,1,0,1,0,-1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [-1,0,-1,0,-1,0,0,0,1,0,0,0,0,0,1,0], [-1,-1,0,0,0,0,0,0,-1,1,1,0,0,0,0,0], [1,0,1,1,1,1,0,0,0,0,0,-1,0,-1,-1,0], [-1,0,-1,1,0,0,-1,1,0,0,1,-1,-1,-1,0,1], [1,0,1,-1,0,0,1,-1,0,0,0,1,1,1,0,-1], [0,-1,0,0,0,1,-1,0,-1,1,0,0,0,0,0,0], [0,-1,-1,0,0,1,-1,0,0,0,0,0,0,-1,0,0]], [[0,-1,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,-1,0,-1,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,-1,0,0,0,-1,1,0,0,0,0,-1,-1,0,1], [1,-1,0,-1,0,1,0,-1,0,0,0,1,0,0,0,-1], [-1,1,-1,0,0,0,0,0,1,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,1,0,0,0,0,-1,-1,0,0,0,0,0,-1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,-1,0,0,0], [0,0,-1,0,0,0,1,0,1,-1,0,0,0,0,0,0]]]], [ # Q-class [16][22] [[8], [0,8], [2,2,8], [2,2,4,8], [-2,-2,-1,-3,8], [-2,0,-4,-4,2,8], [-2,2,1,2,0,-1,8], [-3,-1,-4,-2,2,2,1,8], [4,0,2,2,-1,-4,-1,-1,8], [1,-1,2,0,-1,-2,-1,-1,-2,8], [1,-1,0,0,-2,0,1,0,3,-1,8], [1,3,0,0,1,0,-2,0,3,-1,0,8], [-2,2,0,-2,4,2,-2,0,-1,-3,-4,4,8], [4,4,4,3,-2,-1,2,-4,2,-1,0,0,0,8], [1,-3,-3,-3,1,2,-1,-1,-1,-2,1,-4,-2,-1,8], [-1,3,2,2,-3,0,0,-2,-3,3,0,0,0,2,-4,8]], [[[0,1,-1,0,0,0,0,-1,0,1,1,-1,1,0,-1,-1], [-1,0,0,0,0,0,-1,0,-1,0,0,1,-1,1,0,-1], [0,0,-1,1,0,0,0,0,-1,1,1,0,1,1,0,-1], [-1,0,-1,1,0,0,0,0,0,1,1,0,1,1,0,-1], [0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,1], [0,0,1,0,-1,1,1,1,2,1,-1,0,1,-1,2,1], [-1,-1,0,1,-1,0,0,1,0,1,0,1,1,1,1,0], [0,0,1,0,0,1,0,0,1,-1,-1,0,-1,-1,0,1], [0,0,0,0,0,0,0,-1,-1,0,1,0,0,0,-1,-1], [1,1,-1,-1,1,-1,-1,-1,-2,-2,0,-1,-2,0,-3,-1], [0,-1,0,0,-1,1,1,0,1,1,0,0,1,0,0,0], [0,0,1,-1,0,0,0,0,-1,-1,0,1,-1,0,0,0], [0,0,1,0,0,0,0,1,0,0,0,1,0,0,2,1], [-1,0,-1,1,-1,0,0,0,0,2,1,0,2,1,1,-1], [0,0,0,0,0,0,0,0,1,1,0,-1,1,0,0,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0]], [[0,0,0,1,0,0,0,1,1,1,0,0,1,0,2,1], [0,0,0,1,0,0,0,0,-1,1,1,0,1,0,0,-1], [0,0,0,1,-1,0,0,1,0,1,1,0,2,0,1,0], [0,0,0,1,-1,0,1,1,1,2,1,0,3,0,2,0], [1,1,-1,-1,1,-1,-1,-1,-2,-2,0,-1,-2,0,-3,-1], [0,1,0,-1,1,0,-1,-1,-1,-1,0,-1,-2,0,-2,-1], [-1,0,-1,1,0,0,0,0,0,1,1,0,1,1,0,-1], [0,0,0,-1,1,-1,-1,-1,-2,-2,0,0,-2,1,-2,-1], [0,-1,0,1,-1,0,1,1,1,1,0,0,2,0,2,1], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,1,1], [-1,-1,0,1,-1,1,1,1,2,2,0,0,2,1,2,1], [0,0,0,0,0,-1,0,0,-1,0,0,0,0,0,0,0], [1,1,0,-1,1,-1,-1,-1,-2,-2,0,-1,-2,-1,-3,-1], [0,0,0,1,0,0,0,1,0,1,1,0,1,0,1,0], [0,0,0,0,0,1,0,0,1,0,-1,0,-1,0,0,0], [0,0,0,0,0,0,0,0,0,1,1,0,1,0,0,0]], [[0,0,-1,0,1,-1,-1,-1,-2,-1,1,0,-1,1,-2,-1], [1,1,0,-1,1,-1,-1,-1,-1,-2,0,-1,-2,-1,-2,0], [0,0,0,0,0,-1,0,0,-1,-1,0,1,-1,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,-1,-1,0,-1,0,-1,0], [0,0,-1,0,0,0,0,0,1,1,0,-1,1,0,0,0], [0,1,0,0,0,0,0,-1,0,0,0,-1,0,-1,-1,-1], [1,0,0,0,-1,1,1,0,1,1,0,-1,2,-1,0,0], [0,0,0,0,0,-1,-1,0,-2,-1,1,0,0,1,-1,-1], [0,0,0,0,0,0,0,0,-1,0,0,1,-1,0,0,0], [0,0,0,0,0,-1,-1,0,-2,0,1,0,0,1,-1,-2], [0,0,0,-1,0,-1,-1,0,-1,-1,0,0,-1,1,-1,0], [0,0,0,-1,0,0,0,0,1,-1,-1,0,-1,0,0,1], [0,1,-1,0,1,-1,-1,-1,-1,-1,1,-1,-1,0,-2,-1], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0]]]], [ # Q-class [16][23] [[6], [1,6], [-3,-1,6], [2,3,1,6], [0,2,2,3,6], [-2,1,2,2,0,6], [3,1,-2,0,-1,0,6], [1,0,-2,-1,-2,1,3,6], [1,1,-2,1,-2,2,1,0,6], [2,2,-3,0,-2,-2,0,0,0,6], [1,3,0,1,2,-1,2,-1,0,0,6], [1,-2,-2,-2,-2,-3,-1,-2,0,2,-2,6], [3,3,0,3,1,0,2,1,1,1,2,-2,6], [-2,1,0,0,-1,3,1,1,3,-1,-1,-1,-1,6], [3,-1,-1,0,-2,0,3,0,2,0,1,1,1,-1,6], [1,2,1,3,0,1,-1,-1,0,1,1,0,1,-1,1,6]], [[[0,-1,0,-1,1,0,0,0,0,0,0,0,1,1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,1,1,1,-1,0,0,0,0,0,0,0,-1,-1,0,-1], [-1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [-1,1,1,0,0,-1,1,0,1,0,-1,0,0,-1,0,0], [0,0,0,1,-1,0,-1,0,0,0,1,0,0,0,0,-1], [1,0,1,0,0,0,-1,1,0,0,1,1,0,1,0,0], [1,0,0,0,0,0,-1,0,0,0,0,0,0,1,0,0], [0,-1,-1,0,0,0,-1,0,-1,0,1,0,1,1,0,0], [0,-1,-1,-1,1,1,0,0,0,0,0,0,1,0,0,1], [1,1,1,-1,0,0,0,0,0,0,0,0,0,0,0,0], [-1,-1,-1,0,1,0,1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,-1,0,0,0,1,1,1,0], [0,0,0,1,0,0,-1,1,0,0,1,1,0,0,0,-1], [1,0,0,0,-1,0,-1,0,-1,-1,1,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0]], [[0,-1,0,-1,1,0,0,0,0,1,0,0,1,1,0,1], [0,-1,0,0,0,0,1,0,0,0,0,0,0,0,-1,1], [0,1,1,1,-1,0,0,0,0,0,0,0,-1,-1,0,-1], [-1,-1,0,0,1,0,1,0,0,1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,-1,0,0,0], [1,0,1,0,0,0,-1,1,0,0,1,1,0,1,0,0], [1,-1,0,0,0,0,-1,0,0,0,1,0,0,1,0,0], [-1,0,0,0,1,-1,1,0,1,0,-1,0,0,0,0,1], [0,-1,-1,-1,0,1,1,-1,0,0,0,0,1,0,-1,1], [0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0], [-1,0,-1,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,-1,1,-1,1,0,1,0,1,1,0,0,0,0,-1,1], [0,1,0,1,-1,-1,0,0,0,-1,0,0,-1,0,0,0], [0,0,1,0,1,0,0,1,1,1,0,1,0,0,0,0], [-1,-1,0,1,0,0,1,0,0,1,0,0,0,0,0,0]]]], [ # Q-class [16][24] [[8], [-4,8], [4,-2,8], [2,-4,0,8], [4,0,0,2,8], [0,-1,1,2,-1,8], [4,-2,2,1,2,0,8], [-2,4,-1,-2,0,-2,-4,8], [-3,1,1,-3,-1,-2,0,2,8], [2,1,-1,2,2,-2,-2,2,-4,8], [2,-1,4,0,0,2,4,-2,2,-2,8], [1,-2,0,4,1,4,2,-4,-3,1,0,8], [-3,1,-2,-3,-4,3,-3,2,0,-2,-1,0,8], [-1,-2,-3,1,0,-3,1,-1,2,-2,-3,-1,-2,8], [-4,4,0,0,-2,0,-2,2,1,-1,0,0,0,0,8], [3,-1,2,-1,-1,-3,0,1,-2,2,1,-2,0,-2,0,8]], [[[-2,-2,0,-1,1,1,2,0,0,1,-1,-1,0,-1,1,0], [2,1,-1,0,-1,-1,-2,1,0,-2,1,2,-1,0,-1,0], [-2,-2,0,-1,1,2,2,0,1,2,-1,-1,0,0,1,1], [-2,0,1,0,1,1,1,-1,0,1,-1,-1,0,0,0,1], [0,0,-1,0,0,0,0,0,0,-1,0,0,-1,-1,0,0], [-1,0,1,1,1,1,1,-1,1,1,-1,-1,1,0,0,1], [-1,-1,0,0,1,0,1,-1,1,1,-1,-1,1,-1,1,0], [0,0,0,-1,0,0,-1,1,-1,-1,1,1,-1,1,-1,0], [0,0,0,0,0,0,-1,0,0,0,1,0,0,1,0,0], [0,0,0,-1,0,0,0,1,-1,-1,0,1,-1,0,0,0], [-1,-1,0,0,1,1,1,-1,1,1,-1,-1,1,0,1,1], [-1,1,1,1,1,1,1,-1,1,1,-1,-1,1,0,0,1], [0,1,1,1,0,0,0,0,0,0,0,0,1,1,-1,0], [0,0,0,0,0,-1,-1,0,-1,0,1,0,0,0,0,-1], [0,1,0,0,0,0,-1,0,0,0,1,1,0,1,-1,1], [-1,-1,0,-1,0,0,1,1,-1,0,0,0,0,0,0,0]], [[-2,-2,0,-1,1,2,2,0,1,2,-1,-1,0,0,1,1], [2,2,0,1,-1,-1,-2,0,0,-1,1,1,0,1,-1,0], [-2,-1,0,0,1,1,1,0,0,1,0,-1,0,0,0,1], [0,-1,-1,-1,0,0,0,1,0,-1,0,1,-1,-1,0,0], [1,-1,-1,-1,0,1,0,0,1,1,0,0,0,0,1,0], [0,0,0,0,0,-1,0,1,-1,-1,1,1,0,0,0,0], [-1,-1,0,-1,0,1,1,1,0,1,0,0,-1,0,0,0], [1,1,0,1,0,-1,-1,-1,1,0,0,0,1,0,0,0], [0,0,0,0,0,-1,-1,0,-1,0,1,0,0,0,0,-1], [0,0,0,0,0,1,0,0,1,0,-1,0,0,0,0,1], [-1,-1,0,-1,0,0,0,1,-1,0,1,0,-1,0,0,0], [1,0,-1,0,-1,0,0,1,0,-1,0,1,-1,-1,0,0], [0,1,1,1,0,-1,0,-1,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1], [2,2,-1,1,-1,-1,-2,0,0,-2,1,1,-1,0,-1,0], [-1,0,0,0,0,1,1,-1,1,1,-1,-1,0,0,0,1]], [[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [-1,0,1,1,1,1,1,-1,1,1,-1,-1,1,0,0,1], [1,0,0,0,-1,-1,0,0,0,0,0,0,0,-1,0,-1], [1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,-1,1,1,0,-1,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [-1,0,1,0,1,0,0,0,0,1,0,0,1,1,0,0], [-2,0,1,0,1,1,1,0,0,1,0,0,1,1,0,1], [2,0,-1,0,-1,-1,-1,1,0,-1,0,1,-1,-1,0,-1], [1,1,0,1,0,0,0,-1,1,0,0,0,1,0,0,0], [1,0,-1,0,-1,0,0,0,1,0,0,0,-1,-1,0,0], [0,0,0,0,0,0,-1,0,0,0,1,0,0,1,0,0], [-1,-1,0,-1,0,0,1,1,-1,0,0,0,0,0,0,0], [-1,-1,0,0,1,0,1,-1,1,1,-1,-1,1,-1,1,0], [1,0,0,0,0,-1,-1,0,0,-1,0,1,0,0,0,0]]]], [ # Q-class [16][25] [[12], [5,12], [2,3,12], [-6,-3,-4,12], [-6,-2,1,6,12], [3,4,1,-4,1,12], [1,-3,-6,4,1,-4,12], [3,3,6,-4,-4,-4,0,12], [-6,0,-5,6,0,-2,-1,-5,12], [-6,-6,-4,0,2,-1,1,-5,3,12], [1,5,6,-3,1,-1,0,6,-3,-4,12], [1,-3,-4,-2,1,-2,6,-2,-1,5,-2,12], [5,-2,0,-3,-1,5,-2,-2,-3,1,-6,0,12], [-6,-1,-6,6,0,-2,4,-1,6,2,0,-2,-6,12], [6,4,-4,-4,-3,3,1,-3,-2,-2,1,2,1,-1,12], [-6,1,-5,6,6,2,2,-6,6,2,-2,2,-4,6,-1,12]], [[[1,-1,0,0,0,0,0,2,1,1,0,-1,0,-1,1,2], [1,-2,0,2,-1,1,-1,2,0,1,1,0,0,-1,1,2], [-1,0,0,0,-1,0,0,0,-1,0,0,0,0,0,0,1], [0,0,-1,1,0,1,0,0,0,0,0,0,-1,-1,0,-1], [0,0,-1,-1,1,0,0,-1,0,-1,0,0,-1,0,-1,-1], [2,-1,0,-1,2,0,-1,1,1,0,-1,0,-1,1,0,0], [0,0,0,0,0,0,1,0,1,0,0,-1,0,-1,0,0], [-1,0,0,1,-2,0,0,0,-1,0,1,0,1,0,0,1], [0,0,0,1,0,1,0,0,0,0,0,1,0,0,0,-1], [0,1,1,-2,1,-1,1,-2,0,-1,-1,0,0,1,-1,-1], [-1,0,0,1,-1,0,0,0,-1,0,1,0,1,0,0,1], [1,0,0,-2,1,-1,1,-1,1,0,0,-1,0,0,-1,0], [1,0,0,-1,1,0,0,1,1,0,-1,0,-1,0,0,0], [0,0,0,1,0,1,0,0,0,0,0,0,0,0,0,-1], [1,-1,0,0,1,0,0,2,1,1,0,-1,0,-1,1,1], [1,-1,0,0,1,1,0,0,1,0,0,0,-1,0,0,-1]], [[-1,1,0,-1,1,0,1,0,1,-1,-1,0,0,0,0,-1], [0,0,-1,0,0,0,0,1,0,0,0,-1,0,-1,0,1], [0,1,-1,0,0,0,-1,-1,-1,-1,0,1,0,1,-1,-1], [0,0,1,1,-1,0,0,0,-1,1,0,0,0,0,0,1], [1,0,0,1,0,0,-1,0,-1,1,0,0,0,1,0,0], [2,-1,-1,-1,2,0,0,1,1,0,-1,-1,-1,0,0,0], [-1,1,1,-1,0,-1,1,-1,0,0,0,0,1,1,0,0], [-2,1,0,1,-2,0,0,-1,-1,-1,1,1,1,0,0,0], [1,-1,0,0,0,0,0,1,0,1,0,-1,-1,-1,0,1], [2,-1,0,-1,1,0,0,0,1,1,0,-1,-1,0,0,0], [-1,1,0,-1,0,-1,0,-1,-1,-1,0,0,1,1,0,0], [0,0,0,-1,1,0,0,0,1,0,0,0,0,1,0,-1], [1,0,0,0,1,0,0,0,1,0,-1,0,-1,0,0,-1], [0,-1,1,0,-1,0,1,1,0,1,0,-1,0,-1,1,2], [-1,0,0,-1,1,0,1,1,1,0,-1,-1,0,-1,1,0], [1,-1,0,0,0,0,0,1,0,1,0,-1,0,0,0,1]]]], [ # Q-class [16][26] [[10], [3,10], [3,3,10], [3,3,5,10], [1,4,4,2,10], [3,0,4,2,4,10], [4,3,5,4,1,3,10], [3,4,4,5,4,3,3,10], [5,3,0,0,4,3,3,0,10], [3,3,3,3,1,3,5,5,3,10], [0,3,2,4,5,5,3,3,3,3,10], [3,3,3,3,1,3,3,3,5,4,3,10], [3,5,0,0,1,3,0,3,3,3,3,5,10], [4,1,2,4,-1,5,4,1,1,1,4,1,4,10], [3,2,5,1,2,3,3,5,0,4,0,3,0,-1,10], [3,5,3,0,5,3,3,2,3,3,3,0,1,-1,4,10]], [[[0,0,0,0,-1,1,0,0,0,0,0,0,0,-1,0,0], [0,1,0,-1,-1,1,0,1,0,0,0,0,-1,0,-1,0], [1,0,0,0,0,1,0,0,-1,0,0,0,0,-1,-1,0], [1,0,0,-1,0,0,0,1,-1,0,0,1,-1,0,-1,0], [1,1,0,-1,0,1,0,0,-1,0,0,1,-1,0,-1,0], [1,1,0,0,0,1,0,-1,-1,0,0,0,0,-1,0,-1], [0,0,0,1,-1,1,1,0,0,-1,0,-1,1,-2,0,0], [1,0,0,0,-1,1,1,0,0,-1,1,-1,1,-2,0,-1], [0,1,0,0,-1,1,0,0,0,0,0,0,0,-1,0,0], [0,0,1,1,-2,1,1,0,1,-1,1,-2,2,-3,0,-1], [1,1,0,-1,0,0,0,0,-1,0,0,1,-1,0,-1,0], [1,1,0,0,-1,1,0,0,0,0,1,-1,0,-2,0,-1], [0,1,0,0,-1,1,0,0,1,0,0,-1,0,-1,0,-1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [1,0,0,0,0,1,1,-1,-1,0,1,-1,1,-2,0,-1], [0,1,0,-1,0,1,0,0,-1,0,0,1,-1,0,-1,0]], [[-1,-1,0,0,1,-1,0,0,0,0,-1,1,0,2,0,1], [0,0,0,-1,1,-1,0,0,-1,0,0,1,0,1,0,0], [-1,-1,0,1,-1,0,1,0,1,-1,0,-1,2,-1,1,0], [-1,0,0,1,-1,0,0,0,1,-1,0,-1,1,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,1,0,0,0,0], [-1,-1,0,1,0,0,0,0,0,0,-1,0,1,0,0,1], [0,-1,0,1,0,0,1,-1,0,-1,0,-1,2,-1,1,0], [0,0,-1,0,1,0,0,0,-1,0,-1,1,0,1,0,0], [0,-1,0,0,1,-1,0,0,-1,0,0,1,0,1,0,1], [0,-1,0,1,0,0,1,0,0,-1,0,-1,2,-1,0,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0], [0,-1,-1,0,1,-1,0,0,-1,0,0,1,0,1,0,1], [0,0,-1,-1,2,-1,0,0,-2,1,-1,2,-1,2,-1,1], [-1,0,0,0,0,0,0,0,0,0,-1,0,0,1,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,-1,1,0,0,-1,0,0,0,0,0,0,1,0,0,0]]]], [ # Q-class [16][27] [[4], [2,4], [2,0,4], [-2,-1,-2,4], [-1,-2,-1,2,4], [2,1,2,-1,0,4], [2,2,1,-2,-1,0,4], [1,-1,2,0,1,0,1,4], [0,0,0,0,0,0,0,0,4], [0,0,0,0,0,0,0,0,2,4], [0,0,0,0,0,0,0,0,2,0,4], [0,0,0,0,0,0,0,0,-2,-1,-2,4], [0,0,0,0,0,0,0,0,-1,-2,-1,2,4], [0,0,0,0,0,0,0,0,2,1,2,-1,0,4], [0,0,0,0,0,0,0,0,2,2,1,-2,-1,0,4], [0,0,0,0,0,0,0,0,1,-1,2,0,1,0,1,4]], [[[0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,0,-1,0,0,1,0,1,0,0,0,0,0,0,0,0], [0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,1,1,0,0,0,-1,0,0,0,0,0,0,0,0], [1,0,1,1,0,-1,0,-1,0,0,0,0,0,0,0,0], [1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,-1,0,0,0,0,1,0,0,0,0,0,0,0,0], [0,-1,0,1,-1,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,-1,0,-1,1,0,1,0,0,0,0,0,0,0,0], [0,0,0,1,-1,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,-1,0,-1,1,0,0,0,0,0,0,0,0,0,0], [-1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [-1,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0]]]], [ # Q-class [16][28] [[4], [1,4], [-1,0,4], [1,0,0,4], [-1,0,0,-1,4], [1,1,-1,0,0,4], [-1,-1,0,-1,0,-1,4], [-1,0,0,0,0,0,1,4], [-1,0,1,1,2,-1,1,1,4], [1,1,1,2,0,-1,-1,-1,1,4], [0,1,1,0,-1,1,-2,-2,-1,0,4], [-1,0,-1,0,2,1,0,1,1,-1,-1,4], [0,0,0,-2,0,1,1,0,-1,0,-1,-1,4], [0,1,2,0,-1,-1,1,1,1,0,0,-1,-1,4], [1,2,-1,0,-1,2,-1,1,-1,0,0,1,1,0,4], [-2,-1,-1,-2,0,-1,2,1,-1,-2,-1,0,1,-1,-1,4]], [[[0,-1,0,1,1,0,0,0,0,0,1,0,0,1,1,1], [0,0,-1,2,1,-1,0,1,-1,0,2,1,2,1,-1,0], [0,1,0,0,0,-1,1,1,-1,-1,0,0,0,-1,-1,-2], [0,0,0,0,1,0,0,0,0,0,0,-1,-1,0,1,0], [-1,1,1,-1,-1,1,1,-1,0,0,-2,-1,-2,-2,0,-1], [1,-1,-1,1,1,0,0,0,0,1,2,1,1,2,0,2], [0,0,1,-1,0,1,0,0,0,0,-1,-1,-1,-1,0,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0], [-1,1,1,-2,-1,1,1,0,0,0,-2,-2,-3,-3,0,-2], [-1,1,0,0,0,0,0,0,0,-1,-1,-1,-1,-1,0,-1], [1,0,-1,1,0,-1,0,1,0,0,2,2,2,1,-1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,1,-1,0,0,0,0,0,-1,-1], [1,-1,-1,2,1,-1,-1,0,0,0,2,1,2,2,0,2], [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0]], [[0,0,1,-1,0,1,0,0,0,0,-1,-1,-2,-1,1,0], [0,0,1,-1,-1,0,0,0,0,0,-1,0,-1,-1,0,-1], [0,0,0,0,0,0,-1,-1,0,0,-1,0,0,1,0,1], [0,0,1,-1,0,1,1,-1,0,0,-1,-1,-2,-1,1,0], [0,-1,-1,1,1,-1,0,0,0,0,1,0,1,1,1,0], [0,0,0,-1,0,0,1,1,-1,1,0,0,-1,-1,0,-1], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,0,1,0,0,0,1,0,0,0,1,0,1], [0,-1,0,1,1,0,0,-1,0,0,0,0,0,1,1,1], [0,0,1,0,0,0,0,-1,0,-1,-1,-1,-1,-1,1,0], [0,1,0,-1,-1,0,0,0,0,0,-1,0,-1,-1,-1,-1], [0,-1,-1,0,0,0,0,0,0,1,1,1,1,1,0,0], [0,0,0,1,1,-1,0,1,-1,0,1,0,1,0,0,0], [0,0,1,-1,-1,1,-1,-1,1,0,-2,0,-1,0,0,1], [0,0,1,-1,-1,1,0,0,0,1,-1,0,-1,-1,0,0], [0,0,-1,1,0,-1,0,1,0,0,2,1,2,1,-1,0]]]], [ # Q-class [16][29] [[6], [-1,6], [1,-3,6], [1,2,0,6], [1,-3,2,1,6], [3,-1,2,2,0,6], [1,-3,2,-2,3,1,6], [3,1,-2,3,1,2,-1,6], [-3,-1,0,0,2,-1,2,-2,6], [3,-3,1,-2,1,1,2,1,-1,6], [-3,-2,-1,-2,0,-2,0,-2,2,-1,6], [2,-3,0,-3,1,0,2,0,-1,2,0,6], [2,-1,-1,-2,-2,0,0,1,-3,2,1,2,6], [2,-1,0,-2,-2,0,-1,0,-2,1,0,3,2,6], [-2,1,0,2,2,-1,1,0,3,-3,0,-2,-2,-2,6], [0,2,-2,2,-2,0,-1,1,-1,-2,1,-2,1,-1,1,6]], [[[-1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [0,0,0,1,0,0,0,-1,0,0,0,0,0,0,0,0], [0,0,0,-1,0,0,0,1,0,0,0,-1,0,0,0,0], [-1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,0,0,-1,0,0,0,1,0,0,0,0,-1,0,0,0], [-1,0,0,0,0,0,0,0,-1,1,0,0,0,0,1,0], [-1,1,0,-1,2,1,-1,0,0,1,0,0,0,1,0,1], [-1,-1,0,0,0,0,0,0,0,0,-1,0,0,0,0,0], [0,1,0,0,1,0,0,0,0,0,0,0,0,1,0,0], [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0], [1,0,0,-1,0,0,0,0,0,-1,0,0,0,0,0,0], [0,-1,-1,0,0,0,0,0,0,0,0,0,0,0,0,0], [0,-1,0,0,-1,0,0,0,0,0,0,0,0,0,0,0], [0,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0], [-1,1,0,0,1,1,0,0,0,0,0,0,0,1,0,0], [-2,1,0,0,2,1,0,-1,0,0,-1,0,1,1,-1,1]], [[-1,1,0,0,2,1,-1,-1,1,1,-1,0,1,1,0,1], [0,0,0,0,-1,0,0,0,-1,1,1,0,-1,0,1,0], [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0], [1,0,0,0,-1,0,-1,0,0,1,1,1,-1,-1,1,0], [0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0], [0,0,0,-1,1,0,-1,0,1,0,-1,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,-1,-1,0,0,0,0,0], [0,1,1,0,0,0,-1,0,1,1,0,1,0,0,0,1], [1,-2,-1,1,-2,-1,1,0,-1,-1,0,0,-1,-1,0,-1], [-1,1,0,0,2,1,0,-1,1,0,-1,0,1,1,-1,1], [1,-1,0,0,-2,-1,1,1,0,-1,0,0,0,-1,0,-1], [0,0,0,0,1,0,0,0,1,-1,-1,-1,1,1,-1,0], [0,1,1,0,0,0,0,0,1,0,0,0,1,0,0,0], [-1,0,0,0,1,0,0,0,1,0,-1,-1,1,1,-1,0], [1,-1,0,1,-2,-1,0,0,-1,0,1,1,-1,-1,1,-1], [1,-1,0,-1,-1,0,-1,0,0,0,0,0,0,-1,1,0]]]], [ # Q-class [16][30] [[2], [1,2], [1,1,2], [1,1,1,2], [1,1,1,1,2], [1,1,1,1,1,2], [1,1,1,1,1,1,2], [1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,2], [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]], [[[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1], [-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]], [[-1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,-1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,0,-1,1,0], [0,0,0,0,0,0,0,0,0,0,0,0,-1,0,1,0], [0,0,0,0,0,0,0,0,0,0,0,-1,0,0,1,0], [0,0,0,0,0,0,0,0,0,0,-1,0,0,0,1,0], [0,0,0,0,0,0,0,0,0,-1,0,0,0,0,1,0], [0,0,0,0,0,0,0,0,-1,0,0,0,0,0,1,0], [0,0,0,0,0,0,0,-1,0,0,0,0,0,0,1,0], [0,0,0,0,0,0,-1,0,0,0,0,0,0,0,1,0], [0,0,0,0,0,-1,0,0,0,0,0,0,0,0,1,0], [0,0,0,0,-1,0,0,0,0,0,0,0,0,0,1,0], [0,0,0,-1,0,0,0,0,0,0,0,0,0,0,1,0], [0,0,-1,0,0,0,0,0,0,0,0,0,0,0,1,0], [0,-1,0,0,0,0,0,0,0,0,0,0,0,0,1,0]]]], [ # Q-class [16][31] [[6], [0,6], [3,0,6], [-2,3,-2,6], [-2,-2,1,-2,6], [0,-2,-2,1,-2,6], [1,-3,2,-1,2,-1,6], [-2,1,1,2,2,0,-1,6], [-3,-2,-2,1,2,2,1,0,6], [2,-1,3,-2,0,-2,3,-2,0,6], [3,0,1,0,-2,2,1,0,-2,1,6], [-2,-3,-2,-2,2,0,1,0,2,-1,-1,6], [0,-3,-1,0,-1,1,2,-2,0,0,1,2,6], [0,3,1,3,-1,-2,-1,1,0,1,0,-2,0,6], [3,1,3,-1,-2,-2,0,0,-3,3,1,-1,0,2,6], [-3,2,-2,1,0,-2,-1,-1,1,1,-1,0,0,2,-1,6]], [[[0,-1,0,0,0,0,0,0,0,-1,0,0,0,0,1,1], [0,0,0,0,0,1,1,0,-1,0,-1,0,0,0,0,0], [0,-1,0,0,0,0,0,0,0,-1,0,-1,0,0,1,1], [0,0,0,0,0,2,1,0,-2,1,-1,1,-1,1,-1,0], [0,0,1,1,1,0,-1,-1,0,0,0,0,0,0,0,0], [0,1,0,0,0,1,0,0,0,1,0,1,0,0,0,0], [0,-2,1,1,0,-1,-1,-1,0,-1,1,0,-1,0,0,1], [0,1,0,0,1,2,0,0,-1,1,-1,0,0,0,0,0], [1,0,1,1,0,0,-1,0,0,1,0,1,0,0,-1,0], [0,-2,0,0,-1,-2,-1,0,1,-1,1,-1,0,0,0,0], [-1,0,0,-1,-1,0,0,0,0,0,0,0,0,0,0,0], [1,1,0,0,0,-1,-1,1,1,1,0,0,1,-1,-1,0], [0,1,-1,-2,-1,0,1,1,0,0,0,0,0,1,-1,0], [0,0,0,-1,-1,1,1,1,-1,0,-1,0,0,1,-1,0], [0,0,-1,-1,0,0,0,1,0,0,0,-1,1,0,0,0], [0,0,0,0,-1,-1,0,0,0,0,0,0,0,0,-1,-1]], [[1,0,0,0,0,0,0,0,1,-1,0,0,0,0,1,1], [-1,-2,1,1,0,-1,-1,-1,0,-1,1,0,-1,0,1,0], [0,1,0,-1,0,1,1,0,0,-1,0,0,0,0,1,1], [0,-1,0,1,1,0,-1,0,-1,1,0,0,0,0,0,0], [0,1,0,-1,-1,0,1,1,0,0,0,0,0,0,-1,0], [1,0,-1,1,1,1,0,0,-1,1,-1,0,0,0,0,0], [0,2,-1,-2,0,0,1,1,1,0,0,-1,1,0,0,0], [0,-1,1,2,1,1,0,-1,-2,0,0,1,-1,0,0,1], [0,1,-1,-1,0,0,0,1,0,1,0,-1,1,0,-1,-1], [0,1,0,-1,0,-1,0,0,2,-1,1,-1,1,-1,1,0], [1,-1,0,1,1,0,0,-1,0,-1,0,0,-1,0,1,1], [0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0], [1,1,-1,-1,0,0,0,1,0,1,-1,0,1,0,-1,0], [0,-1,0,0,0,-1,-1,0,0,0,1,0,0,0,0,0], [0,-1,1,1,0,-1,-1,-1,1,-1,1,0,0,-1,1,1], [-1,-1,0,-1,-1,-2,0,0,1,-1,1,-1,0,0,0,-1]]]] ]; MakeImmutable( IMFList[16].matrices ); gap-4r6p5/cnf/0000755000175000017500000000000012174560027011703 5ustar billbillgap-4r6p5/cnf/Makegap.in0000644000175000017500000010145512172557252013612 0ustar billbill# DO NOT EDIT THIS FILE BY HAND IT IS MACHINE GENERATED ############################################################################# ## #W Makefile GAP source Frank Celler ## ## #Y Copyright (C) 1997, Lehrstuhl D fuer Mathematik, RWTH Aachen, Germany ## ## This file compiles and links GAP. It is created from the file ## "Makegap.in" in the directory `cnf/'. ## CFLAGS=@CFLAGS@ $(COPTS) CPPFLAGS=-I. -I../.. -DCONFIG_H @CPPFLAGS@ LDFLAGS=@LDFLAGS@ $(LOPTS) CC=@CC@ ITANIUMOBJ=@ITANIUMOBJ@ # FIXME: What is LIBSOVERRIDE used for? We should either document this here # or elsewhere, or find ways to get rid of it. ifeq "$(LIBSOVERRIDE)" "" CONFLIBS=@LIBS@ else CONFLIBS=$(LIBSOVERRIDE) endif # OBJECTS are generated from SOURCE OBJECTS=ariths.o blister.o bool.o c_meths1.o c_type1.o c_oper1.o c_filt1.o c_random.o calls.o code.o compiler.o compstat.o costab.o cyclotom.o dt.o dteval.o exprs.o finfield.o funcs.o gap.o gasman.o gmpints.o gvars.o integer.o intrprtr.o listfunc.o listoper.o lists.o objcftl.o objects.o objfgelm.o objpcgel.o objscoll.o objccoll.o opers.o permutat.o plist.o precord.o range.o rational.o read.o records.o saveload.o scanner.o sctable.o set.o stats.o streams.o string.o sysfiles.o system.o tietze.o vars.o vecgf2.o vec8bit.o vector.o vecffe.o weakptr.o iostream.o macfloat.o intfuncs.o $(GAPMPI_OBJ) # compile and link GAP gap: $(OBJECTS) $(ITANIUMOBJ) $(EXTOBJS) $(GMP_LIBS) $(CC) $(LDFLAGS) -o gap $(OBJECTS) $(ITANIUMOBJ) -lm $(MPILIBS) $(EXTOBJS) $(GMP_LIBS) $(CONFLIBS) # compile and link gap.dll on cygwin gapdll: $(OBJECTS) $(ITANIUMOBJ) $(EXTOBJS) $(GMP_LIBS) $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -DCOMPILECYGWINDLL -o gap.o -c ../../src/gap.c $(CC) $(LDFLAGS) -o gap.dll -shared $(OBJECTS) $(ITANIUMOBJ) -lm $(MPILIBS) $(EXTOBJS) $(GMP_LIBS) $(CONFLIBS) $(CC) $(LDFLAGS) -o gapw95 ../../src/gapw95.c $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -DCOMPILECYGWINDLL gap.dll # dependencies are automatically generated ariths.o: ../../Makefile @srcdir@/ariths.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/opers.h @srcdir@/ariths.h @srcdir@/bool.h \ @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h @srcdir@/string.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o ariths.o -c @srcdir@/ariths.c blister.o: ../../Makefile @srcdir@/blister.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/opers.h @srcdir@/ariths.h @srcdir@/bool.h \ @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h @srcdir@/plist.h \ @srcdir@/set.h @srcdir@/blister.h @srcdir@/range.h @srcdir@/string.h \ @srcdir@/saveload.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o blister.o -c @srcdir@/blister.c bool.o: ../../Makefile @srcdir@/bool.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/opers.h @srcdir@/ariths.h @srcdir@/bool.h \ @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h @srcdir@/string.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o bool.o -c @srcdir@/bool.c c_meths1.o: ../../Makefile @srcdir@/c_meths1.c @srcdir@/compiled.h @srcdir@/system.h config.h \ @srcdir@/gasman.h @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h \ @srcdir@/read.h @srcdir@/gvars.h @srcdir@/calls.h @srcdir@/opers.h \ @srcdir@/ariths.h @srcdir@/integer.h @srcdir@/rational.h @srcdir@/cyclotom.h \ @srcdir@/finfield.h @srcdir@/macfloat.h @srcdir@/bool.h @srcdir@/permutat.h \ @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h @srcdir@/listoper.h \ @srcdir@/listfunc.h @srcdir@/plist.h @srcdir@/set.h @srcdir@/vector.h \ @srcdir@/blister.h @srcdir@/range.h @srcdir@/string.h @srcdir@/objfgelm.h \ @srcdir@/objpcgel.h @srcdir@/objscoll.h @srcdir@/objcftl.h @srcdir@/dt.h \ @srcdir@/dteval.h @srcdir@/sctable.h @srcdir@/costab.h @srcdir@/tietze.h \ @srcdir@/code.h @srcdir@/vars.h @srcdir@/exprs.h @srcdir@/stats.h \ @srcdir@/funcs.h @srcdir@/intrprtr.h @srcdir@/compiler.h @srcdir@/compstat.h \ @srcdir@/saveload.h @srcdir@/streams.h @srcdir@/sysfiles.h @srcdir@/weakptr.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o c_meths1.o -c @srcdir@/c_meths1.c c_type1.o: ../../Makefile @srcdir@/c_type1.c @srcdir@/compiled.h @srcdir@/system.h config.h \ @srcdir@/gasman.h @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h \ @srcdir@/read.h @srcdir@/gvars.h @srcdir@/calls.h @srcdir@/opers.h \ @srcdir@/ariths.h @srcdir@/integer.h @srcdir@/rational.h @srcdir@/cyclotom.h \ @srcdir@/finfield.h @srcdir@/macfloat.h @srcdir@/bool.h @srcdir@/permutat.h \ @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h @srcdir@/listoper.h \ @srcdir@/listfunc.h @srcdir@/plist.h @srcdir@/set.h @srcdir@/vector.h \ @srcdir@/blister.h @srcdir@/range.h @srcdir@/string.h @srcdir@/objfgelm.h \ @srcdir@/objpcgel.h @srcdir@/objscoll.h @srcdir@/objcftl.h @srcdir@/dt.h \ @srcdir@/dteval.h @srcdir@/sctable.h @srcdir@/costab.h @srcdir@/tietze.h \ @srcdir@/code.h @srcdir@/vars.h @srcdir@/exprs.h @srcdir@/stats.h \ @srcdir@/funcs.h @srcdir@/intrprtr.h @srcdir@/compiler.h @srcdir@/compstat.h \ @srcdir@/saveload.h @srcdir@/streams.h @srcdir@/sysfiles.h @srcdir@/weakptr.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o c_type1.o -c @srcdir@/c_type1.c c_oper1.o: ../../Makefile @srcdir@/c_oper1.c @srcdir@/compiled.h @srcdir@/system.h config.h \ @srcdir@/gasman.h @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h \ @srcdir@/read.h @srcdir@/gvars.h @srcdir@/calls.h @srcdir@/opers.h \ @srcdir@/ariths.h @srcdir@/integer.h @srcdir@/rational.h @srcdir@/cyclotom.h \ @srcdir@/finfield.h @srcdir@/macfloat.h @srcdir@/bool.h @srcdir@/permutat.h \ @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h @srcdir@/listoper.h \ @srcdir@/listfunc.h @srcdir@/plist.h @srcdir@/set.h @srcdir@/vector.h \ @srcdir@/blister.h @srcdir@/range.h @srcdir@/string.h @srcdir@/objfgelm.h \ @srcdir@/objpcgel.h @srcdir@/objscoll.h @srcdir@/objcftl.h @srcdir@/dt.h \ @srcdir@/dteval.h @srcdir@/sctable.h @srcdir@/costab.h @srcdir@/tietze.h \ @srcdir@/code.h @srcdir@/vars.h @srcdir@/exprs.h @srcdir@/stats.h \ @srcdir@/funcs.h @srcdir@/intrprtr.h @srcdir@/compiler.h @srcdir@/compstat.h \ @srcdir@/saveload.h @srcdir@/streams.h @srcdir@/sysfiles.h @srcdir@/weakptr.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o c_oper1.o -c @srcdir@/c_oper1.c c_filt1.o: ../../Makefile @srcdir@/c_filt1.c @srcdir@/compiled.h @srcdir@/system.h config.h \ @srcdir@/gasman.h @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h \ @srcdir@/read.h @srcdir@/gvars.h @srcdir@/calls.h @srcdir@/opers.h \ @srcdir@/ariths.h @srcdir@/integer.h @srcdir@/rational.h @srcdir@/cyclotom.h \ @srcdir@/finfield.h @srcdir@/macfloat.h @srcdir@/bool.h @srcdir@/permutat.h \ @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h @srcdir@/listoper.h \ @srcdir@/listfunc.h @srcdir@/plist.h @srcdir@/set.h @srcdir@/vector.h \ @srcdir@/blister.h @srcdir@/range.h @srcdir@/string.h @srcdir@/objfgelm.h \ @srcdir@/objpcgel.h @srcdir@/objscoll.h @srcdir@/objcftl.h @srcdir@/dt.h \ @srcdir@/dteval.h @srcdir@/sctable.h @srcdir@/costab.h @srcdir@/tietze.h \ @srcdir@/code.h @srcdir@/vars.h @srcdir@/exprs.h @srcdir@/stats.h \ @srcdir@/funcs.h @srcdir@/intrprtr.h @srcdir@/compiler.h @srcdir@/compstat.h \ @srcdir@/saveload.h @srcdir@/streams.h @srcdir@/sysfiles.h @srcdir@/weakptr.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o c_filt1.o -c @srcdir@/c_filt1.c c_random.o: ../../Makefile @srcdir@/c_random.c @srcdir@/compiled.h @srcdir@/system.h config.h \ @srcdir@/gasman.h @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h \ @srcdir@/read.h @srcdir@/gvars.h @srcdir@/calls.h @srcdir@/opers.h \ @srcdir@/ariths.h @srcdir@/integer.h @srcdir@/rational.h @srcdir@/cyclotom.h \ @srcdir@/finfield.h @srcdir@/macfloat.h @srcdir@/bool.h @srcdir@/permutat.h \ @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h @srcdir@/listoper.h \ @srcdir@/listfunc.h @srcdir@/plist.h @srcdir@/set.h @srcdir@/vector.h \ @srcdir@/blister.h @srcdir@/range.h @srcdir@/string.h @srcdir@/objfgelm.h \ @srcdir@/objpcgel.h @srcdir@/objscoll.h @srcdir@/objcftl.h @srcdir@/dt.h \ @srcdir@/dteval.h @srcdir@/sctable.h @srcdir@/costab.h @srcdir@/tietze.h \ @srcdir@/code.h @srcdir@/vars.h @srcdir@/exprs.h @srcdir@/stats.h \ @srcdir@/funcs.h @srcdir@/intrprtr.h @srcdir@/compiler.h @srcdir@/compstat.h \ @srcdir@/saveload.h @srcdir@/streams.h @srcdir@/sysfiles.h @srcdir@/weakptr.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o c_random.o -c @srcdir@/c_random.c calls.o: ../../Makefile @srcdir@/calls.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/opers.h @srcdir@/records.h @srcdir@/precord.h \ @srcdir@/lists.h @srcdir@/bool.h @srcdir@/plist.h @srcdir@/string.h \ @srcdir@/code.h @srcdir@/vars.h @srcdir@/stats.h @srcdir@/saveload.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o calls.o -c @srcdir@/calls.c code.o: ../../Makefile @srcdir@/code.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/calls.h \ @srcdir@/records.h @srcdir@/integer.h @srcdir@/precord.h @srcdir@/lists.h \ @srcdir@/plist.h @srcdir@/string.h @srcdir@/funcs.h @srcdir@/code.h \ @srcdir@/vars.h @srcdir@/saveload.h @srcdir@/read.h @srcdir@/gvars.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o code.o -c @srcdir@/code.c compiler.o: ../../Makefile @srcdir@/compiler.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gvars.h @srcdir@/ariths.h \ @srcdir@/integer.h @srcdir@/bool.h @srcdir@/gap.h @srcdir@/calls.h \ @srcdir@/lists.h @srcdir@/records.h @srcdir@/precord.h @srcdir@/plist.h \ @srcdir@/string.h @srcdir@/code.h @srcdir@/exprs.h @srcdir@/stats.h \ @srcdir@/vars.h @srcdir@/compiler.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o compiler.o -c @srcdir@/compiler.c compstat.o: ../../Makefile @srcdir@/compstat.c @srcdir@/system.h config.h @srcdir@/compstat.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o compstat.o -c @srcdir@/compstat.c costab.o: ../../Makefile @srcdir@/costab.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/opers.h @srcdir@/integer.h @srcdir@/bool.h \ @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h @srcdir@/plist.h \ @srcdir@/string.h @srcdir@/costab.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o costab.o -c @srcdir@/costab.c cyclotom.o: ../../Makefile @srcdir@/cyclotom.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/opers.h @srcdir@/ariths.h @srcdir@/bool.h \ @srcdir@/integer.h @srcdir@/cyclotom.h @srcdir@/records.h @srcdir@/precord.h \ @srcdir@/lists.h @srcdir@/plist.h @srcdir@/string.h @srcdir@/saveload.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o cyclotom.o -c @srcdir@/cyclotom.c dt.o: ../../Makefile @srcdir@/dt.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/bool.h @srcdir@/calls.h \ @srcdir@/gap.h @srcdir@/gvars.h @srcdir@/integer.h @srcdir@/dt.h \ @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h @srcdir@/listfunc.h \ @srcdir@/plist.h @srcdir@/string.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o dt.o -c @srcdir@/dt.c dteval.o: ../../Makefile @srcdir@/dteval.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/bool.h @srcdir@/calls.h \ @srcdir@/gap.h @srcdir@/gvars.h @srcdir@/precord.h @srcdir@/records.h \ @srcdir@/integer.h @srcdir@/dt.h @srcdir@/objcftl.h @srcdir@/dteval.h \ @srcdir@/lists.h @srcdir@/listfunc.h @srcdir@/plist.h @srcdir@/string.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o dteval.o -c @srcdir@/dteval.c exprs.o: ../../Makefile @srcdir@/exprs.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/ariths.h @srcdir@/records.h @srcdir@/lists.h @srcdir@/bool.h \ @srcdir@/integer.h @srcdir@/permutat.h @srcdir@/precord.h @srcdir@/plist.h \ @srcdir@/range.h @srcdir@/string.h @srcdir@/code.h @srcdir@/calls.h \ @srcdir@/vars.h @srcdir@/stats.h @srcdir@/exprs.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o exprs.o -c @srcdir@/exprs.c finfield.o: ../../Makefile @srcdir@/finfield.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/opers.h @srcdir@/ariths.h @srcdir@/bool.h \ @srcdir@/integer.h @srcdir@/finfield.h @srcdir@/records.h @srcdir@/precord.h \ @srcdir@/lists.h @srcdir@/plist.h @srcdir@/string.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o finfield.o -c @srcdir@/finfield.c funcs.o: ../../Makefile @srcdir@/funcs.c @srcdir@/system.h config.h @srcdir@/bool.h \ @srcdir@/gasman.h @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h \ @srcdir@/string.h @srcdir@/calls.h @srcdir@/code.h @srcdir@/vars.h \ @srcdir@/exprs.h @srcdir@/stats.h @srcdir@/funcs.h @srcdir@/read.h \ @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h @srcdir@/plist.h \ @srcdir@/saveload.h @srcdir@/opers.h @srcdir@/gvars.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o funcs.o -c @srcdir@/funcs.c gap.o: ../../Makefile @srcdir@/gap.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/read.h \ @srcdir@/gvars.h @srcdir@/calls.h @srcdir@/opers.h @srcdir@/ariths.h \ @srcdir@/integer.h @srcdir@/rational.h @srcdir@/cyclotom.h @srcdir@/finfield.h \ @srcdir@/bool.h @srcdir@/macfloat.h @srcdir@/permutat.h @srcdir@/records.h \ @srcdir@/precord.h @srcdir@/lists.h @srcdir@/listoper.h @srcdir@/listfunc.h \ @srcdir@/plist.h @srcdir@/set.h @srcdir@/vector.h @srcdir@/vecffe.h \ @srcdir@/blister.h @srcdir@/range.h @srcdir@/string.h @srcdir@/vecgf2.h \ @srcdir@/vec8bit.h @srcdir@/objfgelm.h @srcdir@/objpcgel.h @srcdir@/objscoll.h \ @srcdir@/objccoll.h @srcdir@/objcftl.h @srcdir@/dt.h @srcdir@/dteval.h \ @srcdir@/sctable.h @srcdir@/costab.h @srcdir@/tietze.h @srcdir@/code.h \ @srcdir@/vars.h @srcdir@/exprs.h @srcdir@/stats.h @srcdir@/funcs.h \ @srcdir@/intrprtr.h @srcdir@/compiler.h @srcdir@/compstat.h @srcdir@/saveload.h \ @srcdir@/streams.h @srcdir@/sysfiles.h @srcdir@/weakptr.h @srcdir@/intfuncs.h \ @srcdir@/iostream.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o gap.o -c @srcdir@/gap.c gasman.o: ../../Makefile @srcdir@/gasman.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o gasman.o -c @srcdir@/gasman.c gmpints.o: ../../Makefile @srcdir@/gmpints.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gvars.h @srcdir@/calls.h \ @srcdir@/opers.h @srcdir@/ariths.h @srcdir@/bool.h @srcdir@/gap.h @srcdir@/code.h \ @srcdir@/stats.h @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h \ @srcdir@/string.h @srcdir@/saveload.h @srcdir@/intfuncs.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o gmpints.o -c @srcdir@/gmpints.c gvars.o: ../../Makefile @srcdir@/gvars.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h \ @srcdir@/plist.h @srcdir@/string.h @srcdir@/bool.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o gvars.o -c @srcdir@/gvars.c integer.o: ../../Makefile @srcdir@/integer.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gvars.h @srcdir@/calls.h \ @srcdir@/opers.h @srcdir@/ariths.h @srcdir@/bool.h @srcdir@/integer.h \ @srcdir@/gap.h @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h \ @srcdir@/string.h @srcdir@/saveload.h @srcdir@/intfuncs.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o integer.o -c @srcdir@/integer.c intrprtr.o: ../../Makefile @srcdir@/intrprtr.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/read.h \ @srcdir@/gvars.h @srcdir@/calls.h @srcdir@/opers.h @srcdir@/ariths.h \ @srcdir@/records.h @srcdir@/lists.h @srcdir@/bool.h @srcdir@/integer.h \ @srcdir@/permutat.h @srcdir@/precord.h @srcdir@/plist.h @srcdir@/range.h \ @srcdir@/string.h @srcdir@/code.h @srcdir@/vars.h @srcdir@/funcs.h \ @srcdir@/intrprtr.h @srcdir@/saveload.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o intrprtr.o -c @srcdir@/intrprtr.c listfunc.o: ../../Makefile @srcdir@/listfunc.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/opers.h @srcdir@/ariths.h @srcdir@/records.h \ @srcdir@/precord.h @srcdir@/lists.h @srcdir@/string.h @srcdir@/bool.h \ @srcdir@/permutat.h @srcdir@/listfunc.h @srcdir@/plist.h @srcdir@/set.h \ @srcdir@/range.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o listfunc.o -c @srcdir@/listfunc.c listoper.o: ../../Makefile @srcdir@/listoper.c @srcdir@/system.h config.h @srcdir@/sysfiles.h \ @srcdir@/gasman.h @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h \ @srcdir@/gvars.h @srcdir@/calls.h @srcdir@/ariths.h @srcdir@/bool.h \ @srcdir@/integer.h @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h \ @srcdir@/listoper.h @srcdir@/listfunc.h @srcdir@/plist.h @srcdir@/string.h \ @srcdir@/opers.h @srcdir@/range.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o listoper.o -c @srcdir@/listoper.c lists.o: ../../Makefile @srcdir@/lists.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/opers.h @srcdir@/ariths.h @srcdir@/records.h \ @srcdir@/lists.h @srcdir@/bool.h @srcdir@/precord.h @srcdir@/plist.h \ @srcdir@/range.h @srcdir@/string.h @srcdir@/integer.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o lists.o -c @srcdir@/lists.c objcftl.o: ../../Makefile @srcdir@/objcftl.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gvars.h @srcdir@/calls.h \ @srcdir@/gap.h @srcdir@/bool.h @srcdir@/integer.h @srcdir@/ariths.h \ @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h @srcdir@/plist.h \ @srcdir@/string.h @srcdir@/dt.h @srcdir@/objcftl.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o objcftl.o -c @srcdir@/objcftl.c objects.o: ../../Makefile @srcdir@/objects.c @srcdir@/system.h config.h @srcdir@/sysfiles.h \ @srcdir@/gasman.h @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/opers.h @srcdir@/bool.h @srcdir@/gap.h \ @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h @srcdir@/plist.h \ @srcdir@/string.h @srcdir@/saveload.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o objects.o -c @srcdir@/objects.c objfgelm.o: ../../Makefile @srcdir@/objfgelm.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/opers.h @srcdir@/ariths.h @srcdir@/records.h \ @srcdir@/precord.h @srcdir@/lists.h @srcdir@/plist.h @srcdir@/string.h \ @srcdir@/bool.h @srcdir@/objfgelm.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o objfgelm.o -c @srcdir@/objfgelm.c objpcgel.o: ../../Makefile @srcdir@/objpcgel.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gvars.h @srcdir@/gap.h \ @srcdir@/calls.h @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h \ @srcdir@/plist.h @srcdir@/string.h @srcdir@/ariths.h @srcdir@/bool.h \ @srcdir@/objfgelm.h @srcdir@/objscoll.h @srcdir@/objpcgel.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o objpcgel.o -c @srcdir@/objpcgel.c objscoll.o: ../../Makefile @srcdir@/objscoll.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gvars.h @srcdir@/gap.h \ @srcdir@/calls.h @srcdir@/records.h @srcdir@/lists.h @srcdir@/bool.h \ @srcdir@/precord.h @srcdir@/plist.h @srcdir@/string.h @srcdir@/code.h \ @srcdir@/objfgelm.h @srcdir@/objscoll.h @srcdir@/objccoll.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o objscoll.o -c @srcdir@/objscoll.c objccoll.o: ../../Makefile @srcdir@/objccoll.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gvars.h @srcdir@/gap.h \ @srcdir@/calls.h @srcdir@/records.h @srcdir@/lists.h @srcdir@/bool.h \ @srcdir@/precord.h @srcdir@/plist.h @srcdir@/string.h @srcdir@/code.h \ @srcdir@/objfgelm.h @srcdir@/objscoll.h @srcdir@/objccoll.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o objccoll.o -c @srcdir@/objccoll.c opers.o: ../../Makefile @srcdir@/opers.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gvars.h @srcdir@/gap.h \ @srcdir@/calls.h @srcdir@/opers.h @srcdir@/ariths.h @srcdir@/lists.h \ @srcdir@/bool.h @srcdir@/plist.h @srcdir@/blister.h @srcdir@/string.h \ @srcdir@/range.h @srcdir@/records.h @srcdir@/precord.h @srcdir@/saveload.h \ @srcdir@/listfunc.h @srcdir@/integer.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o opers.o -c @srcdir@/opers.c permutat.o: ../../Makefile @srcdir@/permutat.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/opers.h @srcdir@/ariths.h @srcdir@/bool.h \ @srcdir@/integer.h @srcdir@/permutat.h @srcdir@/records.h @srcdir@/precord.h \ @srcdir@/lists.h @srcdir@/plist.h @srcdir@/range.h @srcdir@/string.h \ @srcdir@/saveload.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o permutat.o -c @srcdir@/permutat.c plist.o: ../../Makefile @srcdir@/plist.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/opers.h @srcdir@/ariths.h @srcdir@/finfield.h \ @srcdir@/bool.h @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h \ @srcdir@/plist.h @srcdir@/range.h @srcdir@/string.h @srcdir@/blister.h \ @srcdir@/saveload.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o plist.o -c @srcdir@/plist.c precord.o: ../../Makefile @srcdir@/precord.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/opers.h @srcdir@/ariths.h @srcdir@/records.h \ @srcdir@/lists.h @srcdir@/bool.h @srcdir@/precord.h @srcdir@/plist.h \ @srcdir@/string.h @srcdir@/saveload.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o precord.o -c @srcdir@/precord.c range.o: ../../Makefile @srcdir@/range.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/opers.h @srcdir@/ariths.h @srcdir@/bool.h \ @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h @srcdir@/plist.h \ @srcdir@/range.h @srcdir@/string.h @srcdir@/saveload.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o range.o -c @srcdir@/range.c rational.o: ../../Makefile @srcdir@/rational.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/opers.h @srcdir@/ariths.h @srcdir@/bool.h \ @srcdir@/integer.h @srcdir@/rational.h @srcdir@/records.h @srcdir@/precord.h \ @srcdir@/lists.h @srcdir@/string.h @srcdir@/saveload.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o rational.o -c @srcdir@/rational.c read.o: ../../Makefile @srcdir@/read.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/string.h @srcdir@/calls.h @srcdir@/code.h @srcdir@/vars.h \ @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h @srcdir@/plist.h \ @srcdir@/intrprtr.h @srcdir@/read.h @srcdir@/bool.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o read.o -c @srcdir@/read.c records.o: ../../Makefile @srcdir@/records.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/opers.h @srcdir@/records.h @srcdir@/bool.h \ @srcdir@/precord.h @srcdir@/lists.h @srcdir@/plist.h @srcdir@/string.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o records.o -c @srcdir@/records.c saveload.o: ../../Makefile @srcdir@/saveload.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/bool.h @srcdir@/calls.h @srcdir@/gap.h \ @srcdir@/gvars.h @srcdir@/streams.h @srcdir@/string.h @srcdir@/scanner.h \ @srcdir@/sysfiles.h @srcdir@/plist.h @srcdir@/macfloat.h @srcdir@/compstat.h \ @srcdir@/saveload.h @srcdir@/finfield.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o saveload.o -c @srcdir@/saveload.c scanner.o: ../../Makefile @srcdir@/scanner.c @srcdir@/system.h config.h @srcdir@/sysfiles.h \ @srcdir@/gasman.h @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h \ @srcdir@/gvars.h @srcdir@/calls.h @srcdir@/bool.h @srcdir@/records.h \ @srcdir@/precord.h @srcdir@/lists.h @srcdir@/plist.h @srcdir@/string.h \ @srcdir@/opers.h @srcdir@/read.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o scanner.o -c @srcdir@/scanner.c sctable.o: ../../Makefile @srcdir@/sctable.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/ariths.h @srcdir@/records.h @srcdir@/precord.h \ @srcdir@/lists.h @srcdir@/plist.h @srcdir@/string.h @srcdir@/sctable.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o sctable.o -c @srcdir@/sctable.c set.o: ../../Makefile @srcdir@/set.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/opers.h @srcdir@/ariths.h @srcdir@/bool.h \ @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h @srcdir@/listfunc.h \ @srcdir@/plist.h @srcdir@/set.h @srcdir@/string.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o set.o -c @srcdir@/set.c stats.o: ../../Makefile @srcdir@/stats.c @srcdir@/system.h config.h @srcdir@/sysfiles.h \ @srcdir@/gasman.h @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h \ @srcdir@/gvars.h @srcdir@/calls.h @srcdir@/records.h @srcdir@/precord.h \ @srcdir@/lists.h @srcdir@/plist.h @srcdir@/string.h @srcdir@/bool.h \ @srcdir@/code.h @srcdir@/vars.h @srcdir@/exprs.h @srcdir@/intrprtr.h \ @srcdir@/ariths.h @srcdir@/stats.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o stats.o -c @srcdir@/stats.c streams.o: ../../Makefile @srcdir@/streams.c @srcdir@/system.h config.h @srcdir@/sysfiles.h \ @srcdir@/gasman.h @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h \ @srcdir@/read.h @srcdir@/funcs.h @srcdir@/gvars.h @srcdir@/calls.h \ @srcdir@/bool.h @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h \ @srcdir@/plist.h @srcdir@/string.h @srcdir@/saveload.h @srcdir@/streams.h \ @srcdir@/code.h @srcdir@/vars.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o streams.o -c @srcdir@/streams.c string.o: ../../Makefile @srcdir@/string.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/opers.h @srcdir@/ariths.h @srcdir@/bool.h \ @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h @srcdir@/plist.h \ @srcdir@/range.h @srcdir@/string.h @srcdir@/saveload.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o string.o -c @srcdir@/string.c sysfiles.o: ../../Makefile @srcdir@/sysfiles.c @srcdir@/system.h config.h @srcdir@/sysfiles.h \ @srcdir@/gasman.h @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h \ @srcdir@/gvars.h @srcdir@/calls.h @srcdir@/lists.h @srcdir@/listfunc.h \ @srcdir@/plist.h @srcdir@/string.h @srcdir@/records.h @srcdir@/bool.h \ @srcdir@/compstat.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o sysfiles.o -c @srcdir@/sysfiles.c system.o: ../../Makefile @srcdir@/system.c @srcdir@/system.h config.h @srcdir@/sysfiles.h \ @srcdir@/gasman.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o system.o -c @srcdir@/system.c tietze.o: ../../Makefile @srcdir@/tietze.c @srcdir@/system.h config.h @srcdir@/code.h \ @srcdir@/stats.h @srcdir@/gasman.h @srcdir@/objects.h @srcdir@/scanner.h \ @srcdir@/gap.h @srcdir@/calls.h @srcdir@/gvars.h @srcdir@/bool.h \ @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h @srcdir@/plist.h \ @srcdir@/string.h @srcdir@/tietze.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o tietze.o -c @srcdir@/tietze.c vars.o: ../../Makefile @srcdir@/vars.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/ariths.h @srcdir@/scanner.h @srcdir@/gap.h \ @srcdir@/gvars.h @srcdir@/calls.h @srcdir@/records.h @srcdir@/lists.h \ @srcdir@/bool.h @srcdir@/precord.h @srcdir@/plist.h @srcdir@/string.h \ @srcdir@/code.h @srcdir@/vars.h @srcdir@/exprs.h @srcdir@/stats.h \ @srcdir@/saveload.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o vars.o -c @srcdir@/vars.c vecgf2.o: ../../Makefile @srcdir@/vecgf2.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/opers.h @srcdir@/ariths.h @srcdir@/finfield.h \ @srcdir@/bool.h @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h \ @srcdir@/plist.h @srcdir@/range.h @srcdir@/blister.h @srcdir@/string.h \ @srcdir@/vecgf2.h @srcdir@/saveload.h @srcdir@/integer.h @srcdir@/vec8bit.h \ @srcdir@/code.h @srcdir@/stats.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o vecgf2.o -c @srcdir@/vecgf2.c vec8bit.o: ../../Makefile @srcdir@/vec8bit.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/gvars.h \ @srcdir@/calls.h @srcdir@/opers.h @srcdir@/ariths.h @srcdir@/finfield.h \ @srcdir@/bool.h @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h \ @srcdir@/listoper.h @srcdir@/plist.h @srcdir@/range.h @srcdir@/blister.h \ @srcdir@/string.h @srcdir@/vector.h @srcdir@/vec8bit.h @srcdir@/saveload.h \ @srcdir@/integer.h @srcdir@/vecgf2.h @srcdir@/code.h @srcdir@/stats.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o vec8bit.o -c @srcdir@/vec8bit.c vector.o: ../../Makefile @srcdir@/vector.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/ariths.h \ @srcdir@/lists.h @srcdir@/bool.h @srcdir@/integer.h @srcdir@/records.h \ @srcdir@/precord.h @srcdir@/listoper.h @srcdir@/plist.h @srcdir@/string.h \ @srcdir@/vector.h @srcdir@/range.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o vector.o -c @srcdir@/vector.c vecffe.o: ../../Makefile @srcdir@/vecffe.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/ariths.h \ @srcdir@/lists.h @srcdir@/bool.h @srcdir@/integer.h @srcdir@/finfield.h \ @srcdir@/gvars.h @srcdir@/records.h @srcdir@/precord.h @srcdir@/listoper.h \ @srcdir@/plist.h @srcdir@/string.h @srcdir@/vecffe.h @srcdir@/range.h \ @srcdir@/calls.h @srcdir@/opers.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o vecffe.o -c @srcdir@/vecffe.c weakptr.o: ../../Makefile @srcdir@/weakptr.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/gap.h @srcdir@/gvars.h @srcdir@/bool.h \ @srcdir@/weakptr.h @srcdir@/lists.h @srcdir@/plist.h @srcdir@/calls.h \ @srcdir@/saveload.h @srcdir@/opers.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o weakptr.o -c @srcdir@/weakptr.c iostream.o: ../../Makefile @srcdir@/iostream.c @srcdir@/system.h config.h @srcdir@/iostream.h \ @srcdir@/gasman.h @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gap.h \ @srcdir@/gvars.h @srcdir@/lists.h @srcdir@/listfunc.h @srcdir@/plist.h \ @srcdir@/string.h @srcdir@/records.h @srcdir@/bool.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o iostream.o -c @srcdir@/iostream.c macfloat.o: ../../Makefile @srcdir@/macfloat.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/gap.h @srcdir@/plist.h @srcdir@/ariths.h \ @srcdir@/integer.h @srcdir@/macfloat.h @srcdir@/bool.h @srcdir@/scanner.h \ @srcdir@/string.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o macfloat.o -c @srcdir@/macfloat.c intfuncs.o: ../../Makefile @srcdir@/intfuncs.c @srcdir@/system.h config.h @srcdir@/gasman.h \ @srcdir@/objects.h @srcdir@/scanner.h @srcdir@/gvars.h @srcdir@/calls.h \ @srcdir@/opers.h @srcdir@/ariths.h @srcdir@/bool.h @srcdir@/intfuncs.h \ @srcdir@/integer.h @srcdir@/gap.h @srcdir@/records.h @srcdir@/precord.h \ @srcdir@/lists.h @srcdir@/string.h @srcdir@/saveload.h $(CC) $(CPPFLAGS) $(GMP_CFLAGS) $(CFLAGS) -o intfuncs.o -c @srcdir@/intfuncs.c itanium.o: @srcdir@/itanium.s $(CC) $(CFLAGS) -o itanium.o -c @srcdir@/itanium.s gapmpi.o: @srcdir@/system.h @srcdir@/gasman.h @srcdir@/objects.h \ @srcdir@/scanner.h @srcdir@/gap.h @srcdir@/read.h \ @srcdir@/calls.h @srcdir@/gvars.h @srcdir@/bool.h \ @srcdir@/records.h @srcdir@/precord.h @srcdir@/lists.h \ @srcdir@/plist.h @srcdir@/sysfiles.h @srcdir@/code.h \ @srcdir@/vars.h @srcdir@/stats.h @srcdir@/gapmpi.h $(CC) -I. $(MPI_CFLAGS) -DCONFIG_H $(CFLAGS) -o gapmpi.o -c @srcdir@/gapmpi.c gap-4r6p5/cnf/config.hin0000644000175000017500000003023212172557252013654 0ustar billbill/* config.hin. Generated from configure.in by autoheader. */ /* Define if building universal (internal helper macro) */ #undef AC_APPLE_UNIVERSAL_BUILD /* the CONFIGNAME value of the active configuration */ #undef CONFIGNAME /* define as least offset which is still safe for an unaligned access */ #undef C_LONG_ALIGN /* define as least offset we have to check the stack for pointer */ #undef C_STACK_ALIGN /* define as 1 if you symbols in ".o" files begin with `_' */ #undef C_UNDERSCORE_SYMBOLS /* Define to 1 if you have the `accept' function. */ #undef HAVE_ACCEPT /* Define to 1 if you have the `access' function. */ #undef HAVE_ACCESS /* define as 1 if >> for long int behaves like an arithmetic right shift for negative numbers */ #undef HAVE_ARITHRIGHTSHIFT /* Define to 1 if you have the header file. */ #undef HAVE_ASSERT_H /* Define to 1 if you have the `atol' function. */ #undef HAVE_ATOL /* Define to 1 if you have the `bind' function. */ #undef HAVE_BIND /* Define to 1 if you have the `chmod' function. */ #undef HAVE_CHMOD /* Define to 1 if you have the `closedir' function. */ #undef HAVE_CLOSEDIR /* Define to 1 if you have the `connect' function. */ #undef HAVE_CONNECT /* Define to 1 if you have the header file, and it defines `DIR'. */ #undef HAVE_DIRENT_H /* define as 1 if you have `dlopen' and `dlsym' */ #undef HAVE_DLOPEN /* Define to 1 if you have the `dup' function. */ #undef HAVE_DUP /* Define to 1 if you have the `dup2' function. */ #undef HAVE_DUP2 /* Define to 1 if you have the header file. */ #undef HAVE_ERRNO_H /* Define to 1 if you have the `exp10' function. */ #undef HAVE_EXP10 /* Define to 1 if you have the `exp2' function. */ #undef HAVE_EXP2 /* Define to 1 if you have the `expm1' function. */ #undef HAVE_EXPM1 /* Define to 1 if you have the header file. */ #undef HAVE_FCNTL_H /* Define to 1 if you have the `fork' function. */ #undef HAVE_FORK /* Define to 1 if you have the `fstat' function. */ #undef HAVE_FSTAT /* Define to 1 if you have the `getpseudotty' function. */ #undef HAVE_GETPSEUDOTTY /* Define to 1 if you have the `getpt' function. */ #undef HAVE_GETPT /* Define to 1 if you have the `getrusage' function. */ #undef HAVE_GETRUSAGE /* Define to 1 if you have the `grantpt' function. */ #undef HAVE_GRANTPT /* Define to 1 if you have the header file. */ #undef HAVE_INTTYPES_H /* Define to 1 if you have the `ncurses' library (-lncurses). */ #undef HAVE_LIBNCURSES /* Define to 1 if you have the `readline' library (-lreadline). */ #undef HAVE_LIBREADLINE /* Define to 1 if you have the header file. */ #undef HAVE_LIBUTIL_H /* Define to 1 if you have the `link' function. */ #undef HAVE_LINK /* Define to 1 if you have the `log10' function. */ #undef HAVE_LOG10 /* Define to 1 if you have the `log1p' function. */ #undef HAVE_LOG1P /* Define to 1 if you have the `log2' function. */ #undef HAVE_LOG2 /* Define to 1 if you have the `lstat' function. */ #undef HAVE_LSTAT /* Define to 1 if you have the `madvise' function. */ #undef HAVE_MADVISE /* Define to 1 if you have the header file. */ #undef HAVE_MATH_H /* Define to 1 if you have the `memcpy' function. */ #undef HAVE_MEMCPY /* Define to 1 if you have the `memmove' function. */ #undef HAVE_MEMMOVE /* Define to 1 if you have the header file. */ #undef HAVE_MEMORY_H /* Define to 1 if you have the `memset' function. */ #undef HAVE_MEMSET /* Define to 1 if you have the `mkdir' function. */ #undef HAVE_MKDIR /* Define to 1 if you have the `mkdtemp' function. */ #undef HAVE_MKDTEMP /* Define to 1 if you have the `mkstemp' function. */ #undef HAVE_MKSTEMP /* Define to 1 if you have the header file, and it defines `DIR'. */ #undef HAVE_NDIR_H /* Define to 1 if you have the `opendir' function. */ #undef HAVE_OPENDIR /* define as 1 if you have `openpty' */ #undef HAVE_OPENPTY /* Define to 1 if you have the `popen' function. */ #undef HAVE_POPEN /* Define to 1 if you have the `posix_openpt' function. */ #undef HAVE_POSIX_OPENPT /* Define to 1 if you have the `ptsname' function. */ #undef HAVE_PTSNAME /* Define to 1 if you have the `ptsname_r' function. */ #undef HAVE_PTSNAME_R /* Define to 1 if you have the header file. */ #undef HAVE_PTY_H /* Define to 1 if you have the `readdir' function. */ #undef HAVE_READDIR /* Define to 1 if you have the `realpath' function. */ #undef HAVE_REALPATH /* Define to 1 if you have the `rename' function. */ #undef HAVE_RENAME /* Define to 1 if you have the `rld_load' function. */ #undef HAVE_RLD_LOAD /* Define to 1 if you have the `rmdir' function. */ #undef HAVE_RMDIR /* Define to 1 if you have the `sbrk' function. */ #undef HAVE_SBRK /* Define to 1 if you have the `select' function. */ #undef HAVE_SELECT /* Define to 1 if you have the `send' function. */ #undef HAVE_SEND /* Define to 1 if you have the `setpgid' function. */ #undef HAVE_SETPGID /* Define to 1 if you have the header file. */ #undef HAVE_SGTTY_H /* Define to 1 if you have the `signal' function. */ #undef HAVE_SIGNAL /* Define to 1 if you have the header file. */ #undef HAVE_SIGNAL_H /* Define to 1 if you have the `sigsetjmp' function. */ #undef HAVE_SIGSETJMP /* Define to 1 if you have the `socket' function. */ #undef HAVE_SOCKET /* Define to 1 if you have the `stat' function. */ #undef HAVE_STAT /* Define to 1 if you have the header file. */ #undef HAVE_STDINT_H /* Define to 1 if you have the header file. */ #undef HAVE_STDIO_H /* Define to 1 if you have the header file. */ #undef HAVE_STDLIB_H /* Define to 1 if you have the `strerror' function. */ #undef HAVE_STRERROR /* Define to 1 if you have the header file. */ #undef HAVE_STRINGS_H /* Define to 1 if you have the header file. */ #undef HAVE_STRING_H /* Define to 1 if you have the `strlcmp' function. */ #undef HAVE_STRLCMP /* Define to 1 if you have the `strlcpy' function. */ #undef HAVE_STRLCPY /* Define to 1 if you have the `sysconf' function. */ #undef HAVE_SYSCONF /* Define to 1 if you have the header file, and it defines `DIR'. */ #undef HAVE_SYS_DIR_H /* Define if your system libraries have a sys_errlist variable. */ #undef HAVE_SYS_ERRLIST /* Define to 1 if you have the header file. */ #undef HAVE_SYS_IOCTL_H /* Define to 1 if you have the header file, and it defines `DIR'. */ #undef HAVE_SYS_NDIR_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_PARAM_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_RESOURCE_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_STAT_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_SYSMACROS_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_TIMES_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_TIME_H /* Define to 1 if you have the header file. */ #undef HAVE_SYS_TYPES_H /* Define to 1 if you have that is POSIX.1 compatible. */ #undef HAVE_SYS_WAIT_H /* Define to 1 if you have the header file. */ #undef HAVE_TERMIOS_H /* Define to 1 if you have the header file. */ #undef HAVE_TERMIO_H /* Define to 1 if you have the `times' function. */ #undef HAVE_TIMES /* Define to 1 if you have the `trunc' function. */ #undef HAVE_TRUNC /* Define to 1 if you have the `ttyname' function. */ #undef HAVE_TTYNAME /* define as 1 if you have "union wait" */ #undef HAVE_UNION_WAIT /* Define to 1 if you have the header file. */ #undef HAVE_UNISTD_H /* Define to 1 if you have the `unlink' function. */ #undef HAVE_UNLINK /* Define to 1 if you have the `unlockpt' function. */ #undef HAVE_UNLOCKPT /* Define to 1 if you have the header file. */ #undef HAVE_UTIL_H /* Define to 1 if you have the `vfork' function. */ #undef HAVE_VFORK /* Define to 1 if you have the header file. */ #undef HAVE_VFORK_H /* Define to 1 if you have the `vm_allocate' function. */ #undef HAVE_VM_ALLOCATE /* Define to 1 if you have the `wait4' function. */ #undef HAVE_WAIT4 /* Define to 1 if you have the `waitpid' function. */ #undef HAVE_WAITPID /* Define to 1 if `fork' works. */ #undef HAVE_WORKING_FORK /* Define to 1 if `vfork' works. */ #undef HAVE_WORKING_VFORK /* Define to 1 if you have the `_getpty' function. */ #undef HAVE__GETPTY /* Define to 1 if you have the `_setjmp' function. */ #undef HAVE__SETJMP /* define as 1 on Itanium architecture to flush and mark register stack */ #undef ITANIUM /* Define to the address where bug reports for this package should be sent. */ #undef PACKAGE_BUGREPORT /* Define to the full name of this package. */ #undef PACKAGE_NAME /* Define to the full name and version of this package. */ #undef PACKAGE_STRING /* Define to the one symbol short name of this package. */ #undef PACKAGE_TARNAME /* Define to the home page for this package. */ #undef PACKAGE_URL /* Define to the version of this package. */ #undef PACKAGE_VERSION /* The size of `void *', as computed by sizeof. */ #undef SIZEOF_VOID_P /* define as 1 on SPARC architecture to flush register windows */ #undef SPARC /* Define to 1 if the `S_IS*' macros in do not work properly. */ #undef STAT_MACROS_BROKEN /* Define to 1 if you have the ANSI C header files. */ #undef STDC_HEADERS /* define the name of the architucture */ #undef SYS_ARCH /* define if this is the Cygwin32 port */ #undef SYS_IS_CYGWIN32 /* define if this is the Darwin port */ #undef SYS_IS_DARWIN /* use GMP for integers */ #undef USE_GMP /* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most significant byte first (like Motorola and SPARC, unlike Intel). */ #if defined AC_APPLE_UNIVERSAL_BUILD # if defined __BIG_ENDIAN__ # define WORDS_BIGENDIAN 1 # endif #else # ifndef WORDS_BIGENDIAN # undef WORDS_BIGENDIAN # endif #endif /* Define for Solaris 2.5.1 so the uint32_t typedef from , , or is not used. If the typedef were allowed, the #define below would cause a syntax error. */ #undef _UINT32_T /* Define for Solaris 2.5.1 so the uint64_t typedef from , , or is not used. If the typedef were allowed, the #define below would cause a syntax error. */ #undef _UINT64_T /* Define for Solaris 2.5.1 so the uint8_t typedef from , , or is not used. If the typedef were allowed, the #define below would cause a syntax error. */ #undef _UINT8_T /* Define to empty if `const' does not conform to ANSI C. */ #undef const /* Define to `__inline__' or `__inline' if that's what the C compiler calls it, or to nothing if 'inline' is not supported under any name. */ #ifndef __cplusplus #undef inline #endif /* Define to the type of a signed integer type of width exactly 16 bits if such a type exists and the standard includes do not define it. */ #undef int16_t /* Define to the type of a signed integer type of width exactly 32 bits if such a type exists and the standard includes do not define it. */ #undef int32_t /* Define to the type of a signed integer type of width exactly 64 bits if such a type exists and the standard includes do not define it. */ #undef int64_t /* Define to the type of a signed integer type of width exactly 8 bits if such a type exists and the standard includes do not define it. */ #undef int8_t /* Define to `int' if does not define. */ #undef pid_t /* Define to the type of an unsigned integer type of width exactly 16 bits if such a type exists and the standard includes do not define it. */ #undef uint16_t /* Define to the type of an unsigned integer type of width exactly 32 bits if such a type exists and the standard includes do not define it. */ #undef uint32_t /* Define to the type of an unsigned integer type of width exactly 64 bits if such a type exists and the standard includes do not define it. */ #undef uint64_t /* Define to the type of an unsigned integer type of width exactly 8 bits if such a type exists and the standard includes do not define it. */ #undef uint8_t /* Define as `fork' if `vfork' does not work. */ #undef vfork gap-4r6p5/cnf/install-sh0000755000175000017500000001273612172557252013724 0ustar billbill#!/bin/sh # # install - install a program, script, or datafile # This comes from X11R5 (mit/util/scripts/install.sh). # # Copyright 1991 by the Massachusetts Institute of Technology # # Permission to use, copy, modify, distribute, and sell this software and its # documentation for any purpose is hereby granted without fee, provided that # the above copyright notice appear in all copies and that both that # copyright notice and this permission notice appear in supporting # documentation, and that the name of M.I.T. not be used in advertising or # publicity pertaining to distribution of the software without specific, # written prior permission. M.I.T. makes no representations about the # suitability of this software for any purpose. It is provided "as is" # without express or implied warranty. # # Calling this script install-sh is preferred over install.sh, to prevent # `make' implicit rules from creating a file called install from it # when there is no Makefile. # # This script is compatible with the BSD install script, but was written # from scratch. It can only install one file at a time, a restriction # shared with many OS's install programs. # set DOITPROG to echo to test this script # Don't use :- since 4.3BSD and earlier shells don't like it. doit="${DOITPROG-}" # put in absolute paths if you don't have them in your path; or use env. vars. mvprog="${MVPROG-mv}" cpprog="${CPPROG-cp}" chmodprog="${CHMODPROG-chmod}" chownprog="${CHOWNPROG-chown}" chgrpprog="${CHGRPPROG-chgrp}" stripprog="${STRIPPROG-strip}" rmprog="${RMPROG-rm}" mkdirprog="${MKDIRPROG-mkdir}" transformbasename="" transform_arg="" instcmd="$mvprog" chmodcmd="$chmodprog 0755" chowncmd="" chgrpcmd="" stripcmd="" rmcmd="$rmprog -f" mvcmd="$mvprog" src="" dst="" dir_arg="" while [ x"$1" != x ]; do case $1 in -c) instcmd="$cpprog" shift continue;; -d) dir_arg=true shift continue;; -m) chmodcmd="$chmodprog $2" shift shift continue;; -o) chowncmd="$chownprog $2" shift shift continue;; -g) chgrpcmd="$chgrpprog $2" shift shift continue;; -s) stripcmd="$stripprog" shift continue;; -t=*) transformarg=`echo $1 | sed 's/-t=//'` shift continue;; -b=*) transformbasename=`echo $1 | sed 's/-b=//'` shift continue;; *) if [ x"$src" = x ] then src=$1 else # this colon is to work around a 386BSD /bin/sh bug : dst=$1 fi shift continue;; esac done if [ x"$src" = x ] then echo "install: no input file specified" exit 1 else true fi if [ x"$dir_arg" != x ]; then dst=$src src="" if [ -d $dst ]; then instcmd=: chmodcmd="" else instcmd=mkdir fi else # Waiting for this to be detected by the "$instcmd $src $dsttmp" command # might cause directories to be created, which would be especially bad # if $src (and thus $dsttmp) contains '*'. if [ -f $src -o -d $src ] then true else echo "install: $src does not exist" exit 1 fi if [ x"$dst" = x ] then echo "install: no destination specified" exit 1 else true fi # If destination is a directory, append the input filename; if your system # does not like double slashes in filenames, you may need to add some logic if [ -d $dst ] then dst="$dst"/`basename $src` else true fi fi ## this sed command emulates the dirname command dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'` # Make sure that the destination directory exists. # this part is taken from Noah Friedman's mkinstalldirs script # Skip lots of stat calls in the usual case. if [ ! -d "$dstdir" ]; then defaultIFS=' ' IFS="${IFS-${defaultIFS}}" oIFS="${IFS}" # Some sh's can't handle IFS=/ for some reason. IFS='%' set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'` IFS="${oIFS}" pathcomp='' while [ $# -ne 0 ] ; do pathcomp="${pathcomp}${1}" shift if [ ! -d "${pathcomp}" ] ; then $mkdirprog "${pathcomp}" else true fi pathcomp="${pathcomp}/" done fi if [ x"$dir_arg" != x ] then $doit $instcmd $dst && if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else true ; fi && if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else true ; fi && if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else true ; fi && if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else true ; fi else # If we're going to rename the final executable, determine the name now. if [ x"$transformarg" = x ] then dstfile=`basename $dst` else dstfile=`basename $dst $transformbasename | sed $transformarg`$transformbasename fi # don't allow the sed command to completely eliminate the filename if [ x"$dstfile" = x ] then dstfile=`basename $dst` else true fi # Make a temp file name in the proper directory. dsttmp=$dstdir/#inst.$$# # Move or copy the file name to the temp name $doit $instcmd $src $dsttmp && trap "rm -f ${dsttmp}" 0 && # and set any options; do chmod last to preserve setuid bits # If any of these fail, we abort the whole thing. If we want to # ignore errors from any of these, just make sure not to ignore # errors from the above "$doit $instcmd $src $dsttmp" command. if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; else true;fi && if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else true;fi && if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else true;fi && if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else true;fi && # Now rename the file to the real destination. $doit $rmcmd -f $dstdir/$dstfile && $doit $mvcmd $dsttmp $dstdir/$dstfile fi && exit 0 gap-4r6p5/cnf/config.guess0000755000175000017500000012776412172557252014250 0ustar billbill#! /bin/sh # Attempt to guess a canonical system name. # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, # 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 # Free Software Foundation, Inc. timestamp='2010-08-21' # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, but # WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU # General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA # 02110-1301, USA. # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. # Originally written by Per Bothner. Please send patches (context # diff format) to and include a ChangeLog # entry. # # This script attempts to guess a canonical system name similar to # config.sub. If it succeeds, it prints the system name on stdout, and # exits with 0. Otherwise, it exits with 1. # # You can get the latest version of this script from: # http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD me=`echo "$0" | sed -e 's,.*/,,'` usage="\ Usage: $0 [OPTION] Output the configuration name of the system \`$me' is run on. Operation modes: -h, --help print this help, then exit -t, --time-stamp print date of last modification, then exit -v, --version print version number, then exit Report bugs and patches to ." version="\ GNU config.guess ($timestamp) Originally written by Per Bothner. Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." help=" Try \`$me --help' for more information." # Parse command line while test $# -gt 0 ; do case $1 in --time-stamp | --time* | -t ) echo "$timestamp" ; exit ;; --version | -v ) echo "$version" ; exit ;; --help | --h* | -h ) echo "$usage"; exit ;; -- ) # Stop option processing shift; break ;; - ) # Use stdin as input. break ;; -* ) echo "$me: invalid option $1$help" >&2 exit 1 ;; * ) break ;; esac done if test $# != 0; then echo "$me: too many arguments$help" >&2 exit 1 fi trap 'exit 1' HUP INT TERM # CC_FOR_BUILD -- compiler used by this script. Note that the use of a # compiler to aid in system detection is discouraged as it requires # temporary files to be created and, as you can see below, it is a # headache to deal with in a portable fashion. # Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still # use `HOST_CC' if defined, but it is deprecated. # Portable tmp directory creation inspired by the Autoconf team. set_cc_for_build=' trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ; trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" HUP INT PIPE TERM ; : ${TMPDIR=/tmp} ; { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } || { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } || { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ; dummy=$tmp/dummy ; tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ; case $CC_FOR_BUILD,$HOST_CC,$CC in ,,) echo "int x;" > $dummy.c ; for c in cc gcc c89 c99 ; do if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then CC_FOR_BUILD="$c"; break ; fi ; done ; if test x"$CC_FOR_BUILD" = x ; then CC_FOR_BUILD=no_compiler_found ; fi ;; ,,*) CC_FOR_BUILD=$CC ;; ,*,*) CC_FOR_BUILD=$HOST_CC ;; esac ; set_cc_for_build= ;' # This is needed to find uname on a Pyramid OSx when run in the BSD universe. # (ghazi@noc.rutgers.edu 1994-08-24) if (test -f /.attbin/uname) >/dev/null 2>&1 ; then PATH=$PATH:/.attbin ; export PATH fi UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown # Note: order is significant - the case branches are not exclusive. case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in *:NetBSD:*:*) # NetBSD (nbsd) targets should (where applicable) match one or # more of the tupples: *-*-netbsdelf*, *-*-netbsdaout*, # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently # switched to ELF, *-*-netbsd* would select the old # object file format. This provides both forward # compatibility and a consistent mechanism for selecting the # object file format. # # Note: NetBSD doesn't particularly care about the vendor # portion of the name. We always set it to "unknown". sysctl="sysctl -n hw.machine_arch" UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \ /usr/sbin/$sysctl 2>/dev/null || echo unknown)` case "${UNAME_MACHINE_ARCH}" in armeb) machine=armeb-unknown ;; arm*) machine=arm-unknown ;; sh3el) machine=shl-unknown ;; sh3eb) machine=sh-unknown ;; sh5el) machine=sh5le-unknown ;; *) machine=${UNAME_MACHINE_ARCH}-unknown ;; esac # The Operating System including object format, if it has switched # to ELF recently, or will in the future. case "${UNAME_MACHINE_ARCH}" in arm*|i386|m68k|ns32k|sh3*|sparc|vax) eval $set_cc_for_build if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ELF__ then # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout). # Return netbsd for either. FIX? os=netbsd else os=netbsdelf fi ;; *) os=netbsd ;; esac # The OS release # Debian GNU/NetBSD machines have a different userland, and # thus, need a distinct triplet. However, they do not need # kernel version information, so it can be replaced with a # suitable tag, in the style of linux-gnu. case "${UNAME_VERSION}" in Debian*) release='-gnu' ;; *) release=`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'` ;; esac # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: # contains redundant information, the shorter form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. echo "${machine}-${os}${release}" exit ;; *:OpenBSD:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'` echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE} exit ;; *:ekkoBSD:*:*) echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE} exit ;; *:SolidBSD:*:*) echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE} exit ;; macppc:MirBSD:*:*) echo powerpc-unknown-mirbsd${UNAME_RELEASE} exit ;; *:MirBSD:*:*) echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE} exit ;; alpha:OSF1:*:*) case $UNAME_RELEASE in *4.0) UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` ;; *5.*) UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'` ;; esac # According to Compaq, /usr/sbin/psrinfo has been available on # OSF/1 and Tru64 systems produced since 1995. I hope that # covers most systems running today. This code pipes the CPU # types through head -n 1, so we only detect the type of CPU 0. ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` case "$ALPHA_CPU_TYPE" in "EV4 (21064)") UNAME_MACHINE="alpha" ;; "EV4.5 (21064)") UNAME_MACHINE="alpha" ;; "LCA4 (21066/21068)") UNAME_MACHINE="alpha" ;; "EV5 (21164)") UNAME_MACHINE="alphaev5" ;; "EV5.6 (21164A)") UNAME_MACHINE="alphaev56" ;; "EV5.6 (21164PC)") UNAME_MACHINE="alphapca56" ;; "EV5.7 (21164PC)") UNAME_MACHINE="alphapca57" ;; "EV6 (21264)") UNAME_MACHINE="alphaev6" ;; "EV6.7 (21264A)") UNAME_MACHINE="alphaev67" ;; "EV6.8CB (21264C)") UNAME_MACHINE="alphaev68" ;; "EV6.8AL (21264B)") UNAME_MACHINE="alphaev68" ;; "EV6.8CX (21264D)") UNAME_MACHINE="alphaev68" ;; "EV6.9A (21264/EV69A)") UNAME_MACHINE="alphaev69" ;; "EV7 (21364)") UNAME_MACHINE="alphaev7" ;; "EV7.9 (21364A)") UNAME_MACHINE="alphaev79" ;; esac # A Pn.n version is a patched version. # A Vn.n version is a released version. # A Tn.n version is a released field test version. # A Xn.n version is an unreleased experimental baselevel. # 1.2 uses "1.2" for uname -r. echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` exit ;; Alpha\ *:Windows_NT*:*) # How do we know it's Interix rather than the generic POSIX subsystem? # Should we change UNAME_MACHINE based on the output of uname instead # of the specific Alpha model? echo alpha-pc-interix exit ;; 21064:Windows_NT:50:3) echo alpha-dec-winnt3.5 exit ;; Amiga*:UNIX_System_V:4.0:*) echo m68k-unknown-sysv4 exit ;; *:[Aa]miga[Oo][Ss]:*:*) echo ${UNAME_MACHINE}-unknown-amigaos exit ;; *:[Mm]orph[Oo][Ss]:*:*) echo ${UNAME_MACHINE}-unknown-morphos exit ;; *:OS/390:*:*) echo i370-ibm-openedition exit ;; *:z/VM:*:*) echo s390-ibm-zvmoe exit ;; *:OS400:*:*) echo powerpc-ibm-os400 exit ;; arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) echo arm-acorn-riscix${UNAME_RELEASE} exit ;; arm:riscos:*:*|arm:RISCOS:*:*) echo arm-unknown-riscos exit ;; SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) echo hppa1.1-hitachi-hiuxmpp exit ;; Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. if test "`(/bin/universe) 2>/dev/null`" = att ; then echo pyramid-pyramid-sysv3 else echo pyramid-pyramid-bsd fi exit ;; NILE*:*:*:dcosx) echo pyramid-pyramid-svr4 exit ;; DRS?6000:unix:4.0:6*) echo sparc-icl-nx6 exit ;; DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*) case `/usr/bin/uname -p` in sparc) echo sparc-icl-nx7; exit ;; esac ;; s390x:SunOS:*:*) echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4H:SunOS:5.*:*) echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*) echo i386-pc-auroraux${UNAME_RELEASE} exit ;; i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*) eval $set_cc_for_build SUN_ARCH="i386" # If there is a compiler, see if it is configured for 64-bit objects. # Note that the Sun cc does not turn __LP64__ into 1 like gcc does. # This test works for both compilers. if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \ (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_64BIT_ARCH >/dev/null then SUN_ARCH="x86_64" fi fi echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4*:SunOS:6*:*) # According to config.sub, this is the proper way to canonicalize # SunOS6. Hard to guess exactly what SunOS6 will be like, but # it's likely to be more like Solaris than SunOS4. echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; sun4*:SunOS:*:*) case "`/usr/bin/arch -k`" in Series*|S4*) UNAME_RELEASE=`uname -v` ;; esac # Japanese Language versions have a version number like `4.1.3-JL'. echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'` exit ;; sun3*:SunOS:*:*) echo m68k-sun-sunos${UNAME_RELEASE} exit ;; sun*:*:4.2BSD:*) UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3 case "`/bin/arch`" in sun3) echo m68k-sun-sunos${UNAME_RELEASE} ;; sun4) echo sparc-sun-sunos${UNAME_RELEASE} ;; esac exit ;; aushp:SunOS:*:*) echo sparc-auspex-sunos${UNAME_RELEASE} exit ;; # The situation for MiNT is a little confusing. The machine name # can be virtually everything (everything which is not # "atarist" or "atariste" at least should have a processor # > m68000). The system name ranges from "MiNT" over "FreeMiNT" # to the lowercase version "mint" (or "freemint"). Finally # the system name "TOS" denotes a system which is actually not # MiNT. But MiNT is downward compatible to TOS, so this should # be no problem. atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} exit ;; milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) echo m68k-milan-mint${UNAME_RELEASE} exit ;; hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) echo m68k-hades-mint${UNAME_RELEASE} exit ;; *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) echo m68k-unknown-mint${UNAME_RELEASE} exit ;; m68k:machten:*:*) echo m68k-apple-machten${UNAME_RELEASE} exit ;; powerpc:machten:*:*) echo powerpc-apple-machten${UNAME_RELEASE} exit ;; RISC*:Mach:*:*) echo mips-dec-mach_bsd4.3 exit ;; RISC*:ULTRIX:*:*) echo mips-dec-ultrix${UNAME_RELEASE} exit ;; VAX*:ULTRIX*:*:*) echo vax-dec-ultrix${UNAME_RELEASE} exit ;; 2020:CLIX:*:* | 2430:CLIX:*:*) echo clipper-intergraph-clix${UNAME_RELEASE} exit ;; mips:*:*:UMIPS | mips:*:*:RISCos) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #ifdef __cplusplus #include /* for printf() prototype */ int main (int argc, char *argv[]) { #else int main (argc, argv) int argc; char *argv[]; { #endif #if defined (host_mips) && defined (MIPSEB) #if defined (SYSTYPE_SYSV) printf ("mips-mips-riscos%ssysv\n", argv[1]); exit (0); #endif #if defined (SYSTYPE_SVR4) printf ("mips-mips-riscos%ssvr4\n", argv[1]); exit (0); #endif #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD) printf ("mips-mips-riscos%sbsd\n", argv[1]); exit (0); #endif #endif exit (-1); } EOF $CC_FOR_BUILD -o $dummy $dummy.c && dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/\([0-9]*\).*/\1/p'` && SYSTEM_NAME=`$dummy $dummyarg` && { echo "$SYSTEM_NAME"; exit; } echo mips-mips-riscos${UNAME_RELEASE} exit ;; Motorola:PowerMAX_OS:*:*) echo powerpc-motorola-powermax exit ;; Motorola:*:4.3:PL8-*) echo powerpc-harris-powermax exit ;; Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) echo powerpc-harris-powermax exit ;; Night_Hawk:Power_UNIX:*:*) echo powerpc-harris-powerunix exit ;; m88k:CX/UX:7*:*) echo m88k-harris-cxux7 exit ;; m88k:*:4*:R4*) echo m88k-motorola-sysv4 exit ;; m88k:*:3*:R3*) echo m88k-motorola-sysv3 exit ;; AViiON:dgux:*:*) # DG/UX returns AViiON for all architectures UNAME_PROCESSOR=`/usr/bin/uname -p` if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ] then if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \ [ ${TARGET_BINARY_INTERFACE}x = x ] then echo m88k-dg-dgux${UNAME_RELEASE} else echo m88k-dg-dguxbcs${UNAME_RELEASE} fi else echo i586-dg-dgux${UNAME_RELEASE} fi exit ;; M88*:DolphinOS:*:*) # DolphinOS (SVR3) echo m88k-dolphin-sysv3 exit ;; M88*:*:R3*:*) # Delta 88k system running SVR3 echo m88k-motorola-sysv3 exit ;; XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) echo m88k-tektronix-sysv3 exit ;; Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) echo m68k-tektronix-bsd exit ;; *:IRIX*:*:*) echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'` exit ;; ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id exit ;; # Note that: echo "'`uname -s`'" gives 'AIX ' i*86:AIX:*:*) echo i386-ibm-aix exit ;; ia64:AIX:*:*) if [ -x /usr/bin/oslevel ] ; then IBM_REV=`/usr/bin/oslevel` else IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} fi echo ${UNAME_MACHINE}-ibm-aix${IBM_REV} exit ;; *:AIX:2:3) if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #include main() { if (!__power_pc()) exit(1); puts("powerpc-ibm-aix3.2.5"); exit(0); } EOF if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` then echo "$SYSTEM_NAME" else echo rs6000-ibm-aix3.2.5 fi elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then echo rs6000-ibm-aix3.2.4 else echo rs6000-ibm-aix3.2 fi exit ;; *:AIX:*:[4567]) IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then IBM_ARCH=rs6000 else IBM_ARCH=powerpc fi if [ -x /usr/bin/oslevel ] ; then IBM_REV=`/usr/bin/oslevel` else IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE} fi echo ${IBM_ARCH}-ibm-aix${IBM_REV} exit ;; *:AIX:*:*) echo rs6000-ibm-aix exit ;; ibmrt:4.4BSD:*|romp-ibm:BSD:*) echo romp-ibm-bsd4.4 exit ;; ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and echo romp-ibm-bsd${UNAME_RELEASE} # 4.3 with uname added to exit ;; # report: romp-ibm BSD 4.3 *:BOSX:*:*) echo rs6000-bull-bosx exit ;; DPX/2?00:B.O.S.:*:*) echo m68k-bull-sysv3 exit ;; 9000/[34]??:4.3bsd:1.*:*) echo m68k-hp-bsd exit ;; hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) echo m68k-hp-bsd4.4 exit ;; 9000/[34678]??:HP-UX:*:*) HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` case "${UNAME_MACHINE}" in 9000/31? ) HP_ARCH=m68000 ;; 9000/[34]?? ) HP_ARCH=m68k ;; 9000/[678][0-9][0-9]) if [ -x /usr/bin/getconf ]; then sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` case "${sc_cpu_version}" in 523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0 528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1 532) # CPU_PA_RISC2_0 case "${sc_kernel_bits}" in 32) HP_ARCH="hppa2.0n" ;; 64) HP_ARCH="hppa2.0w" ;; '') HP_ARCH="hppa2.0" ;; # HP-UX 10.20 esac ;; esac fi if [ "${HP_ARCH}" = "" ]; then eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #define _HPUX_SOURCE #include #include int main () { #if defined(_SC_KERNEL_BITS) long bits = sysconf(_SC_KERNEL_BITS); #endif long cpu = sysconf (_SC_CPU_VERSION); switch (cpu) { case CPU_PA_RISC1_0: puts ("hppa1.0"); break; case CPU_PA_RISC1_1: puts ("hppa1.1"); break; case CPU_PA_RISC2_0: #if defined(_SC_KERNEL_BITS) switch (bits) { case 64: puts ("hppa2.0w"); break; case 32: puts ("hppa2.0n"); break; default: puts ("hppa2.0"); break; } break; #else /* !defined(_SC_KERNEL_BITS) */ puts ("hppa2.0"); break; #endif default: puts ("hppa1.0"); break; } exit (0); } EOF (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy` test -z "$HP_ARCH" && HP_ARCH=hppa fi ;; esac if [ ${HP_ARCH} = "hppa2.0w" ] then eval $set_cc_for_build # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating # 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler # generating 64-bit code. GNU and HP use different nomenclature: # # $ CC_FOR_BUILD=cc ./config.guess # => hppa2.0w-hp-hpux11.23 # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess # => hppa64-hp-hpux11.23 if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | grep -q __LP64__ then HP_ARCH="hppa2.0w" else HP_ARCH="hppa64" fi fi echo ${HP_ARCH}-hp-hpux${HPUX_REV} exit ;; ia64:HP-UX:*:*) HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` echo ia64-hp-hpux${HPUX_REV} exit ;; 3050*:HI-UX:*:*) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #include int main () { long cpu = sysconf (_SC_CPU_VERSION); /* The order matters, because CPU_IS_HP_MC68K erroneously returns true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct results, however. */ if (CPU_IS_PA_RISC (cpu)) { switch (cpu) { case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break; case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break; case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break; default: puts ("hppa-hitachi-hiuxwe2"); break; } } else if (CPU_IS_HP_MC68K (cpu)) puts ("m68k-hitachi-hiuxwe2"); else puts ("unknown-hitachi-hiuxwe2"); exit (0); } EOF $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` && { echo "$SYSTEM_NAME"; exit; } echo unknown-hitachi-hiuxwe2 exit ;; 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:* ) echo hppa1.1-hp-bsd exit ;; 9000/8??:4.3bsd:*:*) echo hppa1.0-hp-bsd exit ;; *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) echo hppa1.0-hp-mpeix exit ;; hp7??:OSF1:*:* | hp8?[79]:OSF1:*:* ) echo hppa1.1-hp-osf exit ;; hp8??:OSF1:*:*) echo hppa1.0-hp-osf exit ;; i*86:OSF1:*:*) if [ -x /usr/sbin/sysversion ] ; then echo ${UNAME_MACHINE}-unknown-osf1mk else echo ${UNAME_MACHINE}-unknown-osf1 fi exit ;; parisc*:Lites*:*:*) echo hppa1.1-hp-lites exit ;; C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) echo c1-convex-bsd exit ;; C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) if getsysinfo -f scalar_acc then echo c32-convex-bsd else echo c2-convex-bsd fi exit ;; C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) echo c34-convex-bsd exit ;; C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) echo c38-convex-bsd exit ;; C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) echo c4-convex-bsd exit ;; CRAY*Y-MP:*:*:*) echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*[A-Z]90:*:*:*) echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \ | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \ -e 's/\.[^.]*$/.X/' exit ;; CRAY*TS:*:*:*) echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*T3E:*:*:*) echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; CRAY*SV1:*:*:*) echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; *:UNICOS/mp:*:*) echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'` echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" exit ;; 5000:UNIX_System_V:4.*:*) FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'` echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" exit ;; i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE} exit ;; sparc*:BSD/OS:*:*) echo sparc-unknown-bsdi${UNAME_RELEASE} exit ;; *:BSD/OS:*:*) echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE} exit ;; *:FreeBSD:*:*) case ${UNAME_MACHINE} in pc98) echo i386-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; amd64) echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; *) echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ;; esac exit ;; i*:CYGWIN*:*) echo ${UNAME_MACHINE}-pc-cygwin exit ;; *:MINGW*:*) echo ${UNAME_MACHINE}-pc-mingw32 exit ;; i*:windows32*:*) # uname -m includes "-pc" on this system. echo ${UNAME_MACHINE}-mingw32 exit ;; i*:PW*:*) echo ${UNAME_MACHINE}-pc-pw32 exit ;; *:Interix*:*) case ${UNAME_MACHINE} in x86) echo i586-pc-interix${UNAME_RELEASE} exit ;; authenticamd | genuineintel | EM64T) echo x86_64-unknown-interix${UNAME_RELEASE} exit ;; IA64) echo ia64-unknown-interix${UNAME_RELEASE} exit ;; esac ;; [345]86:Windows_95:* | [345]86:Windows_98:* | [345]86:Windows_NT:*) echo i${UNAME_MACHINE}-pc-mks exit ;; 8664:Windows_NT:*) echo x86_64-pc-mks exit ;; i*:Windows_NT*:* | Pentium*:Windows_NT*:*) # How do we know it's Interix rather than the generic POSIX subsystem? # It also conflicts with pre-2.0 versions of AT&T UWIN. Should we # UNAME_MACHINE based on the output of uname instead of i386? echo i586-pc-interix exit ;; i*:UWIN*:*) echo ${UNAME_MACHINE}-pc-uwin exit ;; amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) echo x86_64-unknown-cygwin exit ;; p*:CYGWIN*:*) echo powerpcle-unknown-cygwin exit ;; prep*:SunOS:5.*:*) echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` exit ;; *:GNU:*:*) # the GNU system echo `echo ${UNAME_MACHINE}|sed -e 's,[-/].*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'` exit ;; *:GNU/*:*:*) # other systems with GNU libc and userland echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^[^/]*/,,' | tr '[A-Z]' '[a-z]'``echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`-gnu exit ;; i*86:Minix:*:*) echo ${UNAME_MACHINE}-pc-minix exit ;; alpha:Linux:*:*) case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in EV5) UNAME_MACHINE=alphaev5 ;; EV56) UNAME_MACHINE=alphaev56 ;; PCA56) UNAME_MACHINE=alphapca56 ;; PCA57) UNAME_MACHINE=alphapca56 ;; EV6) UNAME_MACHINE=alphaev6 ;; EV67) UNAME_MACHINE=alphaev67 ;; EV68*) UNAME_MACHINE=alphaev68 ;; esac objdump --private-headers /bin/sh | grep -q ld.so.1 if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC} exit ;; arm*:Linux:*:*) eval $set_cc_for_build if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_EABI__ then echo ${UNAME_MACHINE}-unknown-linux-gnu else echo ${UNAME_MACHINE}-unknown-linux-gnueabi fi exit ;; avr32*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; cris:Linux:*:*) echo cris-axis-linux-gnu exit ;; crisv32:Linux:*:*) echo crisv32-axis-linux-gnu exit ;; frv:Linux:*:*) echo frv-unknown-linux-gnu exit ;; i*86:Linux:*:*) LIBC=gnu eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #ifdef __dietlibc__ LIBC=dietlibc #endif EOF eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC'` echo "${UNAME_MACHINE}-pc-linux-${LIBC}" exit ;; ia64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; m32r*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; m68*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; mips:Linux:*:* | mips64:Linux:*:*) eval $set_cc_for_build sed 's/^ //' << EOF >$dummy.c #undef CPU #undef ${UNAME_MACHINE} #undef ${UNAME_MACHINE}el #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) CPU=${UNAME_MACHINE}el #else #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) CPU=${UNAME_MACHINE} #else CPU= #endif #endif EOF eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'` test x"${CPU}" != x && { echo "${CPU}-unknown-linux-gnu"; exit; } ;; or32:Linux:*:*) echo or32-unknown-linux-gnu exit ;; padre:Linux:*:*) echo sparc-unknown-linux-gnu exit ;; parisc64:Linux:*:* | hppa64:Linux:*:*) echo hppa64-unknown-linux-gnu exit ;; parisc:Linux:*:* | hppa:Linux:*:*) # Look for CPU level case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in PA7*) echo hppa1.1-unknown-linux-gnu ;; PA8*) echo hppa2.0-unknown-linux-gnu ;; *) echo hppa-unknown-linux-gnu ;; esac exit ;; ppc64:Linux:*:*) echo powerpc64-unknown-linux-gnu exit ;; ppc:Linux:*:*) echo powerpc-unknown-linux-gnu exit ;; s390:Linux:*:* | s390x:Linux:*:*) echo ${UNAME_MACHINE}-ibm-linux exit ;; sh64*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; sh*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; sparc:Linux:*:* | sparc64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; tile*:Linux:*:*) echo ${UNAME_MACHINE}-tilera-linux-gnu exit ;; vax:Linux:*:*) echo ${UNAME_MACHINE}-dec-linux-gnu exit ;; x86_64:Linux:*:*) echo x86_64-unknown-linux-gnu exit ;; xtensa*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; i*86:DYNIX/ptx:4*:*) # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. # earlier versions are messed up and put the nodename in both # sysname and nodename. echo i386-sequent-sysv4 exit ;; i*86:UNIX_SV:4.2MP:2.*) # Unixware is an offshoot of SVR4, but it has its own version # number series starting with 2... # I am not positive that other SVR4 systems won't match this, # I just have to hope. -- rms. # Use sysv4.2uw... so that sysv4* matches it. echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION} exit ;; i*86:OS/2:*:*) # If we were able to find `uname', then EMX Unix compatibility # is probably installed. echo ${UNAME_MACHINE}-pc-os2-emx exit ;; i*86:XTS-300:*:STOP) echo ${UNAME_MACHINE}-unknown-stop exit ;; i*86:atheos:*:*) echo ${UNAME_MACHINE}-unknown-atheos exit ;; i*86:syllable:*:*) echo ${UNAME_MACHINE}-pc-syllable exit ;; i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*) echo i386-unknown-lynxos${UNAME_RELEASE} exit ;; i*86:*DOS:*:*) echo ${UNAME_MACHINE}-pc-msdosdjgpp exit ;; i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*) UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'` if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL} else echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL} fi exit ;; i*86:*:5:[678]*) # UnixWare 7.x, OpenUNIX and OpenServer 6. case `/bin/uname -X | grep "^Machine"` in *486*) UNAME_MACHINE=i486 ;; *Pentium) UNAME_MACHINE=i586 ;; *Pent*|*Celeron) UNAME_MACHINE=i686 ;; esac echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION} exit ;; i*86:*:3.2:*) if test -f /usr/options/cb.name; then UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \ && UNAME_MACHINE=i586 (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \ && UNAME_MACHINE=i686 (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ && UNAME_MACHINE=i686 echo ${UNAME_MACHINE}-pc-sco$UNAME_REL else echo ${UNAME_MACHINE}-pc-sysv32 fi exit ;; pc:*:*:*) # Left here for compatibility: # uname -m prints for DJGPP always 'pc', but it prints nothing about # the processor, so we play safe by assuming i586. # Note: whatever this is, it MUST be the same as what config.sub # prints for the "djgpp" host, or else GDB configury will decide that # this is a cross-build. echo i586-pc-msdosdjgpp exit ;; Intel:Mach:3*:*) echo i386-pc-mach3 exit ;; paragon:*:*:*) echo i860-intel-osf1 exit ;; i860:*:4.*:*) # i860-SVR4 if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4 else # Add other i860-SVR4 vendors below as they are discovered. echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4 fi exit ;; mini*:CTIX:SYS*5:*) # "miniframe" echo m68010-convergent-sysv exit ;; mc68k:UNIX:SYSTEM5:3.51m) echo m68k-convergent-sysv exit ;; M680?0:D-NIX:5.3:*) echo m68k-diab-dnix exit ;; M68*:*:R3V[5678]*:*) test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;; 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0) OS_REL='' test -r /etc/.relid \ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4.3${OS_REL}; exit; } /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4; exit; } ;; NCR*:*:4.2:* | MPRAS*:*:4.2:*) OS_REL='.3' test -r /etc/.relid \ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ && { echo i486-ncr-sysv4.3${OS_REL}; exit; } /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } /bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) echo m68k-unknown-lynxos${UNAME_RELEASE} exit ;; mc68030:UNIX_System_V:4.*:*) echo m68k-atari-sysv4 exit ;; TSUNAMI:LynxOS:2.*:*) echo sparc-unknown-lynxos${UNAME_RELEASE} exit ;; rs6000:LynxOS:2.*:*) echo rs6000-unknown-lynxos${UNAME_RELEASE} exit ;; PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*) echo powerpc-unknown-lynxos${UNAME_RELEASE} exit ;; SM[BE]S:UNIX_SV:*:*) echo mips-dde-sysv${UNAME_RELEASE} exit ;; RM*:ReliantUNIX-*:*:*) echo mips-sni-sysv4 exit ;; RM*:SINIX-*:*:*) echo mips-sni-sysv4 exit ;; *:SINIX-*:*:*) if uname -p 2>/dev/null >/dev/null ; then UNAME_MACHINE=`(uname -p) 2>/dev/null` echo ${UNAME_MACHINE}-sni-sysv4 else echo ns32k-sni-sysv fi exit ;; PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort # says echo i586-unisys-sysv4 exit ;; *:UNIX_System_V:4*:FTX*) # From Gerald Hewes . # How about differentiating between stratus architectures? -djm echo hppa1.1-stratus-sysv4 exit ;; *:*:*:FTX*) # From seanf@swdc.stratus.com. echo i860-stratus-sysv4 exit ;; i*86:VOS:*:*) # From Paul.Green@stratus.com. echo ${UNAME_MACHINE}-stratus-vos exit ;; *:VOS:*:*) # From Paul.Green@stratus.com. echo hppa1.1-stratus-vos exit ;; mc68*:A/UX:*:*) echo m68k-apple-aux${UNAME_RELEASE} exit ;; news*:NEWS-OS:6*:*) echo mips-sony-newsos6 exit ;; R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) if [ -d /usr/nec ]; then echo mips-nec-sysv${UNAME_RELEASE} else echo mips-unknown-sysv${UNAME_RELEASE} fi exit ;; BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. echo powerpc-be-beos exit ;; BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. echo powerpc-apple-beos exit ;; BePC:BeOS:*:*) # BeOS running on Intel PC compatible. echo i586-pc-beos exit ;; BePC:Haiku:*:*) # Haiku running on Intel PC compatible. echo i586-pc-haiku exit ;; SX-4:SUPER-UX:*:*) echo sx4-nec-superux${UNAME_RELEASE} exit ;; SX-5:SUPER-UX:*:*) echo sx5-nec-superux${UNAME_RELEASE} exit ;; SX-6:SUPER-UX:*:*) echo sx6-nec-superux${UNAME_RELEASE} exit ;; SX-7:SUPER-UX:*:*) echo sx7-nec-superux${UNAME_RELEASE} exit ;; SX-8:SUPER-UX:*:*) echo sx8-nec-superux${UNAME_RELEASE} exit ;; SX-8R:SUPER-UX:*:*) echo sx8r-nec-superux${UNAME_RELEASE} exit ;; Power*:Rhapsody:*:*) echo powerpc-apple-rhapsody${UNAME_RELEASE} exit ;; *:Rhapsody:*:*) echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE} exit ;; *:Darwin:*:*) UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown case $UNAME_PROCESSOR in i386) eval $set_cc_for_build if [ "$CC_FOR_BUILD" != 'no_compiler_found' ]; then if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \ (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \ grep IS_64BIT_ARCH >/dev/null then UNAME_PROCESSOR="x86_64" fi fi ;; unknown) UNAME_PROCESSOR=powerpc ;; esac echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE} exit ;; *:procnto*:*:* | *:QNX:[0123456789]*:*) UNAME_PROCESSOR=`uname -p` if test "$UNAME_PROCESSOR" = "x86"; then UNAME_PROCESSOR=i386 UNAME_MACHINE=pc fi echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE} exit ;; *:QNX:*:4*) echo i386-pc-qnx exit ;; NSE-?:NONSTOP_KERNEL:*:*) echo nse-tandem-nsk${UNAME_RELEASE} exit ;; NSR-?:NONSTOP_KERNEL:*:*) echo nsr-tandem-nsk${UNAME_RELEASE} exit ;; *:NonStop-UX:*:*) echo mips-compaq-nonstopux exit ;; BS2000:POSIX*:*:*) echo bs2000-siemens-sysv exit ;; DS/*:UNIX_System_V:*:*) echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE} exit ;; *:Plan9:*:*) # "uname -m" is not consistent, so use $cputype instead. 386 # is converted to i386 for consistency with other x86 # operating systems. if test "$cputype" = "386"; then UNAME_MACHINE=i386 else UNAME_MACHINE="$cputype" fi echo ${UNAME_MACHINE}-unknown-plan9 exit ;; *:TOPS-10:*:*) echo pdp10-unknown-tops10 exit ;; *:TENEX:*:*) echo pdp10-unknown-tenex exit ;; KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) echo pdp10-dec-tops20 exit ;; XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) echo pdp10-xkl-tops20 exit ;; *:TOPS-20:*:*) echo pdp10-unknown-tops20 exit ;; *:ITS:*:*) echo pdp10-unknown-its exit ;; SEI:*:*:SEIUX) echo mips-sei-seiux${UNAME_RELEASE} exit ;; *:DragonFly:*:*) echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` exit ;; *:*VMS:*:*) UNAME_MACHINE=`(uname -p) 2>/dev/null` case "${UNAME_MACHINE}" in A*) echo alpha-dec-vms ; exit ;; I*) echo ia64-dec-vms ; exit ;; V*) echo vax-dec-vms ; exit ;; esac ;; *:XENIX:*:SysV) echo i386-pc-xenix exit ;; i*86:skyos:*:*) echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//' exit ;; i*86:rdos:*:*) echo ${UNAME_MACHINE}-pc-rdos exit ;; i*86:AROS:*:*) echo ${UNAME_MACHINE}-pc-aros exit ;; esac #echo '(No uname command or uname output not recognized.)' 1>&2 #echo "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" 1>&2 eval $set_cc_for_build cat >$dummy.c < # include #endif main () { #if defined (sony) #if defined (MIPSEB) /* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed, I don't know.... */ printf ("mips-sony-bsd\n"); exit (0); #else #include printf ("m68k-sony-newsos%s\n", #ifdef NEWSOS4 "4" #else "" #endif ); exit (0); #endif #endif #if defined (__arm) && defined (__acorn) && defined (__unix) printf ("arm-acorn-riscix\n"); exit (0); #endif #if defined (hp300) && !defined (hpux) printf ("m68k-hp-bsd\n"); exit (0); #endif #if defined (NeXT) #if !defined (__ARCHITECTURE__) #define __ARCHITECTURE__ "m68k" #endif int version; version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`; if (version < 4) printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version); else printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version); exit (0); #endif #if defined (MULTIMAX) || defined (n16) #if defined (UMAXV) printf ("ns32k-encore-sysv\n"); exit (0); #else #if defined (CMU) printf ("ns32k-encore-mach\n"); exit (0); #else printf ("ns32k-encore-bsd\n"); exit (0); #endif #endif #endif #if defined (__386BSD__) printf ("i386-pc-bsd\n"); exit (0); #endif #if defined (sequent) #if defined (i386) printf ("i386-sequent-dynix\n"); exit (0); #endif #if defined (ns32000) printf ("ns32k-sequent-dynix\n"); exit (0); #endif #endif #if defined (_SEQUENT_) struct utsname un; uname(&un); if (strncmp(un.version, "V2", 2) == 0) { printf ("i386-sequent-ptx2\n"); exit (0); } if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */ printf ("i386-sequent-ptx1\n"); exit (0); } printf ("i386-sequent-ptx\n"); exit (0); #endif #if defined (vax) # if !defined (ultrix) # include # if defined (BSD) # if BSD == 43 printf ("vax-dec-bsd4.3\n"); exit (0); # else # if BSD == 199006 printf ("vax-dec-bsd4.3reno\n"); exit (0); # else printf ("vax-dec-bsd\n"); exit (0); # endif # endif # else printf ("vax-dec-bsd\n"); exit (0); # endif # else printf ("vax-dec-ultrix\n"); exit (0); # endif #endif #if defined (alliant) && defined (i860) printf ("i860-alliant-bsd\n"); exit (0); #endif exit (1); } EOF $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` && { echo "$SYSTEM_NAME"; exit; } # Apollos put the system type in the environment. test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; } # Convex versions that predate uname can use getsysinfo(1) if [ -x /usr/convex/getsysinfo ] then case `getsysinfo -f cpu_type` in c1*) echo c1-convex-bsd exit ;; c2*) if getsysinfo -f scalar_acc then echo c32-convex-bsd else echo c2-convex-bsd fi exit ;; c34*) echo c34-convex-bsd exit ;; c38*) echo c38-convex-bsd exit ;; c4*) echo c4-convex-bsd exit ;; esac fi cat >&2 < in order to provide the needed information to handle your system. config.guess timestamp = $timestamp uname -m = `(uname -m) 2>/dev/null || echo unknown` uname -r = `(uname -r) 2>/dev/null || echo unknown` uname -s = `(uname -s) 2>/dev/null || echo unknown` uname -v = `(uname -v) 2>/dev/null || echo unknown` /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null` /bin/uname -X = `(/bin/uname -X) 2>/dev/null` hostinfo = `(hostinfo) 2>/dev/null` /bin/universe = `(/bin/universe) 2>/dev/null` /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null` /bin/arch = `(/bin/arch) 2>/dev/null` /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null` /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null` UNAME_MACHINE = ${UNAME_MACHINE} UNAME_RELEASE = ${UNAME_RELEASE} UNAME_SYSTEM = ${UNAME_SYSTEM} UNAME_VERSION = ${UNAME_VERSION} EOF exit 1 # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: gap-4r6p5/cnf/Makefile0000644000175000017500000000567012172557252013357 0ustar billbill############################################################################# ## #W Makefile GAP source Frank Celler ## ## #Y Copyright (C) 1997, Lehrstuhl D fuer Mathematik, RWTH Aachen, Germany ## ## This file creates the `configure' scripts using `autoconf'. ## CC=cc SOURCE=\ ariths blister bool c_meths1 c_type1 \ c_oper1 c_filt1 c_random \ calls code compiler compstat costab \ cyclotom dt dteval exprs finfield\ funcs gap gasman gmpints gvars \ integer intrprtr listfunc listoper lists \ objcftl objects objfgelm objpcgel objscoll\ objccoll opers permutat plist precord \ range rational read records saveload\ scanner sctable set stats streams \ string sysfiles system tietze vars \ vecgf2 vec8bit vector vecffe weakptr \ iostream macfloat intfuncs default: configure.out ../configure Makegap.in config.hin: configure.in aclocal.m4 autoheader configure.out: configure.in aclocal.m4 config.hin autoconf sed -e 's%^srcdir=$$%srcdir=../../src%' \ -e 's%ac_dir_suffix=/.*$$%ac_dir_suffix=%' \ -e 's%config\.h:config\.hin%config.h:../../cnf/config.hin%' \ < configure > configure.out chmod 755 configure.out rm configure ../configure: ../configure.in ( cd .. ; autoconf ) Makegap.in: Makegap.top Makefile Makegap.bottom @echo "creating 'Makegap.in'" @echo "# DO NOT EDIT THIS FILE BY HAND IT IS MACHINE GENERATED" > Makegap.in @cat Makegap.top >> Makegap.in @echo >> Makegap.in @echo '# OBJECTS are generated from SOURCE' >> Makegap.in @/bin/echo -n "OBJECTS=" >> Makegap.in @eval 'for i in $(SOURCE); do /bin/echo -n "$$i.o "; done' >> Makegap.in @echo '$$(GAPMPI_OBJ)' >> Makegap.in @echo >> Makegap.in @echo >> Makegap.in @echo '# compile and link GAP' >> Makegap.in @echo 'gap: $$(OBJECTS) $$(ITANIUMOBJ) $$(EXTOBJS) $$(GMP_LIBS)' >> Makegap.in @echo ' $$(CC) $$(LDFLAGS) -o gap $$(OBJECTS) $$(ITANIUMOBJ) -lm $$(MPILIBS) $$(EXTOBJS) $$(GMP_LIBS) $$(CONFLIBS)' >> Makegap.in @echo >> Makegap.in @echo '# compile and link gap.dll on cygwin' >> Makegap.in @echo 'gapdll: $$(OBJECTS) $$(ITANIUMOBJ) $$(EXTOBJS) $$(GMP_LIBS)' >> Makegap.in @echo ' $$(CC) $$(CPPFLAGS) $$(GMP_CFLAGS) $$(CFLAGS) -DCOMPILECYGWINDLL -o gap.o -c ../../src/gap.c' >> Makegap.in @echo ' $$(CC) $$(LDFLAGS) -o gap.dll -shared $$(OBJECTS) $$(ITANIUMOBJ) -lm $$(MPILIBS) $$(EXTOBJS) $$(GMP_LIBS) $$(CONFLIBS)' >> Makegap.in @echo ' $$(CC) $$(LDFLAGS) -o gapw95 ../../src/gapw95.c $$(CPPFLAGS) $$(GMP_CFLAGS) $$(CFLAGS) -DCOMPILECYGWINDLL gap.dll' >> Makegap.in @echo >> Makegap.in @echo '# dependencies are automatically generated' >> Makegap.in @(for i in `eval 'echo $(SOURCE)'`; do \ $(CC) -MM -MG -I .. -DUSE_PRECOMPILED ../src/$$i.c; \ echo ' $$(CC) $$(CPPFLAGS) $$(GMP_CFLAGS) $$(CFLAGS)' -o $$i.o -c ../src/$$i.c; \ echo ; \ done \ ) | sed -e 's:../src:@srcdir@:g' | sed -e 's:extern:../../extern:g' | sed -e 's#\.o: #.o: ../../Makefile #g' >> Makegap.in @cat Makegap.bottom >> Makegap.in gap-4r6p5/cnf/config.sub0000755000175000017500000010437612172557252013705 0ustar billbill#! /bin/sh # Configuration validation subroutine script. # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, # 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 # Free Software Foundation, Inc. timestamp='2010-09-11' # This file is (in principle) common to ALL GNU software. # The presence of a machine in this file suggests that SOME GNU software # can handle that machine. It does not imply ALL GNU software can. # # This file is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA # 02110-1301, USA. # # As a special exception to the GNU General Public License, if you # distribute this file as part of a program that contains a # configuration script generated by Autoconf, you may include it under # the same distribution terms that you use for the rest of that program. # Please send patches to . Submit a context # diff and a properly formatted GNU ChangeLog entry. # # Configuration subroutine to validate and canonicalize a configuration type. # Supply the specified configuration type as an argument. # If it is invalid, we print an error message on stderr and exit with code 1. # Otherwise, we print the canonical config type on stdout and succeed. # You can get the latest version of this script from: # http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD # This file is supposed to be the same for all GNU packages # and recognize all the CPU types, system types and aliases # that are meaningful with *any* GNU software. # Each package is responsible for reporting which valid configurations # it does not support. The user should be able to distinguish # a failure to support a valid configuration from a meaningless # configuration. # The goal of this file is to map all the various variations of a given # machine specification into a single specification in the form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM # or in some cases, the newer four-part form: # CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM # It is wrong to echo any other type of specification. me=`echo "$0" | sed -e 's,.*/,,'` usage="\ Usage: $0 [OPTION] CPU-MFR-OPSYS $0 [OPTION] ALIAS Canonicalize a configuration name. Operation modes: -h, --help print this help, then exit -t, --time-stamp print date of last modification, then exit -v, --version print version number, then exit Report bugs and patches to ." version="\ GNU config.sub ($timestamp) Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." help=" Try \`$me --help' for more information." # Parse command line while test $# -gt 0 ; do case $1 in --time-stamp | --time* | -t ) echo "$timestamp" ; exit ;; --version | -v ) echo "$version" ; exit ;; --help | --h* | -h ) echo "$usage"; exit ;; -- ) # Stop option processing shift; break ;; - ) # Use stdin as input. break ;; -* ) echo "$me: invalid option $1$help" exit 1 ;; *local*) # First pass through any local machine types. echo $1 exit ;; * ) break ;; esac done case $# in 0) echo "$me: missing argument$help" >&2 exit 1;; 1) ;; *) echo "$me: too many arguments$help" >&2 exit 1;; esac # Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any). # Here we must recognize all the valid KERNEL-OS combinations. maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'` case $maybe_os in nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \ linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \ knetbsd*-gnu* | netbsd*-gnu* | \ kopensolaris*-gnu* | \ storm-chaos* | os2-emx* | rtmk-nova*) os=-$maybe_os basic_machine=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'` ;; *) basic_machine=`echo $1 | sed 's/-[^-]*$//'` if [ $basic_machine != $1 ] then os=`echo $1 | sed 's/.*-/-/'` else os=; fi ;; esac ### Let's recognize common machines as not being operating systems so ### that things like config.sub decstation-3100 work. We also ### recognize some manufacturers as not being operating systems, so we ### can provide default operating systems below. case $os in -sun*os*) # Prevent following clause from handling this invalid input. ;; -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \ -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \ -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \ -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\ -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \ -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \ -apple | -axis | -knuth | -cray | -microblaze) os= basic_machine=$1 ;; -bluegene*) os=-cnk ;; -sim | -cisco | -oki | -wec | -winbond) os= basic_machine=$1 ;; -scout) ;; -wrs) os=-vxworks basic_machine=$1 ;; -chorusos*) os=-chorusos basic_machine=$1 ;; -chorusrdb) os=-chorusrdb basic_machine=$1 ;; -hiux*) os=-hiuxwe2 ;; -sco6) os=-sco5v6 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco5) os=-sco3.2v5 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco4) os=-sco3.2v4 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco3.2.[4-9]*) os=`echo $os | sed -e 's/sco3.2./sco3.2v/'` basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco3.2v[4-9]*) # Don't forget version if it is 3.2v4 or newer. basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco5v6*) # Don't forget version if it is 3.2v4 or newer. basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -sco*) os=-sco3.2v2 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -udk*) basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -isc) os=-isc2.2 basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -clix*) basic_machine=clipper-intergraph ;; -isc*) basic_machine=`echo $1 | sed -e 's/86-.*/86-pc/'` ;; -lynx*) os=-lynxos ;; -ptx*) basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'` ;; -windowsnt*) os=`echo $os | sed -e 's/windowsnt/winnt/'` ;; -psos*) os=-psos ;; -mint | -mint[0-9]*) basic_machine=m68k-atari os=-mint ;; esac # Decode aliases for certain CPU-COMPANY combinations. case $basic_machine in # Recognize the basic CPU types without company name. # Some are omitted here because they have special meanings below. 1750a | 580 \ | a29k \ | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \ | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \ | am33_2.0 \ | arc | arm | arm[bl]e | arme[lb] | armv[2345] | armv[345][lb] | avr | avr32 \ | bfin \ | c4x | clipper \ | d10v | d30v | dlx | dsp16xx \ | fido | fr30 | frv \ | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \ | i370 | i860 | i960 | ia64 \ | ip2k | iq2000 \ | lm32 \ | m32c | m32r | m32rle | m68000 | m68k | m88k \ | maxq | mb | microblaze | mcore | mep | metag \ | mips | mipsbe | mipseb | mipsel | mipsle \ | mips16 \ | mips64 | mips64el \ | mips64octeon | mips64octeonel \ | mips64orion | mips64orionel \ | mips64r5900 | mips64r5900el \ | mips64vr | mips64vrel \ | mips64vr4100 | mips64vr4100el \ | mips64vr4300 | mips64vr4300el \ | mips64vr5000 | mips64vr5000el \ | mips64vr5900 | mips64vr5900el \ | mipsisa32 | mipsisa32el \ | mipsisa32r2 | mipsisa32r2el \ | mipsisa64 | mipsisa64el \ | mipsisa64r2 | mipsisa64r2el \ | mipsisa64sb1 | mipsisa64sb1el \ | mipsisa64sr71k | mipsisa64sr71kel \ | mipstx39 | mipstx39el \ | mn10200 | mn10300 \ | moxie \ | mt \ | msp430 \ | nds32 | nds32le | nds32be \ | nios | nios2 \ | ns16k | ns32k \ | or32 \ | pdp10 | pdp11 | pj | pjl \ | powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \ | pyramid \ | rx \ | score \ | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[34]eb | sheb | shbe | shle | sh[1234]le | sh3ele \ | sh64 | sh64le \ | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \ | sparcv8 | sparcv9 | sparcv9b | sparcv9v \ | spu | strongarm \ | tahoe | thumb | tic4x | tic54x | tic55x | tic6x | tic80 | tron \ | ubicom32 \ | v850 | v850e \ | we32k \ | x86 | xc16x | xscale | xscalee[bl] | xstormy16 | xtensa \ | z8k | z80) basic_machine=$basic_machine-unknown ;; c54x) basic_machine=tic54x-unknown ;; c55x) basic_machine=tic55x-unknown ;; c6x) basic_machine=tic6x-unknown ;; m6811 | m68hc11 | m6812 | m68hc12 | picochip) # Motorola 68HC11/12. basic_machine=$basic_machine-unknown os=-none ;; m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65 | z8k) ;; ms1) basic_machine=mt-unknown ;; # We use `pc' rather than `unknown' # because (1) that's what they normally are, and # (2) the word "unknown" tends to confuse beginning users. i*86 | x86_64) basic_machine=$basic_machine-pc ;; # Object if more than one company name word. *-*-*) echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 exit 1 ;; # Recognize the basic CPU types with company name. 580-* \ | a29k-* \ | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \ | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \ | alphapca5[67]-* | alpha64pca5[67]-* | arc-* \ | arm-* | armbe-* | armle-* | armeb-* | armv*-* \ | avr-* | avr32-* \ | bfin-* | bs2000-* \ | c[123]* | c30-* | [cjt]90-* | c4x-* \ | clipper-* | craynv-* | cydra-* \ | d10v-* | d30v-* | dlx-* \ | elxsi-* \ | f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \ | h8300-* | h8500-* \ | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \ | i*86-* | i860-* | i960-* | ia64-* \ | ip2k-* | iq2000-* \ | lm32-* \ | m32c-* | m32r-* | m32rle-* \ | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \ | m88110-* | m88k-* | maxq-* | mcore-* | metag-* | microblaze-* \ | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \ | mips16-* \ | mips64-* | mips64el-* \ | mips64octeon-* | mips64octeonel-* \ | mips64orion-* | mips64orionel-* \ | mips64r5900-* | mips64r5900el-* \ | mips64vr-* | mips64vrel-* \ | mips64vr4100-* | mips64vr4100el-* \ | mips64vr4300-* | mips64vr4300el-* \ | mips64vr5000-* | mips64vr5000el-* \ | mips64vr5900-* | mips64vr5900el-* \ | mipsisa32-* | mipsisa32el-* \ | mipsisa32r2-* | mipsisa32r2el-* \ | mipsisa64-* | mipsisa64el-* \ | mipsisa64r2-* | mipsisa64r2el-* \ | mipsisa64sb1-* | mipsisa64sb1el-* \ | mipsisa64sr71k-* | mipsisa64sr71kel-* \ | mipstx39-* | mipstx39el-* \ | mmix-* \ | mt-* \ | msp430-* \ | nds32-* | nds32le-* | nds32be-* \ | nios-* | nios2-* \ | none-* | np1-* | ns16k-* | ns32k-* \ | orion-* \ | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \ | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \ | pyramid-* \ | romp-* | rs6000-* | rx-* \ | sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \ | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \ | sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \ | sparclite-* \ | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | strongarm-* | sv1-* | sx?-* \ | tahoe-* | thumb-* \ | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \ | tile-* | tilegx-* \ | tron-* \ | ubicom32-* \ | v850-* | v850e-* | vax-* \ | we32k-* \ | x86-* | x86_64-* | xc16x-* | xps100-* | xscale-* | xscalee[bl]-* \ | xstormy16-* | xtensa*-* \ | ymp-* \ | z8k-* | z80-*) ;; # Recognize the basic CPU types without company name, with glob match. xtensa*) basic_machine=$basic_machine-unknown ;; # Recognize the various machine names and aliases which stand # for a CPU type and a company and sometimes even an OS. 386bsd) basic_machine=i386-unknown os=-bsd ;; 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc) basic_machine=m68000-att ;; 3b*) basic_machine=we32k-att ;; a29khif) basic_machine=a29k-amd os=-udi ;; abacus) basic_machine=abacus-unknown ;; adobe68k) basic_machine=m68010-adobe os=-scout ;; alliant | fx80) basic_machine=fx80-alliant ;; altos | altos3068) basic_machine=m68k-altos ;; am29k) basic_machine=a29k-none os=-bsd ;; amd64) basic_machine=x86_64-pc ;; amd64-*) basic_machine=x86_64-`echo $basic_machine | sed 's/^[^-]*-//'` ;; amdahl) basic_machine=580-amdahl os=-sysv ;; amiga | amiga-*) basic_machine=m68k-unknown ;; amigaos | amigados) basic_machine=m68k-unknown os=-amigaos ;; amigaunix | amix) basic_machine=m68k-unknown os=-sysv4 ;; apollo68) basic_machine=m68k-apollo os=-sysv ;; apollo68bsd) basic_machine=m68k-apollo os=-bsd ;; aros) basic_machine=i386-pc os=-aros ;; aux) basic_machine=m68k-apple os=-aux ;; balance) basic_machine=ns32k-sequent os=-dynix ;; blackfin) basic_machine=bfin-unknown os=-linux ;; blackfin-*) basic_machine=bfin-`echo $basic_machine | sed 's/^[^-]*-//'` os=-linux ;; bluegene*) basic_machine=powerpc-ibm os=-cnk ;; c54x-*) basic_machine=tic54x-`echo $basic_machine | sed 's/^[^-]*-//'` ;; c55x-*) basic_machine=tic55x-`echo $basic_machine | sed 's/^[^-]*-//'` ;; c6x-*) basic_machine=tic6x-`echo $basic_machine | sed 's/^[^-]*-//'` ;; c90) basic_machine=c90-cray os=-unicos ;; cegcc) basic_machine=arm-unknown os=-cegcc ;; convex-c1) basic_machine=c1-convex os=-bsd ;; convex-c2) basic_machine=c2-convex os=-bsd ;; convex-c32) basic_machine=c32-convex os=-bsd ;; convex-c34) basic_machine=c34-convex os=-bsd ;; convex-c38) basic_machine=c38-convex os=-bsd ;; cray | j90) basic_machine=j90-cray os=-unicos ;; craynv) basic_machine=craynv-cray os=-unicosmp ;; cr16) basic_machine=cr16-unknown os=-elf ;; crds | unos) basic_machine=m68k-crds ;; crisv32 | crisv32-* | etraxfs*) basic_machine=crisv32-axis ;; cris | cris-* | etrax*) basic_machine=cris-axis ;; crx) basic_machine=crx-unknown os=-elf ;; da30 | da30-*) basic_machine=m68k-da30 ;; decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn) basic_machine=mips-dec ;; decsystem10* | dec10*) basic_machine=pdp10-dec os=-tops10 ;; decsystem20* | dec20*) basic_machine=pdp10-dec os=-tops20 ;; delta | 3300 | motorola-3300 | motorola-delta \ | 3300-motorola | delta-motorola) basic_machine=m68k-motorola ;; delta88) basic_machine=m88k-motorola os=-sysv3 ;; dicos) basic_machine=i686-pc os=-dicos ;; djgpp) basic_machine=i586-pc os=-msdosdjgpp ;; dpx20 | dpx20-*) basic_machine=rs6000-bull os=-bosx ;; dpx2* | dpx2*-bull) basic_machine=m68k-bull os=-sysv3 ;; ebmon29k) basic_machine=a29k-amd os=-ebmon ;; elxsi) basic_machine=elxsi-elxsi os=-bsd ;; encore | umax | mmax) basic_machine=ns32k-encore ;; es1800 | OSE68k | ose68k | ose | OSE) basic_machine=m68k-ericsson os=-ose ;; fx2800) basic_machine=i860-alliant ;; genix) basic_machine=ns32k-ns ;; gmicro) basic_machine=tron-gmicro os=-sysv ;; go32) basic_machine=i386-pc os=-go32 ;; h3050r* | hiux*) basic_machine=hppa1.1-hitachi os=-hiuxwe2 ;; h8300hms) basic_machine=h8300-hitachi os=-hms ;; h8300xray) basic_machine=h8300-hitachi os=-xray ;; h8500hms) basic_machine=h8500-hitachi os=-hms ;; harris) basic_machine=m88k-harris os=-sysv3 ;; hp300-*) basic_machine=m68k-hp ;; hp300bsd) basic_machine=m68k-hp os=-bsd ;; hp300hpux) basic_machine=m68k-hp os=-hpux ;; hp3k9[0-9][0-9] | hp9[0-9][0-9]) basic_machine=hppa1.0-hp ;; hp9k2[0-9][0-9] | hp9k31[0-9]) basic_machine=m68000-hp ;; hp9k3[2-9][0-9]) basic_machine=m68k-hp ;; hp9k6[0-9][0-9] | hp6[0-9][0-9]) basic_machine=hppa1.0-hp ;; hp9k7[0-79][0-9] | hp7[0-79][0-9]) basic_machine=hppa1.1-hp ;; hp9k78[0-9] | hp78[0-9]) # FIXME: really hppa2.0-hp basic_machine=hppa1.1-hp ;; hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893) # FIXME: really hppa2.0-hp basic_machine=hppa1.1-hp ;; hp9k8[0-9][13679] | hp8[0-9][13679]) basic_machine=hppa1.1-hp ;; hp9k8[0-9][0-9] | hp8[0-9][0-9]) basic_machine=hppa1.0-hp ;; hppa-next) os=-nextstep3 ;; hppaosf) basic_machine=hppa1.1-hp os=-osf ;; hppro) basic_machine=hppa1.1-hp os=-proelf ;; i370-ibm* | ibm*) basic_machine=i370-ibm ;; # I'm not sure what "Sysv32" means. Should this be sysv3.2? i*86v32) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv32 ;; i*86v4*) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv4 ;; i*86v) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-sysv ;; i*86sol2) basic_machine=`echo $1 | sed -e 's/86.*/86-pc/'` os=-solaris2 ;; i386mach) basic_machine=i386-mach os=-mach ;; i386-vsta | vsta) basic_machine=i386-unknown os=-vsta ;; iris | iris4d) basic_machine=mips-sgi case $os in -irix*) ;; *) os=-irix4 ;; esac ;; isi68 | isi) basic_machine=m68k-isi os=-sysv ;; m68knommu) basic_machine=m68k-unknown os=-linux ;; m68knommu-*) basic_machine=m68k-`echo $basic_machine | sed 's/^[^-]*-//'` os=-linux ;; m88k-omron*) basic_machine=m88k-omron ;; magnum | m3230) basic_machine=mips-mips os=-sysv ;; merlin) basic_machine=ns32k-utek os=-sysv ;; microblaze) basic_machine=microblaze-xilinx ;; mingw32) basic_machine=i386-pc os=-mingw32 ;; mingw32ce) basic_machine=arm-unknown os=-mingw32ce ;; miniframe) basic_machine=m68000-convergent ;; *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*) basic_machine=m68k-atari os=-mint ;; mips3*-*) basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'` ;; mips3*) basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown ;; monitor) basic_machine=m68k-rom68k os=-coff ;; morphos) basic_machine=powerpc-unknown os=-morphos ;; msdos) basic_machine=i386-pc os=-msdos ;; ms1-*) basic_machine=`echo $basic_machine | sed -e 's/ms1-/mt-/'` ;; mvs) basic_machine=i370-ibm os=-mvs ;; ncr3000) basic_machine=i486-ncr os=-sysv4 ;; netbsd386) basic_machine=i386-unknown os=-netbsd ;; netwinder) basic_machine=armv4l-rebel os=-linux ;; news | news700 | news800 | news900) basic_machine=m68k-sony os=-newsos ;; news1000) basic_machine=m68030-sony os=-newsos ;; news-3600 | risc-news) basic_machine=mips-sony os=-newsos ;; necv70) basic_machine=v70-nec os=-sysv ;; next | m*-next ) basic_machine=m68k-next case $os in -nextstep* ) ;; -ns2*) os=-nextstep2 ;; *) os=-nextstep3 ;; esac ;; nh3000) basic_machine=m68k-harris os=-cxux ;; nh[45]000) basic_machine=m88k-harris os=-cxux ;; nindy960) basic_machine=i960-intel os=-nindy ;; mon960) basic_machine=i960-intel os=-mon960 ;; nonstopux) basic_machine=mips-compaq os=-nonstopux ;; np1) basic_machine=np1-gould ;; neo-tandem) basic_machine=neo-tandem ;; nse-tandem) basic_machine=nse-tandem ;; nsr-tandem) basic_machine=nsr-tandem ;; op50n-* | op60c-*) basic_machine=hppa1.1-oki os=-proelf ;; openrisc | openrisc-*) basic_machine=or32-unknown ;; os400) basic_machine=powerpc-ibm os=-os400 ;; OSE68000 | ose68000) basic_machine=m68000-ericsson os=-ose ;; os68k) basic_machine=m68k-none os=-os68k ;; pa-hitachi) basic_machine=hppa1.1-hitachi os=-hiuxwe2 ;; paragon) basic_machine=i860-intel os=-osf ;; parisc) basic_machine=hppa-unknown os=-linux ;; parisc-*) basic_machine=hppa-`echo $basic_machine | sed 's/^[^-]*-//'` os=-linux ;; pbd) basic_machine=sparc-tti ;; pbb) basic_machine=m68k-tti ;; pc532 | pc532-*) basic_machine=ns32k-pc532 ;; pc98) basic_machine=i386-pc ;; pc98-*) basic_machine=i386-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentium | p5 | k5 | k6 | nexgen | viac3) basic_machine=i586-pc ;; pentiumpro | p6 | 6x86 | athlon | athlon_*) basic_machine=i686-pc ;; pentiumii | pentium2 | pentiumiii | pentium3) basic_machine=i686-pc ;; pentium4) basic_machine=i786-pc ;; pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*) basic_machine=i586-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentiumpro-* | p6-* | 6x86-* | athlon-*) basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*) basic_machine=i686-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pentium4-*) basic_machine=i786-`echo $basic_machine | sed 's/^[^-]*-//'` ;; pn) basic_machine=pn-gould ;; power) basic_machine=power-ibm ;; ppc) basic_machine=powerpc-unknown ;; ppc-*) basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppcle | powerpclittle | ppc-le | powerpc-little) basic_machine=powerpcle-unknown ;; ppcle-* | powerpclittle-*) basic_machine=powerpcle-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppc64) basic_machine=powerpc64-unknown ;; ppc64-*) basic_machine=powerpc64-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppc64le | powerpc64little | ppc64-le | powerpc64-little) basic_machine=powerpc64le-unknown ;; ppc64le-* | powerpc64little-*) basic_machine=powerpc64le-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ps2) basic_machine=i386-ibm ;; pw32) basic_machine=i586-unknown os=-pw32 ;; rdos) basic_machine=i386-pc os=-rdos ;; rom68k) basic_machine=m68k-rom68k os=-coff ;; rm[46]00) basic_machine=mips-siemens ;; rtpc | rtpc-*) basic_machine=romp-ibm ;; s390 | s390-*) basic_machine=s390-ibm ;; s390x | s390x-*) basic_machine=s390x-ibm ;; sa29200) basic_machine=a29k-amd os=-udi ;; sb1) basic_machine=mipsisa64sb1-unknown ;; sb1el) basic_machine=mipsisa64sb1el-unknown ;; sde) basic_machine=mipsisa32-sde os=-elf ;; sei) basic_machine=mips-sei os=-seiux ;; sequent) basic_machine=i386-sequent ;; sh) basic_machine=sh-hitachi os=-hms ;; sh5el) basic_machine=sh5le-unknown ;; sh64) basic_machine=sh64-unknown ;; sparclite-wrs | simso-wrs) basic_machine=sparclite-wrs os=-vxworks ;; sps7) basic_machine=m68k-bull os=-sysv2 ;; spur) basic_machine=spur-unknown ;; st2000) basic_machine=m68k-tandem ;; stratus) basic_machine=i860-stratus os=-sysv4 ;; sun2) basic_machine=m68000-sun ;; sun2os3) basic_machine=m68000-sun os=-sunos3 ;; sun2os4) basic_machine=m68000-sun os=-sunos4 ;; sun3os3) basic_machine=m68k-sun os=-sunos3 ;; sun3os4) basic_machine=m68k-sun os=-sunos4 ;; sun4os3) basic_machine=sparc-sun os=-sunos3 ;; sun4os4) basic_machine=sparc-sun os=-sunos4 ;; sun4sol2) basic_machine=sparc-sun os=-solaris2 ;; sun3 | sun3-*) basic_machine=m68k-sun ;; sun4) basic_machine=sparc-sun ;; sun386 | sun386i | roadrunner) basic_machine=i386-sun ;; sv1) basic_machine=sv1-cray os=-unicos ;; symmetry) basic_machine=i386-sequent os=-dynix ;; t3e) basic_machine=alphaev5-cray os=-unicos ;; t90) basic_machine=t90-cray os=-unicos ;; # This must be matched before tile*. tilegx*) basic_machine=tilegx-unknown os=-linux-gnu ;; tile*) basic_machine=tile-unknown os=-linux-gnu ;; tx39) basic_machine=mipstx39-unknown ;; tx39el) basic_machine=mipstx39el-unknown ;; toad1) basic_machine=pdp10-xkl os=-tops20 ;; tower | tower-32) basic_machine=m68k-ncr ;; tpf) basic_machine=s390x-ibm os=-tpf ;; udi29k) basic_machine=a29k-amd os=-udi ;; ultra3) basic_machine=a29k-nyu os=-sym1 ;; v810 | necv810) basic_machine=v810-nec os=-none ;; vaxv) basic_machine=vax-dec os=-sysv ;; vms) basic_machine=vax-dec os=-vms ;; vpp*|vx|vx-*) basic_machine=f301-fujitsu ;; vxworks960) basic_machine=i960-wrs os=-vxworks ;; vxworks68) basic_machine=m68k-wrs os=-vxworks ;; vxworks29k) basic_machine=a29k-wrs os=-vxworks ;; w65*) basic_machine=w65-wdc os=-none ;; w89k-*) basic_machine=hppa1.1-winbond os=-proelf ;; xbox) basic_machine=i686-pc os=-mingw32 ;; xps | xps100) basic_machine=xps100-honeywell ;; ymp) basic_machine=ymp-cray os=-unicos ;; z8k-*-coff) basic_machine=z8k-unknown os=-sim ;; z80-*-coff) basic_machine=z80-unknown os=-sim ;; none) basic_machine=none-none os=-none ;; # Here we handle the default manufacturer of certain CPU types. It is in # some cases the only manufacturer, in others, it is the most popular. w89k) basic_machine=hppa1.1-winbond ;; op50n) basic_machine=hppa1.1-oki ;; op60c) basic_machine=hppa1.1-oki ;; romp) basic_machine=romp-ibm ;; mmix) basic_machine=mmix-knuth ;; rs6000) basic_machine=rs6000-ibm ;; vax) basic_machine=vax-dec ;; pdp10) # there are many clones, so DEC is not a safe bet basic_machine=pdp10-unknown ;; pdp11) basic_machine=pdp11-dec ;; we32k) basic_machine=we32k-att ;; sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele) basic_machine=sh-unknown ;; sparc | sparcv8 | sparcv9 | sparcv9b | sparcv9v) basic_machine=sparc-sun ;; cydra) basic_machine=cydra-cydrome ;; orion) basic_machine=orion-highlevel ;; orion105) basic_machine=clipper-highlevel ;; mac | mpw | mac-mpw) basic_machine=m68k-apple ;; pmac | pmac-mpw) basic_machine=powerpc-apple ;; *-unknown) # Make sure to match an already-canonicalized machine name. ;; *) echo Invalid configuration \`$1\': machine \`$basic_machine\' not recognized 1>&2 exit 1 ;; esac # Here we canonicalize certain aliases for manufacturers. case $basic_machine in *-digital*) basic_machine=`echo $basic_machine | sed 's/digital.*/dec/'` ;; *-commodore*) basic_machine=`echo $basic_machine | sed 's/commodore.*/cbm/'` ;; *) ;; esac # Decode manufacturer-specific aliases for certain operating systems. if [ x"$os" != x"" ] then case $os in # First match some system type aliases # that might get confused with valid system types. # -solaris* is a basic system type, with this one exception. -auroraux) os=-auroraux ;; -solaris1 | -solaris1.*) os=`echo $os | sed -e 's|solaris1|sunos4|'` ;; -solaris) os=-solaris2 ;; -svr4*) os=-sysv4 ;; -unixware*) os=-sysv4.2uw ;; -gnu/linux*) os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'` ;; # First accept the basic system types. # The portable systems comes first. # Each alternative MUST END IN A *, to match a version number. # -sysv* is not here because it comes later, after sysvr4. -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \ | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\ | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \ | -sym* | -kopensolaris* \ | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \ | -aos* | -aros* \ | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \ | -hiux* | -386bsd* | -knetbsd* | -mirbsd* | -netbsd* \ | -openbsd* | -solidbsd* \ | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \ | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \ | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \ | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \ | -chorusos* | -chorusrdb* | -cegcc* \ | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ | -mingw32* | -linux-gnu* | -linux-android* \ | -linux-newlib* | -linux-uclibc* \ | -uxpv* | -beos* | -mpeix* | -udk* \ | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \ | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \ | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \ | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \ | -morphos* | -superux* | -rtmk* | -rtmk-nova* | -windiss* \ | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \ | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es*) # Remember, each alternative MUST END IN *, to match a version number. ;; -qnx*) case $basic_machine in x86-* | i*86-*) ;; *) os=-nto$os ;; esac ;; -nto-qnx*) ;; -nto*) os=`echo $os | sed -e 's|nto|nto-qnx|'` ;; -sim | -es1800* | -hms* | -xray | -os68k* | -none* | -v88r* \ | -windows* | -osx | -abug | -netware* | -os9* | -beos* | -haiku* \ | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*) ;; -mac*) os=`echo $os | sed -e 's|mac|macos|'` ;; -linux-dietlibc) os=-linux-dietlibc ;; -linux*) os=`echo $os | sed -e 's|linux|linux-gnu|'` ;; -sunos5*) os=`echo $os | sed -e 's|sunos5|solaris2|'` ;; -sunos6*) os=`echo $os | sed -e 's|sunos6|solaris3|'` ;; -opened*) os=-openedition ;; -os400*) os=-os400 ;; -wince*) os=-wince ;; -osfrose*) os=-osfrose ;; -osf*) os=-osf ;; -utek*) os=-bsd ;; -dynix*) os=-bsd ;; -acis*) os=-aos ;; -atheos*) os=-atheos ;; -syllable*) os=-syllable ;; -386bsd) os=-bsd ;; -ctix* | -uts*) os=-sysv ;; -nova*) os=-rtmk-nova ;; -ns2 ) os=-nextstep2 ;; -nsk*) os=-nsk ;; # Preserve the version number of sinix5. -sinix5.*) os=`echo $os | sed -e 's|sinix|sysv|'` ;; -sinix*) os=-sysv4 ;; -tpf*) os=-tpf ;; -triton*) os=-sysv3 ;; -oss*) os=-sysv3 ;; -svr4) os=-sysv4 ;; -svr3) os=-sysv3 ;; -sysvr4) os=-sysv4 ;; # This must come after -sysvr4. -sysv*) ;; -ose*) os=-ose ;; -es1800*) os=-ose ;; -xenix) os=-xenix ;; -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) os=-mint ;; -aros*) os=-aros ;; -kaos*) os=-kaos ;; -zvmoe) os=-zvmoe ;; -dicos*) os=-dicos ;; -nacl*) ;; -none) ;; *) # Get rid of the `-' at the beginning of $os. os=`echo $os | sed 's/[^-]*-//'` echo Invalid configuration \`$1\': system \`$os\' not recognized 1>&2 exit 1 ;; esac else # Here we handle the default operating systems that come with various machines. # The value should be what the vendor currently ships out the door with their # machine or put another way, the most popular os provided with the machine. # Note that if you're going to try to match "-MANUFACTURER" here (say, # "-sun"), then you have to tell the case statement up towards the top # that MANUFACTURER isn't an operating system. Otherwise, code above # will signal an error saying that MANUFACTURER isn't an operating # system, and we'll never get to this point. case $basic_machine in score-*) os=-elf ;; spu-*) os=-elf ;; *-acorn) os=-riscix1.2 ;; arm*-rebel) os=-linux ;; arm*-semi) os=-aout ;; c4x-* | tic4x-*) os=-coff ;; tic54x-*) os=-coff ;; tic55x-*) os=-coff ;; tic6x-*) os=-coff ;; # This must come before the *-dec entry. pdp10-*) os=-tops20 ;; pdp11-*) os=-none ;; *-dec | vax-*) os=-ultrix4.2 ;; m68*-apollo) os=-domain ;; i386-sun) os=-sunos4.0.2 ;; m68000-sun) os=-sunos3 # This also exists in the configure program, but was not the # default. # os=-sunos4 ;; m68*-cisco) os=-aout ;; mep-*) os=-elf ;; mips*-cisco) os=-elf ;; mips*-*) os=-elf ;; or32-*) os=-coff ;; *-tti) # must be before sparc entry or we get the wrong os. os=-sysv3 ;; sparc-* | *-sun) os=-sunos4.1.1 ;; *-be) os=-beos ;; *-haiku) os=-haiku ;; *-ibm) os=-aix ;; *-knuth) os=-mmixware ;; *-wec) os=-proelf ;; *-winbond) os=-proelf ;; *-oki) os=-proelf ;; *-hp) os=-hpux ;; *-hitachi) os=-hiux ;; i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent) os=-sysv ;; *-cbm) os=-amigaos ;; *-dg) os=-dgux ;; *-dolphin) os=-sysv3 ;; m68k-ccur) os=-rtu ;; m88k-omron*) os=-luna ;; *-next ) os=-nextstep ;; *-sequent) os=-ptx ;; *-crds) os=-unos ;; *-ns) os=-genix ;; i370-*) os=-mvs ;; *-next) os=-nextstep3 ;; *-gould) os=-sysv ;; *-highlevel) os=-bsd ;; *-encore) os=-bsd ;; *-sgi) os=-irix ;; *-siemens) os=-sysv4 ;; *-masscomp) os=-rtu ;; f30[01]-fujitsu | f700-fujitsu) os=-uxpv ;; *-rom68k) os=-coff ;; *-*bug) os=-coff ;; *-apple) os=-macos ;; *-atari*) os=-mint ;; *) os=-none ;; esac fi # Here we handle the case where we know the os, and the CPU type, but not the # manufacturer. We pick the logical manufacturer. vendor=unknown case $basic_machine in *-unknown) case $os in -riscix*) vendor=acorn ;; -sunos*) vendor=sun ;; -cnk*|-aix*) vendor=ibm ;; -beos*) vendor=be ;; -hpux*) vendor=hp ;; -mpeix*) vendor=hp ;; -hiux*) vendor=hitachi ;; -unos*) vendor=crds ;; -dgux*) vendor=dg ;; -luna*) vendor=omron ;; -genix*) vendor=ns ;; -mvs* | -opened*) vendor=ibm ;; -os400*) vendor=ibm ;; -ptx*) vendor=sequent ;; -tpf*) vendor=ibm ;; -vxsim* | -vxworks* | -windiss*) vendor=wrs ;; -aux*) vendor=apple ;; -hms*) vendor=hitachi ;; -mpw* | -macos*) vendor=apple ;; -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) vendor=atari ;; -vos*) vendor=stratus ;; esac basic_machine=`echo $basic_machine | sed "s/unknown/$vendor/"` ;; esac echo $basic_machine$os exit # Local variables: # eval: (add-hook 'write-file-hooks 'time-stamp) # time-stamp-start: "timestamp='" # time-stamp-format: "%:y-%02m-%02d" # time-stamp-end: "'" # End: gap-4r6p5/cnf/Makegap.top0000644000175000017500000000130112172557252013773 0ustar billbill############################################################################# ## #W Makefile GAP source Frank Celler ## ## #Y Copyright (C) 1997, Lehrstuhl D fuer Mathematik, RWTH Aachen, Germany ## ## This file compiles and links GAP. It is created from the file ## "Makegap.in" in the directory `cnf/'. ## CFLAGS=@CFLAGS@ $(COPTS) CPPFLAGS=-I. -I../.. -DCONFIG_H @CPPFLAGS@ LDFLAGS=@LDFLAGS@ $(LOPTS) CC=@CC@ ITANIUMOBJ=@ITANIUMOBJ@ # FIXME: What is LIBSOVERRIDE used for? We should either document this here # or elsewhere, or find ways to get rid of it. ifeq "$(LIBSOVERRIDE)" "" CONFLIBS=@LIBS@ else CONFLIBS=$(LIBSOVERRIDE) endif gap-4r6p5/cnf/configure.in0000644000175000017500000002323212172557302014216 0ustar billbilldnl ######################################################################### dnl ## dnl ## check for a unique program in the source directory dnl ## AC_INIT([GAP], [4.6.5], [support@gap-system.org], [gap], [http://www.gap-system.org/]) AC_CONFIG_SRCDIR([gap.c]) AC_CONFIG_AUX_DIR(../../cnf) #if test "x$CFLAGS" = "x" ; then # CFLAGS=${COPTS} #fi dnl ######################################################################### dnl ## dnl ## create a config file from "config.hin" dnl ## AC_CONFIG_HEADER(config.h:config.hin) dnl ######################################################################### dnl ## dnl ## check for compiler features dnl ## AC_PROG_CC AC_C_CONST AC_C_INLINE AC_C_BIGENDIAN AC_COMPUTE_INT(RIGHTSHIFTMINUSONE,[(-1L >> 1)+1]) if test "$RIGHTSHIFTMINUSONE" = "0" ; then HAVE_ARITHRIGHTSHIFT=1 else HAVE_ARITHRIGHTSHIFT=0 fi AC_DEFINE_UNQUOTED([HAVE_ARITHRIGHTSHIFT],[$HAVE_ARITHRIGHTSHIFT], [define as 1 if >> for long int behaves like an arithmetic right shift for negative numbers]) # # Assume that cross-compiling is for 32 bit systems # (alpha/NT will have to wait) # AC_CHECK_SIZEOF([void *]) GP_C_UNDERSCORE_SYMBOLS dnl ######################################################################### dnl ## dnl ## find a canonical name for the system dnl ## AC_CANONICAL_HOST AC_DEFINE_UNQUOTED( SYS_ARCH, "$GAPARCH", [define the name of the architucture] ) AC_SUBST(GAPARCH) dnl This has to be left until after we know the system type GP_C_LONG_ALIGN GP_CFLAGS GP_LDFLAGS GP_PROG_CC_DYNFLAGS dnl ######################################################################### dnl ## dnl ## check for the existence of various header files dnl ## AC_HEADER_STDC AC_CHECK_HEADERS( assert.h errno.h math.h stdio.h stdlib.h string.h ) AC_CHECK_HEADERS( termios.h termio.h sgtty.h signal.h unistd.h sys/stat.h ) AC_CHECK_HEADERS( fcntl.h sys/ioctl.h sys/time.h sys/types.h sys/sysmacros.h sys/resource.h ) dnl ######################################################################### dnl ## dnl ## check for stdint.h and the types int8_t, uint8_t etc. it defines dnl ## AC_TYPE_INT8_T AC_TYPE_INT16_T AC_TYPE_INT32_T AC_TYPE_INT64_T AC_TYPE_UINT8_T AC_TYPE_UINT16_T AC_TYPE_UINT32_T AC_TYPE_UINT64_T dnl ######################################################################### dnl ## dnl ## check how to get a pseudo-tty pair dnl ## # Check for POSIX 98 pty APIs AC_CHECK_FUNCS( ptsname grantpt unlockpt posix_openpt ) # Check for glibc specific pty APIs AC_CHECK_FUNCS( getpt ptsname_r ) # Check for some legacy APIs AC_CHECK_FUNCS( getpseudotty _getpty ) # openpty() is available on various BSD variants, but also in glibc. # On BSD systems, one usually needs to add -lutil to LIBS in order # to use it. AC_CHECK_HEADERS( util.h pty.h libutil.h ) AC_SEARCH_LIBS(openpty, util, AC_DEFINE(HAVE_OPENPTY,1,[define as 1 if you have `openpty'])) dnl ######################################################################### dnl ## dnl ## check whether we have setpgid to protect a background child from SIGINT dnl ## AC_CHECK_FUNCS( setpgid ) dnl ######################################################################### dnl ## dnl ## check for dynamic loading of modules dnl ## AC_CHECK_FUNCS( rld_load ) AC_SEARCH_LIBS(dlopen, dl, AC_DEFINE(HAVE_DLOPEN,1,[define as 1 if you have `dlopen' and `dlsym'])) if test "$ac_cv_search_dlopen" != "no"; then GP_PROG_CC_EXPORT_DYNAMIC if test "$gp_cv_prog_cc_export_dynamic" = yes; then LDFLAGS="$LDFLAGS -export-dynamic" fi fi case "$LIBS" in *-ldl* ) C_DYNLIBS="-ldl" ;; *) C_DYNLIBS="" ;; esac; AC_SUBST(C_DYNLIBS) dnl ######################################################################### dnl ## dnl ## check for timing functions dnl ## AC_CHECK_HEADERS( sys/times.h sys/param.h ) AC_CHECK_FUNCS( times getrusage ) dnl ######################################################################### dnl ## dnl ## check for functions moving memory around dnl ## AC_CHECK_FUNCS( memcpy memmove memset ) dnl ######################################################################### dnl ## dnl ## check for functions dealing with virtual memory dnl ## AC_CHECK_FUNCS( vm_allocate sbrk madvise sysconf ) dnl ######################################################################### dnl ## dnl ## check for functions dealing with strings and integers dnl ## AC_CHECK_FUNCS( atol strlcpy strlcmp ) dnl ######################################################################### dnl ## dnl ## check for fork, wait, execute functions dnl ## AC_HEADER_SYS_WAIT AC_TYPE_PID_T AC_FUNC_FORK AC_CHECK_FUNCS( popen waitpid wait4 ) AC_MSG_CHECKING([for old non-posix union wait]) dnl AC_EGREP_HEADER( union wait, sys/wait.h, dnl [AC_DEFINE( HAVE_UNION_WAIT, 1, [define as 1 if you have "union wait"]) dnl AC_MSG_RESULT(yes)], dnl [AC_MSG_RESULT(no)] ) GP_C_UNION_WAIT dnl ######################################################################### dnl ## dnl ## check for signal handling dnl ## AC_CHECK_FUNCS( signal ) dnl ######################################################################### dnl ## dnl ## check for input/output functions dnl ## AC_CHECK_FUNCS( ttyname strerror select ) GP_VAR_SYS_ERRLIST dnl ######################################################################### dnl ## dnl ## check for file access functions dnl ## AC_HEADER_STAT AC_CHECK_FUNCS( access stat fstat lstat unlink mkdir rmdir mkdtemp mkstemp link rename chmod dup dup2 realpath ) dnl ######################################################################### dnl ## dnl ## check for socket access functions dnl ## AC_CHECK_FUNCS( socket accept connect bind send ) dnl ######################################################################### dnl ## dnl ## check for directory access functions dnl ## AC_HEADER_DIRENT AC_CHECK_FUNCS( opendir closedir readdir ) dnl ######################################################################### dnl ## dnl ## check for math functions dnl ## AC_CHECK_FUNCS( log2 log10 log1p exp2 expm1 exp10 trunc ) dnl ######################################################################### dnl ## dnl ## check if GNU readline is available and requested dnl ## AC_ARG_WITH([readline], [AS_HELP_STRING([--with-readline=yes|no|], [Use readline library for command line editing. [[default=yes]] ])], [], [] ) # TODO: Currently, if the user requests building against readline # explicitly, and this fails for some reason, we simply silently # go on without it. Maybe we should produce an error instead? # TODO: Actually, we should be using CPPFLAGS instead of CFLAGS gap_save_CFLAGS="$CFLAGS" gap_save_LDFLAGS="$LDFLAGS" if test "x$with_readline" != xno; then # Readline support not disabled if test "x$with_readline" != x; then if test "x$with_readline" != xyes; then # Use custom prefix for readline, if the paths are present if test -d ${with_readline}/include && test -d ${with_readline}/lib; then CFLAGS="$CFLAGS -I${with_readline}/include" LDFLAGS="$LDFLAGS -L${with_readline}/lib" # TODO: We could produce an error here, after all, the user specified an # invalid path prefix. fi fi fi # TODO: Should also check for headers AC_CHECK_LIB([ncurses], [initscr]) AC_CHECK_LIB([readline], [rl_gnu_readline_p], [], [with_readline=no], [-lncurses]) fi if test "x$with_readline" = xno; then # Readline support disabled CFLAGS="$gap_save_CFLAGS" LDFLAGS="$gap_save_LDFLAGS" fi; dnl ######################################################################### dnl ## dnl ## enable GMP if parent configure script tell us that it is available dnl ## if test "x$USE_GMP" = "xyes" ; then AC_DEFINE(USE_GMP, 1, [use GMP for integers]) fi dnl ######################################################################### dnl ## dnl ## check for variants of setjmp, longjmp dnl ## AC_CHECK_FUNCS(_setjmp sigsetjmp) dnl ######################################################################### dnl ## dnl ## set features on systems we know for better performance dnl ## case "$host" in i386-*-* | i486-*-* | i586-*-* | i686-*-*) gp_cv_c_long_align=2 ;; esac AC_DEFINE_UNQUOTED(C_STACK_ALIGN, $gp_cv_c_long_align, [define as least offset we have to check the stack for pointer]) case "$host" in sparc-* ) AC_DEFINE(SPARC, 1, [define as 1 on SPARC architecture to flush register windows]) ;; ia64-* ) AC_DEFINE(ITANIUM, 1, [define as 1 on Itanium architecture to flush and mark register stack]) ITANIUMOBJ=itanium.o ;; esac AC_SUBST(ITANIUMOBJ) case "$host_os" in *cygwin*) AC_DEFINE(SYS_IS_CYGWIN32, 1, [define if this is the Cygwin32 port]) ;; *darwin*) AC_DEFINE(SYS_IS_DARWIN, 1, [define if this is the Darwin port]) ;; esac dnl ######################################################################### dnl ## dnl ## These lines allow us to capture the arguments passed to this configure dnl ## so we can substitute into sysinfo.in to make sysinfo.gap dnl ## gp_configure_options=$ac_configure_args AC_SUBST(gp_configure_options) dnl ######################################################################### dnl ## dnl ## generate a makefile dnl ## AC_SUBST(CC) AC_SUBST(CFLAGS) AC_SUBST(CPPFLAGS) AC_SUBST(LDFLAGS) AC_SUBST(gapbin) gapbin=`pwd` AC_SUBST(ABI) AC_SUBST(ABI_CFLAGS) ABI=$ABI ABI_CFLAGS=$ABI_CFLAGS AC_SUBST(GMP_LIBS) GMP_LIBS=$GMP_LIBS AC_SUBST(GMP_CFLAGS) GMP_CFLAGS=$GMP_CFLAGS AC_ARG_WITH(gmp,[dummy],[],[]) AC_ARG_WITH(abi,[dummy],[],[]) AC_ARG_WITH(configname,[dummy],[],[]) AC_DEFINE_UNQUOTED(CONFIGNAME, "$CONFIGNAME", [the CONFIGNAME value of the active configuration]) AC_CONFIG_FILES([sysinfo.gap:../../cnf/sysinfo.in gac:../../cnf/gac.in Makefile:../../cnf/Makegap.in extern/Makefile:../../extern/Makefile.in]) AC_OUTPUT chmod a+x gac gap-4r6p5/cnf/sysinfo.in0000644000175000017500000000207212172557252013732 0ustar billbill# sysinfo.gap is AUTOGENERATED from sysinfo.in - DO NOT EDIT BY HAND ############################################################################# ## #W sysinfo.in Gap compile options John McDermott ## ## #Y Copyright (C) 2011, University of St Andrews, Scotland ## gap_bin=@gapbin@ if [ "X${gap_bin}" = "X$0" ]; then gap_dir="../../"; gap_compiler="./gap"; gap_binary="./"; else gap_dir="${gap_bin}/../.."; gap_compiler="${gap_bin}/gap"; gap_binary="${gap_bin}"; fi gap_options="" gap_include="${gap_dir}/src" gap_config_options="@gp_configure_options@" # These three should be filled in by the standard autoconf procedures c_compiler="@CC@" c_options="@CFLAGS@" c_linker="@CC@" c_link_options="@LDFLAGS@" c_libs="@LIBS@ @GMP_LIBS@" # These will need special care c_dyn_options="@CDYNOPTIONS@" c_dyn_linker="@CDYNLINKER@" c_dyn_linking="@CDYNLINKING@" c_dynlibs="@C_DYNLIBS@" c_addlibs="" ############################################################################# ## #E sysinfo.in ENDS HERE ## gap-4r6p5/cnf/aclocal.m40000644000175000017500000002305512172557252013554 0ustar billbilldnl ######################################################################### dnl ## dnl ## check whether CC expects -export-dynamic dnl ## AC_DEFUN(GP_PROG_CC_EXPORT_DYNAMIC, [AC_CACHE_CHECK(whether ${CC-cc} accepts -export-dynamic, gp_cv_prog_cc_export_dynamic, [echo 'int main(){}' > conftest.c if test -z "`${CC-cc} -export-dynamic -o conftest conftest.c 2>&1`"; then gp_cv_prog_cc_export_dynamic=yes else gp_cv_prog_cc_export_dynamic=no fi rm -f conftest* ])]) dnl ######################################################################### dnl ## dnl ## check what symbols in ".o" start with an underscore dnl ## AC_DEFUN(GP_C_UNDERSCORE_SYMBOLS, [AC_CHECK_PROGS( NM, nm ) AC_CACHE_CHECK(whether symbols begin with an underscore, gp_cv_c_underscore_symbols, [echo 'int foo() { return 0;}' > conftest.c ${CC-cc} -c conftest.c 2>&1 if test -z "$NM" ; then AC_MSG_ERROR( cannot find "nm" ) else if $NM conftest.o | grep _foo > /dev/null 2>&1 ; then gp_cv_c_underscore_symbols=yes else gp_cv_c_underscore_symbols=no fi fi rm -f conftest* ] ) if test "$gp_cv_c_underscore_symbols" = yes; then AC_DEFINE( C_UNDERSCORE_SYMBOLS, 1, [define as 1 if you symbols in ".o" files begin with `_']) fi ] ) dnl ######################################################################### dnl ## dnl ## check what unaligned access is still save dnl ## AC_DEFUN(GP_C_LONG_ALIGN, [AC_CACHE_CHECK(unaligned access, gp_cv_c_long_align, [ case "$host" in alpha* ) gp_cv_c_long_align=8;; mips-* | sparc-* ) gp_cv_c_long_align=$ac_cv_sizeof_void_p;; i586-* | i686-* ) gp_cv_c_long_align=2;; x86_64-* ) gp_cv_c_long_align=2;; * ) case "$host" in *OSF* | *osf* ) uac p sigbus;; esac AC_LANG_PUSH([C]) AC_RUN_IFELSE( [AC_LANG_SOURCE([[char buf[32];main(){long i= *(long*)(buf+1);buf[1]=(char)i;return 0;}]])], [gp_cv_c_long_align=1], [ AC_RUN_IFELSE( [AC_LANG_SOURCE([[char buf[32];main(){long i= *(long*)(buf+2);buf[1]=(char)i;return 0;}]])], [gp_cv_c_long_align=2], [ AC_RUN_IFELSE( [AC_LANG_SOURCE([[char buf[32];main(){long i= *(long*)(buf+4);buf[1]=(char)i;return 0;}]])], [gp_cv_c_long_align=4], [ AC_RUN_IFELSE( [AC_LANG_SOURCE([[char buf[32];main(){long i= *(long*)(buf+8);buf[1]=(char)i;return 0;}]])], [gp_cv_c_long_align=8] ) ] ) ] ) ] ) AC_LANG_POP([C]) rm -f core core.* *.core esac ] ) AC_DEFINE_UNQUOTED( C_LONG_ALIGN, $gp_cv_c_long_align, [define as least offset which is still safe for an unaligned access] ) ] ) dnl ######################################################################### dnl ## dnl ## check for old style union wait more carefully dnl ## AC_DEFUN(GP_C_UNION_WAIT, [AC_CACHE_CHECK(union wait, gp_cv_c_union_wait, [ AC_TRY_COMPILE( [#include ], [int a; int status; waitpid( (pid_t)-1, & status, 0); a = WIFSIGNALED(status); a = WEXITSTATUS(status);], gp_cv_c_union_wait=0, gp_cv_c_union_wait=1 )], AC_DEFINE( HAVE_UNION_WAIT, $gp_cv_c_union_wait, [define as 1 if you have "union wait"] ) )]) dnl ######################################################################### dnl ## dnl ## choose CFLAGS more carefully dnl ## dnl ## For alpha/cc (or some flavours of this at least) -O3 is faster dnl ## but seems to reveal a compiler bug applying to stats.c and causing dnl ## SyCompileInput to be clobbered while PrintStatFuncs is being dnl ## initialized dnl ## AC_DEFUN(GP_CFLAGS, [AC_CACHE_CHECK(C compiler default flags, gp_cv_cflags, [ case "$host-$CC" in *-gcc* ) gp_cv_cflags="-Wall -g -O2 ${ABI_CFLAGS}";; *-clang* ) gp_cv_cflags="-Wall -g -O3 ${ABI_CFLAGS} -Wno-unused-value";; i686-*-egcs ) gp_cv_cflags="-Wall -g -O2 -mcpu=i686 ${ABI_CFLAGS}";; i586-*-egcs ) gp_cv_cflags="-Wall -g -O2 -mcpu=i586 ${ABI_CFLAGS}";; i486-*-egcs ) gp_cv_cflags="-Wall -g -O2 -mcpu=i486 ${ABI_CFLAGS}";; i386-*-egcs ) gp_cv_cflags="-Wall -g -O2 -mcpu=i386 ${ABI_CFLAGS}";; *-icc* ) gp_cv_cflags="-Wall -g -O2 ${ABI_CFLAGS}";; alphaev6-*-osf4*-cc ) gp_cv_cflags="-g3 -arch ev6 -O1 ";; alphaev56-*-osf4*-cc ) gp_cv_cflags="-g3 -arch ev56 -O1";; alphaev5-*-osf4*-cc ) gp_cv_cflags="-g3 -arch ev5 -O1";; alpha*-*-osf4*-cc ) gp_cv_cflags="-g3 -O1";; *aix*cc ) gp_cv_cflags="-g -O3";; *-solaris*-cc ) gp_cv_cflags="-fast -erroff=E_STATEMENT_NOT_REACHED";; *-irix*-cc ) gp_cv_cflags="-O3 -woff 1110,1167,1174,1552";; * ) gp_cv_cflags="-O";; esac ]) CFLAGS="$CFLAGS $gp_cv_cflags"]) dnl ######################################################################### dnl ## dnl ## choose LDFLAGS more carefully dnl ## AC_DEFUN(GP_LDFLAGS, [AC_CACHE_CHECK(Linker default flags, gp_cv_ldflags, [ case "$host-$CC" in *-apple-darwin11*-gcc* ) gp_cv_ldflags="-g -Wl,-no_pie ${ABI_CFLAGS}";; *-apple-darwin12*-gcc* ) gp_cv_ldflags="-g -Wl,-no_pie ${ABI_CFLAGS}";; *-apple-darwin1*-mpicc* ) gp_cv_ldflags="-g -Wl,-no_pie ${ABI_CFLAGS}";; *-gcc* | *-egcs ) gp_cv_ldflags="-g ${ABI_CFLAGS}";; *-apple-darwin*-clang* ) gp_cv_ldflags="-g -Wl,-no_pie ${ABI_CFLAGS}";; *-clang* ) gp_cv_ldflags="-g -rdynamic ${ABI_CFLAGS}";; *-icc* ) gp_cv_ldflags="-g -rdynamic -static-libgcc -static-intel ${ABI_CFLAGS}";; alpha*-*-osf4*-cc ) gp_cv_ldflags="-g3 ";; *-solaris*-cc ) gp_cv_ldflags="";; *aix*cc ) gp_cv_ldflags="-g";; *-irix*-cc ) gp_cv_ldflags="-O3";; * ) gp_cv_ldflags="";; esac ]) LDFLAGS="$LDFLAGS $gp_cv_ldflags"]) dnl ######################################################################### dnl ## dnl ## flags for dynamic linking dnl ## AC_DEFUN(GP_PROG_CC_DYNFLAGS, [AC_CACHE_CHECK(dynamic module compile options, gp_cv_prog_cc_cdynoptions, [ case "$host-$CC" in i686-pc-cygwin-gcc* ) gp_cv_prog_cc_cdynoptions="${ABI_CFLAGS}";; *-apple-darwin*gcc* ) gp_cv_prog_cc_cdynoptions="-fPIC -Wall ${ABI_CFLAGS}";; *-hpux-gcc ) gp_cv_prog_cc_cdynoptions="-fpic -Wall ${ABI_CFLAGS}";; *-gcc* | *-egcs ) gp_cv_prog_cc_cdynoptions="-fpic -Wall -O2 ${ABI_CFLAGS}";; *-clang* ) gp_cv_prog_cc_cdynoptions="-fPIC -Wall ${ABI_CFLAGS} -Wno-unused-value";; *-icc* ) gp_cv_prog_cc_cdynoptions="-fpic -Wall -O2 ${ABI_CFLAGS}";; *-next-nextstep-cc ) gp_cv_prog_cc_cdynoptions=" -Wall -O2 -arch $hostcpu";; *-osf*-cc ) gp_cv_prog_cc_cdynoptions=" -shared -x -O2";; *-irix* ) gp_cv_prog_cc_cdynoptions=" -O3 -woff 1110,1167,1174,1552";; * ) dnl ## if we don't recognise this compiler, guess some flags gp_cv_prog_cc_cdynoptions="-fpic -O2 ${ABI_CFLAGS}";; esac ]) AC_CACHE_CHECK(dynamic linker, gp_cv_prog_cc_cdynlinker, [ case "$host-$CC" in i686-pc-cygwin-gcc* ) gp_cv_prog_cc_cdynlinker="${CC}";; *-apple-darwin*gcc* ) gp_cv_prog_cc_cdynlinker="${CC}";; *-gcc* ) gp_cv_prog_cc_cdynlinker="${CC}";; *-clang* ) gp_cv_prog_cc_cdynlinker="${CC}";; *-egcs ) gp_cv_prog_cc_cdynlinker="${CC}";; *-icc* ) gp_cv_prog_cc_cdynlinker="${CC}";; *-next-nextstep-cc ) gp_cv_prog_cc_cdynlinker="cc";; *-osf*-cc ) gp_cv_prog_cc_cdynlinker="cc";; *-irix* ) gp_cv_prog_cc_cdynlinker="ld";; * ) dnl ## if we don't recognise this compiler, assume it can link gp_cv_prog_cc_cdynlinker="${CC}";; esac ]) AC_CACHE_CHECK(dynamic module link flags, gp_cv_prog_cc_cdynlinking, [ case "$host-$CC" in *-apple-darwin*gcc* ) gp_cv_prog_cc_cdynlinking='-g -bundle -bundle_loader ${gap_bin}/gap -lc -lm'" ${ABI_CFLAGS}";; i686-pc-cygwin-gcc* ) gp_cv_prog_cc_cdynlinking='-shared ${gap_bin}/gap.dll';; *-gcc ) gp_cv_prog_cc_cdynlinking="-shared -g ${ABI_CFLAGS}";; *-apple-darwin*clang ) gp_cv_prog_cc_cdynlinking='-bundle -g -bundle_loader ${gap_bin}/gap'" ${ABI_CFLAGS}";; *-clang ) gp_cv_prog_cc_cdynlinking="-shared -g ${ABI_CFLAGS}";; *-icc ) gp_cv_prog_cc_cdynlinking="-shared -g ${ABI_CFLAGS}";; *-egcs ) gp_cv_prog_cc_cdynlinking="-shared -g ${ABI_CFLAGS}";; *hpux* ) gp_cv_prog_cc_cdynlinking="-b +e Init__Dynamic";; alpha*osf4*-cc ) gp_cv_prog_cc_cdynlinking="-shared -g3";; alpha*osf*cc ) gp_cv_prog_cc_cdynlinking="-shared";; *osf*cc ) gp_cv_prog_cc_cdynlinking="-shared -r";; *-irix* ) gp_cv_prog_cc_cdynlinking="-shared -O3";; *-nextstep*cc ) gp_cv_prog_cc_cdynlinking="-arch $hostcpu -Xlinker -r -Xlinker -x -nostdlib";; *solaris* ) gp_cv_prog_cc_cdynlinking="-G -Bdynamic";; *sunos* ) gp_cv_prog_cc_cdynlinking="-assert pure-text -Bdynamic -x";; * ) dnl ## if we don't recognise this compiler, guess some flags gp_cv_prog_cc_cdynlinking="-shared -g ${ABI_CFLAGS}";; esac ]) AC_DEFUN([GP_VAR_SYS_ERRLIST], [AC_CACHE_CHECK([for sys_errlist], gp_cv_var_sys_errlist, [AC_TRY_LINK([int *p;], [extern int sys_errlist; p = &sys_errlist;], gp_cv_var_sys_errlist=yes, gp_cv_var_sys_errlist=no)]) if test x"$gp_cv_var_sys_errlist" = xyes; then AC_DEFINE(HAVE_SYS_ERRLIST, 1, [Define if your system libraries have a sys_errlist variable.]) fi]) CDYNOPTIONS=$gp_cv_prog_cc_cdynoptions CDYNLINKER=$gp_cv_prog_cc_cdynlinker CDYNLINKING=$gp_cv_prog_cc_cdynlinking AC_SUBST(CDYNOPTIONS) AC_SUBST(CDYNLINKER) AC_SUBST(CDYNLINKING) AC_SUBST(GMP_LIBS) AC_SUBST(GMP_CFLAGS) ]) gap-4r6p5/cnf/configure.out0000755000175000017500000061240412172557302014427 0ustar billbill#! /bin/sh # Guess values for system-dependent variables and create Makefiles. # Generated by GNU Autoconf 2.69 for GAP 4.6.5. # # Report bugs to . # # # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc. # # # This configure script is free software; the Free Software Foundation # gives unlimited permission to copy, distribute and modify it. ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi as_nl=' ' export as_nl # Printing a long string crashes Solaris 7 /usr/bin/printf. as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo # Prefer a ksh shell builtin over an external printf program on Solaris, # but without wasting forks for bash or zsh. if test -z "$BASH_VERSION$ZSH_VERSION" \ && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='print -r --' as_echo_n='print -rn --' elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='printf %s\n' as_echo_n='printf %s' else if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' as_echo_n='/usr/ucb/echo -n' else as_echo_body='eval expr "X$1" : "X\\(.*\\)"' as_echo_n_body='eval arg=$1; case $arg in #( *"$as_nl"*) expr "X$arg" : "X\\(.*\\)$as_nl"; arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; esac; expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" ' export as_echo_n_body as_echo_n='sh -c $as_echo_n_body as_echo' fi export as_echo_body as_echo='sh -c $as_echo_body as_echo' fi # The user is always right. if test "${PATH_SEPARATOR+set}" != set; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # IFS # We need space, tab and new line, in precisely that order. Quoting is # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as `sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Unset variables that we do not need and which cause bugs (e.g. in # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" # suppresses any "Segmentation fault" message there. '((' could # trigger a bug in pdksh 5.2.14. for as_var in BASH_ENV ENV MAIL MAILPATH do eval test x\${$as_var+set} = xset \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH # Use a proper internal environment variable to ensure we don't fall # into an infinite loop, continuously re-executing ourselves. if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then _as_can_reexec=no; export _as_can_reexec; # We cannot yet assume a decent shell, so we have to provide a # neutralization value for shells without unset; and this also # works around shells that cannot unset nonexistent variables. # Preserve -v and -x to the replacement shell. BASH_ENV=/dev/null ENV=/dev/null (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV case $- in # (((( *v*x* | *x*v* ) as_opts=-vx ;; *v* ) as_opts=-v ;; *x* ) as_opts=-x ;; * ) as_opts= ;; esac exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} # Admittedly, this is quite paranoid, since all the known shells bail # out after a failed `exec'. $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 as_fn_exit 255 fi # We don't want this to propagate to other subprocesses. { _as_can_reexec=; unset _as_can_reexec;} if test "x$CONFIG_SHELL" = x; then as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which # is contrary to our usage. Disable this feature. alias -g '\${1+\"\$@\"}'='\"\$@\"' setopt NO_GLOB_SUBST else case \`(set -o) 2>/dev/null\` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi " as_required="as_fn_return () { (exit \$1); } as_fn_success () { as_fn_return 0; } as_fn_failure () { as_fn_return 1; } as_fn_ret_success () { return 0; } as_fn_ret_failure () { return 1; } exitcode=0 as_fn_success || { exitcode=1; echo as_fn_success failed.; } as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; } as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; } as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then : else exitcode=1; echo positional parameters were not saved. fi test x\$exitcode = x0 || exit 1 test -x / || exit 1" as_suggested=" as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" && test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1 test \$(( 1 + 1 )) = 2 || exit 1" if (eval "$as_required") 2>/dev/null; then : as_have_required=yes else as_have_required=no fi if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then : else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR as_found=false for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. as_found=: case $as_dir in #( /*) for as_base in sh bash ksh sh5; do # Try only shells that exist, to save several forks. as_shell=$as_dir/$as_base if { test -f "$as_shell" || test -f "$as_shell.exe"; } && { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then : CONFIG_SHELL=$as_shell as_have_required=yes if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then : break 2 fi fi done;; esac as_found=false done $as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } && { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then : CONFIG_SHELL=$SHELL as_have_required=yes fi; } IFS=$as_save_IFS if test "x$CONFIG_SHELL" != x; then : export CONFIG_SHELL # We cannot yet assume a decent shell, so we have to provide a # neutralization value for shells without unset; and this also # works around shells that cannot unset nonexistent variables. # Preserve -v and -x to the replacement shell. BASH_ENV=/dev/null ENV=/dev/null (unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV case $- in # (((( *v*x* | *x*v* ) as_opts=-vx ;; *v* ) as_opts=-v ;; *x* ) as_opts=-x ;; * ) as_opts= ;; esac exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} # Admittedly, this is quite paranoid, since all the known shells bail # out after a failed `exec'. $as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2 exit 255 fi if test x$as_have_required = xno; then : $as_echo "$0: This script requires a shell more modern than all" $as_echo "$0: the shells that I found on your system." if test x${ZSH_VERSION+set} = xset ; then $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should" $as_echo "$0: be upgraded to zsh 4.3.4 or later." else $as_echo "$0: Please tell bug-autoconf@gnu.org and $0: support@gap-system.org about your system, including any $0: error possibly output before this message. Then install $0: a modern shell, or manually run the script under such a $0: shell if you do have one." fi exit 1 fi fi fi SHELL=${CONFIG_SHELL-/bin/sh} export SHELL # Unset more variables known to interfere with behavior of common tools. CLICOLOR_FORCE= GREP_OPTIONS= unset CLICOLOR_FORCE GREP_OPTIONS ## --------------------- ## ## M4sh Shell Functions. ## ## --------------------- ## # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p # as_fn_executable_p FILE # ----------------------- # Test if FILE is an executable regular file. as_fn_executable_p () { test -f "$1" && test -x "$1" } # as_fn_executable_p # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : eval 'as_fn_append () { eval $1+=\$2 }' else as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : eval 'as_fn_arith () { as_val=$(( $* )) }' else as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi $as_echo "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || $as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits as_lineno_1=$LINENO as_lineno_1a=$LINENO as_lineno_2=$LINENO as_lineno_2a=$LINENO eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" && test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || { # Blame Lee E. McMahon (1931-1989) for sed's syntax. :-) sed -n ' p /[$]LINENO/= ' <$as_myself | sed ' s/[$]LINENO.*/&-/ t lineno b :lineno N :loop s/[$]LINENO\([^'$as_cr_alnum'_].*\n\)\(.*\)/\2\1\2/ t loop s/-\n.*// ' >$as_me.lineno && chmod +x "$as_me.lineno" || { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; } # If we had to re-execute with $CONFIG_SHELL, we're ensured to have # already done that, so ensure we don't try to do so again and fall # in an infinite loop. This has already happened in practice. _as_can_reexec=no; export _as_can_reexec # Don't try to exec as it changes $[0], causing all sort of problems # (the dirname of $[0] is not the place where we might find the # original and so on. Autoconf is especially sensitive to this). . "./$as_me.lineno" # Exit status is that of the last command. exit } ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -pR' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -pR' fi else as_ln_s='cp -pR' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi as_test_x='test -x' as_executable_p=as_fn_executable_p # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" # Sed expression to map a string onto a valid variable name. as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" test -n "$DJDIR" || exec 7<&0 &1 # Name of the host. # hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status, # so uname gets run too. ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q` # # Initializations. # ac_default_prefix=/usr/local ac_clean_files= ac_config_libobj_dir=. LIBOBJS= cross_compiling=no subdirs= MFLAGS= MAKEFLAGS= # Identity of this package. PACKAGE_NAME='GAP' PACKAGE_TARNAME='gap' PACKAGE_VERSION='4.6.5' PACKAGE_STRING='GAP 4.6.5' PACKAGE_BUGREPORT='support@gap-system.org' PACKAGE_URL='http://www.gap-system.org/' ac_unique_file="gap.c" # Factoring default headers for most tests. ac_includes_default="\ #include #ifdef HAVE_SYS_TYPES_H # include #endif #ifdef HAVE_SYS_STAT_H # include #endif #ifdef STDC_HEADERS # include # include #else # ifdef HAVE_STDLIB_H # include # endif #endif #ifdef HAVE_STRING_H # if !defined STDC_HEADERS && defined HAVE_MEMORY_H # include # endif # include #endif #ifdef HAVE_STRINGS_H # include #endif #ifdef HAVE_INTTYPES_H # include #endif #ifdef HAVE_STDINT_H # include #endif #ifdef HAVE_UNISTD_H # include #endif" ac_subst_vars='LTLIBOBJS LIBOBJS ABI_CFLAGS ABI gapbin gp_configure_options ITANIUMOBJ C_DYNLIBS GMP_CFLAGS GMP_LIBS CDYNLINKING CDYNLINKER CDYNOPTIONS GAPARCH host_os host_vendor host_cpu host build_os build_vendor build_cpu build NM EGREP GREP CPP OBJEXT EXEEXT ac_ct_CC CPPFLAGS LDFLAGS CFLAGS CC target_alias host_alias build_alias LIBS ECHO_T ECHO_N ECHO_C DEFS mandir localedir libdir psdir pdfdir dvidir htmldir infodir docdir oldincludedir includedir localstatedir sharedstatedir sysconfdir datadir datarootdir libexecdir sbindir bindir program_transform_name prefix exec_prefix PACKAGE_URL PACKAGE_BUGREPORT PACKAGE_STRING PACKAGE_VERSION PACKAGE_TARNAME PACKAGE_NAME PATH_SEPARATOR SHELL' ac_subst_files='' ac_user_opts=' enable_option_checking with_readline with_gmp with_abi with_configname ' ac_precious_vars='build_alias host_alias target_alias CC CFLAGS LDFLAGS LIBS CPPFLAGS CPP' # Initialize some variables set by options. ac_init_help= ac_init_version=false ac_unrecognized_opts= ac_unrecognized_sep= # The variables have the same names as the options, with # dashes changed to underlines. cache_file=/dev/null exec_prefix=NONE no_create= no_recursion= prefix=NONE program_prefix=NONE program_suffix=NONE program_transform_name=s,x,x, silent= site= srcdir=../../src verbose= x_includes=NONE x_libraries=NONE # Installation directory options. # These are left unexpanded so users can "make install exec_prefix=/foo" # and all the variables that are supposed to be based on exec_prefix # by default will actually change. # Use braces instead of parens because sh, perl, etc. also accept them. # (The list follows the same order as the GNU Coding Standards.) bindir='${exec_prefix}/bin' sbindir='${exec_prefix}/sbin' libexecdir='${exec_prefix}/libexec' datarootdir='${prefix}/share' datadir='${datarootdir}' sysconfdir='${prefix}/etc' sharedstatedir='${prefix}/com' localstatedir='${prefix}/var' includedir='${prefix}/include' oldincludedir='/usr/include' docdir='${datarootdir}/doc/${PACKAGE_TARNAME}' infodir='${datarootdir}/info' htmldir='${docdir}' dvidir='${docdir}' pdfdir='${docdir}' psdir='${docdir}' libdir='${exec_prefix}/lib' localedir='${datarootdir}/locale' mandir='${datarootdir}/man' ac_prev= ac_dashdash= for ac_option do # If the previous option needs an argument, assign it. if test -n "$ac_prev"; then eval $ac_prev=\$ac_option ac_prev= continue fi case $ac_option in *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;; *=) ac_optarg= ;; *) ac_optarg=yes ;; esac # Accept the important Cygnus configure options, so we can diagnose typos. case $ac_dashdash$ac_option in --) ac_dashdash=yes ;; -bindir | --bindir | --bindi | --bind | --bin | --bi) ac_prev=bindir ;; -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*) bindir=$ac_optarg ;; -build | --build | --buil | --bui | --bu) ac_prev=build_alias ;; -build=* | --build=* | --buil=* | --bui=* | --bu=*) build_alias=$ac_optarg ;; -cache-file | --cache-file | --cache-fil | --cache-fi \ | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c) ac_prev=cache_file ;; -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \ | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*) cache_file=$ac_optarg ;; --config-cache | -C) cache_file=config.cache ;; -datadir | --datadir | --datadi | --datad) ac_prev=datadir ;; -datadir=* | --datadir=* | --datadi=* | --datad=*) datadir=$ac_optarg ;; -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \ | --dataroo | --dataro | --datar) ac_prev=datarootdir ;; -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \ | --dataroot=* | --dataroo=* | --dataro=* | --datar=*) datarootdir=$ac_optarg ;; -disable-* | --disable-*) ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval enable_$ac_useropt=no ;; -docdir | --docdir | --docdi | --doc | --do) ac_prev=docdir ;; -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*) docdir=$ac_optarg ;; -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv) ac_prev=dvidir ;; -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*) dvidir=$ac_optarg ;; -enable-* | --enable-*) ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid feature name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "enable_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval enable_$ac_useropt=\$ac_optarg ;; -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \ | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \ | --exec | --exe | --ex) ac_prev=exec_prefix ;; -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \ | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \ | --exec=* | --exe=* | --ex=*) exec_prefix=$ac_optarg ;; -gas | --gas | --ga | --g) # Obsolete; use --with-gas. with_gas=yes ;; -help | --help | --hel | --he | -h) ac_init_help=long ;; -help=r* | --help=r* | --hel=r* | --he=r* | -hr*) ac_init_help=recursive ;; -help=s* | --help=s* | --hel=s* | --he=s* | -hs*) ac_init_help=short ;; -host | --host | --hos | --ho) ac_prev=host_alias ;; -host=* | --host=* | --hos=* | --ho=*) host_alias=$ac_optarg ;; -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht) ac_prev=htmldir ;; -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \ | --ht=*) htmldir=$ac_optarg ;; -includedir | --includedir | --includedi | --included | --include \ | --includ | --inclu | --incl | --inc) ac_prev=includedir ;; -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \ | --includ=* | --inclu=* | --incl=* | --inc=*) includedir=$ac_optarg ;; -infodir | --infodir | --infodi | --infod | --info | --inf) ac_prev=infodir ;; -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*) infodir=$ac_optarg ;; -libdir | --libdir | --libdi | --libd) ac_prev=libdir ;; -libdir=* | --libdir=* | --libdi=* | --libd=*) libdir=$ac_optarg ;; -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \ | --libexe | --libex | --libe) ac_prev=libexecdir ;; -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \ | --libexe=* | --libex=* | --libe=*) libexecdir=$ac_optarg ;; -localedir | --localedir | --localedi | --localed | --locale) ac_prev=localedir ;; -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*) localedir=$ac_optarg ;; -localstatedir | --localstatedir | --localstatedi | --localstated \ | --localstate | --localstat | --localsta | --localst | --locals) ac_prev=localstatedir ;; -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \ | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*) localstatedir=$ac_optarg ;; -mandir | --mandir | --mandi | --mand | --man | --ma | --m) ac_prev=mandir ;; -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*) mandir=$ac_optarg ;; -nfp | --nfp | --nf) # Obsolete; use --without-fp. with_fp=no ;; -no-create | --no-create | --no-creat | --no-crea | --no-cre \ | --no-cr | --no-c | -n) no_create=yes ;; -no-recursion | --no-recursion | --no-recursio | --no-recursi \ | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r) no_recursion=yes ;; -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \ | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \ | --oldin | --oldi | --old | --ol | --o) ac_prev=oldincludedir ;; -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \ | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \ | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*) oldincludedir=$ac_optarg ;; -prefix | --prefix | --prefi | --pref | --pre | --pr | --p) ac_prev=prefix ;; -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*) prefix=$ac_optarg ;; -program-prefix | --program-prefix | --program-prefi | --program-pref \ | --program-pre | --program-pr | --program-p) ac_prev=program_prefix ;; -program-prefix=* | --program-prefix=* | --program-prefi=* \ | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*) program_prefix=$ac_optarg ;; -program-suffix | --program-suffix | --program-suffi | --program-suff \ | --program-suf | --program-su | --program-s) ac_prev=program_suffix ;; -program-suffix=* | --program-suffix=* | --program-suffi=* \ | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*) program_suffix=$ac_optarg ;; -program-transform-name | --program-transform-name \ | --program-transform-nam | --program-transform-na \ | --program-transform-n | --program-transform- \ | --program-transform | --program-transfor \ | --program-transfo | --program-transf \ | --program-trans | --program-tran \ | --progr-tra | --program-tr | --program-t) ac_prev=program_transform_name ;; -program-transform-name=* | --program-transform-name=* \ | --program-transform-nam=* | --program-transform-na=* \ | --program-transform-n=* | --program-transform-=* \ | --program-transform=* | --program-transfor=* \ | --program-transfo=* | --program-transf=* \ | --program-trans=* | --program-tran=* \ | --progr-tra=* | --program-tr=* | --program-t=*) program_transform_name=$ac_optarg ;; -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd) ac_prev=pdfdir ;; -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*) pdfdir=$ac_optarg ;; -psdir | --psdir | --psdi | --psd | --ps) ac_prev=psdir ;; -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*) psdir=$ac_optarg ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) silent=yes ;; -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb) ac_prev=sbindir ;; -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \ | --sbi=* | --sb=*) sbindir=$ac_optarg ;; -sharedstatedir | --sharedstatedir | --sharedstatedi \ | --sharedstated | --sharedstate | --sharedstat | --sharedsta \ | --sharedst | --shareds | --shared | --share | --shar \ | --sha | --sh) ac_prev=sharedstatedir ;; -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \ | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \ | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \ | --sha=* | --sh=*) sharedstatedir=$ac_optarg ;; -site | --site | --sit) ac_prev=site ;; -site=* | --site=* | --sit=*) site=$ac_optarg ;; -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) ac_prev=srcdir ;; -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) srcdir=$ac_optarg ;; -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \ | --syscon | --sysco | --sysc | --sys | --sy) ac_prev=sysconfdir ;; -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \ | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*) sysconfdir=$ac_optarg ;; -target | --target | --targe | --targ | --tar | --ta | --t) ac_prev=target_alias ;; -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*) target_alias=$ac_optarg ;; -v | -verbose | --verbose | --verbos | --verbo | --verb) verbose=yes ;; -version | --version | --versio | --versi | --vers | -V) ac_init_version=: ;; -with-* | --with-*) ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval with_$ac_useropt=\$ac_optarg ;; -without-* | --without-*) ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && as_fn_error $? "invalid package name: $ac_useropt" ac_useropt_orig=$ac_useropt ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in *" "with_$ac_useropt" "*) ;; *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig" ac_unrecognized_sep=', ';; esac eval with_$ac_useropt=no ;; --x) # Obsolete; use --with-x. with_x=yes ;; -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \ | --x-incl | --x-inc | --x-in | --x-i) ac_prev=x_includes ;; -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \ | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*) x_includes=$ac_optarg ;; -x-libraries | --x-libraries | --x-librarie | --x-librari \ | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l) ac_prev=x_libraries ;; -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \ | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) x_libraries=$ac_optarg ;; -*) as_fn_error $? "unrecognized option: \`$ac_option' Try \`$0 --help' for more information" ;; *=*) ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='` # Reject names that are not valid shell variable names. case $ac_envvar in #( '' | [0-9]* | *[!_$as_cr_alnum]* ) as_fn_error $? "invalid variable name: \`$ac_envvar'" ;; esac eval $ac_envvar=\$ac_optarg export $ac_envvar ;; *) # FIXME: should be removed in autoconf 3.0. $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null && $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2 : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}" ;; esac done if test -n "$ac_prev"; then ac_option=--`echo $ac_prev | sed 's/_/-/g'` as_fn_error $? "missing argument to $ac_option" fi if test -n "$ac_unrecognized_opts"; then case $enable_option_checking in no) ;; fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;; *) $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;; esac fi # Check all directory arguments for consistency. for ac_var in exec_prefix prefix bindir sbindir libexecdir datarootdir \ datadir sysconfdir sharedstatedir localstatedir includedir \ oldincludedir docdir infodir htmldir dvidir pdfdir psdir \ libdir localedir mandir do eval ac_val=\$$ac_var # Remove trailing slashes. case $ac_val in */ ) ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'` eval $ac_var=\$ac_val;; esac # Be sure to have absolute directory names. case $ac_val in [\\/$]* | ?:[\\/]* ) continue;; NONE | '' ) case $ac_var in *prefix ) continue;; esac;; esac as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val" done # There might be people who depend on the old broken behavior: `$host' # used to hold the argument of --host etc. # FIXME: To remove some day. build=$build_alias host=$host_alias target=$target_alias # FIXME: To remove some day. if test "x$host_alias" != x; then if test "x$build_alias" = x; then cross_compiling=maybe elif test "x$build_alias" != "x$host_alias"; then cross_compiling=yes fi fi ac_tool_prefix= test -n "$host_alias" && ac_tool_prefix=$host_alias- test "$silent" = yes && exec 6>/dev/null ac_pwd=`pwd` && test -n "$ac_pwd" && ac_ls_di=`ls -di .` && ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` || as_fn_error $? "working directory cannot be determined" test "X$ac_ls_di" = "X$ac_pwd_ls_di" || as_fn_error $? "pwd does not report name of working directory" # Find the source files, if location was not specified. if test -z "$srcdir"; then ac_srcdir_defaulted=yes # Try the directory containing this script, then the parent directory. ac_confdir=`$as_dirname -- "$as_myself" || $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_myself" : 'X\(//\)[^/]' \| \ X"$as_myself" : 'X\(//\)$' \| \ X"$as_myself" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_myself" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` srcdir=$ac_confdir if test ! -r "$srcdir/$ac_unique_file"; then srcdir=.. fi else ac_srcdir_defaulted=no fi if test ! -r "$srcdir/$ac_unique_file"; then test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir" fi ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" ac_abs_confdir=`( cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg" pwd)` # When building in place, set srcdir=. if test "$ac_abs_confdir" = "$ac_pwd"; then srcdir=. fi # Remove unnecessary trailing slashes from srcdir. # Double slashes in file names in object file debugging info # mess up M-x gdb in Emacs. case $srcdir in */) srcdir=`expr "X$srcdir" : 'X\(.*[^/]\)' \| "X$srcdir" : 'X\(.*\)'`;; esac for ac_var in $ac_precious_vars; do eval ac_env_${ac_var}_set=\${${ac_var}+set} eval ac_env_${ac_var}_value=\$${ac_var} eval ac_cv_env_${ac_var}_set=\${${ac_var}+set} eval ac_cv_env_${ac_var}_value=\$${ac_var} done # # Report the --help message. # if test "$ac_init_help" = "long"; then # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF \`configure' configures GAP 4.6.5 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... To assign environment variables (e.g., CC, CFLAGS...), specify them as VAR=VALUE. See below for descriptions of some of the useful variables. Defaults for the options are specified in brackets. Configuration: -h, --help display this help and exit --help=short display options specific to this package --help=recursive display the short help of all the included packages -V, --version display version information and exit -q, --quiet, --silent do not print \`checking ...' messages --cache-file=FILE cache test results in FILE [disabled] -C, --config-cache alias for \`--cache-file=config.cache' -n, --no-create do not create output files --srcdir=DIR find the sources in DIR [configure dir or \`..'] Installation directories: --prefix=PREFIX install architecture-independent files in PREFIX [$ac_default_prefix] --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX [PREFIX] By default, \`make install' will install all the files in \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify an installation prefix other than \`$ac_default_prefix' using \`--prefix', for instance \`--prefix=\$HOME'. For better control, use the options below. Fine tuning of the installation directories: --bindir=DIR user executables [EPREFIX/bin] --sbindir=DIR system admin executables [EPREFIX/sbin] --libexecdir=DIR program executables [EPREFIX/libexec] --sysconfdir=DIR read-only single-machine data [PREFIX/etc] --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com] --localstatedir=DIR modifiable single-machine data [PREFIX/var] --libdir=DIR object code libraries [EPREFIX/lib] --includedir=DIR C header files [PREFIX/include] --oldincludedir=DIR C header files for non-gcc [/usr/include] --datarootdir=DIR read-only arch.-independent data root [PREFIX/share] --datadir=DIR read-only architecture-independent data [DATAROOTDIR] --infodir=DIR info documentation [DATAROOTDIR/info] --localedir=DIR locale-dependent data [DATAROOTDIR/locale] --mandir=DIR man documentation [DATAROOTDIR/man] --docdir=DIR documentation root [DATAROOTDIR/doc/gap] --htmldir=DIR html documentation [DOCDIR] --dvidir=DIR dvi documentation [DOCDIR] --pdfdir=DIR pdf documentation [DOCDIR] --psdir=DIR ps documentation [DOCDIR] _ACEOF cat <<\_ACEOF System types: --build=BUILD configure for building on BUILD [guessed] --host=HOST cross-compile to build programs to run on HOST [BUILD] _ACEOF fi if test -n "$ac_init_help"; then case $ac_init_help in short | recursive ) echo "Configuration of GAP 4.6.5:";; esac cat <<\_ACEOF Optional Packages: --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) --with-readline=yes|no| Use readline library for command line editing. [[default=yes]] dummy Some influential environment variables: CC C compiler command CFLAGS C compiler flags LDFLAGS linker flags, e.g. -L if you have libraries in a nonstandard directory LIBS libraries to pass to the linker, e.g. -l CPPFLAGS (Objective) C/C++ preprocessor flags, e.g. -I if you have headers in a nonstandard directory CPP C preprocessor Use these variables to override the choices made by `configure' or to help it to find libraries and programs with nonstandard names/locations. Report bugs to . GAP home page: . _ACEOF ac_status=$? fi if test "$ac_init_help" = "recursive"; then # If there are subdirs, report their specific --help. for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue test -d "$ac_dir" || { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } || continue ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix= # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix cd "$ac_dir" || { ac_status=$?; continue; } # Check for guested configure. if test -f "$ac_srcdir/configure.gnu"; then echo && $SHELL "$ac_srcdir/configure.gnu" --help=recursive elif test -f "$ac_srcdir/configure"; then echo && $SHELL "$ac_srcdir/configure" --help=recursive else $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2 fi || ac_status=$? cd "$ac_pwd" || { ac_status=$?; break; } done fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF GAP configure 4.6.5 generated by GNU Autoconf 2.69 Copyright (C) 2012 Free Software Foundation, Inc. This configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. _ACEOF exit fi ## ------------------------ ## ## Autoconf initialization. ## ## ------------------------ ## # ac_fn_c_try_compile LINENO # -------------------------- # Try to compile conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest.$ac_objext; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_compile # ac_fn_c_try_run LINENO # ---------------------- # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes # that executables *can* be run. ac_fn_c_try_run () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { ac_try='./conftest$ac_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; }; then : ac_retval=0 else $as_echo "$as_me: program exited with status $ac_status" >&5 $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=$ac_status fi rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_run # ac_fn_c_try_cpp LINENO # ---------------------- # Try to preprocess conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_cpp () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if { { ac_try="$ac_cpp conftest.$ac_ext" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } > conftest.i && { test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || test ! -s conftest.err }; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_cpp # ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES # ------------------------------------------------------- # Tests whether HEADER exists and can be compiled using the include files in # INCLUDES, setting the cache variable VAR accordingly. ac_fn_c_check_header_compile () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 #include <$2> _ACEOF if ac_fn_c_try_compile "$LINENO"; then : eval "$3=yes" else eval "$3=no" fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_header_compile # ac_fn_c_compute_int LINENO EXPR VAR INCLUDES # -------------------------------------------- # Tries to find the compile-time value of EXPR in a program that includes # INCLUDES, setting VAR accordingly. Returns whether the value could be # computed ac_fn_c_compute_int () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack if test "$cross_compiling" = yes; then # Depending upon the size, compute the lo and hi bounds. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main () { static int test_array [1 - 2 * !(($2) >= 0)]; test_array [0] = 0; return test_array [0]; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_lo=0 ac_mid=0 while :; do cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main () { static int test_array [1 - 2 * !(($2) <= $ac_mid)]; test_array [0] = 0; return test_array [0]; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_hi=$ac_mid; break else as_fn_arith $ac_mid + 1 && ac_lo=$as_val if test $ac_lo -le $ac_mid; then ac_lo= ac_hi= break fi as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main () { static int test_array [1 - 2 * !(($2) < 0)]; test_array [0] = 0; return test_array [0]; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_hi=-1 ac_mid=-1 while :; do cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main () { static int test_array [1 - 2 * !(($2) >= $ac_mid)]; test_array [0] = 0; return test_array [0]; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_lo=$ac_mid; break else as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val if test $ac_mid -le $ac_hi; then ac_lo= ac_hi= break fi as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done else ac_lo= ac_hi= fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext # Binary search between lo and hi bounds. while test "x$ac_lo" != "x$ac_hi"; do as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main () { static int test_array [1 - 2 * !(($2) <= $ac_mid)]; test_array [0] = 0; return test_array [0]; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_hi=$ac_mid else as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext done case $ac_lo in #(( ?*) eval "$3=\$ac_lo"; ac_retval=0 ;; '') ac_retval=1 ;; esac else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 static long int longval () { return $2; } static unsigned long int ulongval () { return $2; } #include #include int main () { FILE *f = fopen ("conftest.val", "w"); if (! f) return 1; if (($2) < 0) { long int i = longval (); if (i != ($2)) return 1; fprintf (f, "%ld", i); } else { unsigned long int i = ulongval (); if (i != ($2)) return 1; fprintf (f, "%lu", i); } /* Do not output a trailing newline, as this causes \r\n confusion on some platforms. */ return ferror (f) || fclose (f) != 0; ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : echo >>conftest.val; read $3 &5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } else # Is the header compilable? { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5 $as_echo_n "checking $2 usability... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 #include <$2> _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_header_compiler=yes else ac_header_compiler=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5 $as_echo "$ac_header_compiler" >&6; } # Is the header present? { $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5 $as_echo_n "checking $2 presence... " >&6; } cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include <$2> _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : ac_header_preproc=yes else ac_header_preproc=no fi rm -f conftest.err conftest.i conftest.$ac_ext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5 $as_echo "$ac_header_preproc" >&6; } # So? What about this header? case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #(( yes:no: ) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5 $as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} ;; no:yes:* ) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5 $as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: check for missing prerequisite headers?" >&5 $as_echo "$as_me: WARNING: $2: check for missing prerequisite headers?" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5 $as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&5 $as_echo "$as_me: WARNING: $2: section \"Present But Cannot Be Compiled\"" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5 $as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;} ( $as_echo "## ------------------------------------- ## ## Report this to support@gap-system.org ## ## ------------------------------------- ##" ) | sed "s/^/$as_me: WARNING: /" >&2 ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else eval "$3=\$ac_header_compiler" fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_header_mongrel # ac_fn_c_find_intX_t LINENO BITS VAR # ----------------------------------- # Finds a signed integer type with width BITS, setting cache variable VAR # accordingly. ac_fn_c_find_intX_t () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for int$2_t" >&5 $as_echo_n "checking for int$2_t... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else eval "$3=no" # Order is important - never check a type that is potentially smaller # than half of the expected target width. for ac_type in int$2_t 'int' 'long int' \ 'long long int' 'short int' 'signed char'; do cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default enum { N = $2 / 2 - 1 }; int main () { static int test_array [1 - 2 * !(0 < ($ac_type) ((((($ac_type) 1 << N) << N) - 1) * 2 + 1))]; test_array [0] = 0; return test_array [0]; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default enum { N = $2 / 2 - 1 }; int main () { static int test_array [1 - 2 * !(($ac_type) ((((($ac_type) 1 << N) << N) - 1) * 2 + 1) < ($ac_type) ((((($ac_type) 1 << N) << N) - 1) * 2 + 2))]; test_array [0] = 0; return test_array [0]; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : else case $ac_type in #( int$2_t) : eval "$3=yes" ;; #( *) : eval "$3=\$ac_type" ;; esac fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext if eval test \"x\$"$3"\" = x"no"; then : else break fi done fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_find_intX_t # ac_fn_c_find_uintX_t LINENO BITS VAR # ------------------------------------ # Finds an unsigned integer type with width BITS, setting cache variable VAR # accordingly. ac_fn_c_find_uintX_t () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for uint$2_t" >&5 $as_echo_n "checking for uint$2_t... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else eval "$3=no" # Order is important - never check a type that is potentially smaller # than half of the expected target width. for ac_type in uint$2_t 'unsigned int' 'unsigned long int' \ 'unsigned long long int' 'unsigned short int' 'unsigned char'; do cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default int main () { static int test_array [1 - 2 * !((($ac_type) -1 >> ($2 / 2 - 1)) >> ($2 / 2 - 1) == 3)]; test_array [0] = 0; return test_array [0]; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : case $ac_type in #( uint$2_t) : eval "$3=yes" ;; #( *) : eval "$3=\$ac_type" ;; esac fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext if eval test \"x\$"$3"\" = x"no"; then : else break fi done fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_find_uintX_t # ac_fn_c_try_link LINENO # ----------------------- # Try to link conftest.$ac_ext, and return whether this succeeded. ac_fn_c_try_link () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack rm -f conftest.$ac_objext conftest$ac_exeext if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>conftest.err ac_status=$? if test -s conftest.err; then grep -v '^ *+' conftest.err >conftest.er1 cat conftest.er1 >&5 mv -f conftest.er1 conftest.err fi $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } && { test -z "$ac_c_werror_flag" || test ! -s conftest.err } && test -s conftest$ac_exeext && { test "$cross_compiling" = yes || test -x conftest$ac_exeext }; then : ac_retval=0 else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 ac_retval=1 fi # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would # interfere with the next link command; also delete a directory that is # left behind by Apple's compiler. We do this before executing the actions. rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval } # ac_fn_c_try_link # ac_fn_c_check_func LINENO FUNC VAR # ---------------------------------- # Tests whether FUNC exists, setting the cache variable VAR accordingly ac_fn_c_check_func () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Define $2 to an innocuous variant, in case declares $2. For example, HP-UX 11i declares gettimeofday. */ #define $2 innocuous_$2 /* System header to define __stub macros and hopefully few prototypes, which can conflict with char $2 (); below. Prefer to if __STDC__ is defined, since exists even on freestanding compilers. */ #ifdef __STDC__ # include #else # include #endif #undef $2 /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char $2 (); /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ #if defined __stub_$2 || defined __stub___$2 choke me #endif int main () { return $2 (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : eval "$3=yes" else eval "$3=no" fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_func # ac_fn_c_check_type LINENO TYPE VAR INCLUDES # ------------------------------------------- # Tests whether TYPE exists after having included INCLUDES, setting cache # variable VAR accordingly. ac_fn_c_check_type () { as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5 $as_echo_n "checking for $2... " >&6; } if eval \${$3+:} false; then : $as_echo_n "(cached) " >&6 else eval "$3=no" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main () { if (sizeof ($2)) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 int main () { if (sizeof (($2))) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : else eval "$3=yes" fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi eval ac_res=\$$3 { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno } # ac_fn_c_check_type cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. It was created by GAP $as_me 4.6.5, which was generated by GNU Autoconf 2.69. Invocation command line was $ $0 $@ _ACEOF exec 5>>config.log { cat <<_ASUNAME ## --------- ## ## Platform. ## ## --------- ## hostname = `(hostname || uname -n) 2>/dev/null | sed 1q` uname -m = `(uname -m) 2>/dev/null || echo unknown` uname -r = `(uname -r) 2>/dev/null || echo unknown` uname -s = `(uname -s) 2>/dev/null || echo unknown` uname -v = `(uname -v) 2>/dev/null || echo unknown` /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown` /bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown` /bin/arch = `(/bin/arch) 2>/dev/null || echo unknown` /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown` /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown` /usr/bin/hostinfo = `(/usr/bin/hostinfo) 2>/dev/null || echo unknown` /bin/machine = `(/bin/machine) 2>/dev/null || echo unknown` /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown` /bin/universe = `(/bin/universe) 2>/dev/null || echo unknown` _ASUNAME as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. $as_echo "PATH: $as_dir" done IFS=$as_save_IFS } >&5 cat >&5 <<_ACEOF ## ----------- ## ## Core tests. ## ## ----------- ## _ACEOF # Keep a trace of the command line. # Strip out --no-create and --no-recursion so they do not pile up. # Strip out --silent because we don't want to record it for future runs. # Also quote any args containing shell meta-characters. # Make two passes to allow for proper duplicate-argument suppression. ac_configure_args= ac_configure_args0= ac_configure_args1= ac_must_keep_next=false for ac_pass in 1 2 do for ac_arg do case $ac_arg in -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil) continue ;; *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;; esac case $ac_pass in 1) as_fn_append ac_configure_args0 " '$ac_arg'" ;; 2) as_fn_append ac_configure_args1 " '$ac_arg'" if test $ac_must_keep_next = true; then ac_must_keep_next=false # Got value, back to normal. else case $ac_arg in *=* | --config-cache | -C | -disable-* | --disable-* \ | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \ | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \ | -with-* | --with-* | -without-* | --without-* | --x) case "$ac_configure_args0 " in "$ac_configure_args1"*" '$ac_arg' "* ) continue ;; esac ;; -* ) ac_must_keep_next=true ;; esac fi as_fn_append ac_configure_args " '$ac_arg'" ;; esac done done { ac_configure_args0=; unset ac_configure_args0;} { ac_configure_args1=; unset ac_configure_args1;} # When interrupted or exit'd, cleanup temporary files, and complete # config.log. We remove comments because anyway the quotes in there # would cause problems or look ugly. # WARNING: Use '\'' to represent an apostrophe within the trap. # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug. trap 'exit_status=$? # Save into config.log some information that might help in debugging. { echo $as_echo "## ---------------- ## ## Cache variables. ## ## ---------------- ##" echo # The following way of writing the cache mishandles newlines in values, ( for ac_var in `(set) 2>&1 | sed -n '\''s/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'\''`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #( *${as_nl}ac_space=\ *) sed -n \ "s/'\''/'\''\\\\'\'''\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\''\\2'\''/p" ;; #( *) sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) echo $as_echo "## ----------------- ## ## Output variables. ## ## ----------------- ##" echo for ac_var in $ac_subst_vars do eval ac_val=\$$ac_var case $ac_val in *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac $as_echo "$ac_var='\''$ac_val'\''" done | sort echo if test -n "$ac_subst_files"; then $as_echo "## ------------------- ## ## File substitutions. ## ## ------------------- ##" echo for ac_var in $ac_subst_files do eval ac_val=\$$ac_var case $ac_val in *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;; esac $as_echo "$ac_var='\''$ac_val'\''" done | sort echo fi if test -s confdefs.h; then $as_echo "## ----------- ## ## confdefs.h. ## ## ----------- ##" echo cat confdefs.h echo fi test "$ac_signal" != 0 && $as_echo "$as_me: caught signal $ac_signal" $as_echo "$as_me: exit $exit_status" } >&5 rm -f core *.core core.conftest.* && rm -f -r conftest* confdefs* conf$$* $ac_clean_files && exit $exit_status ' 0 for ac_signal in 1 2 13 15; do trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal done ac_signal=0 # confdefs.h avoids OS command line length limits that DEFS can exceed. rm -f -r conftest* confdefs.h $as_echo "/* confdefs.h */" > confdefs.h # Predefined preprocessor variables. cat >>confdefs.h <<_ACEOF #define PACKAGE_NAME "$PACKAGE_NAME" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_TARNAME "$PACKAGE_TARNAME" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_VERSION "$PACKAGE_VERSION" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_STRING "$PACKAGE_STRING" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT" _ACEOF cat >>confdefs.h <<_ACEOF #define PACKAGE_URL "$PACKAGE_URL" _ACEOF # Let the site file select an alternate cache file if it wants to. # Prefer an explicitly selected file to automatically selected ones. ac_site_file1=NONE ac_site_file2=NONE if test -n "$CONFIG_SITE"; then # We do not want a PATH search for config.site. case $CONFIG_SITE in #(( -*) ac_site_file1=./$CONFIG_SITE;; */*) ac_site_file1=$CONFIG_SITE;; *) ac_site_file1=./$CONFIG_SITE;; esac elif test "x$prefix" != xNONE; then ac_site_file1=$prefix/share/config.site ac_site_file2=$prefix/etc/config.site else ac_site_file1=$ac_default_prefix/share/config.site ac_site_file2=$ac_default_prefix/etc/config.site fi for ac_site_file in "$ac_site_file1" "$ac_site_file2" do test "x$ac_site_file" = xNONE && continue if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5 $as_echo "$as_me: loading site script $ac_site_file" >&6;} sed 's/^/| /' "$ac_site_file" >&5 . "$ac_site_file" \ || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "failed to load site script $ac_site_file See \`config.log' for more details" "$LINENO" 5; } fi done if test -r "$cache_file"; then # Some versions of bash will fail to source /dev/null (special files # actually), so we avoid doing that. DJGPP emulates it as a regular file. if test /dev/null != "$cache_file" && test -f "$cache_file"; then { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5 $as_echo "$as_me: loading cache $cache_file" >&6;} case $cache_file in [\\/]* | ?:[\\/]* ) . "$cache_file";; *) . "./$cache_file";; esac fi else { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5 $as_echo "$as_me: creating cache $cache_file" >&6;} >$cache_file fi # Check that the precious variables saved in the cache have kept the same # value. ac_cache_corrupted=false for ac_var in $ac_precious_vars; do eval ac_old_set=\$ac_cv_env_${ac_var}_set eval ac_new_set=\$ac_env_${ac_var}_set eval ac_old_val=\$ac_cv_env_${ac_var}_value eval ac_new_val=\$ac_env_${ac_var}_value case $ac_old_set,$ac_new_set in set,) { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 $as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} ac_cache_corrupted=: ;; ,set) { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} ac_cache_corrupted=: ;; ,);; *) if test "x$ac_old_val" != "x$ac_new_val"; then # differences in whitespace do not lead to failure. ac_old_val_w=`echo x $ac_old_val` ac_new_val_w=`echo x $ac_new_val` if test "$ac_old_val_w" != "$ac_new_val_w"; then { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 $as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} ac_cache_corrupted=: else { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 $as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} eval $ac_var=\$ac_old_val fi { $as_echo "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 $as_echo "$as_me: former value: \`$ac_old_val'" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 $as_echo "$as_me: current value: \`$ac_new_val'" >&2;} fi;; esac # Pass precious variables to config.status. if test "$ac_new_set" = set; then case $ac_new_val in *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;; *) ac_arg=$ac_var=$ac_new_val ;; esac case " $ac_configure_args " in *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy. *) as_fn_append ac_configure_args " '$ac_arg'" ;; esac fi done if $ac_cache_corrupted; then { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;} as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5 fi ## -------------------- ## ## Main body of script. ## ## -------------------- ## ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu ac_aux_dir= for ac_dir in ../../cnf "$srcdir"/../../cnf; do if test -f "$ac_dir/install-sh"; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/install-sh -c" break elif test -f "$ac_dir/install.sh"; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/install.sh -c" break elif test -f "$ac_dir/shtool"; then ac_aux_dir=$ac_dir ac_install_sh="$ac_aux_dir/shtool install -c" break fi done if test -z "$ac_aux_dir"; then as_fn_error $? "cannot find install-sh, install.sh, or shtool in ../../cnf \"$srcdir\"/../../cnf" "$LINENO" 5 fi # These three variables are undocumented and unsupported, # and are intended to be withdrawn in a future Autoconf release. # They can cause serious problems if a builder's source tree is in a directory # whose full name contains unusual characters. ac_config_guess="$SHELL $ac_aux_dir/config.guess" # Please don't use this var. ac_config_sub="$SHELL $ac_aux_dir/config.sub" # Please don't use this var. ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. #if test "x$CFLAGS" = "x" ; then # CFLAGS=${COPTS} #fi ac_config_headers="$ac_config_headers config.h:../../cnf/config.hin" ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args. set dummy ${ac_tool_prefix}gcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$ac_cv_prog_CC"; then ac_ct_CC=$CC # Extract the first word of "gcc", so it can be a program name with args. set dummy gcc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="gcc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 $as_echo "$ac_ct_CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi else CC="$ac_cv_prog_CC" fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args. set dummy ${ac_tool_prefix}cc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_CC="${ac_tool_prefix}cc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi fi if test -z "$CC"; then # Extract the first word of "cc", so it can be a program name with args. set dummy cc; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else ac_prog_rejected=no as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then ac_prog_rejected=yes continue fi ac_cv_prog_CC="cc" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS if test $ac_prog_rejected = yes; then # We found a bogon in the path, so make sure we never use it. set dummy $ac_cv_prog_CC shift if test $# != 0; then # We chose a different compiler from the bogus one. # However, it has the same basename, so the bogon will be chosen # first if we set CC to just the basename; use the full file name. shift ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@" fi fi fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi fi if test -z "$CC"; then if test -n "$ac_tool_prefix"; then for ac_prog in cl.exe do # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args. set dummy $ac_tool_prefix$ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_CC="$ac_tool_prefix$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi CC=$ac_cv_prog_CC if test -n "$CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5 $as_echo "$CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$CC" && break done fi if test -z "$CC"; then ac_ct_CC=$CC for ac_prog in cl.exe do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_ac_ct_CC+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_ac_ct_CC="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5 $as_echo "$ac_ct_CC" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$ac_ct_CC" && break done if test "x$ac_ct_CC" = x; then CC="" else case $cross_compiling:$ac_tool_warned in yes:) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5 $as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;} ac_tool_warned=yes ;; esac CC=$ac_ct_CC fi fi fi test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "no acceptable C compiler found in \$PATH See \`config.log' for more details" "$LINENO" 5; } # Provide some information about the compiler. $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 set X $ac_compile ac_compiler=$2 for ac_option in --version -v -V -qversion; do { { ac_try="$ac_compiler $ac_option >&5" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compiler $ac_option >&5") 2>conftest.err ac_status=$? if test -s conftest.err; then sed '10a\ ... rest of stderr output deleted ... 10q' conftest.err >conftest.er1 cat conftest.er1 >&5 fi rm -f conftest.er1 conftest.err $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } done cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out" # Try to create an executable without -o first, disregard a.out. # It will help us diagnose broken compilers, and finding out an intuition # of exeext. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5 $as_echo_n "checking whether the C compiler works... " >&6; } ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'` # The possible output files: ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*" ac_rmfiles= for ac_file in $ac_files do case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; * ) ac_rmfiles="$ac_rmfiles $ac_file";; esac done rm -f $ac_rmfiles if { { ac_try="$ac_link_default" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link_default") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : # Autoconf-2.13 could set the ac_cv_exeext variable to `no'. # So ignore a value of `no', otherwise this would lead to `EXEEXT = no' # in a Makefile. We should not override ac_cv_exeext if it was cached, # so that the user can short-circuit this test for compilers unknown to # Autoconf. for ac_file in $ac_files '' do test -f "$ac_file" || continue case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; [ab].out ) # We found the default executable, but exeext='' is most # certainly right. break;; *.* ) if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no; then :; else ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` fi # We set ac_cv_exeext here because the later test for it is not # safe: cross compilers may not add the suffix if given an `-o' # argument, so we may need to know it at that point already. # Even if this section looks crufty: it has the advantage of # actually working. break;; * ) break;; esac done test "$ac_cv_exeext" = no && ac_cv_exeext= else ac_file='' fi if test -z "$ac_file"; then : { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error 77 "C compiler cannot create executables See \`config.log' for more details" "$LINENO" 5; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5 $as_echo "yes" >&6; } fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 $as_echo_n "checking for C compiler default output file name... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5 $as_echo "$ac_file" >&6; } ac_exeext=$ac_cv_exeext rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out ac_clean_files=$ac_clean_files_save { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5 $as_echo_n "checking for suffix of executables... " >&6; } if { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : # If both `conftest.exe' and `conftest' are `present' (well, observable) # catch `conftest.exe'. For instance with Cygwin, `ls conftest' will # work properly (i.e., refer to `conftest.exe'), while it won't with # `rm'. for ac_file in conftest.exe conftest conftest.*; do test -f "$ac_file" || continue case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;; *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` break;; * ) break;; esac done else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of executables: cannot compile and link See \`config.log' for more details" "$LINENO" 5; } fi rm -f conftest conftest$ac_cv_exeext { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 $as_echo "$ac_cv_exeext" >&6; } rm -f conftest.$ac_ext EXEEXT=$ac_cv_exeext ac_exeext=$EXEEXT cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { FILE *f = fopen ("conftest.out", "w"); return ferror (f) || fclose (f) != 0; ; return 0; } _ACEOF ac_clean_files="$ac_clean_files conftest.out" # Check that the compiler produces executables we can run. If not, either # the compiler is broken, or we cross compile. { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5 $as_echo_n "checking whether we are cross compiling... " >&6; } if test "$cross_compiling" != yes; then { { ac_try="$ac_link" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_link") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } if { ac_try='./conftest$ac_cv_exeext' { { case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_try") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; }; then cross_compiling=no else if test "$cross_compiling" = maybe; then cross_compiling=yes else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot run C compiled programs. If you meant to cross compile, use \`--host'. See \`config.log' for more details" "$LINENO" 5; } fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 $as_echo "$cross_compiling" >&6; } rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out ac_clean_files=$ac_clean_files_save { $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 $as_echo_n "checking for suffix of object files... " >&6; } if ${ac_cv_objext+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF rm -f conftest.o conftest.obj if { { ac_try="$ac_compile" case "(($ac_try" in *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; *) ac_try_echo=$ac_try;; esac eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" $as_echo "$ac_try_echo"; } >&5 (eval "$ac_compile") 2>&5 ac_status=$? $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; }; then : for ac_file in conftest.o conftest.obj conftest.*; do test -f "$ac_file" || continue; case $ac_file in *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;; *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'` break;; esac done else $as_echo "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of object files: cannot compile See \`config.log' for more details" "$LINENO" 5; } fi rm -f conftest.$ac_cv_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 $as_echo "$ac_cv_objext" >&6; } OBJEXT=$ac_cv_objext ac_objext=$OBJEXT { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5 $as_echo_n "checking whether we are using the GNU C compiler... " >&6; } if ${ac_cv_c_compiler_gnu+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { #ifndef __GNUC__ choke me #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_compiler_gnu=yes else ac_compiler_gnu=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_cv_c_compiler_gnu=$ac_compiler_gnu fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 $as_echo "$ac_cv_c_compiler_gnu" >&6; } if test $ac_compiler_gnu = yes; then GCC=yes else GCC= fi ac_test_CFLAGS=${CFLAGS+set} ac_save_CFLAGS=$CFLAGS { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5 $as_echo_n "checking whether $CC accepts -g... " >&6; } if ${ac_cv_prog_cc_g+:} false; then : $as_echo_n "(cached) " >&6 else ac_save_c_werror_flag=$ac_c_werror_flag ac_c_werror_flag=yes ac_cv_prog_cc_g=no CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_g=yes else CFLAGS="" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : else ac_c_werror_flag=$ac_save_c_werror_flag CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_g=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext ac_c_werror_flag=$ac_save_c_werror_flag fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 $as_echo "$ac_cv_prog_cc_g" >&6; } if test "$ac_test_CFLAGS" = set; then CFLAGS=$ac_save_CFLAGS elif test $ac_cv_prog_cc_g = yes; then if test "$GCC" = yes; then CFLAGS="-g -O2" else CFLAGS="-g" fi else if test "$GCC" = yes; then CFLAGS="-O2" else CFLAGS= fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5 $as_echo_n "checking for $CC option to accept ISO C89... " >&6; } if ${ac_cv_prog_cc_c89+:} false; then : $as_echo_n "(cached) " >&6 else ac_cv_prog_cc_c89=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include struct stat; /* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */ struct buf { int x; }; FILE * (*rcsopen) (struct buf *, struct stat *, int); static char *e (p, i) char **p; int i; { return p[i]; } static char *f (char * (*g) (char **, int), char **p, ...) { char *s; va_list v; va_start (v,p); s = g (p, va_arg (v,int)); va_end (v); return s; } /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has function prototypes and stuff, but not '\xHH' hex character constants. These don't provoke an error unfortunately, instead are silently treated as 'x'. The following induces an error, until -std is added to get proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an array size at least. It's necessary to write '\x00'==0 to get something that's true only with -std. */ int osf4_cc_array ['\x00' == 0 ? 1 : -1]; /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters inside strings and character constants. */ #define FOO(x) 'x' int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1]; int test (int i, double x); struct s1 {int (*f) (int a);}; struct s2 {int (*f) (double a);}; int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int); int argc; char **argv; int main () { return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]; ; return 0; } _ACEOF for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \ -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__" do CC="$ac_save_CC $ac_arg" if ac_fn_c_try_compile "$LINENO"; then : ac_cv_prog_cc_c89=$ac_arg fi rm -f core conftest.err conftest.$ac_objext test "x$ac_cv_prog_cc_c89" != "xno" && break done rm -f conftest.$ac_ext CC=$ac_save_CC fi # AC_CACHE_VAL case "x$ac_cv_prog_cc_c89" in x) { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 $as_echo "none needed" >&6; } ;; xno) { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 $as_echo "unsupported" >&6; } ;; *) CC="$CC $ac_cv_prog_cc_c89" { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 $as_echo "$ac_cv_prog_cc_c89" >&6; } ;; esac if test "x$ac_cv_prog_cc_c89" != xno; then : fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu { $as_echo "$as_me:${as_lineno-$LINENO}: checking for an ANSI C-conforming const" >&5 $as_echo_n "checking for an ANSI C-conforming const... " >&6; } if ${ac_cv_c_const+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int main () { #ifndef __cplusplus /* Ultrix mips cc rejects this sort of thing. */ typedef int charset[2]; const charset cs = { 0, 0 }; /* SunOS 4.1.1 cc rejects this. */ char const *const *pcpcc; char **ppc; /* NEC SVR4.0.2 mips cc rejects this. */ struct point {int x, y;}; static struct point const zero = {0,0}; /* AIX XL C 1.02.0.0 rejects this. It does not let you subtract one const X* pointer from another in an arm of an if-expression whose if-part is not a constant expression */ const char *g = "string"; pcpcc = &g + (g ? g-g : 0); /* HPUX 7.0 cc rejects these. */ ++pcpcc; ppc = (char**) pcpcc; pcpcc = (char const *const *) ppc; { /* SCO 3.2v4 cc rejects this sort of thing. */ char tx; char *t = &tx; char const *s = 0 ? (char *) 0 : (char const *) 0; *t++ = 0; if (s) return 0; } { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */ int x[] = {25, 17}; const int *foo = &x[0]; ++foo; } { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */ typedef const int *iptr; iptr p = 0; ++p; } { /* AIX XL C 1.02.0.0 rejects this sort of thing, saying "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */ struct s { int j; const int *ap[3]; } bx; struct s *b = &bx; b->j = 5; } { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */ const int foo = 10; if (!foo) return 0; } return !cs[0] && !zero.x; #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_c_const=yes else ac_cv_c_const=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const" >&5 $as_echo "$ac_cv_c_const" >&6; } if test $ac_cv_c_const = no; then $as_echo "#define const /**/" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for inline" >&5 $as_echo_n "checking for inline... " >&6; } if ${ac_cv_c_inline+:} false; then : $as_echo_n "(cached) " >&6 else ac_cv_c_inline=no for ac_kw in inline __inline__ __inline; do cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifndef __cplusplus typedef int foo_t; static $ac_kw foo_t static_foo () {return 0; } $ac_kw foo_t foo () {return 0; } #endif _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_c_inline=$ac_kw fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext test "$ac_cv_c_inline" != no && break done fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_inline" >&5 $as_echo "$ac_cv_c_inline" >&6; } case $ac_cv_c_inline in inline | yes) ;; *) case $ac_cv_c_inline in no) ac_val=;; *) ac_val=$ac_cv_c_inline;; esac cat >>confdefs.h <<_ACEOF #ifndef __cplusplus #define inline $ac_val #endif _ACEOF ;; esac ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 $as_echo_n "checking how to run the C preprocessor... " >&6; } # On Suns, sometimes $CPP names a directory. if test -n "$CPP" && test -d "$CPP"; then CPP= fi if test -z "$CPP"; then if ${ac_cv_prog_CPP+:} false; then : $as_echo_n "(cached) " >&6 else # Double quotes because CPP needs to be expanded for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp" do ac_preproc_ok=false for ac_c_preproc_warn_flag in '' yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. # Prefer to if __STDC__ is defined, since # exists even on freestanding compilers. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef __STDC__ # include #else # include #endif Syntax error _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : else # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext # OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : # Broken: success on invalid input. continue else # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext if $ac_preproc_ok; then : break fi done ac_cv_prog_CPP=$CPP fi CPP=$ac_cv_prog_CPP else ac_cv_prog_CPP=$CPP fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 $as_echo "$CPP" >&6; } ac_preproc_ok=false for ac_c_preproc_warn_flag in '' yes do # Use a header file that comes with gcc, so configuring glibc # with a fresh cross-compiler works. # Prefer to if __STDC__ is defined, since # exists even on freestanding compilers. # On the NeXT, cc -E runs the code through the compiler's parser, # not just through cpp. "Syntax error" is here to catch this case. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifdef __STDC__ # include #else # include #endif Syntax error _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : else # Broken: fails on valid input. continue fi rm -f conftest.err conftest.i conftest.$ac_ext # OK, works on sane cases. Now check whether nonexistent headers # can be detected and how. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if ac_fn_c_try_cpp "$LINENO"; then : # Broken: success on invalid input. continue else # Passes both tests. ac_preproc_ok=: break fi rm -f conftest.err conftest.i conftest.$ac_ext done # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. rm -f conftest.i conftest.err conftest.$ac_ext if $ac_preproc_ok; then : else { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "C preprocessor \"$CPP\" fails sanity check See \`config.log' for more details" "$LINENO" 5; } fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5 $as_echo_n "checking for grep that handles long lines and -e... " >&6; } if ${ac_cv_path_GREP+:} false; then : $as_echo_n "(cached) " >&6 else if test -z "$GREP"; then ac_path_GREP_found=false # Loop through the user's path and test for each of PROGNAME-LIST as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_prog in grep ggrep; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext" as_fn_executable_p "$ac_path_GREP" || continue # Check for GNU ac_path_GREP and select it if it is found. # Check for GNU $ac_path_GREP case `"$ac_path_GREP" --version 2>&1` in *GNU*) ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; *) ac_count=0 $as_echo_n 0123456789 >"conftest.in" while : do cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" $as_echo 'GREP' >> "conftest.nl" "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val if test $ac_count -gt ${ac_path_GREP_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_max=$ac_count fi # 10*(2^10) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out;; esac $ac_path_GREP_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_GREP"; then as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 fi else ac_cv_path_GREP=$GREP fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 $as_echo "$ac_cv_path_GREP" >&6; } GREP="$ac_cv_path_GREP" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 $as_echo_n "checking for egrep... " >&6; } if ${ac_cv_path_EGREP+:} false; then : $as_echo_n "(cached) " >&6 else if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 then ac_cv_path_EGREP="$GREP -E" else if test -z "$EGREP"; then ac_path_EGREP_found=false # Loop through the user's path and test for each of PROGNAME-LIST as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_prog in egrep; do for ac_exec_ext in '' $ac_executable_extensions; do ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext" as_fn_executable_p "$ac_path_EGREP" || continue # Check for GNU ac_path_EGREP and select it if it is found. # Check for GNU $ac_path_EGREP case `"$ac_path_EGREP" --version 2>&1` in *GNU*) ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; *) ac_count=0 $as_echo_n 0123456789 >"conftest.in" while : do cat "conftest.in" "conftest.in" >"conftest.tmp" mv "conftest.tmp" "conftest.in" cp "conftest.in" "conftest.nl" $as_echo 'EGREP' >> "conftest.nl" "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break as_fn_arith $ac_count + 1 && ac_count=$as_val if test $ac_count -gt ${ac_path_EGREP_max-0}; then # Best one so far, save it but keep looking for a better one ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_max=$ac_count fi # 10*(2^10) chars as input seems more than enough test $ac_count -gt 10 && break done rm -f conftest.in conftest.tmp conftest.nl conftest.out;; esac $ac_path_EGREP_found && break 3 done done done IFS=$as_save_IFS if test -z "$ac_cv_path_EGREP"; then as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 fi else ac_cv_path_EGREP=$EGREP fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 $as_echo "$ac_cv_path_EGREP" >&6; } EGREP="$ac_cv_path_EGREP" { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 $as_echo_n "checking for ANSI C header files... " >&6; } if ${ac_cv_header_stdc+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include #include int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_header_stdc=yes else ac_cv_header_stdc=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext if test $ac_cv_header_stdc = yes; then # SunOS 4.x string.h does not declare mem*, contrary to ANSI. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | $EGREP "memchr" >/dev/null 2>&1; then : else ac_cv_header_stdc=no fi rm -f conftest* fi if test $ac_cv_header_stdc = yes; then # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | $EGREP "free" >/dev/null 2>&1; then : else ac_cv_header_stdc=no fi rm -f conftest* fi if test $ac_cv_header_stdc = yes; then # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. if test "$cross_compiling" = yes; then : : else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if ((' ' & 0x0FF) == 0x020) # define ISLOWER(c) ('a' <= (c) && (c) <= 'z') # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) #else # define ISLOWER(c) \ (('a' <= (c) && (c) <= 'i') \ || ('j' <= (c) && (c) <= 'r') \ || ('s' <= (c) && (c) <= 'z')) # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) #endif #define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) int main () { int i; for (i = 0; i < 256; i++) if (XOR (islower (i), ISLOWER (i)) || toupper (i) != TOUPPER (i)) return 2; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : else ac_cv_header_stdc=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 $as_echo "$ac_cv_header_stdc" >&6; } if test $ac_cv_header_stdc = yes; then $as_echo "#define STDC_HEADERS 1" >>confdefs.h fi # On IRIX 5.3, sys/types and inttypes.h are conflicting. for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \ inttypes.h stdint.h unistd.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default " if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5 $as_echo_n "checking whether byte ordering is bigendian... " >&6; } if ${ac_cv_c_bigendian+:} false; then : $as_echo_n "(cached) " >&6 else ac_cv_c_bigendian=unknown # See if we're dealing with a universal compiler. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifndef __APPLE_CC__ not a universal capable compiler #endif typedef int dummy; _ACEOF if ac_fn_c_try_compile "$LINENO"; then : # Check for potential -arch flags. It is not universal unless # there are at least two -arch flags with different values. ac_arch= ac_prev= for ac_word in $CC $CFLAGS $CPPFLAGS $LDFLAGS; do if test -n "$ac_prev"; then case $ac_word in i?86 | x86_64 | ppc | ppc64) if test -z "$ac_arch" || test "$ac_arch" = "$ac_word"; then ac_arch=$ac_word else ac_cv_c_bigendian=universal break fi ;; esac ac_prev= elif test "x$ac_word" = "x-arch"; then ac_prev=arch fi done fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext if test $ac_cv_c_bigendian = unknown; then # See if sys/param.h defines the BYTE_ORDER macro. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include int main () { #if ! (defined BYTE_ORDER && defined BIG_ENDIAN \ && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \ && LITTLE_ENDIAN) bogus endian macros #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : # It does; now see whether it defined to BIG_ENDIAN or not. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include int main () { #if BYTE_ORDER != BIG_ENDIAN not big endian #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_c_bigendian=yes else ac_cv_c_bigendian=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi if test $ac_cv_c_bigendian = unknown; then # See if defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris). cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { #if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN) bogus endian macros #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : # It does; now see whether it defined to _BIG_ENDIAN or not. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { #ifndef _BIG_ENDIAN not big endian #endif ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_c_bigendian=yes else ac_cv_c_bigendian=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi if test $ac_cv_c_bigendian = unknown; then # Compile a test program. if test "$cross_compiling" = yes; then : # Try to guess by grepping values from an object file. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ short int ascii_mm[] = { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 }; short int ascii_ii[] = { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 }; int use_ascii (int i) { return ascii_mm[i] + ascii_ii[i]; } short int ebcdic_ii[] = { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 }; short int ebcdic_mm[] = { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 }; int use_ebcdic (int i) { return ebcdic_mm[i] + ebcdic_ii[i]; } extern int foo; int main () { return use_ascii (foo) == use_ebcdic (foo); ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then ac_cv_c_bigendian=yes fi if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then if test "$ac_cv_c_bigendian" = unknown; then ac_cv_c_bigendian=no else # finding both strings is unlikely to happen, but who knows? ac_cv_c_bigendian=unknown fi fi fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default int main () { /* Are we little or big endian? From Harbison&Steele. */ union { long int l; char c[sizeof (long int)]; } u; u.l = 1; return u.c[sizeof (long int) - 1] == 1; ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ac_cv_c_bigendian=no else ac_cv_c_bigendian=yes fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5 $as_echo "$ac_cv_c_bigendian" >&6; } case $ac_cv_c_bigendian in #( yes) $as_echo "#define WORDS_BIGENDIAN 1" >>confdefs.h ;; #( no) ;; #( universal) $as_echo "#define AC_APPLE_UNIVERSAL_BUILD 1" >>confdefs.h ;; #( *) as_fn_error $? "unknown endianness presetting ac_cv_c_bigendian=no (or yes) will help" "$LINENO" 5 ;; esac if ac_fn_c_compute_int "$LINENO" "(-1L >> 1)+1" "RIGHTSHIFTMINUSONE" ""; then : fi if test "$RIGHTSHIFTMINUSONE" = "0" ; then HAVE_ARITHRIGHTSHIFT=1 else HAVE_ARITHRIGHTSHIFT=0 fi cat >>confdefs.h <<_ACEOF #define HAVE_ARITHRIGHTSHIFT $HAVE_ARITHRIGHTSHIFT _ACEOF # # Assume that cross-compiling is for 32 bit systems # (alpha/NT will have to wait) # # The cast to long int works around a bug in the HP C Compiler # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects # declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'. # This bug is HP SR number 8606223364. { $as_echo "$as_me:${as_lineno-$LINENO}: checking size of void *" >&5 $as_echo_n "checking size of void *... " >&6; } if ${ac_cv_sizeof_void_p+:} false; then : $as_echo_n "(cached) " >&6 else if ac_fn_c_compute_int "$LINENO" "(long int) (sizeof (void *))" "ac_cv_sizeof_void_p" "$ac_includes_default"; then : else if test "$ac_cv_type_void_p" = yes; then { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error 77 "cannot compute sizeof (void *) See \`config.log' for more details" "$LINENO" 5; } else ac_cv_sizeof_void_p=0 fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_void_p" >&5 $as_echo "$ac_cv_sizeof_void_p" >&6; } cat >>confdefs.h <<_ACEOF #define SIZEOF_VOID_P $ac_cv_sizeof_void_p _ACEOF for ac_prog in nm do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5 $as_echo_n "checking for $ac_word... " >&6; } if ${ac_cv_prog_NM+:} false; then : $as_echo_n "(cached) " >&6 else if test -n "$NM"; then ac_cv_prog_NM="$NM" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. for ac_exec_ext in '' $ac_executable_extensions; do if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then ac_cv_prog_NM="$ac_prog" $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5 break 2 fi done done IFS=$as_save_IFS fi fi NM=$ac_cv_prog_NM if test -n "$NM"; then { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5 $as_echo "$NM" >&6; } else { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5 $as_echo "no" >&6; } fi test -n "$NM" && break done { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether symbols begin with an underscore" >&5 $as_echo_n "checking whether symbols begin with an underscore... " >&6; } if ${gp_cv_c_underscore_symbols+:} false; then : $as_echo_n "(cached) " >&6 else echo 'int foo() { return 0;}' > conftest.c ${CC-cc} -c conftest.c 2>&1 if test -z "$NM" ; then as_fn_error $? "cannot find \"nm\" " "$LINENO" 5 else if $NM conftest.o | grep _foo > /dev/null 2>&1 ; then gp_cv_c_underscore_symbols=yes else gp_cv_c_underscore_symbols=no fi fi rm -f conftest* fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gp_cv_c_underscore_symbols" >&5 $as_echo "$gp_cv_c_underscore_symbols" >&6; } if test "$gp_cv_c_underscore_symbols" = yes; then $as_echo "#define C_UNDERSCORE_SYMBOLS 1" >>confdefs.h fi # Make sure we can run config.sub. $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5 { $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5 $as_echo_n "checking build system type... " >&6; } if ${ac_cv_build+:} false; then : $as_echo_n "(cached) " >&6 else ac_build_alias=$build_alias test "x$ac_build_alias" = x && ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"` test "x$ac_build_alias" = x && as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5 ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` || as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5 fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 $as_echo "$ac_cv_build" >&6; } case $ac_cv_build in *-*-*) ;; *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;; esac build=$ac_cv_build ac_save_IFS=$IFS; IFS='-' set x $ac_cv_build shift build_cpu=$1 build_vendor=$2 shift; shift # Remember, the first character of IFS is used to create $*, # except with old shells: build_os=$* IFS=$ac_save_IFS case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5 $as_echo_n "checking host system type... " >&6; } if ${ac_cv_host+:} false; then : $as_echo_n "(cached) " >&6 else if test "x$host_alias" = x; then ac_cv_host=$ac_cv_build else ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` || as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5 fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 $as_echo "$ac_cv_host" >&6; } case $ac_cv_host in *-*-*) ;; *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;; esac host=$ac_cv_host ac_save_IFS=$IFS; IFS='-' set x $ac_cv_host shift host_cpu=$1 host_vendor=$2 shift; shift # Remember, the first character of IFS is used to create $*, # except with old shells: host_os=$* IFS=$ac_save_IFS case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac cat >>confdefs.h <<_ACEOF #define SYS_ARCH "$GAPARCH" _ACEOF { $as_echo "$as_me:${as_lineno-$LINENO}: checking unaligned access" >&5 $as_echo_n "checking unaligned access... " >&6; } if ${gp_cv_c_long_align+:} false; then : $as_echo_n "(cached) " >&6 else case "$host" in alpha* ) gp_cv_c_long_align=8;; mips-* | sparc-* ) gp_cv_c_long_align=$ac_cv_sizeof_void_p;; i586-* | i686-* ) gp_cv_c_long_align=2;; x86_64-* ) gp_cv_c_long_align=2;; * ) case "$host" in *OSF* | *osf* ) uac p sigbus;; esac ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu if test "$cross_compiling" = yes; then : { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot run test program while cross compiling See \`config.log' for more details" "$LINENO" 5; } else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ char buf[32];main(){long i= *(long*)(buf+1);buf[1]=(char)i;return 0;} _ACEOF if ac_fn_c_try_run "$LINENO"; then : gp_cv_c_long_align=1 else if test "$cross_compiling" = yes; then : { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot run test program while cross compiling See \`config.log' for more details" "$LINENO" 5; } else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ char buf[32];main(){long i= *(long*)(buf+2);buf[1]=(char)i;return 0;} _ACEOF if ac_fn_c_try_run "$LINENO"; then : gp_cv_c_long_align=2 else if test "$cross_compiling" = yes; then : { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot run test program while cross compiling See \`config.log' for more details" "$LINENO" 5; } else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ char buf[32];main(){long i= *(long*)(buf+4);buf[1]=(char)i;return 0;} _ACEOF if ac_fn_c_try_run "$LINENO"; then : gp_cv_c_long_align=4 else if test "$cross_compiling" = yes; then : { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;} as_fn_error $? "cannot run test program while cross compiling See \`config.log' for more details" "$LINENO" 5; } else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ char buf[32];main(){long i= *(long*)(buf+8);buf[1]=(char)i;return 0;} _ACEOF if ac_fn_c_try_run "$LINENO"; then : gp_cv_c_long_align=8 fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu rm -f core core.* *.core esac fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gp_cv_c_long_align" >&5 $as_echo "$gp_cv_c_long_align" >&6; } cat >>confdefs.h <<_ACEOF #define C_LONG_ALIGN $gp_cv_c_long_align _ACEOF { $as_echo "$as_me:${as_lineno-$LINENO}: checking C compiler default flags" >&5 $as_echo_n "checking C compiler default flags... " >&6; } if ${gp_cv_cflags+:} false; then : $as_echo_n "(cached) " >&6 else case "$host-$CC" in *-gcc* ) gp_cv_cflags="-Wall -g -O2 ${ABI_CFLAGS}";; *-clang* ) gp_cv_cflags="-Wall -g -O3 ${ABI_CFLAGS} -Wno-unused-value";; i686-*-egcs ) gp_cv_cflags="-Wall -g -O2 -mcpu=i686 ${ABI_CFLAGS}";; i586-*-egcs ) gp_cv_cflags="-Wall -g -O2 -mcpu=i586 ${ABI_CFLAGS}";; i486-*-egcs ) gp_cv_cflags="-Wall -g -O2 -mcpu=i486 ${ABI_CFLAGS}";; i386-*-egcs ) gp_cv_cflags="-Wall -g -O2 -mcpu=i386 ${ABI_CFLAGS}";; *-icc* ) gp_cv_cflags="-Wall -g -O2 ${ABI_CFLAGS}";; alphaev6-*-osf4*-cc ) gp_cv_cflags="-g3 -arch ev6 -O1 ";; alphaev56-*-osf4*-cc ) gp_cv_cflags="-g3 -arch ev56 -O1";; alphaev5-*-osf4*-cc ) gp_cv_cflags="-g3 -arch ev5 -O1";; alpha*-*-osf4*-cc ) gp_cv_cflags="-g3 -O1";; *aix*cc ) gp_cv_cflags="-g -O3";; *-solaris*-cc ) gp_cv_cflags="-fast -erroff=E_STATEMENT_NOT_REACHED";; *-irix*-cc ) gp_cv_cflags="-O3 -woff 1110,1167,1174,1552";; * ) gp_cv_cflags="-O";; esac fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gp_cv_cflags" >&5 $as_echo "$gp_cv_cflags" >&6; } CFLAGS="$CFLAGS $gp_cv_cflags" { $as_echo "$as_me:${as_lineno-$LINENO}: checking Linker default flags" >&5 $as_echo_n "checking Linker default flags... " >&6; } if ${gp_cv_ldflags+:} false; then : $as_echo_n "(cached) " >&6 else case "$host-$CC" in *-apple-darwin11*-gcc* ) gp_cv_ldflags="-g -Wl,-no_pie ${ABI_CFLAGS}";; *-apple-darwin12*-gcc* ) gp_cv_ldflags="-g -Wl,-no_pie ${ABI_CFLAGS}";; *-apple-darwin1*-mpicc* ) gp_cv_ldflags="-g -Wl,-no_pie ${ABI_CFLAGS}";; *-gcc* | *-egcs ) gp_cv_ldflags="-g ${ABI_CFLAGS}";; *-apple-darwin*-clang* ) gp_cv_ldflags="-g -Wl,-no_pie ${ABI_CFLAGS}";; *-clang* ) gp_cv_ldflags="-g -rdynamic ${ABI_CFLAGS}";; *-icc* ) gp_cv_ldflags="-g -rdynamic -static-libgcc -static-intel ${ABI_CFLAGS}";; alpha*-*-osf4*-cc ) gp_cv_ldflags="-g3 ";; *-solaris*-cc ) gp_cv_ldflags="";; *aix*cc ) gp_cv_ldflags="-g";; *-irix*-cc ) gp_cv_ldflags="-O3";; * ) gp_cv_ldflags="";; esac fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gp_cv_ldflags" >&5 $as_echo "$gp_cv_ldflags" >&6; } LDFLAGS="$LDFLAGS $gp_cv_ldflags" { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic module compile options" >&5 $as_echo_n "checking dynamic module compile options... " >&6; } if ${gp_cv_prog_cc_cdynoptions+:} false; then : $as_echo_n "(cached) " >&6 else case "$host-$CC" in i686-pc-cygwin-gcc* ) gp_cv_prog_cc_cdynoptions="${ABI_CFLAGS}";; *-apple-darwin*gcc* ) gp_cv_prog_cc_cdynoptions="-fPIC -Wall ${ABI_CFLAGS}";; *-hpux-gcc ) gp_cv_prog_cc_cdynoptions="-fpic -Wall ${ABI_CFLAGS}";; *-gcc* | *-egcs ) gp_cv_prog_cc_cdynoptions="-fpic -Wall -O2 ${ABI_CFLAGS}";; *-clang* ) gp_cv_prog_cc_cdynoptions="-fPIC -Wall ${ABI_CFLAGS} -Wno-unused-value";; *-icc* ) gp_cv_prog_cc_cdynoptions="-fpic -Wall -O2 ${ABI_CFLAGS}";; *-next-nextstep-cc ) gp_cv_prog_cc_cdynoptions=" -Wall -O2 -arch $hostcpu";; *-osf*-cc ) gp_cv_prog_cc_cdynoptions=" -shared -x -O2";; *-irix* ) gp_cv_prog_cc_cdynoptions=" -O3 -woff 1110,1167,1174,1552";; * ) gp_cv_prog_cc_cdynoptions="-fpic -O2 ${ABI_CFLAGS}";; esac fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gp_cv_prog_cc_cdynoptions" >&5 $as_echo "$gp_cv_prog_cc_cdynoptions" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker" >&5 $as_echo_n "checking dynamic linker... " >&6; } if ${gp_cv_prog_cc_cdynlinker+:} false; then : $as_echo_n "(cached) " >&6 else case "$host-$CC" in i686-pc-cygwin-gcc* ) gp_cv_prog_cc_cdynlinker="${CC}";; *-apple-darwin*gcc* ) gp_cv_prog_cc_cdynlinker="${CC}";; *-gcc* ) gp_cv_prog_cc_cdynlinker="${CC}";; *-clang* ) gp_cv_prog_cc_cdynlinker="${CC}";; *-egcs ) gp_cv_prog_cc_cdynlinker="${CC}";; *-icc* ) gp_cv_prog_cc_cdynlinker="${CC}";; *-next-nextstep-cc ) gp_cv_prog_cc_cdynlinker="cc";; *-osf*-cc ) gp_cv_prog_cc_cdynlinker="cc";; *-irix* ) gp_cv_prog_cc_cdynlinker="ld";; * ) gp_cv_prog_cc_cdynlinker="${CC}";; esac fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gp_cv_prog_cc_cdynlinker" >&5 $as_echo "$gp_cv_prog_cc_cdynlinker" >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic module link flags" >&5 $as_echo_n "checking dynamic module link flags... " >&6; } if ${gp_cv_prog_cc_cdynlinking+:} false; then : $as_echo_n "(cached) " >&6 else case "$host-$CC" in *-apple-darwin*gcc* ) gp_cv_prog_cc_cdynlinking='-g -bundle -bundle_loader ${gap_bin}/gap -lc -lm'" ${ABI_CFLAGS}";; i686-pc-cygwin-gcc* ) gp_cv_prog_cc_cdynlinking='-shared ${gap_bin}/gap.dll';; *-gcc ) gp_cv_prog_cc_cdynlinking="-shared -g ${ABI_CFLAGS}";; *-apple-darwin*clang ) gp_cv_prog_cc_cdynlinking='-bundle -g -bundle_loader ${gap_bin}/gap'" ${ABI_CFLAGS}";; *-clang ) gp_cv_prog_cc_cdynlinking="-shared -g ${ABI_CFLAGS}";; *-icc ) gp_cv_prog_cc_cdynlinking="-shared -g ${ABI_CFLAGS}";; *-egcs ) gp_cv_prog_cc_cdynlinking="-shared -g ${ABI_CFLAGS}";; *hpux* ) gp_cv_prog_cc_cdynlinking="-b +e Init__Dynamic";; alpha*osf4*-cc ) gp_cv_prog_cc_cdynlinking="-shared -g3";; alpha*osf*cc ) gp_cv_prog_cc_cdynlinking="-shared";; *osf*cc ) gp_cv_prog_cc_cdynlinking="-shared -r";; *-irix* ) gp_cv_prog_cc_cdynlinking="-shared -O3";; *-nextstep*cc ) gp_cv_prog_cc_cdynlinking="-arch $hostcpu -Xlinker -r -Xlinker -x -nostdlib";; *solaris* ) gp_cv_prog_cc_cdynlinking="-G -Bdynamic";; *sunos* ) gp_cv_prog_cc_cdynlinking="-assert pure-text -Bdynamic -x";; * ) gp_cv_prog_cc_cdynlinking="-shared -g ${ABI_CFLAGS}";; esac fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gp_cv_prog_cc_cdynlinking" >&5 $as_echo "$gp_cv_prog_cc_cdynlinking" >&6; } CDYNOPTIONS=$gp_cv_prog_cc_cdynoptions CDYNLINKER=$gp_cv_prog_cc_cdynlinker CDYNLINKING=$gp_cv_prog_cc_cdynlinking { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5 $as_echo_n "checking for ANSI C header files... " >&6; } if ${ac_cv_header_stdc+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #include #include int main () { ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_header_stdc=yes else ac_cv_header_stdc=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext if test $ac_cv_header_stdc = yes; then # SunOS 4.x string.h does not declare mem*, contrary to ANSI. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | $EGREP "memchr" >/dev/null 2>&1; then : else ac_cv_header_stdc=no fi rm -f conftest* fi if test $ac_cv_header_stdc = yes; then # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI. cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include _ACEOF if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | $EGREP "free" >/dev/null 2>&1; then : else ac_cv_header_stdc=no fi rm -f conftest* fi if test $ac_cv_header_stdc = yes; then # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi. if test "$cross_compiling" = yes; then : : else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if ((' ' & 0x0FF) == 0x020) # define ISLOWER(c) ('a' <= (c) && (c) <= 'z') # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c)) #else # define ISLOWER(c) \ (('a' <= (c) && (c) <= 'i') \ || ('j' <= (c) && (c) <= 'r') \ || ('s' <= (c) && (c) <= 'z')) # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c)) #endif #define XOR(e, f) (((e) && !(f)) || (!(e) && (f))) int main () { int i; for (i = 0; i < 256; i++) if (XOR (islower (i), ISLOWER (i)) || toupper (i) != TOUPPER (i)) return 2; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : else ac_cv_header_stdc=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5 $as_echo "$ac_cv_header_stdc" >&6; } if test $ac_cv_header_stdc = yes; then $as_echo "#define STDC_HEADERS 1" >>confdefs.h fi for ac_header in assert.h errno.h math.h stdio.h stdlib.h string.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done for ac_header in termios.h termio.h sgtty.h signal.h unistd.h sys/stat.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done for ac_header in fcntl.h sys/ioctl.h sys/time.h sys/types.h sys/sysmacros.h sys/resource.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done ac_fn_c_find_intX_t "$LINENO" "8" "ac_cv_c_int8_t" case $ac_cv_c_int8_t in #( no|yes) ;; #( *) cat >>confdefs.h <<_ACEOF #define int8_t $ac_cv_c_int8_t _ACEOF ;; esac ac_fn_c_find_intX_t "$LINENO" "16" "ac_cv_c_int16_t" case $ac_cv_c_int16_t in #( no|yes) ;; #( *) cat >>confdefs.h <<_ACEOF #define int16_t $ac_cv_c_int16_t _ACEOF ;; esac ac_fn_c_find_intX_t "$LINENO" "32" "ac_cv_c_int32_t" case $ac_cv_c_int32_t in #( no|yes) ;; #( *) cat >>confdefs.h <<_ACEOF #define int32_t $ac_cv_c_int32_t _ACEOF ;; esac ac_fn_c_find_intX_t "$LINENO" "64" "ac_cv_c_int64_t" case $ac_cv_c_int64_t in #( no|yes) ;; #( *) cat >>confdefs.h <<_ACEOF #define int64_t $ac_cv_c_int64_t _ACEOF ;; esac ac_fn_c_find_uintX_t "$LINENO" "8" "ac_cv_c_uint8_t" case $ac_cv_c_uint8_t in #( no|yes) ;; #( *) $as_echo "#define _UINT8_T 1" >>confdefs.h cat >>confdefs.h <<_ACEOF #define uint8_t $ac_cv_c_uint8_t _ACEOF ;; esac ac_fn_c_find_uintX_t "$LINENO" "16" "ac_cv_c_uint16_t" case $ac_cv_c_uint16_t in #( no|yes) ;; #( *) cat >>confdefs.h <<_ACEOF #define uint16_t $ac_cv_c_uint16_t _ACEOF ;; esac ac_fn_c_find_uintX_t "$LINENO" "32" "ac_cv_c_uint32_t" case $ac_cv_c_uint32_t in #( no|yes) ;; #( *) $as_echo "#define _UINT32_T 1" >>confdefs.h cat >>confdefs.h <<_ACEOF #define uint32_t $ac_cv_c_uint32_t _ACEOF ;; esac ac_fn_c_find_uintX_t "$LINENO" "64" "ac_cv_c_uint64_t" case $ac_cv_c_uint64_t in #( no|yes) ;; #( *) $as_echo "#define _UINT64_T 1" >>confdefs.h cat >>confdefs.h <<_ACEOF #define uint64_t $ac_cv_c_uint64_t _ACEOF ;; esac # Check for POSIX 98 pty APIs for ac_func in ptsname grantpt unlockpt posix_openpt do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done # Check for glibc specific pty APIs for ac_func in getpt ptsname_r do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done # Check for some legacy APIs for ac_func in getpseudotty _getpty do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done # openpty() is available on various BSD variants, but also in glibc. # On BSD systems, one usually needs to add -lutil to LIBS in order # to use it. for ac_header in util.h pty.h libutil.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing openpty" >&5 $as_echo_n "checking for library containing openpty... " >&6; } if ${ac_cv_search_openpty+:} false; then : $as_echo_n "(cached) " >&6 else ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char openpty (); int main () { return openpty (); ; return 0; } _ACEOF for ac_lib in '' util; do if test -z "$ac_lib"; then ac_res="none required" else ac_res=-l$ac_lib LIBS="-l$ac_lib $ac_func_search_save_LIBS" fi if ac_fn_c_try_link "$LINENO"; then : ac_cv_search_openpty=$ac_res fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext if ${ac_cv_search_openpty+:} false; then : break fi done if ${ac_cv_search_openpty+:} false; then : else ac_cv_search_openpty=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_openpty" >&5 $as_echo "$ac_cv_search_openpty" >&6; } ac_res=$ac_cv_search_openpty if test "$ac_res" != no; then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" $as_echo "#define HAVE_OPENPTY 1" >>confdefs.h fi for ac_func in setpgid do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done for ac_func in rld_load do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing dlopen" >&5 $as_echo_n "checking for library containing dlopen... " >&6; } if ${ac_cv_search_dlopen+:} false; then : $as_echo_n "(cached) " >&6 else ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char dlopen (); int main () { return dlopen (); ; return 0; } _ACEOF for ac_lib in '' dl; do if test -z "$ac_lib"; then ac_res="none required" else ac_res=-l$ac_lib LIBS="-l$ac_lib $ac_func_search_save_LIBS" fi if ac_fn_c_try_link "$LINENO"; then : ac_cv_search_dlopen=$ac_res fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext if ${ac_cv_search_dlopen+:} false; then : break fi done if ${ac_cv_search_dlopen+:} false; then : else ac_cv_search_dlopen=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_dlopen" >&5 $as_echo "$ac_cv_search_dlopen" >&6; } ac_res=$ac_cv_search_dlopen if test "$ac_res" != no; then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" $as_echo "#define HAVE_DLOPEN 1" >>confdefs.h fi if test "$ac_cv_search_dlopen" != "no"; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${CC-cc} accepts -export-dynamic" >&5 $as_echo_n "checking whether ${CC-cc} accepts -export-dynamic... " >&6; } if ${gp_cv_prog_cc_export_dynamic+:} false; then : $as_echo_n "(cached) " >&6 else echo 'int main(){}' > conftest.c if test -z "`${CC-cc} -export-dynamic -o conftest conftest.c 2>&1`"; then gp_cv_prog_cc_export_dynamic=yes else gp_cv_prog_cc_export_dynamic=no fi rm -f conftest* fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gp_cv_prog_cc_export_dynamic" >&5 $as_echo "$gp_cv_prog_cc_export_dynamic" >&6; } if test "$gp_cv_prog_cc_export_dynamic" = yes; then LDFLAGS="$LDFLAGS -export-dynamic" fi fi case "$LIBS" in *-ldl* ) C_DYNLIBS="-ldl" ;; *) C_DYNLIBS="" ;; esac; for ac_header in sys/times.h sys/param.h do : as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh` ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default" if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1 _ACEOF fi done for ac_func in times getrusage do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done for ac_func in memcpy memmove memset do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done for ac_func in vm_allocate sbrk madvise sysconf do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done for ac_func in atol strlcpy strlcmp do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sys/wait.h that is POSIX.1 compatible" >&5 $as_echo_n "checking for sys/wait.h that is POSIX.1 compatible... " >&6; } if ${ac_cv_header_sys_wait_h+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #ifndef WEXITSTATUS # define WEXITSTATUS(stat_val) ((unsigned int) (stat_val) >> 8) #endif #ifndef WIFEXITED # define WIFEXITED(stat_val) (((stat_val) & 255) == 0) #endif int main () { int s; wait (&s); s = WIFEXITED (s) ? WEXITSTATUS (s) : 1; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_header_sys_wait_h=yes else ac_cv_header_sys_wait_h=no fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_sys_wait_h" >&5 $as_echo "$ac_cv_header_sys_wait_h" >&6; } if test $ac_cv_header_sys_wait_h = yes; then $as_echo "#define HAVE_SYS_WAIT_H 1" >>confdefs.h fi ac_fn_c_check_type "$LINENO" "pid_t" "ac_cv_type_pid_t" "$ac_includes_default" if test "x$ac_cv_type_pid_t" = xyes; then : else cat >>confdefs.h <<_ACEOF #define pid_t int _ACEOF fi for ac_header in vfork.h do : ac_fn_c_check_header_mongrel "$LINENO" "vfork.h" "ac_cv_header_vfork_h" "$ac_includes_default" if test "x$ac_cv_header_vfork_h" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_VFORK_H 1 _ACEOF fi done for ac_func in fork vfork do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done if test "x$ac_cv_func_fork" = xyes; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working fork" >&5 $as_echo_n "checking for working fork... " >&6; } if ${ac_cv_func_fork_works+:} false; then : $as_echo_n "(cached) " >&6 else if test "$cross_compiling" = yes; then : ac_cv_func_fork_works=cross else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default int main () { /* By Ruediger Kuhlmann. */ return fork () < 0; ; return 0; } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ac_cv_func_fork_works=yes else ac_cv_func_fork_works=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_fork_works" >&5 $as_echo "$ac_cv_func_fork_works" >&6; } else ac_cv_func_fork_works=$ac_cv_func_fork fi if test "x$ac_cv_func_fork_works" = xcross; then case $host in *-*-amigaos* | *-*-msdosdjgpp*) # Override, as these systems have only a dummy fork() stub ac_cv_func_fork_works=no ;; *) ac_cv_func_fork_works=yes ;; esac { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: result $ac_cv_func_fork_works guessed because of cross compilation" >&5 $as_echo "$as_me: WARNING: result $ac_cv_func_fork_works guessed because of cross compilation" >&2;} fi ac_cv_func_vfork_works=$ac_cv_func_vfork if test "x$ac_cv_func_vfork" = xyes; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for working vfork" >&5 $as_echo_n "checking for working vfork... " >&6; } if ${ac_cv_func_vfork_works+:} false; then : $as_echo_n "(cached) " >&6 else if test "$cross_compiling" = yes; then : ac_cv_func_vfork_works=cross else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Thanks to Paul Eggert for this test. */ $ac_includes_default #include #ifdef HAVE_VFORK_H # include #endif /* On some sparc systems, changes by the child to local and incoming argument registers are propagated back to the parent. The compiler is told about this with #include , but some compilers (e.g. gcc -O) don't grok . Test for this by using a static variable whose address is put into a register that is clobbered by the vfork. */ static void #ifdef __cplusplus sparc_address_test (int arg) # else sparc_address_test (arg) int arg; #endif { static pid_t child; if (!child) { child = vfork (); if (child < 0) { perror ("vfork"); _exit(2); } if (!child) { arg = getpid(); write(-1, "", 0); _exit (arg); } } } int main () { pid_t parent = getpid (); pid_t child; sparc_address_test (0); child = vfork (); if (child == 0) { /* Here is another test for sparc vfork register problems. This test uses lots of local variables, at least as many local variables as main has allocated so far including compiler temporaries. 4 locals are enough for gcc 1.40.3 on a Solaris 4.1.3 sparc, but we use 8 to be safe. A buggy compiler should reuse the register of parent for one of the local variables, since it will think that parent can't possibly be used any more in this routine. Assigning to the local variable will thus munge parent in the parent process. */ pid_t p = getpid(), p1 = getpid(), p2 = getpid(), p3 = getpid(), p4 = getpid(), p5 = getpid(), p6 = getpid(), p7 = getpid(); /* Convince the compiler that p..p7 are live; otherwise, it might use the same hardware register for all 8 local variables. */ if (p != p1 || p != p2 || p != p3 || p != p4 || p != p5 || p != p6 || p != p7) _exit(1); /* On some systems (e.g. IRIX 3.3), vfork doesn't separate parent from child file descriptors. If the child closes a descriptor before it execs or exits, this munges the parent's descriptor as well. Test for this by closing stdout in the child. */ _exit(close(fileno(stdout)) != 0); } else { int status; struct stat st; while (wait(&status) != child) ; return ( /* Was there some problem with vforking? */ child < 0 /* Did the child fail? (This shouldn't happen.) */ || status /* Did the vfork/compiler bug occur? */ || parent != getpid() /* Did the file descriptor bug occur? */ || fstat(fileno(stdout), &st) != 0 ); } } _ACEOF if ac_fn_c_try_run "$LINENO"; then : ac_cv_func_vfork_works=yes else ac_cv_func_vfork_works=no fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ conftest.$ac_objext conftest.beam conftest.$ac_ext fi fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_vfork_works" >&5 $as_echo "$ac_cv_func_vfork_works" >&6; } fi; if test "x$ac_cv_func_fork_works" = xcross; then ac_cv_func_vfork_works=$ac_cv_func_vfork { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: result $ac_cv_func_vfork_works guessed because of cross compilation" >&5 $as_echo "$as_me: WARNING: result $ac_cv_func_vfork_works guessed because of cross compilation" >&2;} fi if test "x$ac_cv_func_vfork_works" = xyes; then $as_echo "#define HAVE_WORKING_VFORK 1" >>confdefs.h else $as_echo "#define vfork fork" >>confdefs.h fi if test "x$ac_cv_func_fork_works" = xyes; then $as_echo "#define HAVE_WORKING_FORK 1" >>confdefs.h fi for ac_func in popen waitpid wait4 do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done { $as_echo "$as_me:${as_lineno-$LINENO}: checking for old non-posix union wait" >&5 $as_echo_n "checking for old non-posix union wait... " >&6; } { $as_echo "$as_me:${as_lineno-$LINENO}: checking union wait" >&5 $as_echo_n "checking union wait... " >&6; } if ${gp_cv_c_union_wait+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include int main () { int a; int status; waitpid( (pid_t)-1, & status, 0); a = WIFSIGNALED(status); a = WEXITSTATUS(status); ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : gp_cv_c_union_wait=0 else gp_cv_c_union_wait=1 fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gp_cv_c_union_wait" >&5 $as_echo "$gp_cv_c_union_wait" >&6; } for ac_func in signal do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done for ac_func in ttyname strerror select do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sys_errlist" >&5 $as_echo_n "checking for sys_errlist... " >&6; } if ${gp_cv_var_sys_errlist+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int *p; int main () { extern int sys_errlist; p = &sys_errlist; ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : gp_cv_var_sys_errlist=yes else gp_cv_var_sys_errlist=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $gp_cv_var_sys_errlist" >&5 $as_echo "$gp_cv_var_sys_errlist" >&6; } if test x"$gp_cv_var_sys_errlist" = xyes; then $as_echo "#define HAVE_SYS_ERRLIST 1" >>confdefs.h fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stat file-mode macros are broken" >&5 $as_echo_n "checking whether stat file-mode macros are broken... " >&6; } if ${ac_cv_header_stat_broken+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include #if defined S_ISBLK && defined S_IFDIR extern char c1[S_ISBLK (S_IFDIR) ? -1 : 1]; #endif #if defined S_ISBLK && defined S_IFCHR extern char c2[S_ISBLK (S_IFCHR) ? -1 : 1]; #endif #if defined S_ISLNK && defined S_IFREG extern char c3[S_ISLNK (S_IFREG) ? -1 : 1]; #endif #if defined S_ISSOCK && defined S_IFREG extern char c4[S_ISSOCK (S_IFREG) ? -1 : 1]; #endif _ACEOF if ac_fn_c_try_compile "$LINENO"; then : ac_cv_header_stat_broken=no else ac_cv_header_stat_broken=yes fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stat_broken" >&5 $as_echo "$ac_cv_header_stat_broken" >&6; } if test $ac_cv_header_stat_broken = yes; then $as_echo "#define STAT_MACROS_BROKEN 1" >>confdefs.h fi for ac_func in access stat fstat lstat unlink mkdir rmdir mkdtemp mkstemp link rename chmod dup dup2 realpath do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done for ac_func in socket accept connect bind send do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done ac_header_dirent=no for ac_hdr in dirent.h sys/ndir.h sys/dir.h ndir.h; do as_ac_Header=`$as_echo "ac_cv_header_dirent_$ac_hdr" | $as_tr_sh` { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_hdr that defines DIR" >&5 $as_echo_n "checking for $ac_hdr that defines DIR... " >&6; } if eval \${$as_ac_Header+:} false; then : $as_echo_n "(cached) " >&6 else cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include <$ac_hdr> int main () { if ((DIR *) 0) return 0; ; return 0; } _ACEOF if ac_fn_c_try_compile "$LINENO"; then : eval "$as_ac_Header=yes" else eval "$as_ac_Header=no" fi rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext fi eval ac_res=\$$as_ac_Header { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 $as_echo "$ac_res" >&6; } if eval test \"x\$"$as_ac_Header"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_hdr" | $as_tr_cpp` 1 _ACEOF ac_header_dirent=$ac_hdr; break fi done # Two versions of opendir et al. are in -ldir and -lx on SCO Xenix. if test $ac_header_dirent = dirent.h; then { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing opendir" >&5 $as_echo_n "checking for library containing opendir... " >&6; } if ${ac_cv_search_opendir+:} false; then : $as_echo_n "(cached) " >&6 else ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char opendir (); int main () { return opendir (); ; return 0; } _ACEOF for ac_lib in '' dir; do if test -z "$ac_lib"; then ac_res="none required" else ac_res=-l$ac_lib LIBS="-l$ac_lib $ac_func_search_save_LIBS" fi if ac_fn_c_try_link "$LINENO"; then : ac_cv_search_opendir=$ac_res fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext if ${ac_cv_search_opendir+:} false; then : break fi done if ${ac_cv_search_opendir+:} false; then : else ac_cv_search_opendir=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_opendir" >&5 $as_echo "$ac_cv_search_opendir" >&6; } ac_res=$ac_cv_search_opendir if test "$ac_res" != no; then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" fi else { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing opendir" >&5 $as_echo_n "checking for library containing opendir... " >&6; } if ${ac_cv_search_opendir+:} false; then : $as_echo_n "(cached) " >&6 else ac_func_search_save_LIBS=$LIBS cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char opendir (); int main () { return opendir (); ; return 0; } _ACEOF for ac_lib in '' x; do if test -z "$ac_lib"; then ac_res="none required" else ac_res=-l$ac_lib LIBS="-l$ac_lib $ac_func_search_save_LIBS" fi if ac_fn_c_try_link "$LINENO"; then : ac_cv_search_opendir=$ac_res fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext if ${ac_cv_search_opendir+:} false; then : break fi done if ${ac_cv_search_opendir+:} false; then : else ac_cv_search_opendir=no fi rm conftest.$ac_ext LIBS=$ac_func_search_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_search_opendir" >&5 $as_echo "$ac_cv_search_opendir" >&6; } ac_res=$ac_cv_search_opendir if test "$ac_res" != no; then : test "$ac_res" = "none required" || LIBS="$ac_res $LIBS" fi fi for ac_func in opendir closedir readdir do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done for ac_func in log2 log10 log1p exp2 expm1 exp10 trunc do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done # Check whether --with-readline was given. if test "${with_readline+set}" = set; then : withval=$with_readline; fi # TODO: Currently, if the user requests building against readline # explicitly, and this fails for some reason, we simply silently # go on without it. Maybe we should produce an error instead? # TODO: Actually, we should be using CPPFLAGS instead of CFLAGS gap_save_CFLAGS="$CFLAGS" gap_save_LDFLAGS="$LDFLAGS" if test "x$with_readline" != xno; then # Readline support not disabled if test "x$with_readline" != x; then if test "x$with_readline" != xyes; then # Use custom prefix for readline, if the paths are present if test -d ${with_readline}/include && test -d ${with_readline}/lib; then CFLAGS="$CFLAGS -I${with_readline}/include" LDFLAGS="$LDFLAGS -L${with_readline}/lib" # TODO: We could produce an error here, after all, the user specified an # invalid path prefix. fi fi fi # TODO: Should also check for headers { $as_echo "$as_me:${as_lineno-$LINENO}: checking for initscr in -lncurses" >&5 $as_echo_n "checking for initscr in -lncurses... " >&6; } if ${ac_cv_lib_ncurses_initscr+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lncurses $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char initscr (); int main () { return initscr (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_ncurses_initscr=yes else ac_cv_lib_ncurses_initscr=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ncurses_initscr" >&5 $as_echo "$ac_cv_lib_ncurses_initscr" >&6; } if test "x$ac_cv_lib_ncurses_initscr" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_LIBNCURSES 1 _ACEOF LIBS="-lncurses $LIBS" fi { $as_echo "$as_me:${as_lineno-$LINENO}: checking for rl_gnu_readline_p in -lreadline" >&5 $as_echo_n "checking for rl_gnu_readline_p in -lreadline... " >&6; } if ${ac_cv_lib_readline_rl_gnu_readline_p+:} false; then : $as_echo_n "(cached) " >&6 else ac_check_lib_save_LIBS=$LIBS LIBS="-lreadline -lncurses $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC builtin and then its argument prototype would still apply. */ #ifdef __cplusplus extern "C" #endif char rl_gnu_readline_p (); int main () { return rl_gnu_readline_p (); ; return 0; } _ACEOF if ac_fn_c_try_link "$LINENO"; then : ac_cv_lib_readline_rl_gnu_readline_p=yes else ac_cv_lib_readline_rl_gnu_readline_p=no fi rm -f core conftest.err conftest.$ac_objext \ conftest$ac_exeext conftest.$ac_ext LIBS=$ac_check_lib_save_LIBS fi { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_readline_rl_gnu_readline_p" >&5 $as_echo "$ac_cv_lib_readline_rl_gnu_readline_p" >&6; } if test "x$ac_cv_lib_readline_rl_gnu_readline_p" = xyes; then : cat >>confdefs.h <<_ACEOF #define HAVE_LIBREADLINE 1 _ACEOF LIBS="-lreadline $LIBS" else with_readline=no fi fi if test "x$with_readline" = xno; then # Readline support disabled CFLAGS="$gap_save_CFLAGS" LDFLAGS="$gap_save_LDFLAGS" fi; if test "x$USE_GMP" = "xyes" ; then $as_echo "#define USE_GMP 1" >>confdefs.h fi for ac_func in _setjmp sigsetjmp do : as_ac_var=`$as_echo "ac_cv_func_$ac_func" | $as_tr_sh` ac_fn_c_check_func "$LINENO" "$ac_func" "$as_ac_var" if eval test \"x\$"$as_ac_var"\" = x"yes"; then : cat >>confdefs.h <<_ACEOF #define `$as_echo "HAVE_$ac_func" | $as_tr_cpp` 1 _ACEOF fi done case "$host" in i386-*-* | i486-*-* | i586-*-* | i686-*-*) gp_cv_c_long_align=2 ;; esac cat >>confdefs.h <<_ACEOF #define C_STACK_ALIGN $gp_cv_c_long_align _ACEOF case "$host" in sparc-* ) $as_echo "#define SPARC 1" >>confdefs.h ;; ia64-* ) $as_echo "#define ITANIUM 1" >>confdefs.h ITANIUMOBJ=itanium.o ;; esac case "$host_os" in *cygwin*) $as_echo "#define SYS_IS_CYGWIN32 1" >>confdefs.h ;; *darwin*) $as_echo "#define SYS_IS_DARWIN 1" >>confdefs.h ;; esac gp_configure_options=$ac_configure_args gapbin=`pwd` ABI=$ABI ABI_CFLAGS=$ABI_CFLAGS GMP_LIBS=$GMP_LIBS GMP_CFLAGS=$GMP_CFLAGS # Check whether --with-gmp was given. if test "${with_gmp+set}" = set; then : withval=$with_gmp; fi # Check whether --with-abi was given. if test "${with_abi+set}" = set; then : withval=$with_abi; fi # Check whether --with-configname was given. if test "${with_configname+set}" = set; then : withval=$with_configname; fi cat >>confdefs.h <<_ACEOF #define CONFIGNAME "$CONFIGNAME" _ACEOF ac_config_files="$ac_config_files sysinfo.gap:../../cnf/sysinfo.in gac:../../cnf/gac.in Makefile:../../cnf/Makegap.in extern/Makefile:../../extern/Makefile.in" cat >confcache <<\_ACEOF # This file is a shell script that caches the results of configure # tests run on this system so they can be shared between configure # scripts and configure runs, see configure's option --config-cache. # It is not useful on other systems. If it contains results you don't # want to keep, you may remove or edit it. # # config.status only pays attention to the cache file if you give it # the --recheck option to rerun configure. # # `ac_cv_env_foo' variables (set or unset) will be overridden when # loading this file, other *unset* `ac_cv_foo' will be assigned the # following values. _ACEOF # The following way of writing the cache mishandles newlines in values, # but we know of no workaround that is simple, portable, and efficient. # So, we kill variables containing newlines. # Ultrix sh set writes to stderr and can't be redirected directly, # and sets the high bit in the cache file unless we assign to the vars. ( for ac_var in `(set) 2>&1 | sed -n 's/^\([a-zA-Z_][a-zA-Z0-9_]*\)=.*/\1/p'`; do eval ac_val=\$$ac_var case $ac_val in #( *${as_nl}*) case $ac_var in #( *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5 $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;; esac case $ac_var in #( _ | IFS | as_nl) ;; #( BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #( *) { eval $ac_var=; unset $ac_var;} ;; esac ;; esac done (set) 2>&1 | case $as_nl`(ac_space=' '; set) 2>&1` in #( *${as_nl}ac_space=\ *) # `set' does not quote correctly, so add quotes: double-quote # substitution turns \\\\ into \\, and sed turns \\ into \. sed -n \ "s/'/'\\\\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" ;; #( *) # `set' quotes correctly as required by POSIX, so do not add quotes. sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | sort ) | sed ' /^ac_cv_env_/b end t clear :clear s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/ t end s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/ :end' >>confcache if diff "$cache_file" confcache >/dev/null 2>&1; then :; else if test -w "$cache_file"; then if test "x$cache_file" != "x/dev/null"; then { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5 $as_echo "$as_me: updating cache $cache_file" >&6;} if test ! -f "$cache_file" || test -h "$cache_file"; then cat confcache >"$cache_file" else case $cache_file in #( */* | ?:*) mv -f confcache "$cache_file"$$ && mv -f "$cache_file"$$ "$cache_file" ;; #( *) mv -f confcache "$cache_file" ;; esac fi fi else { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5 $as_echo "$as_me: not updating unwritable cache $cache_file" >&6;} fi fi rm -f confcache test "x$prefix" = xNONE && prefix=$ac_default_prefix # Let make expand exec_prefix. test "x$exec_prefix" = xNONE && exec_prefix='${prefix}' DEFS=-DHAVE_CONFIG_H ac_libobjs= ac_ltlibobjs= U= for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue # 1. Remove the extension, and $U if already installed. ac_script='s/\$U\././;s/\.o$//;s/\.obj$//' ac_i=`$as_echo "$ac_i" | sed "$ac_script"` # 2. Prepend LIBOBJDIR. When used with automake>=1.10 LIBOBJDIR # will be set to the directory where LIBOBJS objects are built. as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext" as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo' done LIBOBJS=$ac_libobjs LTLIBOBJS=$ac_ltlibobjs : "${CONFIG_STATUS=./config.status}" ac_write_fail=0 ac_clean_files_save=$ac_clean_files ac_clean_files="$ac_clean_files $CONFIG_STATUS" { $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5 $as_echo "$as_me: creating $CONFIG_STATUS" >&6;} as_write_fail=0 cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1 #! $SHELL # Generated by $as_me. # Run this file to recreate the current configuration. # Compiler output produced by configure, useful for debugging # configure, is in config.log if it exists. debug=false ac_cs_recheck=false ac_cs_silent=false SHELL=\${CONFIG_SHELL-$SHELL} export SHELL _ASEOF cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 ## -------------------- ## ## M4sh Initialization. ## ## -------------------- ## # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : emulate sh NULLCMD=: # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST else case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; esac fi as_nl=' ' export as_nl # Printing a long string crashes Solaris 7 /usr/bin/printf. as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo # Prefer a ksh shell builtin over an external printf program on Solaris, # but without wasting forks for bash or zsh. if test -z "$BASH_VERSION$ZSH_VERSION" \ && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='print -r --' as_echo_n='print -rn --' elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then as_echo='printf %s\n' as_echo_n='printf %s' else if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"' as_echo_n='/usr/ucb/echo -n' else as_echo_body='eval expr "X$1" : "X\\(.*\\)"' as_echo_n_body='eval arg=$1; case $arg in #( *"$as_nl"*) expr "X$arg" : "X\\(.*\\)$as_nl"; arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;; esac; expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl" ' export as_echo_n_body as_echo_n='sh -c $as_echo_n_body as_echo' fi export as_echo_body as_echo='sh -c $as_echo_body as_echo' fi # The user is always right. if test "${PATH_SEPARATOR+set}" != set; then PATH_SEPARATOR=: (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || PATH_SEPARATOR=';' } fi # IFS # We need space, tab and new line, in precisely that order. Quoting is # there to prevent editors from complaining about space-tab. # (If _AS_PATH_WALK were called with IFS unset, it would disable word # splitting by setting IFS to empty value.) IFS=" "" $as_nl" # Find who we are. Look in the path if we contain no directory separator. as_myself= case $0 in #(( *[\\/]* ) as_myself=$0 ;; *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS test -z "$as_dir" && as_dir=. test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break done IFS=$as_save_IFS ;; esac # We did not find ourselves, most probably we were run as `sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 fi if test ! -f "$as_myself"; then $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2 exit 1 fi # Unset variables that we do not need and which cause bugs (e.g. in # pre-3.0 UWIN ksh). But do not cause bugs in bash 2.01; the "|| exit 1" # suppresses any "Segmentation fault" message there. '((' could # trigger a bug in pdksh 5.2.14. for as_var in BASH_ENV ENV MAIL MAILPATH do eval test x\${$as_var+set} = xset \ && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || : done PS1='$ ' PS2='> ' PS4='+ ' # NLS nuisances. LC_ALL=C export LC_ALL LANGUAGE=C export LANGUAGE # CDPATH. (unset CDPATH) >/dev/null 2>&1 && unset CDPATH # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are # provided, also output the error to LOG_FD, referencing LINENO. Then exit the # script with STATUS, using 1 if that was 0. as_fn_error () { as_status=$1; test $as_status -eq 0 && as_status=1 if test "$4"; then as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4 fi $as_echo "$as_me: error: $2" >&2 as_fn_exit $as_status } # as_fn_error # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. as_fn_set_status () { return $1 } # as_fn_set_status # as_fn_exit STATUS # ----------------- # Exit the shell with STATUS, even in a "trap 0" or "set -e" context. as_fn_exit () { set +e as_fn_set_status $1 exit $1 } # as_fn_exit # as_fn_unset VAR # --------------- # Portably unset VAR. as_fn_unset () { { eval $1=; unset $1;} } as_unset=as_fn_unset # as_fn_append VAR VALUE # ---------------------- # Append the text in VALUE to the end of the definition contained in VAR. Take # advantage of any shell optimizations that allow amortized linear growth over # repeated appends, instead of the typical quadratic growth present in naive # implementations. if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then : eval 'as_fn_append () { eval $1+=\$2 }' else as_fn_append () { eval $1=\$$1\$2 } fi # as_fn_append # as_fn_arith ARG... # ------------------ # Perform arithmetic evaluation on the ARGs, and store the result in the # global $as_val. Take advantage of shells that can avoid forks. The arguments # must be portable across $(()) and expr. if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then : eval 'as_fn_arith () { as_val=$(( $* )) }' else as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` } fi # as_fn_arith if expr a : '\(a\)' >/dev/null 2>&1 && test "X`expr 00001 : '.*\(...\)'`" = X001; then as_expr=expr else as_expr=false fi if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then as_basename=basename else as_basename=false fi if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then as_dirname=dirname else as_dirname=false fi as_me=`$as_basename -- "$0" || $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \ X"$0" : 'X\(//\)$' \| \ X"$0" : 'X\(/\)' \| . 2>/dev/null || $as_echo X/"$0" | sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/ q } /^X\/\(\/\/\)$/{ s//\1/ q } /^X\/\(\/\).*/{ s//\1/ q } s/.*/./; q'` # Avoid depending upon Character Ranges. as_cr_letters='abcdefghijklmnopqrstuvwxyz' as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ' as_cr_Letters=$as_cr_letters$as_cr_LETTERS as_cr_digits='0123456789' as_cr_alnum=$as_cr_Letters$as_cr_digits ECHO_C= ECHO_N= ECHO_T= case `echo -n x` in #((((( -n*) case `echo 'xy\c'` in *c*) ECHO_T=' ';; # ECHO_T is single tab character. xy) ECHO_C='\c';; *) echo `echo ksh88 bug on AIX 6.1` > /dev/null ECHO_T=' ';; esac;; *) ECHO_N='-n';; esac rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file else rm -f conf$$.dir mkdir conf$$.dir 2>/dev/null fi if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. # In both cases, we have to default to `cp -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -pR' elif ln conf$$.file conf$$ 2>/dev/null; then as_ln_s=ln else as_ln_s='cp -pR' fi else as_ln_s='cp -pR' fi rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file rmdir conf$$.dir 2>/dev/null # as_fn_mkdir_p # ------------- # Create "$as_dir" as a directory, including parents if necessary. as_fn_mkdir_p () { case $as_dir in #( -*) as_dir=./$as_dir;; esac test -d "$as_dir" || eval $as_mkdir_p || { as_dirs= while :; do case $as_dir in #( *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'( *) as_qdir=$as_dir;; esac as_dirs="'$as_qdir' $as_dirs" as_dir=`$as_dirname -- "$as_dir" || $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$as_dir" : 'X\(//\)[^/]' \| \ X"$as_dir" : 'X\(//\)$' \| \ X"$as_dir" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$as_dir" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` test -d "$as_dir" && break done test -z "$as_dirs" || eval "mkdir $as_dirs" } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir" } # as_fn_mkdir_p if mkdir -p . 2>/dev/null; then as_mkdir_p='mkdir -p "$as_dir"' else test -d ./-p && rmdir ./-p as_mkdir_p=false fi # as_fn_executable_p FILE # ----------------------- # Test if FILE is an executable regular file. as_fn_executable_p () { test -f "$1" && test -x "$1" } # as_fn_executable_p as_test_x='test -x' as_executable_p=as_fn_executable_p # Sed expression to map a string onto a valid CPP name. as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" # Sed expression to map a string onto a valid variable name. as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" exec 6>&1 ## ----------------------------------- ## ## Main body of $CONFIG_STATUS script. ## ## ----------------------------------- ## _ASEOF test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Save the log message, to keep $0 and so on meaningful, and to # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" This file was extended by GAP $as_me 4.6.5, which was generated by GNU Autoconf 2.69. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS CONFIG_LINKS = $CONFIG_LINKS CONFIG_COMMANDS = $CONFIG_COMMANDS $ $0 $@ on `(hostname || uname -n) 2>/dev/null | sed 1q` " _ACEOF case $ac_config_files in *" "*) set x $ac_config_files; shift; ac_config_files=$*;; esac case $ac_config_headers in *" "*) set x $ac_config_headers; shift; ac_config_headers=$*;; esac cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 # Files that config.status was made for. config_files="$ac_config_files" config_headers="$ac_config_headers" _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 ac_cs_usage="\ \`$as_me' instantiates files and other configuration actions from templates according to the current configuration. Unless the files and actions are specified as TAGs, all are instantiated by default. Usage: $0 [OPTION]... [TAG]... -h, --help print this help, then exit -V, --version print version number and configuration settings, then exit --config print configuration, then exit -q, --quiet, --silent do not print progress messages -d, --debug don't remove temporary files --recheck update $as_me by reconfiguring in the same conditions --file=FILE[:TEMPLATE] instantiate the configuration file FILE --header=FILE[:TEMPLATE] instantiate the configuration header FILE Configuration files: $config_files Configuration headers: $config_headers Report bugs to . GAP home page: ." _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ GAP config.status 4.6.5 configured by $0, generated by GNU Autoconf 2.69, with options \\"\$ac_cs_config\\" Copyright (C) 2012 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." ac_pwd='$ac_pwd' srcdir='$srcdir' test -n "\$AWK" || AWK=awk _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # The default lists apply if the user does not specify any file. ac_need_defaults=: while test $# != 0 do case $1 in --*=?*) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'` ac_shift=: ;; --*=) ac_option=`expr "X$1" : 'X\([^=]*\)='` ac_optarg= ac_shift=: ;; *) ac_option=$1 ac_optarg=$2 ac_shift=shift ;; esac case $ac_option in # Handling of the options. -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r) ac_cs_recheck=: ;; --version | --versio | --versi | --vers | --ver | --ve | --v | -V ) $as_echo "$ac_cs_version"; exit ;; --config | --confi | --conf | --con | --co | --c ) $as_echo "$ac_cs_config"; exit ;; --debug | --debu | --deb | --de | --d | -d ) debug=: ;; --file | --fil | --fi | --f ) $ac_shift case $ac_optarg in *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; '') as_fn_error $? "missing file argument" ;; esac as_fn_append CONFIG_FILES " '$ac_optarg'" ac_need_defaults=false;; --header | --heade | --head | --hea ) $ac_shift case $ac_optarg in *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;; esac as_fn_append CONFIG_HEADERS " '$ac_optarg'" ac_need_defaults=false;; --he | --h) # Conflict between --help and --header as_fn_error $? "ambiguous option: \`$1' Try \`$0 --help' for more information.";; --help | --hel | -h ) $as_echo "$ac_cs_usage"; exit ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ | -silent | --silent | --silen | --sile | --sil | --si | --s) ac_cs_silent=: ;; # This is an error. -*) as_fn_error $? "unrecognized option: \`$1' Try \`$0 --help' for more information." ;; *) as_fn_append ac_config_targets " $1" ac_need_defaults=false ;; esac shift done ac_configure_extra_args= if $ac_cs_silent; then exec 6>/dev/null ac_configure_extra_args="$ac_configure_extra_args --silent" fi _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 if \$ac_cs_recheck; then set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion shift \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6 CONFIG_SHELL='$SHELL' export CONFIG_SHELL exec "\$@" fi _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 exec 5>>config.log { echo sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX ## Running $as_me. ## _ASBOX $as_echo "$ac_log" } >&5 _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # Handling of arguments. for ac_config_target in $ac_config_targets do case $ac_config_target in "config.h") CONFIG_HEADERS="$CONFIG_HEADERS config.h:../../cnf/config.hin" ;; "sysinfo.gap") CONFIG_FILES="$CONFIG_FILES sysinfo.gap:../../cnf/sysinfo.in" ;; "gac") CONFIG_FILES="$CONFIG_FILES gac:../../cnf/gac.in" ;; "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile:../../cnf/Makegap.in" ;; "extern/Makefile") CONFIG_FILES="$CONFIG_FILES extern/Makefile:../../extern/Makefile.in" ;; *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; esac done # If the user did not use the arguments to specify the items to instantiate, # then the envvar interface is used. Set only those that are not. # We use the long form for the default assignment because of an extremely # bizarre bug on SunOS 4.1.3. if $ac_need_defaults; then test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers fi # Have a temporary directory for convenience. Make it in the build tree # simply because there is no reason against having it here, and in addition, # creating and moving files from /tmp can sometimes cause problems. # Hook for its removal unless debugging. # Note that there is a small window in which the directory will not be cleaned: # after its creation but before its name has been assigned to `$tmp'. $debug || { tmp= ac_tmp= trap 'exit_status=$? : "${ac_tmp:=$tmp}" { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status ' 0 trap 'as_fn_exit 1' 1 2 13 15 } # Create a (secure) tmp directory for tmp files. { tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` && test -d "$tmp" } || { tmp=./conf$$-$RANDOM (umask 077 && mkdir "$tmp") } || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5 ac_tmp=$tmp # Set up the scripts for CONFIG_FILES section. # No need to generate them if there are no CONFIG_FILES. # This happens for instance with `./config.status config.h'. if test -n "$CONFIG_FILES"; then ac_cr=`echo X | tr X '\015'` # On cygwin, bash can eat \r inside `` if the user requested igncr. # But we know of no other shell where ac_cr would be empty at this # point, so we can use a bashism as a fallback. if test "x$ac_cr" = x; then eval ac_cr=\$\'\\r\' fi ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' /dev/null` if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then ac_cs_awk_cr='\\r' else ac_cs_awk_cr=$ac_cr fi echo 'BEGIN {' >"$ac_tmp/subs1.awk" && _ACEOF { echo "cat >conf$$subs.awk <<_ACEOF" && echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' && echo "_ACEOF" } >conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'` ac_delim='%!_!# ' for ac_last_try in false false false false false :; do . ./conf$$subs.sh || as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X` if test $ac_delim_n = $ac_delim_num; then break elif $ac_last_try; then as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5 else ac_delim="$ac_delim!$ac_delim _$ac_delim!! " fi done rm -f conf$$subs.sh cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK && _ACEOF sed -n ' h s/^/S["/; s/!.*/"]=/ p g s/^[^!]*!// :repl t repl s/'"$ac_delim"'$// t delim :nl h s/\(.\{148\}\)..*/\1/ t more1 s/["\\]/\\&/g; s/^/"/; s/$/\\n"\\/ p n b repl :more1 s/["\\]/\\&/g; s/^/"/; s/$/"\\/ p g s/.\{148\}// t nl :delim h s/\(.\{148\}\)..*/\1/ t more2 s/["\\]/\\&/g; s/^/"/; s/$/"/ p b :more2 s/["\\]/\\&/g; s/^/"/; s/$/"\\/ p g s/.\{148\}// t delim ' >$CONFIG_STATUS || ac_write_fail=1 rm -f conf$$subs.awk cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 _ACAWK cat >>"\$ac_tmp/subs1.awk" <<_ACAWK && for (key in S) S_is_set[key] = 1 FS = "" } { line = $ 0 nfields = split(line, field, "@") substed = 0 len = length(field[1]) for (i = 2; i < nfields; i++) { key = field[i] keylen = length(key) if (S_is_set[key]) { value = S[key] line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3) len += length(value) + length(field[++i]) substed = 1 } else len += 1 + keylen } print line } _ACAWK _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g" else cat fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \ || as_fn_error $? "could not setup config files machinery" "$LINENO" 5 _ACEOF # VPATH may cause trouble with some makes, so we remove sole $(srcdir), # ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and # trailing colons and then remove the whole line if VPATH becomes empty # (actually we leave an empty line to preserve line numbers). if test "x$srcdir" = x.; then ac_vpsub='/^[ ]*VPATH[ ]*=[ ]*/{ h s/// s/^/:/ s/[ ]*$/:/ s/:\$(srcdir):/:/g s/:\${srcdir}:/:/g s/:@srcdir@:/:/g s/^:*// s/:*$// x s/\(=[ ]*\).*/\1/ G s/\n// s/^[^=]*=[ ]*$// }' fi cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 fi # test -n "$CONFIG_FILES" # Set up the scripts for CONFIG_HEADERS section. # No need to generate them if there are no CONFIG_HEADERS. # This happens for instance with `./config.status Makefile'. if test -n "$CONFIG_HEADERS"; then cat >"$ac_tmp/defines.awk" <<\_ACAWK || BEGIN { _ACEOF # Transform confdefs.h into an awk script `defines.awk', embedded as # here-document in config.status, that substitutes the proper values into # config.h.in to produce config.h. # Create a delimiter string that does not exist in confdefs.h, to ease # handling of long lines. ac_delim='%!_!# ' for ac_last_try in false false :; do ac_tt=`sed -n "/$ac_delim/p" confdefs.h` if test -z "$ac_tt"; then break elif $ac_last_try; then as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5 else ac_delim="$ac_delim!$ac_delim _$ac_delim!! " fi done # For the awk script, D is an array of macro values keyed by name, # likewise P contains macro parameters if any. Preserve backslash # newline sequences. ac_word_re=[_$as_cr_Letters][_$as_cr_alnum]* sed -n ' s/.\{148\}/&'"$ac_delim"'/g t rset :rset s/^[ ]*#[ ]*define[ ][ ]*/ / t def d :def s/\\$// t bsnl s/["\\]/\\&/g s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ D["\1"]=" \3"/p s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2"/p d :bsnl s/["\\]/\\&/g s/^ \('"$ac_word_re"'\)\(([^()]*)\)[ ]*\(.*\)/P["\1"]="\2"\ D["\1"]=" \3\\\\\\n"\\/p t cont s/^ \('"$ac_word_re"'\)[ ]*\(.*\)/D["\1"]=" \2\\\\\\n"\\/p t cont d :cont n s/.\{148\}/&'"$ac_delim"'/g t clear :clear s/\\$// t bsnlc s/["\\]/\\&/g; s/^/"/; s/$/"/p d :bsnlc s/["\\]/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p b cont ' >$CONFIG_STATUS || ac_write_fail=1 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 for (key in D) D_is_set[key] = 1 FS = "" } /^[\t ]*#[\t ]*(define|undef)[\t ]+$ac_word_re([\t (]|\$)/ { line = \$ 0 split(line, arg, " ") if (arg[1] == "#") { defundef = arg[2] mac1 = arg[3] } else { defundef = substr(arg[1], 2) mac1 = arg[2] } split(mac1, mac2, "(") #) macro = mac2[1] prefix = substr(line, 1, index(line, defundef) - 1) if (D_is_set[macro]) { # Preserve the white space surrounding the "#". print prefix "define", macro P[macro] D[macro] next } else { # Replace #undef with comments. This is necessary, for example, # in the case of _POSIX_SOURCE, which is predefined and required # on some systems where configure will not decide to define it. if (defundef == "undef") { print "/*", prefix defundef, macro, "*/" next } } } { print } _ACAWK _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 as_fn_error $? "could not setup config headers machinery" "$LINENO" 5 fi # test -n "$CONFIG_HEADERS" eval set X " :F $CONFIG_FILES :H $CONFIG_HEADERS " shift for ac_tag do case $ac_tag in :[FHLC]) ac_mode=$ac_tag; continue;; esac case $ac_mode$ac_tag in :[FHL]*:*);; :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;; :[FH]-) ac_tag=-:-;; :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; esac ac_save_IFS=$IFS IFS=: set x $ac_tag IFS=$ac_save_IFS shift ac_file=$1 shift case $ac_mode in :L) ac_source=$1;; :[FH]) ac_file_inputs= for ac_f do case $ac_f in -) ac_f="$ac_tmp/stdin";; *) # Look for the file first in the build tree, then in the source tree # (if the path is not absolute). The absolute path cannot be DOS-style, # because $ac_f cannot contain `:'. test -f "$ac_f" || case $ac_f in [\\/$]*) false;; *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; esac || as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; esac case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac as_fn_append ac_file_inputs " '$ac_f'" done # Let's still pretend it is `configure' which instantiates (i.e., don't # use $as_me), people would be surprised to read: # /* config.h. Generated by config.status. */ configure_input='Generated from '` $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g' `' by configure.' if test x"$ac_file" != x-; then configure_input="$ac_file. $configure_input" { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5 $as_echo "$as_me: creating $ac_file" >&6;} fi # Neutralize special characters interpreted by sed in replacement strings. case $configure_input in #( *\&* | *\|* | *\\* ) ac_sed_conf_input=`$as_echo "$configure_input" | sed 's/[\\\\&|]/\\\\&/g'`;; #( *) ac_sed_conf_input=$configure_input;; esac case $ac_tag in *:-:* | *:-) cat >"$ac_tmp/stdin" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; esac ;; esac ac_dir=`$as_dirname -- "$ac_file" || $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \ X"$ac_file" : 'X\(//\)[^/]' \| \ X"$ac_file" : 'X\(//\)$' \| \ X"$ac_file" : 'X\(/\)' \| . 2>/dev/null || $as_echo X"$ac_file" | sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/ q } /^X\(\/\/\)[^/].*/{ s//\1/ q } /^X\(\/\/\)$/{ s//\1/ q } /^X\(\/\).*/{ s//\1/ q } s/.*/./; q'` as_dir="$ac_dir"; as_fn_mkdir_p ac_builddir=. case "$ac_dir" in .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_dir_suffix= # A ".." for each directory in $ac_dir_suffix. ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'` case $ac_top_builddir_sub in "") ac_top_builddir_sub=. ac_top_build_prefix= ;; *) ac_top_build_prefix=$ac_top_builddir_sub/ ;; esac ;; esac ac_abs_top_builddir=$ac_pwd ac_abs_builddir=$ac_pwd$ac_dir_suffix # for backward compatibility: ac_top_builddir=$ac_top_build_prefix case $srcdir in .) # We are building in place. ac_srcdir=. ac_top_srcdir=$ac_top_builddir_sub ac_abs_top_srcdir=$ac_pwd ;; [\\/]* | ?:[\\/]* ) # Absolute name. ac_srcdir=$srcdir$ac_dir_suffix; ac_top_srcdir=$srcdir ac_abs_top_srcdir=$srcdir ;; *) # Relative name. ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix ac_top_srcdir=$ac_top_build_prefix$srcdir ac_abs_top_srcdir=$ac_pwd/$srcdir ;; esac ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix case $ac_mode in :F) # # CONFIG_FILE # _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # If the template does not know about datarootdir, expand it. # FIXME: This hack should be removed a few years after 2.60. ac_datarootdir_hack=; ac_datarootdir_seen= ac_sed_dataroot=' /datarootdir/ { p q } /@datadir@/p /@docdir@/p /@infodir@/p /@localedir@/p /@mandir@/p' case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in *datarootdir*) ac_datarootdir_seen=yes;; *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5 $as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;} _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_datarootdir_hack=' s&@datadir@&$datadir&g s&@docdir@&$docdir&g s&@infodir@&$infodir&g s&@localedir@&$localedir&g s&@mandir@&$mandir&g s&\\\${datarootdir}&$datarootdir&g' ;; esac _ACEOF # Neutralize VPATH when `$srcdir' = `.'. # Shell code in configure.ac might set extrasub. # FIXME: do we really want to maintain this feature? cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_sed_extra="$ac_vpsub $extrasub _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 :t /@[a-zA-Z_][a-zA-Z_0-9]*@/!b s|@configure_input@|$ac_sed_conf_input|;t t s&@top_builddir@&$ac_top_builddir_sub&;t t s&@top_build_prefix@&$ac_top_build_prefix&;t t s&@srcdir@&$ac_srcdir&;t t s&@abs_srcdir@&$ac_abs_srcdir&;t t s&@top_srcdir@&$ac_top_srcdir&;t t s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t s&@builddir@&$ac_builddir&;t t s&@abs_builddir@&$ac_abs_builddir&;t t s&@abs_top_builddir@&$ac_abs_top_builddir&;t t $ac_datarootdir_hack " eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \ >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5 test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ "$ac_tmp/out"`; test -z "$ac_out"; } && { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&5 $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' which seems to be undefined. Please make sure it is defined" >&2;} rm -f "$ac_tmp/stdin" case $ac_file in -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";; *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";; esac \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;; :H) # # CONFIG_HEADER # if test x"$ac_file" != x-; then { $as_echo "/* $configure_input */" \ && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" } >"$ac_tmp/config.h" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5 $as_echo "$as_me: $ac_file is unchanged" >&6;} else rm -f "$ac_file" mv "$ac_tmp/config.h" "$ac_file" \ || as_fn_error $? "could not create $ac_file" "$LINENO" 5 fi else $as_echo "/* $configure_input */" \ && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \ || as_fn_error $? "could not create -" "$LINENO" 5 fi ;; esac done # for ac_tag as_fn_exit 0 _ACEOF ac_clean_files=$ac_clean_files_save test $ac_write_fail = 0 || as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5 # configure is writing to config.log, and then calls config.status. # config.status does its own redirection, appending to config.log. # Unfortunately, on DOS this fails, as config.log is still kept open # by configure, so config.status won't be able to write to it; its # output is simply discarded. So we exec the FD to /dev/null, # effectively closing config.log, so it can be properly (re)opened and # appended to by config.status. When coming back to configure, we # need to make the FD available again. if test "$no_create" != yes; then ac_cs_success=: ac_config_status_args= test "$silent" = yes && ac_config_status_args="$ac_config_status_args --quiet" exec 5>/dev/null $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false exec 5>>config.log # Use ||, not &&, to avoid exiting from the if with $? = 1, which # would make configure fail if this is the last instruction. $ac_cs_success || as_fn_exit 1 fi if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5 $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;} fi chmod a+x gac gap-4r6p5/cnf/gac.in0000644000175000017500000003511012172557252012771 0ustar billbill#!/bin/sh ############################################################################# ## #W gac.sh GAP compiler Martin Schoenert ## ## #Y Copyright (C) 1997, Lehrstuhl D fuer Mathematik, RWTH Aachen, Germany ## ## gac [-d] [-c|-C] [-o ] {-f

## The documentation states the following: ##

## <#GAPDoc Label="[1]{testinstall.g}"> ## If you want to run a quick test of your &GAP; installation ## (though this is not required), you can read in a test script ## that exercises some &GAP;'s capabilities. ##

## Read( Filename( DirectoriesLibrary( "tst" ), "testinstall.g" ) ); ## ]]> ##

## The test requires about 512MB of memory and runs about one ## minute on an Intel Core 2 Duo / 2.53 GHz machine. ## You will get a large number of lines with output about the progress ## of the tests. ## <#/GAPDoc> ## Print( "You should start GAP4 using `gap -A -x 80 -r -m 100m -o 512m'.\n", "The more GAP4stones you get, the faster your system is.\n", "The runtime of the following tests (in general) increases.\n", "You should expect the test to take about one minute and show about\n", "100000 GAP4stones on an Intel Core 2 Duo / 2.53 GHz machine.\n", "The `next' time is an approximation of the running time ", "for the next file.\n\n" ); Reread( Filename( DirectoriesLibrary( "tst" ), "testutil.g" ) ); RunStandardTests( [ [ "alghom.tst", 6000000 ], [ "algmat.tst", 180800000 ], [ "algsc.tst", 59000000 ], [ "combinat.tst", 5300000 ], [ "ctblfuns.tst", 3900000 ], [ "ctblmoli.tst", 98500000 ], [ "ctblmono.tst", 33400000 ], [ "ctblsolv.tst", 54000000 ], [ "cyclotom.tst", 900000 ], [ "ffe.tst", 3600000 ], [ "ffeconway.tst", 50200000 ], [ "gaussian.tst", 300000 ], [ "grpfp.tst", 146700000 ], [ "grpfree.tst", 700000 ], [ "grpmat.tst", 481000000 ], [ "grppc.tst", 45300000 ], [ "grppcnrm.tst", 2333400000 ], [ "listgen.tst", 1000000 ], [ "mapping.tst", 37300000 ], [ "mgmring.tst", 1800000 ], [ "modfree.tst", 5800000 ], [ "morpheus.tst", 87200000 ], [ "onecohom.tst", 50600000 ], [ "oprt.tst", 2000000 ], [ "ratfun.tst", 800000 ], [ "relation.tst", 7700000 ], [ "rwspcgrp.tst", 59400000 ], [ "semicong.tst", 7800000 ], [ "semigrp.tst", 11200000 ], [ "semirel.tst", 10900000 ], [ "vspchom.tst", 10500000 ], [ "vspcmat.tst", 8400000 ], [ "vspcrow.tst", 47400000 ], [ "xgap.tst", 1206600000 ], [ "zlattice.tst", 100000 ], [ "zmodnz.tst", 2300000 ], ] ); ############################################################################# ## #E gap-4r6p5/tst/ffeconway.tst0000644000175000017500000012325612172557256014505 0ustar billbill############################################################################# ## #W ffeconway.tst GAP tests Martin Schönert ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file tests the large finite fields . ## ## To be listed in testinstall.g ## gap> START_TEST("ffeconway.tst"); # # Disable various warnings which depend on state of prime number and # Conway Polynomial databases and on whether FactInt is loaded # gap> iPI := InfoLevel(InfoPrimeInt);; gap> iF := InfoLevel(InfoFactor);; gap> if IsBound(InfoFactInt) then iFI := InfoLevel(InfoFactInt); fi; gap> iW := InfoLevel(InfoWarning);; gap> SetInfoLevel(InfoPrimeInt,0); gap> SetInfoLevel(InfoFactor,0); gap> if IsBound(InfoFactInt) then SetInfoLevel(InfoFactInt,0); fi; gap> SetInfoLevel(InfoWarning,0); # # A range of field sizes to hit various cases for the underlying vector # arithmetic. # gap> fieldsizes := [ [2,17], [2,32], [2,60], [2,76], [2,87], [3,11], > [3,20], [3,60], [17,4], [257,2], [257,11], [65521,2], [65537,2], > [268435399,2], [4294967291,2], [1152921504606846883,3] ];; gap> Add( fieldsizes, [NextPrimeInt(2^64),2] ); # # When we come to test cross-field, we need to make sure we don't try and # create overlarge fields # leave the output here so we trip here if the Conway polynomial database changes # gap> fieldpairs := Concatenation(List(fieldsizes, pd -> List(Filtered([1..pd[2]-1], > d2 -> IsCheapConwayPolynomial(pd[1],Lcm(pd[2],d2))), d2 -> > [pd[1],pd[2],d2]))); [ [ 2, 17, 1 ], [ 2, 17, 2 ], [ 2, 17, 3 ], [ 2, 17, 4 ], [ 2, 17, 5 ], [ 2, 17, 6 ], [ 2, 17, 7 ], [ 2, 32, 1 ], [ 2, 32, 2 ], [ 2, 32, 3 ], [ 2, 32, 4 ], [ 2, 32, 6 ], [ 2, 32, 8 ], [ 2, 32, 12 ], [ 2, 32, 16 ], [ 2, 32, 24 ], [ 2, 60, 1 ], [ 2, 60, 2 ], [ 2, 60, 3 ], [ 2, 60, 4 ], [ 2, 60, 5 ], [ 2, 60, 6 ], [ 2, 60, 8 ], [ 2, 60, 10 ], [ 2, 60, 12 ], [ 2, 60, 15 ], [ 2, 60, 20 ], [ 2, 60, 24 ], [ 2, 60, 30 ], [ 2, 60, 40 ], [ 2, 76, 1 ], [ 2, 76, 2 ], [ 2, 76, 4 ], [ 2, 76, 19 ], [ 2, 76, 38 ], [ 2, 87, 1 ], [ 2, 87, 3 ], [ 2, 87, 29 ], [ 3, 11, 1 ], [ 3, 11, 2 ], [ 3, 11, 3 ], [ 3, 11, 4 ], [ 3, 11, 5 ], [ 3, 11, 6 ], [ 3, 11, 7 ], [ 3, 20, 1 ], [ 3, 20, 2 ], [ 3, 20, 3 ], [ 3, 20, 4 ], [ 3, 20, 5 ], [ 3, 20, 6 ], [ 3, 20, 8 ], [ 3, 20, 10 ], [ 3, 20, 12 ], [ 3, 20, 15 ], [ 3, 60, 1 ], [ 3, 60, 2 ], [ 3, 60, 3 ], [ 3, 60, 4 ], [ 3, 60, 5 ], [ 3, 60, 6 ], [ 3, 60, 10 ], [ 3, 60, 12 ], [ 3, 60, 15 ], [ 3, 60, 20 ], [ 3, 60, 30 ], [ 17, 4, 1 ], [ 17, 4, 2 ], [ 17, 4, 3 ], [ 257, 2, 1 ], [ 257, 11, 1 ], [ 65521, 2, 1 ], [ 65537, 2, 1 ], [ 268435399, 2, 1 ], [ 4294967291, 2, 1 ], [ 1152921504606846883, 3, 1 ], [ 18446744073709551629, 2, 1 ] ] # # construct generating elements # gap> zs := List(fieldsizes, pd -> Z(pd[1],pd[2])); [ z, z, z, z, z, z, z, z, z, z, z, z, z, z, z, z, z ] # # and another way # gap> zs = List(fieldsizes, pd -> Z(pd[1]^pd[2])); true # # Construct some more interesting elements and test View, Print and Display # gap> izs := List(zs, Inverse); [ z2+z16, z2+z3+z6+z8+z14+z31, z+z2+z3+z4+z7+z11+z16+z18+z21+z24+z25+z29+z31+z32+z33+z35+z38+z40+z41+z43+z4\ 4+z59, 1+z+z4+z13+z14+z18+z19+z22+z23+z24+z26+z28+z30+z32+z33+z34+z35+z36+z37+z75, 1+z2+z4+z6+z7+z9+z10+z11+z12+z13+z15+z19+z25+z27+z29+z86, z+2z10, 1+2z2+2z3+2z4+z7+z8+z9+z10+2z12+z19, 2z+2z2+2z3+z4+2z5+2z7+z9+2z10+z13+2z14+2z15+z19+z20+2z21+2z23+2z25+2z26+2z27\ +z29+z31+2z32+z33+z34+2z35+2z37+2z38+z39+2z40+z43+z59, 8+9z+11z3, 2+171z, 99+86z10, 61667+23125z, 21846+43691z, 89478467+89478466z, 2147483646+2147483645z, 1+576460752303423442z2, 2+9223372036854775814z ] gap> Print(izs,"\n"); [ Z(2,17)^2+Z(2,17)^16, Z(2,32)^2+Z(2,32)^3+Z(2,32)^6+Z(2,32)^8+Z(2,32)^14+Z(2,32)^31, Z(2,60)+Z(2,60)^2+Z(2,60)^3+Z(2,60)^4+Z(2,60)^7+Z(2,60)^11+Z(2,60)^16+Z(2,60\ )^18+Z(2,60)^21+Z(2,60)^24+Z(2,60)^25+Z(2,60)^29+Z(2,60)^31+Z(2,60)^32+Z(2,60)\ ^33+Z(2,60)^35+Z(2,60)^38+Z(2,60)^40+Z(2,60)^41+Z(2,60)^43+Z(2,60)^44+Z(2,60)^\ 59, Z(2)^0+Z(2,76)+Z(2,76)^4+Z(2,76)^13+Z(2,76)^14+Z(2,76)^18+Z(2,76)^19+Z(2,76)\ ^22+Z(2,76)^23+Z(2,76)^24+Z(2,76)^26+Z(2,76)^28+Z(2,76)^30+Z(2,76)^32+Z(2,76)^\ 33+Z(2,76)^34+Z(2,76)^35+Z(2,76)^36+Z(2,76)^37+Z(2,76)^75, Z(2)^0+Z(2,87)^2+Z(2,87)^4+Z(2,87)^6+Z(2,87)^7+Z(2,87)^9+Z(2,87)^10+Z(2,87)^\ 11+Z(2,87)^12+Z(2,87)^13+Z(2,87)^15+Z(2,87)^19+Z(2,87)^25+Z(2,87)^27+Z(2,87)^2\ 9+Z(2,87)^86, Z(3,11)+2*Z(3,11)^10, Z(3)^0+2*Z(3,20)^2+2*Z(3,20)^3+2*Z(3,20)^4+Z(3,20)^7+Z(3,20)^8+Z(3,20)^9+Z(3\ ,20)^10+2*Z(3,20)^12+Z(3,20)^19, 2*Z(3,60)+2*Z(3,60)^2+2*Z(3,60)^3+Z(3,60)^4+2*Z(3,60)^5+2*Z(3,60)^7+Z(3,60)^\ 9+2*Z(3,60)^10+Z(3,60)^13+2*Z(3,60)^14+2*Z(3,60)^15+Z(3,60)^19+Z(3,60)^20+2*Z(\ 3,60)^21+2*Z(3,60)^23+2*Z(3,60)^25+2*Z(3,60)^26+2*Z(3,60)^27+Z(3,60)^29+Z(3,60\ )^31+2*Z(3,60)^32+Z(3,60)^33+Z(3,60)^34+2*Z(3,60)^35+2*Z(3,60)^37+2*Z(3,60)^38\ +Z(3,60)^39+2*Z(3,60)^40+Z(3,60)^43+Z(3,60)^59, Z(17)^10+9*Z(17,4)+11*Z(17,4)^3, Z(257)^48+171*Z(257,2), Z(257)^198+86*Z(257,11)^10, Z(65521)^1451+23125*Z(65521,2), ZmodpZObj(21846,65537)+43691*Z(65537,2), ZmodpZObj(89478467,268435399)+89478466*Z(268435399,2), ZmodpZObj(2147483646,4294967291)+2147483645*Z(4294967291,2), ZmodpZObj(1,1152921504606846883)+576460752303423442*Z(1152921504606846883,3)\ ^2, ZmodpZObj(2,18446744073709551629)+9223372036854775814*Z(18446744073709551629\ ,2) ] gap> for x in izs do > Display(x); > od; z2+z16 z2+z3+z6+z8+z14+z31 z+z2+z3+z4+z7+z11+z16+z18+z21+z24+z25+z29+z31+z32+z33+z35+z38+z40+z41+z43+z44+\ z59 1+z+z4+z13+z14+z18+z19+z22+z23+z24+z26+z28+z30+z32+z33+z34+z35+z36+z37+z75 1+z2+z4+z6+z7+z9+z10+z11+z12+z13+z15+z19+z25+z27+z29+z86 z+2z10 1+2z2+2z3+2z4+z7+z8+z9+z10+2z12+z19 2z+2z2+2z3+z4+2z5+2z7+z9+2z10+z13+2z14+2z15+z19+z20+2z21+2z23+2z25+2z26+2z27+z\ 29+z31+2z32+z33+z34+2z35+2z37+2z38+z39+2z40+z43+z59 8+9z+11z3 2+171z 99+86z10 61667+23125z 21846+43691z 89478467+89478466z 2147483646+2147483645z 1+576460752303423442z2 2+9223372036854775814z # # Test arithmetic within the field # gap> zs + izs; [ z+z2+z16, z+z2+z3+z6+z8+z14+z31, z2+z3+z4+z7+z11+z16+z18+z21+z24+z25+z29+z31+z32+z33+z35+z38+z40+z41+z43+z44+\ z59, 1+z4+z13+z14+z18+z19+z22+z23+z24+z26+z28+z30+z32+z33+z34+z35+z36+z37+z75, 1+z+z2+z4+z6+z7+z9+z10+z11+z12+z13+z15+z19+z25+z27+z29+z86, 2z+2z10, 1+z+2z2+2z3+2z4+z7+z8+z9+z10+2z12+z19, 2z2+2z3+z4+2z5+2z7+z9+2z10+z13+2z14+2z15+z19+z20+2z21+2z23+2z25+2z26+2z27+z2\ 9+z31+2z32+z33+z34+2z35+2z37+2z38+z39+2z40+z43+z59, 8+10z+11z3, 2+172z, 99+z+86z10, 61667+23126z, 21846+43692z, 89478467+89478467z, 2147483646+2147483646z, 1+z+576460752303423442z2, 2+9223372036854775815z ] gap> zs - izs; [ z+z2+z16, z+z2+z3+z6+z8+z14+z31, z2+z3+z4+z7+z11+z16+z18+z21+z24+z25+z29+z31+z32+z33+z35+z38+z40+z41+z43+z44+\ z59, 1+z4+z13+z14+z18+z19+z22+z23+z24+z26+z28+z30+z32+z33+z34+z35+z36+z37+z75, 1+z+z2+z4+z6+z7+z9+z10+z11+z12+z13+z15+z19+z25+z27+z29+z86, z10, 2+z+z2+z3+z4+2z7+2z8+2z9+2z10+z12+2z19, 2z+z2+z3+2z4+z5+z7+2z9+z10+2z13+z14+z15+2z19+2z20+z21+z23+z25+z26+z27+2z29+2\ z31+z32+2z33+2z34+z35+z37+z38+2z39+z40+2z43+2z59, 9+9z+6z3, 255+87z, 158+z+171z10, 3854+42397z, 43691+21847z, 178956932+178956934z, 2147483645+2147483647z, 1152921504606846882+z+576460752303423441z2, 18446744073709551627+9223372036854775816z ] gap> List(izs, x->x^2); [ z+z15, z+z2+z5+z7+z13+z30, 1+z+z2+z3+z6+z10+z15+z17+z20+z23+z24+z28+z30+z31+z32+z34+z37+z39+z40+z42+z43\ +z58, z+z3+z4+z12+z14+z17+z19+z21+z24+z25+z26+z27+z28+z29+z30+z31+z37+z74+z75, 1+z+z2+z3+z4+z5+z7+z8+z13+z14+z15+z18+z19+z24+z25+z26+z27+z28+z29+z85+z86, 1+2z9, 1+2z+z2+z3+2z4+z6+2z7+2z8+2z9+z10+2z11+2z12+z18+z19, 2+2z+2z2+z3+2z4+2z6+z8+2z9+z12+2z13+2z14+z18+z19+2z20+2z22+2z24+2z25+2z26+z2\ 8+z30+2z31+z32+z33+2z34+2z36+2z37+z38+2z39+z42+z58, 5+4z+11z2+3z3, 175+85z, 35+86z9+33z10, 3174+50331z, 50973+58255z, 59652311+149130777z, 3221225468+3221225468z, 1+576460752303423442z+576460752303423442z2, 9223372036854775818+18446744073709551628z ] gap> List([1..Length(zs)] , i-> zs[i]/izs[i]); [ z2, z2, z2, z2, z2, z2, z2, z2, z2, 254+6z, z2, 65504+3z, 65534+z, 268435396+2z, 4294967289+z, z2, 18446744073709551627+4z ] gap> List(izs, AdditiveInverse); [ z2+z16, z2+z3+z6+z8+z14+z31, z+z2+z3+z4+z7+z11+z16+z18+z21+z24+z25+z29+z31+z32+z33+z35+z38+z40+z41+z43+z4\ 4+z59, 1+z+z4+z13+z14+z18+z19+z22+z23+z24+z26+z28+z30+z32+z33+z34+z35+z36+z37+z75, 1+z2+z4+z6+z7+z9+z10+z11+z12+z13+z15+z19+z25+z27+z29+z86, 2z+z10, 2+z2+z3+z4+2z7+2z8+2z9+2z10+z12+2z19, z+z2+z3+2z4+z5+z7+2z9+z10+2z13+z14+z15+2z19+2z20+z21+z23+z25+z26+z27+2z29+2z\ 31+z32+2z33+2z34+z35+z37+z38+2z39+z40+2z43+2z59, 9+8z+6z3, 255+86z, 158+171z10, 3854+42396z, 43691+21846z, 178956932+178956933z, 2147483645+2147483646z, 1152921504606846882+576460752303423441z2, 18446744073709551627+9223372036854775815z ] # # and across fields # gap> List(fieldpairs, pdd -> Z(pdd[1],pdd[2])+Z(pdd[1],pdd[3])); [ 1+z, z+z4+z9+z10+z15+z17+z19+z21+z23+z25+z26+z27+z29+z30+z33, z2+z3+z6+z10+z13+z15+z16+z18+z19+z20+z24+z25+z35+z38+z39+z40+z41+z44+z46+z48\ +z49, 1+z2+z3+z4+z5+z7+z10+z11+z12+z13+z14+z16+z17+z18+z19+z21+z22+z23+z24+z25+z26\ +z30+z31+z32+z35+z37+z38+z40+z47+z48+z50+z51+z56+z58+z62+z63+z67, z+z3+z7+z8+z9+z10+z13+z14+z17+z19+z20+z21+z22+z24+z25+z27+z28+z30+z32+z33+z3\ 6+z38+z41+z42+z45+z46+z47+z48+z50+z51+z52+z54+z58+z59+z60+z61+z63+z65+z68+z69+\ z71+z73+z75+z76+z77+z82, z2+z3+z5+z7+z10+z11+z13+z16+z18+z19+z20+z21+z22+z25+z26+z27+z28+z30+z31+z32+\ z34+z35+z37+z38+z39+z40+z44+z45+z47+z54+z55+z56+z58+z60+z61+z63+z65+z67+z69+z7\ 3+z74+z79+z83+z87+z89+z96+z97+z99+z100, <>, 1+z, 1+z3+z4+z5+z6+z8+z9+z14+z17+z18+z19+z20+z21+z24+z29+z30, z+z5+z7+z9+z12+z14+z15+z16+z17+z20+z22+z23+z24+z25+z28+z31+z33+z36+z37+z38+z\ 39+z42+z43+z44+z52+z56+z61+z62+z65+z67+z68+z69+z70+z71+z72+z73+z76+z77+z79+z80\ +z81+z82+z83+z85+z86+z89+z94, z4+z5+z6+z8+z10+z12+z14+z15+z17+z18+z19+z20+z21+z22+z23+z24+z25+z29+z30, 1+z6+z11+z12+z13+z15+z18+z22+z23+z30+z31+z36+z37+z38+z39+z41+z44+z45+z47+z48\ +z50+z51+z52+z55+z56+z57+z58+z59+z60+z63+z64+z66+z68+z69+z74+z76+z81+z83+z84+z\ 85+z86+z88+z89+z90+z91+z92+z93, z+z2+z3+z6+z7+z10+z12+z14+z17+z19+z20+z21+z22+z29+z31, z2+z9+z10+z11+z15+z16+z17+z18+z20+z23+z25+z27+z29+z33+z35+z36+z39+z40+z42+z4\ 5+z47+z48+z52+z54+z55+z56+z57+z59+z62+z67+z68+z71+z74+z75+z76+z80+z81+z83+z85+\ z86+z89+z90+z92+z93, z+z2+z4+z5+z6+z7+z10+z11+z14+z15+z16+z20+z23+z26+z28+z29+z30+z31, 1+z+z4+z6+z7+z9+z12+z14+z17+z19+z21+z22+z28+z30+z33+z34+z36+z38+z40+z41+z45+\ z48+z49+z51+z52+z53+z59+z61+z63+z67+z69+z70+z75+z78+z81+z83+z85+z86+z87+z90+z9\ 3+z94, 1+z, z2+z4+z5+z7+z9+z11+z14+z17+z19+z20+z21+z23+z24+z25+z27+z30+z35+z36+z38+z39+z\ 41+z43+z50+z51+z53+z54+z55+z57+z59, 1+z+z5+z7+z8+z11+z12+z15+z17+z22+z23+z24+z27+z28+z29+z31+z34+z35+z37+z38+z39\ +z42+z47+z48+z51+z52+z53, 1+z2+z3+z4+z7+z8+z9+z10+z11+z16+z18+z19+z20+z21+z23+z26+z27+z31+z32+z34+z36+\ z37+z39+z40+z41+z42+z45+z46+z47+z49+z50+z51+z53+z54+z56+z57+z58, z+z2+z3+z6+z7+z9+z11+z13+z17+z19+z21+z22+z23+z25+z27+z29+z30+z31+z36+z38+z39\ +z41+z45+z46+z48+z51+z53+z54+z55+z56+z59, z2+z4+z6+z7+z9+z11+z12+z14+z16+z17+z19+z20+z21+z22+z25+z26+z31+z34+z35+z36+z\ 37+z38+z44+z46+z48+z49+z51+z52+z57+z58+z59, <>, z+z3+z4+z6+z8+z10+z11+z15+z18+z19+z22+z24+z26+z28+z30+z31+z32+z33+z34+z36+z3\ 7+z39+z40+z41+z42+z47+z48+z50+z53+z54+z56+z57+z59, z4+z6+z7+z13+z14+z16+z17+z18+z19+z20+z21+z22+z24+z26+z28+z31+z33+z34+z35+z37\ +z39+z43+z47+z48+z51+z52+z54+z58, 1+z4+z6+z8+z9+z14+z16+z24+z28+z29+z32+z34+z38+z39+z40+z42+z47+z48+z50+z51+z5\ 2+z54+z56+z57+z59, 1+z+z2+z3+z4+z7+z11+z14+z15+z16+z17+z18+z22+z25+z26+z29+z34+z35+z36+z37+z38+\ z40+z44+z45+z46+z47+z48+z50+z52+z55+z56+z57+z58, <>, z2+z4+z7+z10+z13+z15+z18+z20+z23+z25+z26+z38+z39+z41+z43+z44+z46+z48+z50+z51\ +z55+z56+z57+z59, <>, 1+z, z3+z6+z7+z8+z10+z14+z15+z18+z20+z22+z23+z25+z26+z27+z30+z31+z32+z33+z35+z36+\ z38+z42+z45+z46+z47+z50+z51+z54+z55+z57+z58+z60+z62+z63+z64+z65+z66+z67+z69+z7\ 1+z73+z75, 1+z2+z3+z4+z7+z8+z9+z17+z18+z19+z21+z26+z29+z30+z31+z32+z34+z35+z36+z39+z43+\ z44+z45+z46+z48+z49+z52+z53+z56+z57+z60+z63+z64+z65+z69+z70+z71+z73+z74+z75, 1+z2+z5+z6+z7+z8+z10+z12+z13+z15+z16+z18+z19+z20+z26+z28+z33+z35+z37+z40+z41\ +z43+z44+z45+z46+z48+z49+z52+z53+z54+z55+z57+z60+z62+z65+z67+z72+z73+z74, z2+z3+z5+z6+z8+z9+z11+z19+z23+z27+z31+z32+z34+z35+z36+z38+z42+z46+z48+z49+z5\ 0+z53+z58+z59+z60+z62+z63+z65+z66+z67+z68+z69+z70+z74, 1+z, 1+z2+z3+z5+z9+z15+z22+z25+z26+z27+z28+z29+z30+z31+z32+z34+z36+z40+z42+z43+z4\ 4+z48+z51+z52+z55+z56+z57+z60+z61+z62+z63+z64+z65+z67+z68+z69+z70+z71+z72+z75+\ z77+z79+z81+z83+z84+z86, z+z2+z6+z8+z9+z10+z14+z15+z16+z19+z20+z22+z23+z26+z28+z30+z31+z33+z34+z37+z4\ 1+z46+z50+z51+z54+z55+z56+z57+z58+z59+z60+z61+z63+z64+z66+z68+z71+z72+z76+z78+\ z81+z82+z83+z84+z85, 2+z, 2+z+z2+2z3+z4+2z5+2z6+z7+2z9+2z11+z12+2z14+z16+z17+2z18+2z19+2z20+2z21, 1+2z+2z3+2z4+2z6+2z8+2z9+z11+z12+z14+2z15+2z17+z18+z19+2z21+2z23+z25+2z26+2z\ 27+2z28+2z29+2z30+z32, 2z+2z3+z8+z9+z12+z15+2z17+2z19+z21+z22+z23+z24+z25+z30+z34+z35+z37+2z38+2z40\ +z41+2z42+z43, 2+z+z4+2z6+z7+2z9+z10+2z14+z16+2z19+z20+2z21+2z22+z23+2z25+z26+2z27+z28+2z29\ +z30+z31+2z34+2z35+z36+z38+z40+z41+z42+z44+2z45+2z47+z51+z52, 1+z+z4+z6+2z8+z9+z11+2z13+z14+z17+z19+z20+2z21+z23+z25+2z26+z27+z28+z29+z31+\ z32+z33+z34+z35+2z38+z40+z41+2z42+2z45+z46+2z47+z50+2z51+z52+2z57+z58+2z59+z60\ +z61+2z62+2z63+2z64+z65, 1+z2+2z4+z5+2z6+2z7+z8+2z9+2z10+z11+2z12+2z13+z14+z16+2z17+2z18+z21+z22+z24+\ 2z27+2z28+2z29+2z32+z33+z35+z36+z40+2z41+2z42+z45+2z46+2z48+2z49+z51+z52+z53+2\ z54+z55+z56+z57+2z58+z59+z60+z61+z63+z64+2z65+2z66+2z67+z68+2z73+2z76, 2+z, z+z2+2z3+2z4+z7+2z8+z9+z10+2z12+2z13+2z14+z15+2z17+2z18+z19, 2+z2+z3+2z5+z7+2z11+z12+z14+z15+z16+z18+z19+2z20+2z22+z25+z27+z29+2z30+z32+z\ 33+2z34+z35+2z36+2z39+z40+z41+2z43+2z45+z46+2z48+2z49+2z50+z53+2z54+2z55+z56+2\ z57, 1+2z+z2+2z3+2z4+2z5+z6+z7+2z11+2z12+z13+z14+z15+2z16+z17+z18+z19, 2z+2z2+z4+z5+z6+2z8+z11+2z12+z16+z19, 2z+z2+z3+2z4+z6+2z7+2z8+2z9+2z10+2z12+2z13+z15+z16+z17+2z18+z19+z20+2z21+z24\ +z25+2z26+2z27+z28+2z29+z30+2z31+z32+z33+z35+z36+2z37+z39+2z40+2z42+z45+z46+z4\ 7+2z48+2z50+z51+2z52+z53+z54+z55+2z57+2z58+2z59, 2+z+2z3+2z4+2z5+z6+2z7+2z8+z9+2z11+2z12+z13+2z15+z16+z19+z23+2z24+2z25+2z26+\ z27+2z28+z29+2z30+2z33+2z35+z39, z+z3+2z4+2z7+z8+2z10+z11+2z12+z13+z14+z15+z17+z18+2z19, 2+z+2z2+2z5+2z6+z8+2z9+z10+z12+2z15+z18+z19+z20+z23+2z25+2z26+z27+2z28+2z29+\ 2z30+z31+2z32+2z33+2z34+2z38+2z39+2z40+z42+z44+z45+2z46+z48+z49+2z50+2z52+z53+\ z54+2z55+2z56+z57+z58, 2+z+2z2+2z3+z4+z7+2z8+2z9+2z10+z11+z13+z14+z15+2z19+2z21+2z23+2z24+z25+2z29+\ 2z31+z32+z34+z35+z36+z37+z38+z39+2z40+2z42+2z44+z45+2z46+z49+z50+z51+2z53+z54+\ 2z55+2z57+2z58+2z59, 2+z, 2+2z+2z2+2z4+2z5+z6+2z7+z8+2z9+2z11+z13+2z14+2z15+z16+2z17+2z18+z19+2z20+z21\ +z22+2z23+2z25+2z27+z28+2z29+2z31+z35+2z36+z37+2z38+2z39+z40+2z42+z43+2z45+2z4\ 6+z47+z49+z51+2z52+2z53+z55+2z58+z59, 1+z+2z2+2z3+z4+2z5+2z6+z7+z9+z10+z11+z12+2z16+z17+z18+z19+z21+z25+z26+2z27+z\ 28+2z29+2z30+z31+z34+z35+z36+2z37+z38+2z39+z40+2z42+2z43+2z46+z47+2z48+2z49+z5\ 2+2z53+2z55+z57+2z58+2z59, 1+z+z3+2z5+2z7+2z8+2z9+z10+z12+z13+2z14+2z19+z20+z22+2z23+z26+2z27+z28+2z29+\ z30+z32+2z33+z34+2z35+z37+2z38+2z40+z41+2z42+z43+2z44+2z45+z46+2z47+z48+z49+2z\ 51+z53+2z56+z57+2z58+z59, 2+2z+2z3+z4+2z5+z7+z8+z9+z10+2z11+2z12+2z13+z14+z18+2z20+z24+z25+z28+2z29+2z\ 30+2z31+z32+z33+z34+2z35+z36+2z37+z38+z40+z44+z46+z47+z49+z50+2z52+2z53+2z57+2\ z58+2z59, 2+2z2+2z3+2z7+2z8+2z11+2z12+2z13+2z14+2z16+2z17+2z18+z19+2z20+z22+z24+z25+2z\ 28+z30+2z34+z35+z37+z38+z39+2z40+2z41+z42+2z45+2z46+2z47+2z48+z51+2z53+2z54+z5\ 5+2z56+z57+z58+z59, z+2z3+2z4+z5+z6+2z8+z10+z11+2z12+2z15+2z16+z19+z21+2z22+z25+2z29+2z30+2z31+2\ z32+z33+2z34+z38+2z39+z41+z43+2z48+2z49+z50+z53+2z54+2z55+2z56+2z57+z58+z59, 1+2z+z3+z4+2z5+z6+z8+2z10+2z11+z12+2z14+z15+z16+z17+z18+z19+2z20+z21+z22+z23\ +2z25+2z27+2z30+2z31+z32+z33+z34+2z36+2z37+2z39+2z40+2z41+z44+2z45+z47+z48+z49\ +2z53+2z54+2z55+z56+2z59, 1+2z+2z4+2z6+z7+2z8+z13+z16+z17+2z19+z20+z22+2z23+2z24+z25+z26+z27+z28+2z33+\ z35+2z38+z39+2z40+2z41+z42+2z44+2z45+z47+z49+2z50+z51+z52+2z54+2z55+2z56+z57+z\ 58+z59, 1+z+2z2+2z3+2z4+z6+2z9+2z10+z11+z14+z15+2z16+2z17+2z20+2z21+2z22+2z26+2z27+2\ z28+2z29+2z31+z32+z33+z34+z36+z37+2z38+z41+z42+2z45+2z46+2z47+2z50+2z52+2z53+2\ z54+z56+z57+z58+z59, 1+z+2z2+z3+z4+2z6+2z7+2z9+z10+z11+2z12+z14+2z15+z16+z19+2z21+2z24+z26+2z28+2\ z29+2z30+z32+z33+z34+z35+2z37+2z40+z41+2z42+2z46+2z48+z49+2z50+2z53+z54+z55+z5\ 6+z58+2z59, 3+z, 12+z2+9z3, 10+9z+13z3+11z4+5z5+10z6+15z7+5z8+13z9+6z10+9z11, 3+z, 3+z, 17+z, 3+z, 3+z, 2+z, 2+z, 2+z ] gap> List(fieldpairs, pdd -> Z(pdd[1],pdd[2])-Z(pdd[1],pdd[3])); [ 1+z, z+z4+z9+z10+z15+z17+z19+z21+z23+z25+z26+z27+z29+z30+z33, z2+z3+z6+z10+z13+z15+z16+z18+z19+z20+z24+z25+z35+z38+z39+z40+z41+z44+z46+z48\ +z49, 1+z2+z3+z4+z5+z7+z10+z11+z12+z13+z14+z16+z17+z18+z19+z21+z22+z23+z24+z25+z26\ +z30+z31+z32+z35+z37+z38+z40+z47+z48+z50+z51+z56+z58+z62+z63+z67, z+z3+z7+z8+z9+z10+z13+z14+z17+z19+z20+z21+z22+z24+z25+z27+z28+z30+z32+z33+z3\ 6+z38+z41+z42+z45+z46+z47+z48+z50+z51+z52+z54+z58+z59+z60+z61+z63+z65+z68+z69+\ z71+z73+z75+z76+z77+z82, z2+z3+z5+z7+z10+z11+z13+z16+z18+z19+z20+z21+z22+z25+z26+z27+z28+z30+z31+z32+\ z34+z35+z37+z38+z39+z40+z44+z45+z47+z54+z55+z56+z58+z60+z61+z63+z65+z67+z69+z7\ 3+z74+z79+z83+z87+z89+z96+z97+z99+z100, <>, 1+z, 1+z3+z4+z5+z6+z8+z9+z14+z17+z18+z19+z20+z21+z24+z29+z30, z+z5+z7+z9+z12+z14+z15+z16+z17+z20+z22+z23+z24+z25+z28+z31+z33+z36+z37+z38+z\ 39+z42+z43+z44+z52+z56+z61+z62+z65+z67+z68+z69+z70+z71+z72+z73+z76+z77+z79+z80\ +z81+z82+z83+z85+z86+z89+z94, z4+z5+z6+z8+z10+z12+z14+z15+z17+z18+z19+z20+z21+z22+z23+z24+z25+z29+z30, 1+z6+z11+z12+z13+z15+z18+z22+z23+z30+z31+z36+z37+z38+z39+z41+z44+z45+z47+z48\ +z50+z51+z52+z55+z56+z57+z58+z59+z60+z63+z64+z66+z68+z69+z74+z76+z81+z83+z84+z\ 85+z86+z88+z89+z90+z91+z92+z93, z+z2+z3+z6+z7+z10+z12+z14+z17+z19+z20+z21+z22+z29+z31, z2+z9+z10+z11+z15+z16+z17+z18+z20+z23+z25+z27+z29+z33+z35+z36+z39+z40+z42+z4\ 5+z47+z48+z52+z54+z55+z56+z57+z59+z62+z67+z68+z71+z74+z75+z76+z80+z81+z83+z85+\ z86+z89+z90+z92+z93, z+z2+z4+z5+z6+z7+z10+z11+z14+z15+z16+z20+z23+z26+z28+z29+z30+z31, 1+z+z4+z6+z7+z9+z12+z14+z17+z19+z21+z22+z28+z30+z33+z34+z36+z38+z40+z41+z45+\ z48+z49+z51+z52+z53+z59+z61+z63+z67+z69+z70+z75+z78+z81+z83+z85+z86+z87+z90+z9\ 3+z94, 1+z, z2+z4+z5+z7+z9+z11+z14+z17+z19+z20+z21+z23+z24+z25+z27+z30+z35+z36+z38+z39+z\ 41+z43+z50+z51+z53+z54+z55+z57+z59, 1+z+z5+z7+z8+z11+z12+z15+z17+z22+z23+z24+z27+z28+z29+z31+z34+z35+z37+z38+z39\ +z42+z47+z48+z51+z52+z53, 1+z2+z3+z4+z7+z8+z9+z10+z11+z16+z18+z19+z20+z21+z23+z26+z27+z31+z32+z34+z36+\ z37+z39+z40+z41+z42+z45+z46+z47+z49+z50+z51+z53+z54+z56+z57+z58, z+z2+z3+z6+z7+z9+z11+z13+z17+z19+z21+z22+z23+z25+z27+z29+z30+z31+z36+z38+z39\ +z41+z45+z46+z48+z51+z53+z54+z55+z56+z59, z2+z4+z6+z7+z9+z11+z12+z14+z16+z17+z19+z20+z21+z22+z25+z26+z31+z34+z35+z36+z\ 37+z38+z44+z46+z48+z49+z51+z52+z57+z58+z59, <>, z+z3+z4+z6+z8+z10+z11+z15+z18+z19+z22+z24+z26+z28+z30+z31+z32+z33+z34+z36+z3\ 7+z39+z40+z41+z42+z47+z48+z50+z53+z54+z56+z57+z59, z4+z6+z7+z13+z14+z16+z17+z18+z19+z20+z21+z22+z24+z26+z28+z31+z33+z34+z35+z37\ +z39+z43+z47+z48+z51+z52+z54+z58, 1+z4+z6+z8+z9+z14+z16+z24+z28+z29+z32+z34+z38+z39+z40+z42+z47+z48+z50+z51+z5\ 2+z54+z56+z57+z59, 1+z+z2+z3+z4+z7+z11+z14+z15+z16+z17+z18+z22+z25+z26+z29+z34+z35+z36+z37+z38+\ z40+z44+z45+z46+z47+z48+z50+z52+z55+z56+z57+z58, <>, z2+z4+z7+z10+z13+z15+z18+z20+z23+z25+z26+z38+z39+z41+z43+z44+z46+z48+z50+z51\ +z55+z56+z57+z59, <>, 1+z, z3+z6+z7+z8+z10+z14+z15+z18+z20+z22+z23+z25+z26+z27+z30+z31+z32+z33+z35+z36+\ z38+z42+z45+z46+z47+z50+z51+z54+z55+z57+z58+z60+z62+z63+z64+z65+z66+z67+z69+z7\ 1+z73+z75, 1+z2+z3+z4+z7+z8+z9+z17+z18+z19+z21+z26+z29+z30+z31+z32+z34+z35+z36+z39+z43+\ z44+z45+z46+z48+z49+z52+z53+z56+z57+z60+z63+z64+z65+z69+z70+z71+z73+z74+z75, 1+z2+z5+z6+z7+z8+z10+z12+z13+z15+z16+z18+z19+z20+z26+z28+z33+z35+z37+z40+z41\ +z43+z44+z45+z46+z48+z49+z52+z53+z54+z55+z57+z60+z62+z65+z67+z72+z73+z74, z2+z3+z5+z6+z8+z9+z11+z19+z23+z27+z31+z32+z34+z35+z36+z38+z42+z46+z48+z49+z5\ 0+z53+z58+z59+z60+z62+z63+z65+z66+z67+z68+z69+z70+z74, 1+z, 1+z2+z3+z5+z9+z15+z22+z25+z26+z27+z28+z29+z30+z31+z32+z34+z36+z40+z42+z43+z4\ 4+z48+z51+z52+z55+z56+z57+z60+z61+z62+z63+z64+z65+z67+z68+z69+z70+z71+z72+z75+\ z77+z79+z81+z83+z84+z86, z+z2+z6+z8+z9+z10+z14+z15+z16+z19+z20+z22+z23+z26+z28+z30+z31+z33+z34+z37+z4\ 1+z46+z50+z51+z54+z55+z56+z57+z58+z59+z60+z61+z63+z64+z66+z68+z71+z72+z76+z78+\ z81+z82+z83+z84+z85, 1+z, 2+2z+2z2+2z3+z4+2z5+z8+z9+2z10+z11+z12+z15+z16+2z18+2z19+2z20+z21, 1+2z+2z2+2z3+z4+z6+z8+2z11+z12+2z13+2z14+2z15+2z16+2z17+z18+z20+2z21+z22+z23\ +z24+2z25+z26+2z28+z30+2z31, 2z+z5+2z7+2z8+z9+z10+2z11+z12+z13+z14+z17+z18+2z19+2z20+2z23+2z26+2z28+2z31+\ 2z33+2z35+z36+2z38+z39+z40+2z41+2z42+2z43, 1+z+z3+2z4+2z5+z6+2z9+z11+z12+z15+2z18+2z19+z20+2z21+z22+2z24+z25+2z27+z28+z\ 29+2z34+z36+2z37+2z38+z40+2z41+2z43+2z45+z47+2z51+z52+2z54, 1+z+z3+z4+2z5+2z6+z9+z10+z11+z13+2z14+2z15+z16+2z17+2z18+z19+2z22+2z23+2z24+\ z26+z28+z30+z31+2z33+z34+z35+z37+2z38+z40+2z41+z42+z44+2z45+z46+2z47+z49+2z50+\ z51+2z52+z54+2z55+z56+z57+z58+z59+2z61+z62+z64, 2+z+z5+z6+2z9+2z11+2z13+z14+z16+2z20+z23+2z24+z27+z28+2z29+2z30+z31+2z32+2z3\ 4+2z35+z36+2z37+z38+z39+2z40+2z41+z42+z45+2z46+z47+2z49+2z51+2z52+2z55+z56+2z5\ 7+z58+z61+2z63+z64+2z65+2z67+2z69+2z70+z71+z72+z73+z75+2z76, 1+z, z+2z2+z3+z4+2z7+z8+2z9+2z10+z12+z13+z14+2z15+z17+z18+2z19, z4+z5+2z6+2z7+z9+z10+2z12+z14+z15+z17+2z18+2z19+2z20+z21+2z22+2z25+z26+z28+z\ 30+z31+z32+z33+2z35+2z37+z38+z39+2z40+z41+2z42+z43+2z45+z47+z48+z49+2z50+z52+2\ z54+z55+z56+2z58+2z59, 2+2z2+z3+z4+z5+2z6+2z7+z11+z12+2z13+2z14+2z15+z16+2z17+2z18+2z19, z2+2z4+2z5+2z6+z8+2z11+z12+2z16+2z19, 2+z+2z4+z6+z7+z8+2z9+2z10+2z11+z12+z13+2z14+z15+z18+2z19+2z21+z22+2z24+2z25+\ 2z26+2z27+2z29+2z30+2z31+z32+z33+2z34+2z35+z36+z38+2z39+z40+2z41+z48+2z50+2z51\ +2z52+2z55+2z56, 2+z+2z7+2z8+2z9+2z10+2z11+2z12+z13+2z14+z15+2z16+2z17+z18+2z20+2z21+2z22+z24\ +2z25+2z26+2z28+z29+2z30+2z32+z33+z34+z36+2z38+z39, z+2z3+z4+z7+2z8+z10+2z11+z12+2z13+2z14+2z15+2z17+2z18+z19, 2z+2z2+z3+z4+z5+2z8+2z9+2z11+2z12+2z14+z16+z17+2z18+2z19+z21+z22+2z23+z25+2z\ 26+2z28+2z29+z30+2z36+2z37+2z38+z39+z40+2z41+z42+2z44+2z46+z47+2z48+2z49+2z50+\ 2z52+z55+z57+z58+2z59, 2z+2z2+2z3+2z6+2z7+z8+2z9+2z10+z11+2z13+z14+z15+z16+z17+z19+z20+2z21+z22+z23\ +z24+2z25+z26+z27+z28+2z29+2z31+z32+2z33+z34+2z35+z36+z37+2z39+z40+2z41+z44+2z\ 46+z47+2z49+2z51+z52+2z53+z55+2z56, 1+z, 1+z2+z4+z5+2z6+z7+2z8+z9+z11+2z13+z14+z15+2z16+z17+z18+2z19+z20+2z21+2z22+z2\ 3+z25+z27+2z28+z29+z31+2z35+z36+2z37+z38+z39+2z40+z42+2z43+z45+z46+2z47+2z49+2\ z51+z52+z53+2z55+z58+2z59, 2+z+z2+z3+2z4+z5+z6+2z7+2z9+2z10+2z11+2z12+z16+2z17+2z18+2z19+2z21+2z25+2z26\ +z27+2z28+z29+z30+2z31+2z34+2z35+2z36+z37+2z38+z39+2z40+z42+z43+z46+2z47+z48+z\ 49+2z52+z53+z55+2z57+z58+z59, 2+z+2z3+z5+z7+z8+z9+2z10+2z12+2z13+z14+z19+2z20+2z22+z23+2z26+z27+2z28+z29+2\ z30+2z32+z33+2z34+z35+2z37+z38+z40+2z41+z42+2z43+z44+z45+2z46+z47+2z48+2z49+z5\ 1+2z53+z56+2z57+z58+2z59, 1+z3+2z4+z5+2z7+2z8+2z9+2z10+z11+z12+z13+2z14+2z18+z20+2z24+2z25+2z28+z29+z3\ 0+z31+2z32+2z33+2z34+z35+2z36+z37+2z38+2z40+2z44+2z46+2z47+2z49+2z50+z52+z53+z\ 57+z58+z59, 1+2z+z2+z3+z7+z8+z11+z12+z13+z14+z16+z17+z18+2z19+z20+2z22+2z24+2z25+z28+2z3\ 0+z34+2z35+2z37+2z38+2z39+z40+z41+2z42+z45+z46+z47+z48+2z51+z53+z54+2z55+z56+2\ z57+2z58+2z59, z+z3+z4+2z5+2z6+z8+2z10+2z11+z12+z15+z16+2z19+2z21+z22+2z25+z29+z30+z31+z32+\ 2z33+z34+2z38+z39+2z41+2z43+z48+z49+2z50+2z53+z54+z55+z56+z57+2z58+2z59, 2+2z3+2z4+z5+2z6+2z8+z10+z11+2z12+z14+2z15+2z16+2z17+2z18+2z19+z20+2z21+2z22\ +2z23+z25+z27+z30+z31+2z32+2z33+2z34+z36+z37+z39+z40+z41+2z44+z45+2z47+2z48+2z\ 49+z53+z54+z55+2z56+z59, 2+z4+z6+2z7+z8+2z13+2z16+2z17+z19+2z20+2z22+z23+z24+2z25+2z26+2z27+2z28+z33+\ 2z35+z38+2z39+z40+z41+2z42+z44+z45+2z47+2z49+z50+2z51+2z52+z54+z55+z56+2z57+2z\ 58+2z59, 2+z+z2+z3+z4+2z6+z9+z10+2z11+2z14+2z15+z16+z17+z20+z21+z22+z26+z27+z28+z29+z\ 31+2z32+2z33+2z34+2z36+2z37+z38+2z41+2z42+z45+z46+z47+z50+z52+z53+z54+2z56+2z5\ 7+2z58+2z59, 2+z+z2+2z3+2z4+z6+z7+z9+2z10+2z11+z12+2z14+z15+2z16+2z19+z21+z24+2z26+z28+z2\ 9+z30+2z32+2z33+2z34+2z35+z37+z40+2z41+z42+z46+z48+2z49+z50+z53+2z54+2z55+2z56\ +2z58+z59, 14+z, 5+2z+16z2+8z3, 4z+13z2+8z3+4z4+8z6+16z7+9z8+14z9+16z10+11z11, 254+z, 254+z, 65504+z, 65534+z, 268435396+z, 4294967289+z, 1152921504606846881+z, 18446744073709551627+z ] gap> List(fieldpairs, pdd -> Z(pdd[1],pdd[2])*Z(pdd[1],pdd[3])); [ z, 1+z2+z4+z9+z10+z13+z14+z15+z16+z18+z20+z21+z24+z25+z29+z30+z31+z33, 1+z+z3+z9+z10+z11+z14+z19+z20+z21+z22+z23+z25+z26+z33+z35+z36+z37+z41+z43+z4\ 6+z47+z49, z+z3+z4+z5+z7+z10+z14+z15+z17+z19+z26+z28+z31+z32+z37+z40+z41+z44+z45+z47+z4\ 8+z51+z53+z55+z57+z60+z62+z64+z65+z66+z67, 1+z3+z5+z6+z7+z9+z10+z11+z12+z13+z14+z16+z18+z19+z22+z26+z28+z29+z31+z34+z42\ +z44+z47+z51+z55+z56+z58+z60+z64+z68+z71+z72+z73+z74+z75+z76+z77+z80+z81+z82+z\ 84, 1+z+z4+z6+z8+z10+z11+z13+z15+z16+z17+z19+z20+z23+z26+z31+z37+z38+z39+z42+z45\ +z46+z50+z51+z52+z56+z57+z62+z63+z65+z66+z69+z71+z72+z73+z76+z81+z83+z84+z85+z\ 87+z88+z91+z93+z98+z100+z101, 1+z2+z4+z6+z8+z11+z13+z16+z17+z20+z21+z23+z24+z27+z28+z29+z32+z35+z36+z38+z4\ 0+z48+z49+z51+z52+z54+z55+z56+z58+z59+z61+z68+z69+z70+z72+z75+z77+z78+z79+z80+\ z81+z87+z91+z92+z96+z101+z102+z107+z109+z111+z112+z113+z115+z118, z, z+z2+z4+z5+z6+z7+z9+z10+z15+z18+z19+z20+z21+z22+z25+z30+z31, z2+z3+z8+z13+z17+z19+z22+z23+z24+z27+z29+z31+z33+z37+z39+z40+z42+z45+z48+z51\ +z52+z54+z55+z58+z59+z60+z63+z64+z68+z69+z70+z76+z78+z79+z81+z82+z83+z86+z87+z\ 88+z89+z93+z94+z95, z2+z5+z6+z7+z9+z11+z13+z15+z16+z18+z19+z20+z21+z22+z23+z24+z25+z26+z30+z31, z+z3+z6+z8+z10+z16+z18+z19+z25+z26+z28+z32+z35+z36+z40+z41+z42+z43+z44+z45+z\ 47+z48+z49+z50+z51+z52+z53+z54+z55+z56+z57+z58+z60+z65+z67+z69+z71+z72+z74+z77\ +z83+z84+z88+z89+z91+z93+z94+z95, 1+z8+z9+z11+z13+z18+z20+z21+z22+z23+z30, z+z2+z3+z4+z5+z6+z7+z8+z10+z11+z13+z15+z18+z20+z21+z24+z26+z27+z28+z29+z30+z\ 32+z37+z38+z39+z40+z43+z46+z47+z48+z49+z52+z53+z54+z57+z62+z66+z67+z68+z70+z74\ +z77+z79+z80+z82+z83+z86+z87+z89+z90+z91+z93+z94+z95, 1+z4+z5+z6+z8+z9+z11+z12+z16+z17+z21+z24+z27+z29+z30+z31, 1+z+z3+z5+z6+z10+z11+z13+z14+z17+z18+z19+z20+z23+z25+z27+z29+z33+z34+z41+z42\ +z43+z45+z46+z47+z50+z51+z53+z54+z55+z56+z57+z60+z61+z62+z64+z67+z68+z70+z73+z\ 75+z77+z81+z82+z84+z88+z89+z94, z, 1+z4+z6+z10+z15+z17+z18+z19+z20+z21+z24+z28+z30+z31+z32+z33+z34+z37+z40+z41+\ z45+z51+z52+z54+z55+z56+z58, z+z6+z8+z9+z12+z13+z16+z18+z23+z24+z25+z28+z29+z30+z32+z35+z36+z38+z39+z40+z\ 43+z48+z49+z52+z53+z54, z+z2+z3+z4+z5+z8+z9+z10+z11+z12+z17+z19+z20+z21+z22+z24+z27+z28+z32+z33+z35+\ z37+z38+z40+z41+z42+z43+z46+z47+z48+z50+z51+z52+z54+z55+z57+z58+z59, 1+z2+z5+z7+z10+z14+z17+z18+z19+z20+z23+z24+z25+z28+z31+z33+z34+z36+z37+z40+z\ 41+z44+z45+z46+z47+z49+z52+z54+z55+z56+z57, 1+z4+z7+z10+z13+z15+z18+z19+z20+z21+z23+z25+z27+z30+z33+z34+z35+z37+z38+z41+\ z42+z44+z47+z49+z50+z52+z53+z58+z59, 1+z2+z3+z4+z5+z6+z7+z12+z16+z17+z19+z20+z22+z26+z27+z28+z29+z30+z33+z36+z37+\ z38+z40+z41+z45+z46+z47+z48+z52+z53+z54+z56+z57+z59+z62+z64+z69+z73+z75+z85+z8\ 7+z89+z92+z95+z100+z101+z104+z105+z106+z108+z110+z113+z115+z118, 1+z2+z3+z7+z8+z9+z11+z16+z17+z20+z22+z23+z26+z27+z29+z30+z31+z35+z36+z37+z38\ +z39+z40+z43+z44+z45+z48+z49+z51+z54+z55+z57+z58, z2+z5+z7+z8+z14+z15+z17+z18+z19+z20+z21+z22+z23+z25+z27+z29+z32+z34+z35+z36+\ z38+z40+z44+z48+z49+z52+z53+z55+z59, 1+z+z3+z4+z7+z8+z9+z10+z12+z15+z19+z22+z26+z29+z32+z34+z35+z36+z40+z42+z43+z\ 44+z45+z48+z49+z51+z52+z53+z55+z57+z58, z+z3+z4+z5+z8+z12+z15+z16+z17+z18+z19+z23+z26+z27+z30+z35+z36+z37+z38+z39+z4\ 1+z45+z46+z47+z48+z49+z51+z53+z56+z57+z58+z59, <>, 1+z4+z11+z12+z14+z16+z17+z21+z22+z24+z25+z27+z30+z32+z33+z34+z36+z40+z41+z47\ +z49+z51+z52+z56+z57+z58, <>, z, 1+z+z4+z5+z7+z8+z9+z11+z14+z16+z20+z21+z25+z26+z28+z29+z32+z35+z38+z39+z43+z\ 46+z47+z48+z51+z52+z55+z56+z58+z59+z61+z63+z64+z65+z66+z67+z68+z70+z72+z74, 1+z3+z4+z8+z9+z10+z14+z15+z18+z22+z23+z24+z25+z29+z30+z32+z34+z38+z40+z44+z4\ 5+z46+z47+z49+z50+z53+z54+z57+z58+z61+z64+z65+z66+z70+z71+z72+z74+z75, z+z2+z3+z6+z7+z8+z9+z11+z13+z14+z16+z17+z19+z20+z21+z27+z29+z34+z36+z38+z41+\ z42+z44+z45+z46+z47+z49+z50+z53+z54+z55+z56+z58+z61+z63+z66+z68+z73+z74+z75, z2+z3+z4+z6+z7+z9+z10+z12+z20+z24+z28+z32+z33+z35+z36+z37+z39+z43+z47+z49+z5\ 0+z51+z54+z59+z60+z61+z63+z64+z66+z67+z68+z69+z70+z71+z75, z, 1+z2+z4+z5+z6+z7+z8+z11+z12+z13+z14+z20+z23+z27+z29+z31+z32+z33+z35+z37+z41+\ z43+z44+z45+z49+z52+z53+z56+z57+z58+z61+z62+z63+z64+z65+z66+z68+z69+z70+z71+z7\ 2+z73+z76+z78+z80+z82+z84+z85, z3+z7+z9+z10+z11+z15+z16+z17+z20+z21+z23+z24+z27+z29+z31+z32+z34+z35+z38+z42\ +z47+z51+z52+z55+z56+z57+z58+z59+z60+z61+z62+z64+z65+z67+z69+z72+z73+z77+z79+z\ 82+z83+z84+z85+z86, 2z, 1+z+2z2+2z3+z4+z5+z9+2z12+2z14+z17+z18, 1+2z+2z2+z3+2z4+z6+z7+2z8+2z9+2z10+z11+2z13+2z14+2z16+z18+z20+z21+2z22+2z24+\ 2z25+z26+z27+2z31, 2z+2z2+z3+z6+2z7+z8+2z11+2z12+2z13+z16+2z17+z18+2z22+2z24+2z26+z27+z28+z29+2\ z30+2z31+2z32+z33+z37+z38+2z41, 2z2+2z4+z5+z6+2z9+2z11+z12+z13+z16+z17+z18+2z19+z21+z23+z24+z27+z28+2z31+z32\ +2z33+2z34+2z36+2z39+2z41+2z44+z45+2z46+2z47+2z48+2z51+2z52+2z53+2z54, 1+z+z2+2z3+z5+z6+2z8+z9+2z13+2z16+2z17+2z18+2z19+z20+z21+z22+2z23+z24+2z25+z\ 26+2z27+z28+z33+2z34+2z35+z36+2z38+2z39+z40+2z41+z42+z44+z45+z47+z48+z49+z50+2\ z51+2z52+z53+2z54+2z55+z56+2z57+2z59+2z60+2z61+2z62+2z63, 1+2z+z5+2z8+2z9+z12+z13+2z16+2z17+z19+z20+z24+z25+z27+z29+z30+z31+z32+2z33+2\ z34+z35+2z38+z39+2z42+z44+z45+2z46+z48+z49+z50+z52+2z54+2z55+2z57+z58+z59+2z62\ +z64+2z66+z68+z69+z71+2z72+z73+z75, 2z, 1+2z+2z3+z9+2z14+2z15+z16+2z18+2z19, 2+2z+2z2+z6+z7+2z10+z17+z19+2z20+2z21+z24+2z25+2z27+z28+z29+2z30+z31+2z32+2z\ 35+z36+2z37+z38+2z40+2z41+2z42+z44+2z46+z47+z49+z51+z52+z54+z56+2z57+2z58+z59, 1+z2+2z3+2z6+z7+2z9+2z10+2z11+2z12+z14+z15+z16+2z17+z18+z19, 1+2z+z2+z4+2z5+z6+z7+2z8+z9+2z10+2z11+z12+z17, 1+z+2z2+2z3+z5+2z6+z7+2z10+2z11+2z12+2z13+z14+z15+z16+2z17+2z18+z20+2z21+2z2\ 3+2z24+2z25+z28+2z30+z31+2z32+z34+2z36+z37+z41+2z42+2z43+2z44+z45+z47+z48+2z49\ +z53+z54+2z55+z56+2z59, 1+z+2z2+z3+2z6+z7+z10+2z11+z13+2z14+z15+z16+z17+2z18+z19+z21+z22+z23+z24+2z2\ 5+z28+2z29+2z31+2z33+z35+z36+z38+2z39, 2+z+2z3+z5+2z9+z10+z12+z13+z14+z15+z16+z18+z19, 2+z+2z4+2z6+2z7+z8+2z10+z11+z12+z13+z16+z18+2z19+z20+2z22+z23+z25+2z26+2z28+\ z29+z30+2z31+2z32+2z33+z37+z38+z40+z41+z42+2z46+2z47+2z48+z50+z51+2z52+2z53+2z\ 54+2z55+z56+z57, 2+z+2z2+2z4+2z6+2z7+2z9+2z11+2z12+2z13+z14+z15+2z16+2z17+2z18+2z20+2z21+z22+\ z23+2z24+2z25+z28+z29+z30+2z31+z32+2z33+2z34+2z35+z36+2z37+2z39+2z40+z41+2z42+\ 2z43+2z44+2z45+z46+z47+2z48+z49+z50+z51+z52+z53+2z54+z57+2z58, 2z, 1+2z+2z2+z4+z5+z7+z9+z10+z11+2z12+z17+2z18+2z19+z21+2z22+z23+z27+z29+z30+z32\ +z33+2z34+2z35+2z36+2z37+2z38+z40+2z41+2z43+2z46+2z47+z48+z50+z52+2z53+2z54+z5\ 6+2z59, 2+z+2z2+z3+z4+2z5+z6+2z7+2z10+z12+z13+z14+2z15+2z16+2z17+z18+z19+2z20+z21+2z\ 24+z28+z29+2z31+2z32+2z33+z34+2z35+z37+z38+2z43+2z47+z48+2z49+2z50+z53+2z54+2z\ 56+z58+2z59, 1+z+z2+z3+2z4+2z5+2z9+z10+2z11+z13+z16+z20+z22+z23+z26+2z27+z29+z30+z31+2z32\ +2z33+z34+2z38+2z40+z42+2z43+2z45+2z46+z47+2z48+z49+z50+2z52+z54+2z57+z58+2z59 , 2+2z+2z3+z4+2z5+z6+z9+2z10+2z12+2z13+2z16+z19+z20+2z22+2z24+z25+2z27+2z28+z2\ 9+2z31+2z34+2z35+z36+z37+z38+z40+z44+z45+z47+z48+z50+z51+2z53+2z54+2z58+2z59, 1+2z+2z5+z6+2z9+2z10+z11+2z12+2z13+z14+z16+2z17+2z18+2z19+z21+z22+z23+z24+z2\ 5+2z26+z27+z28+2z29+2z30+z31+2z32+z33+2z34+z35+2z36+2z38+2z39+2z42+z43+2z44+2z\ 46+2z47+2z48+2z49+z52+2z54+2z55+z56+2z57+z58+z59, 1+z2+z3+z5+2z6+z7+z8+2z9+2z10+2z11+z12+2z13+2z14+z15+2z17+2z21+2z22+2z23+z24\ +2z26+z27+z28+z30+2z31+z32+z35+z36+z38+2z39+z40+z41+z42+2z49+2z50+z51+z54+2z55\ +2z56+2z57+2z58+z59, 2+z+2z3+2z5+z6+z7+2z8+z9+z10+z11+2z12+z13+z14+z15+z17+z18+z19+2z20+z23+z26+2\ z27+z28+z30+2z31+2z34+2z35+2z36+2z37+z38+2z39+z41+2z42+z44+z45+2z46+z48+z49+z5\ 0+2z54+2z55+2z56+z57, 1+z+2z2+z3+z4+z5+z6+2z7+2z8+2z9+2z10+z11+z15+z16+z17+z18+z20+z22+z23+2z25+2z\ 26+2z27+2z28+z29+2z30+2z32+z33+z34+2z35+2z36+z38+2z42+z43+2z44+2z45+2z46+z48+z\ 50+2z51+z52+z53+2z55+2z56+2z57+z58+z59, 1+z+z2+z5+z6+z7+z8+z10+z12+2z14+2z15+2z16+2z17+2z18+2z20+z21+2z23+z24+z26+2z\ 29+z30+z32+2z33+z36+z37+2z38+2z40+z41+z42+z43+2z44+2z46+2z47+2z48+2z51+2z53+2z\ 54+2z55+z57+z58+z59, 2+z+2z2+z3+2z5+2z6+2z7+z8+z12+2z13+z14+z16+z17+2z20+z21+z22+2z24+2z25+2z26+2\ z28+2z29+2z31+z32+2z34+2z35+z38+2z39+z40+z41+z42+2z43+z44+2z47+2z49+z50+2z51+2\ z54+z55+z56+z57+z59, 3z, 7+7z+4z2+z3, 5+12z+z2+11z3+3z5+8z6+z7+11z8+10z9+16z10+7z11, 3z, 3z, 17z, 3z, 3z, 2z, 2z, 2z ] gap> List(fieldpairs, pdd -> Z(pdd[1],pdd[2])/Z(pdd[1],pdd[3])); [ z, z+z4+z7+z8+z9+z10+z13+z14+z17+z18+z19+z23+z24+z25+z26+z27+z28+z29+z32, 1+z+z9+z10+z12+z13+z20+z21+z26+z28+z30+z31+z32+z33+z34+z37+z39+z46+z48+z49+z\ 50, z+z5+z6+z10+z11+z12+z15+z16+z20+z24+z25+z28+z34+z36+z37+z38+z40+z43+z44+z45+\ z46+z47+z48+z49+z53+z55+z57+z58+z59+z63+z64, z+z2+z5+z8+z9+z13+z14+z15+z16+z20+z21+z22+z24+z26+z27+z28+z29+z30+z31+z32+z3\ 3+z38+z41+z42+z44+z46+z48+z49+z50+z53+z55+z59+z62+z63+z65+z66+z68+z70+z72+z75+\ z77+z78+z79+z80+z82+z83, 1+z2+z7+z8+z9+z10+z11+z12+z13+z16+z17+z19+z20+z22+z27+z28+z29+z30+z34+z36+z3\ 7+z39+z40+z41+z45+z47+z51+z52+z54+z56+z58+z59+z60+z63+z65+z67+z68+z69+z72+z74+\ z81+z84+z88+z89+z90+z93+z95+z97+z101, 1+z2+z3+z4+z8+z10+z11+z12+z14+z15+z16+z21+z22+z24+z32+z33+z34+z36+z39+z40+z4\ 4+z50+z51+z52+z54+z62+z63+z65+z68+z70+z71+z74+z77+z80+z88+z89+z92+z94+z101+z10\ 2+z104+z107+z108+z109+z110+z111+z118, z, z2+z4+z5+z6+z7+z9+z10+z15+z18+z19+z20+z21+z22+z25+z30+z31, 1+z3+z8+z9+z10+z12+z13+z16+z17+z18+z20+z23+z24+z28+z29+z31+z34+z36+z38+z40+z\ 42+z43+z46+z47+z48+z51+z55+z56+z57+z59+z63+z64+z65+z66+z69+z71+z72+z73+z77+z79\ +z81+z82+z83+z85+z86+z87+z88+z90+z91+z92+z93+z94+z95, z+z2+z4+z6+z8+z9+z12+z16+z17+z18+z20+z21+z23+z24+z26+z28+z29+z30, 1+z3+z6+z7+z8+z10+z11+z13+z15+z16+z17+z18+z19+z21+z22+z29+z31+z32+z36+z37+z3\ 8+z39+z40+z41+z42+z45+z46+z47+z48+z49+z50+z51+z53+z55+z58+z61+z62+z65+z67+z68+\ z72+z73+z76+z78+z81+z84+z87+z88+z92+z93+z94+z95, z2+z7+z8+z11+z14+z16+z17+z19+z21+z24+z25+z27+z28+z30+z31, 1+z2+z3+z5+z9+z11+z13+z15+z16+z17+z18+z19+z20+z23+z26+z27+z33+z39+z40+z41+z4\ 5+z46+z48+z49+z50+z51+z53+z55+z56+z59+z60+z61+z62+z63+z64+z65+z67+z68+z69+z70+\ z73+z77+z82+z83+z84+z88+z89+z90+z91+z93+z94+z95, 1+z3+z4+z5+z7+z10+z11+z13+z14+z15+z16+z18+z19+z20+z22+z23+z24+z26+z29+z30+z3\ 1, z+z2+z7+z10+z11+z13+z14+z18+z20+z21+z24+z25+z27+z30+z33+z34+z37+z38+z39+z41+\ z43+z44+z46+z48+z50+z51+z52+z55+z56+z58+z59+z63+z65+z66+z67+z68+z69+z71+z76+z7\ 8+z80+z81+z83+z88+z89+z90+z91+z92+z94, z, 1+z+z4+z6+z10+z15+z17+z18+z19+z20+z21+z24+z28+z30+z31+z32+z33+z34+z37+z40+z4\ 1+z45+z51+z52+z54+z55+z56+z58, z+z2+z5+z6+z7+z8+z10+z11+z12+z13+z15+z17+z19+z20+z22+z23+z24+z25+z26+z27+z29\ +z32+z34+z38+z39+z41+z43+z50+z52+z56+z57, 1+z2+z3+z5+z6+z7+z8+z11+z14+z16+z19+z20+z22+z23+z26+z27+z30+z31+z32+z36+z42+\ z43+z44+z45+z47+z48+z50+z52+z58+z59, 1+z4+z6+z7+z8+z9+z10+z13+z17+z20+z21+z25+z26+z35+z37+z38+z44+z45+z47+z48+z56\ +z57+z58+z59, 1+z2+z4+z5+z6+z7+z9+z11+z16+z21+z22+z24+z26+z27+z31+z32+z33+z35+z36+z37+z45+\ z48+z49+z50+z51+z52+z53+z55+z57+z58, 1+z3+z5+z8+z9+z11+z13+z16+z17+z20+z21+z22+z26+z27+z28+z29+z32+z33+z35+z42+z4\ 6+z47+z49+z50+z51+z52+z55+z60+z61+z62+z63+z66+z67+z69+z70+z72+z73+z74+z78+z80+\ z81+z82+z83+z87+z88+z92+z93+z96+z99+z100+z102+z103+z105+z106+z107+z108+z115+z1\ 16, z+z2+z3+z4+z6+z8+z9+z10+z11+z12+z13+z14+z15+z17+z20+z24+z25+z28+z30+z37+z40+\ z41+z42+z45+z46+z48+z50+z51+z54+z57+z58, z2+z3+z5+z6+z7+z10+z11+z13+z15+z16+z21+z22+z26+z29+z30+z32+z33+z35+z36+z37+z\ 38+z43+z45+z46+z47+z49+z50+z51+z53+z54+z56+z58, z2+z3+z4+z6+z9+z12+z13+z14+z16+z24+z25+z26+z30+z31+z32+z34+z37+z40+z42+z43+z\ 44+z45+z46+z49+z50, z3+z8+z9+z13+z14+z17+z19+z22+z23+z24+z25+z28+z29+z32+z33+z36+z38+z40+z41+z42\ +z43+z44+z46+z47+z51+z53+z54+z57, z2+z3+z4+z7+z12+z17+z19+z20+z21+z22+z23+z28+z29+z30+z31+z32+z34+z36+z37+z38+\ z41+z50+z51+z57+z58+z60+z61+z63+z66+z67+z68+z69+z73+z74+z75+z76+z79+z81+z82+z8\ 3+z85+z87+z89+z93+z94+z97+z98+z99+z100+z101+z102+z104+z106+z107+z110+z112+z116\ +z117, z2+z4+z5+z6+z8+z10+z11+z12+z16+z17+z18+z20+z21+z23+z24+z25+z27+z30+z34+z36+z\ 38+z39+z41+z43+z44+z45+z48+z49+z51+z53+z54+z56+z59, 1+z+z2+z6+z11+z13+z17+z18+z22+z23+z24+z26+z31+z32+z33+z35+z40+z44+z45+z47+z4\ 8+z49+z51+z55+z57+z59+z62+z66+z67+z69+z71+z74+z76+z77+z79+z81+z82+z83+z88+z89+\ z90+z93+z94+z96+z97+z98+z99+z102+z104+z105+z106+z108+z111+z112+z114+z118+z119, z, 1+z4+z5+z7+z8+z9+z11+z14+z16+z20+z21+z25+z26+z28+z29+z32+z35+z38+z39+z43+z46\ +z47+z48+z51+z52+z55+z56+z58+z59+z61+z63+z64+z65+z66+z67+z68+z70+z72+z74, z2+z4+z7+z8+z9+z11+z12+z13+z15+z16+z17+z19+z22+z23+z25+z26+z31+z34+z35+z37+z\ 38+z41+z42+z44+z45+z47+z50+z53+z54+z55+z56+z57+z58+z61+z62+z64+z67+z68+z69+z70\ +z71+z72+z73+z75, 1+z2+z3+z8+z9+z10+z11+z13+z17+z19+z21+z25+z26+z27+z28+z29+z31+z32+z35+z36+z4\ 1+z43+z47+z51+z52+z59+z60+z61+z63+z64+z67+z69+z75, z2+z3+z8+z9+z11+z14+z15+z16+z20+z21+z22+z24+z27+z28+z30+z33+z34+z39+z40+z41+\ z44+z46+z48+z50+z51+z53+z58+z61+z62+z63+z64+z65+z66+z67+z68+z69+z70+z71+z72+z7\ 3+z74+z75, z, 1+z2+z4+z5+z6+z8+z11+z13+z15+z16+z18+z20+z24+z25+z27+z29+z30+z31+z33+z37+z40\ +z42+z44+z45+z48+z49+z50+z53+z54+z55+z58+z59+z62+z63+z65+z67+z68+z69+z70+z71+z\ 72+z73+z74+z75+z77+z79+z80+z84+z86, z2+z4+z7+z9+z12+z13+z18+z19+z21+z22+z24+z25+z28+z29+z30+z33+z34+z36+z39+z43+\ z45+z46+z50+z51+z52+z55+z57+z58+z60+z61+z62+z65+z66+z69+z71+z73+z74+z75+z77+z7\ 8+z79+z80+z81+z82, 2z, 2+z+2z2+2z5+2z6+z7+z8+z9+2z10+z12+z14+z15+2z16+2z17+2z18+z19+z20, 2+2z5+2z6+2z7+2z8+2z9+2z11+2z13+2z14+2z16+2z19+z21+z22+z23+2z24+z25+2z26+z29\ +z30+2z31+2z32, 1+z+z2+2z3+z6+z7+z8+z9+2z10+2z11+z12+2z14+z15+z26+z27+2z29+z30+z31+2z33+2z34\ +z35+z36+z41+2z42, 2+2z+z2+2z3+z4+z5+z7+z8+z11+2z13+2z14+2z20+2z21+2z22+2z26+z28+z29+z30+z31+2z\ 32+z33+2z34+2z35+2z38+z39+z40+2z41+2z42+2z43+z44+z46+z48+z49+2z52+2z53+2z54, 1+z+z2+z4+2z5+2z7+z8+z9+z10+2z11+z13+z14+2z16+2z18+2z19+z20+2z22+2z25+z26+2z\ 28+z29+z30+2z31+2z32+z33+2z36+z38+2z39+2z42+2z43+z44+2z45+2z46+2z48+2z49+2z50+\ 2z54+2z55+z57+z58+z60+2z65, 2+z+z3+2z4+2z5+2z6+2z7+z8+2z10+z11+z14+2z15+2z18+z19+z24+2z25+z26+z27+z30+z3\ 1+2z32+2z33+2z35+z36+z38+z39+2z40+z41+2z43+2z45+z46+2z48+2z50+z52+2z53+z55+z59\ +2z60+z61+z63+z65+2z66+z67+2z68+z69+z70+z73+z75+z76, 2z, 1+z+2z3+z9+2z14+2z15+z16+2z18+2z19, 1+2z2+2z3+2z4+z5+2z6+2z8+2z9+z10+z13+2z16+2z17+z18+z19+2z20+z22+2z25+z27+2z2\ 8+z29+2z31+z32+z33+z35+z37+2z40+z41+2z48+2z50+z52+z53+z54+2z55+2z57+z58, 2z+z3+z4+z5+z8+2z9+2z10+z11+2z12+2z14+2z16+2z18+2z19, 2+z3+2z4+2z6+2z7+2z10+z11+2z13+2z14+2z17+2z18+z19, 2+z3+2z4+2z6+2z8+z9+z10+2z12+z13+2z14+2z16+z19+z21+z22+2z23+z24+2z25+2z26+2z\ 28+2z29+z30+z32+2z33+2z34+2z35+z37+z39+z41+2z42+z44+2z45+z46+2z47+z48+z49+z51+\ z52+2z53+2z54+2z55+z57+2z58+z59, 2+2z2+z3+2z4+z6+z8+z10+z11+2z13+z15+2z16+z17+z19+z20+2z22+z23+2z24+z25+2z26+\ 2z27+z28+2z29+z30+z31+z32+2z33+z35+z36+2z37+2z39, z+z2+2z3+2z5+2z7+2z8+2z9+z10+2z11+2z12+z13+z14+z15+z18, z+2z3+2z4+z5+2z6+2z7+z8+2z12+2z15+z16+2z17+z18+2z19+2z20+z21+2z24+2z25+2z26+\ 2z28+2z29+2z31+z33+z34+z35+z37+z38+z40+2z41+z42+2z43+z45+z46+z47+2z48+2z51+2z5\ 3+z54+2z56+2z57+2z58+2z59, 1+z2+z3+2z5+z6+2z8+z11+2z12+z14+2z16+2z19+2z20+2z21+z22+z23+z25+z26+2z28+z29\ +z30+2z32+2z33+z34+z35+z36+2z38+2z39+z40+2z41+2z45+z47+z55+2z56+2z57, 2z, 1+z+2z2+z4+z5+z7+z9+z10+z11+2z12+z17+2z18+2z19+z21+2z22+z23+z27+z29+z30+z32+\ z33+2z34+2z35+2z36+2z37+2z38+z40+2z41+2z43+2z46+2z47+z48+z50+z52+2z53+2z54+z56\ +2z59, 2+2z+2z2+z4+z5+2z6+z8+2z12+2z13+2z15+z16+z17+2z18+2z19+2z20+z22+z23+z24+2z25\ +2z26+z27+2z29+2z30+2z32+z33+z34+2z35+z36+2z37+2z38+z39+2z40+2z41+z42+z43+z44+\ z45+z46+z50+z51+z54+z55+2z56+2z58+2z59, 2+z3+2z4+2z5+z9+2z10+z11+2z12+2z13+z14+2z17+z19+2z21+z22+z24+z25+2z26+z27+z2\ 8+z29+z30+2z31+z32+z34+2z35+2z36+2z37+z39+z41+z42+2z43+z44+z45+z46+z48+z49+z50\ +z51+z52+2z53+2z54+2z55+z56+z59, 1+2z2+2z5+z6+z7+2z10+z11+2z12+2z13+2z14+2z16+z18+z19+z20+2z22+2z23+2z24+2z25\ +z26+2z27+2z28+2z30+z31+z32+2z33+2z34+2z35+2z36+2z37+2z38+z40+z41+2z43+z44+2z4\ 5+2z46+z47+z48+z50+2z52+2z53+z55+2z58, 2z2+z3+z4+z6+z7+z11+z14+z16+2z17+2z18+z19+z20+z21+z22+z23+z26+2z27+2z28+z29+\ z30+2z31+2z32+2z34+2z35+2z36+z38+z39+z40+2z42+z45+2z46+2z49+2z51+z52+z53+2z54+\ 2z55+2z56+2z57+z58+2z59, 2+z+2z5+z6+z7+z8+z9+z14+z15+z16+2z17+2z19+z20+2z21+z23+z24+2z25+2z26+2z28+2z\ 30+2z32+z33+2z34+z36+2z37+z38+z40+z41+z42+2z43+z44+2z48+z50+2z52+2z53+2z54+z55\ +z56+2z58, 2+2z+z2+2z3+2z4+2z6+z9+2z11+z14+2z15+2z16+z17+2z18+2z19+2z20+2z21+z23+z24+z2\ 5+z26+2z27+z29+2z30+2z31+z32+2z34+2z36+z37+2z38+2z39+z40+2z41+z42+z43+z44+2z45\ +2z46+z47+2z48+2z49+z50+2z51+z52+z55+z56+z57+z59, z3+2z5+2z6+2z7+z9+z10+2z11+z12+z15+2z17+z18+z19+2z20+z21+z22+z24+z25+z27+z28\ +z30+z32+2z33+z34+2z35+2z36+2z37+z38+2z40+2z41+2z45+z46+z47+2z48+z49+2z50+z53+\ 2z54+2z55+z56+z57+z59, 2+z+2z4+2z5+z6+z7+z9+z10+2z11+z12+2z13+z15+z16+2z17+2z22+z25+2z26+z29+2z32+z\ 33+z35+2z37+2z38+z40+2z41+z44+z45+2z46+2z48+2z49+2z50+z52+z56+2z58+z59, 2z+2z2+2z4+z5+2z7+z8+2z9+2z10+2z12+z14+2z15+z16+z17+2z18+z19+z20+z21+2z22+z2\ 5+2z26+z28+2z29+z30+z32+z33+2z34+z35+2z36+z39+z40+2z41+z42+z44+2z46+z47+2z48+z\ 49+z51+2z52+z53+z54+z57+z58+2z59, 6z, 9+15z+10z2+11z3, 5+7z+14z2+13z3+10z4+10z5+4z6+13z7+5z8+12z9+3z10+7z11, 86z, 86z, 42396z, 21846z, 178956933z, 2147483646z, 576460752303423442z, 9223372036854775815z ] gap> ForAll(fieldsizes, pd -> ForAll(DivisorsInt(pd[2]), d2 -> > Z(pd[1],pd[2])^((pd[1]^pd[2]-1)/(pd[1]^d2-1)) = Z(pd[1],d2) )); true gap> AsInternalFFE(0*Z(2,10)); 0*Z(2) gap> AsInternalFFE(Z(2,10)^0); Z(2)^0 gap> AsInternalFFE(Z(2,10)); Z(2^10) gap> AsInternalFFE(0*Z(7,6)); 0*Z(7) gap> AsInternalFFE(Z(7,6)^0); Z(7)^0 gap> AsInternalFFE(Z(7,6)); fail gap> AsInternalFFE(0*Z(65537,2)); fail gap> AsInternalFFE(Z(65537,2)^0); fail gap> AsInternalFFE(Z(65537,2)); fail gap> SetInfoLevel(InfoPrimeInt,iPI); gap> SetInfoLevel(InfoFactor,iF); gap> if IsBound(InfoFactInt) then SetInfoLevel(InfoFactInt,iFI); fi; gap> SetInfoLevel(InfoWarning,iW); gap> STOP_TEST( "ffeconway.tst", 50200000 ); gap-4r6p5/tst/polytest.g0000644000175000017500000000632712172557256014022 0ustar billbill############################################################################# ## ## ## Polynomial arithmetic timing tests Robert Arthur ## ## ## ############################################################################# if IsBound(Permutations) then # running GAP3 # Without these, the parser doesn't like the GAP4 code's presence LaurentPolynomialByCoefficients:= x->x; ElementsFamily:= x->x; FamilyObj:= x->x; # require a function to test for zero polynomials polyIsZero:= function(p) return p = Polynomial(p.baseRing, []); end; # create a polynomial with base field f, coefficient list l PolynomialTest:= function(f, l) # the actual call return Polynomial(f, l); end; fi; if not IsBound(Permutations) then # running GAP4 PolynomialTest:= function(f, l) return LaurentPolynomialByCoefficients( ElementsFamily(FamilyObj(f)), l, 0); end; polyIsZero:= IsZero; fi; testfields:= [FiniteField(2), FiniteField(3), FiniteField(128), FiniteField(1013), Rationals]; # polys[l] will contain 100 random polynomials over testfields[l]. polys:= List(testfields, x->[]); # Start the calculations! ProdTest:=function() local l,i,j,start,scratch; for l in [1..Length(testfields)] do start:= Runtime(); for i in [1..100] do for j in [1..100] do scratch:= polys[l][i]*polys[l][j]; od; od; Print("Time for product over ",testfields[l],": ", Runtime()-start, "\n"); od; end; AddTest:=function() local l,i,j,start,scratch; for l in [1..Length(testfields)] do start:= Runtime(); for i in [1..100] do for j in [1..100] do scratch:= polys[l][i]+polys[l][j]; od; od; Print("Time for addition over ",testfields[l],": ", Runtime()-start, "\n"); od; end; SubTest:=function() local l,i,j,start,scratch; for l in [1..Length(testfields)] do start:= Runtime(); for i in [1..100] do for j in [1..100] do scratch:= polys[l][i]-polys[l][j]; od; od; Print("Time for subtraction over ",testfields[l],": ", Runtime()-start, "\n"); od; end; # Division not defined for all pairs - we must make sure that p2 divides # p1. Timing only performed for final division. DivTest:=function() local p,l,i,j,start,scratch,total; p:= []; for l in [1..Length(testfields)] do total:= 0; for i in [1..100] do for j in [1..100] do p[j]:= polys[l][i]*polys[l][j]; od; start:= Runtime(); for j in [1..100] do if not polyIsZero(polys[l][i]) then scratch:= p[j]/polys[l][i]; fi; od; total:= total + Runtime() - start; od; Print("Time for division over ", testfields[l],": ",total,"\n"); od; end; DoTests:=function() local i,j,a,l; for i in [1..100] do for j in [1..Length(testfields)] do a:= Random([1..20]); l:= List([1..a], x->Random(testfields[j])); Add(polys[j], PolynomialTest(testfields[j], l)); od; od; Print("Fields are: ", testfields, "\n"); AddTest(); SubTest(); ProdTest(); DivTest(); end; gap-4r6p5/tst/ctblsolv.tst0000644000175000017500000000143312172557256014344 0ustar billbill############################################################################# ## #W ctblsolv.tst GAP Library Thomas Breuer ## ## #Y Copyright (C) 1998, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## To be listed in testinstall.g ## gap> START_TEST("ctblsolv.tst"); gap> CharacterDegrees( SmallGroup( 256, 529 ) ); [ [ 1, 8 ], [ 2, 30 ], [ 4, 8 ] ] gap> for pair in [ [ 18, 3 ], [ 27, 3 ], [ 36, 7 ], [ 50, 3 ], [ 54, 4 ] ] do > G:= SmallGroup( pair[1], pair[2] ); > if CharacterDegrees( G, 0 ) > <> Collected( List( Irr( G ), x -> x[1] ) ) then > Error( IdGroup( G ) ); > fi; > od; gap> STOP_TEST( "ctblsolv.tst", 54000000 ); ############################################################################# ## #E gap-4r6p5/tst/semicong.tst0000644000175000017500000000775312172557256014333 0ustar billbill############################################################################# ## #W semicong.tst GAP library Robert F. Morse ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## To be listed in testinstall.g ## gap> START_TEST("semicong.tst"); gap> ####################################################################### gap> ## gap> ## 1. Testing infinite finitely presented commutative semigroups gap> ## generated by n elements s_1, ... s_n with relations gap> ## of the form s_i^{i+1}=s_i for i=1,...,n-1, and s_i*s_n = s_i gap> ## gap> ## For congruences generated by the torsion elements we have gap> ## full closure. gap> ## gap> ## The following are tests for n=3 gap> ####################################################################### gap> n:=3;; gap> f := FreeSemigroup(n);; gap> gns := GeneratorsOfSemigroup(f);; gap> rel := [];; gap> x:=0;; gap> for x in [1..Length(gns)-1] do > Append(rel,List(gns,y->[gns[x]*y,y*gns[x]])); > Add(rel,[gns[x]^(x+1),gns[x]]); > Add(rel,[gns[x]*gns[Length(gns)],gns[x]]); > Add(rel,[gns[Length(gns)]*gns[x],gns[x]]); > od; gap> s := f/rel;; gap> sgns := GeneratorsOfSemigroup(s);; gap> c := SemigroupCongruenceByGeneratingPairs(s,[[sgns[1],sgns[2]]]);; gap> EquivalenceRelationPartition(c);; gap> ## gap> ## Check to see if elements are in the partition gap> ## true and false gap> ## gap> ec := EquivalenceClassOfElement(c,sgns[n]);; gap> Size(ec); 1 gap> ec := EquivalenceClassOfElement(c,sgns[n-1]);; gap> sgns[n] in ec; false gap> Size(ec); 5 gap> ###################################################################### gap> ## 2. Check partital closure of an infinite block gap> ## gap> ## The semigroup has two generators, is commutative and has gap> ## two blocks. One finite the other infinite. gap> ## gap> ## /[a^3=a, a*b=a, b*a=a] gap> ## gap> ###################################################################### gap> f :=FreeSemigroup(2);; gap> s := f/[[f.1^3,f.1],[f.1*f.2,f.1],[f.2*f.1,f.1]];; gap> gns := GeneratorsOfSemigroup(s);; gap> c:= > SemigroupCongruenceByGeneratingPairs(s,[[gns[1],gns[1]^2],[gns[2],gns[2]^2]]);; gap> ec :=EquivalenceClassOfElement(c,gns[2]);; gap> gns[2]^20 in ec; true gap> gns[2]^40 in ec; true gap> ## gap> ## We should never get a full closure gap> ## gap> HasEquivalenceRelationPartition(c); false gap> ###################################################################### gap> ## 3. Check partital closure with an infinite number of blocks gap> ## gap> ## Create a congruence with an infinite number of blocks gap> ## gap> ###################################################################### gap> f :=FreeSemigroup(2);; # gap> s := f/[[f.1^3,f.1],[f.1*f.2,f.2*f.1]];; # a^3=a, a*b=b*a gap> gns := GeneratorsOfSemigroup(s);; # gap> c := SemigroupCongruenceByGeneratingPairs(s,[[gns[1],gns[1]^2]]);; gap> ec :=EquivalenceClassOfElement(c,gns[1]*gns[2]^20);; gap> gns[1]^2*gns[2]^20 in ec; true gap> ###################################################################### gap> ## 4. Compute some quotient semigroups and compute some finite gap> ## congruences of these quotient semigroups. gap> ## gap> ###################################################################### gap> f := FreeSemigroup("a","b","c");; a:= f.1;; b:=f.2;; c:=f.3;; gap> s := f/[[a^5,a],[b^10,b],[a*b,a],[b*a,a],[c*b,b],[b*c,b],[c*a,a],[a*c,a]];; gap> sng:=GeneratorsOfSemigroup(s);; gap> c := SemigroupCongruenceByGeneratingPairs(s,[[sng[1],sng[1]^2]]);; gap> ec := EquivalenceRelationPartition(c);; gap> s1:=s/c;; gap> sng1 := GeneratorsOfSemigroup(s1);; gap> c := SemigroupCongruenceByGeneratingPairs(s1,[[sng1[1],sng1[1]^2]]);; gap> EquivalenceRelationPartition(c); [ ] gap> c := SemigroupCongruenceByGeneratingPairs(s1,[[sng1[2],sng1[2]^2]]);; gap> ec:=EquivalenceRelationPartition(c);; gap> Size(ec); 1 gap> Size(ec[1]); 9 gap> STOP_TEST( "semicong.tst", 7800000 ); ############################################################################# ## #E gap-4r6p5/tst/vspcrow.tst0000644000175000017500000003161112172557256014220 0ustar billbill############################################################################# ## #W vspcrow.tst GAP library Thomas Breuer ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## (The test file `vspcmat.tst' should contain the same tests, ## applied to matrix spaces.) ## ## To be listed in testinstall.g ## gap> START_TEST("vspcrow.tst"); ############################################################################# ## ## 1. Construct Gaussian and non-Gaussian row spaces ## gap> z:= LeftModuleByGenerators( GF(3), [], [ 0*Z(9) ] ); gap> IsGaussianRowSpace( z ); true gap> IsNonGaussianRowSpace( z ); false gap> v:= LeftModuleByGenerators( GF(9), [ [ Z(3), Z(3), Z(3) ] ] ); gap> IsGaussianRowSpace( v ); true gap> IsNonGaussianRowSpace( v ); false gap> v = LeftModuleByGenerators( GF(9), [ [ Z(3), Z(3), Z(3) ] ], Zero( v ) ); true gap> w:= LeftModuleByGenerators( GF(9), [ [ Z(27), Z(3), Z(3) ] ] ); gap> IsGaussianRowSpace( w ); false gap> IsNonGaussianRowSpace( w ); true gap> w = LeftModuleByGenerators( GF(9), [ [ Z(27), Z(3), Z(3) ] ], Zero( w ) ); true ############################################################################# ## ## 2. Methods for bases of non-Gaussian row spaces ## gap> Dimension( w ); 1 gap> n:= NiceVector( w, [ Z(27), Z(3), Z(3) ] ); [ Z(3), Z(3), Z(3^2)^3, Z(3), 0*Z(3), 0*Z(3), Z(3), 0*Z(3), 0*Z(3) ] gap> UglyVector( w, n ) = [ Z(27), Z(3), Z(3) ]; true ############################################################################# ## ## 3. Methods for semi-echelonized bases of Gaussian row spaces ## gap> v:= LeftModuleByGenerators( GF(9), > [ [ Z(3), Z(3), Z(3) ], [ Z(3), Z(3), 0*Z(3) ] ] ); gap> b:= SemiEchelonBasis( v ); SemiEchelonBasis( , ... ) gap> lc:= LinearCombination( b, [ Z(3)^0, Z(3) ] ); [ Z(3)^0, Z(3)^0, 0*Z(3) ] gap> Coefficients( b, lc ); [ Z(3)^0, Z(3) ] gap> SiftedVector( b, [ Z(3), 0*Z(3), 0*Z(3) ] ); [ 0*Z(3), Z(3)^0, 0*Z(3) ] gap> SiftedVector( b, [ 0*Z(3), 0*Z(3), Z(3) ] ); [ 0*Z(3), 0*Z(3), 0*Z(3) ] gap> b:= Basis( v, [ [ Z(3), Z(3), Z(3) ] ] ); fail gap> b:= Basis( v, [ [ Z(3), Z(3), Z(3) ], [ Z(3), Z(3), 0*Z(3) ] ] ); Basis( , [ [ Z(3), Z(3), Z(3) ], [ Z(3), Z(3), 0*Z(3) ] ] ) gap> IsSemiEchelonized( b ); false gap> b:= Basis( v, [ [ Z(3), Z(3), Z(3) ], [ 0*Z(3), 0*Z(3), Z(3) ] ] ); Basis( , [ [ Z(3), Z(3), Z(3) ], [ 0*Z(3), 0*Z(3), Z(3) ] ] ) gap> IsSemiEchelonized( b ); false gap> b:= Basis( v, [ [ Z(3)^0, Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0, 0*Z(3) ] ] ); Basis( , [ [ Z(3)^0, Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0, 0*Z(3) ] ] ) gap> IsSemiEchelonized( b ); false gap> b:= Basis( v, [ [ Z(3)^0, Z(3)^0, Z(3)^0 ], [ 0*Z(3), 0*Z(3), Z(3)^0 ] ] ); SemiEchelonBasis( , [ [ Z(3)^0, Z(3)^0, Z(3)^0 ], [ 0*Z(3), 0*Z(3), Z(3)^0 ] ] ) gap> IsSemiEchelonized( b ); true ############################################################################# ## ## 4. Methods for row spaces ## gap> m:= Z(3)^0 * [ [ 1, 1 ], [ 1, 0 ], [ 0, 0 ] ]; [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, 0*Z(3) ], [ 0*Z(3), 0*Z(3) ] ] gap> im:= v * m;; gap> Print( im, "\n" ); VectorSpace( GF(3^2), [ [ Z(3)^0, Z(3) ], [ Z(3)^0, Z(3) ] ] ) gap> Dimension( im ); 1 gap> im = v^m; true gap> im:= w * m;; gap> Print( im, "\n" ); VectorSpace( GF(3^2), [ [ Z(3^3)^3, Z(3^3) ] ] ) gap> [] in w; false gap> Zero( w ) in w; true gap> [ 0, 0, 1 ] in w; false gap> Z(3) * [ 0, 1 ] in v; false gap> [ Z(27), Z(3), Z(3) ] in w; true gap> [] in v; false gap> Zero( v ) in v; true gap> [ 0, 0, 1 ] in v; false gap> Z(3) * [ 0, 1 ] in v; false gap> Z(3) * [ 0, 0, 1 ] in v; true gap> BasisNC( v, > [ [ Z(3)^0, Z(3)^0, Z(3)^0 ], [ 0*Z(3), 0*Z(3), Z(3)^0 ] ] ); SemiEchelonBasis( , [ [ Z(3)^0, Z(3)^0, Z(3)^0 ], [ 0*Z(3), 0*Z(3), Z(3)^0 ] ] ) gap> Basis( v ); SemiEchelonBasis( , [ [ Z(3)^0, Z(3)^0, Z(3)^0 ], [ 0*Z(3), 0*Z(3), Z(3)^0 ] ] ) gap> SemiEchelonBasis( v ); SemiEchelonBasis( , [ [ Z(3)^0, Z(3)^0, Z(3)^0 ], [ 0*Z(3), 0*Z(3), Z(3)^0 ] ] ) gap> b:= SemiEchelonBasis( v, > [ [ Z(3), Z(3), Z(3) ], [ 0*Z(3), 0*Z(3), Z(3)^0 ] ] ); fail gap> b:= SemiEchelonBasis( v, > [ [ Z(3)^0, Z(3)^0, Z(3)^0 ], [ 0*Z(3), 0*Z(3), Z(3)^0 ] ] ); SemiEchelonBasis( , [ [ Z(3)^0, Z(3)^0, Z(3)^0 ], [ 0*Z(3), 0*Z(3), Z(3)^0 ] ] ) gap> b:= SemiEchelonBasisNC( v, > [ [ Z(3)^0, Z(3)^0, Z(3)^0 ], [ 0*Z(3), 0*Z(3), Z(3)^0 ] ] ); SemiEchelonBasis( , [ [ Z(3)^0, Z(3)^0, Z(3)^0 ], [ 0*Z(3), 0*Z(3), Z(3)^0 ] ] ) gap> c1:= CanonicalBasis( v );; gap> Print( c1, "\n" ); CanonicalBasis( VectorSpace( GF(3^2), [ [ Z(3), Z(3), Z(3) ], [ Z(3), Z(3), 0*Z(3) ] ] ) ) gap> c2:= CanonicalBasis( VectorSpace( GF(3), BasisVectors( b ) ) );; gap> Print( c2, "\n" ); CanonicalBasis( VectorSpace( GF(3), [ [ Z(3)^0, Z(3)^0, Z(3)^0 ], [ 0*Z(3), 0*Z(3), Z(3)^0 ] ] ) ) gap> c1 = c2; true gap> w:= LeftModuleByGenerators( GF(9), > [ [ Z(27), Z(3), Z(3) ], > [ Z(27), Z(3), Z(3) ], > [ 0*Z(3), Z(3), Z(3) ] ] ); gap> Basis( w ); Basis( , ... ) gap> b:= Basis( w, > [ [ 0*Z(3), Z(3), Z(3) ], [ Z(27), Z(3), Z(3) ] ] ); Basis( , [ [ 0*Z(3), Z(3), Z(3) ], [ Z(3^3), Z(3), Z(3) ] ] ) gap> IsBasisByNiceBasis( b ); true gap> Coefficients( b, [ Z(27), 0*Z(3), 0*Z(3) ] ); [ Z(3), Z(3)^0 ] gap> IsZero( Zero( v ) ); true gap> ForAny( b, IsZero ); false gap> ww:= AsVectorSpace( GF(3), w );; gap> Print( ww, "\n" ); VectorSpace( GF(3), [ [ Z(3^3), Z(3), Z(3) ], [ Z(3^3), Z(3), Z(3) ], [ 0*Z(3), Z(3), Z(3) ], [ Z(3^6)^119, Z(3^2)^5, Z(3^2)^5 ], [ Z(3^6)^119, Z(3^2)^5, Z(3^2)^5 ], [ 0*Z(3), Z(3^2)^5, Z(3^2)^5 ] ] ) gap> Dimension( ww ); 4 gap> w = ww; true gap> AsVectorSpace( GF(27), w ); fail gap> u:= GF( 3^6 )^4; ( GF(3^6)^4 ) gap> uu:= AsVectorSpace( GF(9), u );; gap> Print( uu, "\n" ); VectorSpace( GF(3^2), [ [ Z(3)^0, 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3)^0, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3), Z(3)^0 ], [ Z(3^6), 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3), Z(3^6) ], [ Z(3^6)^2, 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6)^2, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6)^2, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3), Z(3^6)^2 ] ] ) gap> uuu:= AsVectorSpace( GF(27), uu );; gap> Print( uuu, "\n" ); VectorSpace( GF(3^3), [ [ Z(3)^0, 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3)^0, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3), Z(3)^0 ], [ Z(3^6), 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3), Z(3^6) ], [ Z(3^6)^2, 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6)^2, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6)^2, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3), Z(3^6)^2 ], [ Z(3^2), 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^2), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^2), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3), Z(3^2) ], [ Z(3^6)^92, 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6)^92, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6)^92, 0*Z(3) ] , [ 0*Z(3), 0*Z(3), 0*Z(3), Z(3^6)^92 ], [ Z(3^6)^93, 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6)^93, 0*Z(3), 0*Z(3) ] , [ 0*Z(3), 0*Z(3), Z(3^6)^93, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3), Z(3^6)^93 ] ] ) gap> uuuu:= AsVectorSpace( GF(3^6), uu );; gap> Print( uuuu, "\n" ); VectorSpace( GF(3^6), [ [ Z(3)^0, 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3)^0, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3), Z(3)^0 ], [ Z(3^6), 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3), Z(3^6) ], [ Z(3^6)^2, 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6)^2, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6)^2, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3), Z(3^6)^2 ] ] ) gap> u = uuu; true gap> c:= VectorSpace( GF(9), [ [ Z(3)^0, 0*Z(3), 0*Z(3) ] ] ); gap> f:= v + c;; gap> Print( f, "\n" ); VectorSpace( GF(3^2), [ [ Z(3)^0, Z(3)^0, Z(3)^0 ], [ 0*Z(3), Z(3)^0, 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3)^0 ] ] ) gap> Intersection( v, c ); gap> Intersection( v, f ) = v; true gap> nv:= NormedRowVectors( v );; gap> Print( nv{ [ 1 .. 5 ] }, "\n" ); [ [ 0*Z(3), 0*Z(3), Z(3)^0 ], [ Z(3)^0, Z(3)^0, 0*Z(3) ], [ Z(3)^0, Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0, Z(3) ], [ Z(3)^0, Z(3)^0, Z(3^2) ] ] ############################################################################# ## ## 5. Methods for full row spaces ## gap> IsFullRowModule( v ); false gap> IsFullRowModule( f ); true gap> c:= CanonicalBasis( f ); CanonicalBasis( ( GF(3^2)^3 ) ) gap> BasisVectors( c ) = IdentityMat( Length( c ), GF(3) ); true ############################################################################# ## ## 6. Methods for collections of subspaces of full row spaces ## gap> subsp:= Subspaces( f, 2 ); Subspaces( ( GF(3^2)^3 ), 2 ) gap> Size( subsp ); 91 gap> iter:= Iterator( subsp );; gap> for i in [ 1 .. 6 ] do > NextIterator( iter ); > od; gap> IsDoneIterator( iter ); false gap> Print( NextIterator( iter ), "\n" ); VectorSpace( GF(3^2), [ [ Z(3)^0, 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0, Z(3^2)^5 ] ] ) gap> subsp:= Subspaces( f ); Subspaces( ( GF(3^2)^3 ) ) gap> Size( subsp ); 184 gap> iter:= Iterator( subsp );; gap> for i in [ 1 .. 6 ] do > NextIterator( iter ); > od; gap> IsDoneIterator( iter ); false gap> Print( NextIterator( iter ), "\n" ); VectorSpace( GF(3^2), [ [ Z(3)^0, 0*Z(3), Z(3^2)^3 ] ] ) ############################################################################# ## ## 7. Methods for mutable bases of Gaussian row spaces ## gap> mb:= MutableBasis( Rationals, > [ [ 1, 1, 1, 1 ], [ 0, 1, 1, 1 ], [ 1, 1, 1, 1 ] ] ); gap> IsMutableBasisOfGaussianRowSpaceRep( mb ); true gap> CloseMutableBasis( mb, [ E(4), 0, 0, 0 ] ); gap> IsMutableBasisOfGaussianRowSpaceRep( mb ); false gap> BasisVectors( mb ); [ [ 1, 1, 1, 1 ], [ 0, 1, 1, 1 ], [ E(4), 0, 0, 0 ] ] gap> mb:= MutableBasis( Rationals, > [ [ 1, 1, 1, 1 ], [ 0, 1, 1, 1 ], [ 1, 1, 1, 1 ] ] ); gap> CloseMutableBasis( mb, [ 1, 2, 3, 4 ] ); gap> CloseMutableBasis( mb, [ 1, 2, 3, 5 ] ); gap> CloseMutableBasis( mb, [ 0, 0, 0, 7 ] ); gap> IsMutableBasisOfGaussianRowSpaceRep( mb ); true gap> BasisVectors( mb ); [ [ 1, 1, 1, 1 ], [ 0, 1, 1, 1 ], [ 0, 0, 1, 2 ], [ 0, 0, 0, 1 ] ] gap> ImmutableBasis( mb ); SemiEchelonBasis( , [ [ 1, 1, 1, 1 ], [ 0, 1, 1, 1 ], [ 0, 0, 1, 2 ], [ 0, 0, 0, 1 ] ] ) gap> mb:= MutableBasis( Rationals, [], [ 0, 0, 0, 0 ] ); gap> CloseMutableBasis( mb, [ 1, 2, 3, 4 ] ); gap> CloseMutableBasis( mb, [ 1, 2, 3, 5 ] ); gap> CloseMutableBasis( mb, [ 0, 0, 0, 7 ] ); gap> IsMutableBasisOfGaussianRowSpaceRep( mb ); true gap> BasisVectors( mb ); [ [ 1, 2, 3, 4 ], [ 0, 0, 0, 1 ] ] gap> ImmutableBasis( mb ); SemiEchelonBasis( , [ [ 1, 2, 3, 4 ], [ 0, 0, 0, 1 ] ] ) ############################################################################# ## ## 8. Enumerations ## gap> erg:= [];; i:= 0;; gap> dims:= [ 1,4,27,28,29,31,32,33,63,64,65,92,127,128,129,384 ];; gap> p := fail;; for p in [ 2,3,7,19,53,101 ] do > for i in dims do > v:= BasisVectors( CanonicalBasis( GF(p)^i ) ); > l:= List( v, x -> NumberFFVector( x, p ) ); > AddSet( erg, l = List( [ 1 .. i ], j -> p^(i-j) ) ); > od; > od; gap> erg; [ true ] ############################################################################# ## ## 9. Arithmetic ## gap> A := [ [ Z(2^2)^2, 0*Z(2), Z(2^2), 0*Z(2), 0*Z(2), 0*Z(2) ], > [ Z(2^2)^2, 0*Z(2), Z(2^2)^2, Z(2)^0, Z(2^2)^2, Z(2)^0 ], > [ 0*Z(2), Z(2)^0, 0*Z(2), Z(2^2)^2, 0*Z(2), Z(2^2)^2 ], > [ 0*Z(2), Z(2^2), Z(2^2), Z(2^2), Z(2^2)^2, 0*Z(2) ], > [ Z(2^2)^2, Z(2^2)^2, Z(2^2)^2, 0*Z(2), 0*Z(2), 0*Z(2) ], > [ Z(2)^0, Z(2)^0, 0*Z(2), Z(2^2), 0*Z(2), Z(2^2)^2 ] ];; gap> F := GF(4);; gap> MinimalPolynomial(F, A); x_1^6+Z(2^2)*x_1^5+x_1^4+Z(2^2)^2*x_1^3+x_1^2+Z(2^2)*x_1+Z(2)^0 gap> MinimalPolynomial(F, A); x_1^6+Z(2^2)*x_1^5+x_1^4+Z(2^2)^2*x_1^3+x_1^2+Z(2^2)*x_1+Z(2)^0 gap> STOP_TEST( "vspcrow.tst", 47400000 ); ############################################################################# ## #E gap-4r6p5/tst/xgap.tst0000644000175000017500000000321012172557256013446 0ustar billbill############################################################################# ## #W xgap.tst GAP-4 library Max Neunhöffer ## ## #Y Copyright 1999, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## To be listed in testinstall.g ## gap> START_TEST("xgap.tst"); gap> f := FreeGroup(2); gap> FactorGroup(f,f); Group(()) gap> Size(last); 1 gap> f := FreeGroup( "a", "b" );; a := f.1;; b := f.2;; gap> c2 := f / [ a*b*a^-2*b*a/b, (b^-1*a^3*b^-1*a^-3)^2*a ];; gap> e := GQuotients(c2,PSL(2,11));; gap> Length(e); 1 gap> e := e[1];; gap> i := Image(e);; gap> Stabilizer(i,1);; gap> g := PreImage(e,last);; gap> l := LowIndexSubgroupsFpGroup(g,TrivialSubgroup(g),5);; gap> Filtered(last,x->IndexInWholeGroup(x)=60);; gap> gg := last[5];; gap> n := Normalizer(c2,gg);; gap> Index(c2,n) = Index(c2,gg); false gap> Index(c2,n); 12 gap> Index(c2,gg); 60 gap> k := Kernel(e);; gap> LowIndexSubgroupsFpGroup(c2,k,11); [ Group(), Group(), Group() ] gap> Length(last); 3 gap> l := LowIndexSubgroupsFpGroup(c2,TrivialSubgroup(c2),11);; gap> List(l,x->ConjugacyClassSubgroups(c2,x));; gap> Length(last); 11 gap> f := FreeGroup(2); gap> t := TrivialSubgroup(f); Group([ ]) gap> CanComputeSize(t); true gap> HasSize(t); true gap> Size(t); 1 gap> f := FreeGroup(2);; gap> g:=f/[f.1^2,f.2^3];; gap> g.1^5=g.1; true gap> STOP_TEST( "xgap.tst", 1206600000 ); ############################################################################# ## #E gap-4r6p5/tst/zlattice.tst0000644000175000017500000000132612172557256014334 0ustar billbill############################################################################# ## #W zlattice.tst GAP library Thomas Breuer ## ## #Y Copyright (C) 1999, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## To be listed in testinstall.g ## gap> START_TEST("zlattice.tst"); # trivial cases of `LLLReducedBasis' gap> LLLReducedBasis( [ ] ); rec( B := [ ], basis := [ ], mue := [ ] ) gap> LLLReducedBasis( [ [ 0, 0 ], [ 0, 0 ] ], "linearcomb" ); rec( B := [ ], basis := [ ], mue := [ ], relations := [ [ 1, 0 ], [ 0, 1 ] ], transformation := [ ] ) gap> STOP_TEST( "zlattice.tst", 100000 ); ############################################################################# ## #E gap-4r6p5/tst/testutil.g0000644000175000017500000006236512172557256014020 0ustar billbill############################################################################# ## #W testutil.g GAP Library Thomas Breuer #W Frank Celler ## ## #Y Copyright (C) 2005 The GAP Group ## ## This file contains utilities for running tests. ## It is not read with the library when {\GAP} is started. ## ############################################################################# ## #F RunStandardTests( [, ] ) ## ## Let be a list of pairs consisting of a file name, relative to ## the `tst' directory of the {\GAP} distribution, and a scaling factor ## that is proportional to the expected runtime when the file is read with ## `Test'. ## `RunStandardTests' applies `Test' to the files listed in , ## in increasing order of the expected runtime, ## such that the differences between the actual output and the one that is ## prescribed in the test files are printed. ## Additionally, information about the file currently being read and the ## runtime is printed. ## ## If a second argument `true' is given, the scaling factors in the ## processed files are replaced by $10^5$ times the runtime in milliseconds. ## Of course this runtime depends on the hardware, so this renormalization ## should be executed on a ``typical'' machine, which should fit to the ## information in the files `tst/testall.g' and `tst/testinstall.g' and ## in the documentation file `doc/ref/install.xml'. ## BindGlobal( "RunStandardTests", function( arg ) local testfiles, renormalize, sizescreen, stop_TEST, infoRead1, infoRead2, count, totaltime, totalprev, prod, dir, i, name, info, time, stone, new, oldcontents, pos, newcontents; # Get and check the arguments. if Length( arg ) = 0 or Length( arg ) > 2 or not IsList( arg[1] ) then Error( "usage: RunStandardTests( [, ] )" ); fi; testfiles:= arg[1]; renormalize:= Length( arg ) = 2 and arg[2] = true; # Initialize variables that must be global. GAPInfo.TestData:= rec( results:= [] ); sizescreen:= SizeScreen(); # Replace the `STOP_TEST' function by one that collects statistical data. stop_TEST := STOP_TEST; STOP_TEST := function( file, fac ) Add( GAPInfo.TestData.results, [ file, fac, Runtime() - GAPInfo.TestData.START_TIME ] ); end; # Print a header. Print( "Architecture: ", GAPInfo.Architecture, "\n\n", "test file GAP4stones time(msec)\n", "-------------------------------------------\n" ); # Switch off info messages during the tests. infoRead1 := InfoRead1; InfoRead1 := Ignore; infoRead2 := InfoRead2; InfoRead2 := Ignore; # Loop over the test files. count:= 0; totaltime:= 0; totalprev:= 0; prod:= 1; dir:= DirectoriesLibrary( "tst" ); testfiles:= ShallowCopy( testfiles ); Sort( testfiles, function( a, b ) return a[2] < b[2]; end ); for i in [ 1 .. Length( testfiles ) ] do name:= Filename( dir, testfiles[i][1] ); Print( "testing: ", name, "\n" ); Test( name ); if Length( GAPInfo.TestData.results ) < i then Print( "#E Add a `STOP_TEST' command to the file `", name, "'!\n" ); GAPInfo.TestData.results[i]:= "dummy"; else info:= GAPInfo.TestData.results[i]; if info[1] <> testfiles[i][1] then Print( "#E Replace `", info[1], "' in the `STOP_TEST' command of `", name, "'!\n" ); fi; time:= info[3]; if 100 < time and IsPosRat(info[2]) then count:= count + 1; totaltime:= totaltime + time; totalprev:= totalprev + info[2]; stone := QuoInt( info[2], time ); prod:= prod * stone; else stone := 0; fi; Print( String( testfiles[i][1], -20 ), String( stone, 8 ), String( time, 15 ) ); if i < Length( testfiles ) and IsPosRat( testfiles[i+1][2] ) and totalprev <> 0 then Print( " (next ~ ", Int( totaltime * testfiles[i+1][2] / 10^3 / totalprev ), " sec)" ); fi; Print( "\n" ); if renormalize then new:= 10^5 * time; if info[2] = infinity or ( info[2] <> 0 and ( ( new >= info[2] and new / info[2] < 105/100 ) or ( new <= info[2] and new / info[2] > 95/100 ) ) ) then Print( "#I scaling factor in `", name, "' unchanged\n" ); else oldcontents:= StringFile( name ); pos:= PositionSublist( oldcontents, "STOP_TEST" ); newcontents:= oldcontents{ [ 1 .. pos-1 ] }; Append( newcontents, "STOP_TEST( \"" ); Append( newcontents, testfiles[i][1] ); Append( newcontents, "\", " ); Append( newcontents, String( new ) ); Append( newcontents, " );" ); pos:= PositionSublist( oldcontents, ";", pos ); Append( newcontents, oldcontents{ [ pos + 1 .. Length( oldcontents ) ] } ); # Save the old file, and print a new file. Exec( Concatenation( "mv ", name, " ", name, "~" ) ); SizeScreen( [ 1000 ] ); PrintTo( name, newcontents ); Print( "#I `", name, "' replaced:\n" ); SizeScreen( sizescreen ); Exec( Concatenation( "diff ", name, "~ ", name ) ); fi; fi; fi; od; # Print statistics information. Print("-------------------------------------------\n"); if count = 0 then count:= 1; fi; Print( "total", String( RootInt( prod, count ), 23 ), String( totaltime, 15 ), "\n\n" ); # Reset the changed globals. InfoRead1 := infoRead1; InfoRead2 := infoRead2; STOP_TEST := stop_TEST; GAPInfo.TestData:= rec(); end ); ############################################################################# ## #F ExtractManualExamples( ) ## ## is either ref or tut. ## The function should be called EXACTLY from the GAP root directory. ## LoadPackage("gapdoc"); ExtractManualExamples:=function( bookname ) local path, main, files, tst, i, s, name, output; if bookname="tut" then files:=[]; elif bookname="ref" then Read( "doc/ref/makedocreldata.g" ); files:= GAPInfo.ManualDataRef.files; else Error( "RunManualsTest : the argument bust be \"ref\" or \"tut\"" ); fi; path:=Directory( Concatenation( GAPInfo.RootPaths[1], "doc/", bookname ) ); main:="main.xml"; Print("===============================================================\n"); Print("Extracting manual examples from the book '", bookname, "'\n" ); Print("===============================================================\n"); tst:=ManualExamples( path, main, files, "Chapter" ); for i in [ 1 .. Length(tst) ] do Print("Processing '", bookname, "' chapter number ", i, " of ", Length(tst), "\c" ); if Length( tst[i] ) > 0 then s := String(i); if Length(s)=1 then # works for <100 chapters s:=Concatenation("0",s); fi; name := Filename( Directory( Concatenation( "doc/test/", bookname ) ), Concatenation( bookname, s, ".tst" ) ); output := OutputTextFile( name, false ); # to empty the file first SetPrintFormattingStatus( output, false ); # to avoid line breaks PrintTo( output, tst[i] ); CloseStream(output); # one superfluous check if tst[i] <> StringFile( name ) then Error("Saved file does not match original examples string!!!\n"); else Print(" - OK! \n" ); fi; else Print(" - no examples to save! \n" ); fi; od; Print("===============================================================\n"); end; ############################################################################# ## #F CreateTestinstallFile( ) ## ## replaces the file `tst/testinstall.g' by a file that reflects the current ## contents of the `tst' directory, that is, all those files in `tst/*.tst' ## are listed that contain the substring `To be listed in testinstall.g'; ## the scaling factors in the `STOP_TEST' calls in the files are inserted ## in the list entries. ## ## BindGlobal( "CreateTestinstallFile", function( ) local dir, oldfile, oldcontents, pos, newcontents, error, name, file, filecontents, stoppos, stonepos; dir:= DirectoriesLibrary( "tst" ); oldfile:= Filename( dir, "testinstall.g" ); if oldfile = fail then Error( "no file `testinstall.g' found" ); fi; oldcontents:= StringFile( oldfile ); pos:= PositionSublist( oldcontents, "RunStandardTests( [" ); if pos = fail then Print( "#E no substring `RunStandardTests( [' in `testinstall.g'\n" ); return false; fi; newcontents:= oldcontents{ [ 1 .. pos-1 ] }; Append( newcontents, "RunStandardTests( [\n" ); error:= false; for name in SortedList( DirectoryContents( Filename( dir, "" ) ) ) do if 4 < Length( name ) and name{ [ Length( name ) - 3 .. Length( name ) ] } = ".tst" then file:= Filename( dir, name ); filecontents:= StringFile( file ); if PositionSublist( filecontents, "To be listed in testinstall.g" ) <> fail then if PositionSublist( filecontents, "START_TEST" ) = fail then error:= true; Print( "#E no `START_TEST' in `", file, "'\n" ); else stoppos:= PositionSublist( filecontents, "STOP_TEST" ); if stoppos = fail then error:= true; Print( "#E no `STOP_TEST' in `", file, "'\n" ); elif filecontents{ [ stoppos+12 .. stoppos+12+Length( name ) ] } <> Concatenation( name, "\"" ) then error:= true; Print( "#E corrupted `STOP_TEST' command in `", file, "'\n" ); else stonepos:= PositionSublist( filecontents, ");", stoppos ); Append( newcontents, " [" ); Append( newcontents, filecontents{ [ stoppos+10 .. stonepos-1 ] } ); Append( newcontents, "],\n" ); fi; fi; fi; fi; od; if error then return false; fi; Append( newcontents, "] )" ); # Append the part behind the list. pos:= Position( oldcontents, ';', pos ); if pos = fail then Print( "#E no semicolon behind the list in `testinstall.g'\n" ); return false; fi; Append( newcontents, oldcontents{ [ pos .. Length( oldcontents ) ] } ); if oldcontents = newcontents then Print( "#I `testinstall.g' unchanged\n" ); else # Save the old file as `testinstall.g~', and print a new `testinstall.g'. Exec( Concatenation( "mv ", oldfile, " ", oldfile, "~" ) ); PrintTo( oldfile, newcontents ); Print( "#I `testinstall.g' replaced:\n" ); Exec( Concatenation( "diff ", oldfile, "~ ", oldfile ) ); fi; return true; end ); ############################################################################# ## #F CreatePackageTestsInput( , , , ) ## ## writes the file that starts a new GAP session using the ## command (including all command line options) for each test file ## of a package (given by the component `TestFile' in the record stored in ## its `PackageInfo.g' file) and reads this file. The output of all tests ## is collected in the files . ## GAP} is started as (including all command line options). ## may be true, false or "auto" to specify whether all available ## packages are loaded, not loaded or only autoloaded packages. This mode ## is actually managed in the Makefile, and is passed to this function ## just to be printed in the information messages. ## BindGlobal( "CreatePackageTestsInput", function( scriptfile, outfile, gap, other ) local result, name, entry, pair, testfile; SizeScreen( [ 1000 ] ); InitializePackagesInfoRecords( false ); result:= ""; Append( result, "TIMESTAMP=`date -u +_%Y-%m-%d-%H-%M`\n" ); for name in SortedList(ShallowCopy(RecNames(GAPInfo.PackagesInfo))) do for entry in GAPInfo.PackagesInfo.( name ) do if IsBound( entry.InstallationPath ) and IsBound( entry.TestFile ) then testfile := Filename( DirectoriesPackageLibrary( name, "" ), entry.TestFile ); if testfile <> fail then Append( result, Concatenation( "echo 'Testing ", name, " ", entry.Version, ", test=", testfile, ", all packages=", other, "'\n" ) ); Append( result, Concatenation( "echo ", "'============================OUTPUT START=============================='", " > ", outfile, "$TIMESTAMP.", name, "\n" ) ); Append( result, Concatenation( "echo 'SetUserPreference(\"UseColorsInTerminal\",false); ", "RunPackageTests( \"", name, "\", \"", entry.Version, "\", \"", entry.TestFile, "\", \"", other, "\" );' | ", gap, " >> ", outfile, "$TIMESTAMP.", name, "\n" ) ); Append( result, Concatenation( "echo ", "'============================OUTPUT END================================'", " >> ", outfile, "$TIMESTAMP.", name, "\n" ) ); else Append( result, Concatenation( "echo 'failed to find test files for the ", name, " package'\n") ); fi; fi; od; od; PrintTo( scriptfile, result ); end ); ############################################################################# ## #F RunPackageTests( , , , ) ## ## loads the package in version , ## and reads the file (a path relative to the package directory). ## If is `true' then all other available packages are also loaded. ## ## The file can either be a file that contains `ReadTest' ## or `Test' statements and therefore must be read with `Read', ## or it can be a file that itself must be read with `Test'; ## the latter is detected from the occurrence of a substring ## `"START_TEST"' in the file. ## BindGlobal( "RunPackageTests", function( pkgname, version, testfile, other ) local file, PKGTSTHDR, str; if LoadPackage( pkgname, Concatenation( "=", version ) ) = fail then Print( "#I RunPackageTests: package `", pkgname, "' (version ", version, ") not loadable\n" ); return; fi; if other = "true" then LoadAllPackages(); fi; PKGTSTHDR := Concatenation( "\"", pkgname, "\", \"", version, "\", \"", testfile, "\", ", other ); Print( "#I RunPackageTests(", PKGTSTHDR, ");\n" ); ShowSystemInformation(); file:= Filename( DirectoriesPackageLibrary( pkgname, "" ), testfile ); str:= StringFile( file ); if not IsString( str ) then Print( "#I RunPackageTests: file `", testfile, "' for package `", pkgname, "' (version ", version, ") not readable\n" ); return; fi; if PositionSublist( str, "gap> START_TEST(" ) = fail then if not READ( file ) then Print( "#I RunPackageTests: file `", testfile, "' for package `", pkgname, "' (version ", version, ") not readable\n" ); fi; else if not Test( file, rec(compareFunction := "uptowhitespace") ) then Print( "#I Errors detected while testing package ", pkgname, " ", version, "\n", "#I using the test file `", testfile, "'\n"); else Print( "#I No errors detected while testing package ", pkgname, " ", version, "\n", "#I using the test file `", testfile, "'\n"); fi; fi; Print( "#I RunPackageTests(", PKGTSTHDR, "): runtime ", Runtime(), "\n" ); end ); ############################################################################# ## #F CreatePackageLoadTestsInput( , , , ## , ) ## ## Writes the file that tests loading each package ## BindGlobal( "CreatePackageLoadTestsInput", function( scriptfile, outfileprefix, gap, autoload, onlyneeded ) local mode, smode, PKGLOADTSTOPT, result, name, entry, packagenames; SizeScreen( [ 1000 ] ); InitializePackagesInfoRecords( false ); result:= ""; mode:=""; PKGLOADTSTOPT:=""; if autoload then Append( mode, " with autoloaded" ); else Append( mode, " " ); fi; if onlyneeded then Append( mode, ", only needed" ); PKGLOADTSTOPT:=":OnlyNeeded"; fi; smode := NormalizedWhitespace(mode); if Length(smode) > 0 and smode[1] <> ' ' then smode:=Concatenation( " ", smode ); fi; packagenames := ShallowCopy( RecNames( GAPInfo.PackagesInfo ) ); Sort( packagenames ); Append( result, "TIMESTAMP=`date -u +_%Y-%m-%d-%H-%M`\n" ); for name in packagenames do for entry in GAPInfo.PackagesInfo.( name ) do Append( result, "echo '==========================================='\n" ); Append( result, Concatenation( "echo '%%% Loading ", name, " ", entry.Version, smode, "'\n" ) ); Append( result, Concatenation( "echo 'SetUserPreference(\"UseColorsInTerminal\",false); ", "PKGLOADTSTRES:=LoadPackage(\"", name, "\"", PKGLOADTSTOPT, ");;", "Filtered(NamesUserGVars(),x->IsLowerAlphaChar(x[1]) or Length(x)<=3);", "if PKGLOADTSTRES=true then PKGLOADTSTRES:=\"### Loaded\"; ", "else PKGLOADTSTRES:=\"### Not loaded\"; fi;", "Print( PKGLOADTSTRES, \" \",\"", name, "\",\" \",\"", entry.Version, smode, "\");", "Print([CHAR_INT(10)]);' | ", gap, " > ", outfileprefix, "$TIMESTAMP.", name, " 2>&1 \n" ) ); Append( result, Concatenation( "cat ", outfileprefix, "$TIMESTAMP.", name, "\n" ) ); od; od; Append( result, "echo '==========================================='\n" ); # do not test LoadAllPackages with OnlyNeeded option if not onlyneeded then Append( result, Concatenation("echo '\n======OUTPUT START: LoadAllPackages", mode, "'\n" ) ); Append( result, Concatenation( "echo 'SetUserPreference(\"UseColorsInTerminal\",false); ", "if CompareVersionNumbers( GAPInfo.Version, \"4.5.0\") then ", "SetInfoLevel(InfoPackageLoading,4);", "fi;LoadAllPackages(", PKGLOADTSTOPT, "); ", "Print([CHAR_INT(10)]); ", "Print(\"### all packages loaded ", mode, "\"); ' | ", gap, " > ", outfileprefix, "$TIMESTAMP.all 2>&1 \n" ) ); Append( result, Concatenation( "cat ", outfileprefix, "$TIMESTAMP.all\n" ) ); Append( result, Concatenation("echo '\n======OUTPUT END: LoadAllPackages", mode, "'\n" ) ); Append( result, "echo '==========================================='\n" ); Append( result, Concatenation("echo '\n======OUTPUT START: LoadAllPackages ", "in the reverse order", mode, "'\n" ) ); if PKGLOADTSTOPT="" then PKGLOADTSTOPT:=":reversed"; else PKGLOADTSTOPT:=":OnlyNeeded,reversed"; fi; Append( result, Concatenation( "echo 'SetUserPreference(\"UseColorsInTerminal\",false); ", "if CompareVersionNumbers( GAPInfo.Version, \"4.5.0\") then ", "SetInfoLevel(InfoPackageLoading,4);", "fi;LoadAllPackages(", PKGLOADTSTOPT, "); ", "Print([CHAR_INT(10)]); ", "Print(\"### all packages loaded in reverse order", mode, "\"); ' | ", gap, " > ", outfileprefix, "$TIMESTAMP.all 2>&1 \n" ) ); Append( result, Concatenation( "cat ", outfileprefix, "$TIMESTAMP.all\n" ) ); Append( result, Concatenation("echo '\n======OUTPUT END: LoadAllPackages ", "in the reverse order", mode, "'\n" ) ); fi; Append( result, Concatenation( "rm ", outfileprefix, "$TIMESTAMP.*\n" ) ); PrintTo( scriptfile, result ); end ); ############################################################################# ## #F CreatePackageVarsTestsInput( , , ) ## ## Writes the file that calls ShowPackageVariables ## for each package in a new GAP session ## BindGlobal( "CreatePackageVarsTestsInput", function( scriptfile, outfileprefix, gap ) local result, name, entry, packagenames; SizeScreen( [ 1000 ] ); InitializePackagesInfoRecords( false ); result:= ""; packagenames := ShallowCopy( RecNames( GAPInfo.PackagesInfo ) ); Sort( packagenames ); Append( result, "TIMESTAMP=`date -u +_%Y-%m-%d-%H-%M`\n" ); for name in packagenames do for entry in GAPInfo.PackagesInfo.( name ) do Append( result, "echo '==========================================='\n" ); Append( result, Concatenation( "echo '### Checking variables in \"", name, "\", ver. ", entry.Version, "'\n" ) ); Append( result, Concatenation( "echo 'ShowPackageVariables(\"", name, "\"", ");", "Print(\"### Variables checked for \\\"\",\"", name, "\\\"\",\", ver. \",\"", entry.Version, "\" );", "Print([CHAR_INT(10)]);' | ", gap, " > ", outfileprefix, "$TIMESTAMP.", name, " 2>&1 \n" ) ); Append( result, Concatenation( "cat ", outfileprefix, "$TIMESTAMP.", name, "\n" ) ); od; od; Append( result, "echo '==========================================='\n" ); Append( result, Concatenation( "rm ", outfileprefix, "$TIMESTAMP.*\n" ) ); PrintTo( scriptfile, result ); end ); ############################################################################# ## #F CreateDevUpdateTestInput( ) #F RunDevUpdateTests( ) ## ## RunDevUpdateTests() extracts test from dev/Update files and runs them ## in the current GAP session. CreateDevUpdateTestInput() is an auxiliary ## function which returns the string with the tests. It may be used to ## view the tests or print them to a file. ## BindGlobal( "CreateDevUpdateTestInput", function() local dirname, file, f, filename, content, alltests, output, nr, line, teststart, testlines; dirname:= DirectoriesLibrary( "dev/Updates" ); if dirname = fail then Error("Can not find the 'dev/Updates' directory. Note that it is a part of the\n", "development version of GAP and is not included in the GAP distribution\n"); fi; alltests := [ ]; # Exclude hidden files and directories. Sort to ensure the order is not system-dependent for file in SortedList( Filtered( DirectoryContents(dirname[1]), f -> f[1] <> '.' ) ) do filename := Filename( dirname, file ); content := SplitString( StringFile( filename ), "\r\n"); output := [ ]; nr:=0; repeat nr := nr+1; if nr > Length(content) then break; fi; line := content[nr]; if Length(line) > 0 then if line[1]='!' then if LowercaseString( ReplacedString( line, " ","")) = "!testcode" then teststart := nr; testlines := []; repeat nr := nr+1; line := content[nr]; if Length(line) > 0 then if line[1]='!' then break; elif not line[1]='%' then Add( testlines, Concatenation(line,"\n") ); fi; fi; until false; if Length( testlines ) > 0 then Add(output, Concatenation( "# ", filename, ", line ", String(teststart), "\n") ); Append(output, testlines ); Add( output, "\n" ); fi; fi; fi; fi; until false; if Length(output) > 0 then Add( output, "#######################\n#END\n"); Add( alltests, [ filename, Concatenation( output ) ] ); fi; od; return alltests; end); BindGlobal( "RunDevUpdateTests", function() local tests, t, resfile, str; tests := CreateDevUpdateTestInput(); SaveWorkspace("testdevupdate.wsp"); for t in tests do Print("Checking " , t[1],"\n"); resfile := "TESTDEVUPDATEOUTPUT"; FileString( "TESTDEVUPDATE", t[2] ); Exec( Concatenation( "echo 'Test(\"TESTDEVUPDATE\");' | bin/gap.sh -b -r -A -q -L testdevupdate.wsp > ", resfile )); str := StringFile(resfile); Print(str); od; RemoveFile("testdevupdate.wsp"); RemoveFile("TESTDEVUPDATE"); RemoveFile(resfile); end); ############################################################################# ## #E gap-4r6p5/tst/float.tst0000644000175000017500000000640612172557256013626 0ustar billbill############################################################################# ## #W float.tst GAP Tests Stefan Kohl ## ## gap> START_TEST("float.tst"); gap> SetFloats(IEEE754FLOAT); gap> Float(3); 3. gap> Float(-4); -4. gap> Float(2/3); 0.666667 gap> Float("-4"); -4. gap> 0.6; 0.6 gap> -0.7; -0.7 gap> 355.0/113.0; 3.14159 gap> last = 355.0/113; false gap> 355.0/113.0-355/113; 0. gap> 355.0/113.0 = 355.0/113; false gap> 355.0/113.0 < 355.0/113; false gap> 355.0/113.0 > 355.0/113; true gap> 355.0/113; 3.14159 gap> 355.0/113.0 - 355.0/113; 4.44089e-16 gap> 355/113.0 = 355.0/113.0; false gap> 355/113.0 - 355.0/113.0; -4.44089e-16 gap> 355/113.0 - 355.0/113; 0. gap> 355/113.0 = 355.0/113; true gap> 355.0/113.0; 3.14159 gap> Rat(last); 355/113 gap> Int(1.0); 1 gap> Int(1.5); 1 gap> Int(-1.0); -1 gap> Int(-1.5); -1 gap> Rat(0.5); 1/2 gap> Rat(0.0); 0 gap> Sqrt(2.0); 1.41421 gap> MinimalPolynomial(Rationals,last); -2*x_1^2+1 gap> r:=Rat("2.7182818");; r:=Rat(Float(String(NumeratorRat(r)))/Float(String(DenominatorRat(r)))); 2721/1001 gap> Float(String(NumeratorRat(r)))/Float(String(DenominatorRat(r))); 2.71828 gap> AbsoluteValue(Float("1")/Float("2")); 0.5 gap> AbsoluteValue(Float("-1")/Float("2")); 0.5 gap> AbsoluteValue(-Float("1")/Float("2")); 0.5 gap> AbsoluteValue(-Float("0")); 0. gap> Float(List([1..100],n->1/Factorial(n))); [ 1., 0.5, 0.166667, 0.0416667, 0.00833333, 0.00138889, 0.000198413, 2.48016e-05, 2.75573e-06, 2.75573e-07, 2.50521e-08, 2.08768e-09, 1.6059e-10, 1.14707e-11, 7.64716e-13, 4.77948e-14, 2.81146e-15, 1.56192e-16, 8.22064e-18, 4.11032e-19, 1.95729e-20, 8.89679e-22, 3.86817e-23, 1.61174e-24, 6.44695e-26, 2.4796e-27, 9.18369e-29, 3.27989e-30, 1.131e-31, 3.76999e-33, 1.21613e-34, 3.80039e-36, 1.15163e-37, 3.38716e-39, 9.67759e-41, 2.68822e-42, 7.26546e-44, 1.91196e-45, 4.90247e-47, 1.22562e-48, 2.98931e-50, 7.11741e-52, 1.65521e-53, 3.76184e-55, 8.35965e-57, 1.81732e-58, 3.86663e-60, 8.05548e-62, 1.64397e-63, 3.28795e-65, 6.44696e-67, 1.2398e-68, 2.33925e-70, 4.33194e-72, 7.87625e-74, 1.40647e-75, 2.4675e-77, 4.2543e-79, 7.21068e-81, 1.20178e-82, 1.97013e-84, 3.17763e-86, 5.04386e-88, 7.88103e-90, 1.21247e-91, 1.83707e-93, 2.7419e-95, 4.0322e-97, 5.84377e-99, 8.34824e-101, 1.17581e-102, 1.63307e-104, 2.23708e-106, 3.02308e-108, 4.03077e-110, 5.30365e-112, 6.88785e-114, 8.83058e-116, 1.1178e-117, 1.39724e-119, 1.72499e-121, 2.10365e-123, 2.53452e-125, 3.01728e-127, 3.54974e-129, 4.12761e-131, 4.74438e-133, 5.39134e-135, 6.05769e-137, 6.73076e-139, 7.39644e-141, 8.03961e-143, 8.64474e-145, 9.19653e-147, 9.68056e-149, 1.00839e-150, 1.03958e-152, 1.0608e-154, 1.07151e-156, 1.07151e-158 ] gap> 1.5e10; 1.5e+10 gap> -1.5e0; -1.5 gap> 0.7e-10; 7.e-11 gap> -0.8e-0; -0.8 gap> 1000000000000000000000000000000000000000000000000000000000000000\ > 00000000000000000000000000000000000000000000000000000000000000.0; 1.e+125 gap> 1.5+1; 2.5 gap> last-1.6; 0.9 gap> last*2; 1.8 gap> last/2.0; 0.9 gap> Sqrt(last); 0.948683 gap> Log(last); -0.0526803 gap> Exp(last); 0.948683 gap> last^2; 0.9 gap> STOP_TEST( "float.tst", 500000 ); ############################################################################# ## #E float.tst . . . . . . . . . . . . . . . . . . . . . . . . . . . ends here gap-4r6p5/tst/package.tst0000644000175000017500000000414512172557256014112 0ustar billbill############################################################################# ## #W package.tst GAP Library Thomas Breuer ## ## #Y Copyright (C) 2005, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## Exclude from testinstall.g: why? ## gap> START_TEST("package.tst"); # CompareVersionNumbers( , [, \"equal\"] ) gap> sml:= [ [ "", "dev" ], [ "a", "1" ], [ "a", "b1c" ], [ "1", "2" ], > [ "a1b", "1c1" ], [ "1a2", "b2c1d" ], [ "a1b2c3", "d1e3" ], > [ "1a2b3", "c1d2e4f" ] ];; gap> equ:= [ [ "a", "" ], [ "a1b", "1" ], [ "a1b2c", "1a2" ], > [ "a1b2c3d", "1a2b3" ] ];; gap> for pair in sml do > if CompareVersionNumbers( pair[1], pair[2] ) then > Error( "wrong result for ", pair ); > elif not CompareVersionNumbers( pair[2], pair[1] ) then > Error( "wrong result for ", Reversed( pair ) ); > elif CompareVersionNumbers( pair[1], pair[2], "equal" ) then > Error( "wrong result for ", pair, " and \"equal\"" ); > elif CompareVersionNumbers( pair[2], pair[1], "equal" ) then > Error( "wrong result for ", Reversed( pair ), " and \"equal\"" ); > fi; > od; gap> for pair in equ do > if not CompareVersionNumbers( pair[1], pair[2] ) then > Error( "wrong result for ", pair ); > elif not CompareVersionNumbers( pair[2], pair[1] ) then > Error( "wrong result for ", Reversed( pair ) ); > elif not CompareVersionNumbers( pair[1], pair[2], "equal" ) then > Error( "wrong result for ", pair, " and \"equal\"" ); > elif not CompareVersionNumbers( pair[2], pair[1], "equal" ) then > Error( "wrong result for ", Reversed( pair ), " and \"equal\"" ); > fi; > od; gap> for entry in Set( Concatenation( Concatenation( [ sml, equ ] ) ) ) do > if not CompareVersionNumbers( entry, entry ) then > Error( "wrong result for ", [ entry, entry ] ); > elif not CompareVersionNumbers( entry, entry, "equal" ) then > Error( "wrong result for ", [ entry, entry ], " and \"equal\"" ); > fi; > od; gap> STOP_TEST( "package.tst", 100000 ); ############################################################################# ## #E gap-4r6p5/tst/testall.g0000644000175000017500000000757012172557256013610 0ustar billbill############################################################################# ## #W testall.g GAP library Frank Celler ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file lists those files in the directory tst of the &GAP; ## distribution that are recommended to be read after a &GAP; installation. ## ## Each entry in the argument list of RunStandardTests is a pair that ## consists of the filename (relative to the tst directory) and the ## scaling factor that occurs in the STOP_TEST call at the end of the ## test file. ##

## The documentation states the following: ##

## <#GAPDoc Label="[1]{testall.g}"> ## If you want to run a more advanced check (this is not required and ## make take up to an hour), you can read testall.g ## which is an extended test script performing all tests from the ## tst directory. ##

## Read( Filename( DirectoriesLibrary( "tst" ), "testall.g" ) ); ## ]]> ##

## The test requires about 512MB of memory and runs about one hour on an ## Intel Core 2 Duo / 2.53 GHz machine, and produces an output similar ## to the testinstall.g test. ## <#/GAPDoc> ## Print( "You should start GAP4 using `gap -A -x 80 -r -m 100m -o 512m'.\n", "The more GAP4stones you get, the faster your system is.\n", "The runtime of the following tests (in general) increases.\n", "******************************************************************\n", "You should expect the test to take about *ONE HOUR* and show about\n", "125000 GAP4stones on an Intel Core 2 Duo / 2.53 GHz machine.\n", "For a quick test taking about one minute, use 'testinstall.g'\n", "******************************************************************\n", "The `next' time is an approximation of the running time ", "for the next file.\n\n" ); Reread( Filename( DirectoriesLibrary( "tst" ), "testutil.g" ) ); RunStandardTests( [ [ "alghom.tst",6000000], [ "algmat.tst",180800000], [ "algsc.tst",59000000], [ "arithlst.tst",52558700000], [ "boolean.tst",100000], [ "bugfix.tst",15319000000*10], [ "combinat.tst",5300000], [ "ctbl.tst",14300000], [ "ctblfuns.tst",3900000], [ "ctblmoli.tst",98500000], [ "ctblmono.tst",33400000], [ "ctblsolv.tst",54000000], [ "cyclotom.tst",900000], [ "eigen.tst",2500000], [ "ffe.tst",3600000], [ "ffeconway.tst",50200000], [ "fldabnum.tst",13400000], [ "float.tst",500000], [ "gaussian.tst",300000], [ "grpconst.tst",20754500000*10], [ "grpfp.tst",146700000], [ "grpfree.tst",700000], [ "grplatt.tst",971100000], [ "grpmat.tst",481000000], [ "grppc.tst",45300000], [ "grppcnrm.tst",2333400000], [ "grpperm.tst",490500000], [ "grpprmcs.tst",4153600000], [ "hash2.tst",3702400000], [ "helpsys.tst",58077900000], [ "listgen.tst",1000000], [ "longnumber.tst",100000], [ "mapphomo.tst",4800000], [ "mapping.tst",37300000], [ "matblock.tst",700000], [ "matrix.tst",882500000], [ "mgmring.tst",1800000], [ "modfree.tst",5800000], [ "morpheus.tst",87200000], [ "onecohom.tst",50600000], [ "oprt.tst",2000000], [ "package.tst",100000], [ "primsan.tst",125486700000], [ "ratfun.tst",800000], [ "relation.tst",7700000], [ "rwspcgrp.tst",59400000], [ "rwspcsng.tst",81100000], [ "semicong.tst",7800000], [ "semigrp.tst",11200000], [ "semirel.tst",10900000], [ "set.tst",5600000], [ "unknown.tst",100000], [ "varnames.tst",3600000/1000], [ "vspchom.tst",10500000], [ "vspcmali.tst",11100000], [ "vspcmat.tst",8400000], [ "vspcrow.tst",47400000], [ "weakptr.tst",11500000], [ "xgap.tst",1206600000], [ "zlattice.tst",100000], [ "zmodnz.tst",2300000], ] ); ############################################################################# ## #E gap-4r6p5/tst/rwspcsng.tst0000644000175000017500000013424312172557256014370 0ustar billbill############################################################################# ## #W rwspcsng.tst GAP library Frank Celler ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## Exclude from testinstall.g: why? ## gap> START_TEST("rwspcsng.tst"); ############################################################################# # create a free group, 8 bits gap> f := FreeGroup(IsSyllableWordsFamily,11);; gap> g := GeneratorsOfGroup(f){[1..11]};; # use 'fn' as abbreviation of 'g[n]' gap> f1 := g[1];; gap> f2 := g[2];; gap> f3 := g[3];; gap> f4 := g[4];; gap> f5 := g[5];; gap> f6 := g[6];; gap> f7 := g[7];; gap> f8 := g[8];; gap> f9 := g[9];; gap> f10 := g[10];; gap> f11 := g[11];; # store the relators in gap> r := [ > # power relators > [ 1, f2*f9 ], > # commutator relators > [ 6, 1, f9*f10*f11 ], [ 7, 1, f9*f11 ], [ 8, 1, f9*f10 ], [ 3, 2, > f9*f11 ], [ 5, 2, f9*f10 ], [ 5, 3, f5 ], [ 7, 3, f8 ], [ 8, 3, > f7*f8 ], [ 9, 3, f9*f11 ], [ 10, 3, f9*f10 ], [ 11, 3, f10*f11 ], [ > 6, 5, f6*f8 ], [ 7, 5, f6*f7*f8 ], [ 8, 5, f7*f8 ], [ 9, 5, f9*f10 > ], [ 10, 5, f9*f11 ], [ 11, 5, f10 ] ];; # construct a new single collector gap> rws := SingleCollector( g, [ 2, 2, 3, 3, 7, 2, 2, 2, 2, 2, 2 ] ); <> # set the relators gap> for x in r do > if 2 = Length(x) then > SetPower( rws, x[1], x[2] ); > else > SetCommutator( rws, x[1], x[2], x[3] ); > fi; > od; # reduce the rules and update the collector gap> UpdatePolycyclicCollector(rws); gap> ReduceRules(rws); gap> UpdatePolycyclicCollector(rws); gap> IsConfluent(rws); true gap> rws; <> # force stack overflow gap> rws![SCP_MAX_STACK_SIZE] := 1;; gap> IsConfluent(rws); true gap> rws![SCP_MAX_STACK_SIZE] := 1;; # construct the maximal word gap> l := [1..11]*0;; gap> r := RelativeOrders(rws);; gap> w := Product( List( [1..11], x -> g[x]^(r[x]-1) ) );; gap> Print(ExtRepOfObj(w),"\n"); [ 1, 1, 2, 1, 3, 2, 4, 2, 5, 6, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 1 ] # start multiplying around with gap> Print(ExtRepOfObj( ReducedProduct( rws, w, w ) ),"\n"); [ 2, 1, 3, 1, 4, 1, 5, 2, 9, 1, 11, 1 ] gap> Print(ExtRepOfObj( SingleCollector_Solution( rws, w, w^0 ) ),"\n"); [ 1, 1, 3, 1, 4, 1, 5, 2, 6, 1, 7, 1, 8, 1, 9, 1, 11, 1 ] gap> Print(ExtRepOfObj( ReducedInverse( rws, w ) ),"\n"); [ 1, 1, 3, 1, 4, 1, 5, 2, 6, 1, 7, 1, 8, 1, 9, 1, 11, 1 ] gap> Print(ExtRepOfObj( ReducedForm( rws, w^-1 ) ),"\n"); [ 1, 1, 3, 1, 4, 1, 5, 2, 6, 1, 7, 1, 8, 1, 9, 1, 11, 1 ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, 1000 ) ),"\n"); [ 3, 2, 4, 2, 5, 6, 9, 1, 10, 1, 11, 1 ] gap> l := GeneratorsOfRws(rws);; gap> p := ReducedOne(rws);; gap> for i in l do > p := ReducedProduct( rws, p, ReducedProduct(rws,w,i) ); > od; gap> Print(ExtRepOfObj(p),"\n"); [ 3, 2, 4, 2, 5, 3, 6, 1, 8, 1, 9, 1 ] gap> l := GeneratorsOfRws(rws);; gap> p := ReducedOne(rws);; gap> for i in l do > p := ReducedProduct( rws, p, ReducedProduct( rws, > ReducedProduct(rws,w,i), w ) ); > od; gap> Print(ExtRepOfObj(p),"\n"); [ 1, 1, 6, 1, 8, 1, 11, 1 ] gap> Print(ExtRepOfObj( ReducedComm( rws, w, w ) ),"\n"); [ ] gap> a := ReducedProduct( rws, ReducedProduct( rws, w, w ), w );; gap> Print(ExtRepOfObj(a),"\n"); [ 1, 1, 6, 1, 7, 1, 8, 1 ] gap> a := ReducedProduct( rws, a, a );; gap> Print(ExtRepOfObj(a),"\n"); [ 2, 1 ] gap> a := ReducedProduct( rws, a, a );; gap> Print(ExtRepOfObj(a),"\n"); [ ] gap> Print(ExtRepOfObj( ReducedLeftQuotient( rws, ReducedProduct(rws,w,w), w) ),"\n"); [ 1, 1, 3, 1, 4, 1, 5, 2, 6, 1, 7, 1, 8, 1, 9, 1, 11, 1 ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, -1 ) ),"\n"); [ 1, 1, 3, 1, 4, 1, 5, 2, 6, 1, 7, 1, 8, 1, 9, 1, 11, 1 ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, 0 ) ),"\n"); [ ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, 1 ) ),"\n"); [ 1, 1, 2, 1, 3, 2, 4, 2, 5, 6, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 1 ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, 2 ) ),"\n"); [ 2, 1, 3, 1, 4, 1, 5, 2, 9, 1, 11, 1 ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, 3 ) ),"\n"); [ 1, 1, 6, 1, 7, 1, 8, 1 ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, 4 ) ),"\n"); [ 3, 2, 4, 2, 5, 6, 9, 1, 10, 1, 11, 1 ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, 5 ) ),"\n"); [ 1, 1, 2, 1, 3, 1, 4, 1, 5, 2, 6, 1, 7, 1, 8, 1, 9, 1, 11, 1 ] gap> Print(ExtRepOfObj( ReducedComm( rws, w, w ) ),"\n"); [ ] gap> Print(ExtRepOfObj( ReducedComm( rws, w, l[1] ) ),"\n"); [ 9, 1 ] gap> Print(ExtRepOfObj( ReducedLeftQuotient( rws, w, w ) ) ,"\n"); [ ] gap> Print(ExtRepOfObj( ReducedLeftQuotient( rws, w, l[1] ) ),"\n"); [ 2, 1, 3, 1, 4, 1, 5, 2, 6, 1, 7, 1, 8, 1, 9, 1, 11, 1 ] gap> Print(ExtRepOfObj( ReducedOne( rws ) ),"\n"); [ ] gap> Print(ExtRepOfObj( ReducedQuotient( rws, w, w ) ),"\n"); [ ] gap> Print(ExtRepOfObj( ReducedQuotient( rws, w, l[1] ) ),"\n"); [ 2, 1, 3, 2, 4, 2, 5, 6, 6, 1, 7, 1, 8, 1, 10, 1, 11, 1 ] gap> rws := ShallowCopy(rws);; gap> Print(ExtRepOfObj( ReducedComm( rws, w, w ) ),"\n"); [ ] gap> rws := ShallowCopy(rws);; gap> Print(ExtRepOfObj( ReducedConjugate( rws, w, w ) ),"\n"); [ 1, 1, 2, 1, 3, 2, 4, 2, 5, 6, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 1 ] gap> rws := ShallowCopy(rws);; gap> Print(ExtRepOfObj( ReducedForm( rws, w^-1 ) ),"\n") ; [ 1, 1, 3, 1, 4, 1, 5, 2, 6, 1, 7, 1, 8, 1, 9, 1, 11, 1 ] gap> rws := ShallowCopy(rws);; gap> Print(ExtRepOfObj( ReducedInverse( rws, w ) ),"\n"); [ 1, 1, 3, 1, 4, 1, 5, 2, 6, 1, 7, 1, 8, 1, 9, 1, 11, 1 ] gap> rws := ShallowCopy(rws);; gap> Print(ExtRepOfObj( ReducedLeftQuotient( rws, w, w ) ),"\n"); [ ] gap> rws := ShallowCopy(rws);; gap> Print(ExtRepOfObj( ReducedPower( rws, w, 0 ) ),"\n"); [ ] gap> rws := ShallowCopy(rws);; gap> Print(ExtRepOfObj( ReducedPower( rws, w, 1 ) ),"\n"); [ 1, 1, 2, 1, 3, 2, 4, 2, 5, 6, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 1 ] gap> rws := ShallowCopy(rws);; gap> Print(ExtRepOfObj( ReducedPower( rws, w, 2 ) ),"\n"); [ 2, 1, 3, 1, 4, 1, 5, 2, 9, 1, 11, 1 ] gap> rws := ShallowCopy(rws);; gap> Print(ExtRepOfObj( ReducedPower( rws, w, -1 ) ),"\n"); [ 1, 1, 3, 1, 4, 1, 5, 2, 6, 1, 7, 1, 8, 1, 9, 1, 11, 1 ] gap> rws := ShallowCopy(rws);; gap> Print(ExtRepOfObj( ReducedPower( rws, w, -2 ) ),"\n"); [ 2, 1, 3, 2, 4, 2, 5, 6, 9, 1, 10, 1, 11, 1 ] gap> rws := ShallowCopy(rws);; gap> Print(ExtRepOfObj( ReducedProduct( rws, w, w ) ),"\n"); [ 2, 1, 3, 1, 4, 1, 5, 2, 9, 1, 11, 1 ] gap> rws := ShallowCopy(rws);; gap> Print(ExtRepOfObj( ReducedQuotient( rws, w, w ) ),"\n"); [ ] gap> rws := ShallowCopy(rws);; gap> Print(ExtRepOfObj( ReducedOne( rws ) ),"\n"); [ ] ############################################################################# # create a free group, 16 bits gap> f := FreeGroup(IsSyllableWordsFamily,61);; gap> g := GeneratorsOfGroup(f){[1..61]};; # use 'fn' as abbreviation of 'g[n]' gap> f1 := g[1];; gap> f2 := g[2];; gap> f3 := g[3];; gap> f4 := g[4];; gap> f5 := g[5];; gap> f6 := g[6];; gap> f7 := g[7];; gap> f8 := g[8];; gap> f9 := g[9];; gap> f10 := g[10];; gap> f11 := g[11];; gap> f12 := g[12];; gap> f13 := g[13];; gap> f14 := g[14];; gap> f15 := g[15];; gap> f16 := g[16];; gap> f17 := g[17];; gap> f18 := g[18];; gap> f19 := g[19];; gap> f20 := g[20];; gap> f21 := g[21];; gap> f22 := g[22];; gap> f23 := g[23];; gap> f24 := g[24];; gap> f25 := g[25];; gap> f26 := g[26];; gap> f27 := g[27];; gap> f28 := g[28];; gap> f29 := g[29];; gap> f30 := g[30];; gap> f31 := g[31];; gap> f32 := g[32];; gap> f33 := g[33];; gap> f34 := g[34];; gap> f35 := g[35];; gap> f36 := g[36];; gap> f37 := g[37];; gap> f38 := g[38];; gap> f39 := g[39];; gap> f40 := g[40];; gap> f41 := g[41];; gap> f42 := g[42];; gap> f43 := g[43];; gap> f44 := g[44];; gap> f45 := g[45];; gap> f46 := g[46];; gap> f47 := g[47];; gap> f48 := g[48];; gap> f49 := g[49];; gap> f50 := g[50];; gap> f51 := g[51];; gap> f52 := g[52];; gap> f53 := g[53];; gap> f54 := g[54];; gap> f55 := g[55];; gap> f56 := g[56];; gap> f57 := g[57];; gap> f58 := g[58];; gap> f59 := g[59];; gap> f60 := g[60];; gap> f61 := g[61];; # store the relators in gap> r := [ > # power relators > [ 8, f9 ], [ 15, f16 ], [ 22, f23 ], [ 29, f30 ], [ 36, f37 ], [ 43, > f44 ], [ 50, f51 ], [ 57, f58 ], > # commutator relators > [ 2, 1, f2 ], [ 4, 1, f5 ], [ 5, 1, f4*f5 ], [ 13, 1, f13^2*f20 ], [ > 14, 1, f14^30*f21 ], [ 15, 1, f15*f16*f22 ], [ 16, 1, f16*f23 ], [ > 17, 1, f17^4*f24 ], [ 18, 1, f18^4*f25 ], [ 19, 1, f19^4*f26 ], [ > 20, 1, f20^2*f27 ], [ 21, 1, f21^30*f28 ], [ 22, 1, f22*f23*f29 ], [ > 23, 1, f23*f30 ], [ 24, 1, f24^4*f31 ], [ 25, 1, f25^4*f32 ], [ 26, > 1, f26^4*f33 ], [ 27, 1, f13*f27^2 ], [ 28, 1, f14*f28^30 ], [ 29, > 1, f15*f29*f30 ], [ 30, 1, f16*f30 ], [ 31, 1, f17*f31^4 ], [ 32, 1, > f18*f32^4 ], [ 33, 1, f19*f33^4 ], [ 41, 1, f41^2*f48 ], [ 42, 1, > f42^30*f49 ], [ 43, 1, f43*f44*f50 ], [ 44, 1, f44*f51 ], [ 45, 1, > f45^4*f52 ], [ 46, 1, f46^4*f53 ], [ 47, 1, f47^4*f54 ], [ 48, 1, > f48^2*f55 ], [ 49, 1, f49^30*f56 ], [ 50, 1, f50*f51*f57 ], [ 51, 1, > f51*f58 ], [ 52, 1, f52^4*f59 ], [ 53, 1, f53^4*f60 ], [ 54, 1, > f54^4*f61 ], [ 55, 1, f41*f55^2 ], [ 56, 1, f42*f56^30 ], [ 57, 1, > f43*f57*f58 ], [ 58, 1, f44*f58 ], [ 59, 1, f45*f59^4 ], [ 60, 1, > f46*f60^4 ], [ 61, 1, f47*f61^4 ], [ 3, 2, f3*f5 ], [ 4, 2, f3*f4*f5 > ], [ 5, 2, f4*f5 ], [ 13, 2, f13^2*f20 ], [ 14, 2, f14^30*f21 ], [ > 15, 2, f15*f16*f22 ], [ 16, 2, f16*f23 ], [ 17, 2, f17^4*f24 ], [ > 18, 2, f18^4*f25 ], [ 19, 2, f19^4*f26 ], [ 20, 2, f20^2*f41 ], [ > 21, 2, f21^30*f42 ], [ 22, 2, f22*f23*f43 ], [ 23, 2, f23*f44 ], [ > 24, 2, f24^4*f45 ], [ 25, 2, f25^4*f46 ], [ 26, 2, f26^4*f47 ], [ > 27, 2, f27^2*f55 ], [ 28, 2, f28^30*f56 ], [ 29, 2, f29*f30*f57 ], [ > 30, 2, f30*f58 ], [ 31, 2, f31^4*f59 ], [ 32, 2, f32^4*f60 ], [ 33, > 2, f33^4*f61 ], [ 34, 2, f13*f34^2 ], [ 35, 2, f14*f35^30 ], [ 36, > 2, f15*f36*f37 ], [ 37, 2, f16*f37 ], [ 38, 2, f17*f38^4 ], [ 39, 2, > f18*f39^4 ], [ 40, 2, f19*f40^4 ], [ 41, 2, f27*f41^2 ], [ 42, 2, > f28*f42^30 ], [ 43, 2, f29*f43*f44 ], [ 44, 2, f30*f44 ], [ 45, 2, > f31*f45^4 ], [ 46, 2, f32*f46^4 ], [ 47, 2, f33*f47^4 ], [ 48, 2, > f34*f48^2 ], [ 49, 2, f35*f49^30 ], [ 50, 2, f36*f50*f51 ], [ 51, 2, > f37*f51 ], [ 52, 2, f38*f52^4 ], [ 53, 2, f39*f53^4 ], [ 54, 2, > f40*f54^4 ], [ 55, 2, f48*f55^2 ], [ 56, 2, f49*f56^30 ], [ 57, 2, > f50*f57*f58 ], [ 58, 2, f51*f58 ], [ 59, 2, f52*f59^4 ], [ 60, 2, > f53*f60^4 ], [ 61, 2, f54*f61^4 ], [ 6, 3, f6^2*f34 ], [ 7, 3, > f7^30*f35 ], [ 8, 3, f8*f9*f36 ], [ 9, 3, f9*f37 ], [ 10, 3, > f10^4*f38 ], [ 11, 3, f11^4*f39 ], [ 12, 3, f12^4*f40 ], [ 13, 3, > f13^2*f41 ], [ 14, 3, f14^30*f42 ], [ 15, 3, f15*f16*f43 ], [ 16, 3, > f16*f44 ], [ 17, 3, f17^4*f45 ], [ 18, 3, f18^4*f46 ], [ 19, 3, > f19^4*f47 ], [ 20, 3, f20^2*f48 ], [ 21, 3, f21^30*f49 ], [ 22, 3, > f22*f23*f50 ], [ 23, 3, f23*f51 ], [ 24, 3, f24^4*f52 ], [ 25, 3, > f25^4*f53 ], [ 26, 3, f26^4*f54 ], [ 27, 3, f27^2*f55 ], [ 28, 3, > f28^30*f56 ], [ 29, 3, f29*f30*f57 ], [ 30, 3, f30*f58 ], [ 31, 3, > f31^4*f59 ], [ 32, 3, f32^4*f60 ], [ 33, 3, f33^4*f61 ], [ 34, 3, > f6*f34^2 ], [ 35, 3, f7*f35^30 ], [ 36, 3, f8*f36*f37 ], [ 37, 3, > f9*f37 ], [ 38, 3, f10*f38^4 ], [ 39, 3, f11*f39^4 ], [ 40, 3, > f12*f40^4 ], [ 41, 3, f13*f41^2 ], [ 42, 3, f14*f42^30 ], [ 43, 3, > f15*f43*f44 ], [ 44, 3, f16*f44 ], [ 45, 3, f17*f45^4 ], [ 46, 3, > f18*f46^4 ], [ 47, 3, f19*f47^4 ], [ 48, 3, f20*f48^2 ], [ 49, 3, > f21*f49^30 ], [ 50, 3, f22*f50*f51 ], [ 51, 3, f23*f51 ], [ 52, 3, > f24*f52^4 ], [ 53, 3, f25*f53^4 ], [ 54, 3, f26*f54^4 ], [ 55, 3, > f27*f55^2 ], [ 56, 3, f28*f56^30 ], [ 57, 3, f29*f57*f58 ], [ 58, 3, > f30*f58 ], [ 59, 3, f31*f59^4 ], [ 60, 3, f32*f60^4 ], [ 61, 3, > f33*f61^4 ], [ 6, 4, f6^2*f20 ], [ 7, 4, f7^30*f21 ], [ 8, 4, > f8*f9*f22 ], [ 9, 4, f9*f23 ], [ 10, 4, f10^4*f24 ], [ 11, 4, > f11^4*f25 ], [ 12, 4, f12^4*f26 ], [ 13, 4, f13^2*f27 ], [ 14, 4, > f14^30*f28 ], [ 15, 4, f15*f16*f29 ], [ 16, 4, f16*f30 ], [ 17, 4, > f17^4*f31 ], [ 18, 4, f18^4*f32 ], [ 19, 4, f19^4*f33 ], [ 20, 4, > f6*f20^2 ], [ 21, 4, f7*f21^30 ], [ 22, 4, f8*f22*f23 ], [ 23, 4, > f9*f23 ], [ 24, 4, f10*f24^4 ], [ 25, 4, f11*f25^4 ], [ 26, 4, > f12*f26^4 ], [ 27, 4, f13*f27^2 ], [ 28, 4, f14*f28^30 ], [ 29, 4, > f15*f29*f30 ], [ 30, 4, f16*f30 ], [ 31, 4, f17*f31^4 ], [ 32, 4, > f18*f32^4 ], [ 33, 4, f19*f33^4 ], [ 34, 4, f34^2*f48 ], [ 35, 4, > f35^30*f49 ], [ 36, 4, f36*f37*f50 ], [ 37, 4, f37*f51 ], [ 38, 4, > f38^4*f52 ], [ 39, 4, f39^4*f53 ], [ 40, 4, f40^4*f54 ], [ 41, 4, > f41^2*f55 ], [ 42, 4, f42^30*f56 ], [ 43, 4, f43*f44*f57 ], [ 44, 4, > f44*f58 ], [ 45, 4, f45^4*f59 ], [ 46, 4, f46^4*f60 ], [ 47, 4, > f47^4*f61 ], [ 48, 4, f34*f48^2 ], [ 49, 4, f35*f49^30 ], [ 50, 4, > f36*f50*f51 ], [ 51, 4, f37*f51 ], [ 52, 4, f38*f52^4 ], [ 53, 4, > f39*f53^4 ], [ 54, 4, f40*f54^4 ], [ 55, 4, f41*f55^2 ], [ 56, 4, > f42*f56^30 ], [ 57, 4, f43*f57*f58 ], [ 58, 4, f44*f58 ], [ 59, 4, > f45*f59^4 ], [ 60, 4, f46*f60^4 ], [ 61, 4, f47*f61^4 ], [ 6, 5, > f6^2*f13 ], [ 7, 5, f7^30*f14 ], [ 8, 5, f8*f9*f15 ], [ 9, 5, f9*f16 > ], [ 10, 5, f10^4*f17 ], [ 11, 5, f11^4*f18 ], [ 12, 5, f12^4*f19 ], > [ 13, 5, f6*f13^2 ], [ 14, 5, f7*f14^30 ], [ 15, 5, f8*f15*f16 ], [ > 16, 5, f9*f16 ], [ 17, 5, f10*f17^4 ], [ 18, 5, f11*f18^4 ], [ 19, > 5, f12*f19^4 ], [ 20, 5, f20^2*f27 ], [ 21, 5, f21^30*f28 ], [ 22, > 5, f22*f23*f29 ], [ 23, 5, f23*f30 ], [ 24, 5, f24^4*f31 ], [ 25, 5, > f25^4*f32 ], [ 26, 5, f26^4*f33 ], [ 27, 5, f20*f27^2 ], [ 28, 5, > f21*f28^30 ], [ 29, 5, f22*f29*f30 ], [ 30, 5, f23*f30 ], [ 31, 5, > f24*f31^4 ], [ 32, 5, f25*f32^4 ], [ 33, 5, f26*f33^4 ], [ 34, 5, > f34^2*f41 ], [ 35, 5, f35^30*f42 ], [ 36, 5, f36*f37*f43 ], [ 37, 5, > f37*f44 ], [ 38, 5, f38^4*f45 ], [ 39, 5, f39^4*f46 ], [ 40, 5, > f40^4*f47 ], [ 41, 5, f34*f41^2 ], [ 42, 5, f35*f42^30 ], [ 43, 5, > f36*f43*f44 ], [ 44, 5, f37*f44 ], [ 45, 5, f38*f45^4 ], [ 46, 5, > f39*f46^4 ], [ 47, 5, f40*f47^4 ], [ 48, 5, f48^2*f55 ], [ 49, 5, > f49^30*f56 ], [ 50, 5, f50*f51*f57 ], [ 51, 5, f51*f58 ], [ 52, 5, > f52^4*f59 ], [ 53, 5, f53^4*f60 ], [ 54, 5, f54^4*f61 ], [ 55, 5, > f48*f55^2 ], [ 56, 5, f49*f56^30 ], [ 57, 5, f50*f57*f58 ], [ 58, 5, > f51*f58 ], [ 59, 5, f52*f59^4 ], [ 60, 5, f53*f60^4 ], [ 61, 5, > f54*f61^4 ], [ 7, 6, f7^4 ], [ 10, 6, f11*f12 ], [ 11, 6, > f11^4*f12^3 ], [ 12, 6, f11^3*f12^3 ], [ 10, 7, f11^4*f12^3 ], [ 11, > 7, f10^4*f11^4*f12^2 ], [ 12, 7, f10^2*f11^4*f12^4 ], [ 10, 8, f10 > ], [ 11, 8, f11 ], [ 12, 8, f12 ], [ 10, 9, f10^3 ], [ 11, 9, f11^3 > ], [ 12, 9, f12^3 ], [ 14, 13, f14^4 ], [ 17, 13, f18*f19 ], [ 18, > 13, f18^4*f19^3 ], [ 19, 13, f18^3*f19^3 ], [ 17, 14, f18^4*f19^3 ], > [ 18, 14, f17^4*f18^4*f19^2 ], [ 19, 14, f17^2*f18^4*f19^4 ], [ 17, > 15, f17 ], [ 18, 15, f18 ], [ 19, 15, f19 ], [ 17, 16, f17^3 ], [ > 18, 16, f18^3 ], [ 19, 16, f19^3 ], [ 21, 20, f21^4 ], [ 24, 20, > f25*f26 ], [ 25, 20, f25^4*f26^3 ], [ 26, 20, f25^3*f26^3 ], [ 24, > 21, f25^4*f26^3 ], [ 25, 21, f24^4*f25^4*f26^2 ], [ 26, 21, > f24^2*f25^4*f26^4 ], [ 24, 22, f24 ], [ 25, 22, f25 ], [ 26, 22, f26 > ], [ 24, 23, f24^3 ], [ 25, 23, f25^3 ], [ 26, 23, f26^3 ], [ 28, > 27, f28^4 ], [ 31, 27, f32*f33 ], [ 32, 27, f32^4*f33^3 ], [ 33, 27, > f32^3*f33^3 ], [ 31, 28, f32^4*f33^3 ], [ 32, 28, f31^4*f32^4*f33^2 > ], [ 33, 28, f31^2*f32^4*f33^4 ], [ 31, 29, f31 ], [ 32, 29, f32 ], > [ 33, 29, f33 ], [ 31, 30, f31^3 ], [ 32, 30, f32^3 ], [ 33, 30, > f33^3 ], [ 35, 34, f35^4 ], [ 38, 34, f39*f40 ], [ 39, 34, > f39^4*f40^3 ], [ 40, 34, f39^3*f40^3 ], [ 38, 35, f39^4*f40^3 ], [ > 39, 35, f38^4*f39^4*f40^2 ], [ 40, 35, f38^2*f39^4*f40^4 ], [ 38, > 36, f38 ], [ 39, 36, f39 ], [ 40, 36, f40 ], [ 38, 37, f38^3 ], [ > 39, 37, f39^3 ], [ 40, 37, f40^3 ], [ 42, 41, f42^4 ], [ 45, 41, > f46*f47 ], [ 46, 41, f46^4*f47^3 ], [ 47, 41, f46^3*f47^3 ], [ 45, > 42, f46^4*f47^3 ], [ 46, 42, f45^4*f46^4*f47^2 ], [ 47, 42, > f45^2*f46^4*f47^4 ], [ 45, 43, f45 ], [ 46, 43, f46 ], [ 47, 43, f47 > ], [ 45, 44, f45^3 ], [ 46, 44, f46^3 ], [ 47, 44, f47^3 ], [ 49, > 48, f49^4 ], [ 52, 48, f53*f54 ], [ 53, 48, f53^4*f54^3 ], [ 54, 48, > f53^3*f54^3 ], [ 52, 49, f53^4*f54^3 ], [ 53, 49, f52^4*f53^4*f54^2 > ], [ 54, 49, f52^2*f53^4*f54^4 ], [ 52, 50, f52 ], [ 53, 50, f53 ], > [ 54, 50, f54 ], [ 52, 51, f52^3 ], [ 53, 51, f53^3 ], [ 54, 51, > f54^3 ], [ 56, 55, f56^4 ], [ 59, 55, f60*f61 ], [ 60, 55, > f60^4*f61^3 ], [ 61, 55, f60^3*f61^3 ], [ 59, 56, f60^4*f61^3 ], [ > 60, 56, f59^4*f60^4*f61^2 ], [ 61, 56, f59^2*f60^4*f61^4 ], [ 59, > 57, f59 ], [ 60, 57, f60 ], [ 61, 57, f61 ], [ 59, 58, f59^3 ], [ > 60, 58, f60^3 ], [ 61, 58, f61^3 ], ];; # construct a new single collector gap> rws := SingleCollector( g, [ 3, 7, 2, 2, 2, 3, 31, 2, 2, 5, 5, 5, 3, > 31, 2, 2, 5, 5, 5, 3, 31, 2, 2, 5, 5, 5, 3, 31, 2, 2, 5, 5, 5, 3, 31, > 2, 2, 5, 5, 5, 3, 31, 2, 2, 5, 5, 5, 3, 31, 2, 2, 5, 5, 5, 3, 31, 2, 2, > 5, 5, 5 ] ); <> # set the relators gap> for x in r do > if 2 = Length(x) then > SetPower( rws, x[1], x[2] ); > else > SetCommutator( rws, x[1], x[2], x[3] ); > fi; > od; # reduce the rules and update the collector gap> UpdatePolycyclicCollector(rws); gap> ReduceRules(rws); gap> UpdatePolycyclicCollector(rws); gap> IsConfluent(rws); true gap> rws; <> gap> Print(List( rws![SCP_INVERSES], ExtRepOfObj ),"\n"); [ [ 1, 2 ], [ 2, 6 ], [ 3, 1 ], [ 4, 1 ], [ 5, 1 ], [ 6, 2 ], [ 7, 30 ], [ 8, 1, 9, 1 ], [ 9, 1 ], [ 10, 4 ], [ 11, 4 ], [ 12, 4 ], [ 13, 2 ], [ 14, 30 ], [ 15, 1, 16, 1 ], [ 16, 1 ], [ 17, 4 ], [ 18, 4 ], [ 19, 4 ], [ 20, 2 ], [ 21, 30 ], [ 22, 1, 23, 1 ], [ 23, 1 ], [ 24, 4 ], [ 25, 4 ], [ 26, 4 ], [ 27, 2 ], [ 28, 30 ], [ 29, 1, 30, 1 ], [ 30, 1 ], [ 31, 4 ], [ 32, 4 ], [ 33, 4 ], [ 34, 2 ], [ 35, 30 ], [ 36, 1, 37, 1 ], [ 37, 1 ], [ 38, 4 ], [ 39, 4 ], [ 40, 4 ], [ 41, 2 ], [ 42, 30 ], [ 43, 1, 44, 1 ], [ 44, 1 ], [ 45, 4 ], [ 46, 4 ], [ 47, 4 ], [ 48, 2 ], [ 49, 30 ], [ 50, 1, 51, 1 ], [ 51, 1 ], [ 52, 4 ], [ 53, 4 ], [ 54, 4 ], [ 55, 2 ], [ 56, 30 ], [ 57, 1, 58, 1 ], [ 58, 1 ], [ 59, 4 ], [ 60, 4 ], [ 61, 4 ] ] # force stack overflow gap> rws![SCP_MAX_STACK_SIZE] := 1;; gap> IsConfluent(rws); true gap> rws![SCP_MAX_STACK_SIZE] := 1;; # construct the maximal word gap> l := [1..61]*0;; gap> r := RelativeOrders(rws);; gap> w := Product( List( [1..61], x -> g[x]^(r[x]-1) ) );; gap> Print(ExtRepOfObj(w),"\n"); [ 1, 2, 2, 6, 3, 1, 4, 1, 5, 1, 6, 2, 7, 30, 8, 1, 9, 1, 10, 4, 11, 4, 12, 4, 13, 2, 14, 30, 15, 1, 16, 1, 17, 4, 18, 4, 19, 4, 20, 2, 21, 30, 22, 1, 23, 1, 24, 4, 25, 4, 26, 4, 27, 2, 28, 30, 29, 1, 30, 1, 31, 4, 32, 4, 33, 4, 34, 2, 35, 30, 36, 1, 37, 1, 38, 4, 39, 4, 40, 4, 41, 2, 42, 30, 43, 1, 44, 1, 45, 4, 46, 4, 47, 4, 48, 2, 49, 30, 50, 1, 51, 1, 52, 4, 53, 4, 54, 4, 55, 2, 56, 30, 57, 1, 58, 1, 59, 4, 60, 4, 61, 4 ] # start multiplying around with gap> Print(ExtRepOfObj( ReducedProduct( rws, w, w ) ),"\n"); [ 1, 1, 2, 2, 6, 1, 7, 5, 9, 1, 10, 3, 11, 3, 13, 1, 14, 5, 16, 1, 17, 3, 18, 3, 20, 1, 21, 5, 23, 1, 24, 3, 25, 3, 27, 1, 28, 5, 30, 1, 31, 3, 32, 3, 34, 1, 35, 5, 37, 1, 38, 3, 39, 3, 41, 1, 42, 5, 44, 1, 45, 3, 46, 3, 48, 1, 49, 5, 51, 1, 52, 3, 53, 3, 55, 1, 56, 5, 58, 1, 59, 3, 60, 3 ] gap> Print(ExtRepOfObj( SingleCollector_Solution( rws, w, w^0 ) ),"\n"); [ 1, 1, 2, 2, 3, 1, 4, 1, 5, 1, 6, 1, 7, 5, 8, 1, 10, 4, 11, 4, 12, 2, 13, 1, 14, 5, 15, 1, 17, 4, 18, 4, 19, 2, 20, 1, 21, 5, 22, 1, 24, 4, 25, 4, 26, 2, 27, 1, 28, 5, 29, 1, 31, 4, 32, 4, 33, 2, 34, 1, 35, 5, 36, 1, 38, 4, 39, 4, 40, 2, 41, 1, 42, 5, 43, 1, 45, 4, 46, 4, 47, 2, 48, 1, 49, 5, 50, 1, 52, 4, 53, 4, 54, 2, 55, 1, 56, 5, 57, 1, 59, 4, 60, 4, 61, 2 ] gap> Print(ExtRepOfObj( ReducedInverse( rws, w ) ),"\n"); [ 1, 1, 2, 2, 3, 1, 4, 1, 5, 1, 6, 1, 7, 5, 8, 1, 10, 4, 11, 4, 12, 2, 13, 1, 14, 5, 15, 1, 17, 4, 18, 4, 19, 2, 20, 1, 21, 5, 22, 1, 24, 4, 25, 4, 26, 2, 27, 1, 28, 5, 29, 1, 31, 4, 32, 4, 33, 2, 34, 1, 35, 5, 36, 1, 38, 4, 39, 4, 40, 2, 41, 1, 42, 5, 43, 1, 45, 4, 46, 4, 47, 2, 48, 1, 49, 5, 50, 1, 52, 4, 53, 4, 54, 2, 55, 1, 56, 5, 57, 1, 59, 4, 60, 4, 61, 2 ] gap> Print(ExtRepOfObj( ReducedForm( rws, w^-1 ) ),"\n"); [ 1, 1, 2, 2, 3, 1, 4, 1, 5, 1, 6, 1, 7, 5, 8, 1, 10, 4, 11, 4, 12, 2, 13, 1, 14, 5, 15, 1, 17, 4, 18, 4, 19, 2, 20, 1, 21, 5, 22, 1, 24, 4, 25, 4, 26, 2, 27, 1, 28, 5, 29, 1, 31, 4, 32, 4, 33, 2, 34, 1, 35, 5, 36, 1, 38, 4, 39, 4, 40, 2, 41, 1, 42, 5, 43, 1, 45, 4, 46, 4, 47, 2, 48, 1, 49, 5, 50, 1, 52, 4, 53, 4, 54, 2, 55, 1, 56, 5, 57, 1, 59, 4, 60, 4, 61, 2 ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, 1000 ) ),"\n"); [ 1, 2, 2, 6, 6, 2, 7, 30, 10, 3, 11, 3, 12, 4, 13, 2, 14, 30, 17, 3, 18, 3, 19, 4, 20, 2, 21, 30, 24, 3, 25, 3, 26, 4, 27, 2, 28, 30, 31, 3, 32, 3, 33, 4, 34, 2, 35, 30, 38, 3, 39, 3, 40, 4, 41, 2, 42, 30, 45, 3, 46, 3, 47, 4, 48, 2, 49, 30, 52, 3, 53, 3, 54, 4, 55, 2, 56, 30, 59, 3, 60, 3, 61, 4 ] gap> l := GeneratorsOfRws(rws);; gap> p := ReducedOne(rws);; gap> for i in l do > p := ReducedProduct( rws, p, ReducedProduct(rws,w,i) ); > od; gap> Print(ExtRepOfObj(p),"\n"); [ 4, 1, 5, 1, 6, 2, 7, 5, 8, 1, 9, 1, 11, 2, 12, 2, 14, 22, 17, 3, 18, 4, 20, 2, 21, 4, 22, 1, 24, 1, 26, 4, 28, 26, 31, 2, 32, 3, 33, 3, 34, 2, 35, 24, 36, 1, 38, 1, 39, 3, 42, 30, 43, 1, 44, 1, 45, 3, 46, 3, 47, 1, 48, 2, 50, 1, 51, 1, 52, 3, 54, 2, 55, 1, 56, 26, 57, 1, 59, 4, 60, 2 ] gap> l := GeneratorsOfRws(rws);; gap> p := ReducedOne(rws);; gap> for i in l do > p := ReducedProduct( rws, p, ReducedProduct( rws, > ReducedProduct(rws,w,i), w ) ); > od; gap> Print(ExtRepOfObj(p),"\n"); [ 1, 2, 4, 1, 6, 2, 7, 3, 8, 1, 10, 1, 11, 2, 12, 3, 13, 1, 14, 21, 17, 4, 18, 4, 19, 1, 20, 2, 21, 30, 22, 1, 24, 2, 26, 1, 27, 1, 28, 5, 29, 1, 31, 4, 33, 2, 34, 2, 35, 19, 36, 1, 38, 1, 39, 2, 41, 1, 42, 5, 44, 1, 45, 3, 48, 2, 49, 6, 50, 1, 52, 3, 53, 1, 54, 4, 55, 2, 56, 19, 57, 1, 59, 2, 60, 2, 61, 1 ] gap> Print(ExtRepOfObj( ReducedComm( rws, w, w ) ),"\n"); [ ] gap> a := ReducedProduct( rws, ReducedProduct( rws, w, w ), w );; gap> Print(ExtRepOfObj(a),"\n"); [ 3, 1, 4, 1, 5, 1, 8, 1, 12, 1, 15, 1, 19, 1, 22, 1, 26, 1, 29, 1, 33, 1, 36, 1, 40, 1, 43, 1, 47, 1, 50, 1, 54, 1, 57, 1, 61, 1 ] gap> a := ReducedProduct( rws, a, a );; gap> Print(ExtRepOfObj(a),"\n"); [ 9, 1, 12, 3, 16, 1, 19, 3, 23, 1, 26, 3, 30, 1, 33, 3, 37, 1, 40, 3, 44, 1, 47, 3, 51, 1, 54, 3, 58, 1, 61, 3 ] gap> a := ReducedProduct( rws, a, a );; gap> Print(ExtRepOfObj(a),"\n"); [ ] gap> Print(ExtRepOfObj( ReducedLeftQuotient( rws, ReducedProduct(rws,w,w), w) ),"\n"); [ 1, 1, 2, 2, 3, 1, 4, 1, 5, 1, 6, 1, 7, 5, 8, 1, 10, 4, 11, 4, 12, 2, 13, 1, 14, 5, 15, 1, 17, 4, 18, 4, 19, 2, 20, 1, 21, 5, 22, 1, 24, 4, 25, 4, 26, 2, 27, 1, 28, 5, 29, 1, 31, 4, 32, 4, 33, 2, 34, 1, 35, 5, 36, 1, 38, 4, 39, 4, 40, 2, 41, 1, 42, 5, 43, 1, 45, 4, 46, 4, 47, 2, 48, 1, 49, 5, 50, 1, 52, 4, 53, 4, 54, 2, 55, 1, 56, 5, 57, 1, 59, 4, 60, 4, 61, 2 ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, -1 ) ),"\n"); [ 1, 1, 2, 2, 3, 1, 4, 1, 5, 1, 6, 1, 7, 5, 8, 1, 10, 4, 11, 4, 12, 2, 13, 1, 14, 5, 15, 1, 17, 4, 18, 4, 19, 2, 20, 1, 21, 5, 22, 1, 24, 4, 25, 4, 26, 2, 27, 1, 28, 5, 29, 1, 31, 4, 32, 4, 33, 2, 34, 1, 35, 5, 36, 1, 38, 4, 39, 4, 40, 2, 41, 1, 42, 5, 43, 1, 45, 4, 46, 4, 47, 2, 48, 1, 49, 5, 50, 1, 52, 4, 53, 4, 54, 2, 55, 1, 56, 5, 57, 1, 59, 4, 60, 4, 61, 2 ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, 0 ) ),"\n"); [ ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, 1 ) ),"\n"); [ 1, 2, 2, 6, 3, 1, 4, 1, 5, 1, 6, 2, 7, 30, 8, 1, 9, 1, 10, 4, 11, 4, 12, 4, 13, 2, 14, 30, 15, 1, 16, 1, 17, 4, 18, 4, 19, 4, 20, 2, 21, 30, 22, 1, 23, 1, 24, 4, 25, 4, 26, 4, 27, 2, 28, 30, 29, 1, 30, 1, 31, 4, 32, 4, 33, 4, 34, 2, 35, 30, 36, 1, 37, 1, 38, 4, 39, 4, 40, 4, 41, 2, 42, 30, 43, 1, 44, 1, 45, 4, 46, 4, 47, 4, 48, 2, 49, 30, 50, 1, 51, 1, 52, 4, 53, 4, 54, 4, 55, 2, 56, 30, 57, 1, 58, 1, 59, 4, 60, 4, 61, 4 ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, 2 ) ),"\n"); [ 1, 1, 2, 2, 6, 1, 7, 5, 9, 1, 10, 3, 11, 3, 13, 1, 14, 5, 16, 1, 17, 3, 18, 3, 20, 1, 21, 5, 23, 1, 24, 3, 25, 3, 27, 1, 28, 5, 30, 1, 31, 3, 32, 3, 34, 1, 35, 5, 37, 1, 38, 3, 39, 3, 41, 1, 42, 5, 44, 1, 45, 3, 46, 3, 48, 1, 49, 5, 51, 1, 52, 3, 53, 3, 55, 1, 56, 5, 58, 1, 59, 3, 60, 3 ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, 3 ) ),"\n"); [ 3, 1, 4, 1, 5, 1, 8, 1, 12, 1, 15, 1, 19, 1, 22, 1, 26, 1, 29, 1, 33, 1, 36, 1, 40, 1, 43, 1, 47, 1, 50, 1, 54, 1, 57, 1, 61, 1 ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, 4 ) ),"\n"); [ 1, 2, 2, 6, 6, 2, 7, 30, 10, 3, 11, 3, 12, 4, 13, 2, 14, 30, 17, 3, 18, 3, 19, 4, 20, 2, 21, 30, 24, 3, 25, 3, 26, 4, 27, 2, 28, 30, 31, 3, 32, 3, 33, 4, 34, 2, 35, 30, 38, 3, 39, 3, 40, 4, 41, 2, 42, 30, 45, 3, 46, 3, 47, 4, 48, 2, 49, 30, 52, 3, 53, 3, 54, 4, 55, 2, 56, 30, 59, 3, 60, 3, 61, 4 ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, 5 ) ),"\n"); [ 1, 1, 2, 2, 3, 1, 4, 1, 5, 1, 6, 1, 7, 5, 8, 1, 9, 1, 10, 1, 11, 1, 12, 1, 13, 1, 14, 5, 15, 1, 16, 1, 17, 1, 18, 1, 19, 1, 20, 1, 21, 5, 22, 1, 23, 1, 24, 1, 25, 1, 26, 1, 27, 1, 28, 5, 29, 1, 30, 1, 31, 1, 32, 1, 33, 1, 34, 1, 35, 5, 36, 1, 37, 1, 38, 1, 39, 1, 40, 1, 41, 1, 42, 5, 43, 1, 44, 1, 45, 1, 46, 1, 47, 1, 48, 1, 49, 5, 50, 1, 51, 1, 52, 1, 53, 1, 54, 1, 55, 1, 56, 5, 57, 1, 58, 1, 59, 1, 60, 1, 61, 1 ] gap> Print(ExtRepOfObj( ReducedComm( rws, w, w ) ),"\n"); [ ] gap> Print(ExtRepOfObj( ReducedComm( rws, w, l[1] ) ),"\n"); [ 2, 6, 3, 1, 4, 1 ] gap> Print(ExtRepOfObj( ReducedLeftQuotient( rws, w, w ) ),"\n"); [ ] gap> Print(ExtRepOfObj( ReducedLeftQuotient( rws, w, l[1] ) ),"\n"); [ 1, 2, 2, 4, 3, 1, 5, 1, 6, 1, 7, 5, 8, 1, 10, 4, 11, 4, 12, 2, 13, 1, 14, 5, 15, 1, 17, 4, 18, 4, 19, 2, 20, 1, 21, 5, 22, 1, 24, 4, 25, 4, 26, 2, 27, 1, 28, 5, 29, 1, 31, 4, 32, 4, 33, 2, 34, 1, 35, 5, 36, 1, 38, 4, 39, 4, 40, 2, 41, 1, 42, 5, 43, 1, 45, 4, 46, 4, 47, 2, 48, 1, 49, 5, 50, 1, 52, 4, 53, 4, 54, 2, 55, 1, 56, 5, 57, 1, 59, 4, 60, 4, 61, 2 ] gap> Print(ExtRepOfObj( ReducedOne( rws ) ),"\n"); [ ] gap> Print(ExtRepOfObj( ReducedQuotient( rws, w, w ) ),"\n"); [ ] gap> Print(ExtRepOfObj( ReducedQuotient( rws, w, l[1] ) ),"\n"); [ 1, 1, 2, 3, 3, 1, 4, 1, 6, 2, 7, 30, 8, 1, 9, 1, 10, 4, 11, 4, 12, 4, 13, 2, 14, 30, 15, 1, 16, 1, 17, 4, 18, 4, 19, 4, 20, 2, 21, 30, 22, 1, 23, 1, 24, 4, 25, 4, 26, 4, 27, 2, 28, 30, 29, 1, 30, 1, 31, 4, 32, 4, 33, 4, 34, 2, 35, 30, 36, 1, 37, 1, 38, 4, 39, 4, 40, 4, 41, 2, 42, 30, 43, 1, 44, 1, 45, 4, 46, 4, 47, 4, 48, 2, 49, 30, 50, 1, 51, 1, 52, 4, 53, 4, 54, 4, 55, 2, 56, 30, 57, 1, 58, 1, 59, 4, 60, 4, 61, 4 ] ############################################################################# # create a free group, 32 bits gap> f := FreeGroup(IsSyllableWordsFamily,1200);; gap> g := GeneratorsOfGroup(f){[1..61]};; # use 'fn' as abbreviation of 'g[n]' gap> f1 := g[1];; gap> f2 := g[2];; gap> f3 := g[3];; gap> f4 := g[4];; gap> f5 := g[5];; gap> f6 := g[6];; gap> f7 := g[7];; gap> f8 := g[8];; gap> f9 := g[9];; gap> f10 := g[10];; gap> f11 := g[11];; gap> f12 := g[12];; gap> f13 := g[13];; gap> f14 := g[14];; gap> f15 := g[15];; gap> f16 := g[16];; gap> f17 := g[17];; gap> f18 := g[18];; gap> f19 := g[19];; gap> f20 := g[20];; gap> f21 := g[21];; gap> f22 := g[22];; gap> f23 := g[23];; gap> f24 := g[24];; gap> f25 := g[25];; gap> f26 := g[26];; gap> f27 := g[27];; gap> f28 := g[28];; gap> f29 := g[29];; gap> f30 := g[30];; gap> f31 := g[31];; gap> f32 := g[32];; gap> f33 := g[33];; gap> f34 := g[34];; gap> f35 := g[35];; gap> f36 := g[36];; gap> f37 := g[37];; gap> f38 := g[38];; gap> f39 := g[39];; gap> f40 := g[40];; gap> f41 := g[41];; gap> f42 := g[42];; gap> f43 := g[43];; gap> f44 := g[44];; gap> f45 := g[45];; gap> f46 := g[46];; gap> f47 := g[47];; gap> f48 := g[48];; gap> f49 := g[49];; gap> f50 := g[50];; gap> f51 := g[51];; gap> f52 := g[52];; gap> f53 := g[53];; gap> f54 := g[54];; gap> f55 := g[55];; gap> f56 := g[56];; gap> f57 := g[57];; gap> f58 := g[58];; gap> f59 := g[59];; gap> f60 := g[60];; gap> f61 := g[61];; # store the relators in gap> r := [ > # power relators > [ 8, f9 ], [ 15, f16 ], [ 22, f23 ], [ 29, f30 ], [ 36, f37 ], [ 43, > f44 ], [ 50, f51 ], [ 57, f58 ], > # commutator relators > [ 2, 1, f2 ], [ 4, 1, f5 ], [ 5, 1, f4*f5 ], [ 13, 1, f13^2*f20 ], [ > 14, 1, f14^30*f21 ], [ 15, 1, f15*f16*f22 ], [ 16, 1, f16*f23 ], [ > 17, 1, f17^4*f24 ], [ 18, 1, f18^4*f25 ], [ 19, 1, f19^4*f26 ], [ > 20, 1, f20^2*f27 ], [ 21, 1, f21^30*f28 ], [ 22, 1, f22*f23*f29 ], [ > 23, 1, f23*f30 ], [ 24, 1, f24^4*f31 ], [ 25, 1, f25^4*f32 ], [ 26, > 1, f26^4*f33 ], [ 27, 1, f13*f27^2 ], [ 28, 1, f14*f28^30 ], [ 29, > 1, f15*f29*f30 ], [ 30, 1, f16*f30 ], [ 31, 1, f17*f31^4 ], [ 32, 1, > f18*f32^4 ], [ 33, 1, f19*f33^4 ], [ 41, 1, f41^2*f48 ], [ 42, 1, > f42^30*f49 ], [ 43, 1, f43*f44*f50 ], [ 44, 1, f44*f51 ], [ 45, 1, > f45^4*f52 ], [ 46, 1, f46^4*f53 ], [ 47, 1, f47^4*f54 ], [ 48, 1, > f48^2*f55 ], [ 49, 1, f49^30*f56 ], [ 50, 1, f50*f51*f57 ], [ 51, 1, > f51*f58 ], [ 52, 1, f52^4*f59 ], [ 53, 1, f53^4*f60 ], [ 54, 1, > f54^4*f61 ], [ 55, 1, f41*f55^2 ], [ 56, 1, f42*f56^30 ], [ 57, 1, > f43*f57*f58 ], [ 58, 1, f44*f58 ], [ 59, 1, f45*f59^4 ], [ 60, 1, > f46*f60^4 ], [ 61, 1, f47*f61^4 ], [ 3, 2, f3*f5 ], [ 4, 2, f3*f4*f5 > ], [ 5, 2, f4*f5 ], [ 13, 2, f13^2*f20 ], [ 14, 2, f14^30*f21 ], [ > 15, 2, f15*f16*f22 ], [ 16, 2, f16*f23 ], [ 17, 2, f17^4*f24 ], [ > 18, 2, f18^4*f25 ], [ 19, 2, f19^4*f26 ], [ 20, 2, f20^2*f41 ], [ > 21, 2, f21^30*f42 ], [ 22, 2, f22*f23*f43 ], [ 23, 2, f23*f44 ], [ > 24, 2, f24^4*f45 ], [ 25, 2, f25^4*f46 ], [ 26, 2, f26^4*f47 ], [ > 27, 2, f27^2*f55 ], [ 28, 2, f28^30*f56 ], [ 29, 2, f29*f30*f57 ], [ > 30, 2, f30*f58 ], [ 31, 2, f31^4*f59 ], [ 32, 2, f32^4*f60 ], [ 33, > 2, f33^4*f61 ], [ 34, 2, f13*f34^2 ], [ 35, 2, f14*f35^30 ], [ 36, > 2, f15*f36*f37 ], [ 37, 2, f16*f37 ], [ 38, 2, f17*f38^4 ], [ 39, 2, > f18*f39^4 ], [ 40, 2, f19*f40^4 ], [ 41, 2, f27*f41^2 ], [ 42, 2, > f28*f42^30 ], [ 43, 2, f29*f43*f44 ], [ 44, 2, f30*f44 ], [ 45, 2, > f31*f45^4 ], [ 46, 2, f32*f46^4 ], [ 47, 2, f33*f47^4 ], [ 48, 2, > f34*f48^2 ], [ 49, 2, f35*f49^30 ], [ 50, 2, f36*f50*f51 ], [ 51, 2, > f37*f51 ], [ 52, 2, f38*f52^4 ], [ 53, 2, f39*f53^4 ], [ 54, 2, > f40*f54^4 ], [ 55, 2, f48*f55^2 ], [ 56, 2, f49*f56^30 ], [ 57, 2, > f50*f57*f58 ], [ 58, 2, f51*f58 ], [ 59, 2, f52*f59^4 ], [ 60, 2, > f53*f60^4 ], [ 61, 2, f54*f61^4 ], [ 6, 3, f6^2*f34 ], [ 7, 3, > f7^30*f35 ], [ 8, 3, f8*f9*f36 ], [ 9, 3, f9*f37 ], [ 10, 3, > f10^4*f38 ], [ 11, 3, f11^4*f39 ], [ 12, 3, f12^4*f40 ], [ 13, 3, > f13^2*f41 ], [ 14, 3, f14^30*f42 ], [ 15, 3, f15*f16*f43 ], [ 16, 3, > f16*f44 ], [ 17, 3, f17^4*f45 ], [ 18, 3, f18^4*f46 ], [ 19, 3, > f19^4*f47 ], [ 20, 3, f20^2*f48 ], [ 21, 3, f21^30*f49 ], [ 22, 3, > f22*f23*f50 ], [ 23, 3, f23*f51 ], [ 24, 3, f24^4*f52 ], [ 25, 3, > f25^4*f53 ], [ 26, 3, f26^4*f54 ], [ 27, 3, f27^2*f55 ], [ 28, 3, > f28^30*f56 ], [ 29, 3, f29*f30*f57 ], [ 30, 3, f30*f58 ], [ 31, 3, > f31^4*f59 ], [ 32, 3, f32^4*f60 ], [ 33, 3, f33^4*f61 ], [ 34, 3, > f6*f34^2 ], [ 35, 3, f7*f35^30 ], [ 36, 3, f8*f36*f37 ], [ 37, 3, > f9*f37 ], [ 38, 3, f10*f38^4 ], [ 39, 3, f11*f39^4 ], [ 40, 3, > f12*f40^4 ], [ 41, 3, f13*f41^2 ], [ 42, 3, f14*f42^30 ], [ 43, 3, > f15*f43*f44 ], [ 44, 3, f16*f44 ], [ 45, 3, f17*f45^4 ], [ 46, 3, > f18*f46^4 ], [ 47, 3, f19*f47^4 ], [ 48, 3, f20*f48^2 ], [ 49, 3, > f21*f49^30 ], [ 50, 3, f22*f50*f51 ], [ 51, 3, f23*f51 ], [ 52, 3, > f24*f52^4 ], [ 53, 3, f25*f53^4 ], [ 54, 3, f26*f54^4 ], [ 55, 3, > f27*f55^2 ], [ 56, 3, f28*f56^30 ], [ 57, 3, f29*f57*f58 ], [ 58, 3, > f30*f58 ], [ 59, 3, f31*f59^4 ], [ 60, 3, f32*f60^4 ], [ 61, 3, > f33*f61^4 ], [ 6, 4, f6^2*f20 ], [ 7, 4, f7^30*f21 ], [ 8, 4, > f8*f9*f22 ], [ 9, 4, f9*f23 ], [ 10, 4, f10^4*f24 ], [ 11, 4, > f11^4*f25 ], [ 12, 4, f12^4*f26 ], [ 13, 4, f13^2*f27 ], [ 14, 4, > f14^30*f28 ], [ 15, 4, f15*f16*f29 ], [ 16, 4, f16*f30 ], [ 17, 4, > f17^4*f31 ], [ 18, 4, f18^4*f32 ], [ 19, 4, f19^4*f33 ], [ 20, 4, > f6*f20^2 ], [ 21, 4, f7*f21^30 ], [ 22, 4, f8*f22*f23 ], [ 23, 4, > f9*f23 ], [ 24, 4, f10*f24^4 ], [ 25, 4, f11*f25^4 ], [ 26, 4, > f12*f26^4 ], [ 27, 4, f13*f27^2 ], [ 28, 4, f14*f28^30 ], [ 29, 4, > f15*f29*f30 ], [ 30, 4, f16*f30 ], [ 31, 4, f17*f31^4 ], [ 32, 4, > f18*f32^4 ], [ 33, 4, f19*f33^4 ], [ 34, 4, f34^2*f48 ], [ 35, 4, > f35^30*f49 ], [ 36, 4, f36*f37*f50 ], [ 37, 4, f37*f51 ], [ 38, 4, > f38^4*f52 ], [ 39, 4, f39^4*f53 ], [ 40, 4, f40^4*f54 ], [ 41, 4, > f41^2*f55 ], [ 42, 4, f42^30*f56 ], [ 43, 4, f43*f44*f57 ], [ 44, 4, > f44*f58 ], [ 45, 4, f45^4*f59 ], [ 46, 4, f46^4*f60 ], [ 47, 4, > f47^4*f61 ], [ 48, 4, f34*f48^2 ], [ 49, 4, f35*f49^30 ], [ 50, 4, > f36*f50*f51 ], [ 51, 4, f37*f51 ], [ 52, 4, f38*f52^4 ], [ 53, 4, > f39*f53^4 ], [ 54, 4, f40*f54^4 ], [ 55, 4, f41*f55^2 ], [ 56, 4, > f42*f56^30 ], [ 57, 4, f43*f57*f58 ], [ 58, 4, f44*f58 ], [ 59, 4, > f45*f59^4 ], [ 60, 4, f46*f60^4 ], [ 61, 4, f47*f61^4 ], [ 6, 5, > f6^2*f13 ], [ 7, 5, f7^30*f14 ], [ 8, 5, f8*f9*f15 ], [ 9, 5, f9*f16 > ], [ 10, 5, f10^4*f17 ], [ 11, 5, f11^4*f18 ], [ 12, 5, f12^4*f19 ], > [ 13, 5, f6*f13^2 ], [ 14, 5, f7*f14^30 ], [ 15, 5, f8*f15*f16 ], [ > 16, 5, f9*f16 ], [ 17, 5, f10*f17^4 ], [ 18, 5, f11*f18^4 ], [ 19, > 5, f12*f19^4 ], [ 20, 5, f20^2*f27 ], [ 21, 5, f21^30*f28 ], [ 22, > 5, f22*f23*f29 ], [ 23, 5, f23*f30 ], [ 24, 5, f24^4*f31 ], [ 25, 5, > f25^4*f32 ], [ 26, 5, f26^4*f33 ], [ 27, 5, f20*f27^2 ], [ 28, 5, > f21*f28^30 ], [ 29, 5, f22*f29*f30 ], [ 30, 5, f23*f30 ], [ 31, 5, > f24*f31^4 ], [ 32, 5, f25*f32^4 ], [ 33, 5, f26*f33^4 ], [ 34, 5, > f34^2*f41 ], [ 35, 5, f35^30*f42 ], [ 36, 5, f36*f37*f43 ], [ 37, 5, > f37*f44 ], [ 38, 5, f38^4*f45 ], [ 39, 5, f39^4*f46 ], [ 40, 5, > f40^4*f47 ], [ 41, 5, f34*f41^2 ], [ 42, 5, f35*f42^30 ], [ 43, 5, > f36*f43*f44 ], [ 44, 5, f37*f44 ], [ 45, 5, f38*f45^4 ], [ 46, 5, > f39*f46^4 ], [ 47, 5, f40*f47^4 ], [ 48, 5, f48^2*f55 ], [ 49, 5, > f49^30*f56 ], [ 50, 5, f50*f51*f57 ], [ 51, 5, f51*f58 ], [ 52, 5, > f52^4*f59 ], [ 53, 5, f53^4*f60 ], [ 54, 5, f54^4*f61 ], [ 55, 5, > f48*f55^2 ], [ 56, 5, f49*f56^30 ], [ 57, 5, f50*f57*f58 ], [ 58, 5, > f51*f58 ], [ 59, 5, f52*f59^4 ], [ 60, 5, f53*f60^4 ], [ 61, 5, > f54*f61^4 ], [ 7, 6, f7^4 ], [ 10, 6, f11*f12 ], [ 11, 6, > f11^4*f12^3 ], [ 12, 6, f11^3*f12^3 ], [ 10, 7, f11^4*f12^3 ], [ 11, > 7, f10^4*f11^4*f12^2 ], [ 12, 7, f10^2*f11^4*f12^4 ], [ 10, 8, f10 > ], [ 11, 8, f11 ], [ 12, 8, f12 ], [ 10, 9, f10^3 ], [ 11, 9, f11^3 > ], [ 12, 9, f12^3 ], [ 14, 13, f14^4 ], [ 17, 13, f18*f19 ], [ 18, > 13, f18^4*f19^3 ], [ 19, 13, f18^3*f19^3 ], [ 17, 14, f18^4*f19^3 ], > [ 18, 14, f17^4*f18^4*f19^2 ], [ 19, 14, f17^2*f18^4*f19^4 ], [ 17, > 15, f17 ], [ 18, 15, f18 ], [ 19, 15, f19 ], [ 17, 16, f17^3 ], [ > 18, 16, f18^3 ], [ 19, 16, f19^3 ], [ 21, 20, f21^4 ], [ 24, 20, > f25*f26 ], [ 25, 20, f25^4*f26^3 ], [ 26, 20, f25^3*f26^3 ], [ 24, > 21, f25^4*f26^3 ], [ 25, 21, f24^4*f25^4*f26^2 ], [ 26, 21, > f24^2*f25^4*f26^4 ], [ 24, 22, f24 ], [ 25, 22, f25 ], [ 26, 22, f26 > ], [ 24, 23, f24^3 ], [ 25, 23, f25^3 ], [ 26, 23, f26^3 ], [ 28, > 27, f28^4 ], [ 31, 27, f32*f33 ], [ 32, 27, f32^4*f33^3 ], [ 33, 27, > f32^3*f33^3 ], [ 31, 28, f32^4*f33^3 ], [ 32, 28, f31^4*f32^4*f33^2 > ], [ 33, 28, f31^2*f32^4*f33^4 ], [ 31, 29, f31 ], [ 32, 29, f32 ], > [ 33, 29, f33 ], [ 31, 30, f31^3 ], [ 32, 30, f32^3 ], [ 33, 30, > f33^3 ], [ 35, 34, f35^4 ], [ 38, 34, f39*f40 ], [ 39, 34, > f39^4*f40^3 ], [ 40, 34, f39^3*f40^3 ], [ 38, 35, f39^4*f40^3 ], [ > 39, 35, f38^4*f39^4*f40^2 ], [ 40, 35, f38^2*f39^4*f40^4 ], [ 38, > 36, f38 ], [ 39, 36, f39 ], [ 40, 36, f40 ], [ 38, 37, f38^3 ], [ > 39, 37, f39^3 ], [ 40, 37, f40^3 ], [ 42, 41, f42^4 ], [ 45, 41, > f46*f47 ], [ 46, 41, f46^4*f47^3 ], [ 47, 41, f46^3*f47^3 ], [ 45, > 42, f46^4*f47^3 ], [ 46, 42, f45^4*f46^4*f47^2 ], [ 47, 42, > f45^2*f46^4*f47^4 ], [ 45, 43, f45 ], [ 46, 43, f46 ], [ 47, 43, f47 > ], [ 45, 44, f45^3 ], [ 46, 44, f46^3 ], [ 47, 44, f47^3 ], [ 49, > 48, f49^4 ], [ 52, 48, f53*f54 ], [ 53, 48, f53^4*f54^3 ], [ 54, 48, > f53^3*f54^3 ], [ 52, 49, f53^4*f54^3 ], [ 53, 49, f52^4*f53^4*f54^2 > ], [ 54, 49, f52^2*f53^4*f54^4 ], [ 52, 50, f52 ], [ 53, 50, f53 ], > [ 54, 50, f54 ], [ 52, 51, f52^3 ], [ 53, 51, f53^3 ], [ 54, 51, > f54^3 ], [ 56, 55, f56^4 ], [ 59, 55, f60*f61 ], [ 60, 55, > f60^4*f61^3 ], [ 61, 55, f60^3*f61^3 ], [ 59, 56, f60^4*f61^3 ], [ > 60, 56, f59^4*f60^4*f61^2 ], [ 61, 56, f59^2*f60^4*f61^4 ], [ 59, > 57, f59 ], [ 60, 57, f60 ], [ 61, 57, f61 ], [ 59, 58, f59^3 ], [ > 60, 58, f60^3 ], [ 61, 58, f61^3 ], ];; # construct a new single collector gap> rws := SingleCollector( g, [ 3, 7, 2, 2, 2, 3, 31, 2, 2, 5, 5, 5, 3, > 31, 2, 2, 5, 5, 5, 3, 31, 2, 2, 5, 5, 5, 3, 31, 2, 2, 5, 5, 5, 3, 31, > 2, 2, 5, 5, 5, 3, 31, 2, 2, 5, 5, 5, 3, 31, 2, 2, 5, 5, 5, 3, 31, 2, 2, > 5, 5, 5 ] ); <> # set the relators gap> for x in r do > if 2 = Length(x) then > SetPower( rws, x[1], x[2] ); > else > SetCommutator( rws, x[1], x[2], x[3] ); > fi; > od; # reduce the rules and update the collector gap> UpdatePolycyclicCollector(rws); gap> ReduceRules(rws); gap> UpdatePolycyclicCollector(rws); gap> IsConfluent(rws); true gap> rws; <> gap> Print(List( rws![SCP_INVERSES], ExtRepOfObj ),"\n"); [ [ 1, 2 ], [ 2, 6 ], [ 3, 1 ], [ 4, 1 ], [ 5, 1 ], [ 6, 2 ], [ 7, 30 ], [ 8, 1, 9, 1 ], [ 9, 1 ], [ 10, 4 ], [ 11, 4 ], [ 12, 4 ], [ 13, 2 ], [ 14, 30 ], [ 15, 1, 16, 1 ], [ 16, 1 ], [ 17, 4 ], [ 18, 4 ], [ 19, 4 ], [ 20, 2 ], [ 21, 30 ], [ 22, 1, 23, 1 ], [ 23, 1 ], [ 24, 4 ], [ 25, 4 ], [ 26, 4 ], [ 27, 2 ], [ 28, 30 ], [ 29, 1, 30, 1 ], [ 30, 1 ], [ 31, 4 ], [ 32, 4 ], [ 33, 4 ], [ 34, 2 ], [ 35, 30 ], [ 36, 1, 37, 1 ], [ 37, 1 ], [ 38, 4 ], [ 39, 4 ], [ 40, 4 ], [ 41, 2 ], [ 42, 30 ], [ 43, 1, 44, 1 ], [ 44, 1 ], [ 45, 4 ], [ 46, 4 ], [ 47, 4 ], [ 48, 2 ], [ 49, 30 ], [ 50, 1, 51, 1 ], [ 51, 1 ], [ 52, 4 ], [ 53, 4 ], [ 54, 4 ], [ 55, 2 ], [ 56, 30 ], [ 57, 1, 58, 1 ], [ 58, 1 ], [ 59, 4 ], [ 60, 4 ], [ 61, 4 ] ] # force stack overflow gap> rws![SCP_MAX_STACK_SIZE] := 1;; gap> IsConfluent(rws); true gap> rws![SCP_MAX_STACK_SIZE] := 1;; # construct the maximal word gap> l := [1..61]*0;; gap> r := RelativeOrders(rws);; gap> w := Product( List( [1..61], x -> g[x]^(r[x]-1) ) );; gap> Print(ExtRepOfObj(w),"\n"); [ 1, 2, 2, 6, 3, 1, 4, 1, 5, 1, 6, 2, 7, 30, 8, 1, 9, 1, 10, 4, 11, 4, 12, 4, 13, 2, 14, 30, 15, 1, 16, 1, 17, 4, 18, 4, 19, 4, 20, 2, 21, 30, 22, 1, 23, 1, 24, 4, 25, 4, 26, 4, 27, 2, 28, 30, 29, 1, 30, 1, 31, 4, 32, 4, 33, 4, 34, 2, 35, 30, 36, 1, 37, 1, 38, 4, 39, 4, 40, 4, 41, 2, 42, 30, 43, 1, 44, 1, 45, 4, 46, 4, 47, 4, 48, 2, 49, 30, 50, 1, 51, 1, 52, 4, 53, 4, 54, 4, 55, 2, 56, 30, 57, 1, 58, 1, 59, 4, 60, 4, 61, 4 ] # start multiplying around with gap> Print(ExtRepOfObj( ReducedProduct( rws, w, w ) ),"\n"); [ 1, 1, 2, 2, 6, 1, 7, 5, 9, 1, 10, 3, 11, 3, 13, 1, 14, 5, 16, 1, 17, 3, 18, 3, 20, 1, 21, 5, 23, 1, 24, 3, 25, 3, 27, 1, 28, 5, 30, 1, 31, 3, 32, 3, 34, 1, 35, 5, 37, 1, 38, 3, 39, 3, 41, 1, 42, 5, 44, 1, 45, 3, 46, 3, 48, 1, 49, 5, 51, 1, 52, 3, 53, 3, 55, 1, 56, 5, 58, 1, 59, 3, 60, 3 ] gap> Print(ExtRepOfObj( SingleCollector_Solution( rws, w, w^0 ) ),"\n"); [ 1, 1, 2, 2, 3, 1, 4, 1, 5, 1, 6, 1, 7, 5, 8, 1, 10, 4, 11, 4, 12, 2, 13, 1, 14, 5, 15, 1, 17, 4, 18, 4, 19, 2, 20, 1, 21, 5, 22, 1, 24, 4, 25, 4, 26, 2, 27, 1, 28, 5, 29, 1, 31, 4, 32, 4, 33, 2, 34, 1, 35, 5, 36, 1, 38, 4, 39, 4, 40, 2, 41, 1, 42, 5, 43, 1, 45, 4, 46, 4, 47, 2, 48, 1, 49, 5, 50, 1, 52, 4, 53, 4, 54, 2, 55, 1, 56, 5, 57, 1, 59, 4, 60, 4, 61, 2 ] gap> Print(ExtRepOfObj( ReducedInverse( rws, w ) ),"\n"); [ 1, 1, 2, 2, 3, 1, 4, 1, 5, 1, 6, 1, 7, 5, 8, 1, 10, 4, 11, 4, 12, 2, 13, 1, 14, 5, 15, 1, 17, 4, 18, 4, 19, 2, 20, 1, 21, 5, 22, 1, 24, 4, 25, 4, 26, 2, 27, 1, 28, 5, 29, 1, 31, 4, 32, 4, 33, 2, 34, 1, 35, 5, 36, 1, 38, 4, 39, 4, 40, 2, 41, 1, 42, 5, 43, 1, 45, 4, 46, 4, 47, 2, 48, 1, 49, 5, 50, 1, 52, 4, 53, 4, 54, 2, 55, 1, 56, 5, 57, 1, 59, 4, 60, 4, 61, 2 ] gap> Print(ExtRepOfObj( ReducedForm( rws, w^-1 ) ),"\n"); [ 1, 1, 2, 2, 3, 1, 4, 1, 5, 1, 6, 1, 7, 5, 8, 1, 10, 4, 11, 4, 12, 2, 13, 1, 14, 5, 15, 1, 17, 4, 18, 4, 19, 2, 20, 1, 21, 5, 22, 1, 24, 4, 25, 4, 26, 2, 27, 1, 28, 5, 29, 1, 31, 4, 32, 4, 33, 2, 34, 1, 35, 5, 36, 1, 38, 4, 39, 4, 40, 2, 41, 1, 42, 5, 43, 1, 45, 4, 46, 4, 47, 2, 48, 1, 49, 5, 50, 1, 52, 4, 53, 4, 54, 2, 55, 1, 56, 5, 57, 1, 59, 4, 60, 4, 61, 2 ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, 1000 ) ),"\n"); [ 1, 2, 2, 6, 6, 2, 7, 30, 10, 3, 11, 3, 12, 4, 13, 2, 14, 30, 17, 3, 18, 3, 19, 4, 20, 2, 21, 30, 24, 3, 25, 3, 26, 4, 27, 2, 28, 30, 31, 3, 32, 3, 33, 4, 34, 2, 35, 30, 38, 3, 39, 3, 40, 4, 41, 2, 42, 30, 45, 3, 46, 3, 47, 4, 48, 2, 49, 30, 52, 3, 53, 3, 54, 4, 55, 2, 56, 30, 59, 3, 60, 3, 61, 4 ] gap> l := GeneratorsOfRws(rws);; gap> p := ReducedOne(rws);; gap> for i in l do > p := ReducedProduct( rws, p, ReducedProduct(rws,w,i) ); > od; gap> Print(ExtRepOfObj(p),"\n"); [ 4, 1, 5, 1, 6, 2, 7, 5, 8, 1, 9, 1, 11, 2, 12, 2, 14, 22, 17, 3, 18, 4, 20, 2, 21, 4, 22, 1, 24, 1, 26, 4, 28, 26, 31, 2, 32, 3, 33, 3, 34, 2, 35, 24, 36, 1, 38, 1, 39, 3, 42, 30, 43, 1, 44, 1, 45, 3, 46, 3, 47, 1, 48, 2, 50, 1, 51, 1, 52, 3, 54, 2, 55, 1, 56, 26, 57, 1, 59, 4, 60, 2 ] gap> l := GeneratorsOfRws(rws);; gap> p := ReducedOne(rws);; gap> for i in l do > p := ReducedProduct( rws, p, ReducedProduct( rws, > ReducedProduct(rws,w,i), w ) ); > od; gap> Print(ExtRepOfObj(p),"\n"); [ 1, 2, 4, 1, 6, 2, 7, 3, 8, 1, 10, 1, 11, 2, 12, 3, 13, 1, 14, 21, 17, 4, 18, 4, 19, 1, 20, 2, 21, 30, 22, 1, 24, 2, 26, 1, 27, 1, 28, 5, 29, 1, 31, 4, 33, 2, 34, 2, 35, 19, 36, 1, 38, 1, 39, 2, 41, 1, 42, 5, 44, 1, 45, 3, 48, 2, 49, 6, 50, 1, 52, 3, 53, 1, 54, 4, 55, 2, 56, 19, 57, 1, 59, 2, 60, 2, 61, 1 ] gap> Print(ExtRepOfObj( ReducedComm( rws, w, w ) ),"\n"); [ ] gap> a := ReducedProduct( rws, ReducedProduct( rws, w, w ), w );; gap> Print(ExtRepOfObj(a),"\n"); [ 3, 1, 4, 1, 5, 1, 8, 1, 12, 1, 15, 1, 19, 1, 22, 1, 26, 1, 29, 1, 33, 1, 36, 1, 40, 1, 43, 1, 47, 1, 50, 1, 54, 1, 57, 1, 61, 1 ] gap> a := ReducedProduct( rws, a, a );; gap> Print(ExtRepOfObj(a),"\n"); [ 9, 1, 12, 3, 16, 1, 19, 3, 23, 1, 26, 3, 30, 1, 33, 3, 37, 1, 40, 3, 44, 1, 47, 3, 51, 1, 54, 3, 58, 1, 61, 3 ] gap> a := ReducedProduct( rws, a, a );; gap> Print(ExtRepOfObj(a),"\n"); [ ] gap> Print(ExtRepOfObj( ReducedLeftQuotient( rws, ReducedProduct(rws,w,w), w) ),"\n"); [ 1, 1, 2, 2, 3, 1, 4, 1, 5, 1, 6, 1, 7, 5, 8, 1, 10, 4, 11, 4, 12, 2, 13, 1, 14, 5, 15, 1, 17, 4, 18, 4, 19, 2, 20, 1, 21, 5, 22, 1, 24, 4, 25, 4, 26, 2, 27, 1, 28, 5, 29, 1, 31, 4, 32, 4, 33, 2, 34, 1, 35, 5, 36, 1, 38, 4, 39, 4, 40, 2, 41, 1, 42, 5, 43, 1, 45, 4, 46, 4, 47, 2, 48, 1, 49, 5, 50, 1, 52, 4, 53, 4, 54, 2, 55, 1, 56, 5, 57, 1, 59, 4, 60, 4, 61, 2 ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, -1 ) ),"\n"); [ 1, 1, 2, 2, 3, 1, 4, 1, 5, 1, 6, 1, 7, 5, 8, 1, 10, 4, 11, 4, 12, 2, 13, 1, 14, 5, 15, 1, 17, 4, 18, 4, 19, 2, 20, 1, 21, 5, 22, 1, 24, 4, 25, 4, 26, 2, 27, 1, 28, 5, 29, 1, 31, 4, 32, 4, 33, 2, 34, 1, 35, 5, 36, 1, 38, 4, 39, 4, 40, 2, 41, 1, 42, 5, 43, 1, 45, 4, 46, 4, 47, 2, 48, 1, 49, 5, 50, 1, 52, 4, 53, 4, 54, 2, 55, 1, 56, 5, 57, 1, 59, 4, 60, 4, 61, 2 ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, 0 ) ),"\n"); [ ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, 1 ) ),"\n"); [ 1, 2, 2, 6, 3, 1, 4, 1, 5, 1, 6, 2, 7, 30, 8, 1, 9, 1, 10, 4, 11, 4, 12, 4, 13, 2, 14, 30, 15, 1, 16, 1, 17, 4, 18, 4, 19, 4, 20, 2, 21, 30, 22, 1, 23, 1, 24, 4, 25, 4, 26, 4, 27, 2, 28, 30, 29, 1, 30, 1, 31, 4, 32, 4, 33, 4, 34, 2, 35, 30, 36, 1, 37, 1, 38, 4, 39, 4, 40, 4, 41, 2, 42, 30, 43, 1, 44, 1, 45, 4, 46, 4, 47, 4, 48, 2, 49, 30, 50, 1, 51, 1, 52, 4, 53, 4, 54, 4, 55, 2, 56, 30, 57, 1, 58, 1, 59, 4, 60, 4, 61, 4 ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, 2 ) ),"\n"); [ 1, 1, 2, 2, 6, 1, 7, 5, 9, 1, 10, 3, 11, 3, 13, 1, 14, 5, 16, 1, 17, 3, 18, 3, 20, 1, 21, 5, 23, 1, 24, 3, 25, 3, 27, 1, 28, 5, 30, 1, 31, 3, 32, 3, 34, 1, 35, 5, 37, 1, 38, 3, 39, 3, 41, 1, 42, 5, 44, 1, 45, 3, 46, 3, 48, 1, 49, 5, 51, 1, 52, 3, 53, 3, 55, 1, 56, 5, 58, 1, 59, 3, 60, 3 ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, 3 ) ),"\n"); [ 3, 1, 4, 1, 5, 1, 8, 1, 12, 1, 15, 1, 19, 1, 22, 1, 26, 1, 29, 1, 33, 1, 36, 1, 40, 1, 43, 1, 47, 1, 50, 1, 54, 1, 57, 1, 61, 1 ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, 4 ) ),"\n"); [ 1, 2, 2, 6, 6, 2, 7, 30, 10, 3, 11, 3, 12, 4, 13, 2, 14, 30, 17, 3, 18, 3, 19, 4, 20, 2, 21, 30, 24, 3, 25, 3, 26, 4, 27, 2, 28, 30, 31, 3, 32, 3, 33, 4, 34, 2, 35, 30, 38, 3, 39, 3, 40, 4, 41, 2, 42, 30, 45, 3, 46, 3, 47, 4, 48, 2, 49, 30, 52, 3, 53, 3, 54, 4, 55, 2, 56, 30, 59, 3, 60, 3, 61, 4 ] gap> Print(ExtRepOfObj( ReducedPower( rws, w, 5 ) ),"\n"); [ 1, 1, 2, 2, 3, 1, 4, 1, 5, 1, 6, 1, 7, 5, 8, 1, 9, 1, 10, 1, 11, 1, 12, 1, 13, 1, 14, 5, 15, 1, 16, 1, 17, 1, 18, 1, 19, 1, 20, 1, 21, 5, 22, 1, 23, 1, 24, 1, 25, 1, 26, 1, 27, 1, 28, 5, 29, 1, 30, 1, 31, 1, 32, 1, 33, 1, 34, 1, 35, 5, 36, 1, 37, 1, 38, 1, 39, 1, 40, 1, 41, 1, 42, 5, 43, 1, 44, 1, 45, 1, 46, 1, 47, 1, 48, 1, 49, 5, 50, 1, 51, 1, 52, 1, 53, 1, 54, 1, 55, 1, 56, 5, 57, 1, 58, 1, 59, 1, 60, 1, 61, 1 ] gap> Print(ExtRepOfObj( ReducedComm( rws, w, w ) ),"\n"); [ ] gap> Print(ExtRepOfObj( ReducedComm( rws, w, l[1] ) ),"\n"); [ 2, 6, 3, 1, 4, 1 ] gap> Print(ExtRepOfObj( ReducedLeftQuotient( rws, w, w ) ) ,"\n"); [ ] gap> Print(ExtRepOfObj( ReducedLeftQuotient( rws, w, l[1] ) ),"\n"); [ 1, 2, 2, 4, 3, 1, 5, 1, 6, 1, 7, 5, 8, 1, 10, 4, 11, 4, 12, 2, 13, 1, 14, 5, 15, 1, 17, 4, 18, 4, 19, 2, 20, 1, 21, 5, 22, 1, 24, 4, 25, 4, 26, 2, 27, 1, 28, 5, 29, 1, 31, 4, 32, 4, 33, 2, 34, 1, 35, 5, 36, 1, 38, 4, 39, 4, 40, 2, 41, 1, 42, 5, 43, 1, 45, 4, 46, 4, 47, 2, 48, 1, 49, 5, 50, 1, 52, 4, 53, 4, 54, 2, 55, 1, 56, 5, 57, 1, 59, 4, 60, 4, 61, 2 ] gap> Print(ExtRepOfObj( ReducedOne( rws ) ),"\n"); [ ] gap> Print(ExtRepOfObj( ReducedQuotient( rws, w, w ) ),"\n"); [ ] gap> Print(ExtRepOfObj( ReducedQuotient( rws, w, l[1] ) ),"\n"); [ 1, 1, 2, 3, 3, 1, 4, 1, 6, 2, 7, 30, 8, 1, 9, 1, 10, 4, 11, 4, 12, 4, 13, 2, 14, 30, 15, 1, 16, 1, 17, 4, 18, 4, 19, 4, 20, 2, 21, 30, 22, 1, 23, 1, 24, 4, 25, 4, 26, 4, 27, 2, 28, 30, 29, 1, 30, 1, 31, 4, 32, 4, 33, 4, 34, 2, 35, 30, 36, 1, 37, 1, 38, 4, 39, 4, 40, 4, 41, 2, 42, 30, 43, 1, 44, 1, 45, 4, 46, 4, 47, 4, 48, 2, 49, 30, 50, 1, 51, 1, 52, 4, 53, 4, 54, 4, 55, 2, 56, 30, 57, 1, 58, 1, 59, 4, 60, 4, 61, 4 ] ############################################################################# gap> STOP_TEST( "rwspcsng.tst", 81100000 ); ############################################################################# ## #E gap-4r6p5/tst/vspcmat.tst0000644000175000017500000003647212172557256014204 0ustar billbill############################################################################# ## #W vspcmat.tst GAP library Thomas Breuer ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## (The test file 'vspcrow.tst' should contain the same tests.) ## ## To be listed in testinstall.g ## gap> START_TEST("vspcmat.tst"); ############################################################################# ## ## 1. Construct Gaussian and non-Gaussian matrix spaces ## gap> z:= LeftModuleByGenerators( GF(3), [], [ [ 0*Z(9) ] ] ); gap> IsGaussianMatrixSpace( z ); true gap> IsNonGaussianMatrixSpace( z ); false gap> v:= LeftModuleByGenerators( GF(9), > [ [ [ Z(3), Z(3) ], [ Z(3), Z(3) ] ] ] ); gap> IsGaussianMatrixSpace( v ); true gap> IsNonGaussianMatrixSpace( v ); false gap> v = LeftModuleByGenerators( GF(9), > [ [ [ Z(3), Z(3) ], [ Z(3), Z(3) ] ] ], Zero( v ) ); true gap> w:= LeftModuleByGenerators( GF(9), > [ [ [ Z(27), Z(3) ], [ Z(3), Z(3) ] ] ] ); gap> IsGaussianMatrixSpace( w ); false gap> IsNonGaussianMatrixSpace( w ); true gap> w = LeftModuleByGenerators( GF(9), > [ [ [ Z(27), Z(3) ], [ Z(3), Z(3) ] ] ], Zero( w ) ); true ############################################################################# ## ## 2. Methods for bases of non-Gaussian matrix spaces ## gap> Dimension( w ); 1 gap> n:= NiceVector( w, [ [ Z(27), Z(3) ], [ Z(3), Z(3) ] ] ); [ Z(3^3), Z(3), Z(3), Z(3) ] gap> UglyVector( w, n ) = [ [ Z(27), Z(3) ], [ Z(3), Z(3) ] ]; true ############################################################################# ## ## 3. Methods for semi-echelonized bases of Gaussian matrix spaces ## gap> v:= LeftModuleByGenerators( GF(9), > [ [ [ Z(3), Z(3) ], [ Z(3), Z(3) ] ], > [ [ Z(3), Z(3) ], [ Z(3), 0*Z(3) ] ] ] ); gap> b:= SemiEchelonBasis( v ); SemiEchelonBasis( , ... ) gap> lc:= LinearCombination( b, [ Z(3)^0, Z(3) ] ); [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, 0*Z(3) ] ] gap> Coefficients( b, lc ); [ Z(3)^0, Z(3) ] gap> SiftedVector( b, [ [ Z(3), Z(3) ], [ 0*Z(3), 0*Z(3) ] ] ); [ [ 0*Z(3), 0*Z(3) ], [ Z(3)^0, 0*Z(3) ] ] gap> SiftedVector( b, [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ] ] ); [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3) ] ] gap> b:= Basis( v, [ [ [ Z(3), Z(3) ], [ Z(3), Z(3) ] ] ] ); fail gap> b:= Basis( v, [ [ [ Z(3), Z(3) ], [ Z(3), Z(3) ] ], > [ [ Z(3), Z(3) ], [ Z(3), 0*Z(3) ] ] ] ); Basis( , [ [ [ Z(3), Z(3) ], [ Z(3), Z(3) ] ], [ [ Z(3), Z(3) ], [ Z(3), 0*Z(3) ] ] ] ) gap> IsSemiEchelonized( b ); false gap> b:= Basis( v, [ [ [ Z(3), Z(3) ], [ Z(3), Z(3) ] ], > [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ] ] ] ); Basis( , [ [ [ Z(3), Z(3) ], [ Z(3), Z(3) ] ], [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ] ] ] ) gap> IsSemiEchelonized( b ); false gap> b:= Basis( v, [ [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ], > [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, 0*Z(3) ] ] ] ); Basis( , [ [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ], [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, 0*Z(3) ] ] ] ) gap> IsSemiEchelonized( b ); false gap> b:= Basis( v, [ [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ], > [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ] ); SemiEchelonBasis( , [ [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ], [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ] ) gap> IsSemiEchelonized( b ); true ############################################################################# ## ## 4. Methods for row spaces ## gap> [ [] ] in w; false gap> Zero( w ) in w; true gap> [ [ 0, 0 ], [ 0, 1 ] ] in w; false gap> Z(3) * [ [ 0, 0 ], [ 0, 1 ], [ 0, 0 ] ] in w; false gap> [ [ Z(27), Z(3) ], [ Z(3), Z(3) ] ] in w; true gap> [ [] ] in v; false gap> Zero( v ) in v; true gap> [ [ 0, 0 ], [ 0, 1 ] ] in v; false gap> Z(3) * [ [ 0, 0 ], [ 0, 1 ], [ 0, 0 ] ] in v; false gap> Z(3) * [ [ 0, 0 ], [ 0, 1 ] ] in v; true gap> BasisNC( v, > [ [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ], > [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ] ); SemiEchelonBasis( , [ [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ], [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ] ) gap> Basis( v ); SemiEchelonBasis( , [ [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ], [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ] ) gap> SemiEchelonBasis( v ); SemiEchelonBasis( , [ [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ], [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ] ) gap> b:= SemiEchelonBasis( v, > [ [ [ Z(3), Z(3) ], [ Z(3), Z(3) ] ], > [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ] ); fail gap> b:= SemiEchelonBasis( v, > [ [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ], > [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ] ); SemiEchelonBasis( , [ [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ], [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ] ) gap> b:= SemiEchelonBasisNC( v, > [ [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ], > [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ] ); SemiEchelonBasis( , [ [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ], [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ] ) gap> c1:= CanonicalBasis( v );; gap> Print( c1, "\n" ); CanonicalBasis( VectorSpace( GF(3^2), [ [ [ Z(3), Z(3) ], [ Z(3), Z(3) ] ], [ [ Z(3), Z(3) ], [ Z(3), 0*Z(3) ] ] ] ) ) gap> c2:= CanonicalBasis( VectorSpace( GF(3), BasisVectors( b ) ) );; gap> Print( c2, "\n" ); CanonicalBasis( VectorSpace( GF(3), [ [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ], [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ] ) ) gap> c1 = c2; true gap> w:= LeftModuleByGenerators( GF(9), > [ [ [ Z(27), Z(3) ], [ Z(3), Z(3) ] ], > [ [ Z(27), Z(3) ], [ Z(3), Z(3) ] ], > [ [ 0*Z(3), Z(3) ], [ Z(3), Z(3) ] ] ] ); gap> Basis( w ); Basis( , ... ) gap> b:= Basis( w, > [ [ [ 0*Z(3), Z(3) ], [ Z(3), Z(3) ] ], > [ [ Z(27), Z(3) ], [ Z(3), Z(3) ] ] ] ); Basis( , [ [ [ 0*Z(3), Z(3) ], [ Z(3), Z(3) ] ], [ [ Z(3^3), Z(3) ], [ Z(3), Z(3) ] ] ] ) gap> IsBasisByNiceBasis( b ); true gap> Coefficients( b, [ [ Z(27), 0*Z(3) ], [ 0*Z(3), 0*Z(3) ] ] ); [ Z(3), Z(3)^0 ] gap> IsZero( Zero( v ) ); true gap> ForAny( b, IsZero ); false gap> ww:= AsVectorSpace( GF(3), w );; gap> Print( ww, "\n" ); VectorSpace( GF(3), [ [ [ Z(3^3), Z(3) ], [ Z(3), Z(3) ] ], [ [ Z(3^3), Z(3) ], [ Z(3), Z(3) ] ], [ [ 0*Z(3), Z(3) ], [ Z(3), Z(3) ] ], [ [ Z(3^6)^119, Z(3^2)^5 ], [ Z(3^2)^5, Z(3^2)^5 ] ], [ [ Z(3^6)^119, Z(3^2)^5 ], [ Z(3^2)^5, Z(3^2)^5 ] ], [ [ 0*Z(3), Z(3^2)^5 ], [ Z(3^2)^5, Z(3^2)^5 ] ] ] ) gap> Dimension( ww ); 4 gap> w = ww; true gap> AsVectorSpace( GF(27), w ); fail gap> u:= GF( 3^6 )^[ 2, 3 ]; ( GF(3^6)^[ 2, 3 ] ) gap> uu:= AsVectorSpace( GF(9), u );; gap> Print( uu, "\n" ); VectorSpace( GF(3^2), [ [ [ Z(3)^0, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), Z(3)^0, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), Z(3)^0 ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3)^0, 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0, 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3)^0 ] ], [ [ Z(3^6), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), Z(3^6), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), Z(3^6) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3^6), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6) ] ], [ [ Z(3^6)^2, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), Z(3^6)^2, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), Z(3^6)^2 ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3^6)^2, 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6)^2, 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6)^2 ] ] ] ) gap> uuu:= AsVectorSpace( GF(27), uu );; gap> Print( uuu, "\n" ); VectorSpace( GF(3^3), [ [ [ Z(3)^0, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), Z(3)^0, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), Z(3)^0 ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3)^0, 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0, 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3)^0 ] ], [ [ Z(3^6), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), Z(3^6), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), Z(3^6) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3^6), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6) ] ], [ [ Z(3^6)^2, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), Z(3^6)^2, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), Z(3^6)^2 ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3^6)^2, 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6)^2, 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6)^2 ] ], [ [ Z(3^2), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), Z(3^2), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), Z(3^2) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3^2), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^2), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^2) ] ], [ [ Z(3^6)^92, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), Z(3^6)^92, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), Z(3^6)^92 ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3^6)^92, 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6)^92, 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6)^92 ] ], [ [ Z(3^6)^93, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), Z(3^6)^93, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), Z(3^6)^93 ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3^6)^93, 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6)^93, 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6)^93 ] ] ] ) gap> uuuu:= AsVectorSpace( GF(3^6), uu );; gap> Print( uuuu, "\n" ); VectorSpace( GF(3^6), [ [ [ Z(3)^0, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), Z(3)^0, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), Z(3)^0 ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3)^0, 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0, 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3)^0 ] ], [ [ Z(3^6), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), Z(3^6), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), Z(3^6) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3^6), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6) ] ], [ [ Z(3^6)^2, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), Z(3^6)^2, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), Z(3^6)^2 ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3^6)^2, 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6)^2, 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6)^2 ] ] ] ) gap> u = uuu; true gap> c:= VectorSpace( GF(9), > [ [ [ Z(3)^0, 0*Z(3) ], [ 0*Z(3), 0*Z(3) ] ], > [ [ 0*Z(3), Z(3)^0 ], [ 0*Z(3), 0*Z(3) ] ] ] ); gap> f:= v + c;; gap> Print( f, "\n" ); VectorSpace( GF(3^2), [ [ [ Z(3), Z(3) ], [ Z(3), Z(3) ] ], [ [ Z(3), Z(3) ], [ Z(3), 0*Z(3) ] ], [ [ Z(3)^0, 0*Z(3) ], [ 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), Z(3)^0 ], [ 0*Z(3), 0*Z(3) ] ] ] ) gap> Intersection( v, c ); gap> Intersection( v, f ) = v; true ############################################################################# ## ## 5. Methods for full matrix spaces ## gap> IsFullMatrixModule( v ); false gap> IsFullMatrixModule( f ); true gap> c:= CanonicalBasis( f ); CanonicalBasis( ( GF(3^2)^[ 2, 2 ] ) ) gap> Print( BasisVectors( c ), "\n" ); [ [ [ Z(3)^0, 0*Z(3) ], [ 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), Z(3)^0 ], [ 0*Z(3), 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3) ], [ Z(3)^0, 0*Z(3) ] ], [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ] ############################################################################# ## ## 7. Methods for mutable bases of Gaussian matrix spaces ## gap> mb:= MutableBasis( Rationals, > [ [ [ 1, 1 ], [ 1, 1 ] ], > [ [ 0, 1 ], [ 1, 1 ] ], > [ [ 1, 1 ], [ 1, 1 ] ] ] ); gap> IsMutableBasisOfGaussianMatrixSpaceRep( mb ); true gap> CloseMutableBasis( mb, [ [ E(4), 0 ], [ 0, 0 ] ] ); gap> IsMutableBasisOfGaussianMatrixSpaceRep( mb ); false gap> BasisVectors( mb ); [ [ [ 1, 1 ], [ 1, 1 ] ], [ [ 0, 1 ], [ 1, 1 ] ], [ [ E(4), 0 ], [ 0, 0 ] ] ] gap> mb:= MutableBasis( Rationals, > [ [ [ 1, 1 ], [ 1, 1 ] ], > [ [ 0, 1 ], [ 1, 1 ] ], > [ [ 1, 1 ], [ 1, 1 ] ] ] ); gap> CloseMutableBasis( mb, [ [ 1, 2 ], [ 3, 4 ] ] ); gap> CloseMutableBasis( mb, [ [ 1, 2 ], [ 3, 5 ] ] ); gap> CloseMutableBasis( mb, [ [ 0, 0 ], [ 0, 7 ] ] ); gap> IsMutableBasisOfGaussianMatrixSpaceRep( mb ); true gap> bv:= BasisVectors( mb );; gap> Print( bv, "\n" ); [ [ [ 1, 1 ], [ 1, 1 ] ], [ [ 0, 1 ], [ 1, 1 ] ], [ [ 0, 0 ], [ 1, 2 ] ], [ [ 0, 0 ], [ 0, 1 ] ] ] gap> ImmutableBasis( mb ); SemiEchelonBasis( , [ [ [ 1, 1 ], [ 1, 1 ] ], [ [ 0, 1 ], [ 1, 1 ] ], [ [ 0, 0 ], [ 1, 2 ] ], [ [ 0, 0 ], [ 0, 1 ] ] ] ) gap> mb:= MutableBasis( Rationals, [], [ [ 0, 0 ], [ 0, 0 ] ] ); gap> CloseMutableBasis( mb, [ [ 1, 2 ], [ 3, 4 ] ] ); gap> CloseMutableBasis( mb, [ [ 1, 2 ], [ 3, 5 ] ] ); gap> CloseMutableBasis( mb, [ [ 0, 0 ], [ 0, 7 ] ] ); gap> IsMutableBasisOfGaussianMatrixSpaceRep( mb ); true gap> BasisVectors( mb ); [ [ [ 1, 2 ], [ 3, 4 ] ], [ [ 0, 0 ], [ 0, 1 ] ] ] gap> ImmutableBasis( mb ); SemiEchelonBasis( , [ [ [ 1, 2 ], [ 3, 4 ] ], [ [ 0, 0 ], [ 0, 1 ] ] ] ) gap> mb:= MutableBasis( Rationals, [], [ [ 0, 0 ], [ 0, 0 ] ] ); gap> CloseMutableBasis( mb, [ [ 1, 0 ], [ 0, 1 ] ] ); gap> CloseMutableBasis( mb, [ [ 0, 1 ], [ 1, 0 ] ] ); gap> IsContainedInSpan( mb, [ [ 1, 1 ], [ 1, 1 ] ] ); true gap> STOP_TEST( "vspcmat.tst", 8400000 ); ############################################################################# ## #E gap-4r6p5/tst/set.tst0000644000175000017500000000304212172557256013305 0ustar billbill############################################################################# ## #W set.tst GAP Library Alexander Hulpke ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## Exclude from testinstall.g: why? ## gap> START_TEST("set.tst"); gap> a:=Set([(1,3,2),(4,5)]);; gap> b:=[(1,2),(5,9,7)];; gap> UniteSet(a,b); gap> a; [ (5,9,7), (4,5), (1,2), (1,3,2) ] gap> HasIsSSortedList(a); true gap> IsSSortedList(a); true gap> c:=Union(a,[(5,3,7),(1,2)]); [ (5,9,7), (4,5), (3,7,5), (1,2), (1,3,2) ] gap> HasIsSSortedList(c) and IsSSortedList(c); true gap> SubtractSet(c,[(1,2),(1,2,3)]); gap> c; [ (5,9,7), (4,5), (3,7,5), (1,3,2) ] gap> HasIsSSortedList(c) and IsSSortedList(c); true gap> AddSet(c,5); gap> c; [ 5, (5,9,7), (4,5), (3,7,5), (1,3,2) ] gap> HasIsSSortedList(c) and IsSSortedList(c); true gap> AddSet(a,(5,6)); #gap> HasIsSSortedList(a) and IsSSortedList(a); #true gap> c:=Union(a,[(1,2),(1,2,3)]); [ (5,6), (5,9,7), (4,5), (1,2), (1,2,3), (1,3,2) ] gap> HasIsSSortedList(c) and IsSSortedList(c); true gap> g:=Group((3,11)(4,7)(6,8)(9,10),(1,3)(2,8,10,12)(4,5,6,7)(9,11));; gap> l:=AsSortedList(g);; gap> HasIsSSortedList(l) and IsSSortedList(l); true gap> c:=Difference(l,[(3,11)( 4, 7)( 6, 8)( 9,10)]);; gap> HasIsSSortedList(c) and IsSSortedList(c); true gap> Length(c); 7919 gap> c:=Difference(l,a);; gap> c=l; true gap> STOP_TEST( "set.tst", 5600000 ); ############################################################################# ## #E gap-4r6p5/tst/grpconst.tst0000644000175000017500000000253512172557256014357 0ustar billbill############################################################################# ## #W grpconst.tst GAP Library Hans Ulrich Besche ## ## #Y Copyright (C) 1999, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## Exclude from testinstall.g: why? ## gap> START_TEST("grpconst.tst"); gap> if LoadPackage( "grpconst", false )=fail then > Print("\n\n", > "*** Since you do not have the `grpconst' package installed, ***\n", > "*** you will get some error messages. They should be ignored. ***\n\n\n"); > fi; gap> ConstructAndTestAllGroups := function( size ) > local grps; > grps := ConstructAllGroups( size ); > if Length( grps ) <> NumberSmallGroups( size ) then > Print( "wrong number of groups of size ", size, "\n" ); > fi; > if Set( List( grps, IdGroup ) ) <> > List( [ 1 .. NumberSmallGroups( size ) ], x -> [ size, x ] ) then > Print( "wrong ids for the groups of size ", size, "\n" ); > fi; > end; function( size ) ... end gap> ConstructAndTestAllGroups( 96 );; gap> ConstructAndTestAllGroups( 648 );; gap> ConstructAndTestAllGroups( 840 );; gap> ConstructAndTestAllGroups( 1560 );; gap> ConstructAndTestAllGroups( 1800 );; gap> UnloadSmallGroupsData(); gap> STOP_TEST( "grpconst.tst", 20754500000*10 ); ############################################################################# ## #E gap-4r6p5/tst/zmodnz.tst0000644000175000017500000001621212172557256014036 0ustar billbill############################################################################# ## #W zmodnz.tst GAP library Thomas Breuer ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## To be listed in testinstall.g ## gap> START_TEST("zmodnz.tst"); # small prime field gap> Fam7:= ElementsFamily( FamilyObj( Integers mod 7 ) );; gap> z1:= ZmodnZObj( Fam7, -3 ); ZmodpZObj( 4, 7 ) gap> z2:= ZmodnZObj( Fam7, 1 ); ZmodpZObj( 1, 7 ) gap> z3:= ZmodnZObj( Fam7, 10 ); ZmodpZObj( 3, 7 ) gap> z1 = z2; z2 = z3; false false gap> z1 < z2; z1 < z3; z2 < z3; z2 < z1; z3 < z1; z3 < z2; false false true true true false gap> z1 = Zero( GF(7) ); z2 = Z(7); Zero( GF(7) ) = z1; Z(7) = z2; false false false false gap> z2 < Z(7); Z(7) < z2; true false gap> Print(SSortedList( [ Z(7)^3, Z(7)^2, z1, z2, z3, Z(7)^5 ] ),"\n"); [ ZmodpZObj( 1, 7 ), ZmodpZObj( 3, 7 ), Z(7)^2, Z(7)^3, ZmodpZObj( 4, 7 ), Z(7)^5 ] gap> z1 + z2; z1 + z3; z2 + z3; z1 + 1; 2 + z2; z1 + Z(7); Z(7)^2 + z2; ZmodpZObj( 5, 7 ) ZmodpZObj( 0, 7 ) ZmodpZObj( 4, 7 ) ZmodpZObj( 5, 7 ) ZmodpZObj( 3, 7 ) 0*Z(7) Z(7) gap> z1 - z2; z1 - z3; z2 - z3; z1 - 1; 2 - z2; z1 - Z(7); Z(7)^2 - z2; ZmodpZObj( 3, 7 ) ZmodpZObj( 1, 7 ) ZmodpZObj( 5, 7 ) ZmodpZObj( 3, 7 ) ZmodpZObj( 1, 7 ) Z(7)^0 Z(7)^0 gap> z1 * z2; z1 * z3; z2 * z3; z1 * 1; 2 * z2; z1 * Z(7); Z(7)^2 * z2; ZmodpZObj( 4, 7 ) ZmodpZObj( 5, 7 ) ZmodpZObj( 3, 7 ) ZmodpZObj( 4, 7 ) ZmodpZObj( 2, 7 ) Z(7)^5 Z(7)^2 gap> z1 / z2; z1 / z3; z2 / z3; z1 / 1; 2 / z2; z1 / Z(7); Z(7)^2 / z2; ZmodpZObj( 4, 7 ) ZmodpZObj( 6, 7 ) ZmodpZObj( 5, 7 ) ZmodpZObj( 4, 7 ) ZmodpZObj( 2, 7 ) Z(7)^3 Z(7)^2 gap> z2^3; z2^(-2); z2^0; ZmodpZObj( 1, 7 ) ZmodpZObj( 1, 7 ) ZmodpZObj( 1, 7 ) gap> DegreeFFE( z1 ); DegreeFFE( z2 ); DegreeFFE( z3 ); 1 1 1 gap> Int( z1 ); Int( z2 ); Int( z3 ); Int( z2 ) = Int( Z(7)^6 ); 4 1 3 true gap> SquareRoots( GF(7), z1 ); [ ZmodpZObj( 2, 7 ), ZmodpZObj( 5, 7 ) ] gap> SquareRoots( GF(7), z2 ); [ ZmodpZObj( 1, 7 ), ZmodpZObj( 6, 7 ) ] gap> SquareRoots( GF(7), z3 ); [ ] # large prime field gap> p:= NextPrimeInt( MAXSIZE_GF_INTERNAL ); 65537 gap> Famp:= ElementsFamily( FamilyObj( Integers mod p ) );; gap> z1:= ZmodnZObj( Famp, -3 ); ZmodpZObj( 65534, 65537 ) gap> z2:= ZmodnZObj( Famp, 1 ); ZmodpZObj( 1, 65537 ) gap> z3:= ZmodnZObj( Famp, 10 ); ZmodpZObj( 10, 65537 ) gap> z1 = z2; z2 = z3; false false gap> z1 < z2; z1 < z3; z2 < z3; z2 < z1; z3 < z1; z3 < z2; false false true true true false gap> z1 = Zero( GF(p) ); Zero( GF(p) ) = z1; false false gap> z1 + z2; z1 + z3; z2 + z3; z1 + 1; 2 + z2; ZmodpZObj( 65535, 65537 ) ZmodpZObj( 7, 65537 ) ZmodpZObj( 11, 65537 ) ZmodpZObj( 65535, 65537 ) ZmodpZObj( 3, 65537 ) gap> z1 - z2; z1 - z3; z2 - z3; z1 - 1; 2 - z2; ZmodpZObj( 65533, 65537 ) ZmodpZObj( 65524, 65537 ) ZmodpZObj( 65528, 65537 ) ZmodpZObj( 65533, 65537 ) ZmodpZObj( 1, 65537 ) gap> z1 * z2; z1 * z3; z2 * z3; z1 * 1; 2 * z2; ZmodpZObj( 65534, 65537 ) ZmodpZObj( 65507, 65537 ) ZmodpZObj( 10, 65537 ) ZmodpZObj( 65534, 65537 ) ZmodpZObj( 2, 65537 ) gap> z1 / z2; z1 / z3; z2 / z3; z1 / 1; 2 / z2; ZmodpZObj( 65534, 65537 ) ZmodpZObj( 58983, 65537 ) ZmodpZObj( 45876, 65537 ) ZmodpZObj( 65534, 65537 ) ZmodpZObj( 2, 65537 ) gap> z2^3; z2^(-2); z2^0; ZmodpZObj( 1, 65537 ) ZmodpZObj( 1, 65537 ) ZmodpZObj( 1, 65537 ) gap> DegreeFFE( z1 ); DegreeFFE( z2 ); DegreeFFE( z3 ); 1 1 1 gap> Int( z1 ); Int( z2 ); Int( z3 ); 65534 1 10 gap> SquareRoots( GF(p), z1 ); [ ] gap> SquareRoots( GF(p), z2 ); [ ZmodpZObj( 1, 65537 ), ZmodpZObj( 65536, 65537 ) ] gap> SquareRoots( GF(p), z3 ); [ ] # ring that is not a field gap> Fam8:= ElementsFamily( FamilyObj( Integers mod 8 ) );; gap> z1:= ObjByExtRep( Fam8, -3 ); ExtRepOfObj( z1 ); ZmodnZObj( 5, 8 ) 5 gap> z2:= ObjByExtRep( Fam8, 1 ); ExtRepOfObj( z2 ); ZmodnZObj( 1, 8 ) 1 gap> z3:= ObjByExtRep( Fam8, 3 ); ExtRepOfObj( z3 ); ZmodnZObj( 3, 8 ) 3 gap> z1 = z2; z2 = z3; false false gap> z1 < z2; z1 < z3; z2 < z3; z2 < z1; z3 < z1; z3 < z2; false false true true true false gap> z1 + z2; z1 + z3; z2 + z3; z1 + 1; 2 + z2; ZmodnZObj( 6, 8 ) ZmodnZObj( 0, 8 ) ZmodnZObj( 4, 8 ) ZmodnZObj( 6, 8 ) ZmodnZObj( 3, 8 ) gap> z1 - z2; z1 - z3; z2 - z3; z1 - 1; 2 - z2; ZmodnZObj( 4, 8 ) ZmodnZObj( 2, 8 ) ZmodnZObj( 6, 8 ) ZmodnZObj( 4, 8 ) ZmodnZObj( 1, 8 ) gap> z1 * z2; z1 * z3; z2 * z3; z1 * 1; 2 * z2; ZmodnZObj( 5, 8 ) ZmodnZObj( 7, 8 ) ZmodnZObj( 3, 8 ) ZmodnZObj( 5, 8 ) ZmodnZObj( 2, 8 ) gap> z1 / z2; z1 / z3; z2 / z3; z1 / 1; 2 / z2; ZmodnZObj( 5, 8 ) ZmodnZObj( 7, 8 ) ZmodnZObj( 3, 8 ) ZmodnZObj( 5, 8 ) ZmodnZObj( 2, 8 ) gap> z2^3; z2^(-2); z2^0; ZmodnZObj( 1, 8 ) ZmodnZObj( 1, 8 ) ZmodnZObj( 1, 8 ) gap> Int( z1 ); Int( z2 ); Int( z3 ); 5 1 3 # work with domains gap> rings:= List( [ 2, 3, 4, 6, 8 ], i -> Integers mod i ); [ GF(2), GF(3), (Integers mod 4), (Integers mod 6), (Integers mod 8) ] gap> Print(List( rings, AsList ),"\n"); [ [ 0*Z(2), Z(2)^0 ], [ 0*Z(3), Z(3)^0, Z(3) ], [ ZmodnZObj( 0, 4 ), ZmodnZObj( 1, 4 ), ZmodnZObj( 2, 4 ), ZmodnZObj( 3, 4 ) ], [ ZmodnZObj( 0, 6 ), ZmodnZObj( 1, 6 ), ZmodnZObj( 2, 6 ), ZmodnZObj( 3, 6 ), ZmodnZObj( 4, 6 ), ZmodnZObj( 5, 6 ) ], [ ZmodnZObj( 0, 8 ), ZmodnZObj( 1, 8 ), ZmodnZObj( 2, 8 ), ZmodnZObj( 3, 8 ), ZmodnZObj( 4, 8 ), ZmodnZObj( 5, 8 ), ZmodnZObj( 6, 8 ), ZmodnZObj( 7, 8 ) ] ] gap> Print(List( rings, AsSSortedList ),"\n"); [ [ 0*Z(2), Z(2)^0 ], [ 0*Z(3), Z(3)^0, Z(3) ], [ ZmodnZObj( 0, 4 ), ZmodnZObj( 1, 4 ), ZmodnZObj( 2, 4 ), ZmodnZObj( 3, 4 ) ], [ ZmodnZObj( 0, 6 ), ZmodnZObj( 1, 6 ), ZmodnZObj( 2, 6 ), ZmodnZObj( 3, 6 ), ZmodnZObj( 4, 6 ), ZmodnZObj( 5, 6 ) ], [ ZmodnZObj( 0, 8 ), ZmodnZObj( 1, 8 ), ZmodnZObj( 2, 8 ), ZmodnZObj( 3, 8 ), ZmodnZObj( 4, 8 ), ZmodnZObj( 5, 8 ), ZmodnZObj( 6, 8 ), ZmodnZObj( 7, 8 ) ] ] gap> List( [ 1 .. Length( rings ) ], i -> Random( rings[i] ) in rings[i] ); [ true, true, true, true, true ] gap> List( rings, Size ); [ 2, 3, 4, 6, 8 ] gap> Print(List( rings, Units ),"\n"); [ Group( [ Z(2)^0 ] ), Group( [ Z(3) ] ), Group( [ ZmodnZObj( 3, 4 ) ] ), Group( [ ZmodnZObj( 5, 6 ) ] ), Group( [ ZmodnZObj( 7, 8 ), ZmodnZObj( 5, 8 ) ] ) ] gap> enum:= Enumerator( Integers mod 9 ); gap> len:= Length( enum ); 9 gap> l:= [];; gap> for i in [ 1 .. len ] do > l[i]:= enum[i]; > od; gap> Print(l,"\n"); [ ZmodnZObj( 0, 9 ), ZmodnZObj( 1, 9 ), ZmodnZObj( 2, 9 ), ZmodnZObj( 3, 9 ), ZmodnZObj( 4, 9 ), ZmodnZObj( 5, 9 ), ZmodnZObj( 6, 9 ), ZmodnZObj( 7, 9 ), ZmodnZObj( 8, 9 ) ] gap> ForAll( [ 1 .. len ], i -> i = Position( enum, enum[i], 0 ) ); true # arithmetic operations with matrices over residue class rings # (From time to time, solved problems come up again because clever methods # for matrices assume too much about the domains of their entries ...) gap> R:= Integers mod 6; (Integers mod 6) gap> A:= MatrixAlgebra( R, 2 );; gap> one:= One( A ); [ [ ZmodnZObj( 1, 6 ), ZmodnZObj( 0, 6 ) ], [ ZmodnZObj( 0, 6 ), ZmodnZObj( 1, 6 ) ] ] gap> G:= GroupWithGenerators( [ one ] );; gap> One( G ); [ [ ZmodnZObj( 1, 6 ), ZmodnZObj( 0, 6 ) ], [ ZmodnZObj( 0, 6 ), ZmodnZObj( 1, 6 ) ] ] gap> STOP_TEST( "zmodnz.tst", 2300000 ); ############################################################################# ## #E gap-4r6p5/tst/grpperm.tst0000644000175000017500000000676212172557256014202 0ustar billbill############################################################################# ## #W grpperm.tst GAP tests Alexander Hulpke ## ## #Y Copyright (C) 1997 ## ## Exclude from testinstall.g: why? ## gap> START_TEST("grpperm.tst"); gap> G1 := TrivialSubgroup (Group ((1,2)));; gap> G2 := SymmetricGroup ([]);; gap> G3:=Intersection (G1, G2);; gap> Size(G3); 1 gap> Pcgs(G3);; gap> g:=Group((1,2,9)(3,4,5)(6,7,8), (1,4,7)(2,5,8)(3,6,9));; gap> h:=Group((1,2,9)(3,4,5)(6,7,8));; gap> (g g:=Group( (1,2,3), (2,3)(4,5) );; gap> IsSolvable(g); true gap> RepresentativeAction(g,(2,5,3), (2,3,4)); (2,3)(4,5) gap> g:=Group( ( 9,11,10), ( 2, 3, 4), (14,17,15), (13,16)(15,17), > ( 8,12)(10,11), ( 5, 7)(10,11), (15,16,17), (10,11,12) );; gap> Sum(ConjugacyClasses(g),Size)=Size(g); true gap> g:= Group( (4,8,12),(2,10)(4,8),(1,10)(2,5)(3,12)(4,7)(6,9)(8,11), > (1,7)(3,9)(5,11)(6,10) );; gap> e:=ElementaryAbelianSeriesLargeSteps(DerivedSeries(g));; gap> List(e,Size); [ 2592, 324, 162, 81, 1 ] gap> ForAll([1..Length(e)-1],i->HasElementaryAbelianFactorGroup(e[i],e[i+1])); true gap> group:= > Subgroup( Group( ( 1, 2)( 3, 5)( 4, 7)( 6, 10)( 8, 12)( 9, 13) > ( 14, 19)( 15, 20)( 16, 22)( 17, 23)( 18, 25)( 24, 31)( 26, 33)( 27, 34) > ( 28, 36)( 29, 38)( 30, 39)( 35, 45)( 37, 46)( 41, 48)( 42, 50)( 43, 51) > ( 44, 53)( 47, 57)( 49, 59)( 52, 62)( 54, 64)( 55, 65)( 56, 67)( 58, 70) > ( 60, 73)( 61, 74)( 63, 77)( 66, 80)( 68, 82)( 69, 75)( 71, 84)( 72, 85) > ( 76, 88)( 78, 90)( 79, 91)( 81, 94)( 83, 97)( 86,100)( 87,101)( 89,102) > ( 92,104)( 93,105)( 95,103)( 96,106)( 99,107)(108,114)(109,115)(110,112) > (113,117)(118,119), ( 1, 3, 6)( 2, 4, 8)( 5, 9, 14)( 7, 11, 16) > ( 10, 15, 21)( 12, 17, 24)( 13, 18, 26)( 19, 27, 35)( 20, 28, 37)( 22, 29, 36) > ( 23, 30, 40)( 25, 32, 42)( 31, 41, 49)( 33, 43, 52)( 34, 44, 54)( 38, 39, 47) > ( 45, 55, 66)( 46, 56, 68)( 48, 58, 71)( 50, 60, 65)( 51, 61, 75)( 53, 63, 78) > ( 57, 69, 73)( 59, 72, 86)( 62, 76, 89)( 64, 79, 92)( 67, 81, 95)( 70, 83, 98) > ( 74, 87, 77)( 80, 93, 88)( 82, 96, 97)( 84, 99,108)( 85, 90,103)( 91,101,110) > ( 94,100,109)(102,111,104)(105,112,116)(106,113,118)(114,115,117) ), > [ ( 1, 6)( 2, 25)( 4, 27, 70, 98, 35, 42)( 5, 44)( 7, 11)( 8, 32, 19) > ( 9, 50, 33,111, 24, 34)( 12,113, 40, 65, 14, 54)( 13, 78)( 15, 21) > ( 17,104, 52, 60, 23,106)( 18, 41, 88, 93, 49, 63)( 20,109)( 22,107, 29) > ( 26, 53, 31)( 28, 86, 76, 62, 59,100)( 30,118)( 37, 94, 72) > ( 38,110, 99,114, 90, 95)( 39, 87, 92, 71, 73,101)( 43,102) > ( 45, 85,115, 46, 58, 64)( 47, 67, 84, 91, 57, 74)( 48, 56, 66, 79, 77, 69 > )( 51, 75)( 55, 68,117,108, 81,103)( 96, 97)(112,116), > ( 1, 8, 65, 89, 94, 10, 37, 72, 43, 32, 6, 14, 19, 83, 54) > ( 2, 9, 78, 86, 67, 63, 52, 76, 93, 55, 44, 49, 42, 24, 82,118, 4, 13, > 17, 92, 88, 62,104, 18, 85,109, 41, 34, 35, 16)( 3, 21, 15) > ( 5, 45, 95,117, 59, 29, 47, 74,110, 50, 30, 69, 64, 91, 22, 20,103, 99, > 46, 60, 26, 87, 39, 90, 27, 25, 66, 81, 73, 53)( 7, 36, 84,106, 38, 51, > 33, 79, 98, 96, 56,100, 68, 31,116,112, 80, 71, 28,114, 97, 70, 48,111, > 75, 77, 23,115,107, 11)( 12,102, 40,119,113)( 57,108,105,101, 58, 61) > ] );; gap> perf:=RepresentativesPerfectSubgroups(group);; gap> List(perf,Size); [ 1, 60, 960, 30720 ] # that's all, folks gap> STOP_TEST( "grpperm.tst", 490500000 ); ############################################################################# ## #E gap-4r6p5/tst/longnumber.tst0000644000175000017500000002505312172557256014670 0ustar billbill############################################################################# ## #A longnumber.tst GAP 4.0 library Steve Linton ## ## #Y Copyright 2011, The GAP Group ## to be listed in testinstall.g ## these tests deal with various cases in long integer parsing where the number has ## to be read in one two or three blocks, which may sometimes be exactly filled or ## sometimes end with a partial block. ## ## To be extended with similar tests for all the cases of float and long-float ## parsing when I have a reliable way of testing them. ## gap> START_TEST("longnumber.tst"); # integers gap> x := > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999;; gap> x = 10^1000-1; true gap> x := > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 999999999999999999999999999999999999999999999999999999999999999999999999999;; gap> x = 10^1023-1; true gap> x := > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999;; gap> x = 10^1024-1; true gap> x := > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999;; gap> x = 10^2000-1; true gap> x := > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 99999999999999999999999999999999999999999999999999999999999999999999999;; gap> x = 10^2046-1; true gap> x := > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 9999999999999999999999999999999999999999999999999999999999999999999999999999999\ > 999999999999999999999999999999999999999999999999999999999999999999999999;; gap> x = 10^2047-1; true # Basic float formats gap> 1.; 1. gap> 0.; 0. gap> .1; 0.1 gap> 0.1; 0.1 gap> 1111111111111111111111111111111111111.1; 1.11111e+36 gap> 1.11111111111111111111111111111111111111; 1.11111 gap> Unbind(x); gap> STOP_TEST( "longnumber.tst", 100000 ); ############################################################################# ## #E gap-4r6p5/tst/vspcmali.tst0000644000175000017500000004537012172557256014342 0ustar billbill############################################################################# ## #W vspcmali.tst GAP library Thomas Breuer ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file ontains tests for vector spaces of Lie matrices. ## ## (The test files 'vspcrow.tst' and 'vspcmat.tst' should contain the same ## tests.) ## ## Exclude from testinstall.g: why? ## gap> START_TEST("vspcmali.tst"); ############################################################################# ## ## 1. Construct Gaussian and non-Gaussian Lie matrix spaces ## gap> z:= LeftModuleByGenerators( GF(3), [], LieObject( [ [ 0*Z(9) ] ] ) ); gap> IsGaussianMatrixSpace( z ); true gap> IsNonGaussianMatrixSpace( z ); false gap> v:= LeftModuleByGenerators( GF(9), > [ LieObject( [ [ Z(3), Z(3) ], [ Z(3), Z(3) ] ] ) ] ); gap> IsGaussianMatrixSpace( v ); true gap> IsNonGaussianMatrixSpace( v ); false gap> v = LeftModuleByGenerators( GF(9), > [ LieObject( [ [ Z(3), Z(3) ], [ Z(3), Z(3) ] ] ) ], Zero( v ) ); true gap> w:= LeftModuleByGenerators( GF(9), > [ LieObject( [ [ Z(27), Z(3) ], [ Z(3), Z(3) ] ] ) ] ); gap> IsGaussianMatrixSpace( w ); false gap> IsNonGaussianMatrixSpace( w ); true gap> w = LeftModuleByGenerators( GF(9), > [ LieObject( [ [ Z(27), Z(3) ], [ Z(3), Z(3) ] ] ) ], Zero( w ) ); true ############################################################################# ## ## 2. Methods for bases of non-Gaussian matrix spaces ## gap> Dimension( w ); 1 gap> n:= NiceVector( w, LieObject( [ [ Z(27), Z(3) ], [ Z(3), Z(3) ] ] ) ); [ Z(3^3), Z(3), Z(3), Z(3) ] gap> UglyVector( w, n ) = [ [ Z(27), Z(3) ], [ Z(3), Z(3) ] ]; false gap> UglyVector( w, n ) = LieObject( [ [ Z(27), Z(3) ], [ Z(3), Z(3) ] ] ); true ############################################################################# ## ## 3. Methods for semi-echelonized bases of Gaussian matrix spaces ## gap> v:= LeftModuleByGenerators( GF(9), > [ LieObject( [ [ Z(3), Z(3) ], [ Z(3), Z(3) ] ] ), > LieObject( [ [ Z(3), Z(3) ], [ Z(3), 0*Z(3) ] ] ) ] ); gap> b:= SemiEchelonBasis( v ); SemiEchelonBasis( , ... ) gap> lc:= LinearCombination( b, [ Z(3)^0, Z(3) ] ); LieObject( [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, 0*Z(3) ] ] ) gap> Coefficients( b, lc ); [ Z(3)^0, Z(3) ] gap> SiftedVector( b, LieObject( [ [ Z(3), Z(3) ], [ 0*Z(3), 0*Z(3) ] ] ) ); LieObject( [ [ 0*Z(3), 0*Z(3) ], [ Z(3)^0, 0*Z(3) ] ] ) gap> SiftedVector( b, LieObject( [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ] ] ) ); LieObject( [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3) ] ] ) gap> b:= Basis( v, [ LieObject( [ [ Z(3), Z(3) ], [ Z(3), Z(3) ] ] ) ] ); fail gap> b:= Basis( v, [ LieObject( [ [ Z(3), Z(3) ], [ Z(3), Z(3) ] ] ), > LieObject( [ [ Z(3), Z(3) ], [ Z(3), 0*Z(3) ] ] ) ] ); Basis( , [ LieObject( [ [ Z(3), Z(3) ], [ Z(3), Z(3) ] ] ), LieObject( [ [ Z(3), Z(3) ], [ Z(3), 0*Z(3) ] ] ) ] ) gap> IsSemiEchelonized( b ); false gap> b:= Basis( v, [ LieObject( [ [ Z(3), Z(3) ], [ Z(3), Z(3) ] ] ), > LieObject( [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ] ] ) ] ); Basis( , [ LieObject( [ [ Z(3), Z(3) ], [ Z(3), Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3) ] ] ) ] ) gap> IsSemiEchelonized( b ); false gap> b:= Basis( v, > [ LieObject( [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ] ), > LieObject( [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, 0*Z(3) ] ] ) ] ); Basis( , [ LieObject( [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ] ), LieObject( [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, 0*Z(3) ] ] ) ] ) gap> IsSemiEchelonized( b ); false gap> b:= Basis( v, > [ LieObject( [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ] ), > LieObject( [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ) ] ); SemiEchelonBasis( , [ LieObject( [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ) ] ) gap> IsSemiEchelonized( b ); true ############################################################################# ## ## 4. Methods for Lie matrix spaces ## gap> [ [] ] in w; false gap> Zero( w ) in w; true gap> [ [ 0, 0 ], [ 0, 1 ] ] in w; false gap> Z(3) * [ [ 0, 0 ], [ 0, 1 ], [ 0, 0 ] ] in w; false gap> [ [ Z(27), Z(3) ], [ Z(3), Z(3) ] ] in w; false gap> LieObject( [ [ 0, 0 ], [ 0, 1 ] ] ) in w; false gap> LieObject( Z(3) * [ [ 0, 0 ], [ 0, 1 ], [ 0, 0 ] ] ) in w; false gap> LieObject( [ [ Z(27), Z(3) ], [ Z(3), Z(3) ] ] ) in w; true gap> [ [] ] in v; false gap> Zero( v ) in v; true gap> [ [ 0, 0 ], [ 0, 1 ] ] in v; false gap> Z(3) * [ [ 0, 0 ], [ 0, 1 ], [ 0, 0 ] ] in v; false gap> Z(3) * [ [ 0, 0 ], [ 0, 1 ] ] in v; false gap> LieObject( [ [ 0, 0 ], [ 0, 1 ] ] ) in v; false gap> LieObject( Z(3) * [ [ 0, 0 ], [ 0, 1 ], [ 0, 0 ] ] ) in v; false gap> LieObject( Z(3) * [ [ 0, 0 ], [ 0, 1 ] ] ) in v; true gap> BasisNC( v, > [ LieObject( [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ] ), > LieObject( [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ) ] ); SemiEchelonBasis( , [ LieObject( [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ) ] ) gap> Basis( v ); SemiEchelonBasis( , [ LieObject( [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ) ] ) gap> SemiEchelonBasis( v ); SemiEchelonBasis( , [ LieObject( [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ) ] ) gap> b:= SemiEchelonBasis( v, > [ LieObject( [ [ Z(3), Z(3) ], [ Z(3), Z(3) ] ] ), > LieObject( [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ) ] ); fail gap> b:= SemiEchelonBasis( v, > [ LieObject( [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ] ), > LieObject( [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ) ] ); SemiEchelonBasis( , [ LieObject( [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ) ] ) gap> b:= SemiEchelonBasisNC( v, > [ LieObject( [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ] ), > LieObject( [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ) ] ); SemiEchelonBasis( , [ LieObject( [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ) ] ) gap> c1:= CanonicalBasis( v );; gap> Print( c1, "\n" ); CanonicalBasis( VectorSpace( GF(3^2), [ LieObject( [ [ Z(3), Z(3) ], [ Z(3), Z(3) ] ] ), LieObject( [ [ Z(3), Z(3) ], [ Z(3), 0*Z(3) ] ] ) ] ) ) gap> c2:= CanonicalBasis( VectorSpace( GF(3), BasisVectors( b ) ) );; gap> Print( c2, "\n" ); CanonicalBasis( VectorSpace( GF(3), [ LieObject( [ [ Z(3)^0, Z(3)^0 ], [ Z(3)^0, Z(3)^0 ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ) ] ) ) gap> c1 = c2; true gap> w:= LeftModuleByGenerators( GF(9), > [ LieObject( [ [ Z(27), Z(3) ], [ Z(3), Z(3) ] ] ), > LieObject( [ [ Z(27), Z(3) ], [ Z(3), Z(3) ] ] ), > LieObject( [ [ 0*Z(3), Z(3) ], [ Z(3), Z(3) ] ] ) ] ); gap> Basis( w ); Basis( , ... ) gap> b:= Basis( w, > [ LieObject( [ [ 0*Z(3), Z(3) ], [ Z(3), Z(3) ] ] ), > LieObject( [ [ Z(27), Z(3) ], [ Z(3), Z(3) ] ] ) ] );; gap> Print( b, "\n" ); Basis( VectorSpace( GF(3^2), [ LieObject( [ [ Z(3^3), Z(3) ], [ Z(3), Z(3) ] ] ), LieObject( [ [ Z(3^3), Z(3) ], [ Z(3), Z(3) ] ] ), LieObject( [ [ 0*Z(3), Z(3) ], [ Z(3), Z(3) ] ] ) ] ), [ LieObject( [ [ 0*Z(3), Z(3) ], [ Z(3), Z(3) ] ] ), LieObject( [ [ Z(3^3), Z(3) ], [ Z(3), Z(3) ] ] ) ] ) gap> IsBasisByNiceBasis( b ); true gap> Coefficients( b, LieObject( [ [ Z(27), 0*Z(3) ], [ 0*Z(3), 0*Z(3) ] ] ) ); [ Z(3), Z(3)^0 ] gap> IsZero( Zero( v ) ); true gap> ForAny( b, IsZero ); false gap> ww:= AsVectorSpace( GF(3), w );; gap> Print( ww, "\n" ); VectorSpace( GF(3), [ LieObject( [ [ Z(3^3), Z(3) ], [ Z(3), Z(3) ] ] ), LieObject( [ [ Z(3^3), Z(3) ], [ Z(3), Z(3) ] ] ), LieObject( [ [ 0*Z(3), Z(3) ], [ Z(3), Z(3) ] ] ), LieObject( [ [ Z(3^6)^119, Z(3^2)^5 ], [ Z(3^2)^5, Z(3^2)^5 ] ] ), LieObject( [ [ Z(3^6)^119, Z(3^2)^5 ], [ Z(3^2)^5, Z(3^2)^5 ] ] ), LieObject( [ [ 0*Z(3), Z(3^2)^5 ], [ Z(3^2)^5, Z(3^2)^5 ] ] ) ] ) gap> Dimension( ww ); 4 gap> w = ww; true gap> AsVectorSpace( GF(27), w ); fail gap> u:= GF( 3^6 )^[ 2, 3 ]; ( GF(3^6)^[ 2, 3 ] ) gap> u:= LeftModuleByGenerators( GF(3^6), > List( GeneratorsOfLeftModule( u ), LieObject ) );; gap> Print( u, "\n" ); VectorSpace( GF(3^6), [ LieObject( [ [ Z(3)^0, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), Z(3)^0, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), Z(3)^0 ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3)^0, 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0, 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3)^0 ] ] ) ] ) gap> IsFullMatrixModule( u ); true gap> u; gap> uu:= AsVectorSpace( GF(9), u );; gap> Print( uu, "\n" ); VectorSpace( GF(3^2), [ LieObject( [ [ Z(3)^0, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), Z(3)^0, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), Z(3)^0 ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3)^0, 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0, 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3)^0 ] ] ), LieObject( [ [ Z(3^6), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), Z(3^6), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), Z(3^6) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3^6), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6) ] ] ), LieObject( [ [ Z(3^6)^2, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), Z(3^6)^2, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), Z(3^6)^2 ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3^6)^2, 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6)^2, 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6)^2 ] ] ) ] ) gap> uuu:= AsVectorSpace( GF(27), uu );; gap> Print( uuu, "\n" ); VectorSpace( GF(3^3), [ LieObject( [ [ Z(3)^0, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), Z(3)^0, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), Z(3)^0 ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3)^0, 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0, 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3)^0 ] ] ), LieObject( [ [ Z(3^6), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), Z(3^6), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), Z(3^6) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3^6), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6) ] ] ), LieObject( [ [ Z(3^6)^2, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), Z(3^6)^2, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), Z(3^6)^2 ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3^6)^2, 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6)^2, 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6)^2 ] ] ), LieObject( [ [ Z(3^2), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), Z(3^2), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), Z(3^2) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3^2), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^2), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^2) ] ] ), LieObject( [ [ Z(3^6)^92, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), Z(3^6)^92, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), Z(3^6)^92 ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3^6)^92, 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6)^92, 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6)^92 ] ] ), LieObject( [ [ Z(3^6)^93, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), Z(3^6)^93, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), Z(3^6)^93 ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3^6)^93, 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6)^93, 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6)^93 ] ] ) ] ) gap> uuuu:= AsVectorSpace( GF(3^6), uu );; gap> Print( uuuu, "\n" ); VectorSpace( GF(3^6), [ LieObject( [ [ Z(3)^0, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), Z(3)^0, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), Z(3)^0 ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3)^0, 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0, 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3)^0 ] ] ), LieObject( [ [ Z(3^6), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), Z(3^6), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), Z(3^6) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3^6), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6) ] ] ), LieObject( [ [ Z(3^6)^2, 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), Z(3^6)^2, 0*Z(3) ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), Z(3^6)^2 ], [ 0*Z(3), 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ Z(3^6)^2, 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3^6)^2, 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3), 0*Z(3) ], [ 0*Z(3), 0*Z(3), Z(3^6)^2 ] ] ) ] ) gap> u = uuu; true gap> c:= VectorSpace( GF(9), > [ LieObject( [ [ Z(3)^0, 0*Z(3) ], [ 0*Z(3), 0*Z(3) ] ] ), > LieObject( [ [ 0*Z(3), Z(3)^0 ], [ 0*Z(3), 0*Z(3) ] ] ) ] ); gap> f:= v + c;; gap> Print( f, "\n" ); VectorSpace( GF(3^2), [ LieObject( [ [ Z(3), Z(3) ], [ Z(3), Z(3) ] ] ), LieObject( [ [ Z(3), Z(3) ], [ Z(3), 0*Z(3) ] ] ), LieObject( [ [ Z(3)^0, 0*Z(3) ], [ 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), Z(3)^0 ], [ 0*Z(3), 0*Z(3) ] ] ) ] ) gap> Intersection( v, c ); gap> Intersection( v, f ) = v; true ############################################################################# ## ## 5. Methods for full matrix spaces ## gap> IsFullMatrixModule( v ); false gap> IsFullMatrixModule( f ); true gap> c:= CanonicalBasis( f ); CanonicalBasis( ) gap> Print( BasisVectors( c ), "\n" ); [ LieObject( [ [ Z(3)^0, 0*Z(3) ], [ 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), Z(3)^0 ], [ 0*Z(3), 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3) ], [ Z(3)^0, 0*Z(3) ] ] ), LieObject( [ [ 0*Z(3), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ) ] ############################################################################# ## ## 7. Methods for mutable bases of Gaussian matrix spaces ## gap> mb:= MutableBasis( Rationals, > [ LieObject( [ [ 1, 1 ], [ 1, 1 ] ] ), > LieObject( [ [ 0, 1 ], [ 1, 1 ] ] ), > LieObject( [ [ 1, 1 ], [ 1, 1 ] ] ) ] ); gap> IsMutableBasisOfGaussianMatrixSpaceRep( mb ); true gap> CloseMutableBasis( mb, LieObject( [ [ E(4), 0 ], [ 0, 0 ] ] ) ); gap> IsMutableBasisOfGaussianMatrixSpaceRep( mb ); false gap> Print( BasisVectors( mb ), "\n" ); [ LieObject( [ [ 1, 1 ], [ 1, 1 ] ] ), LieObject( [ [ 0, 1 ], [ 1, 1 ] ] ), LieObject( [ [ E(4), 0 ], [ 0, 0 ] ] ) ] gap> mb:= MutableBasis( Rationals, > [ LieObject( [ [ 1, 1 ], [ 1, 1 ] ] ), > LieObject( [ [ 0, 1 ], [ 1, 1 ] ] ), > LieObject( [ [ 1, 1 ], [ 1, 1 ] ] ) ] ); gap> CloseMutableBasis( mb, LieObject( [ [ 1, 2 ], [ 3, 4 ] ] ) ); gap> CloseMutableBasis( mb, LieObject( [ [ 1, 2 ], [ 3, 5 ] ] ) ); gap> CloseMutableBasis( mb, LieObject( [ [ 0, 0 ], [ 0, 7 ] ] ) ); gap> IsMutableBasisOfGaussianMatrixSpaceRep( mb ); true gap> bv:= BasisVectors( mb );; gap> Print( bv, "\n" ); [ LieObject( [ [ 1, 1 ], [ 1, 1 ] ] ), LieObject( [ [ 0, 1 ], [ 1, 1 ] ] ), LieObject( [ [ 0, 0 ], [ 1, 2 ] ] ), LieObject( [ [ 0, 0 ], [ 0, 1 ] ] ) ] gap> ImmutableBasis( mb ); SemiEchelonBasis( , [ LieObject( [ [ 1, 1 ], [ 1, 1 ] ] ), LieObject( [ [ 0, 1 ], [ 1, 1 ] ] ), LieObject( [ [ 0, 0 ], [ 1, 2 ] ] ), LieObject( [ [ 0, 0 ], [ 0, 1 ] ] ) ] ) gap> mb:= MutableBasis( Rationals, [], > LieObject( [ [ 0, 0 ], [ 0, 0 ] ] ) ); gap> CloseMutableBasis( mb, LieObject( [ [ 1, 2 ], [ 3, 4 ] ] ) ); gap> CloseMutableBasis( mb, LieObject( [ [ 1, 2 ], [ 3, 5 ] ] ) ); gap> CloseMutableBasis( mb, LieObject( [ [ 0, 0 ], [ 0, 7 ] ] ) ); gap> IsMutableBasisOfGaussianMatrixSpaceRep( mb ); true gap> BasisVectors( mb ); [ LieObject( [ [ 1, 2 ], [ 3, 4 ] ] ), LieObject( [ [ 0, 0 ], [ 0, 1 ] ] ) ] gap> ImmutableBasis( mb ); SemiEchelonBasis( , [ LieObject( [ [ 1, 2 ], [ 3, 4 ] ] ), LieObject( [ [ 0, 0 ], [ 0, 1 ] ] ) ] ) gap> STOP_TEST( "vspcmali.tst", 11100000 ); ############################################################################# ## #E gap-4r6p5/tst/alghom.tst0000644000175000017500000000461112172557256013764 0ustar billbill############################################################################# ## #W alghom.tst GAP library Thomas Breuer ## ## #Y Copyright (C) 1998, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## To be listed in testinstall.g ## gap> START_TEST("alghom.tst"); # An example of a non-homomorphism which is total but not single-valued. gap> q:= QuaternionAlgebra( Rationals ); gap> gensq:= GeneratorsOfAlgebra( q ); [ e, i, j, k ] gap> f:= FullMatrixAlgebra( Rationals, 2 ); ( Rationals^[ 2, 2 ] ) gap> b:= Basis( f ); CanonicalBasis( ( Rationals^[ 2, 2 ] ) ) gap> map:= AlgebraGeneralMappingByImages( q, f, gensq, b );; gap> ker:= KernelOfAdditiveGeneralMapping( map );; gap> Dimension( ker ); 4 gap> coker:= CoKernelOfAdditiveGeneralMapping( map );; gap> Dimension( coker ); 4 gap> IsTotal(map); true gap> IsSingleValued(map); false # A non-homomorphism which is single-valued but not total gap> map:= AlgebraGeneralMappingByImages( q, f, gensq{[1]}, b{[1]} );; gap> ker:= KernelOfAdditiveGeneralMapping( map );; gap> Dimension( ker ); 0 gap> coker:= CoKernelOfAdditiveGeneralMapping( map );; gap> Dimension( coker ); 0 gap> IsTotal(map); false gap> IsSingleValued(map); true # A non-homomorphism which is neither single-valued nor total gap> map:= AlgebraGeneralMappingByImages( q, f, gensq{[1,2]}, b{[1,2]} );; gap> ker:= KernelOfAdditiveGeneralMapping( map );; gap> Dimension( ker ); 2 gap> coker:= CoKernelOfAdditiveGeneralMapping( map );; gap> Dimension( coker ); 2 gap> IsTotal(map); false gap> IsSingleValued(map); false # An example of an algebra-with-one homomorphism. gap> T:= EmptySCTable( 2, 0 );; gap> SetEntrySCTable( T, 1, 1, [1,1] ); gap> SetEntrySCTable( T, 2, 2, [1,2] ); gap> A:= AlgebraByStructureConstants( Rationals, T );; gap> C:= CanonicalBasis( A );; gap> A:= AsAlgebraWithOne( Rationals, A );; gap> IsomorphismFpAlgebra( A );; gap> m1:= NullMat( 2, 2 );; m1[1][1]:= 1;; gap> m2:= NullMat( 2, 2 );; m2[2][2]:= 1;; gap> B:= AlgebraByGenerators( Rationals, [ m1, m2 ] );; gap> B:= AsAlgebraWithOne( Rationals, B );; gap> f:= AlgebraWithOneHomomorphismByImages( A, B, [ C[2] ], [ m2 ] ); [ v.2, v.1+v.2 ] -> [ [ [ 0, 0 ], [ 0, 1 ] ], [ [ 1, 0 ], [ 0, 1 ] ] ] gap> IsBijective( f ); true gap> STOP_TEST( "alghom.tst", 6000000 ); ############################################################################# ## #E gap-4r6p5/tst/grppc.tst0000644000175000017500000000752712172557256013641 0ustar billbill############################################################################# ## #W grppc.tst GAP tests Alexander Hulpke ## ## #Y Copyright (C) 1997 ## ## To be listed in testinstall.g ## gap> START_TEST("grppc.tst"); gap> h:=Group((1,2,3,4),(1,2));; gap> m:=IsomorphismPcGroup(h);; gap> hh:=Image(m,h);; gap> pcgs:=Pcgs(hh);; gap> ForAll(pcgs,i->PreImagesRepresentative(m,i) in h); true gap> g:=WreathProduct(Group((1,2,3),(1,2)),Group((1,2,3,4,5,6,7)));; gap> i:=IsomorphismPcGroup(g);; gap> g:=Range(i);; gap> u:=Subgroup(g,GeneratorsOfGroup(g){[2..15]});; gap> n:=Subgroup(g,[g.1]);; gap> v:=Normalizer(u,n);; gap> IsSubgroup(u,v); true gap> G:=function() > local g1,g2,g3,g4,g5,g6,g7,g8,g9,g10,g11,g12,g13,g14,r,f,g,rws,x; > f:=FreeGroup(IsSyllableWordsFamily,14); g:=GeneratorsOfGroup(f); > g1:=g[1]; g2:=g[2]; > g3:=g[3]; g4:=g[4]; g5:=g[5]; g6:=g[6]; g7:=g[7]; g8:=g[8]; g9:=g[9]; > g10:=g[10]; g11:=g[11]; g12:=g[12]; g13:=g[13]; g14:=g[14]; > rws:=SingleCollector(f,[ 2, 2, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2 ]); > r:=[ [1,g2], ]; for x in r do SetPower(rws,x[1],x[2]);od; > r:=[ [3,1,g3^2*g4], [4,1,g4^2*g5], [5,1,g5^2*g6], [6,1,g3*g6^2], > [7,1,g7*g9], [8,1,g8*g10], [9,1,g9*g11], [10,1,g10*g12], [11,1,g11*g13], > [12,1,g12*g14],[13,1,g7*g13],[14,1,g8*g14], [3,2,g3^2*g5], [4,2,g4^2*g6], > [5,2,g3*g5^2], [6,2,g4*g6^2], [7,2,g7*g11], [8,2,g8*g12], [9,2,g9*g13], > [10,2,g10*g14], [11,2,g7*g11], [12,2,g8*g12],[13,2,g9*g13],[14,2,g10*g14], > [7,3,g7*g8],[8,3,g7],[9,4,g9*g10],[10,4,g9], [11,5,g11*g12], [12,5,g11], > [13,6,g13*g14], [14,6,g13] ]; > for x in r do SetCommutator(rws,x[1],x[2],x[3]);od; > return GroupByRwsNC(rws); end;; G:=G();; gap> gens:=GeneratorsOfGroup(G);; gap> u:=Group( gens[2], gens[3]*gens[5], gens[4]*gens[6], gens[7], gens[8], > gens[9], gens[10], gens[11], gens[12], gens[13], gens[14] );; gap> v:=Group( gens[1], gens[2], gens[3]*gens[5], gens[4]*gens[6], > gens[7]*gens[11],gens[8]*gens[12],gens[9]*gens[13], gens[10]*gens[14]);; gap> Intersection(u,v);; gap> g:=Group((1,15,8,4,14,9)(2,16,7,3,13,10)(5,18,12)(6,17,11), > (1,3)(2,4)(7,9)(8,10)(13,15)(14,16), > (1,3,6)(2,4,5)(7,9,12)(8,10,11)(13,15,18)(14,16,17), > (5,6)(7,8)(9,10)(13,14)(15,16),(1,2)(7,8)(13,14),(1,2)(3,4)(5,6), > (7,8)(9,10)(11,12),(13,14)(15,16)(17,18));; gap> cl:=ConjugacyClasses(Image(IsomorphismPcGroup(g),g));; gap> G := Group( ( 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14), (15,16) );; gap> sys := SylowSystem( G );; gap> List( sys, Size ); [ 4, 7 ] gap> List(sys,i->Length(AsList(i))); [ 4, 7 ] gap> G := SmallGroup( 144, 183 );; gap> F := FittingSubgroup( G );; gap> S := SylowSubgroup( F, 2 );; gap> Length(ComplementClassesRepresentatives( G, S )); 1 gap> c:=111738634087016687677581080419779823937672962105281999064930026947977838341505382863502660652163271927890657789545865354105698690880491419382732505129685548945886493976382779091529311779061982182942409366242406420035526825355893426176; 111738634087016687677581080419779823937672962105281999064930026947977838341505\ 382863502660652163271927890657789545865354105698690880491419382732505129685548\ 945886493976382779091529311779061982182942409366242406420035526825355893426176 gap> PcGroupCode (c, 43008); gap> G:= > 62914798297585954914426131977340386523695645250865424229791550956377401783;; gap> G:=PcGroupCode(G,24570);; gap> x := G.1*G.3*G.5;;y := x^4;; gap> RepresentativeAction(G,x,y)=fail; false gap> G:=2353881588135032924850825470669869647984062942442421472263823;; gap> G:=PcGroupCode(G,7938);; gap> x:=G.3*G.5^2*G.6^3*G.7^3;; gap> RepresentativeAction(G,x,x^2)<>fail; true gap> RepresentativeAction(G,x,x^2); f1*f2 # that's all, folks gap> STOP_TEST( "grppc.tst", 45300000 ); ############################################################################# ## #E gap-4r6p5/tst/grpprmcs.tst0000644000175000017500000032226612172557256014363 0ustar billbill############################################################################# ## #W grpprmcs.tst GAP library Ákos Seress ## ## #Y Copyright (C) 1998, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## Exclude from testinstall.g: why? ## gap> START_TEST("grpprmcs.tst"); # we don't want `GroupString' to display the number of generators as this # may differ. We get the sizes anyhow from the composition factors. Thus # install a dummy method gap> InstallMethod(GroupString, "for a group", true, [ IsGroup,IsString ], 0, > function( G,nam )return "Group";end); # missing (?): # bbox # dim8p3 # fi23.grp # gl83.gen # proba # agl10.2 gap> g:= > Group( ( 1, 2)( 3, 4)( 5, 6)( 7, 8)( 9, 10) > ( 11, 12)( 13, 14)( 15, 16)( 17, 18)( 19, 20)( 21, 22) > ( 23, 24)( 25, 26)( 27, 28)( 29, 30)( 31, 32)( 33, 34) > ( 35, 36)( 37, 38)( 39, 40)( 41, 42)( 43, 44)( 45, 46) > ( 47, 48)( 49, 50)( 51, 52)( 53, 54)( 55, 56)( 57, 58) > ( 59, 60)( 61, 62)( 63, 64)( 65, 66)( 67, 68)( 69, 70) > ( 71, 72)( 73, 74)( 75, 76)( 77, 78)( 79, 80)( 81, 82) > ( 83, 84)( 85, 86)( 87, 88)( 89, 90)( 91, 92)( 93, 94) > ( 95, 96)( 97, 98)( 99, 100)( 101, 102)( 103, 104)( 105, 106) > ( 107, 108)( 109, 110)( 111, 112)( 113, 114)( 115, 116)( 117, 118) > ( 119, 120)( 121, 122)( 123, 124)( 125, 126)( 127, 128)( 129, 130) > ( 131, 132)( 133, 134)( 135, 136)( 137, 138)( 139, 140)( 141, 142) > ( 143, 144)( 145, 146)( 147, 148)( 149, 150)( 151, 152)( 153, 154) > ( 155, 156)( 157, 158)( 159, 160)( 161, 162)( 163, 164)( 165, 166) > ( 167, 168)( 169, 170)( 171, 172)( 173, 174)( 175, 176)( 177, 178) > ( 179, 180)( 181, 182)( 183, 184)( 185, 186)( 187, 188)( 189, 190) > ( 191, 192)( 193, 194)( 195, 196)( 197, 198)( 199, 200)( 201, 202) > ( 203, 204)( 205, 206)( 207, 208)( 209, 210)( 211, 212)( 213, 214) > ( 215, 216)( 217, 218)( 219, 220)( 221, 222)( 223, 224)( 225, 226) > ( 227, 228)( 229, 230)( 231, 232)( 233, 234)( 235, 236)( 237, 238) > ( 239, 240)( 241, 242)( 243, 244)( 245, 246)( 247, 248)( 249, 250) > ( 251, 252)( 253, 254)( 255, 256)( 257, 258)( 259, 260)( 261, 262) > ( 263, 264)( 265, 266)( 267, 268)( 269, 270)( 271, 272)( 273, 274) > ( 275, 276)( 277, 278)( 279, 280)( 281, 282)( 283, 284)( 285, 286) > ( 287, 288)( 289, 290)( 291, 292)( 293, 294)( 295, 296)( 297, 298) > ( 299, 300)( 301, 302)( 303, 304)( 305, 306)( 307, 308)( 309, 310) > ( 311, 312)( 313, 314)( 315, 316)( 317, 318)( 319, 320)( 321, 322) > ( 323, 324)( 325, 326)( 327, 328)( 329, 330)( 331, 332)( 333, 334) > ( 335, 336)( 337, 338)( 339, 340)( 341, 342)( 343, 344)( 345, 346) > ( 347, 348)( 349, 350)( 351, 352)( 353, 354)( 355, 356)( 357, 358) > ( 359, 360)( 361, 362)( 363, 364)( 365, 366)( 367, 368)( 369, 370) > ( 371, 372)( 373, 374)( 375, 376)( 377, 378)( 379, 380)( 381, 382) > ( 383, 384)( 385, 386)( 387, 388)( 389, 390)( 391, 392)( 393, 394) > ( 395, 396)( 397, 398)( 399, 400)( 401, 402)( 403, 404)( 405, 406) > ( 407, 408)( 409, 410)( 411, 412)( 413, 414)( 415, 416)( 417, 418) > ( 419, 420)( 421, 422)( 423, 424)( 425, 426)( 427, 428)( 429, 430) > ( 431, 432)( 433, 434)( 435, 436)( 437, 438)( 439, 440)( 441, 442) > ( 443, 444)( 445, 446)( 447, 448)( 449, 450)( 451, 452)( 453, 454) > ( 455, 456)( 457, 458)( 459, 460)( 461, 462)( 463, 464)( 465, 466) > ( 467, 468)( 469, 470)( 471, 472)( 473, 474)( 475, 476)( 477, 478) > ( 479, 480)( 481, 482)( 483, 484)( 485, 486)( 487, 488)( 489, 490) > ( 491, 492)( 493, 494)( 495, 496)( 497, 498)( 499, 500)( 501, 502) > ( 503, 504)( 505, 506)( 507, 508)( 509, 510)( 511, 512)( 513, 514) > ( 515, 516)( 517, 518)( 519, 520)( 521, 522)( 523, 524)( 525, 526) > ( 527, 528)( 529, 530)( 531, 532)( 533, 534)( 535, 536)( 537, 538) > ( 539, 540)( 541, 542)( 543, 544)( 545, 546)( 547, 548)( 549, 550) > ( 551, 552)( 553, 554)( 555, 556)( 557, 558)( 559, 560)( 561, 562) > ( 563, 564)( 565, 566)( 567, 568)( 569, 570)( 571, 572)( 573, 574) > ( 575, 576)( 577, 578)( 579, 580)( 581, 582)( 583, 584)( 585, 586) > ( 587, 588)( 589, 590)( 591, 592)( 593, 594)( 595, 596)( 597, 598) > ( 599, 600)( 601, 602)( 603, 604)( 605, 606)( 607, 608)( 609, 610) > ( 611, 612)( 613, 614)( 615, 616)( 617, 618)( 619, 620)( 621, 622) > ( 623, 624)( 625, 626)( 627, 628)( 629, 630)( 631, 632)( 633, 634) > ( 635, 636)( 637, 638)( 639, 640)( 641, 642)( 643, 644)( 645, 646) > ( 647, 648)( 649, 650)( 651, 652)( 653, 654)( 655, 656)( 657, 658) > ( 659, 660)( 661, 662)( 663, 664)( 665, 666)( 667, 668)( 669, 670) > ( 671, 672)( 673, 674)( 675, 676)( 677, 678)( 679, 680)( 681, 682) > ( 683, 684)( 685, 686)( 687, 688)( 689, 690)( 691, 692)( 693, 694) > ( 695, 696)( 697, 698)( 699, 700)( 701, 702)( 703, 704)( 705, 706) > ( 707, 708)( 709, 710)( 711, 712)( 713, 714)( 715, 716)( 717, 718) > ( 719, 720)( 721, 722)( 723, 724)( 725, 726)( 727, 728)( 729, 730) > ( 731, 732)( 733, 734)( 735, 736)( 737, 738)( 739, 740)( 741, 742) > ( 743, 744)( 745, 746)( 747, 748)( 749, 750)( 751, 752)( 753, 754) > ( 755, 756)( 757, 758)( 759, 760)( 761, 762)( 763, 764)( 765, 766) > ( 767, 768)( 769, 770)( 771, 772)( 773, 774)( 775, 776)( 777, 778) > ( 779, 780)( 781, 782)( 783, 784)( 785, 786)( 787, 788)( 789, 790) > ( 791, 792)( 793, 794)( 795, 796)( 797, 798)( 799, 800)( 801, 802) > ( 803, 804)( 805, 806)( 807, 808)( 809, 810)( 811, 812)( 813, 814) > ( 815, 816)( 817, 818)( 819, 820)( 821, 822)( 823, 824)( 825, 826) > ( 827, 828)( 829, 830)( 831, 832)( 833, 834)( 835, 836)( 837, 838) > ( 839, 840)( 841, 842)( 843, 844)( 845, 846)( 847, 848)( 849, 850) > ( 851, 852)( 853, 854)( 855, 856)( 857, 858)( 859, 860)( 861, 862) > ( 863, 864)( 865, 866)( 867, 868)( 869, 870)( 871, 872)( 873, 874) > ( 875, 876)( 877, 878)( 879, 880)( 881, 882)( 883, 884)( 885, 886) > ( 887, 888)( 889, 890)( 891, 892)( 893, 894)( 895, 896)( 897, 898) > ( 899, 900)( 901, 902)( 903, 904)( 905, 906)( 907, 908)( 909, 910) > ( 911, 912)( 913, 914)( 915, 916)( 917, 918)( 919, 920)( 921, 922) > ( 923, 924)( 925, 926)( 927, 928)( 929, 930)( 931, 932)( 933, 934) > ( 935, 936)( 937, 938)( 939, 940)( 941, 942)( 943, 944)( 945, 946) > ( 947, 948)( 949, 950)( 951, 952)( 953, 954)( 955, 956)( 957, 958) > ( 959, 960)( 961, 962)( 963, 964)( 965, 966)( 967, 968)( 969, 970) > ( 971, 972)( 973, 974)( 975, 976)( 977, 978)( 979, 980)( 981, 982) > ( 983, 984)( 985, 986)( 987, 988)( 989, 990)( 991, 992)( 993, 994) > ( 995, 996)( 997, 998)( 999,1000)(1001,1002)(1003,1004)(1005,1006) > (1007,1008)(1009,1010)(1011,1012)(1013,1014)(1015,1016)(1017,1018) > (1019,1020)(1021,1022)(1023,1024), (257,513)(258,514)(259,515)(260,516) > (261,517)(262,518)(263,519)(264,520)(265,521)(266,522)(267,523) > (268,524)(269,525)(270,526)(271,527)(272,528)(273,529)(274,530) > (275,531)(276,532)(277,533)(278,534)(279,535)(280,536)(281,537) > (282,538)(283,539)(284,540)(285,541)(286,542)(287,543)(288,544) > (289,545)(290,546)(291,547)(292,548)(293,549)(294,550)(295,551) > (296,552)(297,553)(298,554)(299,555)(300,556)(301,557)(302,558) > (303,559)(304,560)(305,561)(306,562)(307,563)(308,564)(309,565) > (310,566)(311,567)(312,568)(313,569)(314,570)(315,571)(316,572) > (317,573)(318,574)(319,575)(320,576)(321,577)(322,578)(323,579) > (324,580)(325,581)(326,582)(327,583)(328,584)(329,585)(330,586) > (331,587)(332,588)(333,589)(334,590)(335,591)(336,592)(337,593) > (338,594)(339,595)(340,596)(341,597)(342,598)(343,599)(344,600) > (345,601)(346,602)(347,603)(348,604)(349,605)(350,606)(351,607) > (352,608)(353,609)(354,610)(355,611)(356,612)(357,613)(358,614) > (359,615)(360,616)(361,617)(362,618)(363,619)(364,620)(365,621) > (366,622)(367,623)(368,624)(369,625)(370,626)(371,627)(372,628) > (373,629)(374,630)(375,631)(376,632)(377,633)(378,634)(379,635) > (380,636)(381,637)(382,638)(383,639)(384,640)(385,641)(386,642) > (387,643)(388,644)(389,645)(390,646)(391,647)(392,648)(393,649) > (394,650)(395,651)(396,652)(397,653)(398,654)(399,655)(400,656) > (401,657)(402,658)(403,659)(404,660)(405,661)(406,662)(407,663) > (408,664)(409,665)(410,666)(411,667)(412,668)(413,669)(414,670) > (415,671)(416,672)(417,673)(418,674)(419,675)(420,676)(421,677) > (422,678)(423,679)(424,680)(425,681)(426,682)(427,683)(428,684) > (429,685)(430,686)(431,687)(432,688)(433,689)(434,690)(435,691) > (436,692)(437,693)(438,694)(439,695)(440,696)(441,697)(442,698) > (443,699)(444,700)(445,701)(446,702)(447,703)(448,704)(449,705) > (450,706)(451,707)(452,708)(453,709)(454,710)(455,711)(456,712) > (457,713)(458,714)(459,715)(460,716)(461,717)(462,718)(463,719) > (464,720)(465,721)(466,722)(467,723)(468,724)(469,725)(470,726) > (471,727)(472,728)(473,729)(474,730)(475,731)(476,732)(477,733) > (478,734)(479,735)(480,736)(481,737)(482,738)(483,739)(484,740) > (485,741)(486,742)(487,743)(488,744)(489,745)(490,746)(491,747) > (492,748)(493,749)(494,750)(495,751)(496,752)(497,753)(498,754) > (499,755)(500,756)(501,757)(502,758)(503,759)(504,760)(505,761) > (506,762)(507,763)(508,764)(509,765)(510,766)(511,767)(512,768), > ( 2, 3, 5, 9, 17, 33, 65, 129, 257, 513)( 4, 7, 13, > 25, 49, 97, 193, 385, 769, 514)( 6, 11, 21, 41, 81, 161, > 321, 641, 258, 515)( 8, 15, 29, 57, 113, 225, 449, 897, 770, 516 > )( 10, 19, 37, 73, 145, 289, 577, 130, 259, 517)( 12, 23, 45, > 89, 177, 353, 705, 386, 771, 518)( 14, 27, 53, 105, 209, 417, > 833, 642, 260, 519)( 16, 31, 61, 121, 241, 481, 961, 898, 772, 520 > )( 18, 35, 69, 137, 273, 545, 66, 131, 261, 521)( 20, 39, 77, > 153, 305, 609, 194, 387, 773, 522)( 22, 43, 85, 169, 337, 673, > 322, 643, 262, 523)( 24, 47, 93, 185, 369, 737, 450, 899, 774, 524 > )( 26, 51, 101, 201, 401, 801, 578, 132, 263, 525)( 28, 55, 109, > 217, 433, 865, 706, 388, 775, 526)( 30, 59, 117, 233, 465, 929, > 834, 644, 264, 527)( 32, 63, 125, 249, 497, 993, 962, 900, 776, 528 > )( 34, 67, 133, 265, 529)( 36, 71, 141, 281, 561, 98, 195, 389, > 777, 530)( 38, 75, 149, 297, 593, 162, 323, 645, 266, 531) > ( 40, 79, 157, 313, 625, 226, 451, 901, 778, 532)( 42, 83, 165, > 329, 657, 290, 579, 134, 267, 533)( 44, 87, 173, 345, 689, 354, > 707, 390, 779, 534)( 46, 91, 181, 361, 721, 418, 835, 646, 268, 535 > )( 48, 95, 189, 377, 753, 482, 963, 902, 780, 536)( 50, 99, 197, > 393, 785, 546, 68, 135, 269, 537)( 52, 103, 205, 409, 817, 610, > 196, 391, 781, 538)( 54, 107, 213, 425, 849, 674, 324, 647, 270, 539 > )( 56, 111, 221, 441, 881, 738, 452, 903, 782, 540)( 58, 115, 229, > 457, 913, 802, 580, 136, 271, 541)( 60, 119, 237, 473, 945, 866, > 708, 392, 783, 542)( 62, 123, 245, 489, 977, 930, 836, 648, 272, 543 > )( 64, 127, 253, 505,1009, 994, 964, 904, 784, 544)( 70, 139, 277, > 553, 82, 163, 325, 649, 274, 547)( 72, 143, 285, 569, 114, 227, > 453, 905, 786, 548)( 74, 147, 293, 585, 146, 291, 581, 138, 275, 549 > )( 76, 151, 301, 601, 178, 355, 709, 394, 787, 550)( 78, 155, 309, > 617, 210, 419, 837, 650, 276, 551)( 80, 159, 317, 633, 242, 483, > 965, 906, 788, 552)( 84, 167, 333, 665, 306, 611, 198, 395, 789, 554 > )( 86, 171, 341, 681, 338, 675, 326, 651, 278, 555)( 88, 175, 349, > 697, 370, 739, 454, 907, 790, 556)( 90, 179, 357, 713, 402, 803, > 582, 140, 279, 557)( 92, 183, 365, 729, 434, 867, 710, 396, 791, 558 > )( 94, 187, 373, 745, 466, 931, 838, 652, 280, 559)( 96, 191, 381, > 761, 498, 995, 966, 908, 792, 560)( 100, 199, 397, 793, 562) > ( 102, 203, 405, 809, 594, 164, 327, 653, 282, 563)( 104, 207, 413, > 825, 626, 228, 455, 909, 794, 564)( 106, 211, 421, 841, 658, 292, > 583, 142, 283, 565)( 108, 215, 429, 857, 690, 356, 711, 398, 795, 566 > )( 110, 219, 437, 873, 722, 420, 839, 654, 284, 567)( 112, 223, 445, > 889, 754, 484, 967, 910, 796, 568)( 116, 231, 461, 921, 818, 612, > 200, 399, 797, 570)( 118, 235, 469, 937, 850, 676, 328, 655, 286, 571 > )( 120, 239, 477, 953, 882, 740, 456, 911, 798, 572)( 122, 243, 485, > 969, 914, 804, 584, 144, 287, 573)( 124, 247, 493, 985, 946, 868, > 712, 400, 799, 574)( 126, 251, 501,1001, 978, 932, 840, 656, 288, 575 > )( 128, 255, 509,1017,1010, 996, 968, 912, 800, 576)( 148, 295, 589, > 154, 307, 613, 202, 403, 805, 586)( 150, 299, 597, 170, 339, 677, > 330, 659, 294, 587)( 152, 303, 605, 186, 371, 741, 458, 915, 806, 588 > )( 156, 311, 621, 218, 435, 869, 714, 404, 807, 590)( 158, 315, 629, > 234, 467, 933, 842, 660, 296, 591)( 160, 319, 637, 250, 499, 997, > 970, 916, 808, 592)( 166, 331, 661, 298, 595)( 168, 335, 669, 314, > 627, 230, 459, 917, 810, 596)( 172, 343, 685, 346, 691, 358, 715, > 406, 811, 598)( 174, 347, 693, 362, 723, 422, 843, 662, 300, 599) > ( 176, 351, 701, 378, 755, 486, 971, 918, 812, 600)( 180, 359, 717, > 410, 819, 614, 204, 407, 813, 602)( 182, 363, 725, 426, 851, 678, > 332, 663, 302, 603)( 184, 367, 733, 442, 883, 742, 460, 919, 814, 604 > )( 188, 375, 749, 474, 947, 870, 716, 408, 815, 606)( 190, 379, 757, > 490, 979, 934, 844, 664, 304, 607)( 192, 383, 765, 506,1011, 998, > 972, 920, 816, 608)( 206, 411, 821, 618, 212, 423, 845, 666, 308, 615 > )( 208, 415, 829, 634, 244, 487, 973, 922, 820, 616)( 214, 427, 853, > 682, 340, 679, 334, 667, 310, 619)( 216, 431, 861, 698, 372, 743, > 462, 923, 822, 620)( 220, 439, 877, 730, 436, 871, 718, 412, 823, 622 > )( 222, 443, 885, 746, 468, 935, 846, 668, 312, 623)( 224, 447, 893, > 762, 500, 999, 974, 924, 824, 624)( 232, 463, 925, 826, 628) > ( 236, 471, 941, 858, 692, 360, 719, 414, 827, 630)( 238, 475, 949, > 874, 724, 424, 847, 670, 316, 631)( 240, 479, 957, 890, 756, 488, > 975, 926, 828, 632)( 246, 491, 981, 938, 852, 680, 336, 671, 318, 635 > )( 248, 495, 989, 954, 884, 744, 464, 927, 830, 636)( 252, 503,1005, > 986, 948, 872, 720, 416, 831, 638)( 254, 507,1013,1002, 980, 936, > 848, 672, 320, 639)( 256, 511,1021,1018,1012,1000, 976, 928, 832, 640 > )( 342, 683)( 344, 687, 350, 699, 374, 747, 470, 939, 854, 684) > ( 348, 695, 366, 731, 438, 875, 726, 428, 855, 686)( 352, 703, 382, > 763, 502,1003, 982, 940, 856, 688)( 364, 727, 430, 859, 694) > ( 368, 735, 446, 891, 758, 492, 983, 942, 860, 696)( 376, 751, 478, > 955, 886, 748, 472, 943, 862, 700)( 380, 759, 494, 987, 950, 876, > 728, 432, 863, 702)( 384, 767, 510,1019,1014,1004, 984, 944, 864, 704 > )( 440, 879, 734, 444, 887, 750, 476, 951, 878, 732)( 448, 895, 766, > 508,1015,1006, 988, 952, 880, 736)( 480, 959, 894, 764, 504,1007, > 990, 956, 888, 752)( 496, 991, 958, 892, 760)( 512,1023,1022,1020, > 1016,1008, 992, 960, 896, 768), ( 257, 769)( 258, 770)( 259, 771) > ( 260, 772)( 261, 773)( 262, 774)( 263, 775)( 264, 776)( 265, 777) > ( 266, 778)( 267, 779)( 268, 780)( 269, 781)( 270, 782)( 271, 783) > ( 272, 784)( 273, 785)( 274, 786)( 275, 787)( 276, 788)( 277, 789) > ( 278, 790)( 279, 791)( 280, 792)( 281, 793)( 282, 794)( 283, 795) > ( 284, 796)( 285, 797)( 286, 798)( 287, 799)( 288, 800)( 289, 801) > ( 290, 802)( 291, 803)( 292, 804)( 293, 805)( 294, 806)( 295, 807) > ( 296, 808)( 297, 809)( 298, 810)( 299, 811)( 300, 812)( 301, 813) > ( 302, 814)( 303, 815)( 304, 816)( 305, 817)( 306, 818)( 307, 819) > ( 308, 820)( 309, 821)( 310, 822)( 311, 823)( 312, 824)( 313, 825) > ( 314, 826)( 315, 827)( 316, 828)( 317, 829)( 318, 830)( 319, 831) > ( 320, 832)( 321, 833)( 322, 834)( 323, 835)( 324, 836)( 325, 837) > ( 326, 838)( 327, 839)( 328, 840)( 329, 841)( 330, 842)( 331, 843) > ( 332, 844)( 333, 845)( 334, 846)( 335, 847)( 336, 848)( 337, 849) > ( 338, 850)( 339, 851)( 340, 852)( 341, 853)( 342, 854)( 343, 855) > ( 344, 856)( 345, 857)( 346, 858)( 347, 859)( 348, 860)( 349, 861) > ( 350, 862)( 351, 863)( 352, 864)( 353, 865)( 354, 866)( 355, 867) > ( 356, 868)( 357, 869)( 358, 870)( 359, 871)( 360, 872)( 361, 873) > ( 362, 874)( 363, 875)( 364, 876)( 365, 877)( 366, 878)( 367, 879) > ( 368, 880)( 369, 881)( 370, 882)( 371, 883)( 372, 884)( 373, 885) > ( 374, 886)( 375, 887)( 376, 888)( 377, 889)( 378, 890)( 379, 891) > ( 380, 892)( 381, 893)( 382, 894)( 383, 895)( 384, 896)( 385, 897) > ( 386, 898)( 387, 899)( 388, 900)( 389, 901)( 390, 902)( 391, 903) > ( 392, 904)( 393, 905)( 394, 906)( 395, 907)( 396, 908)( 397, 909) > ( 398, 910)( 399, 911)( 400, 912)( 401, 913)( 402, 914)( 403, 915) > ( 404, 916)( 405, 917)( 406, 918)( 407, 919)( 408, 920)( 409, 921) > ( 410, 922)( 411, 923)( 412, 924)( 413, 925)( 414, 926)( 415, 927) > ( 416, 928)( 417, 929)( 418, 930)( 419, 931)( 420, 932)( 421, 933) > ( 422, 934)( 423, 935)( 424, 936)( 425, 937)( 426, 938)( 427, 939) > ( 428, 940)( 429, 941)( 430, 942)( 431, 943)( 432, 944)( 433, 945) > ( 434, 946)( 435, 947)( 436, 948)( 437, 949)( 438, 950)( 439, 951) > ( 440, 952)( 441, 953)( 442, 954)( 443, 955)( 444, 956)( 445, 957) > ( 446, 958)( 447, 959)( 448, 960)( 449, 961)( 450, 962)( 451, 963) > ( 452, 964)( 453, 965)( 454, 966)( 455, 967)( 456, 968)( 457, 969) > ( 458, 970)( 459, 971)( 460, 972)( 461, 973)( 462, 974)( 463, 975) > ( 464, 976)( 465, 977)( 466, 978)( 467, 979)( 468, 980)( 469, 981) > ( 470, 982)( 471, 983)( 472, 984)( 473, 985)( 474, 986)( 475, 987) > ( 476, 988)( 477, 989)( 478, 990)( 479, 991)( 480, 992)( 481, 993) > ( 482, 994)( 483, 995)( 484, 996)( 485, 997)( 486, 998)( 487, 999) > ( 488,1000)( 489,1001)( 490,1002)( 491,1003)( 492,1004)( 493,1005) > ( 494,1006)( 495,1007)( 496,1008)( 497,1009)( 498,1010)( 499,1011) > ( 500,1012)( 501,1013)( 502,1014)( 503,1015)( 504,1016)( 505,1017) > ( 506,1018)( 507,1019)( 508,1020)( 509,1021)( 510,1022)( 511,1023) > ( 512,1024) );; gap> SetName( g, "g" ); gap> DisplayCompositionSeries( g ); Group | A(9,2) = L(10,2) Group | Z(2) Group | Z(2) Group | Z(2) Group | Z(2) Group | Z(2) Group | Z(2) Group | Z(2) Group | Z(2) Group | Z(2) Group | Z(2) Group gap> List( ChiefSeriesOfGroup( g ), Size ); [ 375234700595146883504949480652800, 1024, 1 ] # agl1103.gen gap> perm1:= PermList( Concatenation( [ 2 .. 1103 ], [ 1 ] ) );; gap> perm2:= PermList( List( [1 .. 1103 ], x -> (5*x mod 1103) +1 ) );; gap> g:= Group( perm1, perm2 );; gap> SetName( g, "g" ); gap> DisplayCompositionSeries( g ); Group | Z(2) Group | Z(19) Group | Z(29) Group | Z(1103) Group gap> List( ChiefSeriesOfGroup( g ), Size ); [ 1215506, 607753, 31987, 1103, 1 ] # $Co_2$ on 2300 points gap> g:= > Group( ( 1, 4)( 2, 7)( 5, 10)( 6, 12)( 8, 17) > ( 11, 18)( 13, 24)( 15, 25)( 16, 23)( 20, 30)( 21, 31) > ( 22, 33)( 26, 42)( 27, 45)( 28, 40)( 29, 41)( 34, 46) > ( 36, 60)( 37, 63)( 38, 52)( 43, 72)( 47, 49)( 48, 80) > ( 50, 84)( 51, 87)( 53, 69)( 54, 76)( 56, 77)( 57, 78) > ( 58, 104)( 59, 106)( 61, 109)( 62, 110)( 64, 116)( 65, 117) > ( 67, 82)( 68, 124)( 71, 129)( 73, 131)( 74, 90)( 79, 142) > ( 81, 146)( 83, 148)( 85, 151)( 86, 152)( 88, 155)( 89, 156) > ( 91, 126)( 92, 159)( 93, 164)( 94, 136)( 95, 137)( 97, 138) > ( 98, 171)( 100, 140)( 101, 141)( 103, 128)( 107, 178)( 108, 179) > ( 111, 183)( 112, 193)( 113, 186)( 114, 187)( 115, 199)( 118, 201) > ( 119, 204)( 120, 209)( 121, 130)( 122, 165)( 123, 215)( 125, 219) > ( 127, 132)( 133, 224)( 134, 135)( 139, 228)( 143, 232)( 144, 233) > ( 147, 241)( 149, 243)( 150, 244)( 153, 250)( 154, 251)( 157, 258) > ( 158, 259)( 160, 265)( 161, 246)( 162, 264)( 163, 225)( 166, 271) > ( 167, 276)( 168, 277)( 169, 279)( 170, 227)( 172, 281)( 173, 284) > ( 175, 222)( 180, 290)( 181, 295)( 182, 296)( 184, 303)( 185, 292) > ( 188, 312)( 189, 298)( 190, 317)( 191, 301)( 192, 320)( 194, 321) > ( 195, 324)( 196, 309)( 197, 328)( 198, 332)( 200, 334)( 202, 256) > ( 205, 345)( 206, 335)( 207, 338)( 208, 349)( 210, 351)( 211, 223) > ( 212, 269)( 213, 273)( 214, 216)( 217, 357)( 218, 356)( 220, 364) > ( 221, 366)( 226, 280)( 229, 370)( 230, 371)( 234, 375)( 235, 380) > ( 236, 381)( 238, 272)( 240, 388)( 242, 392)( 245, 291)( 247, 395) > ( 248, 336)( 249, 257)( 252, 260)( 253, 405)( 254, 310)( 255, 267) > ( 261, 414)( 262, 409)( 263, 416)( 266, 419)( 268, 421)( 270, 353) > ( 274, 352)( 275, 427)( 278, 430)( 282, 434)( 283, 385)( 285, 439) > ( 287, 358)( 289, 443)( 293, 447)( 294, 450)( 297, 453)( 299, 456) > ( 300, 444)( 302, 462)( 304, 455)( 305, 464)( 306, 468)( 307, 446) > ( 308, 472)( 311, 477)( 313, 480)( 314, 481)( 315, 454)( 316, 486) > ( 318, 487)( 319, 488)( 322, 491)( 323, 494)( 325, 497)( 326, 498) > ( 327, 425)( 329, 501)( 330, 502)( 331, 504)( 333, 507)( 339, 399) > ( 340, 517)( 341, 406)( 342, 523)( 344, 527)( 346, 530)( 347, 531) > ( 348, 536)( 350, 539)( 354, 544)( 355, 359)( 360, 547)( 361, 545) > ( 362, 436)( 363, 551)( 365, 555)( 367, 557)( 368, 433)( 369, 432) > ( 376, 461)( 377, 393)( 378, 572)( 379, 575)( 383, 580)( 386, 583) > ( 387, 586)( 389, 590)( 390, 591)( 391, 576)( 394, 600)( 396, 511) > ( 397, 516)( 398, 512)( 400, 407)( 401, 607)( 402, 411)( 403, 412) > ( 404, 413)( 408, 615)( 410, 619)( 415, 629)( 417, 435)( 420, 632) > ( 422, 633)( 423, 634)( 424, 637)( 426, 639)( 428, 429)( 431, 642) > ( 437, 649)( 438, 651)( 440, 654)( 445, 570)( 448, 663)( 449, 664) > ( 451, 638)( 452, 656)( 457, 674)( 458, 657)( 459, 658)( 460, 680) > ( 463, 617)( 465, 673)( 466, 685)( 467, 690)( 469, 693)( 470, 695) > ( 471, 697)( 473, 701)( 474, 702)( 475, 705)( 476, 618)( 478, 711) > ( 479, 712)( 482, 716)( 483, 727)( 484, 719)( 485, 720)( 489, 736) > ( 490, 738)( 492, 742)( 493, 743)( 495, 746)( 496, 744)( 499, 753) > ( 500, 754)( 503, 755)( 505, 758)( 506, 757)( 509, 672)( 515, 773) > ( 518, 520)( 519, 777)( 521, 781)( 522, 784)( 524, 786)( 525, 789) > ( 526, 791)( 528, 795)( 529, 796)( 532, 799)( 533, 810)( 534, 802) > ( 535, 803)( 537, 816)( 538, 614)( 542, 825)( 543, 826)( 546, 828) > ( 548, 648)( 549, 831)( 550, 834)( 552, 838)( 553, 839)( 554, 827) > ( 558, 847)( 559, 647)( 560, 643)( 561, 644)( 567, 683)( 571, 599) > ( 573, 574)( 578, 865)( 581, 869)( 582, 871)( 584, 873)( 585, 876) > ( 587, 588)( 589, 878)( 592, 884)( 593, 892)( 594, 886)( 595, 887) > ( 596, 861)( 597, 862)( 598, 820)( 601, 602)( 603, 829)( 604, 776) > ( 605, 904)( 606, 907)( 608, 902)( 609, 623)( 610, 624)( 611, 625) > ( 612, 916)( 613, 627)( 616, 860)( 620, 925)( 621, 761)( 622, 710) > ( 626, 934)( 628, 815)( 631, 739)( 635, 942)( 636, 944)( 640, 641) > ( 645, 950)( 650, 955)( 652, 956)( 653, 957)( 659, 676)( 660, 858) > ( 661, 969)( 665, 972)( 666, 981)( 667, 975)( 668, 976)( 669, 965) > ( 670, 947)( 675, 966)( 677, 849)( 678, 848)( 679, 998)( 681,1001) > ( 682,1002)( 684, 752)( 686,1009)( 687,1012)( 689,1016)( 691,1020) > ( 692,1021)( 694,1027)( 696, 983)( 698,1032)( 699,1034)( 700,1031) > ( 703,1043)( 704,1048)( 706,1050)( 707,1051)( 708, 918)( 709, 924) > ( 713,1060)( 714,1065)( 715, 730)( 717,1072)( 718, 974)( 722,1066) > ( 723,1082)( 724,1068)( 725,1070)( 726,1089)( 728,1094)( 729,1093) > ( 731,1076)( 732,1102)( 734, 745)( 735, 741)( 737,1033)( 740,1112) > ( 747,1121)( 748,1122)( 749,1019)( 750,1123)( 751, 763)( 756,1140) > ( 759,1141)( 760,1142)( 762,1143)( 765,1158)( 766, 993)( 772,1167) > ( 774,1170)( 775,1171)( 778,1144)( 779,1176)( 780,1179)( 782,1182) > ( 783,1183)( 785, 787)( 788,1189)( 790, 812)( 792,1194)( 793,1195) > ( 794,1193)( 797,1204)( 798,1208)( 800,1215)( 805,1209)( 806,1221) > ( 807,1211)( 808,1213)( 809,1225)( 811,1228)( 813,1218)( 814,1197) > ( 817, 920)( 818, 921)( 819,1181)( 823,1245)( 832,1255)( 833,1256) > ( 835,1261)( 836,1262)( 837,1260)( 840,1266)( 841,1269)( 842, 843) > ( 844,1254)( 846,1113)( 850,1279)( 855,1285)( 856,1287)( 859, 897) > ( 863,1293)( 866,1296)( 867,1298)( 868,1295)( 870,1303)( 872, 874) > ( 875,1249)( 877, 881)( 879, 883)( 880,1313)( 882, 894)( 885,1316) > ( 888,1315)( 889,1318)( 890, 891)( 893,1321)( 895,1267)( 896,1322) > ( 898,1292)( 899,1240)( 900,1328)( 901,1331)( 903,1251)( 905,1333) > ( 906,1332)( 908,1237)( 909,1336)( 910,1320)( 911,1338)( 912, 931) > ( 913,1340)( 914,1341)( 915,1342)( 917,1344)( 919,1348)( 922,1290) > ( 923,1351)( 926,1353)( 927,1150)( 928,1151)( 929,1058)( 930,1059) > ( 932,1358)( 933,1359)( 935,1362)( 936,1235)( 937,1236)( 938,1365) > ( 939,1368)( 940,1115)( 941,1276)( 943,1374)( 945,1375)( 946, 990) > ( 948,1120)( 949,1378)( 951,1379)( 954,1250)( 958,1384)( 959,1393) > ( 960,1387)( 961,1388)( 962,1396)( 967, 968)( 973,1414)( 977,1408) > ( 978,1410)( 979,1412)( 980,1422)( 982,1425)( 984,1418)( 985,1430) > ( 986,1399)( 987,1392)( 988,1302)( 992,1441)( 994,1445)( 995,1278) > ( 996,1446)( 997,1447)( 999,1169)(1000,1168)(1003,1452)(1004,1456) > (1005,1454)(1006,1137)(1007,1138)(1008,1458)(1010,1461)(1011,1462) > (1013,1467)(1014,1468)(1015,1470)(1017,1474)(1018,1475)(1022,1419) > (1023,1428)(1024,1481)(1025,1482)(1026,1490)(1028,1493)(1029,1494) > (1030,1466)(1035,1501)(1036,1512)(1037,1513)(1038,1504)(1039,1507) > (1040,1498)(1041,1499)(1042,1500)(1044,1485)(1045,1523)(1046,1486) > (1047,1457)(1049,1527)(1052,1528)(1053,1532)(1054,1530)(1055,1531) > (1056,1086)(1057,1539)(1061,1548)(1062,1545)(1063,1547)(1064,1550) > (1067,1556)(1069,1411)(1071,1559)(1073,1564)(1074,1563)(1075,1565) > (1077,1571)(1079,1553)(1080,1555)(1081,1576)(1083,1579)(1084,1581) > (1085,1557)(1087,1584)(1088,1587)(1090,1591)(1091,1590)(1092,1593) > (1095,1360)(1096,1598)(1097,1596)(1098,1319)(1099,1600)(1100,1568) > (1101,1603)(1103,1104)(1105,1116)(1106,1117)(1107,1119)(1108,1139) > (1109,1505)(1110,1506)(1111,1126)(1114,1611)(1118,1460)(1124,1273) > (1125,1618)(1127,1131)(1128,1613)(1129,1614)(1130,1311)(1132,1478) > (1133,1479)(1134,1602)(1135,1636)(1136,1639)(1146,1645)(1147,1646) > (1148,1324)(1149,1650)(1152,1196)(1153,1655)(1154,1656)(1156,1659) > (1157,1663)(1159,1665)(1160,1443)(1161,1669)(1162,1670)(1164,1633) > (1165,1671)(1166,1449)(1172,1536)(1173,1519)(1174,1647)(1175,1217) > (1177,1524)(1178,1678)(1180,1680)(1184,1683)(1185,1364)(1186,1688) > (1187,1690)(1188,1691)(1190,1693)(1191,1694)(1192,1677)(1198,1701) > (1199,1205)(1200,1543)(1201,1697)(1202,1203)(1206,1708)(1207,1709) > (1210,1712)(1214,1714)(1216,1716)(1220,1401)(1222,1719)(1223,1721) > (1224,1713)(1226,1722)(1227,1720)(1229,1724)(1230,1727)(1231,1728) > (1232,1699)(1233,1717)(1234,1700)(1238,1732)(1239,1681)(1241,1735) > (1242,1682)(1244,1736)(1246,1738)(1248,1742)(1257,1747)(1258,1617) > (1259,1749)(1263,1753)(1264,1756)(1265,1752)(1268,1757)(1270,1642) > (1271,1746)(1272,1381)(1274,1275)(1277,1758)(1281,1759)(1284,1761) > (1286,1763)(1288,1766)(1289,1767)(1291,1770)(1294,1433)(1297,1773) > (1299,1300)(1301,1771)(1304,1407)(1305,1403)(1306,1687)(1307,1755) > (1308,1776)(1309,1310)(1312,1782)(1314,1785)(1317,1786)(1323,1787) > (1325,1788)(1326,1790)(1327,1791)(1329,1793)(1330,1794)(1334,1797) > (1335,1540)(1337,1651)(1339,1626)(1343,1784)(1345,1804)(1346,1805) > (1347,1806)(1349,1808)(1350,1809)(1352,1811)(1354,1814)(1355,1815) > (1356,1816)(1357,1817)(1361,1820)(1363,1821)(1366,1824)(1367,1825) > (1369,1432)(1370,1826)(1371,1823)(1372,1827)(1373,1605)(1376,1607) > (1377,1437)(1380,1829)(1382,1644)(1385,1772)(1389,1836)(1390,1777) > (1391,1832)(1394,1838)(1395,1840)(1400,1779)(1406,1854)(1409,1597) > (1413,1862)(1415,1867)(1416,1866)(1417,1871)(1420,1453)(1421,1875) > (1423,1879)(1424,1580)(1426,1883)(1427,1884)(1429,1873)(1431,1455) > (1434,1775)(1436,1890)(1439,1896)(1440,1899)(1442,1739)(1444,1905) > (1448,1535)(1450,1492)(1451,1673)(1459,1910)(1463,1911)(1464,1914) > (1465,1915)(1469,1916)(1471,1921)(1472,1922)(1473,1765)(1476,1926) > (1477,1929)(1480,1641)(1483,1919)(1484,1723)(1487,1939)(1488,1934) > (1489,1940)(1491,1941)(1495,1943)(1496,1948)(1497,1946)(1502,1511) > (1503,1958)(1508,1947)(1509,1953)(1510,1715)(1514,1963)(1515,1949) > (1516,1965)(1517,1951)(1518,1818)(1520,1674)(1521,1952)(1522,1972) > (1525,1974)(1526,1970)(1529,1977)(1533,1609)(1534,1898)(1537,1583) > (1538,1979)(1541,1981)(1542,1913)(1544,1982)(1546,1975)(1549,1984) > (1551,1679)(1554,1857)(1558,1989)(1560,1994)(1561,1993)(1562,1938) > (1566,1996)(1567,1997)(1570,1998)(1572,1999)(1573,1734)(1574,2000) > (1575,1582)(1577,2002)(1578,2004)(1585,1942)(1586,2010)(1588,2011) > (1589,1594)(1592,1961)(1595,2021)(1599,1819)(1601,1606)(1604,1638) > (1608,1908)(1610,1643)(1612,2034)(1615,2036)(1616,1628)(1619,2008) > (1620,2045)(1621,2042)(1622,2050)(1623,1631)(1624,1632)(1625,2055) > (1627,1780)(1629,2059)(1630,2063)(1634,1930)(1635,1931)(1637,2072) > (1640,2076)(1649,2077)(1652,2079)(1653,1945)(1654,2080)(1657,2081) > (1658,2082)(1660,2084)(1661,2086)(1662,1705)(1664,2087)(1666,2085) > (1667,1902)(1668,1903)(1675,1845)(1676,1686)(1684,1703)(1685,2092) > (1689,1955)(1692,2096)(1695,2043)(1696,2091)(1698,1933)(1702,2099) > (1704,2100)(1706,2101)(1707,2102)(1711,2103)(1725,2107)(1726,2030) > (1729,1987)(1730,1874)(1731,2093)(1733,1894)(1737,2111)(1744,2115) > (1748,2037)(1750,2039)(1751,2117)(1754,2122)(1760,2126)(1764,2129) > (1768,1886)(1769,2132)(1774,2133)(1778,1852)(1781,2134)(1783,2135) > (1789,2016)(1792,2137)(1795,1799)(1796,1928)(1798,2139)(1800,1976) > (1801,2125)(1802,1851)(1803,2024)(1807,1980)(1810,1950)(1812,2114) > (1813,1920)(1822,2146)(1830,2152)(1831,2105)(1834,2136)(1835,2163) > (1839,1846)(1841,1859)(1844,2168)(1849,2170)(1853,2173)(1855,2175) > (1856,2179)(1858,2025)(1860,2184)(1861,2071)(1863,1868)(1864,2067) > (1865,2176)(1869,2171)(1870,2195)(1872,2073)(1876,2199)(1877,2165) > (1878,2003)(1880,2196)(1881,2006)(1882,2007)(1885,2119)(1888,2121) > (1889,2213)(1891,2142)(1892,2141)(1893,2215)(1895,2144)(1897,2161) > (1900,2218)(1901,2220)(1904,2150)(1906,2217)(1907,2029)(1909,1924) > (1912,2147)(1917,2018)(1918,1959)(1923,2130)(1925,1995)(1927,2145) > (1932,2191)(1935,2204)(1936,1957)(1937,2178)(1944,2224)(1954,2222) > (1956,2223)(1960,2233)(1962,2118)(1964,1967)(1966,2185)(1968,2237) > (1969,2090)(1971,2239)(1973,1986)(1978,2031)(1983,2019)(1985,2221) > (1988,2032)(1990,2026)(1991,2028)(1992,2227)(2001,2154)(2005,2253) > (2009,2022)(2012,2097)(2013,2151)(2014,2015)(2017,2023)(2020,2225) > (2027,2075)(2033,2180)(2035,2260)(2038,2058)(2040,2263)(2041,2206) > (2044,2047)(2046,2203)(2048,2054)(2049,2265)(2051,2198)(2052,2066) > (2053,2188)(2056,2194)(2057,2269)(2060,2274)(2061,2201)(2062,2249) > (2064,2271)(2065,2200)(2068,2162)(2069,2259)(2070,2229)(2074,2192) > (2078,2261)(2083,2284)(2088,2283)(2098,2286)(2104,2110)(2106,2109) > (2108,2287)(2112,2235)(2113,2276)(2116,2242)(2120,2252)(2123,2143) > (2124,2254)(2138,2140)(2148,2228)(2149,2244)(2153,2278)(2155,2226) > (2158,2257)(2159,2246)(2160,2258)(2166,2183)(2167,2181)(2169,2255) > (2172,2272)(2174,2294)(2177,2197)(2182,2211)(2186,2281)(2187,2264) > (2189,2193)(2190,2298)(2202,2238)(2205,2256)(2207,2266)(2208,2216) > (2209,2299)(2210,2289)(2212,2268)(2214,2295)(2219,2290)(2230,2292) > (2231,2241)(2232,2240)(2234,2248)(2236,2262)(2243,2247)(2245,2282) > (2250,2277)(2267,2273)(2270,2279)(2275,2280)(2288,2297)(2291,2293) > (2296,2300), ( 2, 21, 26, 27, 11, 22, 39, 15, 5, 3, 8, > 13, 14, 6, 9)( 4, 20, 208, 81, 28, 23, 76, 331, 114, > 223, 222, 278, 559, 194, 19)( 7, 79, 154, 90, 69, 70, 268, > 426, 224, 71, 128, 163, 359, 82, 16)( 10, 36, 95, 215, 648, > 175, 164, 282, 245, 638, 211, 169, 140, 118, 89)( 12, 83, 423, > 273, 168, 33, 34, 195, 352, 121, 127, 286, 546, 283, 72) > ( 17, 48, 147, 365, 196, 53, 54, 424, 943, 431, 134, 98, 102, 210, > 65)( 18, 37, 52, 85, 229, 25, 68, 451, 358, 263, 47, 50, 227, > 180, 172)( 24, 123, 220, 197, 35, 104, 105, 198, 367, 126, 74, > 97, 323, 113, 135)( 29, 30, 261, 489, 264, 67, 51, 66, 297, > 108, 103, 212, 542, 503, 207)( 31, 221, 558, 492, 191, 133, 56, > 322, 499, 217, 40, 93, 174, 440, 173)( 32, 55, 94, 437, 353, > 132, 43, 46, 253, 119, 41, 44, 159, 354, 157)( 38, 64, 86, > 77, 348, 125, 269, 501, 235, 236, 153, 189, 137, 112, 115) > ( 42, 160, 255, 49, 73)( 45, 122, 158, 295, 262, 91, 92, 141, > 111, 166, 96, 167, 100, 161, 230)( 57, 107, 355, 441, 636, 271, > 192, 254, 421, 422, 318, 139, 78, 88, 120)( 58, 59, 288, 190, > 315, 75, 226, 274, 379, 425, 129, 214, 655, 356, 329) > ( 60, 401,1495,1674, 459, 376, 378,1307,1427, 307, 248, 252, 812,1486, > 305)( 61, 162, 136, 326, 213, 143, 328, 234, 420, 267, 206, 170, 181, > 182, 177)( 62, 99, 225, 543, 635, 436, 130, 176, 330, 537, 150, 131, > 287, 289, 200)( 63, 408,1463, 603, 407, 299, 646,1112,1122, 569, 486, > 1294,1055,1364, 341)( 80, 582,1298,1687, 579, 556, 846,1263,1083, > 433, 643, 949,1140,1273, 362)( 84, 308,1025,1780, 857, 279, 460, > 1487, 811, 117, 257, 694,1167,1750, 406)( 87, 344,1702,1699, 776, > 256, 260, 730, 896, 219, 372, 585, 745,1538, 398)( 101, 272, 275, > 138, 319, 368, 294, 415, 450, 500, 357, 545, 442, 165, 285) > ( 106, 311, 627,1345, 673, 659,1233, 797, 814, 204, 399, 838,1335,1350, > 310)( 109, 605, 902, 842, 463, 366, 867, 960,1575, 849, 675, 884, 484, > 883, 599)( 110, 249, 778, 936,1675, 371, 145, 240, 586, 893, 858, 184, > 188, 591, 729)( 116, 606, 860,1798, 787, 683, 757,1113, 980, 581, 577, > 850,1115,1585, 524)( 124, 830,1764,1363, 617, 570, 687, 667, 723, 561, > 575, 855,1314, 897, 239)( 142, 856,1038,1049, 995, 291, 293, 983, 726, > 693, 151, 467,1451,1534, 309)( 144, 149, 417, 505, 325, 270, 316, 493, > 756, 650, 327, 216, 360, 242, 350)( 146, 383,1672,1054, 919, 251, 510, > 870, 961, 889, 660, 513, 772,1088, 894)( 148, 438,1079,1760, 848, 733, > 948, 532,1644, 629, 361, 549, 395,1272, 410)( 152, 185, 598, 572, 878, > 374, 377,1141,1465,1208, 512, 369, 825,1259, 914)( 155, 521,1537,1308, > 384, 238, 402, 485,1116, 968, 183, 737,1379,1098, 446)( 156, 203,1187, > 937, 844, 244, 428,1166,1257, 744, 639, 863,1162, 873, 933) > ( 171, 515,1184,1686, 518, 462, 618,1270, 945, 427, 300, 994, 611, 806, > 644)( 178, 476,1535,1696, 568, 455,1315, 703,1907, 678, 298, 734,1035, > 1526, 469)( 179, 292, 555,1022,1489, 466, 418, 504,1327,1514, 465, > 458,1266,1469, 982)( 186, 397, 590, 998,1789, 620, 218, 363,1395, > 1876, 688, 456, 634,1003, 985)( 187, 445,1080,1283,1390, 864, 228, > 490, 921, 596, 233, 373, 621, 910, 732)( 193, 526, 535,1700, 685, > 468, 392,1349,1276, 434, 567, 387, 595,1578, 630)( 199, 509,1664, > 1235,1685,1202,1698,1218, 820, 821,1697,2088,1158,1652,1074) > ( 201, 686, 494,1781, 866, 276, 475, 922,1726, 771, 382, 939, 742,1047, > 770)( 202, 205, 839,1455, 786, 336, 562, 544,1430, 777, 339,1026, 592, > 1450, 514)( 209, 541,1737, 781,1332,1572, 752,1145,1654, 803,1566, > 1067,1378,1171,1216)( 231, 411,1476,1431, 457, 432, 645, 665,1783, > 565, 564, 754,1768,2116, 548)( 232, 926,1778, 898, 619, 317, 471, > 668,1064, 464, 280, 997,1005, 903, 520)( 237, 386, 381, 900, 785, > 511, 622, 613,1046,1163, 966, 885, 625, 728, 768)( 241,1091, 930, > 616,1347,1143, 739,1292,1011, 746,1121,1370, 491,1053,1056) > ( 243, 563, 874,1394, 284, 444,1401,1280,1118, 487, 306, 661, 840, 862, > 604)( 246, 247, 495, 333, 266)( 250, 304, 996, 931,1533, 454, 380, > 1352,1196,1207, 925, 303, 435,1052,1330)( 258, 340,1164, 713,1291) > ( 259, 396, 938, 847,1268, 674, 430,1277, 958,1536, 338, 461, 502, 920, > 935)( 265,1015,1039, 892, 658, 676, 679,1024,1376, 370, 320, 689,1745, > 1613, 845)( 277, 429,1302,1845,1301)( 281, 337, 779, 534, 917, 571, > 523, 788,1316, 576, 400, 517,1173,1464,1119)( 290, 394, 881,1602, > 419, 566, 684, 637, 915, 677, 375,1008,1199,1206,1278) > ( 296, 990,2214,1948,1916,1548,1807,2064,2189,2172,2190,1634,1454,1633, > 1416)( 301, 302, 631,1743,1457)( 312, 796,1704,1183,1570,1138, 773, > 538, 527,1336,1711,1441,2083,1666, 508)( 313, 859, 602,1252,2098, > 1300, 871,1306,1305,1304,1081,1367, 951, 666, 449)( 314, 573,1312, > 1253, 832, 554, 615,1017,2090,1391,1085,1284, 978,1377, 483) > ( 321, 342, 525,1337,1339, 409, 522,1186,1324,1371, 557, 578, 946, 482, > 1612)( 324,1629,1351,1895,1012,2011,1027,1619,1656,2270,1128,2043, > 2218,2081,1419)( 332,1214,1560,1152,1667,1552,1531,1213,1203, 824, > 1150,1733, 498,1681,1077)( 334, 765, 711,1540,1333,1058,1573,1076, > 1574, 720,1543,1549,1741,1060,1161)( 335, 550, 594,1095, 640, 560, > 875,1605,1231, 343, 516, 780, 600,1751,1165)( 345, 712,1542,1181, > 1201,1657,1658,1156,1157,1683,1210,1279,1051,1653, 540) > ( 346, 901, 574, 583, 391, 607,1180, 837, 624,1010, 741, 950,1086, 626, > 404)( 347, 601,1614,1249, 547,1271, 628, 551,1356,1357, 891,1084, 852, > 1373, 533)( 349,1649, 760, 761,1713,1899,1710,1247,1061, 719,1147, > 1643, 753,1641,1194)( 351, 823, 795, 904,1796, 791, 815,1139, 762, > 763,1195,1706,1211,1212,1248)( 364,1023,1014, 969, 841, 390, 880, > 1599, 653, 774,1185,1178, 789,1355,1317)( 385, 393, 470,1497,1323) > ( 388,1030, 474,1037, 612, 413, 448,1426, 775,1174,1676,1484,1488,1334, > 614)( 389, 861, 836)( 403,1230, 682,1006,1250, 633,1288,1512,1646, > 1812,1197,1191, 979, 879, 833)( 405,1326,1423, 872,1392,1582, 977, > 984,1117, 807, 942,1004,1000, 927, 911)( 412, 882, 707, 918, 843, > 909, 609,1099,1063,1290,1281, 724,1274,1264, 584)( 414, 908,1226, > 888, 731, 913, 886, 725,1577, 940,1309,1361, 743, 706, 923) > ( 416, 784,1188,1200, 809, 967, 769,1429,1282,1222, 642, 767,1297,1310, > 827)( 439, 964, 974,1860,2275,2154,2156,2261,1790, 727,1998,2271,2252, > 2253, 986)( 443, 641, 580,1393,1399,2126,1771,1293,1772,1846,1838, > 1296, 868, 947, 656)( 447,1261,2139,1820,2106,1961,2280,1840,1827, > 831,2040,1787,2241,1900, 671)( 452, 672,1901,1989,2258,1985,1639, > 1694,1527,1986,2109,1506,1127,2004,1844)( 453,1436,1262,2119,2027, > 1102,1926,1382,1383,2289,1824,1624,1621,1019,1444)( 472, 810,1786, > 2124,1637,1930,1842,2283,1973,2092,2185,1130,1135,1408, 496) > ( 473,1885,1586, 792,1232,1045,1673,1258, 588, 552,1421,1472, 899, 589, > 610)( 477,1541,1544,1068,1069, 717, 721, 481, 801,1703,1182, 907,1731, > 1238, 506)( 478,1057, 890, 695,1329,1459,1645,1234,1509,1190,1318, > 479, 608,1496, 699)( 480,1242,1170, 536,2093,1237, 822,1561,2000, > 1567,1740,1553,1554, 716,1075)( 488,2031,1880,2045,2067,2068,2177, > 1850,2018,1595,2010,1475,1021,1132,1452)( 497,1131,2071, 747,2078, > 1941,2017,2046,1340,1912,1655,1413,2117,1106,1136)( 507,1149,1240, > 759,1209,1528,1529,1070,1059, 766,2086,2082,1155,1236,1154) > ( 519, 657,1100, 912,1729)( 528,1709,1692,1511,1251,1110, 632,1325, > 1018, 877,1111,1275,1471,1695, 793)( 529,1198,1708,1510,1177,1223, > 953, 738,1744,1286, 587,1097, 924,1028,1192)( 530,1151,1050,1243, > 1680, 710,1078,1990,1148,1153,1066,1988,1545, 799,1217) > ( 531, 718,1682,1684,1647,1179, 705,1239,1244,1193,1707,1668,1204, 800, > 804)( 539,1241,1734, 817,1976,1555,1547,1160,1205, 802,1073,1648,1718, > 1137,1144)( 553, 835,1319, 709, 851, 829,1104, 929,1346,1267,1142, > 1114, 758,1491, 593)( 597, 906, 623,1477,1354,1366, 941, 740,1013, > 1096, 854, 652,1172,1169,1689)( 647, 681,1679, 783, 853,1776,1775, > 2089,1229, 805,1320, 704, 696,1109,1380)( 649,1630,2230,1805,1439, > 1440,1518,2053,2001,1611,1747,2016,1598,2121,1834)( 651,1403, 955, > 1628,2298,2033, 972,1342,1891,1331,1255,2054,2074, 973, 963) > ( 654, 664,1407,2024,1285,1753,2057,2266,2237,2206,1550,2240,1502,1508, > 1406)( 662, 702,1520,2097,1996,2153,1931,2292,2229,1794,2262,2300, > 2183,2138, 989)( 663,2120,1365,2003,1626,1978,2164, 957,1386,2163, > 2061,1338,1381,2142,1417)( 669,1832,1833,1432,1792,1588,1093,1715, > 1460,2222,1815,1438,2030,1607,1831)( 670, 992, 701,1712,2152,1806, > 1821,1983,2107,1678,1065,1911,2264,1615,1795)( 680,2069,1523,1126, > 1735,1819,2216,2212,2251,1915,1925,1928,1810,1640,1107) > ( 690,2180, 736,1608,1896,2165, 988,1433,1434,1826,2009,1590,2110,1992, > 2221)( 691,1908,1758,1299,1779,1837,1420, 714, 715, 895,1090, 692, > 952,1101, 755)( 697,1221,1723, 735,1108,2193,1348,1927,1904,1742, > 1493,1587,1793,2035,2044)( 698,1428,1062, 813, 798, 790,1485,1265, > 928, 708,1906,1449,1224, 932, 887)( 700,1397,1701,1016,1564,2060, > 1722,1893,2209,2039,2276,1962,1563,1360,1609)( 722,1583, 959, 962, > 1168,1087,1007, 828,1769,1289, 905,1601,1220,1448,1456) > ( 748, 749,1453,1412,2182,1442,1481,1873,1932,2096,1374,2029,2263,2293, > 1862)( 750, 751,1861,1635,1617,2042,1368,1788,1094,1759,1260,1835, > 1632,2278,2192)( 764,1558, 818, 819,1557,1446,1530,1739,1705,1159, > 1546,1717, 816,1730,1662)( 782,1839,1447,1774,1311, 876,1103,1036, > 1029, 808,1372,1120, 999,1048,1175)( 794,1219,1071,1660,1661,2087, > 1663,2284,1665,1651,1246,1146,1568,1569,1642)( 826,1369,1123) > ( 834,2145,1951,1125,1636,1462,1940,1972, 934,1725,2101,2105,2200,2037, > 954)( 865,1777, 869,1295,1671)( 916,1596,1650,2255,2238,1358,1604, > 1997,1040,2244,1868,2259,2032,1864,2143)( 944,2125,1341,1092,1909, > 2080,2227,2111,1515,2108,1228,1562,1618,2157,2036)( 956,1402,2133, > 2265,2094,1714,2135,1521,2052,2134,1579,1580,1920,1405,1849) > ( 965,1761,1400)( 970, 971,1133,1001,1857,2272,2132, 981,2269,2287, > 1727,1917,1919,2256, 987)( 975,1855,1470,1565,2149,1853,2115,1968, > 1225,1801,1859,1002,1478,1443,1044)( 976,1176,2249,1501,1033,1625, > 1875,1414,1882,2118,1784,1763,1852,1479,1480)( 991,2065,1623,2122, > 1581,1817,1589,2198,2282,1603,1913,1967,1969,2215,1724) > ( 993,1923,2297,2159,2225,2226,2217,1517,2294,2171,2210,2211,2295,2181, > 1042)(1009,2148,1752,2161,1921,1867,1938,1816,1993,1803,1359,1227, > 1525,1903,1043)(1020,1902,2273,1606,1638,1791,2034,1886,2002,2155, > 2025,2075,2023,2150,1933)(1031,1957,1934,1892,1836,1841,1404,1851, > 2128,1256,1616,2205,2059,1881,2147)(1032,1215,1799,2021,2239,1422, > 1719,1720,1956,2224,1041,1874,1418,1483,2231)(1034,1677,2103,1939, > 1946,1884,1918,1445,2051,1631,2070,2197,2008,2257,1922) > (1072,1782,2187,2274,2286,2260,2137,1691,1785,1856,1387,1773,1847,2006, > 1287)(1082,1592,2104,1571,1498,1124,2207,1385,1389,1396,1800,1965, > 1129,1254,1766)(1089,1963,1693,2130,1935,1458,1813,2233,2007,1953, > 1825,2254,1966,1854,2191)(1105,1970,1507,1955,2169,1384,1303,1437, > 2268,2299,2079,1949,2091,1425,1971)(1134,1959,1321,2012,1269,1999, > 1818,2136,1492,1905,1659,2247,1435,2058,2072)(1189,2236,2084,2288, > 1482,1500,1503,1559,2141,1593,2201,1879,2195,2250,1504) > (1245,2113,1914,2246,2144,1375,1828,1979,1474,1871,1716,1343,2013,2186, > 2112)(1313,1754,1755,1532,1732,2146,2076,1728,1974,2099,2020,2077, > 2049,1584,1748)(1322,1958,2028,2243,2208,1894,1980,2245,2196,1924, > 2102,2019,1490,1328,1829)(1344,1398,1415,1610,2291,1362,1551,2235, > 2114,1353,1556,2158,2047,1823,1843)(1388,2204,2063,1756,1797,1461, > 1929,1597,2151,1600,2026,2170,1952,1576,2162)(1409,1670,2296,2277, > 1738,2219,2167,2160,2095,1981,1822,2184,2242,2055,1872) > (1410,1977,1950,2179,1878,2194,1863,2176,1765,2129,1883,1945,2234,1519, > 1522)(1411,2056,1877,2203,2066,1770,2228,1688,2127,1942,1984,1524, > 2290,1858,1890)(1424,1804,2123,1762,1848,2232,1994,2166,2248,1499, > 1954,1513,2038,2199,1866)(1466,1960,1690,1937,1910,1814,1494,2022, > 1995,1749,1622,1869,2168,1865,2015)(1467,1505,2048,2279,2267,2175, > 1757,2041,2131,2223,1987,1669,1944,1947,1591)(1468,1594,1811,1473, > 1936,2281,2213,1887,2140,2178,2202,2173,1627,1830,1767) > (1516,1802,1870,2014,1982,2005,2050,2073,1721,2100,2188,2174,1539,1746, > 1736)(1620,1809,2062,2285,2085,1943,1975,1964,1897,1898,2220,1888, > 1889,1991,1808) );; gap> SetName( g, "g" ); gap> DisplayCompositionSeries( g ); Group | Co(2) Group gap> List( ChiefSeriesOfGroup( g ), Size ); [ 42305421312000, 1 ] # $Co_3$ on 276 points gap> g:= Group( > (4,6)(5,10)(7,13)(8,16)(9,11)(12,21)(14,24)(15,27) > (17,29)(20,34)(22,37)(23,40)(25,46)(26,47)(28,44)(31,53) > (33,50)(35,57)(36,59)(38,63)(41,66)(42,45)(43,72)(48,81) > (49,83)(52,89)(54,92)(55,56)(58,99)(60,62)(61,73)(64,109) > (67,112)(68,75)(69,116)(70,78)(71,120)(74,123)(77,102)(82,91) > (84,136)(85,135)(86,138)(87,141)(90,145)(93,151)(94,153)(95,147) > (96,155)(97,149)(98,150)(101,159)(103,127)(104,163)(105,131)(106,165) > (107,167)(110,170)(114,175)(115,130)(117,179)(118,178)(119,129)(121,183) > (124,160)(125,182)(128,161)(133,188)(134,193)(137,196)(139,202)(140,204) > (142,190)(143,208)(146,209)(148,194)(152,216)(154,219)(156,222)(157,215) > (158,205)(162,224)(164,185)(166,226)(171,228)(173,232)(176,177)(180,195) > (181,241)(184,242)(187,244)(191,245)(192,211)(197,250)(198,217)(200,252) > (201,253)(203,256)(206,257)(207,237)(212,249)(213,238)(214,259)(218,240) > (220,263)(221,261)(223,262)(225,235)(229,265)(230,266)(233,243)(236,239) > (246,270)(247,272)(248,271)(251,260)(254,255)(258,269)(268,276)(273,274), > > (4,8)(6,12)(7,14)(9,17)(10,19)(11,20)(13,22)(15,27) > (16,21)(18,31)(23,41)(24,37)(26,32)(28,33)(29,34)(35,54) > (36,50)(39,48)(40,67)(42,69)(43,61)(44,59)(45,77)(46,80) > (49,84)(51,87)(55,94)(56,96)(57,98)(58,93)(60,101)(62,105) > (63,108)(65,110)(66,112)(68,114)(70,118)(71,76)(72,123)(73,74) > (75,104)(78,128)(79,130)(82,117)(83,134)(85,137)(86,139)(88,142) > (89,144)(91,148)(92,150)(95,154)(97,156)(99,157)(102,116)(103,127) > (106,107)(109,169)(111,171)(119,181)(121,126)(122,145)(124,162)(125,132) > (129,187)(131,159)(135,195)(136,193)(138,200)(143,206)(146,211)(147,212) > (149,214)(151,215)(152,176)(153,155)(160,225)(161,178)(163,175)(164,192) > (165,226)(166,167)(168,205)(172,204)(177,238)(179,194)(180,196)(184,189) > (185,209)(186,232)(188,234)(198,223)(199,243)(202,252)(203,220)(207,258) > (208,254)(210,250)(213,216)(217,236)(218,221)(219,249)(222,259)(224,235) > (230,246)(231,253)(237,247)(239,262)(240,248)(241,244)(245,267)(251,266) > (255,257)(256,273)(260,270)(261,271)(263,274)(265,275)(268,276)(269,272), > > (2,4)(3,6)(5,10)(9,13)(12,19)(14,25)(16,27)(17,30) > (20,35)(21,32)(22,38)(23,42)(24,45)(28,49)(29,51)(31,54) > (33,55)(34,56)(36,60)(37,62)(39,65)(40,46)(41,68)(43,71) > (44,75)(48,82)(50,57)(52,64)(53,91)(58,100)(59,63)(61,103) > (66,83)(67,113)(69,117)(70,119)(73,124)(74,106)(76,105)(77,127) > (78,129)(79,131)(80,133)(81,92)(85,86)(87,101)(89,135)(90,146) > (95,97)(96,98)(99,111)(102,160)(104,107)(108,162)(109,138)(110,114) > (112,172)(115,176)(116,177)(118,180)(123,185)(125,164)(128,186)(130,179) > (132,188)(134,194)(137,198)(139,203)(140,158)(141,205)(142,207)(144,161) > (145,209)(148,211)(151,208)(153,216)(154,220)(156,223)(157,196)(159,204) > (165,182)(168,224)(169,199)(170,175)(171,221)(173,230)(174,235)(178,195) > (181,218)(183,242)(189,227)(190,240)(191,247)(192,238)(193,213)(197,215) > (201,254)(202,255)(206,258)(212,236)(214,229)(217,250)(219,262)(222,263) > (225,234)(228,259)(231,268)(233,244)(237,241)(239,269)(245,271)(246,248) > (249,257)(252,260)(253,256)(261,265)(264,274)(267,276)(270,272)(273,275), > > (1,2)(4,9)(6,11)(7,13)(8,17)(12,20)(14,22)(15,27) > (16,29)(21,34)(23,41)(24,37)(26,48)(28,36)(32,39)(33,50) > (35,58)(38,64)(40,66)(42,70)(43,74)(44,59)(45,78)(47,81) > (49,85)(51,88)(54,93)(55,56)(57,99)(60,68)(61,73)(62,75) > (63,109)(65,111)(67,112)(69,118)(71,121)(72,123)(76,126)(77,128) > (82,95)(83,135)(84,137)(86,119)(87,142)(91,147)(92,151)(94,96) > (97,143)(98,157)(101,114)(102,161)(103,127)(104,105)(106,166)(107,167) > (108,169)(110,171)(113,174)(116,178)(117,154)(120,183)(124,162)(125,184) > (129,138)(131,163)(132,189)(133,191)(134,195)(136,196)(139,181)(140,201) > (141,190)(148,212)(149,208)(150,215)(152,217)(153,155)(156,206)(159,175) > (160,224)(165,226)(170,228)(172,231)(173,233)(176,236)(177,239)(179,219) > (180,193)(182,242)(186,199)(187,200)(188,245)(194,249)(198,216)(202,241) > (203,207)(204,253)(213,223)(214,254)(218,221)(220,258)(222,257)(225,235) > (227,264)(230,260)(232,243)(234,267)(237,256)(238,262)(240,261)(244,252) > (246,270)(247,273)(248,271)(251,266)(255,259)(263,269)(268,276)(272,274) > );; gap> SetName( g, "g" ); gap> DisplayCompositionSeries( g ); Group | Co(3) Group gap> List( ChiefSeriesOfGroup( g ), Size ); [ 495766656000, 1 ] # cube gap> g := Group( > (1,3,8,6)(2,5,7,4)(9,48,15,12)(10,47,16,13)(11,46,17,14), > (9,11,26,24)(10,19,25,18)(1,12,33,41)(4,20,36,44)(6,27,38,46), > (12,14,29,27)(13,21,28,20)(6,15,35,26)(7,22,34,19)(8,30,33,11), > (15,17,32,30)(16,23,31,22)(3,43,35,14)(5,45,37,21)(8,48,40,29), > (33,35,40,38)(34,37,39,36)(24,27,30,43)(25,28,31,42)(26,29,32,41), > (41,43,48,46)(42,45,47,44)(1,24,40,17)(2,18,39,23)(3,9,38,32) );; gap> SetName( g, "g" ); gap> DisplayCompositionSeries( g ); Group | Z(2) Group | A(8) ~ A(3,2) = L(4,2) ~ D(3,2) = O+(6,2) Group | Z(3) Group | Z(3) Group | Z(3) Group | Z(3) Group | Z(3) Group | Z(3) Group | Z(3) Group | A(12) Group | Z(2) Group | Z(2) Group | Z(2) Group | Z(2) Group | Z(2) Group | Z(2) Group | Z(2) Group | Z(2) Group | Z(2) Group | Z(2) Group | Z(2) Group gap> List( ChiefSeriesOfGroup( g ), Size ); [ 43252003274489856000, 21626001637244928000, 1072718335180800, 490497638400, 2048, 2, 1 ] # gl10.2 gap> g:= > Group( (257,513)(258,514)(259,515)(260,516)(261,517)(262,518)(263,519) > (264,520)(265,521)(266,522)(267,523)(268,524)(269,525)(270,526) > (271,527)(272,528)(273,529)(274,530)(275,531)(276,532)(277,533) > (278,534)(279,535)(280,536)(281,537)(282,538)(283,539)(284,540) > (285,541)(286,542)(287,543)(288,544)(289,545)(290,546)(291,547) > (292,548)(293,549)(294,550)(295,551)(296,552)(297,553)(298,554) > (299,555)(300,556)(301,557)(302,558)(303,559)(304,560)(305,561) > (306,562)(307,563)(308,564)(309,565)(310,566)(311,567)(312,568) > (313,569)(314,570)(315,571)(316,572)(317,573)(318,574)(319,575) > (320,576)(321,577)(322,578)(323,579)(324,580)(325,581)(326,582) > (327,583)(328,584)(329,585)(330,586)(331,587)(332,588)(333,589) > (334,590)(335,591)(336,592)(337,593)(338,594)(339,595)(340,596) > (341,597)(342,598)(343,599)(344,600)(345,601)(346,602)(347,603) > (348,604)(349,605)(350,606)(351,607)(352,608)(353,609)(354,610) > (355,611)(356,612)(357,613)(358,614)(359,615)(360,616)(361,617) > (362,618)(363,619)(364,620)(365,621)(366,622)(367,623)(368,624) > (369,625)(370,626)(371,627)(372,628)(373,629)(374,630)(375,631) > (376,632)(377,633)(378,634)(379,635)(380,636)(381,637)(382,638) > (383,639)(384,640)(385,641)(386,642)(387,643)(388,644)(389,645) > (390,646)(391,647)(392,648)(393,649)(394,650)(395,651)(396,652) > (397,653)(398,654)(399,655)(400,656)(401,657)(402,658)(403,659) > (404,660)(405,661)(406,662)(407,663)(408,664)(409,665)(410,666) > (411,667)(412,668)(413,669)(414,670)(415,671)(416,672)(417,673) > (418,674)(419,675)(420,676)(421,677)(422,678)(423,679)(424,680) > (425,681)(426,682)(427,683)(428,684)(429,685)(430,686)(431,687) > (432,688)(433,689)(434,690)(435,691)(436,692)(437,693)(438,694) > (439,695)(440,696)(441,697)(442,698)(443,699)(444,700)(445,701) > (446,702)(447,703)(448,704)(449,705)(450,706)(451,707)(452,708) > (453,709)(454,710)(455,711)(456,712)(457,713)(458,714)(459,715) > (460,716)(461,717)(462,718)(463,719)(464,720)(465,721)(466,722) > (467,723)(468,724)(469,725)(470,726)(471,727)(472,728)(473,729) > (474,730)(475,731)(476,732)(477,733)(478,734)(479,735)(480,736) > (481,737)(482,738)(483,739)(484,740)(485,741)(486,742)(487,743) > (488,744)(489,745)(490,746)(491,747)(492,748)(493,749)(494,750) > (495,751)(496,752)(497,753)(498,754)(499,755)(500,756)(501,757) > (502,758)(503,759)(504,760)(505,761)(506,762)(507,763)(508,764) > (509,765)(510,766)(511,767)(512,768), ( 2, 3, 5, 9, 17, 33, > 65, 129, 257, 513)( 4, 7, 13, 25, 49, 97, 193, 385, 769, 514 > )( 6, 11, 21, 41, 81, 161, 321, 641, 258, 515)( 8, 15, 29, > 57, 113, 225, 449, 897, 770, 516)( 10, 19, 37, 73, 145, 289, > 577, 130, 259, 517)( 12, 23, 45, 89, 177, 353, 705, 386, 771, 518 > )( 14, 27, 53, 105, 209, 417, 833, 642, 260, 519)( 16, 31, 61, > 121, 241, 481, 961, 898, 772, 520)( 18, 35, 69, 137, 273, 545, > 66, 131, 261, 521)( 20, 39, 77, 153, 305, 609, 194, 387, 773, 522 > )( 22, 43, 85, 169, 337, 673, 322, 643, 262, 523)( 24, 47, 93, > 185, 369, 737, 450, 899, 774, 524)( 26, 51, 101, 201, 401, 801, > 578, 132, 263, 525)( 28, 55, 109, 217, 433, 865, 706, 388, 775, 526 > )( 30, 59, 117, 233, 465, 929, 834, 644, 264, 527)( 32, 63, 125, > 249, 497, 993, 962, 900, 776, 528)( 34, 67, 133, 265, 529) > ( 36, 71, 141, 281, 561, 98, 195, 389, 777, 530)( 38, 75, 149, > 297, 593, 162, 323, 645, 266, 531)( 40, 79, 157, 313, 625, 226, > 451, 901, 778, 532)( 42, 83, 165, 329, 657, 290, 579, 134, 267, 533 > )( 44, 87, 173, 345, 689, 354, 707, 390, 779, 534)( 46, 91, 181, > 361, 721, 418, 835, 646, 268, 535)( 48, 95, 189, 377, 753, 482, > 963, 902, 780, 536)( 50, 99, 197, 393, 785, 546, 68, 135, 269, 537 > )( 52, 103, 205, 409, 817, 610, 196, 391, 781, 538)( 54, 107, 213, > 425, 849, 674, 324, 647, 270, 539)( 56, 111, 221, 441, 881, 738, > 452, 903, 782, 540)( 58, 115, 229, 457, 913, 802, 580, 136, 271, 541 > )( 60, 119, 237, 473, 945, 866, 708, 392, 783, 542)( 62, 123, 245, > 489, 977, 930, 836, 648, 272, 543)( 64, 127, 253, 505,1009, 994, > 964, 904, 784, 544)( 70, 139, 277, 553, 82, 163, 325, 649, 274, 547 > )( 72, 143, 285, 569, 114, 227, 453, 905, 786, 548)( 74, 147, 293, > 585, 146, 291, 581, 138, 275, 549)( 76, 151, 301, 601, 178, 355, > 709, 394, 787, 550)( 78, 155, 309, 617, 210, 419, 837, 650, 276, 551 > )( 80, 159, 317, 633, 242, 483, 965, 906, 788, 552)( 84, 167, 333, > 665, 306, 611, 198, 395, 789, 554)( 86, 171, 341, 681, 338, 675, > 326, 651, 278, 555)( 88, 175, 349, 697, 370, 739, 454, 907, 790, 556 > )( 90, 179, 357, 713, 402, 803, 582, 140, 279, 557)( 92, 183, 365, > 729, 434, 867, 710, 396, 791, 558)( 94, 187, 373, 745, 466, 931, > 838, 652, 280, 559)( 96, 191, 381, 761, 498, 995, 966, 908, 792, 560 > )( 100, 199, 397, 793, 562)( 102, 203, 405, 809, 594, 164, 327, 653, > 282, 563)( 104, 207, 413, 825, 626, 228, 455, 909, 794, 564) > ( 106, 211, 421, 841, 658, 292, 583, 142, 283, 565)( 108, 215, 429, > 857, 690, 356, 711, 398, 795, 566)( 110, 219, 437, 873, 722, 420, > 839, 654, 284, 567)( 112, 223, 445, 889, 754, 484, 967, 910, 796, 568 > )( 116, 231, 461, 921, 818, 612, 200, 399, 797, 570)( 118, 235, 469, > 937, 850, 676, 328, 655, 286, 571)( 120, 239, 477, 953, 882, 740, > 456, 911, 798, 572)( 122, 243, 485, 969, 914, 804, 584, 144, 287, 573 > )( 124, 247, 493, 985, 946, 868, 712, 400, 799, 574)( 126, 251, 501, > 1001, 978, 932, 840, 656, 288, 575)( 128, 255, 509,1017,1010, 996, > 968, 912, 800, 576)( 148, 295, 589, 154, 307, 613, 202, 403, 805, 586 > )( 150, 299, 597, 170, 339, 677, 330, 659, 294, 587)( 152, 303, 605, > 186, 371, 741, 458, 915, 806, 588)( 156, 311, 621, 218, 435, 869, > 714, 404, 807, 590)( 158, 315, 629, 234, 467, 933, 842, 660, 296, 591 > )( 160, 319, 637, 250, 499, 997, 970, 916, 808, 592)( 166, 331, 661, > 298, 595)( 168, 335, 669, 314, 627, 230, 459, 917, 810, 596) > ( 172, 343, 685, 346, 691, 358, 715, 406, 811, 598)( 174, 347, 693, > 362, 723, 422, 843, 662, 300, 599)( 176, 351, 701, 378, 755, 486, > 971, 918, 812, 600)( 180, 359, 717, 410, 819, 614, 204, 407, 813, 602 > )( 182, 363, 725, 426, 851, 678, 332, 663, 302, 603)( 184, 367, 733, > 442, 883, 742, 460, 919, 814, 604)( 188, 375, 749, 474, 947, 870, > 716, 408, 815, 606)( 190, 379, 757, 490, 979, 934, 844, 664, 304, 607 > )( 192, 383, 765, 506,1011, 998, 972, 920, 816, 608)( 206, 411, 821, > 618, 212, 423, 845, 666, 308, 615)( 208, 415, 829, 634, 244, 487, > 973, 922, 820, 616)( 214, 427, 853, 682, 340, 679, 334, 667, 310, 619 > )( 216, 431, 861, 698, 372, 743, 462, 923, 822, 620)( 220, 439, 877, > 730, 436, 871, 718, 412, 823, 622)( 222, 443, 885, 746, 468, 935, > 846, 668, 312, 623)( 224, 447, 893, 762, 500, 999, 974, 924, 824, 624 > )( 232, 463, 925, 826, 628)( 236, 471, 941, 858, 692, 360, 719, 414, > 827, 630)( 238, 475, 949, 874, 724, 424, 847, 670, 316, 631) > ( 240, 479, 957, 890, 756, 488, 975, 926, 828, 632)( 246, 491, 981, > 938, 852, 680, 336, 671, 318, 635)( 248, 495, 989, 954, 884, 744, > 464, 927, 830, 636)( 252, 503,1005, 986, 948, 872, 720, 416, 831, 638 > )( 254, 507,1013,1002, 980, 936, 848, 672, 320, 639)( 256, 511,1021, > 1018,1012,1000, 976, 928, 832, 640)( 342, 683)( 344, 687, 350, 699, > 374, 747, 470, 939, 854, 684)( 348, 695, 366, 731, 438, 875, 726, > 428, 855, 686)( 352, 703, 382, 763, 502,1003, 982, 940, 856, 688) > ( 364, 727, 430, 859, 694)( 368, 735, 446, 891, 758, 492, 983, 942, > 860, 696)( 376, 751, 478, 955, 886, 748, 472, 943, 862, 700) > ( 380, 759, 494, 987, 950, 876, 728, 432, 863, 702)( 384, 767, 510, > 1019,1014,1004, 984, 944, 864, 704)( 440, 879, 734, 444, 887, 750, > 476, 951, 878, 732)( 448, 895, 766, 508,1015,1006, 988, 952, 880, 736 > )( 480, 959, 894, 764, 504,1007, 990, 956, 888, 752)( 496, 991, 958, > 892, 760)( 512,1023,1022,1020,1016,1008, 992, 960, 896, 768), > ( 257, 769)( 258, 770)( 259, 771)( 260, 772)( 261, 773)( 262, 774) > ( 263, 775)( 264, 776)( 265, 777)( 266, 778)( 267, 779)( 268, 780) > ( 269, 781)( 270, 782)( 271, 783)( 272, 784)( 273, 785)( 274, 786) > ( 275, 787)( 276, 788)( 277, 789)( 278, 790)( 279, 791)( 280, 792) > ( 281, 793)( 282, 794)( 283, 795)( 284, 796)( 285, 797)( 286, 798) > ( 287, 799)( 288, 800)( 289, 801)( 290, 802)( 291, 803)( 292, 804) > ( 293, 805)( 294, 806)( 295, 807)( 296, 808)( 297, 809)( 298, 810) > ( 299, 811)( 300, 812)( 301, 813)( 302, 814)( 303, 815)( 304, 816) > ( 305, 817)( 306, 818)( 307, 819)( 308, 820)( 309, 821)( 310, 822) > ( 311, 823)( 312, 824)( 313, 825)( 314, 826)( 315, 827)( 316, 828) > ( 317, 829)( 318, 830)( 319, 831)( 320, 832)( 321, 833)( 322, 834) > ( 323, 835)( 324, 836)( 325, 837)( 326, 838)( 327, 839)( 328, 840) > ( 329, 841)( 330, 842)( 331, 843)( 332, 844)( 333, 845)( 334, 846) > ( 335, 847)( 336, 848)( 337, 849)( 338, 850)( 339, 851)( 340, 852) > ( 341, 853)( 342, 854)( 343, 855)( 344, 856)( 345, 857)( 346, 858) > ( 347, 859)( 348, 860)( 349, 861)( 350, 862)( 351, 863)( 352, 864) > ( 353, 865)( 354, 866)( 355, 867)( 356, 868)( 357, 869)( 358, 870) > ( 359, 871)( 360, 872)( 361, 873)( 362, 874)( 363, 875)( 364, 876) > ( 365, 877)( 366, 878)( 367, 879)( 368, 880)( 369, 881)( 370, 882) > ( 371, 883)( 372, 884)( 373, 885)( 374, 886)( 375, 887)( 376, 888) > ( 377, 889)( 378, 890)( 379, 891)( 380, 892)( 381, 893)( 382, 894) > ( 383, 895)( 384, 896)( 385, 897)( 386, 898)( 387, 899)( 388, 900) > ( 389, 901)( 390, 902)( 391, 903)( 392, 904)( 393, 905)( 394, 906) > ( 395, 907)( 396, 908)( 397, 909)( 398, 910)( 399, 911)( 400, 912) > ( 401, 913)( 402, 914)( 403, 915)( 404, 916)( 405, 917)( 406, 918) > ( 407, 919)( 408, 920)( 409, 921)( 410, 922)( 411, 923)( 412, 924) > ( 413, 925)( 414, 926)( 415, 927)( 416, 928)( 417, 929)( 418, 930) > ( 419, 931)( 420, 932)( 421, 933)( 422, 934)( 423, 935)( 424, 936) > ( 425, 937)( 426, 938)( 427, 939)( 428, 940)( 429, 941)( 430, 942) > ( 431, 943)( 432, 944)( 433, 945)( 434, 946)( 435, 947)( 436, 948) > ( 437, 949)( 438, 950)( 439, 951)( 440, 952)( 441, 953)( 442, 954) > ( 443, 955)( 444, 956)( 445, 957)( 446, 958)( 447, 959)( 448, 960) > ( 449, 961)( 450, 962)( 451, 963)( 452, 964)( 453, 965)( 454, 966) > ( 455, 967)( 456, 968)( 457, 969)( 458, 970)( 459, 971)( 460, 972) > ( 461, 973)( 462, 974)( 463, 975)( 464, 976)( 465, 977)( 466, 978) > ( 467, 979)( 468, 980)( 469, 981)( 470, 982)( 471, 983)( 472, 984) > ( 473, 985)( 474, 986)( 475, 987)( 476, 988)( 477, 989)( 478, 990) > ( 479, 991)( 480, 992)( 481, 993)( 482, 994)( 483, 995)( 484, 996) > ( 485, 997)( 486, 998)( 487, 999)( 488,1000)( 489,1001)( 490,1002) > ( 491,1003)( 492,1004)( 493,1005)( 494,1006)( 495,1007)( 496,1008) > ( 497,1009)( 498,1010)( 499,1011)( 500,1012)( 501,1013)( 502,1014) > ( 503,1015)( 504,1016)( 505,1017)( 506,1018)( 507,1019)( 508,1020) > ( 509,1021)( 510,1022)( 511,1023)( 512,1024) );; gap> SetName( g, "g" ); gap> DisplayCompositionSeries( g ); Group | A(9,2) = L(10,2) Group gap> List( ChiefSeriesOfGroup( g ), Size ); [ 366440137299948128422802227200, 1 ] # $J_2$ on 100 points gap> g:= Group( (2,3,4,5,6,7,8)(9,10,11,12,13,14,15) > (16,17,18,19,20,21,22)(23,24,25,26,27,28,29)(30,31,32,33,34,35,36) > (37,38,39,40,41,42,43)(44,45,46,47,48,49,50)(51,52,53,54,55,56,57) > (58,59,60,61,62,63,64)(65,66,67,68,69,70,71)(72,73,74,75,76,77,78) > (79,80,81,82,83,84,85)(86,87,88,89,90,91,92)(93,94,95,96,97,98,99), > (1,2,9,16,23,20,30,17)(3,35,13,29,31,24,25,11)(4,26,27,7)(5,21,14,10) > (6,19,32,36)(8,18,28,22,15,12,33,34)(38,92,67,77,99,89,49,84) > (39,59,82,46,88,54,52,68)(40,55,47,81,75,95,61,78) > (41,44,63,58,72,65,50,51)(42,76,53,93,86,80,79,57) > (43,85,48,70,96,83,66,94)(45,97)(56,87)(60,71,91,69,90,73,64,74) > (62,98), > (1,100)(2,74)(3,73)(4,72)(5,78)(6,77)(7,76)(8,75)(9,34)(10,33)(11,32) > (12,31)(13,30)(14,36)(15,35)(16,71)(17,70)(18,69)(19,68)(20,67)(21,66) > (22,65)(23,53)(24,52)(25,51)(26,57)(27,56)(28,55)(29,54)(37,91)(38,90) > (39,89)(40,88)(41,87)(42,86)(43,92)(44,99)(45,98)(46,97)(47,96)(48,95) > (49,94)(50,93)(58,85)(59,84)(60,83)(61,82)(62,81)(63,80)(64,79) );; gap> SetName( g, "g" ); gap> DisplayCompositionSeries( g ); Group | HJ = J(2) = F(5-) Group gap> List( ChiefSeriesOfGroup( g ), Size ); [ 604800, 1 ] # neum on 240 points gap> g:= > Group( ( 3, 8, 6)( 4, 16, 23)( 5, 86,119)( 7, 91,149) > ( 9, 89, 14)( 10,164, 18)( 11, 19, 20)( 12, 74,120)( 13,101, 28) > ( 15, 58, 30)( 17, 45, 35)( 21, 36, 22)( 24, 67, 25)( 26,133, 57) > ( 27,135, 80)( 29,165,136)( 31,177, 32)( 33, 93, 34)( 37, 79, 49) > ( 38, 66, 63)( 39, 92, 55)( 40,114,134)( 41, 68,115)( 42, 51, 43) > ( 44, 84, 46)( 47, 78,116)( 48,159, 70)( 50,175, 75)( 52,211, 53) > ( 54,212,188)( 59,141,142)( 60,129,110)( 61,231,230)( 62,140,139) > ( 64, 72,107)( 65,184,172)( 69,143, 83)( 71,128,195)( 73,122,192) > ( 76,225,228)( 77, 88,170)( 81, 87,137)( 82,227,154)( 85,109,108) > ( 90,173,193)( 94,160,132)( 95, 99,118)( 96,213,148)( 97,218,150) > ( 98,111,127)(100,124,117)(102,229,190)(103,167,138)(104,185,147) > (105,180,174)(106,125,153)(112,113,186)(121,131,126)(123,168,205) > (130,196,233)(144,197,223)(145,146,166)(151,155,152)(156,215,217) > (157,207,187)(158,178,208)(161,226,232)(162,182,171)(163,181,198) > (169,201,176)(179,238,210)(183,191,206)(189,209,236)(194,203,220) > (200,222,221)(202,219,204)(214,224,234)(216,235,240), ( 1, 3, 2) > ( 4,146,151)( 5, 11, 41)( 7, 66,109)( 9, 27, 28)( 10,137,136) > ( 12, 40, 15)( 13, 86, 32)( 14, 85,153)( 16, 26, 17)( 18,129,133) > ( 19,135,114)( 20,108, 73)( 21, 99, 56)( 22, 94, 95)( 23,140, 77) > ( 24,150, 54)( 25,102, 96)( 29, 35, 78)( 30,100,122)( 31, 37,192) > ( 33,190,213)( 34, 97,105)( 36,160,118)( 38, 68, 74)( 39, 60, 65) > ( 42,184, 75)( 43, 62, 59)( 44,115,117)( 45, 92,141)( 46, 80, 79) > ( 47, 69, 88)( 48, 67,212)( 49,106,120)( 50, 71,155)( 51,166,165) > ( 52,148,159)( 53,173,180)( 55, 81,152)( 57,195,113)( 58, 89, 72) > ( 63, 64,177)( 70, 93,174)( 76, 98,182)( 82,161,147)( 83,110,145) > ( 84,107,131)( 87,112,139)( 90,218,229)( 91,134,126)(101,124,149) > (103,104,206)(111,181,228)(116,186,172)(119,121,125)(123,194,157) > (127,223,225)(128,143,142)(130,220,222)(138,154,226)(144,198,171) > (156,234,187)(158,237,236)(162,163,197)(164,170,175)(167,183,185) > (168,221,240)(169,216,217)(176,224,202)(178,189,179)(188,211,193) > (191,227,232)(196,207,215)(199,239,231)(200,201,233)(203,204,214) > (205,219,235)(208,209,210), ( 2, 11, 16)( 3, 17, 15)( 4, 47, 10) > ( 5, 12, 9)( 6, 39, 43)( 7,162,147)( 8, 34, 25)( 13,166,184) > ( 14, 86,118)( 18,126, 19)( 20, 21, 24)( 22, 23, 93)( 26, 28, 27) > ( 29,185,182)( 30, 48, 31)( 32,128, 33)( 35, 36, 42)( 38,187,109) > ( 40, 61, 41)( 44, 73,201)( 45, 53, 78)( 46,112,227)( 49,219,133) > ( 50, 67, 71)( 51,131, 52)( 54,174, 83)( 55, 56, 58)( 57,139,220) > ( 59,170, 60)( 62,231, 63)( 64,199, 65)( 66,189,114)( 68,135,194) > ( 69,156,106)( 70,116,121)( 72,204,209)( 74,111,120)( 75,159, 92) > ( 76,190,154)( 77,210,110)( 79, 80,222)( 81,208,158)( 82,235,228) > ( 84,167,180)( 85,101,107)( 87,232,238)( 88,129,178)( 89, 94,119) > ( 90,229,144)( 91,205,197)( 95, 99,117)( 96,169, 97)( 98,124,160) > (100,127,132)(102,215,103)(104,196,105)(108,145,203)(113,130,191) > (115,237,140)(122,225,155)(123,136,181)(125,233,214)(134,146,157) > (137,179,161)(138,148,149)(141,226,142)(143,153,173)(150,152,186) > (151,163,234)(164,175,177)(165,213,183)(168,218,176)(171,188,224) > (172,236,200)(192,212,223)(193,198,240)(202,221,230)(206,217,216) );; gap> SetName( g, "g" ); gap> DisplayCompositionSeries( g ); Group | A(2,4) = L(3,4) Group | Z(2) Group gap> List( ChiefSeriesOfGroup( g ), Size ); [ 40320, 2, 1 ] # regular gap> g:= PrimitiveGroup( 11, 6 );; gap> elms:= AsList( g );; gap> gens:= Concatenation( List( GeneratorsOfGroup( g ), > x -> [ PermList( List( [ 1 .. 7920 ], > i -> Position( elms, elms[i] * x ) ) ), > PermList( List( [ 1 .. 7920 ], > i -> Position( elms, x^-1 * elms[i] ) ) ) ] ) );; gap> reg:= Group( gens );; gap> SetName( g, "g" ); gap> DisplayCompositionSeries( g ); Group | M(11) Group gap> List( ChiefSeriesOfGroup( g ), Size ); [ 7920, 1 ] gap> # $S_5 \wr S_5$ on 3125 points. gap> l:= [ (1,2,3,4,5), (1,2), (1,6,11,16,21)(2,7,12,17,22)(3,8,13,18,23) > (4,9,14,19,24)(5,10,15,20,25), (1,6)(2,7)(3,8)(4,9)(5,10) ];; gap> tuptonum:= tup -> tup * [ 1, 5, 25, 125, 625 ] - 15430;; gap> numtotup:= function( num ) > local tup,i; > tup:= []; > num:= num-1; > for i in [ 1 .. 5 ] do > tup[i]:= (num mod 5) + 1 + 5*(i-1); > num:= (num - tup[i] + 5*(i-1) + 1)/5; > od; > return tup; > end;; gap> gens:= [];; gap> for j in [ 1 .. 4 ] do > gens[j]:= []; > for i in [ 1 .. 3125 ] do > tup:= numtotup(i); > for k in [ 1 .. 5 ] do > tup[k]:= tup[k]^l[j]; > od; > Sort(tup); > gens[j][i]:=tuptonum(tup); > od; > od; gap> g:= Group( List( gens, PermList ), () );; gap> SetName( g, "g" ); gap> DisplayCompositionSeries( g ); Group | Z(2) Group | Z(2) Group | A(5) ~ A(1,4) = L(2,4) ~ B(1,4) = O(3,4) ~ C(1,4) = S(2,4) ~ 2A(1,4) = U(2,\ 4) ~ A(1,5) = L(2,5) ~ B(1,5) = O(3,5) ~ C(1,5) = S(2,5) ~ 2A(1,5) = U(2,5) Group | Z(2) Group | A(5) ~ A(1,4) = L(2,4) ~ B(1,4) = O(3,4) ~ C(1,4) = S(2,4) ~ 2A(1,4) = U(2,\ 4) ~ A(1,5) = L(2,5) ~ B(1,5) = O(3,5) ~ C(1,5) = S(2,5) ~ 2A(1,5) = U(2,5) Group | Z(2) Group | A(5) ~ A(1,4) = L(2,4) ~ B(1,4) = O(3,4) ~ C(1,4) = S(2,4) ~ 2A(1,4) = U(2,\ 4) ~ A(1,5) = L(2,5) ~ B(1,5) = O(3,5) ~ C(1,5) = S(2,5) ~ 2A(1,5) = U(2,5) Group | Z(2) Group | A(5) ~ A(1,4) = L(2,4) ~ B(1,4) = O(3,4) ~ C(1,4) = S(2,4) ~ 2A(1,4) = U(2,\ 4) ~ A(1,5) = L(2,5) ~ B(1,5) = O(3,5) ~ C(1,5) = S(2,5) ~ 2A(1,5) = U(2,5) Group | Z(2) Group | A(5) ~ A(1,4) = L(2,4) ~ B(1,4) = O(3,4) ~ C(1,4) = S(2,4) ~ 2A(1,4) = U(2,\ 4) ~ A(1,5) = L(2,5) ~ B(1,5) = O(3,5) ~ C(1,5) = S(2,5) ~ 2A(1,5) = U(2,5) Group | A(5) ~ A(1,4) = L(2,4) ~ B(1,4) = O(3,4) ~ C(1,4) = S(2,4) ~ 2A(1,4) = U(2,\ 4) ~ A(1,5) = L(2,5) ~ B(1,5) = O(3,5) ~ C(1,5) = S(2,5) ~ 2A(1,5) = U(2,5) Group gap> List( ChiefSeriesOfGroup( g ), Size ); [ 2985984000000, 1492992000000, 746496000000, 12441600000, 777600000, 1 ] # sol768.gen gap> g:= > Group( ( 1, 4)( 2, 5)( 3, 73)( 9,175, 28,188, 12,172) > ( 10,177,132,221, 13,174)( 11,176, 75,552, 14,173)( 15,166)( 16,168) > ( 17,167)( 18,482)( 19,217)( 20,612)( 21,394, 24,530, 42,164) > ( 22,395, 25,209,141,165)( 23,163, 26,614, 86,388)( 29,436, 43,512, 33, > 186)( 30,619, 47,498, 34,196)( 31,181,424,201,454,184) > ( 32,437,445,622, 35,180)( 36,462,375,185,461,474)( 37,169) > ( 38,178, 39,455,475,182)( 40,489, 41,434,444,191)( 44,528, 51,187,440, > 62)( 45,446,467,415, 57,531)( 46,194,376,527,515, 65)( 48,476, 55,504, > 404,481)( 49, 66, 50, 64, 54, 71)( 52,532,441,192,611, 69) > ( 53, 70,373,193,208, 63)( 56,183, 58,179,435,190)( 59,495, 61,494, 60, > 502)( 67,714,469,508,432,496)( 68,497,189,430,517,422)( 72, 74) > ( 76,219, 87,386,443,218)( 77,662, 92,118,447,598)( 78,213,600,240,648, > 576)( 79,397,110,592, 80,212)( 81,239,607,216,112,486)( 82,170) > ( 83,222,458,214,452,210)( 84,656, 85,223,385,228)( 88,657, 97,220,574, > 116)( 89,523, 98,492,398,591)( 90,234,381,522,580,121) > ( 91,232,584,500,101,499)( 93,226,103,503,413,524)( 94,225,104,505,113, > 661)( 95,160, 96,158,105,162)( 99,493,107,593,114,479) > (100,605,411,231,596,161)(102,126,145,122,146,119)(106,215,108,211,401, > 227)(109,590,115,511,111,408)(117,149,125,377,554,247) > (120,233,389,660,765,159)(123,382,664,763,230,390)(124,148,588,246,595, > 573)(127,550,425,752,448,575)(128,551,142,393,135,249) > (129,556,380,248,154,487)(130,392,133,621,144,157)(131,549,138,623,412, > 597)(134,403,152,750,136,546)(137,171)(139,755,140,643,599,553) > (143,601,147,655,379,156)(150,626,151,606,391,744)(153,501,387,610,155, > 427)(195,471,205,632,275,642)(197,206,266,268,625,261) > (198,293,207,483,200,637)(199,490,263,202,260,635)(203,712,509,269,279, > 711)(204,529,274,267,651,459)(224,609,229,384,518,383) > (235,346,680,348,442,702)(236,699,243,478,748,710)(237,244,352,354,698, > 350)(238,757,747,344,245,603)(241,737,615,340,544,733) > (242,672,488,673,652,353)(250,466,477,506,252,484)(251,259,347,311,400, > 730)(253,257,295,258,297,693)(254,296)(255,306)(256,351) > (262,283,624,620,271,485)(264,287,641)(265,421)(270,280,423,289,405,272 > )(273,277,450,692,281,420)(276,634,282,716,290,653)(278,534,520,713, > 533,525)(284,291,438,706,439,721)(285,374,292,451,638,644) > (286,719,491,288,473,433)(294,715,645)(298,308,312,726,302,307) > (299,666,314,568,303,327)(300,301,725,640,463,304)(305,332,456) > (309,650,310,313,723,318)(315,355,325,417,367,510)(316,322,317,399,326, > 409)(319,756,372,470,557,631)(320,602,361,694,369,410)(321,670,604) > (323,683,519,687,686,608)(324,617,449,671,682,564)(328,370,538,696,732, > 669)(329,378,337,675,331,416)(330,768,753,366,722,762) > (333,558,678,717,742,559)(334,407,341,572,745,419)(335,414,356,613,746, > 583)(336,561,582,758,679,362)(338,342,586,339,359,700) > (343,736,740,728,585,555)(345,365,457)(349,667,639,761,751,707) > (357,571,406)(358,663,690,658,734,541)(360,543,565,676,739,542) > (363,735,371,684,364,418)(368,727,759,743,685,741)(396,514,567,579,566, > 581)(402,513,616,426,545,766)(429,563,691,594,537,535) > (431,704,647,708,720,453)(460,709,464,472,465,636)(468,633,646) > (507,630,526,627,516,654)(521,689,540,539,764,570)(547,677,695,665,697, > 729)(548,560)(562,754,578,674,681,731)(569,659)(577,668,587,738,589, > 760)(618,701,724,688,749,703)(628,767)(649,718,705), ( 1, 9, 85,514, > 38,398, 3, 10,140,513,131, 57)( 2, 11, 41, 67,452,107) > ( 4,516,310,590,328,195)( 5,535,353,495,284,372, 73,521,459,610,362, > 236)( 6,394,453,343,249,746, 7,163,562,293,218,282)( 8,395,741,344, > 186,361)( 12, 46, 91,611,497, 93, 14,120,377,573,382, 48) > ( 13, 90,373,596,383, 94)( 15,469, 89,127,454,447, 16,579, 45, 78,448, > 34)( 17,426,114, 31,648,130)( 18,103,380,247,149, 39) > ( 19, 55,607,208,101,138, 20,104,375,584, 53, 83)( 21,422,153,128, 51, > 81, 22,390, 60, 76,147, 36)( 23,384,111, 29, 97,129)( 24, 98,379,246, > 146, 40)( 25,467,574,441, 96,139, 26, 99,440,411, 50, 84) > ( 27,250,116,374,307,123, 74,251, 62,735,197, 68)( 28,387,132, 59) > ( 30,112,137,151, 33,413,133,154, 82, 58,443,113)( 32, 87,141,412, 35, > 155,134,142, 86,475, 80,115)( 37,108,135,404, 77,461)( 42,458,136, 61, > 79, 43)( 44, 92,580, 54,376,385)( 47,515,105,389,599,143,144,765,102, > 381,444, 88)( 49,106)( 52,432,401,445,600,763)( 56, 95,150,145) > ( 63,460,520,118,273,568)( 64,670,699,121,764,269,158,571,471, 65,526, > 564)( 66,438,421,194,705,534,160,538,255,233,703,683)( 69,317,267,175, > 320,652,124,450,309,177,276,650)( 70,708,466,517,720,633,499,743,258, > 229,685,665)( 71,322,266,169,325,457,126,277,308,171,280,456) > ( 72,295,156,378,237,518)( 75,109)(100,766,391,152,425,609,148,581,435, > 110,424,430)(117,360,690,498,316,485,500,589,519,157,338,235) > (119,645,470,159,594,340)(122,561,256,234,724,663)(125,681,259,230,731, > 547)(161,586,673,176,356,651)(162,342,352,170,745,641) > (164,355,541,588,583,509)(165,572,608,532,694,615,388,270,525,605,716, > 682)(166,684,243,180,719,303,168,675,205,212,768,262)(167,451,557,546, > 742,346)(172,602,238,178,647,305,174,613,200,210,759,264) > (173,634,728,549,674,345)(179,718,265,598,669,241)(181,706,506,386,559, > 245)(182,367,348,462,628,327)(183,428,740,224,366,490,215,629,483,189, > 288,463)(184,371,349,455,630,726)(185,627,756,545,370,274,216,570,642, > 508,291,318)(187,654,319,755,406,686,655,429,748,489,604,734) > (188,439,304,567,722,268)(190,510,323,505,727,204,227,405,278,503,578, > 242)(191,649,484,492,638,298)(192,418,620,240,678,478,595,416,442,201, > 433,631)(193,417,529,223,542,737,554,419,672,434,636,671) > (196,721,449,606,701,306,392,679,203,211,749,351)(198,530,363,347,402, > 540)(199,397,653,646,501,739,639,437,410,697,408,587)(202,592,760,296, > 494,369,707,750,543,254,511,335)(206,228,688,730,415,364,244,553,618, > 257,493,331)(207,213,582,693,512,491,736,550,696,311,393,753) > (209,285,477,496,507,555,614,329,297,396,563,747)(214,289,299,556,560, > 680,597,334,624,239,659,283)(217,577,350,660,668,365,612,565,261,527, > 472,332)(219,569,279,486,420,713)(220,689,275,656,294,533) > (221,732,751,616,558,354,552,758,263,714,473,312)(222,539,625,576,292, > 301,623,691,698,575,337,260)(225,692,468,591,272,252,226,339,695,593, > 341,400)(231,644,666,752,762,632)(232,423,723,643,738,712) > (248,537,710,566,336,488)(253,476,399,729,531,315)(271,524,359,711,657, > 754)(281,617,601,368,702,481,326,733,528,431,314,661)(286,725,479,715, > 585,621,717,667,446,321,757,619)(287,482,464,302,522,676) > (290,300,622,709,480,427)(313,744,407,358,504,704)(324,487,700,658,551, > 548,544,474,409,687,436,767)(330,635,523,357,637,662)(333,761,626,536, > 603,664)(403,414,677,502,465,640) );; gap> SetName( g, "g" ); gap> DisplayCompositionSeries( g ); Group | Z(2) Group | Z(3) Group | Z(2) Group | Z(2) Group | Z(2) Group | Z(3) Group | Z(3) Group | Z(3) Group | Z(2) Group | Z(2) Group | Z(2) Group | Z(2) Group | Z(2) Group | Z(2) Group | Z(2) Group | Z(3) Group | Z(3) Group | Z(3) Group | Z(3) Group | Z(3) Group | Z(3) Group | Z(3) Group | Z(3) Group gap> List( ChiefSeriesOfGroup( g ), Size ); [ 1088391168, 544195584, 181398528, 45349632, 22674816, 2519424, 839808, 13122, 6561, 1 ] # $Suz$ on 1782 points gap> g:= > Group( ( 2, 3)( 8, 14)( 9, 15)( 11, 17)( 13, 24) > ( 16, 25)( 18, 31)( 20, 28)( 23, 40)( 26, 29)( 27, 43) > ( 30, 54)( 32, 57)( 35, 48)( 36, 64)( 38, 68)( 39, 69) > ( 42, 49)( 44, 50)( 45, 77)( 46, 72)( 47, 73)( 51, 87) > ( 52, 91)( 53, 93)( 55, 96)( 56, 97)( 58, 101)( 60, 80) > ( 61, 81)( 62, 106)( 63, 109)( 65, 111)( 67, 114)( 71, 82) > ( 74, 84)( 75, 85)( 76, 124)( 78, 120)( 79, 119)( 86, 133) > ( 88, 138)( 89, 140)( 90, 144)( 92, 147)( 94, 149)( 95, 150) > ( 98, 125)( 99, 155)( 100, 158)( 102, 160)( 104, 129)( 105, 164) > ( 107, 166)( 108, 168)( 110, 170)( 113, 174)( 115, 171)( 118, 130) > ( 121, 131)( 122, 182)( 123, 183)( 126, 178)( 127, 187)( 128, 177) > ( 132, 191)( 134, 153)( 135, 195)( 136, 198)( 137, 201)( 139, 203) > ( 141, 204)( 142, 208)( 143, 210)( 145, 213)( 146, 214)( 148, 217) > ( 151, 184)( 154, 223)( 156, 225)( 157, 227)( 159, 229)( 162, 189) > ( 163, 233)( 165, 235)( 167, 239)( 169, 241)( 172, 244)( 173, 246) > ( 175, 242)( 179, 251)( 180, 190)( 181, 254)( 185, 249)( 186, 260) > ( 188, 248)( 192, 220)( 193, 267)( 194, 270)( 196, 273)( 197, 275) > ( 199, 277)( 200, 279)( 202, 281)( 205, 285)( 206, 283)( 207, 288) > ( 209, 292)( 211, 295)( 212, 296)( 215, 282)( 216, 256)( 218, 257) > ( 222, 306)( 224, 308)( 226, 311)( 228, 313)( 230, 315)( 231, 263) > ( 232, 319)( 234, 321)( 236, 299)( 237, 325)( 238, 328)( 240, 331) > ( 243, 334)( 245, 336)( 247, 332)( 250, 342)( 252, 264)( 253, 347) > ( 255, 343)( 258, 340)( 259, 355)( 261, 357)( 262, 359)( 265, 303) > ( 266, 363)( 268, 366)( 269, 368)( 271, 371)( 272, 365)( 274, 374) > ( 276, 376)( 278, 380)( 280, 382)( 284, 387)( 286, 385)( 287, 391) > ( 289, 377)( 290, 344)( 291, 397)( 293, 401)( 294, 402)( 297, 383) > ( 298, 349)( 300, 384)( 301, 409)( 305, 413)( 307, 415)( 309, 418) > ( 310, 422)( 312, 425)( 314, 427)( 316, 429)( 317, 432)( 318, 435) > ( 320, 438)( 322, 405)( 323, 442)( 324, 446)( 326, 449)( 327, 450) > ( 329, 453)( 330, 448)( 333, 458)( 335, 461)( 337, 462)( 338, 455) > ( 339, 456)( 341, 468)( 345, 472)( 346, 474)( 348, 469)( 350, 372) > ( 351, 394)( 352, 481)( 353, 466)( 354, 485)( 356, 487)( 358, 426) > ( 360, 491)( 361, 493)( 362, 495)( 364, 498)( 367, 500)( 369, 503) > ( 370, 497)( 373, 507)( 375, 509)( 378, 513)( 379, 516)( 381, 519) > ( 386, 524)( 388, 527)( 389, 483)( 390, 530)( 392, 510)( 393, 470) > ( 395, 408)( 396, 536)( 398, 540)( 399, 538)( 400, 543)( 403, 520) > ( 404, 476)( 406, 521)( 407, 551)( 411, 554)( 412, 557)( 414, 560) > ( 416, 563)( 417, 567)( 419, 570)( 420, 573)( 421, 575)( 423, 578) > ( 424, 569)( 428, 583)( 430, 586)( 431, 588)( 433, 593)( 434, 594) > ( 436, 597)( 437, 591)( 439, 546)( 440, 604)( 441, 608)( 443, 611) > ( 444, 596)( 445, 614)( 447, 617)( 451, 620)( 452, 616)( 454, 618) > ( 457, 492)( 459, 627)( 460, 626)( 463, 631)( 464, 632)( 465, 471) > ( 467, 638)( 473, 643)( 475, 639)( 477, 504)( 478, 533)( 479, 580) > ( 480, 653)( 482, 656)( 484, 659)( 486, 662)( 488, 582)( 489, 666) > ( 490, 667)( 494, 673)( 496, 676)( 501, 679)( 502, 675)( 505, 683) > ( 506, 686)( 508, 689)( 511, 692)( 512, 561)( 514, 696)( 515, 610) > ( 517, 698)( 518, 562)( 522, 703)( 523, 705)( 525, 708)( 526, 711) > ( 528, 714)( 529, 715)( 531, 690)( 532, 640)( 534, 550)( 535, 706) > ( 537, 725)( 539, 727)( 541, 635)( 542, 731)( 544, 728)( 545, 645) > ( 547, 700)( 548, 701)( 549, 741)( 552, 744)( 553, 748)( 555, 752) > ( 556, 753)( 558, 756)( 559, 750)( 564, 764)( 565, 598)( 566, 768) > ( 568, 771)( 572, 777)( 574, 779)( 576, 781)( 577, 770)( 579, 772) > ( 581, 785)( 584, 787)( 585, 791)( 587, 795)( 589, 796)( 590, 799) > ( 592, 801)( 595, 805)( 599, 802)( 600, 733)( 601, 710)( 602, 707) > ( 603, 815)( 605, 818)( 606, 806)( 607, 822)( 609, 825)( 612, 804) > ( 613, 829)( 615, 831)( 619, 830)( 621, 832)( 622, 833)( 623, 834) > ( 624, 840)( 625, 841)( 628, 842)( 629, 827)( 630, 843)( 633, 852) > ( 634, 849)( 636, 855)( 637, 856)( 641, 860)( 642, 861)( 644, 862) > ( 646, 680)( 647, 859)( 648, 718)( 649, 746)( 650, 760)( 651, 873) > ( 652, 759)( 654, 876)( 655, 877)( 657, 702)( 658, 881)( 660, 878) > ( 661, 886)( 663, 786)( 664, 755)( 665, 890)( 668, 895)( 669, 898) > ( 670, 899)( 672, 903)( 674, 905)( 678, 907)( 681, 912)( 682, 814) > ( 684, 917)( 685, 824)( 687, 919)( 688, 762)( 691, 743)( 693, 925) > ( 694, 926)( 695, 927)( 697, 929)( 699, 928)( 704, 937)( 709, 942) > ( 712, 946)( 713, 947)( 716, 948)( 717, 858)( 719, 921)( 720, 737) > ( 721, 722)( 723, 961)( 724, 962)( 726, 965)( 729, 932)( 730, 970) > ( 732, 971)( 734, 968)( 735, 969)( 736, 980)( 738, 933)( 739, 934) > ( 740, 987)( 742, 788)( 745, 994)( 747, 897)( 749, 998)( 751,1000) > ( 754,1003)( 757, 766)( 758,1001)( 761,1009)( 763,1011)( 767,1015) > ( 769,1017)( 775,1023)( 776,1024)( 778,1026)( 780,1016)( 782,1018) > ( 783,1019)( 784,1032)( 789,1034)( 790,1013)( 792,1039)( 793,1042) > ( 794,1043)( 797,1046)( 798,1047)( 800,1050)( 803,1055)( 807,1048) > ( 808,1052)( 809,1053)( 810, 943)( 811,1065)( 812,1066)( 813,1069) > ( 816,1073)( 817,1074)( 820,1056)( 821,1081)( 823,1082)( 826,1075) > ( 828,1086)( 835,1088)( 836,1089)( 837,1090)( 838, 944)( 839,1091) > ( 844,1033)( 845,1079)( 846,1099)( 847,1101)( 848,1106)( 850,1109) > ( 851,1111)( 853,1113)( 854,1114)( 857,1115)( 863,1116)( 864,1127) > ( 865,1128)( 866,1135)( 867, 909)( 868,1122)( 869, 955)( 870, 990) > ( 871,1140)( 872,1141)( 874,1031)( 875,1144)( 879,1151)( 880,1152) > ( 882,1145)( 883,1154)( 884,1149)( 885,1160)( 887,1004)( 888,1163) > ( 889,1164)( 891,1165)( 892, 894)( 893,1098)( 896, 959)( 902,1178) > ( 904,1179)( 906,1181)( 908, 924)( 910, 991)( 911,1063)( 913,1187) > ( 914,1068)( 915,1189)( 916,1190)( 918,1192)( 920,1191)( 922,1197) > ( 923, 988)( 930,1199)( 931,1198)( 935,1208)( 936,1209)( 938,1210) > ( 939,1213)( 940,1214)( 941,1136)( 945,1219)( 949,1195)( 950,1220) > ( 951,1118)( 952,1224)( 953,1225)( 954,1234)( 956,1196)( 957, 981) > ( 958,1240)( 960,1242)( 963,1243)( 964, 967)( 966,1248)( 972,1260) > ( 973,1257)( 974,1258)( 975,1265)( 976,1254)( 977,1270)( 978,1085) > ( 979,1273)( 982,1279)( 983,1206)( 984,1100)( 985,1207)( 986,1237) > ( 989,1020)( 992,1287)( 993,1288)( 995,1291)( 996,1292)( 997,1293) > ( 999,1296)(1002,1300)(1005,1294)(1006,1298)(1007,1027)(1008,1305) > (1010,1307)(1012,1306)(1014,1289)(1022,1035)(1025,1314)(1028,1310) > (1029,1311)(1030,1255)(1036,1319)(1037,1320)(1038,1078)(1040,1326) > (1041,1327)(1044,1051)(1045,1328)(1049,1334)(1054,1338)(1057,1330) > (1058,1332)(1059,1333)(1060,1076)(1061,1336)(1062,1217)(1064,1349) > (1070,1355)(1071,1356)(1072,1357)(1080,1361)(1083,1095)(1084,1096) > (1087,1329)(1092,1365)(1093,1366)(1094,1218)(1097,1227)(1102,1379) > (1103,1174)(1104,1171)(1105,1384)(1107,1386)(1108,1387)(1110,1388) > (1112,1390)(1117,1392)(1119,1393)(1120,1394)(1121,1403)(1123,1147) > (1124,1126)(1125,1173)(1129,1416)(1130,1419)(1131,1412)(1132,1424) > (1133,1414)(1134,1428)(1137,1404)(1138,1236)(1139,1431)(1142,1432) > (1143,1148)(1146,1441)(1150,1271)(1153,1447)(1155,1439)(1156,1158) > (1157,1457)(1159,1460)(1161,1461)(1162,1464)(1166,1376)(1167,1466) > (1168,1377)(1169,1374)(1170,1375)(1172,1473)(1175,1477)(1177,1479) > (1180,1186)(1182,1481)(1183,1346)(1184,1368)(1185,1284)(1188,1484) > (1193,1485)(1194,1483)(1200,1308)(1201,1343)(1202,1304)(1203,1435) > (1204,1499)(1205,1502)(1211,1448)(1212,1508)(1215,1511)(1216,1223) > (1221,1350)(1222,1506)(1226,1519)(1228,1530)(1229,1533)(1230,1525) > (1231,1538)(1232,1520)(1233,1542)(1235,1546)(1238,1491)(1239,1276) > (1241,1552)(1244,1554)(1245,1555)(1246,1556)(1247,1563)(1249,1256) > (1250,1564)(1251,1565)(1252,1425)(1253,1462)(1259,1532)(1261,1580) > (1262,1575)(1263,1582)(1264,1509)(1266,1584)(1267,1536)(1268,1363) > (1269,1274)(1272,1586)(1275,1588)(1277,1589)(1278,1562)(1280,1503) > (1281,1318)(1282,1548)(1283,1587)(1285,1590)(1286,1591)(1290,1297) > (1295,1492)(1299,1570)(1301,1594)(1302,1597)(1303,1598)(1309,1372) > (1313,1321)(1315,1606)(1316,1504)(1317,1572)(1322,1610)(1323,1352) > (1324,1360)(1325,1613)(1331,1617)(1335,1359)(1337,1524)(1339,1615) > (1340,1616)(1341,1358)(1342,1618)(1344,1539)(1345,1609)(1347,1627) > (1348,1480)(1353,1629)(1354,1630)(1362,1369)(1364,1614)(1367,1397) > (1370,1633)(1371,1518)(1373,1527)(1378,1642)(1380,1644)(1381,1472) > (1382,1649)(1383,1652)(1385,1654)(1389,1655)(1391,1653)(1395,1663) > (1396,1658)(1398,1456)(1399,1422)(1400,1660)(1401,1668)(1402,1498) > (1405,1442)(1406,1443)(1407,1662)(1408,1474)(1409,1475)(1410,1415) > (1411,1559)(1413,1676)(1417,1426)(1418,1679)(1420,1681)(1421,1684) > (1423,1476)(1427,1568)(1429,1526)(1430,1547)(1433,1689)(1434,1592) > (1436,1687)(1437,1688)(1438,1693)(1440,1540)(1444,1500)(1445,1450) > (1446,1571)(1449,1694)(1451,1529)(1452,1455)(1453,1458)(1454,1700) > (1459,1702)(1463,1705)(1465,1596)(1467,1638)(1468,1707)(1469,1639) > (1470,1636)(1471,1637)(1478,1718)(1482,1635)(1486,1604)(1487,1622) > (1488,1620)(1489,1722)(1490,1726)(1493,1605)(1494,1573)(1495,1514) > (1496,1600)(1497,1599)(1501,1603)(1505,1507)(1510,1667)(1512,1551) > (1513,1714)(1515,1733)(1516,1734)(1517,1737)(1521,1730)(1522,1731) > (1523,1680)(1528,1739)(1531,1717)(1534,1576)(1535,1632)(1537,1543) > (1541,1696)(1544,1741)(1545,1743)(1549,1558)(1550,1656)(1553,1685) > (1557,1648)(1560,1736)(1561,1746)(1566,1692)(1567,1645)(1569,1704) > (1574,1748)(1577,1701)(1578,1669)(1579,1754)(1581,1756)(1583,1695) > (1585,1758)(1593,1686)(1595,1720)(1601,1760)(1602,1755)(1607,1611) > (1608,1728)(1612,1628)(1619,1690)(1621,1763)(1623,1631)(1624,1761) > (1626,1719)(1634,1664)(1640,1682)(1641,1769)(1643,1677)(1646,1713) > (1647,1703)(1650,1651)(1657,1715)(1659,1683)(1661,1698)(1665,1699) > (1666,1742)(1670,1768)(1671,1774)(1672,1711)(1673,1675)(1674,1776) > (1678,1727)(1691,1759)(1697,1738)(1706,1750)(1708,1753)(1709,1778) > (1710,1773)(1712,1757)(1716,1777)(1723,1729)(1724,1765)(1725,1764) > (1732,1775)(1735,1747)(1740,1752)(1744,1749)(1745,1772)(1751,1779) > (1770,1771), ( 1, 5, 39, 386, 390, 490, 688, 452, 414, 315, 800, > 902, 628, 823, 557, 448, 245, 709, 205, 51, 11)( 3, 73, 640, > 715, 644,1750, 792, 756,1131, 409, 144, 439,1318, 836, 226,1260,1394, > 734, 182, 31, 6)( 4, 34, 128, 717,1604, 722,1341,1627,1009, 232, > 461,1136,1501,1640, 834,1409, 973, 171, 550, 30, 42)( 7, 257, 219, > 260, 680, 659, 732,1089, 766,1256, 857,1671, 703, 600, 878,1531,1457, > 1741,1266, 977, 52)( 8, 69, 259, 824, 574, 625, 880,1072, 993, > 608, 569, 316, 940, 338, 605,1178, 960,1064, 757, 156, 20) > ( 9, 22, 532, 421,1244,1381,1559,1335, 465,1099, 714,1436, 667, 602, > 1389, 966,1752,1638, 430, 111, 29)( 10, 15, 47, 82, 356, 718, > 881, 623, 979, 971,1736,1442, 666, 762, 919,1484, 925, 352,1051,1231, > 89)( 12, 393, 274, 929, 725, 885, 809, 736,1392,1776, 870, 892, 566, > 1203, 984,1774,1161, 802, 952, 251, 90)( 13, 132, 113, 575, 633, > 598, 107)( 14, 61, 162, 450, 568, 482, 433,1477, 872, 293, 624, > 822, 770,1080, 997, 784, 704,1184, 380, 196, 56)( 16, 118, 103, > 805,1294,1474, 631, 607, 578,1410,1713, 649,1433,1468,1058, 305, 583, > 1066,1333, 783, 99)( 17, 81, 70, 114, 247, 610, 329, 555,1324, > 1482, 695,1038,1518, 761,1479, 992, 507, 268, 145, 48, 41) > ( 18, 130, 486,1281,1706,1400, 408)( 19, 79, 192, 178, 509,1549, > 1737,1084, 172,1195,1255,1378,1502, 359,1017,1252,1513, 343, 63, 220, > 141)( 21, 498, 475, 685,1319,1304, 899, 701,1695,1561, 621,1355, 926, > 1696,1337, 982, 682,1465,1173,1643, 458)( 23, 284, 86, 67, 374, > 272, 165)( 24, 148, 189, 523, 936, 346,1045,1626, 906, 195, 224, > 35, 104, 227, 918,1607, 694, 726, 400, 935, 142)( 25, 218, 185, > 1314,1062, 742,1174, 957,1703, 588,1623,1767,1027,1739,1085, 866,1402, > 1380,1100, 622, 62)( 26, 265, 249, 781,1565, 891,1757, 799, 309, > 1101,1264,1149, 785,1670,1692, 728,1606, 827, 584, 967, 377) > ( 27, 49, 303, 206, 161,1082,1302, 494,1146,1421,1598, 987,1440,1664, > 1274,1382,1336,1406, 864, 147, 154)( 28, 176, 341, 753, 616, 999, > 1177, 518, 330, 65, 32, 116, 174, 658,1041, 422, 665, 806, 312, 730, > 92)( 33, 308, 295, 434,1464, 896, 846, 445,1725, 692,1361, 691,1163, > 1650,1254, 604, 863,1738,1129,1545, 358)( 36, 153, 75, 662,1430, > 683, 774, 611,1233, 862,1742,1374, 942,1157,1678,1063,1164,1473,1102, > 1710, 808)( 37, 676,1207,1095,1012, 399, 920,1248, 893, 444,1036, > 1345, 930,1220,1446, 262,1015, 472, 344, 254, 54)( 38, 275, 502, > 778, 724, 798,1718, 924, 804, 763, 673, 851,1013, 328, 419, 634, 122, > 223, 375, 777, 335)( 40, 186, 368, 595, 755, 888, 812,1182, 460,1033, > 767, 636, 337, 596, 564, 101, 271, 95, 129, 76, 207)( 43, 470, 347, > 340,1595, 842,1216,1634,1340,1068,1761, 499, 890,1768,1338, 536,1614, > 1204,1423, 384, 105)( 44, 487, 720, 985,1758,1753, 586, 449, 954, > 1115,1732,1672,1777,1701,1633,1079,1512,1646,1544, 215, 510) > ( 45, 123, 287, 246, 945, 463, 80)( 46, 134, 53, 71, 59, 415, > 856, 544,1699,1259,1243,1475,1271,1253,1196,1147,1560, 710, 453,1019, > 314)( 50, 119, 476, 530,1754,1251,1581,1667, 933, 601, 336, 388,1686, > 1746,1663,1416,1532,1439,1190, 136, 170)( 55, 83, 94, 117, 250, > 495, 754, 845, 687,1478, 514,1112, 459, 712, 797,1347,1020, 239, 443, > 64, 110)( 57, 191, 391, 556,1111,1213,1685,1401, 120, 376, 403,1404, > 491,1771,1438, 909,1227,1375, 801,1537, 350)( 58, 298, 157,1118, > 976, 394, 242, 737, 258,1622, 772,1114,1444,1659,1711,1059, 813,1609, > 571, 825,1006)( 60, 158, 369, 467,1110,1008,1325, 567, 139, 201, 675, > 1025,1070,1625, 874, 319, 830, 889,1078, 573, 428)( 66,1003,1422, > 548,1516,1662, 735,1575,1093,1635,1781, 378,1653, 963,1138, 814,1176, > 931, 135, 98, 93)( 68, 175, 168, 697,1175, 267, 364, 211, 263, 713, > 944, 435, 424, 102, 212, 253, 594, 577, 674, 875, 489)( 72, 349, 133, > 288, 362, 883,1534,1061, 84, 235, 150, 342, 143, 112,1307,1414,1316, > 1775, 938, 833, 243)( 74, 229, 180, 620,1311, 612,1322,1624, 699, > 1125,1769,1644,1572,1328,1005, 479, 261, 533, 332,1547,1132) > ( 77, 302, 355,1280,1760,1242,1432,1092, 310,1391,1167,1510,1407,1472, > 585, 560,1450,1687, 795,1230, 300)( 78, 281, 700, 572, 964,1569,1159) > ( 85, 177, 951,1676,1602,1759, 660,1272,1454, 292,1448,1498,1702,1039, > 1011,1128, 839, 214, 406, 124, 221)( 87, 183, 304, 204, 184, 152, > 217, 468, 466,1720,1240,1592,1571, 986,1142, 955,1397,1587,1043, 471, > 256)( 88, 371, 741, 353,1620,1719, 927)( 91, 322, 648, 776,1765, > 561,1077, 519, 656,1279, 837,1371,1782, 512, 972, 599, 291,1689,1107, > 1236,1262)( 96, 387, 520, 483,1617,1197, 898,1044, 716,1668,1155, > 455,1460,1458,1726, 535,1334,1288, 541, 299, 477)( 97, 149, 524, > 1558,1310, 961,1636,1419, 739,1690,1104, 947, 395, 469, 108, 858,1156, > 1637, 593, 323, 166)( 100, 404, 327,1596,1428, 456, 831,1497, 481, > 1194, 193, 405, 646, 485,1700, 969,1594,1250, 838, 396, 216) > ( 106, 159, 294, 529,1186, 629, 850, 941, 996,1035, 473, 360, 437, 326, > 537, 146, 181, 306, 576, 939, 587)( 109, 169, 354, 816,1323,1762, 989, > 464, 590,1611,1007, 427, 769, 654, 592, 539,1218, 516, 240, 641, 115) > ( 121, 313, 389,1483,1305,1054, 953,1424, 884, 285, 383, 190,1026, 397, > 1487,1309, 230,1350,1083, 552, 160)( 125, 410, 283, 886,1723,1443, > 1540,1339, 412,1086, 998, 488, 829, 752, 441, 425,1520,1704,1398,1463, > 140)( 126, 382,1282,1434, 255, 194, 151)( 127, 270, 307, 231, 614, > 381,1313, 563, 780, 904,1353,1766, 693, 138, 497, 280,1024,1014, 854, > 817, 642)( 131, 321, 638,1577,1246,1494,1453,1533,1553,1586,1121,1120, > 1751,1119, 208, 266, 546,1503, 426,1223, 282)( 137, 503,1491,1030, > 1666,1500, 351)( 155, 276, 233, 451, 749,1321, 745)( 163, 248,1221, > 1683,1618, 554, 847,1511,1717, 835,1629, 696, 865,1747,1680, 868,1368, > 914, 677, 203, 521)( 164, 228, 484,1348,1004, 508,1022, 325, 436, 559, > 447,1354,1023, 542, 913, 198, 370, 234, 173, 768, 199)( 167,1116,1705, > 1370,1141,1127, 937,1342,1299,1232,1601, 672,1722, 513,1021, 570,1228, > 1418, 603,1312,1202)( 179, 363, 496, 637,1286, 686, 501, 655, 684, > 958, 811, 334, 615,1188, 907,1241,1071,1612,1780,1181, 651) > ( 187, 504, 402,1548,1526,1578,1661, 522,1193,1605, 820,1295, 663,1514, > 1258,1708,1654,1042, 579, 841,1212)( 188, 949,1437,1270,1681, 897, > 1435,1135,1171, 606,1002, 324,1631, 759, 429, 526,1049, 416, 225, 213, > 222)( 197, 241, 286, 668,1656,1665, 209, 630,1550,1273,1426,1566,1527, > 1429,1379, 707, 645,1455,1377, 525, 290)( 200,1192,1630,1031, 492, > 236, 478)( 202, 279, 365)( 210,1154,1268, 740,1745, 990,1191,1645, > 796,1764,1721, 908,1134,1515,1073, 379,1037,1489, 511, 273, 551) > ( 237, 932,1123,1642,1779, 882,1261,1573,1466,1731, 848,1712,1431,1277, > 289, 392, 531,1137,1187, 480, 803)( 238,1297,1528, 252,1331, 562, 689, > 876,1649,1486,1564,1327, 782, 877, 934,1075,1224,1349,1600, 635,1076) > ( 244, 613,1352, 775, 446, 517,1360, 500, 828,1628, 678, 786,1010, 903, > 1162, 853, 871, 995,1040, 418, 320)( 264,1343,1525, 815,1290, 950, > 1130, 832,1000,1445, 719,1682,1582,1028,1144, 983,1615,1287,1675,1451, > 1697)( 269, 661,1145,1535, 681, 366, 348)( 277, 297, 690, 385,1211, > 807,1217,1199,1267, 911, 679, 580,1507, 980,1385, 840, 708,1655,1568, > 440, 900)( 278,1034,1300, 965,1091, 627,1749,1563,1090, 750,1320,1492, > 1390,1517, 981,1150, 974,1048,1306,1519,1356)( 296, 547, 705,1608, > 1189,1597,1552,1772,1652,1363, 339,1081, 744, 617,1570, 457,1505,1117, > 975,1269, 372)( 301, 407, 549,1238,1733,1291,1168,1651,1529,1105,1660, > 1263,1160,1411,1469,1603, 912,1387, 721,1060, 727)( 311, 609, 413, > 1016,1108, 723, 793)( 317, 671, 852,1744,1694,1292, 626,1050, 860, > 1506,1098, 591,1185,1551,1546,1096, 540,1283,1180,1427,1585) > ( 318,1289, 538, 545,1362, 743, 905, 760,1364,1493, 873,1490,1425, 647, > 1357,1298, 731,1359,1234,1245, 818)( 331,1225,1330,1200,1408,1209, > 968,1065,1538,1756, 991,1179,1346, 988,1151,1583,1366, 664, 789,1724, > 652)( 333,1495, 867,1265,1470,1580,1206)( 345, 894, 946,1557,1413, > 657,1358, 420,1103,1057,1183, 928,1673, 702, 357, 534, 639, 515,1284, > 1441, 826)( 361,1329,1496,1530,1693,1405,1208,1459,1393,1152,1303, > 1688,1369,1308, 959,1485,1018,1113,1170,1046, 758)( 367, 879,1714, > 1632,1122, 462,1778,1555,1140,1471,1590,1647,1166,1219, 738,1462,1278, > 943, 779, 493,1488)( 373, 787,1126,1727,1734,1728,1388,1399, 618, 855, > 1210,1677,1584, 747, 765, 597,1001,1226, 401,1616,1029) > ( 398,1139, 581, 528,1285, 916, 790)( 411, 901, 771,1476,1684,1169, > 1214,1257,1613, 553, 819, 698, 849,1621,1599,1415, 978,1367, 956,1588, > 1326)( 417,1148,1239,1589,1344,1658,1047)( 423,1172, 794, 442, 619, > 558,1056)( 431,1067, 788,1249,1053,1574,1639,1735,1576, 589,1351, > 923,1657,1556,1730,1591,1567,1052, 643,1447,1740)( 432, 729,1691, > 1396, 474,1395,1235, 505,1554,1743,1539, 910,1109,1773,1158,1403,1376, > 565,1124,1679,1619)( 438,1543,1648,1755,1237,1229,1524, 921,1509,1386, > 1315, 506,1610,1198,1032,1449, 543,1521,1094,1069, 773) > ( 454, 962,1205,1275,1480,1499, 669,1593,1106, 711, 843,1770, 746,1087, > 1372, 632,1562,1317, 917,1133,1716)( 527,1201, 948,1365, 887,1715,1165 > )( 582, 844, 821, 751, 670, 915, 922)( 650, 733,1522,1420,1332, 994, > 1536, 859,1074,1542,1669,1247,1276,1088,1293,1412,1373,1763, 748,1143, > 1301)( 653, 895,1709, 791, 764,1541,1579)( 706,1055, 861,1504,1641, > 1508,1481)( 810,1296, 970,1698,1523,1215, 869)(1097,1456,1383,1461, > 1467,1748,1153)(1222,1674,1384,1729,1707,1452,1417) );; gap> SetName( g, "g" ); gap> DisplayCompositionSeries( g ); Group | Suz Group gap> List( ChiefSeriesOfGroup( g ), Size ); [ 448345497600, 1 ] # test gap> g:= > Group( ( 1, 5, 7, 3, 12, 24, 11)( 2, 23, 4, 27, 13, 14, 26) > ( 6, 20, 18, 8, 25, 21, 28)( 9, 10, 17, 15, 22, 16, 19) > ( 29, 33, 35, 31, 40, 52, 39)( 30, 51, 32, 55, 41, 42, 54) > ( 34, 48, 46, 36, 53, 49, 56)( 37, 38, 45, 43, 50, 44, 47) > ( 57, 61, 63, 59, 68, 80, 67)( 58, 79, 60, 83, 69, 70, 82) > ( 62, 76, 74, 64, 81, 77, 84)( 65, 66, 73, 71, 78, 72, 75) > ( 85, 89, 91, 87, 96,108, 95)( 86,107, 88,111, 97, 98,110) > ( 90,104,102, 92,109,105,112)( 93, 94,101, 99,106,100,103) > (113,117,119,115,124,136,123)(114,135,116,139,125,126,138) > (118,132,130,120,137,133,140)(121,122,129,127,134,128,131) > (141,145,147,143,152,164,151)(142,163,144,167,153,154,166) > (146,160,158,148,165,161,168)(149,150,157,155,162,156,159) > (169,173,175,171,180,192,179)(170,191,172,195,181,182,194) > (174,188,186,176,193,189,196)(177,178,185,183,190,184,187) > (197,201,203,199,208,220,207)(198,219,200,223,209,210,222) > (202,216,214,204,221,217,224)(205,206,213,211,218,212,215) > (225,229,231,227,236,248,235)(226,247,228,251,237,238,250) > (230,244,242,232,249,245,252)(233,234,241,239,246,240,243) > (253,257,259,255,264,276,263)(254,275,256,279,265,266,278) > (258,272,270,260,277,273,280)(261,262,269,267,274,268,271) > (281,285,287,283,292,304,291)(282,303,284,307,293,294,306) > (286,300,298,288,305,301,308)(289,290,297,295,302,296,299) > (309,313,315,311,320,332,319)(310,331,312,335,321,322,334) > (314,328,326,316,333,329,336)(317,318,325,323,330,324,327) > (337,341,343,339,348,360,347)(338,359,340,363,349,350,362) > (342,356,354,344,361,357,364)(345,346,353,351,358,352,355) > (365,369,371,367,376,388,375)(366,387,368,391,377,378,390) > (370,384,382,372,389,385,392)(373,374,381,379,386,380,383) > (393,397,399,395,404,416,403)(394,415,396,419,405,406,418) > (398,412,410,400,417,413,420)(401,402,409,407,414,408,411) > (421,425,427,423,432,444,431)(422,443,424,447,433,434,446) > (426,440,438,428,445,441,448)(429,430,437,435,442,436,439) > (449,453,455,451,460,472,459)(450,471,452,475,461,462,474) > (454,468,466,456,473,469,476)(457,458,465,463,470,464,467) > (477,481,483,479,488,500,487)(478,499,480,503,489,490,502) > (482,496,494,484,501,497,504)(485,486,493,491,498,492,495) > (505,509,511,507,516,528,515)(506,527,508,531,517,518,530) > (510,524,522,512,529,525,532)(513,514,521,519,526,520,523) > (533,537,539,535,544,556,543)(534,555,536,559,545,546,558) > (538,552,550,540,557,553,560)(541,542,549,547,554,548,551) > (561,565,567,563,572,584,571)(562,583,564,587,573,574,586) > (566,580,578,568,585,581,588)(569,570,577,575,582,576,579) > (589,593,595,591,600,612,599)(590,611,592,615,601,602,614) > (594,608,606,596,613,609,616)(597,598,605,603,610,604,607) > (617,621,623,619,628,640,627)(618,639,620,643,629,630,642) > (622,636,634,624,641,637,644)(625,626,633,631,638,632,635) > (645,649,651,647,656,668,655)(646,667,648,671,657,658,670) > (650,664,662,652,669,665,672)(653,654,661,659,666,660,663) > (673,677,679,675,684,696,683)(674,695,676,699,685,686,698) > (678,692,690,680,697,693,700)(681,682,689,687,694,688,691) > (701,705,707,703,712,724,711)(702,723,704,727,713,714,726) > (706,720,718,708,725,721,728)(709,710,717,715,722,716,719) > (729,733,735,731,740,752,739)(730,751,732,755,741,742,754) > (734,748,746,736,753,749,756)(737,738,745,743,750,744,747) > (757,761,763,759,768,780,767)(758,779,760,783,769,770,782) > (762,776,774,764,781,777,784)(765,766,773,771,778,772,775), > ( 1,113,169, 57,309,645,281)( 2,114,170, 58,310,646,282) > ( 3,115,171, 59,311,647,283)( 4,116,172, 60,312,648,284) > ( 5,117,173, 61,313,649,285)( 6,118,174, 62,314,650,286) > ( 7,119,175, 63,315,651,287)( 8,120,176, 64,316,652,288) > ( 9,121,177, 65,317,653,289)( 10,122,178, 66,318,654,290) > ( 11,123,179, 67,319,655,291)( 12,124,180, 68,320,656,292) > ( 13,125,181, 69,321,657,293)( 14,126,182, 70,322,658,294) > ( 15,127,183, 71,323,659,295)( 16,128,184, 72,324,660,296) > ( 17,129,185, 73,325,661,297)( 18,130,186, 74,326,662,298) > ( 19,131,187, 75,327,663,299)( 20,132,188, 76,328,664,300) > ( 21,133,189, 77,329,665,301)( 22,134,190, 78,330,666,302) > ( 23,135,191, 79,331,667,303)( 24,136,192, 80,332,668,304) > ( 25,137,193, 81,333,669,305)( 26,138,194, 82,334,670,306) > ( 27,139,195, 83,335,671,307)( 28,140,196, 84,336,672,308) > ( 29,617, 85,729,337,365,701)( 30,618, 86,730,338,366,702) > ( 31,619, 87,731,339,367,703)( 32,620, 88,732,340,368,704) > ( 33,621, 89,733,341,369,705)( 34,622, 90,734,342,370,706) > ( 35,623, 91,735,343,371,707)( 36,624, 92,736,344,372,708) > ( 37,625, 93,737,345,373,709)( 38,626, 94,738,346,374,710) > ( 39,627, 95,739,347,375,711)( 40,628, 96,740,348,376,712) > ( 41,629, 97,741,349,377,713)( 42,630, 98,742,350,378,714) > ( 43,631, 99,743,351,379,715)( 44,632,100,744,352,380,716) > ( 45,633,101,745,353,381,717)( 46,634,102,746,354,382,718) > ( 47,635,103,747,355,383,719)( 48,636,104,748,356,384,720) > ( 49,637,105,749,357,385,721)( 50,638,106,750,358,386,722) > ( 51,639,107,751,359,387,723)( 52,640,108,752,360,388,724) > ( 53,641,109,753,361,389,725)( 54,642,110,754,362,390,726) > ( 55,643,111,755,363,391,727)( 56,644,112,756,364,392,728) > (141,533,477,197,673,561,757)(142,534,478,198,674,562,758) > (143,535,479,199,675,563,759)(144,536,480,200,676,564,760) > (145,537,481,201,677,565,761)(146,538,482,202,678,566,762) > (147,539,483,203,679,567,763)(148,540,484,204,680,568,764) > (149,541,485,205,681,569,765)(150,542,486,206,682,570,766) > (151,543,487,207,683,571,767)(152,544,488,208,684,572,768) > (153,545,489,209,685,573,769)(154,546,490,210,686,574,770) > (155,547,491,211,687,575,771)(156,548,492,212,688,576,772) > (157,549,493,213,689,577,773)(158,550,494,214,690,578,774) > (159,551,495,215,691,579,775)(160,552,496,216,692,580,776) > (161,553,497,217,693,581,777)(162,554,498,218,694,582,778) > (163,555,499,219,695,583,779)(164,556,500,220,696,584,780) > (165,557,501,221,697,585,781)(166,558,502,222,698,586,782) > (167,559,503,223,699,587,783)(168,560,504,224,700,588,784) > (225,253,449,393,589,421,505)(226,254,450,394,590,422,506) > (227,255,451,395,591,423,507)(228,256,452,396,592,424,508) > (229,257,453,397,593,425,509)(230,258,454,398,594,426,510) > (231,259,455,399,595,427,511)(232,260,456,400,596,428,512) > (233,261,457,401,597,429,513)(234,262,458,402,598,430,514) > (235,263,459,403,599,431,515)(236,264,460,404,600,432,516) > (237,265,461,405,601,433,517)(238,266,462,406,602,434,518) > (239,267,463,407,603,435,519)(240,268,464,408,604,436,520) > (241,269,465,409,605,437,521)(242,270,466,410,606,438,522) > (243,271,467,411,607,439,523)(244,272,468,412,608,440,524) > (245,273,469,413,609,441,525)(246,274,470,414,610,442,526) > (247,275,471,415,611,443,527)(248,276,472,416,612,444,528) > (249,277,473,417,613,445,529)(250,278,474,418,614,446,530) > (251,279,475,419,615,447,531)(252,280,476,420,616,448,532), ( 3, 4) > ( 5, 17, 7, 16, 8, 20, 6, 13)( 9, 19, 11, 14, 12, 18, 10, 15) > ( 21, 23, 26, 28, 24, 22, 27, 25)( 31, 32)( 33, 45, 35, 44, 36, 48, 34, > 41)( 37, 47, 39, 42, 40, 46, 38, 43)( 49, 51, 54, 56, 52, 50, 55, 53) > ( 59, 60)( 61, 73, 63, 72, 64, 76, 62, 69)( 65, 75, 67, 70, 68, 74, 66, > 71)( 77, 79, 82, 84, 80, 78, 83, 81)( 87, 88)( 89,101, 91,100, 92,104, > 90, 97)( 93,103, 95, 98, 96,102, 94, 99)(105,107,110,112,108,106,111, > 109)(115,116)(117,129,119,128,120,132,118,125)(121,131,123,126,124, > 130,122,127)(133,135,138,140,136,134,139,137)(143,144) > (145,157,147,156,148,160,146,153)(149,159,151,154,152,158,150,155) > (161,163,166,168,164,162,167,165)(171,172)(173,185,175,184,176,188,174, > 181)(177,187,179,182,180,186,178,183)(189,191,194,196,192,190,195,193) > (199,200)(201,213,203,212,204,216,202,209)(205,215,207,210,208,214,206, > 211)(217,219,222,224,220,218,223,221)(227,228)(229,241,231,240,232, > 244,230,237)(233,243,235,238,236,242,234,239)(245,247,250,252,248,246, > 251,249)(255,256)(257,269,259,268,260,272,258,265)(261,271,263,266, > 264,270,262,267)(273,275,278,280,276,274,279,277)(283,284) > (285,297,287,296,288,300,286,293)(289,299,291,294,292,298,290,295) > (301,303,306,308,304,302,307,305)(311,312)(313,325,315,324,316,328,314, > 321)(317,327,319,322,320,326,318,323)(329,331,334,336,332,330,335,333) > (339,340)(341,353,343,352,344,356,342,349)(345,355,347,350,348,354,346, > 351)(357,359,362,364,360,358,363,361)(367,368)(369,381,371,380,372, > 384,370,377)(373,383,375,378,376,382,374,379)(385,387,390,392,388,386, > 391,389)(395,396)(397,409,399,408,400,412,398,405)(401,411,403,406, > 404,410,402,407)(413,415,418,420,416,414,419,417)(423,424) > (425,437,427,436,428,440,426,433)(429,439,431,434,432,438,430,435) > (441,443,446,448,444,442,447,445)(451,452)(453,465,455,464,456,468,454, > 461)(457,467,459,462,460,466,458,463)(469,471,474,476,472,470,475,473) > (479,480)(481,493,483,492,484,496,482,489)(485,495,487,490,488,494,486, > 491)(497,499,502,504,500,498,503,501)(507,508)(509,521,511,520,512, > 524,510,517)(513,523,515,518,516,522,514,519)(525,527,530,532,528,526, > 531,529)(535,536)(537,549,539,548,540,552,538,545)(541,551,543,546, > 544,550,542,547)(553,555,558,560,556,554,559,557)(563,564) > (565,577,567,576,568,580,566,573)(569,579,571,574,572,578,570,575) > (581,583,586,588,584,582,587,585)(591,592)(593,605,595,604,596,608,594, > 601)(597,607,599,602,600,606,598,603)(609,611,614,616,612,610,615,613) > (619,620)(621,633,623,632,624,636,622,629)(625,635,627,630,628,634,626, > 631)(637,639,642,644,640,638,643,641)(647,648)(649,661,651,660,652, > 664,650,657)(653,663,655,658,656,662,654,659)(665,667,670,672,668,666, > 671,669)(675,676)(677,689,679,688,680,692,678,685)(681,691,683,686, > 684,690,682,687)(693,695,698,700,696,694,699,697)(703,704) > (705,717,707,716,708,720,706,713)(709,719,711,714,712,718,710,715) > (721,723,726,728,724,722,727,725)(731,732)(733,745,735,744,736,748,734, > 741)(737,747,739,742,740,746,738,743)(749,751,754,756,752,750,755,753) > (759,760)(761,773,763,772,764,776,762,769)(765,775,767,770,768,774,766, > 771)(777,779,782,784,780,778,783,781), ( 57, 85)( 58, 86)( 59, 87) > ( 60, 88)( 61, 89)( 62, 90)( 63, 91)( 64, 92)( 65, 93)( 66, 94) > ( 67, 95)( 68, 96)( 69, 97)( 70, 98)( 71, 99)( 72,100)( 73,101) > ( 74,102)( 75,103)( 76,104)( 77,105)( 78,106)( 79,107)( 80,108) > ( 81,109)( 82,110)( 83,111)( 84,112)(113,449,169,421,197,533,141,337) > (114,450,170,422,198,534,142,338)(115,451,171,423,199,535,143,339) > (116,452,172,424,200,536,144,340)(117,453,173,425,201,537,145,341) > (118,454,174,426,202,538,146,342)(119,455,175,427,203,539,147,343) > (120,456,176,428,204,540,148,344)(121,457,177,429,205,541,149,345) > (122,458,178,430,206,542,150,346)(123,459,179,431,207,543,151,347) > (124,460,180,432,208,544,152,348)(125,461,181,433,209,545,153,349) > (126,462,182,434,210,546,154,350)(127,463,183,435,211,547,155,351) > (128,464,184,436,212,548,156,352)(129,465,185,437,213,549,157,353) > (130,466,186,438,214,550,158,354)(131,467,187,439,215,551,159,355) > (132,468,188,440,216,552,160,356)(133,469,189,441,217,553,161,357) > (134,470,190,442,218,554,162,358)(135,471,191,443,219,555,163,359) > (136,472,192,444,220,556,164,360)(137,473,193,445,221,557,165,361) > (138,474,194,446,222,558,166,362)(139,475,195,447,223,559,167,363) > (140,476,196,448,224,560,168,364)(225,505,281,365,309,477,253,393) > (226,506,282,366,310,478,254,394)(227,507,283,367,311,479,255,395) > (228,508,284,368,312,480,256,396)(229,509,285,369,313,481,257,397) > (230,510,286,370,314,482,258,398)(231,511,287,371,315,483,259,399) > (232,512,288,372,316,484,260,400)(233,513,289,373,317,485,261,401) > (234,514,290,374,318,486,262,402)(235,515,291,375,319,487,263,403) > (236,516,292,376,320,488,264,404)(237,517,293,377,321,489,265,405) > (238,518,294,378,322,490,266,406)(239,519,295,379,323,491,267,407) > (240,520,296,380,324,492,268,408)(241,521,297,381,325,493,269,409) > (242,522,298,382,326,494,270,410)(243,523,299,383,327,495,271,411) > (244,524,300,384,328,496,272,412)(245,525,301,385,329,497,273,413) > (246,526,302,386,330,498,274,414)(247,527,303,387,331,499,275,415) > (248,528,304,388,332,500,276,416)(249,529,305,389,333,501,277,417) > (250,530,306,390,334,502,278,418)(251,531,307,391,335,503,279,419) > (252,532,308,392,336,504,280,420)(561,617,701,757,645,589,729,673) > (562,618,702,758,646,590,730,674)(563,619,703,759,647,591,731,675) > (564,620,704,760,648,592,732,676)(565,621,705,761,649,593,733,677) > (566,622,706,762,650,594,734,678)(567,623,707,763,651,595,735,679) > (568,624,708,764,652,596,736,680)(569,625,709,765,653,597,737,681) > (570,626,710,766,654,598,738,682)(571,627,711,767,655,599,739,683) > (572,628,712,768,656,600,740,684)(573,629,713,769,657,601,741,685) > (574,630,714,770,658,602,742,686)(575,631,715,771,659,603,743,687) > (576,632,716,772,660,604,744,688)(577,633,717,773,661,605,745,689) > (578,634,718,774,662,606,746,690)(579,635,719,775,663,607,747,691) > (580,636,720,776,664,608,748,692)(581,637,721,777,665,609,749,693) > (582,638,722,778,666,610,750,694)(583,639,723,779,667,611,751,695) > (584,640,724,780,668,612,752,696)(585,641,725,781,669,613,753,697) > (586,642,726,782,670,614,754,698)(587,643,727,783,671,615,755,699) > (588,644,728,784,672,616,756,700) );; gap> SetName( g, "g" ); gap> DisplayCompositionSeries( g ); Group | 2A(2,3) = U(3,3) Group | 2A(2,3) = U(3,3) Group gap> List( ChiefSeriesOfGroup( g ), Size ); [ 36578304, 6048, 1 ] # $A_5 \times A_5$ in primitive action on $60$ points # (direct factors corresponding to left and right regular action) gap> g:= AlternatingGroup( 5 );; gap> e:= AsList( g );; gap> gens:= GeneratorsOfGroup( g );; gap> p:= List( gens, i -> PermList( List( e, j -> Position( e, i*j ) ) ) );; gap> q:= List( gens, i -> PermList( List( e, j -> Position( e, j*i ) ) ) );; gap> h:= Group( Concatenation( p, q ) ); gap> IsPrimitive( h, [ 1 .. 60 ] ); true gap> CompositionSeries( h ); [ , , Group(()) ] gap> STOP_TEST( "grpprmcs.tst", 4153600000 ); ############################################################################# ## #E gap-4r6p5/tst/varnames.tst0000644000175000017500000000161012172557256014325 0ustar billbill############################################################################# ## #W varnames.tst GAP Tests Alexander Konovalov ## ## ## Exclude from testinstall.g: too sensitive to the context ## gap> START_TEST("varnames.tst"); gap> Filtered( NamesSystemGVars(), x -> not x in ALL_KEYWORDS() and > ( Length(x)=1 or IsLowerAlphaChar(x[1]) ) ); [ "*", "+", "-", ".", "/", "<", "=", "E", "X", "Z", "^", "fail", "infinity", "last", "last2", "last3", "time" ] gap> # Filtered(NamesSystemGVars(),name->IsSubset(LETTERS,name));; gap> E; gap> X; gap> Z; function( q ) ... end gap> Length; gap> STOP_TEST( "varnames.tst", 3600000/1000 ); ############################################################################# ## #E varnames.tst . . . . . . . . . . . . . . . . . . . . . . . . . ends here gap-4r6p5/tst/combinat.tst0000644000175000017500000004616612172557256014324 0ustar billbill############################################################################# ## #W combinat.tst GAP tests Martin Schönert ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file tests the functions that mainly deal with combinatorics. ## ## To be listed in testinstall.g ## gap> START_TEST("combinat.tst"); #F Factorial( ) . . . . . . . . . . . . . . . . factorial of an integer gap> Print(List( [0..10], Factorial ),"\n"); [ 1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800 ] gap> Factorial( 50 ); 30414093201713378043612608166064768844377641568960512000000000000 #F Binomial( , ) . . . . . . . . . binomial coefficient of integers gap> Print(List( [-8..8], k -> Binomial( 0, k ) ),"\n"); [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ] gap> List( [-8..8], n -> Binomial( n, 0 ) ); [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ] gap> ForAll( [-8..8], n -> ForAll( [-2..8], k -> > Binomial(n,k) = Binomial(n-1,k) + Binomial(n-1,k-1) ) ); true gap> Binomial( 400, 50 ); 17035900270730601418919867558071677342938596450600561760371485120 #F Bell( ) . . . . . . . . . . . . . . . . . value of the Bell sequence gap> Print(List( [0..10], n -> Bell(n) ),"\n"); [ 1, 1, 2, 5, 15, 52, 203, 877, 4140, 21147, 115975 ] gap> Print(List( [0..10], n -> Sum( [0..n], k -> Stirling2( n, k ) ) ),"\n"); [ 1, 1, 2, 5, 15, 52, 203, 877, 4140, 21147, 115975 ] gap> Bell( 60 ); 976939307467007552986994066961675455550246347757474482558637 #F Stirling1( , ) . . . . . . . . . Stirling number of the first kind gap> Print(List( [-8..8], k -> Stirling1( 0, k ) ),"\n"); [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ] gap> Print(List( [-8..8], n -> Stirling1( n, 0 ) ),"\n"); [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ] gap> ForAll( [-8..8], n -> ForAll( [-8..8], k -> > Stirling1(n,k) = (n-1) * Stirling1(n-1,k) + Stirling1(n-1,k-1) ) ); true gap> Stirling1( 60, 20 ); 568611292461582075463109862277030309493811818619783570055397018154658816 #F Stirling2( , ) . . . . . . . . Stirling number of the second kind gap> Print(List( [-8..8], k -> Stirling2( 0, k ) ),"\n"); [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ] gap> Print(List( [-8..8], n -> Stirling2( n, 0 ) ),"\n"); [ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ] gap> ForAll( [-8..8], n -> ForAll( [-8..8], k -> > Stirling2(n,k) = k * Stirling2(n-1,k) + Stirling2(n-1,k-1) ) ); true gap> Stirling2( 60, 20 ); 170886257768137628374668205554120607567311094075812403938286 #F Combinations( , ) . . . . set of sorted sublists of a multiset gap> Combinations( [] ); [ [ ] ] gap> Print(List( [0..1], k -> Combinations( [], k ) ),"\n"); [ [ [ ] ], [ ] ] gap> Print(Combinations( [1..4] ),"\n"); [ [ ], [ 1 ], [ 1, 2 ], [ 1, 2, 3 ], [ 1, 2, 3, 4 ], [ 1, 2, 4 ], [ 1, 3 ], [ 1, 3, 4 ], [ 1, 4 ], [ 2 ], [ 2, 3 ], [ 2, 3, 4 ], [ 2, 4 ], [ 3 ], [ 3, 4 ], [ 4 ] ] gap> Print(List( [0..5], k -> Combinations( [1..4], k ) ),"\n"); [ [ [ ] ], [ [ 1 ], [ 2 ], [ 3 ], [ 4 ] ], [ [ 1, 2 ], [ 1, 3 ], [ 1, 4 ], [ 2, 3 ], [ 2, 4 ], [ 3, 4 ] ], [ [ 1, 2, 3 ], [ 1, 2, 4 ], [ 1, 3, 4 ], [ 2, 3, 4 ] ], [ [ 1, 2, 3, 4 ] ], [ ] ] gap> Print(Combinations( [1,2,2,3] ),"\n"); [ [ ], [ 1 ], [ 1, 2 ], [ 1, 2, 2 ], [ 1, 2, 2, 3 ], [ 1, 2, 3 ], [ 1, 3 ], [ 2 ], [ 2, 2 ], [ 2, 2, 3 ], [ 2, 3 ], [ 3 ] ] gap> Print(List( [0..5], k -> Combinations( [1,2,2,3], k ) ),"\n"); [ [ [ ] ], [ [ 1 ], [ 2 ], [ 3 ] ], [ [ 1, 2 ], [ 1, 3 ], [ 2, 2 ], [ 2, 3 ] ], [ [ 1, 2, 2 ], [ 1, 2, 3 ], [ 2, 2, 3 ] ], [ [ 1, 2, 2, 3 ] ], [ ] ] gap> Combinations( [1..12] )[4039]; [ 7, 8, 9, 10, 11, 12 ] gap> Combinations( [1..16], 4 )[266]; [ 1, 5, 9, 13 ] gap> Combinations( [1,2,3,3,4,4,5,5,5,6,6,6,7,7,7,7] )[378]; [ 1, 2, 3, 4, 5, 6, 7 ] gap> Combinations( [1,2,3,3,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8], 8 )[97]; [ 1, 2, 3, 4, 5, 6, 7, 8 ] #F NrCombinations( , ) . . number of sorted sublists of a multiset gap> NrCombinations( [] ); 1 gap> Print(List( [0..1], k -> NrCombinations( [], k ) ),"\n"); [ 1, 0 ] gap> NrCombinations( [1..4] ); 16 gap> Print(List( [0..5], k -> NrCombinations( [1..4], k ) ),"\n"); [ 1, 4, 6, 4, 1, 0 ] gap> NrCombinations( [1,2,2,3] ); 12 gap> Print(List( [0..5], k -> NrCombinations( [1,2,2,3], k ) ),"\n"); [ 1, 3, 4, 3, 1, 0 ] gap> NrCombinations( [1..12] ); 4096 gap> NrCombinations( [1..16], 4 ); 1820 gap> NrCombinations( [1,2,3,3,4,4,5,5,5,6,6,6,7,7,7,7] ); 2880 gap> NrCombinations( [1,2,3,3,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8], 8 ); 1558 #F Arrangements( ) . . . . set of ordered combinations of a multiset gap> Arrangements( [] ); [ [ ] ] gap> Print(List( [0..1], k -> Arrangements( [], k ) ),"\n"); [ [ [ ] ], [ ] ] gap> Print(Arrangements( [1..3] ),"\n"); [ [ ], [ 1 ], [ 1, 2 ], [ 1, 2, 3 ], [ 1, 3 ], [ 1, 3, 2 ], [ 2 ], [ 2, 1 ], [ 2, 1, 3 ], [ 2, 3 ], [ 2, 3, 1 ], [ 3 ], [ 3, 1 ], [ 3, 1, 2 ], [ 3, 2 ], [ 3, 2, 1 ] ] gap> Print(List( [0..4], k -> Arrangements( [1..3], k ) ),"\n"); [ [ [ ] ], [ [ 1 ], [ 2 ], [ 3 ] ], [ [ 1, 2 ], [ 1, 3 ], [ 2, 1 ], [ 2, 3 ], [ 3, 1 ], [ 3, 2 ] ], [ [ 1, 2, 3 ], [ 1, 3, 2 ], [ 2, 1, 3 ], [ 2, 3, 1 ], [ 3, 1, 2 ], [ 3, 2, 1 ] ], [ ] ] gap> Print(Arrangements( [1,2,2,3] ),"\n"); [ [ ], [ 1 ], [ 1, 2 ], [ 1, 2, 2 ], [ 1, 2, 2, 3 ], [ 1, 2, 3 ], [ 1, 2, 3, 2 ], [ 1, 3 ], [ 1, 3, 2 ], [ 1, 3, 2, 2 ], [ 2 ], [ 2, 1 ], [ 2, 1, 2 ], [ 2, 1, 2, 3 ], [ 2, 1, 3 ], [ 2, 1, 3, 2 ], [ 2, 2 ], [ 2, 2, 1 ], [ 2, 2, 1, 3 ], [ 2, 2, 3 ], [ 2, 2, 3, 1 ], [ 2, 3 ], [ 2, 3, 1 ], [ 2, 3, 1, 2 ], [ 2, 3, 2 ], [ 2, 3, 2, 1 ], [ 3 ], [ 3, 1 ], [ 3, 1, 2 ], [ 3, 1, 2, 2 ], [ 3, 2 ], [ 3, 2, 1 ], [ 3, 2, 1, 2 ], [ 3, 2, 2 ], [ 3, 2, 2, 1 ] ] gap> Print(List( [0..5], k -> Arrangements( [1,2,2,3], k ) ),"\n"); [ [ [ ] ], [ [ 1 ], [ 2 ], [ 3 ] ], [ [ 1, 2 ], [ 1, 3 ], [ 2, 1 ], [ 2, 2 ], [ 2, 3 ], [ 3, 1 ], [ 3, 2 ] ], [ [ 1, 2, 2 ], [ 1, 2, 3 ], [ 1, 3, 2 ], [ 2, 1, 2 ], [ 2, 1, 3 ], [ 2, 2, 1 ], [ 2, 2, 3 ], [ 2, 3, 1 ], [ 2, 3, 2 ], [ 3, 1, 2 ], [ 3, 2, 1 ], [ 3, 2, 2 ] ], [ [ 1, 2, 2, 3 ], [ 1, 2, 3, 2 ], [ 1, 3, 2, 2 ], [ 2, 1, 2, 3 ], [ 2, 1, 3, 2 ], [ 2, 2, 1, 3 ], [ 2, 2, 3, 1 ], [ 2, 3, 1, 2 ], [ 2, 3, 2, 1 ], [ 3, 1, 2, 2 ], [ 3, 2, 1, 2 ], [ 3, 2, 2, 1 ] ], [ ] ] gap> Arrangements( [1..6] )[736]; [ 3, 2, 1, 6, 5, 4 ] gap> Arrangements( [1..8], 4 )[443]; [ 3, 1, 7, 5 ] gap> Arrangements( [1,2,3,3,4,4,5] )[3511]; [ 5, 4, 3, 2, 1 ] gap> Arrangements( [1,2,3,4,4,5,5,6,6], 5 )[424]; [ 2, 3, 4, 5, 6 ] #F NrArrangements( , ) . . number of sorted sublists of a multiset gap> NrArrangements( [] ); 1 gap> Print(List( [0..1], k -> NrArrangements( [], k ) ),"\n"); [ 1, 0 ] gap> NrArrangements( [1..3] ); 16 gap> Print(List( [0..4], k -> NrArrangements( [1..3], k ) ),"\n"); [ 1, 3, 6, 6, 0 ] gap> NrArrangements( [1,2,2,3] ); 35 gap> Print(List( [0..5], k -> NrArrangements( [1,2,2,3], k ) ),"\n"); [ 1, 3, 7, 12, 12, 0 ] gap> NrArrangements( [1..6] ); 1957 gap> NrArrangements( [1..8], 4 ); 1680 gap> NrArrangements( [1,2,3,3,4,4,5] ); 3592 gap> NrArrangements( [1,2,3,4,4,5,5,6,6], 5 ); 2880 #F UnorderedTuples( , ) . . . . set of unordered tuples from a set gap> Print(List( [0..1], k -> UnorderedTuples( [], k ) ),"\n"); [ [ [ ] ], [ ] ] gap> Print(List( [0..4], k -> UnorderedTuples( [1..3], k ) ),"\n"); [ [ [ ] ], [ [ 1 ], [ 2 ], [ 3 ] ], [ [ 1, 1 ], [ 1, 2 ], [ 1, 3 ], [ 2, 2 ], [ 2, 3 ], [ 3, 3 ] ], [ [ 1, 1, 1 ], [ 1, 1, 2 ], [ 1, 1, 3 ], [ 1, 2, 2 ], [ 1, 2, 3 ], [ 1, 3, 3 ], [ 2, 2, 2 ], [ 2, 2, 3 ], [ 2, 3, 3 ], [ 3, 3, 3 ] ], [ [ 1, 1, 1, 1 ], [ 1, 1, 1, 2 ], [ 1, 1, 1, 3 ], [ 1, 1, 2, 2 ], [ 1, 1, 2, 3 ], [ 1, 1, 3, 3 ], [ 1, 2, 2, 2 ], [ 1, 2, 2, 3 ], [ 1, 2, 3, 3 ], [ 1, 3, 3, 3 ], [ 2, 2, 2, 2 ], [ 2, 2, 2, 3 ], [ 2, 2, 3, 3 ], [ 2, 3, 3, 3 ], [ 3, 3, 3, 3 ] ] ] gap> UnorderedTuples( [1..10], 6 )[1459]; [ 1, 3, 5, 7, 9, 10 ] #F NrUnorderedTuples( , ) . . number unordered of tuples from a set gap> Print(List( [0..1], k -> NrUnorderedTuples( [], k ) ),"\n"); [ 1, 0 ] gap> Print(List( [0..4], k -> NrUnorderedTuples( [1..3], k ) ),"\n"); [ 1, 3, 6, 10, 15 ] gap> NrUnorderedTuples( [1..10], 6 ); 5005 #F Tuples( , ) . . . . . . . . . set of ordered tuples from a set gap> Print(List( [0..1], k -> Tuples( [], k ) ),"\n"); [ [ [ ] ], [ ] ] gap> Print(List( [0..3], k -> Tuples( [1..3], k ) ),"\n"); [ [ [ ] ], [ [ 1 ], [ 2 ], [ 3 ] ], [ [ 1, 1 ], [ 1, 2 ], [ 1, 3 ], [ 2, 1 ], [ 2, 2 ], [ 2, 3 ], [ 3, 1 ], [ 3, 2 ], [ 3, 3 ] ], [ [ 1, 1, 1 ], [ 1, 1, 2 ], [ 1, 1, 3 ], [ 1, 2, 1 ], [ 1, 2, 2 ], [ 1, 2, 3 ], [ 1, 3, 1 ], [ 1, 3, 2 ], [ 1, 3, 3 ], [ 2, 1, 1 ], [ 2, 1, 2 ], [ 2, 1, 3 ], [ 2, 2, 1 ], [ 2, 2, 2 ], [ 2, 2, 3 ], [ 2, 3, 1 ], [ 2, 3, 2 ], [ 2, 3, 3 ], [ 3, 1, 1 ], [ 3, 1, 2 ], [ 3, 1, 3 ], [ 3, 2, 1 ], [ 3, 2, 2 ], [ 3, 2, 3 ], [ 3, 3, 1 ], [ 3, 3, 2 ], [ 3, 3, 3 ] ] ] gap> Tuples( [1..8], 4 )[167]; [ 1, 3, 5, 7 ] #F NrTuples( , ) . . . . . . . number of ordered tuples from a set gap> Print(List( [0..1], k -> NrTuples( [], k ) ),"\n"); [ 1, 0 ] gap> Print(List( [0..3], k -> NrTuples( [1..3], k ) ),"\n"); [ 1, 3, 9, 27 ] gap> NrTuples( [1..8], 4 ); 4096 #F PermutationsList( ) . . . . . . set of permutations of a multiset gap> PermutationsList( [] ); [ [ ] ] gap> Print(PermutationsList( [1..4] ),"\n"); [ [ 1, 2, 3, 4 ], [ 1, 2, 4, 3 ], [ 1, 3, 2, 4 ], [ 1, 3, 4, 2 ], [ 1, 4, 2, 3 ], [ 1, 4, 3, 2 ], [ 2, 1, 3, 4 ], [ 2, 1, 4, 3 ], [ 2, 3, 1, 4 ], [ 2, 3, 4, 1 ], [ 2, 4, 1, 3 ], [ 2, 4, 3, 1 ], [ 3, 1, 2, 4 ], [ 3, 1, 4, 2 ], [ 3, 2, 1, 4 ], [ 3, 2, 4, 1 ], [ 3, 4, 1, 2 ], [ 3, 4, 2, 1 ], [ 4, 1, 2, 3 ], [ 4, 1, 3, 2 ], [ 4, 2, 1, 3 ], [ 4, 2, 3, 1 ], [ 4, 3, 1, 2 ], [ 4, 3, 2, 1 ] ] gap> Print(PermutationsList( [1,2,2,3,] ),"\n"); [ [ 1, 2, 2, 3 ], [ 1, 2, 3, 2 ], [ 1, 3, 2, 2 ], [ 2, 1, 2, 3 ], [ 2, 1, 3, 2 ], [ 2, 2, 1, 3 ], [ 2, 2, 3, 1 ], [ 2, 3, 1, 2 ], [ 2, 3, 2, 1 ], [ 3, 1, 2, 2 ], [ 3, 2, 1, 2 ], [ 3, 2, 2, 1 ] ] gap> Print(PermutationsList( [1..6] )[ 128 ],"\n"); [ 2, 1, 4, 3, 6, 5 ] gap> Print(PermutationsList( [1,2,2,3,3,4,4,4] )[1359],"\n"); [ 4, 3, 2, 1, 4, 3, 2, 4 ] #F NrPermutationsList( ) . . . number of permutations of a multiset gap> NrPermutationsList( [] ); 1 gap> NrPermutationsList( [1..4] ); 24 gap> NrPermutationsList( [1,2,2,3] ); 12 gap> NrPermutationsList( [1..6] ); 720 gap> NrPermutationsList( [1,2,2,3,3,4,4,4] ); 1680 #F Derangements( ) . . . . set of fixpointfree permutations of a list gap> Derangements( [] ); [ [ ] ] gap> Print(Derangements( [1..4] ),"\n"); [ [ 2, 1, 4, 3 ], [ 2, 3, 4, 1 ], [ 2, 4, 1, 3 ], [ 3, 1, 4, 2 ], [ 3, 4, 1, 2 ], [ 3, 4, 2, 1 ], [ 4, 1, 2, 3 ], [ 4, 3, 1, 2 ], [ 4, 3, 2, 1 ] ] gap> Print(Derangements( [1..6] )[ 128 ],"\n"); [ 4, 3, 6, 1, 2, 5 ] gap> Print(Derangements( [1,2,2,3,3,4,4,4] )[64],"\n"); [ 4, 1, 4, 2, 4, 2, 3, 3 ] #F NrDerangements( ) . number of fixpointfree permutations of a list gap> NrDerangements( [] ); 1 gap> NrDerangements( [1..4] ); 9 gap> NrDerangements( [1..6] ); 265 gap> NrDerangements( [1,2,2,3,3,4,4,4] ); 126 #F Permanent( ) . . . . . . . . . . . . . . . . permanent of a matrix gap> Permanent( [[0,1,1,1],[1,0,1,1],[1,1,0,1],[1,1,1,0]] ); 9 gap> Permanent( [[1,1,0,1,0,0,0],[0,1,1,0,1,0,0],[0,0,1,1,0,1,0],[0,0,0,1,1,0,1], > [1,0,0,0,1,1,0],[0,1,0,0,0,1,1],[1,0,1,0,0,0,1]] ); 24 #F PartitionsSet( ) . . . . . . . . . . . set of partitions of a set gap> PartitionsSet( [] ); [ [ ] ] gap> Print(List( [0..1], k -> PartitionsSet( [], k ) ),"\n"); [ [ [ ] ], [ ] ] gap> Print(PartitionsSet( [1..4] ),"\n"); [ [ [ 1 ], [ 2 ], [ 3 ], [ 4 ] ], [ [ 1 ], [ 2 ], [ 3, 4 ] ], [ [ 1 ], [ 2, 3 ], [ 4 ] ], [ [ 1 ], [ 2, 3, 4 ] ], [ [ 1 ], [ 2, 4 ], [ 3 ] ], [ [ 1, 2 ], [ 3 ], [ 4 ] ], [ [ 1, 2 ], [ 3, 4 ] ], [ [ 1, 2, 3 ], [ 4 ] ], [ [ 1, 2, 3, 4 ] ], [ [ 1, 2, 4 ], [ 3 ] ], [ [ 1, 3 ], [ 2 ], [ 4 ] ], [ [ 1, 3 ], [ 2, 4 ] ], [ [ 1, 3, 4 ], [ 2 ] ], [ [ 1, 4 ], [ 2 ], [ 3 ] ], [ [ 1, 4 ], [ 2, 3 ] ] ] gap> Print(List( [0..4], k -> PartitionsSet( [1..3], k ) ),"\n"); [ [ ], [ [ [ 1, 2, 3 ] ] ], [ [ [ 1 ], [ 2, 3 ] ], [ [ 1, 2 ], [ 3 ] ], [ [ 1, 3 ], [ 2 ] ] ], [ [ [ 1 ], [ 2 ], [ 3 ] ] ], [ ] ] gap> Print(PartitionsSet( [1..7] )[521],"\n"); [ [ 1, 3, 5, 7 ], [ 2, 4, 6 ] ] gap> Print(PartitionsSet( [1..8], 3 )[96],"\n"); [ [ 1, 2, 3 ], [ 4, 5 ], [ 6, 7, 8 ] ] #F NrPartitionsSet( ) . . . . . . . . . number of partitions of a set gap> NrPartitionsSet( [] ); 1 gap> List( [0..1], k -> NrPartitionsSet( [], k ) ); [ 1, 0 ] gap> NrPartitionsSet( [1..4] ); 15 gap> Print(List( [0..4], k -> NrPartitionsSet( [1,2,3], k ) ),"\n"); [ 0, 1, 3, 1, 0 ] gap> NrPartitionsSet( [1..8] ); 4140 gap> NrPartitionsSet( [1..9], 3 ); 3025 #F Partitions( ) . . . . . . . . . . . . set of partitions of an integer gap> Partitions( 0 ); [ [ ] ] gap> List( [0..1], k -> Partitions( 0, k ) ); [ [ [ ] ], [ ] ] gap> Print(Partitions( 6 ),"\n"); [ [ 1, 1, 1, 1, 1, 1 ], [ 2, 1, 1, 1, 1 ], [ 2, 2, 1, 1 ], [ 2, 2, 2 ], [ 3, 1, 1, 1 ], [ 3, 2, 1 ], [ 3, 3 ], [ 4, 1, 1 ], [ 4, 2 ], [ 5, 1 ], [ 6 ] ] gap> Print(List( [0..7], k -> Partitions( 6, k ) ),"\n"); [ [ ], [ [ 6 ] ], [ [ 3, 3 ], [ 4, 2 ], [ 5, 1 ] ], [ [ 2, 2, 2 ], [ 3, 2, 1 ], [ 4, 1, 1 ] ], [ [ 2, 2, 1, 1 ], [ 3, 1, 1, 1 ] ], [ [ 2, 1, 1, 1, 1 ] ], [ [ 1, 1, 1, 1, 1, 1 ] ], [ ] ] gap> Partitions( 20 )[314]; [ 7, 4, 3, 3, 2, 1 ] gap> Partitions( 20, 10 )[17]; [ 5, 3, 3, 2, 2, 1, 1, 1, 1, 1 ] #F NrPartitions( ) . . . . . . . . . number of partitions of an integer gap> NrPartitions( 0 ); 1 gap> List( [0..1], k -> NrPartitions( 0, k ) ); [ 1, 0 ] gap> NrPartitions( 6 ); 11 gap> List( [0..7], k -> NrPartitions( 6, k ) ); [ 0, 1, 3, 3, 2, 1, 1, 0 ] gap> NrPartitions( 100 ); 190569292 gap> NrPartitions( 100, 10 ); 2977866 #F OrderedPartitions( ) . . . . set of ordered partitions of an integer gap> OrderedPartitions( 0 ); [ [ ] ] gap> List( [0..1], k -> OrderedPartitions( 0, k ) ); [ [ [ ] ], [ ] ] gap> Print(OrderedPartitions( 5 ),"\n"); [ [ 1, 1, 1, 1, 1 ], [ 1, 1, 1, 2 ], [ 1, 1, 2, 1 ], [ 1, 1, 3 ], [ 1, 2, 1, 1 ], [ 1, 2, 2 ], [ 1, 3, 1 ], [ 1, 4 ], [ 2, 1, 1, 1 ], [ 2, 1, 2 ], [ 2, 2, 1 ], [ 2, 3 ], [ 3, 1, 1 ], [ 3, 2 ], [ 4, 1 ], [ 5 ] ] gap> Print(List( [0..6], k -> OrderedPartitions( 5, k ) ),"\n"); [ [ ], [ [ 5 ] ], [ [ 1, 4 ], [ 2, 3 ], [ 3, 2 ], [ 4, 1 ] ], [ [ 1, 1, 3 ], [ 1, 2, 2 ], [ 1, 3, 1 ], [ 2, 1, 2 ], [ 2, 2, 1 ], [ 3, 1, 1 ] ], [ [ 1, 1, 1, 2 ], [ 1, 1, 2, 1 ], [ 1, 2, 1, 1 ], [ 2, 1, 1, 1 ] ], [ [ 1, 1, 1, 1, 1 ] ], [ ] ] gap> OrderedPartitions( 13 )[2048]; [ 1, 12 ] gap> OrderedPartitions( 16, 6 )[1001]; [ 1, 11, 1, 1, 1, 1 ] #F NrOrderedPartitions( ) . . number of ordered partitions of an integer gap> NrOrderedPartitions( 0 ); 1 gap> List( [0..1], k -> NrOrderedPartitions( 0, k ) ); [ 1, 0 ] gap> NrOrderedPartitions( 5 ); 16 gap> List( [0..6], k -> NrOrderedPartitions( 5, k ) ); [ 0, 1, 4, 6, 4, 1, 0 ] gap> NrOrderedPartitions( 13 ); 4096 gap> NrOrderedPartitions( 16, 6 ); 3003 #F RestrictedPartitions( , ) . restricted partitions of an integer gap> RestrictedPartitions( 0, [1..10] ); [ [ ] ] gap> List( [0..1], k -> RestrictedPartitions( 0, [1..10], k ) ); [ [ [ ] ], [ ] ] gap> Print(RestrictedPartitions( 10, [1,2,5,10] ),"\n"); [ [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ], [ 2, 1, 1, 1, 1, 1, 1, 1, 1 ], [ 2, 2, 1, 1, 1, 1, 1, 1 ], [ 2, 2, 2, 1, 1, 1, 1 ], [ 2, 2, 2, 2, 1, 1 ], [ 2, 2, 2, 2, 2 ], [ 5, 1, 1, 1, 1, 1 ], [ 5, 2, 1, 1, 1 ], [ 5, 2, 2, 1 ], [ 5, 5 ], [ 10 ] ] gap> Print(List( [1..10],k->RestrictedPartitions( 10, [1,2,5,10], k )),"\n"); [ [ [ 10 ] ], [ [ 5, 5 ] ], [ ], [ [ 5, 2, 2, 1 ] ], [ [ 2, 2, 2, 2, 2 ], [ 5, 2, 1, 1, 1 ] ], [ [ 2, 2, 2, 2, 1, 1 ], [ 5, 1, 1, 1, 1, 1 ] ], [ [ 2, 2, 2, 1, 1, 1, 1 ] ], [ [ 2, 2, 1, 1, 1, 1, 1, 1 ] ], [ [ 2, 1, 1, 1, 1, 1, 1, 1, 1 ] ], [ [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ] ] ] gap> Print(RestrictedPartitions( 20, [2,5,10] ),"\n"); [ [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 ], [ 5, 5, 2, 2, 2, 2, 2 ], [ 5, 5, 5, 5 ], [ 10, 2, 2, 2, 2, 2 ], [ 10, 5, 5 ], [ 10, 10 ] ] gap> Print(List( [1..20], k -> RestrictedPartitions( 20, [2,5,10],k)),"\n"); [ [ ], [ [ 10, 10 ] ], [ [ 10, 5, 5 ] ], [ [ 5, 5, 5, 5 ] ], [ ], [ [ 10, 2, 2, 2, 2, 2 ] ], [ [ 5, 5, 2, 2, 2, 2, 2 ] ], [ ], [ ], [ [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 ] ], [ ], [ ], [ ], [ ], [ ], [ ], [ ], [ ], [ ], [ ] ] gap> Print(RestrictedPartitions( 60, [2,3,5,7,11,13,17] )[600],"\n"); [ 13, 7, 5, 5, 5, 5, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 ] gap> Print(RestrictedPartitions( 100, [2,3,5,7,11,13,17], 10 )[75],"\n"); [ 17, 17, 13, 13, 13, 7, 5, 5, 5, 5 ] #F NrRestrictedPartitions(,) . . . . number of restricted partitions gap> NrRestrictedPartitions( 0, [1..10] ); 1 gap> List( [0..1], k -> NrRestrictedPartitions( 0, [1..10], k ) ); [ 1, 0 ] gap> NrRestrictedPartitions( 50, [1,2,5,10] ); 341 gap> Print(List( [1..50], k->NrRestrictedPartitions( 50, [1,2,5,10], k)),"\n"); [ 0, 0, 0, 0, 1, 1, 1, 2, 4, 6, 6, 8, 10, 11, 11, 12, 13, 14, 14, 14, 15, 15, 14, 14, 14, 13, 12, 12, 11, 10, 9, 9, 8, 7, 6, 6, 6, 5, 4, 4, 4, 3, 2, 2, 2, 2, 1, 1, 1, 1 ] gap> NrRestrictedPartitions( 50, [2,5,10] ); 21 gap> Print(List( [1..50],k -> NrRestrictedPartitions( 50, [2,5,10],k)),"\n"); [ 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] gap> NrRestrictedPartitions( 60, [2,3,5,7,11,13,17] ); 1213 gap> NrRestrictedPartitions( 100, [2,3,5,7,11,13,17], 10 ); 125 #F IteratorOfPartitions( ) gap> for n in [ 1 .. 15 ] do > pn:= Partitions( n ); > iter:= IteratorOfPartitions( n ); > list:= []; > for i in [ 1 .. Length( pn ) ] do > Add( list, NextIterator( iter ) ); > od; > if not IsDoneIterator( iter ) then > Error( "wrong number of elements" ); > elif pn <> list then > Error( "different elements" ); > fi; > od; #F Lucas(

,,) . . . . . . . . . . . . . . value of a lucas sequence gap> Print(List( [0..10], i->Lucas(1,-2,i)[1] ),"\n"); [ 0, 1, 1, 3, 5, 11, 21, 43, 85, 171, 341 ] gap> Print(List( [0..10], i->Lucas(1,-2,i)[2] ),"\n"); [ 2, 1, 5, 7, 17, 31, 65, 127, 257, 511, 1025 ] gap> Print(List( [0..10], i->Lucas(1,-1,i)[1] ),"\n"); [ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 ] gap> Print(List( [0..10], i->Lucas(2,1,i)[1] ),"\n"); [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] gap> Lucas( 0, -4, 100 ) = [ 0, 2^101, 4^100 ]; true #F Fibonacci( ) . . . . . . . . . . . . value of the Fibonacci sequence gap> Print(List( [0..17], Fibonacci ),"\n"); [ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597 ] gap> Fibonacci( 333 ); 1751455877444438095408940282208383549115781784912085789506677971125378 #F Bernoulli( ) . . . . . . . . . . . . value of the Bernoulli sequence gap> Print(List( [0..14], Bernoulli ),"\n"); [ 1, -1/2, 1/6, 0, -1/30, 0, 1/42, 0, -1/30, 0, 5/66, 0, -691/2730, 0, 7/6 ] gap> Bernoulli( 80 ); -4603784299479457646935574969019046849794257872751288919656867/230010 # thats it for the combinatorical package ################################## gap> STOP_TEST( "combinat.tst", 5300000 ); ############################################################################# ## #E gap-4r6p5/tst/matrix.tst0000644000175000017500000003266712172557256014035 0ustar billbill############################################################################# ## #W matrix.tst GAP Tests Robert F. Morse ## ## ## #Y (C) 1998 School Math. and Comp. Sci., University of St Andrews, Scotland ## ## Exclude from testinstall.g: why? ## gap> START_TEST("matrix.tst"); gap> ## gap> ## gap> ######################################################################## gap> ## gap> ## Categories of Matrices gap> ## gap> ## gap> r := Rationals;; gap> m := RandomMat(10,10,r);; gap> IsMatrix(m); true gap> IsTable(m); true gap> IsRectangularTable(m); true gap> m := [RandomMat(10,10,r)];; gap> IsMatrix(m); false gap> IsTable(m); true gap> m := RandomMat(10,10,r);; gap> IsOrdinaryMatrix(m); true gap> IsLieMatrix(m); false gap> #T gap> #T Make malformed matrices of both types gap> #T gap> m := [[1,2,3],[1,2],[1]];; gap> IsMatrix(m); true gap> IsOrdinaryMatrix(m); true gap> IsTable(m); true gap> IsRectangularTable(m); false gap> m := LieObject(m);; gap> IsMatrix(m); true gap> IsLieMatrix(m); true gap> IsTable(m); true gap> IsRectangularTable(m); false gap> ## gap> m := LieObject(RandomMat(50,50,[-100..100]));; gap> IsLieMatrix(m); true gap> IsOrdinaryMatrix(m); false gap> m*m=Zero(m); true gap> m1 := LieObject(IdentityMat(50));; gap> m*m1=m; false gap> #T gap> #T From the manual: A matrix is a list of lists of equal length gap> #T whose entries lie in a common ring gap> #T gap> #T But not rings represented as matrices. gap> #T gap> m := RandomInvertibleMat(5,GF(3));; gap> r := Ring(m);; gap> IsFinite(r); true gap> e:=Random(r);; gap> m1 := [[e,e],[e,e]];; gap> IsMatrix(m1); false gap> IsRingElement(e); true gap> nm := NullMat(2,2,r);; gap> IsMatrix(nm); false gap> d := DiagonalMat([e,e]);; gap> IsMatrix(d); false gap> ## gap> ######################################################################## gap> ## gap> ## Operators for Matrices gap> ## gap> ## gap> m := RandomInvertibleMat(10,Rationals);; gap> m1 := RandomInvertibleMat(10,Rationals);; gap> v := Flat(RandomMat(1,10,Rationals));; gap> e := 3/23;; gap> ## gap> ## scalar ops gap> ## gap> e*m/e=m; true gap> (m/e)*e=m; true gap> (e/m)=m^-1*e; true gap> e+m-e = m; true gap> ## list ops gap> mlst := [m,m1,m,m1];; gap> e+mlst-e = mlst; true gap> e*mlst/e=mlst; true gap> #T gap> #T not sure why this is a syntax error gap> #T (m^-1*mlst*m){[1,3]} = mlst{[1,3]}; gap> #T gap> m1lst := m^-1*mlst*m;; gap> m1lst{[1,3]}=mlst{[1,3]}; true gap> ## gap> r := Integers;; gap> n := Random([5..10]);; gap> rm := RandomInvertibleMat(n,r);; rmi := rm^-1;; gap> e*rmi = e/rm; true gap> rm*rmi = rm/rm; true gap> Comm(rm,IdentityMat(n,r))=IdentityMat(n,r); true gap> Comm(rm,rm)=IdentityMat(n,r); true gap> Comm(rm,rmi)=One(rm); true gap> ## gap> ## vector ops gap> ## gap> v1 := v*m;; gap> v1[1]=Sum(List([1..10],x->v[x]*m[x][1])); true gap> v1 := m*v{[1..5]};; gap> v1[1]=Sum(List([1..5],x->m[1][x]*v[x])); true gap> rm := RandomInvertibleMat(5,r);; rmi := rm^-1;; gap> rm*rmi = rmi*rm; true gap> v := List([1..5],x->Random(r));; gap> v*rmi = v/rm; true gap> v := List([1..5],x->rmi[1][x]);; gap> v*rm = [One(rm[1][1]),Zero(rm[1][1]),Zero(rm[1][1]),Zero(rm[1][1]),Zero(rm[1][1])]; true gap> ## gap> ## More general ring gap> ## gap> r := GroupRing(GF(2), ElementaryAbelianGroup(4));; gap> m := RandomMat(10,5,r);; gap> v := Flat(RandomMat(1,10,r));; gap> e := Random(r);; gap> ## gap> ## scalar ops gap> ## gap> m1 := e*m;; gap> m1[5][5] = e*m[5][5]; true gap> m1 := e+m;; gap> m1[3][1] = e+m[3][1]; true gap> m1 := m+e;; gap> m1[3][1] = e+m[3][1]; true gap> m1 := e-m;; gap> m1[3][1] = e-m[3][1]; true gap> m1 := m-e;; gap> m1[3][1] = m[3][1]-e; true gap> mlst := [m,m1,m,m1];; gap> mlst1 := e * mlst;; gap> e*mlst[1]=mlst1[3]; true gap> mlst := [m,m1,m,m1];; gap> mlst1 := e + mlst;; gap> e+mlst[1]=mlst1[3]; true gap> ## gap> ## vector ops gap> ## gap> v1 := v*m;; gap> v1[1]=Sum(List([1..10],x->v[x]*m[x][1])); true gap> v1 := m*v{[1..5]};; gap> v2 := Sum(List([1..5],x->m[1][x]*v[x]));; gap> v1[1]=v2; true gap> ## gap> ## gap> ######################################################################## gap> ## gap> ## Properties and Attributes of Matrices gap> ## gap> #T gap> #T Dimensions of malformed matrices gap> #T gap> m := [[1,2,3],[2,3]];; gap> DimensionsMat(m); fail gap> m := [[1],[1,2]];; gap> DimensionsMat(m); fail gap> m := [[1,2,3,4],[1,2,3,4]];; gap> DimensionsMat(m); [ 2, 4 ] gap> TransposedMatDestructive(m);; gap> DimensionsMat(m); [ 4, 2 ] gap> ## gap> m := [[Random(GF(34147))]];; gap> DefaultFieldOfMatrix(m); GF(34147) gap> ## gap> pr := PolynomialRing(Integers,15);; gap> v := IndeterminatesOfPolynomialRing(pr);; gap> d:= DiagonalMat(v);; gap> Trace(d)=Sum(v); true gap> v1 := v*d;; gap> v2 := List(v,x->x^2);; gap> v1=v2; true gap> ## gap> n:=5;; gap> ##base elements for Vandermonde matrix gap> v := [1/5,1/4,1/3,1/2,1];; ##Rationals gap> M := List(v,x->List([0..n-1],y->x^y));; ## build Vandermonde matrix gap> VD := Product(List(Filtered(Cartesian([1..n],[1..n]), > x->x[1]v[x[2]]-v[x[1]]));; ## determine analytically determinant gap> D := Determinant(M);; ## compute gap> VD=D; ## compare true gap> D := DeterminantMatDivFree(M);; ## second method for testing gap> VD=D; true gap> n:=5;; gap> ##base elements for Vandermonde matrix gap> v := [1,3,5,7,11];; #integers gap> M := List(v,x->List([0..n-1],y->x^y));; ## build Vandermonde matrix gap> VD := Product(List(Filtered(Cartesian([1..n],[1..n]), > x->x[1]v[x[2]]-v[x[1]]));; ## determine analytically determinant gap> D := Determinant(M);; ## compute gap> VD=D; ## compare true gap> D := DeterminantMatDivFree(M);; ## second method for testing gap> VD=D; true gap> v:=Elements(ZmodnZ(12)){[4..8]};; gap> M := List(v,x->List([0..n-1],y->x^y));; ## build Vandermonde matrix gap> VD := Product(List(Filtered(Cartesian([1..n],[1..n]), > x->x[1]v[x[2]]-v[x[1]]));; ## determine analytically determinant gap> D := DeterminantMatDivFree(M);; ## can we only use the division free method gap> VD=D; true gap> ## gap> v:=Elements(GF(97)){[26..50]};; gap> d:= DiagonalMat(v);; gap> Product(v)=Determinant(d); true gap> Product(v)=DeterminantMatDivFree(d); true gap> v:=Elements(GroupRing(GF(2),ElementaryAbelianGroup(8))){[26..50]};; gap> d:= DiagonalMat(v);; gap> Product(v)=DeterminantMatDivFree(d); true gap> ## gap> x := Indeterminate(Integers,1);; gap> hm := [[x,x^0,0*x,0*x], [x^0,x,x^0,0*x], [0*x,x^0,x,x^0], [0*x,0*x,x^0,x]];; gap> DeterminantMatDivFree(hm); x_1^4-3*x_1^2+1 gap> ## gap> ## Simple matrix functions for testing gap> ## gap> Minor := function(m,i,j) local m1; > m1 := TransposedMat(m{Filtered([1..Length(m)],x->x<>i)}); > return TransposedMat(m1{Filtered([1..Length(m1)],x->x<>j)}); > end;; gap> Cofactor := function(m,i,j) > return (-One(m[1][1]))^(i+j)*DeterminantMat(Minor(m,i,j)); > end;; gap> CofactorDV := function(m,i,j) > return (-One(m[1][1]))^(i+j)*DeterminantMatDivFree(Minor(m,i,j)); > end;; gap> Adjoint := m-> > TransposedMat(List([1..Length(m)], > i-> List([1..Length(m[i])], j-> Cofactor(m,i,j))));; gap> AdjointDV := m-> > TransposedMat(List([1..Length(m)], > i-> List([1..Length(m[i])], j-> CofactorDV(m,i,j))));; gap> ## gap> ## Adjoint(m)*m = Det(m)*I gap> m := RandomInvertibleMat(20,GF(2));; gap> Adjoint(m)*m = DeterminantMat(m)*One(m); true gap> AdjointDV(m)*m = DeterminantMatDivFree(m)*One(m); #for testing true gap> ## gap> n:=5;; gap> VV:=Elements(ZmodnZ(12)){[4..8]};; gap> MM := List(VV,x->List([0..n-1],y->x^y));; ## build Vandermonde matrix gap> AdjointDV(MM)*MM = DeterminantMatDivFree(M)*One(M); true gap> ## gap> ######################################################################## gap> ## gap> ## Matrix Constructions gap> ## gap> ## gap> m := IdentityMat(40,Rationals);; gap> v := List([1..40],x->One(Rationals));; gap> m1 := DiagonalMat(v);; gap> m=m1; true gap> IsMatrix(IdentityMat(0,GF(2))); true gap> nm := NullMat(40,40,Rationals);; gap> nm=m-m; true gap> #T gap> #T We cannot determine the default field in this case. gap> #T But can do some reasonabe things with the matrix. gap> #T gap> pr := PolynomialRing(Integers);; gap> x := IndeterminatesOfPolynomialRing(pr)[1];; gap> m := IdentityMat(5,pr);; gap> v := List([1..5],x->One(pr));; gap> m1 := DiagonalMat(v);; gap> m=m1; true gap> DefaultFieldOfMatrix(m); fail gap> nm := NullMat(5,5,pr);; gap> nm=m-m; true gap> #T gap> #T EmptyMatrix Naming convention does not follow the gap> #T other operations/constructions gap> #T gap> em := EmptyMatrix(2); EmptyMatrix( 2 ) gap> IsMutable(em); false gap> em0 := EmptyMatrix(0); EmptyMatrix( 0 ) gap> em=em0; true gap> DimensionsMat(em); [ 0, 0 ] gap> em+em=em; true gap> em^em=em; true gap> []*em =em*[]; true gap> 3*em=em; true gap> #T gap> #T Can't use the ^ or + operations as stated in the manual: gap> #T []+em; gives a no method found gap> #T []^em; gives a no method found gap> #T gap> #T Must compare as lists gap> #T gap> []=em; true gap> IsMatrix([]); false gap> ## gap> #T Allows to construct over a ring but not its elements gap> #T x := Indeterminate(Integers); gap> #T PermutationMat((),30,x); no method found gap> ## gap> pr := PolynomialRing(Integers);; gap> pm := PermutationMat((),30,pr);; gap> pm = IdentityMat(30,pr); true gap> pm = IdentityMat(30,1); false gap> pm := PermutationMat((1,2,3),3,pr);; gap> pm1:= PermutationMat((1,2),3,pr);; gap> pm*pm1 = PermutationMat((2,3),3,pr); true gap> #T gap> #T According to the manual should return a matrix gap> #T gap> IsMatrix(PermutationMat((),0,GF(2))); false gap> ## gap> tm := TransposedMat(pm);; gap> IsMutable(tm); false gap> tm := MutableTransposedMat(pm);; gap> IsMutable(tm); true gap> TransposedMat(IdentityMat(50,Rationals))=IdentityMat(50,Rationals); true gap> m := [[1,2,3],[4,5,6],[7,8,9]];; gap> m1 := TransposedMat(m);; gap> TransposedMatDestructive(m);; gap> m=m1; true gap> ## gap> m := [[1,2]];; gap> m1 := [[5,7],[9,2]];; gap> kp := KroneckerProduct(m,m1); [ [ 5, 7, 10, 14 ], [ 9, 2, 18, 4 ] ] gap> [DimensionsMat(m)[1]*DimensionsMat(m1)[1], > DimensionsMat(m)[2]*DimensionsMat(m1)[2]] = DimensionsMat(kp); true gap> r := GF(269);; gap> m1 := RandomInvertibleMat(4,r);; gap> m2 := RandomInvertibleMat(4,r);; gap> m3 := RandomInvertibleMat(4,r);; gap> m4 := RandomInvertibleMat(4,r);; gap> ## gap> ## associativity, distributive, operation preserving gap> KroneckerProduct(m1,KroneckerProduct(m2,m3))= > KroneckerProduct(KroneckerProduct(m1,m2),m3); true gap> KroneckerProduct(m1,m2+m3)=KroneckerProduct(m1,m2)+KroneckerProduct(m1,m3); true gap> TransposedMat(KroneckerProduct(m1,m2))= > KroneckerProduct(TransposedMat(m1),TransposedMat(m2)); true gap> Inverse(KroneckerProduct(m1,m2))= > KroneckerProduct(Inverse(m1),Inverse(m2)); true gap> Trace(KroneckerProduct(m1,m2))= Trace(m1)*Trace(m2); true gap> KroneckerProduct(m1*m2,m3*m4)= > KroneckerProduct(m1,m3)*KroneckerProduct(m2,m4); true gap> ## use known relations about eigenvalues gap> kb := KroneckerProduct(m1,m3);; gap> Set(Eigenvalues(r,kb)) = > Set(Flat(List(Eigenvalues(r,m1), x->x*Eigenvalues(r,m3)))); true gap> ## gap> ## Malformed construction gap> KroneckerProduct([[1,2],[1,2]],[[5],[9,2,3]]);; gap> DimensionsMat(last); fail gap> ## gap> rm:=ReflectionMat([1,2,3,4,5,6,7,8,9,10]);; gap> rm*[1,2,3,4,5,6,7,8,9,10]=[-1,-2,-3,-4,-5,-6,-7,-8,-9,-10]; true gap> rm*rm*[1,2,3,4,5,6,7,8,9,10]=[1,2,3,4,5,6,7,8,9,10]; true gap> rm^2=One(rm); true gap> rm:=ReflectionMat([1,2,3,4,5,6,7,8,9,10],E(10));; gap> rm^10=One(rm); true gap> pr := PolynomialRing(Integers);; gap> x := IndeterminatesOfPolynomialRing(pr)[1];; gap> v := List([0..4],z->x^z);; gap> rm := ReflectionMat(v,x->-x);; gap> rm*v=-v; true gap> rm^2=One(rm); true gap> rm := ReflectionMat(v,x->x,E(3));; gap> rm^3=One(rm); true gap> ## gap> ######################################################################## gap> ## gap> ## Random Matrices gap> ## gap> ## gap> m := RandomMat(10,43,[100,1000]);; gap> DimensionsMat(m); [ 10, 43 ] gap> m := RandomInvertibleMat(10,GF(23));; gap> One(m)=IdentityMat(10,GF(23)); true gap> m^-1*m=IdentityMat(10,GF(23)); true gap> m^0=One(m); true gap> #T gap> #T RandomInvertibleMat fails at *times* for rings since it uses gap> #T a method that requires multiplicative inverses. gap> #T So we get random failures for gap> #T gr := GroupRing(Integers, CyclicGroup(10)); gap> #T RandomInvertibleMat(2,gr); gap> #T gap> #T When it does return how does it know it has an inverse? Can't use inverse. gap> #T gap> m := RandomUnimodularMat(10);; gap> AbsInt(Determinant(m))=1; true gap> ######################################################################## gap> ## gap> ## Matrices Representing Linear Equations and the Gaussian Algorithm gap> ## gap> ## gap> ######################################################################## gap> ## gap> ## Eigenvectors and eigenvalues gap> ## gap> ## gap> ######################################################################## gap> ## gap> ## Elementary Divisors gap> ## gap> ## gap> ######################################################################## gap> ## gap> ## Echelonized Matrices gap> ## gap> ## gap> ######################################################################## gap> ## gap> ## Matrices as Basis of a Row Space gap> ## gap> ## gap> ######################################################################## gap> ## gap> ## Triangular Matrices gap> ## gap> ## gap> ######################################################################## gap> ## gap> ## Matrices as Linear Mappings gap> ## gap> ## gap> ######################################################################## gap> STOP_TEST( "matrix.tst", 882500000 ); ############################################################################# ## #E gap-4r6p5/tst/algmat.tst0000644000175000017500000002103112172557256013755 0ustar billbill############################################################################# ## #W algmat.tst GAP library Thomas Breuer ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## To be listed in testinstall.g ## gap> START_TEST("algmat.tst"); ############################################################################# gap> Ring( [ [ [ Z(9), Z(3) ], [ Z(3), 0*Z(3) ] ], > [ [ 0*Z(9), Z(27) ], [ Z(3)^0, Z(3) ] ] ] ); gap> Ring( [ [ 1, E(5) ], [ E(5), 0 ] ] ); gap> Ring( [ [ 1, 0 ], [ 0, 0 ] ], [ [ 0, E(5) ], [ E(7), 5 ] ] ); gap> RingWithOne( [ [ [ Z(9), Z(3) ], [ Z(3), 0*Z(3) ] ], > [ [ 0*Z(9), Z(27) ], [ Z(3)^0, Z(3) ] ] ] ); gap> RingWithOne( [ [ 1, E(5) ], [ E(5), 0 ] ] ); gap> RingWithOne( [ [ 1, 0 ], [ 0, 0 ] ], [ [ 0, E(5) ], [ E(7), 5 ] ] ); gap> mat:= [ [ 1, E(4) ], [ 1, 1 ] ]; [ [ 1, E(4) ], [ 1, 1 ] ] gap> r:= DefaultRing( [ mat ] ); gap> mat in r; true ############################################################################# gap> z:= Algebra( GF(3), [], [ [ 0*Z(9), 0*Z(3) ], [ 0*Z(3), 0*Z(3) ] ] ); gap> IsGaussianMatrixSpace( z ); true gap> IsTrivial( z ); true gap> Dimension( z ); 0 gap> a:= Algebra( GF(3), [ [ [ Z(9), Z(3) ], [ Z(3), 0*Z(3) ] ], > [ [ 0*Z(9), Z(27) ], [ Z(3)^0, Z(3) ] ] ] ); gap> IsNonGaussianMatrixSpace( a ); true gap> Dimension( a ); 24 gap> b:= Algebra( Rationals, [ [ [ 1, E(5) ], [ E(5), 0 ] ] ] ); gap> IsNonGaussianMatrixSpace( b ); true gap> Dimension( b ); 8 gap> c:= Algebra( CF(5), [ [ [ 1, E(5) ], [ E(5), 0 ] ] ], > [ [ 0, 0 ], [ 0, 0 ] ] ); gap> IsGaussianMatrixSpace( c ); true gap> Dimension( c ); 2 gap> d:= Algebra( Rationals, [ [ [ 1, 0 ], [ 0, 0 ] ], > [ [ 0, E(3) ], [ E(4), 5 ] ] ] ); gap> IsNonGaussianMatrixSpace( d ); true gap> Dimension( d ); 16 ############################################################################# gap> uz:= AlgebraWithOne( GF(3), [], > [ [ 0*Z(9), 0*Z(3) ], [ 0*Z(3), 0*Z(3) ] ] ); gap> IsGaussianMatrixSpace( uz ); true gap> IsTrivial( uz ); false gap> Dimension( uz ); 1 gap> ua:= AlgebraWithOne( GF(3), [ [ [ Z(9), Z(3) ], [ Z(3), 0*Z(3) ] ], > [ [ 0*Z(9), Z(27) ], [ Z(3)^0, Z(3) ] ] ] ); gap> IsNonGaussianMatrixSpace( ua ); true gap> Dimension( ua ); 24 gap> ub:= AlgebraWithOne( Rationals, [ [ [ 1, E(5) ], [ E(5), 0 ] ] ] ); gap> IsNonGaussianMatrixSpace( ub ); true gap> Dimension( ub ); 8 gap> uc:= AlgebraWithOne( CF(5), [ [ [ 1, E(5) ], [ E(5), 0 ] ] ], > [ [ 0, 0 ], [ 0, 0 ] ] ); gap> IsGaussianMatrixSpace( uc ); true gap> Dimension( uc ); 2 gap> ud:= AlgebraWithOne( Rationals, [ [ [ 1, 0 ], [ 0, 0 ] ], > [ [ 0, E(3) ], [ E(4), 5 ] ] ] ); gap> IsNonGaussianMatrixSpace( ud ); true gap> Dimension( ud ); 16 ############################################################################# gap> IsUnit( c, Zero( c ) ); false gap> r:= [ [ 1, 1 ], [ 1, 1 ] ]; r in c; IsUnit( c, r ); [ [ 1, 1 ], [ 1, 1 ] ] false false gap> r:= [ [ 1, 1 ], [ 0, 1 ] ]; r in c; IsUnit( c, r ); [ [ 1, 1 ], [ 0, 1 ] ] false false gap> IsUnit( c, [ [ 1, E(5) ], [ E(5), 0 ] ] ); true gap> IdentityMat( 2, GF(3) ); [ [ Z(3)^0, 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ] ############################################################################# gap> IsAssociative( a ); true gap> rada:= RadicalOfAlgebra( a ); gap> Dimension( rada ); 0 gap> IsAssociative( c ); true gap> radc:= RadicalOfAlgebra( c ); gap> Dimension( radc ); 0 ############################################################################# gap> cen:= Centralizer( c, GeneratorsOfAlgebra( c )[1] ); gap> cen = c; true gap> cen:= Centralizer( c, cen ); gap> cen = c; true gap> cen:= Centralizer( uc, GeneratorsOfAlgebra( uc )[1] ); gap> cen = uc; true gap> cen:= Centralizer( uc, cen ); gap> cen = uc; true gap> cen:= Centralizer( a, GeneratorsOfAlgebra( a )[1] ); gap> Dimension( cen ); 12 gap> cen:= Centralizer( a, cen ); gap> Dimension( cen ); 12 gap> cen:= Centralizer( ua, One( ua ) ); gap> cen = ua; true gap> cen:= Centralizer( ua, GeneratorsOfAlgebra( ua )[2] ); gap> Dimension( cen ); 12 gap> cen:= Centralizer( ua, cen ); gap> Dimension( cen ); 12 ############################################################################# gap> fullcen:= FullMatrixAlgebraCentralizer( CF(5), > GeneratorsOfAlgebra( c ) ); gap> Dimension( fullcen ); 2 gap> fullcen:= FullMatrixAlgebraCentralizer( GF(3^6), > GeneratorsOfAlgebra( a ) ); gap> Dimension( fullcen ); 1 ############################################################################# gap> f:= GF(2)^[3,3]; ( GF(2)^[ 3, 3 ] ) gap> f = FullMatrixFLMLOR( GF(2), 3 ); true gap> IsFullMatrixModule( f ); true gap> IsAlgebra( f ); true gap> u:= Algebra( GF(2), > [ [ [ 1, 1, 1 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ] * Z(2) ] ); gap> Dimension( u ); 2 gap> IsSubset( f, u ); true gap> cenu:= Centralizer( f, u ); gap> Dimension( cenu ); 5 gap> v:= FreeLeftModule( GF(2), > [ [ [ 1, 1, 1 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ] * Z(2) ] ); gap> Dimension( v ); 1 gap> IsSubset( f, v ); true gap> cenv:= Centralizer( f, v ); gap> Dimension( cenv ); 5 gap> IsSubset( cenv, cenu ); true gap> cenv = Centralizer( f, GeneratorsOfLeftModule( v ) ); true gap> gap> Centralizer( f, [] ) = f; true ############################################################################# gap> l:= FullMatrixLieAlgebra( GF(2), 3 ); gap> Dimension( l ); 9 ############################################################################# gap> sum:= DirectSumOfAlgebras( f, f ); gap> Dimension( sum ) = 2 * Dimension( f ); true gap> IsFullMatrixModule( sum ); false gap> sum:= DirectSumOfAlgebras( l, l ); gap> Dimension( sum ) = 2 * Dimension( l ); true gap> IsFullMatrixModule( sum ); false gap> sum:= DirectSumOfAlgebras( l, f ); gap> Dimension( sum ) = 2 * Dimension( l ); true gap> IsFullMatrixModule( sum ); false ############################################################################# gap> n:= NullAlgebra( GF(3) ); gap> Dimension( n ); 0 gap> b:= Basis( n ); SemiEchelonBasis( , [ ] ) gap> BasisVectors( b ); [ ] gap> zero:= Zero( n ); EmptyMatrix( 3 ) gap> Coefficients( b, zero ); [ ] gap> zero + zero = zero; true gap> zero * zero = zero; true gap> [] * zero; [ ] gap> zero * []; [ ] gap> Z(3) * zero = zero; true gap> zero * Z(3) = zero; true gap> zero^3 = zero; true gap> zero^-3 = zero; true ############################################################################# # missing: F.p. algebras # missing: standard bases of matrix algebras, # fingerprints, 'RepresentativeOperation' # missing: natural modules, abstract expressions, field multiplicity ############################################################################# gap> STOP_TEST( "algmat.tst", 180800000 ); ############################################################################# ## #E gap-4r6p5/tst/fldabnum.tst0000644000175000017500000002000312172557256014276 0ustar billbill############################################################################# ## #W fldabnum.tst GAP library Thomas Breuer ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## Exclude from testinstall.g: why? ## gap> START_TEST("fldabnum.tst"); gap> CF( 1 ); CF( 6 ); CF( 4 ); CF( 5 ); CF( 36 ); Rationals CF(3) GaussianRationals CF(5) CF(36) gap> CF( [ E(3), E(5) ] ); CF(15) gap> CF( CF(3), 12 ); AsField( CF(3), CF(12) ) gap> CF( CF(3), [ E(3), E(4) ] ); AsField( CF(3), CF(12) ) gap> NF( 7, [ 1 ] ); NF( 7, [ 2 ] ); NF( 7, [ 1, 2, 4 ] ); CF(7) NF(7,[ 1, 2, 4 ]) NF(7,[ 1, 2, 4 ]) gap> NF( 8, [ 5 ] ); GaussianRationals gap> CF(5) = CF(7); false gap> CF(5) = NF( 15, [ 1 ] ); false gap> CF(5) = NF( 15, [ 11 ] ); true gap> NF( 15, [ 4 ] ) = CF(3); false gap> NF( 15, [ 7 ] ) = CF(3); true gap> CF(8) < CF(9); true gap> CF(9) < CF(8); false gap> CF(5) < NF( 5, [ 4 ] ); true gap> NF( 5, [ 4 ] ) < CF(5); false gap> NF( 8, [ 3 ] ) < NF( 8, [ 5 ] ); false gap> NF( 8, [ 5 ] ) < NF( 8, [ 7 ] ); true gap> NF( 8, [ 7 ] ) < NF( 8, [ 3 ] ); false gap> E(5) in CF(7); false gap> E(5) in CF(10); true gap> Z(5) in CF(5); false gap> E(5) in NF( 7, [ 2 ] ); false gap> E(5) in NF( 5, [ 4 ] ); false gap> Z(5) in NF( 3, [ 2 ] ); false gap> EY(5) in NF( 5, [ 4 ] ); true gap> Intersection( CF(12), CF(15) ); CF(3) gap> Intersection( CF(12), NF( 15, [ 14 ] ) ); Rationals gap> Intersection( NF( 12, [ 5 ] ), CF(15) ); Rationals gap> Intersection( NF( 12, [ 5 ] ), NF( 15, [ 14 ] ) ); Rationals gap> Intersection( NF( 12, [ 7 ] ), NF( 15, [ 7 ] ) ); CF(3) gap> Intersection( NF( 35, [ 34 ] ), NF( 15, [ 11 ] ) ); NF(5,[ 1, 4 ]) gap> GeneratorsOfField( CF(37) ); [ E(37) ] gap> GeneratorsOfField( NF( 15, [ 2 ] ) ); [ E(15)+E(15)^2+E(15)^4+E(15)^8 ] gap> Conductor( CF(7) ); 7 gap> Conductor( NF( 17, [ 3 ] ) ); 1 gap> Conductor( NF( 15, [ 3 ] ) ); 15 gap> Subfields( CF(15) ); [ Rationals, CF(3), CF(5), NF(5,[ 1, 4 ]), CF(15), NF(15,[ 1, 2, 4, 8 ]), NF(15,[ 1, 4 ]), NF(15,[ 1, 14 ]) ] gap> Subfields( NF( 15, [ 14 ] ) ); [ Rationals, NF(5,[ 1, 4 ]), NF(15,[ 1, 14 ]) ] gap> x:= Indeterminate( Rationals );; pol:= x^2 + x + 1;; gap> FieldExtension( Rationals, pol ); CF(3) gap> FieldExtension( CF(5), pol ); AsField( CF(5), CF(15) ) gap> x:= Indeterminate( Rationals );; pol:= x^2 - x - 1;; gap> FieldExtension( Rationals, pol ); NF(5,[ 1, 4 ]) gap> Conjugates( CF( CF(3), 15 ), E(15) ); [ E(15), E(15)^4, E(15)^7, E(15)^13 ] gap> Conjugates( CF(15), E(15) ); [ E(15), E(15)^2, E(15)^4, E(15)^7, E(15)^8, E(15)^11, E(15)^13, E(15)^14 ] gap> Conjugates( AsField( CF(3), NF( 15, [ 4 ] ) ), E(15) ); [ E(15), E(15)^7 ] gap> Conjugates( CF(15), E(15) ); [ E(15), E(15)^2, E(15)^4, E(15)^7, E(15)^8, E(15)^11, E(15)^13, E(15)^14 ] gap> Norm( CF( CF(3), 15 ), E(15) ); E(3)^2 gap> Norm( CF(15), E(15) ); 1 gap> Norm( AsField( CF(3), NF( 15, [ 4 ] ) ), E(15) ); E(15)^8 gap> Norm( CF(15), E(15) ); 1 gap> Trace( CF( CF(3), 15 ), E(15) ); -E(3)^2 gap> Trace( CF(15), E(15) ); 1 gap> Trace( AsField( CF(3), NF( 15, [ 4 ] ) ), E(15) ); E(15)+E(15)^7 gap> Trace( CF(15), E(15) ); 1 gap> ZumbroichBase( 12, 1 ); [ 4, 7, 8, 11 ] gap> ZumbroichBase( 12, 3 ); [ 0, 3 ] gap> ZumbroichBase( 12, 4 ); [ 4, 8 ] gap> Print(ZumbroichBase( 45, 1 ),"\n"); [ 1, 2, 3, 6, 7, 8, 11, 12, 16, 17, 19, 21, 24, 26, 28, 29, 33, 34, 37, 38, 39, 42, 43, 44 ] gap> ZumbroichBase( 10, 1 ); [ 2, 4, 6, 8 ] gap> ZumbroichBase( 5, 1 ); [ 1, 2, 3, 4 ] gap> ZumbroichBase( 16, 1 ); [ 0, 1, 2, 3, 4, 5, 6, 7 ] gap> LenstraBase( 12, [ 1, 5 ], [ 1 ], 1 ); [ [ 4, 8 ], [ 7, 11 ] ] gap> LenstraBase( 12, [ 1, 5 ], [ 1 ], 3 ); [ [ 0, 0 ], [ 3, 3 ] ] gap> LenstraBase( 8, [ 1, 3 ], [ 1 ], 1 ); [ [ 0 ], [ 1, 3 ] ] gap> LenstraBase( 15, [ 1, 4 ], [ 2 ], 1 ); [ [ 1, 4 ], [ 2, 8 ], [ 7, 13 ], [ 11, 14 ] ] gap> c:= Basis( CF(12) ); CanonicalBasis( CF(12) ) gap> BasisVectors( c ); [ E(3), E(12)^7, E(3)^2, E(12)^11 ] gap> Coefficients( c, E(12) ); [ 0, -1, 0, 0 ] gap> Coefficients( c, E( 4) ); [ 0, -1, 0, -1 ] gap> Coefficients( c, E( 3) ); [ 1, 0, 0, 0 ] gap> Coefficients( c, E( 6) ); [ 0, 0, -1, 0 ] gap> Coefficients( c, E( 8) ); fail gap> c:= Basis( NF( 12, [ 11 ] ) ); CanonicalBasis( NF(12,[ 1, 11 ]) ) gap> BasisVectors( c ); [ -1, E(12)^7-E(12)^11 ] gap> Coefficients( c, E(12) ); fail gap> Coefficients( c, EY(12) ); [ 0, -1 ] gap> c:= Basis( AsField( CF(3), CF(12) ) ); CanonicalBasis( AsField( CF(3), CF(12) ) ) gap> BasisVectors( c ); [ 1, E(4) ] gap> Coefficients( c, E(12) ); [ 0, -E(3) ] gap> Coefficients( c, E( 4) ); [ 0, 1 ] gap> Coefficients( c, E( 3) ); [ E(3), 0 ] gap> Coefficients( c, E( 6) ); [ -E(3)^2, 0 ] gap> Coefficients( c, E( 8) ); fail gap> c:= Basis( AsField( GaussianRationals, NF( 12, [ 5 ] ) ) ); CanonicalBasis( AsField( GaussianRationals, CF(4) ) ) gap> BasisVectors( c ); [ 1 ] gap> Coefficients( c, E(12) ); fail gap> Coefficients( c, E(12)+E(12)^5 ); [ E(4) ] gap> c:= Basis( AsField( NF( 5, [ 4 ] ), CF(15) ) ); CanonicalBasis( AsField( NF(5,[ 1, 4 ]), CF(15) ) ) gap> Print(BasisVectors( c ),"\n"); [ -1/15*E(15)+2/15*E(15)^2+2/5*E(15)^4-2/15*E(15)^7+8/15*E(15)^8+1/15*E(15)^11 +7/15*E(15)^13+3/5*E(15)^14, 2/5*E(15)+8/15*E(15)^2-1/15*E(15)^4+7/15*E(15)^7+2/15*E(15)^8+3/5*E(15)^11 -2/15*E(15)^13+1/15*E(15)^14, 1/15*E(15)-2/15*E(15)^2+3/5*E(15)^4+2/15*E(15)^7+7/15*E(15)^8-1/15*E(15)^11 +8/15*E(15)^13+2/5*E(15)^14, 3/5*E(15)+7/15*E(15)^2+1/15*E(15)^4+8/15*E(15)^7-2/15*E(15)^8+2/5*E(15)^11 +2/15*E(15)^13-1/15*E(15)^14 ] gap> Print(Coefficients( c, E(15) ),"\n"); [ 3*E(5)+E(5)^2+E(5)^3+3*E(5)^4, -3*E(5)-3*E(5)^4, -3*E(5)-2*E(5)^2-2*E(5)^3-3*E(5)^4, 3*E(5)+3*E(5)^4 ] gap> Coefficients( c, E( 5) ); [ -1, -E(5)^2-E(5)^3, -1, -E(5)^2-E(5)^3 ] gap> Coefficients( c, E( 3) ); [ -2, -2, 1, 1 ] gap> Coefficients( c, E( 6) ); [ -1, -1, 2, 2 ] gap> Coefficients( c, E( 8) ); fail gap> FieldByGenerators( [ 2, 3, 4, E(2), E(3), EY(5) ] ); NF(15,[ 1, 4 ]) gap> FieldByGenerators( Rationals, [ 2, 3, 4, E(2), E(3), EY(5) ] ); NF(15,[ 1, 4 ]) gap> FieldByGenerators( CF(3), [ 2, 3, 4, E(2), E(3), EY(5) ] ); AsField( CF(3), NF(15,[ 1, 4 ]) ) gap> DefaultFieldByGenerators( [ 2, 3, 4, E(2), E(3), EY(5) ] ); CF(15) gap> f:= CF(45); CF(45) gap> aut:= ANFAutomorphism( f, 2 ); ANFAutomorphism( CF(45), 2 ) gap> id:= IdentityMapping( f ); IdentityMapping( CF(45) ) gap> aut = id; false gap> aut^0 = id; true gap> aut = ANFAutomorphism( f, 47 ); true gap> id = aut^0; true gap> auts:= List( PrimeResidues( 45 ), i -> ANFAutomorphism( f, i ) );; gap> IsSSortedList( auts ); true gap> Position( auts, aut ); 2 gap> aut^0 < id; false gap> id < aut^0; false gap> Order( aut ); 12 gap> ImageElm( aut, E(45) ); E(45)^2 gap> Print(ImagesSet( aut, Conjugates( f, E(45) ) ),"\n"); [ -E(45)-E(45)^16, -E(45)^2-E(45)^17, -E(45)^7-E(45)^37, -E(45)^8-E(45)^38, -E(45)^11-E(45)^26, -E(45)^19-E(45)^34, -E(45)^28-E(45)^43, -E(45)^29-E(45)^44, E(45)^44, E(45)^43, E(45)^38, E(45)^37, E(45)^34, E(45)^29, E(45)^28, E(45)^26, E(45)^19, E(45)^17, E(45)^16, E(45)^11, E(45)^8, E(45)^7, E(45)^2, E(45) ] gap> ImagesRepresentative( aut, E(45) ); E(45)^2 gap> PreImageElm( aut, E(45) ); -E(45)^8-E(45)^38 gap> Print(PreImagesSet( aut, Conjugates( f, E(45) ) ),"\n"); [ -E(45)-E(45)^16, -E(45)^2-E(45)^17, -E(45)^7-E(45)^37, -E(45)^8-E(45)^38, -E(45)^11-E(45)^26, -E(45)^19-E(45)^34, -E(45)^28-E(45)^43, -E(45)^29-E(45)^44, E(45)^44, E(45)^43, E(45)^38, E(45)^37, E(45)^34, E(45)^29, E(45)^28, E(45)^26, E(45)^19, E(45)^17, E(45)^16, E(45)^11, E(45)^8, E(45)^7, E(45)^2, E(45) ] gap> PreImagesRepresentative( aut, E(45) ); -E(45)^8-E(45)^38 gap> aut * id; ANFAutomorphism( CF(45), 2 ) gap> id * aut; ANFAutomorphism( CF(45), 2 ) gap> aut * aut; ANFAutomorphism( CF(45), 4 ) gap> CompositionMapping( aut, aut ); ANFAutomorphism( CF(45), 4 ) gap> Inverse( aut ); ANFAutomorphism( CF(45), 23 ) gap> One( aut ); IdentityMapping( CF(45) ) gap> aut^3; ANFAutomorphism( CF(45), 8 ) gap> g:= GaloisGroup( f ); gap> Size( g ); 24 gap> IsAbelian( g ); true gap> STOP_TEST( "fldabnum.tst", 13400000 ); ############################################################################# ## #E gap-4r6p5/tst/grppcnrm.tst0000644000175000017500000010534312172557256014351 0ustar billbill############################################################################# ## #W grppcnrm.tst GAP library Frank Celler ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## To be listed in testinstall.g ## gap> START_TEST("grppcnrm.tst"); ############################################################################# # construct a nice big group gap> f := FreeGroup(IsSyllableWordsFamily,65);; gap> g := GeneratorsOfGroup(f);; # setup generators as "fn" gap> f1 := g[1];; f2 := g[2];; f3 := g[3];; f4 := g[4];; f5 := g[5];; f6 := > g[6];; f7 := g[7];; f8 := g[8];; f9 := g[9];; f10 := g[10];; f11 := > g[11];; f12 := g[12];; f13 := g[13];; f14 := g[14];; f15 := g[15];; > f16 := g[16];; f17 := g[17];; f18 := g[18];; f19 := g[19];; f20 := > g[20];; f21 := g[21];; f22 := g[22];; f23 := g[23];; f24 := g[24];; > f25 := g[25];; f26 := g[26];; f27 := g[27];; f28 := g[28];; f29 := > g[29];; f30 := g[30];; f31 := g[31];; f32 := g[32];; f33 := g[33];; > f34 := g[34];; f35 := g[35];; f36 := g[36];; f37 := g[37];; f38 := > g[38];; f39 := g[39];; f40 := g[40];; f41 := g[41];; f42 := g[42];; > f43 := g[43];; f44 := g[44];; f45 := g[45];; f46 := g[46];; f47 := > g[47];; f48 := g[48];; f49 := g[49];; f50 := g[50];; f51 := g[51];; > f52 := g[52];; f53 := g[53];; f54 := g[54];; f55 := g[55];; f56 := > g[56];; f57 := g[57];; f58 := g[58];; f59 := g[59];; f60 := g[60];; > f61 := g[61];; f62 := g[62];; f63 := g[63];; f64 := g[64];; f65 := > g[65];; # and now the relators gap> r := [ [ 2, f4*f8^2 ], [ 6, f8 ], [ 7, f9 ], [ 2, 1, f8^2 ], [ 4, 1, > f8 ], [ 5, 1, f5 ], [ 6, 1, f6*f8^2 ], [ 7, 1, f8^2 ], [ 8, 1, f8 ], [ > 10, 1, f11^6 ], [ 11, 1, f11^5 ], [ 24, 1, f24*f36 ], [ 25, 1, f25*f37 > ], [ 26, 1, f26*f38 ], [ 27, 1, f27*f39 ], [ 28, 1, f28*f40 ], [ 29, > 1, f29*f41 ], [ 30, 1, f30*f42 ], [ 31, 1, f31*f43 ], [ 32, 1, f32*f44 > ], [ 33, 1, f33*f45 ], [ 34, 1, f34*f46 ], [ 35, 1, f35*f47 ], [ 36, > 1, f24*f36 ], [ 37, 1, f25*f37 ], [ 38, 1, f26*f38 ], [ 39, 1, f27*f39 > ], [ 40, 1, f28*f40 ], [ 41, 1, f29*f41 ], [ 42, 1, f30*f42 ], [ 43, > 1, f31*f43 ], [ 44, 1, f32*f44 ], [ 45, 1, f33*f45 ], [ 46, 1, f34*f46 > ], [ 47, 1, f35*f47 ], [ 54, 1, f54*f60 ], [ 55, 1, f55*f61 ], [ 56, > 1, f56*f62 ], [ 57, 1, f57*f63 ], [ 58, 1, f58*f64 ], [ 59, 1, f59*f65 > ], [ 60, 1, f54*f60 ], [ 61, 1, f55*f61 ], [ 62, 1, f56*f62 ], [ 63, > 1, f57*f63 ], [ 64, 1, f58*f64 ], [ 65, 1, f59*f65 ], [ 5, 2, f6*f7 ], > [ 24, 2, f28 ], [ 25, 2, f24*f25*f27*f28 ], [ 26, 2, f25 ], [ 27, 2, > f26 ], [ 28, 2, f26*f27*f28*f29 ], [ 29, 2, f24 ], [ 30, 2, > f31*f32*f33*f35*f54*f56*f57*f59 ], [ 31, 2, > f30*f31*f34*f35*f54*f55*f56*f58*f59 ], [ 32, 2, > f31*f32*f35*f54*f55*f56*f57*f59 ], [ 33, 2, f31*f35*f54*f55*f58*f59 ], > [ 34, 2, f30*f31*f33*f35*f54*f55*f57 ], [ 35, 2, > f30*f31*f32*f34*f55*f56*f58 ], [ 36, 2, f37*f40*f41 ], [ 37, 2, > f38*f41 ], [ 38, 2, f37*f38*f40*f41 ], [ 39, 2, f36*f37*f40*f41 ], [ > 40, 2, f37*f38*f41 ], [ 41, 2, f36*f37*f39*f40*f41 ], [ 42, 2, f46*f65 > ], [ 43, 2, f46*f47*f60*f65 ], [ 44, 2, f42*f47*f61 ], [ 45, 2, > f43*f46*f62*f65 ], [ 46, 2, f44*f46*f47*f63*f65 ], [ 47, 2, > f45*f47*f64 ], [ 54, 2, f54*f56*f58 ], [ 55, 2, > f54*f55*f56*f57*f58*f59 ], [ 56, 2, f55*f56*f57*f58*f59 ], [ 57, 2, > f57*f59 ], [ 58, 2, f54*f56 ], [ 59, 2, f55*f57 ], [ 60, 2, f65 ], [ > 61, 2, f60*f65 ], [ 62, 2, f61 ], [ 63, 2, f62*f65 ], [ 64, 2, f63*f65 > ], [ 65, 2, f64 ], [ 12, 3, f12*f13*f14*f16*f17 ], [ 13, 3, > f13*f15*f16 ], [ 14, 3, f13*f17 ], [ 15, 3, f13*f15*f16*f17 ], [ 16, > 3, f14*f16*f17 ], [ 17, 3, f12*f13*f16 ], [ 18, 3, > f19*f21*f22*f48*f50*f52 ], [ 19, 3, > f18*f19*f20*f21*f23*f48*f49*f50*f51*f52*f53 ], [ 20, 3, > f19*f20*f21*f22*f49*f50*f51*f52*f53 ], [ 21, 3, f19*f20*f23*f51*f53 ], > [ 22, 3, f19*f20*f22*f48*f50 ], [ 23, 3, f18*f20*f21*f23*f49*f51 ], [ > 24, 3, f24*f25*f26*f28*f29 ], [ 25, 3, f25*f27*f28 ], [ 26, 3, f25*f29 > ], [ 27, 3, f25*f27*f28*f29 ], [ 28, 3, f26*f28*f29 ], [ 29, 3, > f24*f25*f28 ], [ 30, 3, f31*f33*f34*f54*f56*f58 ], [ 31, 3, > f30*f31*f32*f33*f35*f54*f55*f56*f57*f58*f59 ], [ 32, 3, > f31*f32*f33*f34*f55*f56*f57*f58*f59 ], [ 33, 3, f31*f32*f35*f57*f59 ], > [ 34, 3, f31*f32*f34*f54*f56 ], [ 35, 3, f30*f32*f33*f35*f55*f57 ], [ > 36, 3, f36*f37*f38*f40*f41 ], [ 37, 3, f37*f39*f40 ], [ 38, 3, f37*f41 > ], [ 39, 3, f37*f39*f40*f41 ], [ 40, 3, f38*f40*f41 ], [ 41, 3, > f36*f37*f40 ], [ 42, 3, f43*f45*f46*f60*f62*f64 ], [ 43, 3, > f42*f43*f44*f45*f47*f60*f61*f62*f63*f64*f65 ], [ 44, 3, > f43*f44*f45*f46*f61*f62*f63*f64*f65 ], [ 45, 3, f43*f44*f47*f63*f65 ], > [ 46, 3, f43*f44*f46*f60*f62 ], [ 47, 3, f42*f44*f45*f47*f61*f63 ], [ > 48, 3, f48*f50 ], [ 49, 3, f48*f49*f50*f51 ], [ 50, 3, > f48*f49*f50*f51*f52 ], [ 51, 3, f49*f51*f52*f53 ], [ 52, 3, > f48*f52*f53 ], [ 53, 3, f49*f53 ], [ 54, 3, f54*f56 ], [ 55, 3, > f54*f55*f56*f57 ], [ 56, 3, f54*f55*f56*f57*f58 ], [ 57, 3, > f55*f57*f58*f59 ], [ 58, 3, f54*f58*f59 ], [ 59, 3, f55*f59 ], [ 60, > 3, f60*f62 ], [ 61, 3, f60*f61*f62*f63 ], [ 62, 3, f60*f61*f62*f63*f64 > ], [ 63, 3, f61*f63*f64*f65 ], [ 64, 3, f60*f64*f65 ], [ 65, 3, > f61*f65 ], [ 5, 4, f8*f9^2 ], [ 36, 4, f37*f38*f40 ], [ 37, 4, > f38*f39*f40 ], [ 38, 4, f37*f38*f39*f41 ], [ 39, 4, f36*f38*f40 ], [ > 40, 4, f36*f38*f41 ], [ 41, 4, f36*f38*f39 ], [ 42, 4, > f45*f46*f61*f62*f63*f64*f65 ], [ 43, 4, f42*f45*f47*f60*f61 ], [ 44, > 4, f42*f43*f46*f60*f61*f62 ], [ 45, 4, f42*f43*f44*f45*f46*f47*f64*f65 > ], [ 46, 4, f43*f44*f47*f60*f61*f62*f63*f64 ], [ 47, 4, > f44*f45*f60*f61*f62*f63*f64*f65 ], [ 60, 4, f60*f63*f64 ], [ 61, 4, > f60*f61*f63*f65 ], [ 62, 4, f60*f61*f62*f64 ], [ 63, 4, > f60*f61*f62*f64*f65 ], [ 64, 4, f61*f62*f64*f65 ], [ 65, 4, > f62*f63*f65 ], [ 6, 5, f7^2*f9^2 ], [ 7, 5, f8*f9^2 ], [ 8, 5, f9^2 ], > [ 10, 5, f10^5*f11 ], [ 11, 5, f10^6*f11^6 ], [ 12, 5, f12*f24 ], [ > 13, 5, f13*f25 ], [ 14, 5, f14*f26 ], [ 15, 5, f15*f27 ], [ 16, 5, > f16*f28 ], [ 17, 5, f17*f29 ], [ 18, 5, f18*f30 ], [ 19, 5, f19*f31 ], > [ 20, 5, f20*f32 ], [ 21, 5, f21*f33 ], [ 22, 5, f22*f34 ], [ 23, 5, > f23*f35 ], [ 24, 5, f24*f36 ], [ 25, 5, f25*f37 ], [ 26, 5, f26*f38 ], > [ 27, 5, f27*f39 ], [ 28, 5, f28*f40 ], [ 29, 5, f29*f41 ], [ 30, 5, > f30*f42 ], [ 31, 5, f31*f43 ], [ 32, 5, f32*f44 ], [ 33, 5, f33*f45 ], > [ 34, 5, f34*f46 ], [ 35, 5, f35*f47 ], [ 36, 5, f12*f36 ], [ 37, 5, > f13*f37 ], [ 38, 5, f14*f38 ], [ 39, 5, f15*f39 ], [ 40, 5, f16*f40 ], > [ 41, 5, f17*f41 ], [ 42, 5, f18*f42 ], [ 43, 5, f19*f43 ], [ 44, 5, > f20*f44 ], [ 45, 5, f21*f45 ], [ 46, 5, f22*f46 ], [ 47, 5, f23*f47 ], > [ 48, 5, f48*f54 ], [ 49, 5, f49*f55 ], [ 50, 5, f50*f56 ], [ 51, 5, > f51*f57 ], [ 52, 5, f52*f58 ], [ 53, 5, f53*f59 ], [ 54, 5, f54*f60 ], > [ 55, 5, f55*f61 ], [ 56, 5, f56*f62 ], [ 57, 5, f57*f63 ], [ 58, 5, > f58*f64 ], [ 59, 5, f59*f65 ], [ 60, 5, f48*f60 ], [ 61, 5, f49*f61 ], > [ 62, 5, f50*f62 ], [ 63, 5, f51*f63 ], [ 64, 5, f52*f64 ], [ 65, 5, > f53*f65 ], [ 24, 6, f26 ], [ 25, 6, f26*f27*f28*f29 ], [ 26, 6, f28 ], > [ 27, 6, f24 ], [ 28, 6, f25 ], [ 29, 6, f27 ], [ 30, 6, > f30*f32*f34*f56*f57 ], [ 31, 6, f30*f31*f32*f33*f34*f35*f56*f58 ], [ > 32, 6, f31*f32*f33*f34*f35*f54*f57*f59 ], [ 33, 6, > f33*f35*f54*f55*f56*f57*f58 ], [ 34, 6, f30*f32*f54*f55*f58*f59 ], [ > 35, 6, f31*f33*f55*f56*f59 ], [ 36, 6, f37*f40*f41 ], [ 37, 6, f38*f41 > ], [ 38, 6, f37*f38*f40*f41 ], [ 39, 6, f36*f37*f40*f41 ], [ 40, 6, > f37*f38*f41 ], [ 41, 6, f36*f37*f39*f40*f41 ], [ 42, 6, f46*f65 ], [ > 43, 6, f46*f47*f60*f65 ], [ 44, 6, f42*f47*f61 ], [ 45, 6, > f43*f46*f62*f65 ], [ 46, 6, f44*f46*f47*f63*f65 ], [ 47, 6, > f45*f47*f64 ], [ 54, 6, f54*f55*f56*f57*f58*f59 ], [ 55, 6, f54 ], [ > 56, 6, f54*f55 ], [ 57, 6, f57*f58*f59 ], [ 58, 6, f54*f55*f56*f57 ], > [ 59, 6, f54*f55*f56*f57*f58 ], [ 60, 6, f65 ], [ 61, 6, f60*f65 ], [ > 62, 6, f61 ], [ 63, 6, f62*f65 ], [ 64, 6, f63*f65 ], [ 65, 6, f64 ], > [ 12, 7, f14 ], [ 13, 7, f14*f15*f16*f17 ], [ 14, 7, f16 ], [ 15, 7, > f12 ], [ 16, 7, f13 ], [ 17, 7, f15 ], [ 18, 7, f18*f20*f22*f50*f51 ], > [ 19, 7, f18*f19*f20*f21*f22*f23*f50*f52 ], [ 20, 7, > f19*f20*f21*f22*f23*f48*f51*f53 ], [ 21, 7, > f21*f23*f48*f49*f50*f51*f52 ], [ 22, 7, f18*f20*f48*f49*f52*f53 ], [ > 23, 7, f19*f21*f49*f50*f53 ], [ 24, 7, f26 ], [ 25, 7, f26*f27*f28*f29 > ], [ 26, 7, f28 ], [ 27, 7, f24 ], [ 28, 7, f25 ], [ 29, 7, f27 ], [ > 30, 7, f30*f32*f34*f56*f57 ], [ 31, 7, f30*f31*f32*f33*f34*f35*f56*f58 > ], [ 32, 7, f31*f32*f33*f34*f35*f54*f57*f59 ], [ 33, 7, > f33*f35*f54*f55*f56*f57*f58 ], [ 34, 7, f30*f32*f54*f55*f58*f59 ], [ > 35, 7, f31*f33*f55*f56*f59 ], [ 36, 7, f36*f39*f40*f41 ], [ 37, 7, > f36*f38*f39 ], [ 38, 7, f36*f37*f38*f39 ], [ 39, 7, f36*f37*f39 ], [ > 40, 7, f36*f39*f41 ], [ 41, 7, f39*f40*f41 ], [ 42, 7, > f44*f46*f47*f63*f64*f65 ], [ 43, 7, f44*f45*f46*f63 ], [ 44, 7, > f45*f46*f47*f60*f64 ], [ 45, 7, f44*f60*f61*f63*f64 ], [ 46, 7, > f42*f44*f45*f46*f47*f61*f62*f63 ], [ 47, 7, > f43*f45*f46*f47*f62*f63*f64 ], [ 48, 7, f48*f49*f50*f51*f52*f53 ], [ > 49, 7, f48 ], [ 50, 7, f48*f49 ], [ 51, 7, f51*f52*f53 ], [ 52, 7, > f48*f49*f50*f51 ], [ 53, 7, f48*f49*f50*f51*f52 ], [ 54, 7, > f54*f55*f56*f57*f58*f59 ], [ 55, 7, f54 ], [ 56, 7, f54*f55 ], [ 57, > 7, f57*f58*f59 ], [ 58, 7, f54*f55*f56*f57 ], [ 59, 7, > f54*f55*f56*f57*f58 ], [ 60, 7, f64 ], [ 61, 7, f64*f65 ], [ 62, 7, > f60*f65 ], [ 63, 7, f61*f64 ], [ 64, 7, f62*f64*f65 ], [ 65, 7, > f63*f65 ], [ 24, 8, f25*f26*f28 ], [ 25, 8, f26*f27*f28 ], [ 26, 8, > f25*f26*f27*f29 ], [ 27, 8, f24*f26*f28 ], [ 28, 8, f24*f26*f29 ], [ > 29, 8, f24*f26*f27 ], [ 30, 8, f33*f34*f55*f56*f57*f58*f59 ], [ 31, 8, > f30*f33*f35*f54*f55 ], [ 32, 8, f30*f31*f34*f54*f55*f56 ], [ 33, 8, > f30*f31*f32*f33*f34*f35*f58*f59 ], [ 34, 8, > f31*f32*f35*f54*f55*f56*f57*f58 ], [ 35, 8, > f32*f33*f54*f55*f56*f57*f58*f59 ], [ 36, 8, f36*f37*f38*f40 ], [ 37, > 8, f37*f38*f39*f40 ], [ 38, 8, f37*f39*f41 ], [ 39, 8, f36*f38*f39*f40 > ], [ 40, 8, f36*f38*f40*f41 ], [ 41, 8, f36*f38*f39*f41 ], [ 42, 8, > f42*f45*f46*f61*f62*f63*f64*f65 ], [ 43, 8, f42*f43*f45*f47*f60*f61 ], > [ 44, 8, f42*f43*f44*f46*f60*f61*f62 ], [ 45, 8, > f42*f43*f44*f46*f47*f64*f65 ], [ 46, 8, > f43*f44*f46*f47*f60*f61*f62*f63*f64 ], [ 47, 8, > f44*f45*f47*f60*f61*f62*f63*f64*f65 ], [ 54, 8, f54*f57*f58 ], [ 55, > 8, f54*f55*f57*f59 ], [ 56, 8, f54*f55*f56*f58 ], [ 57, 8, > f54*f55*f56*f58*f59 ], [ 58, 8, f55*f56*f58*f59 ], [ 59, 8, > f56*f57*f59 ], [ 60, 8, f63*f64 ], [ 61, 8, f60*f63*f65 ], [ 62, 8, > f60*f61*f64 ], [ 63, 8, f60*f61*f62*f63*f64*f65 ], [ 64, 8, > f61*f62*f65 ], [ 65, 8, f62*f63 ], [ 12, 9, f13*f14*f16 ], [ 13, 9, > f14*f15*f16 ], [ 14, 9, f13*f14*f15*f17 ], [ 15, 9, f12*f14*f16 ], [ > 16, 9, f12*f14*f17 ], [ 17, 9, f12*f14*f15 ], [ 18, 9, > f21*f22*f49*f50*f51*f52*f53 ], [ 19, 9, f18*f21*f23*f48*f49 ], [ 20, > 9, f18*f19*f22*f48*f49*f50 ], [ 21, 9, f18*f19*f20*f21*f22*f23*f52*f53 > ], [ 22, 9, f19*f20*f23*f48*f49*f50*f51*f52 ], [ 23, 9, > f20*f21*f48*f49*f50*f51*f52*f53 ], [ 24, 9, f25*f26*f28 ], [ 25, 9, > f26*f27*f28 ], [ 26, 9, f25*f26*f27*f29 ], [ 27, 9, f24*f26*f28 ], [ > 28, 9, f24*f26*f29 ], [ 29, 9, f24*f26*f27 ], [ 30, 9, > f33*f34*f55*f56*f57*f58*f59 ], [ 31, 9, f30*f33*f35*f54*f55 ], [ 32, > 9, f30*f31*f34*f54*f55*f56 ], [ 33, 9, f30*f31*f32*f33*f34*f35*f58*f59 > ], [ 34, 9, f31*f32*f35*f54*f55*f56*f57*f58 ], [ 35, 9, > f32*f33*f54*f55*f56*f57*f58*f59 ], [ 36, 9, f37*f38*f40 ], [ 37, 9, > f38*f39*f40 ], [ 38, 9, f37*f38*f39*f41 ], [ 39, 9, f36*f38*f40 ], [ > 40, 9, f36*f38*f41 ], [ 41, 9, f36*f38*f39 ], [ 42, 9, > f45*f46*f61*f62*f63*f64*f65 ], [ 43, 9, f42*f45*f47*f60*f61 ], [ 44, > 9, f42*f43*f46*f60*f61*f62 ], [ 45, 9, f42*f43*f44*f45*f46*f47*f64*f65 > ], [ 46, 9, f43*f44*f47*f60*f61*f62*f63*f64 ], [ 47, 9, > f44*f45*f60*f61*f62*f63*f64*f65 ], [ 48, 9, f48*f51*f52 ], [ 49, 9, > f48*f49*f51*f53 ], [ 50, 9, f48*f49*f50*f52 ], [ 51, 9, > f48*f49*f50*f52*f53 ], [ 52, 9, f49*f50*f52*f53 ], [ 53, 9, > f50*f51*f53 ], [ 54, 9, f54*f57*f58 ], [ 55, 9, f54*f55*f57*f59 ], [ > 56, 9, f54*f55*f56*f58 ], [ 57, 9, f54*f55*f56*f58*f59 ], [ 58, 9, > f55*f56*f58*f59 ], [ 59, 9, f56*f57*f59 ], [ 60, 9, f60*f63*f64 ], [ > 61, 9, f60*f61*f63*f65 ], [ 62, 9, f60*f61*f62*f64 ], [ 63, 9, > f60*f61*f62*f64*f65 ], [ 64, 9, f61*f62*f64*f65 ], [ 65, 9, > f62*f63*f65 ], [ 12, 10, f13*f14*f16*f17 ], [ 13, 10, f15*f16 ], [ 14, > 10, f13*f14*f17 ], [ 15, 10, f13*f16*f17 ], [ 16, 10, f14*f17 ], [ 17, > 10, f12*f13*f16*f17 ], [ 18, 10, f19*f20*f21*f22*f48*f51*f52*f53 ], [ > 19, 10, f19*f23*f49*f51 ], [ 20, 10, f18*f20*f48*f50*f52 ], [ 21, 10, > f20*f22*f48*f49*f52 ], [ 22, 10, f18*f19*f20*f22*f23*f49*f50*f51*f52 > ], [ 23, 10, f18*f19*f20*f21*f23*f50*f51*f52*f53 ], [ 36, 10, > f37*f38*f39*f40 ], [ 37, 10, f38*f39 ], [ 38, 10, f36*f37*f38*f39*f41 > ], [ 39, 10, f36*f38*f40*f41 ], [ 40, 10, f36*f41 ], [ 41, 10, > f37*f39*f41 ], [ 42, 10, f42*f44*f62*f63*f65 ], [ 43, 10, > f42*f43*f44*f45*f60*f62*f64*f65 ], [ 44, 10, > f42*f43*f44*f45*f46*f60*f61*f63*f65 ], [ 45, 10, > f43*f45*f46*f47*f60*f61*f63*f64*f65 ], [ 46, 10, > f42*f46*f47*f60*f61*f63*f64 ], [ 47, 10, f43*f47*f61*f62*f64*f65 ], [ > 48, 10, f48*f49*f51*f52 ], [ 49, 10, f48*f50*f51*f53 ], [ 50, 10, > f49*f51*f52 ], [ 51, 10, f49*f50*f51*f53 ], [ 52, 10, f49*f50 ], [ 53, > 10, f48*f50*f51 ], [ 60, 10, f60*f61*f62*f63*f64 ], [ 61, 10, f65 ], [ > 62, 10, f60 ], [ 63, 10, f62*f63*f64 ], [ 64, 10, f60*f61*f62*f65 ], [ > 65, 10, f60*f61*f62*f63 ], [ 24, 11, f25*f26*f28*f29 ], [ 25, 11, > f27*f28 ], [ 26, 11, f25*f26*f29 ], [ 27, 11, f25*f28*f29 ], [ 28, 11, > f26*f29 ], [ 29, 11, f24*f25*f28*f29 ], [ 30, 11, > f31*f32*f33*f34*f54*f57*f58*f59 ], [ 31, 11, f31*f35*f55*f57 ], [ 32, > 11, f30*f32*f54*f56*f58 ], [ 33, 11, f32*f34*f54*f55*f58 ], [ 34, 11, > f30*f31*f32*f34*f35*f55*f56*f57*f58 ], [ 35, 11, > f30*f31*f32*f33*f35*f56*f57*f58*f59 ], [ 36, 11, f37*f38*f39*f40 ], [ > 37, 11, f38*f39 ], [ 38, 11, f36*f37*f38*f39*f41 ], [ 39, 11, > f36*f38*f40*f41 ], [ 40, 11, f36*f41 ], [ 41, 11, f37*f39*f41 ], [ 42, > 11, f42*f44*f62*f63*f65 ], [ 43, 11, f42*f43*f44*f45*f60*f62*f64*f65 > ], [ 44, 11, f42*f43*f44*f45*f46*f60*f61*f63*f65 ], [ 45, 11, > f43*f45*f46*f47*f60*f61*f63*f64*f65 ], [ 46, 11, > f42*f46*f47*f60*f61*f63*f64 ], [ 47, 11, f43*f47*f61*f62*f64*f65 ], [ > 54, 11, f54*f55*f57*f58 ], [ 55, 11, f54*f56*f57*f59 ], [ 56, 11, > f55*f57*f58 ], [ 57, 11, f55*f56*f57*f59 ], [ 58, 11, f55*f56 ], [ 59, > 11, f54*f56*f57 ], [ 60, 11, f60*f61*f62*f63*f64 ], [ 61, 11, f65 ], [ > 62, 11, f60 ], [ 63, 11, f62*f63*f64 ], [ 64, 11, f60*f61*f62*f65 ], [ > 65, 11, f60*f61*f62*f63 ], [ 18, 12, f49*f50*f52*f53 ], [ 19, 12, > f49*f51*f52 ], [ 20, 12, f48*f50*f52*f53 ], [ 21, 12, f48*f50*f51*f52 > ], [ 22, 12, f48*f50*f51 ], [ 23, 12, f48*f49*f51*f52 ], [ 18, 13, > f49*f50 ], [ 19, 13, f48*f49*f51 ], [ 20, 13, f49*f50*f52 ], [ 21, 13, > f48*f49*f51*f53 ], [ 22, 13, f48*f52 ], [ 23, 13, f48*f49*f53 ], [ 18, > 14, f48*f49*f51*f52 ], [ 19, 14, f48*f50*f51*f53 ], [ 20, 14, > f49*f51*f52 ], [ 21, 14, f49*f50*f51*f53 ], [ 22, 14, f49*f50 ], [ 23, > 14, f48*f50*f51 ], [ 18, 15, f50*f51*f53 ], [ 19, 15, f48*f50*f52*f53 > ], [ 20, 15, f48*f49*f51*f53 ], [ 21, 15, f48*f49*f51*f52*f53 ], [ 22, > 15, f48*f49*f51*f52 ], [ 23, 15, f49*f50*f52*f53 ], [ 18, 16, > f48*f50*f51 ], [ 19, 16, f49*f50*f52 ], [ 20, 16, f48*f50*f51*f53 ], [ > 21, 16, f48*f49*f50*f52 ], [ 22, 16, f48*f49*f53 ], [ 23, 16, f49*f50 > ], [ 18, 17, f48*f51*f52 ], [ 19, 17, f48*f49*f51*f53 ], [ 20, 17, > f48*f49*f50*f52 ], [ 21, 17, f48*f49*f50*f52*f53 ], [ 22, 17, > f49*f50*f52*f53 ], [ 23, 17, f50*f51*f53 ], [ 30, 24, f55*f56*f58*f59 > ], [ 31, 24, f55*f57*f58 ], [ 32, 24, f54*f56*f58*f59 ], [ 33, 24, > f54*f56*f57*f58 ], [ 34, 24, f54*f56*f57 ], [ 35, 24, f54*f55*f57*f58 > ], [ 30, 25, f55*f56 ], [ 31, 25, f54*f55*f57 ], [ 32, 25, f55*f56*f58 > ], [ 33, 25, f54*f55*f57*f59 ], [ 34, 25, f54*f58 ], [ 35, 25, > f54*f55*f59 ], [ 30, 26, f54*f55*f57*f58 ], [ 31, 26, f54*f56*f57*f59 > ], [ 32, 26, f55*f57*f58 ], [ 33, 26, f55*f56*f57*f59 ], [ 34, 26, > f55*f56 ], [ 35, 26, f54*f56*f57 ], [ 30, 27, f56*f57*f59 ], [ 31, 27, > f54*f56*f58*f59 ], [ 32, 27, f54*f55*f57*f59 ], [ 33, 27, > f54*f55*f57*f58*f59 ], [ 34, 27, f54*f55*f57*f58 ], [ 35, 27, > f55*f56*f58*f59 ], [ 30, 28, f54*f56*f57 ], [ 31, 28, f55*f56*f58 ], [ > 32, 28, f54*f56*f57*f59 ], [ 33, 28, f54*f55*f56*f58 ], [ 34, 28, > f54*f55*f59 ], [ 35, 28, f55*f56 ], [ 30, 29, f54*f57*f58 ], [ 31, 29, > f54*f55*f57*f59 ], [ 32, 29, f54*f55*f56*f58 ], [ 33, 29, > f54*f55*f56*f58*f59 ], [ 34, 29, f55*f56*f58*f59 ], [ 35, 29, > f56*f57*f59 ], [ 42, 36, f61*f62*f64*f65 ], [ 43, 36, f61*f63*f64 ], [ > 44, 36, f60*f62*f64*f65 ], [ 45, 36, f60*f62*f63*f64 ], [ 46, 36, > f60*f62*f63 ], [ 47, 36, f60*f61*f63*f64 ], [ 42, 37, f61*f62 ], [ 43, > 37, f60*f61*f63 ], [ 44, 37, f61*f62*f64 ], [ 45, 37, f60*f61*f63*f65 > ], [ 46, 37, f60*f64 ], [ 47, 37, f60*f61*f65 ], [ 42, 38, > f60*f61*f63*f64 ], [ 43, 38, f60*f62*f63*f65 ], [ 44, 38, f61*f63*f64 > ], [ 45, 38, f61*f62*f63*f65 ], [ 46, 38, f61*f62 ], [ 47, 38, > f60*f62*f63 ], [ 42, 39, f62*f63*f65 ], [ 43, 39, f60*f62*f64*f65 ], [ > 44, 39, f60*f61*f63*f65 ], [ 45, 39, f60*f61*f63*f64*f65 ], [ 46, 39, > f60*f61*f63*f64 ], [ 47, 39, f61*f62*f64*f65 ], [ 42, 40, f60*f62*f63 > ], [ 43, 40, f61*f62*f64 ], [ 44, 40, f60*f62*f63*f65 ], [ 45, 40, > f60*f61*f62*f64 ], [ 46, 40, f60*f61*f65 ], [ 47, 40, f61*f62 ], [ 42, > 41, f60*f63*f64 ], [ 43, 41, f60*f61*f63*f65 ], [ 44, 41, > f60*f61*f62*f64 ], [ 45, 41, f60*f61*f62*f64*f65 ], [ 46, 41, > f61*f62*f64*f65 ], [ 47, 41, f62*f63*f65 ], ];; # create a group defined by a single collecotr gap> rws := SingleCollector( f, [ 2, 3, 7, 3, 3, 3, 3, 3, 3, 7, 7, 2, > 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, > 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, > 2, 2, 2, 2, 2, 2, 2, 2, 2 ] );; gap> for x in r do > if 2 = Length(x) then > SetPower( rws, x[1], x[2] ); > else > SetCommutator( rws, x[1], x[2], x[3] ); > fi; > od; gap> g := GroupByRws(rws);; gap> n := GeneratorsOfGroup(g);; gap> s := Subgroup( g, n{[1]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, false, false, false, false );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f2*f8, f3, f4*f8^2, f7*f8, f9, f10*f11^3, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, f24*f36, f25*f37, f26*f38, f27*f39, f28*f40, f29*f41, f30*f42, f31*f43, f32*f44, f33*f45, f34*f46, f35*f47, f48, f49, f50, f51, f52, f53, f54*f60, f55*f61, f56*f62, f57*f63, f58*f64, f59*f65 ]) gap> s := Subgroup( g, n{[1]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, false, false, true, false );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f2*f8, f3, f4*f8^2, f7*f8, f9, f10*f11^3, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, f24*f36, f25*f37, f26*f38, f27*f39, f28*f40, f29*f41, f30*f42, f31*f43, f32*f44, f33*f45, f34*f46, f35*f47, f48, f49, f50, f51, f52, f53, f54*f60, f55*f61, f56*f62, f57*f63, f58*f64, f59*f65 ]) gap> s := Subgroup( g, n{[1]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, true, true, false, false );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f2*f8, f3, f4*f8^2, f7*f8, f9, f10*f11^3, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, f24*f36, f25*f37, f26*f38, f27*f39, f28*f40, f29*f41, f30*f42, f31*f43, f32*f44, f33*f45, f34*f46, f35*f47, f48, f49, f50, f51, f52, f53, f54*f60, f55*f61, f56*f62, f57*f63, f58*f64, f59*f65 ]) gap> s := Subgroup( g, n{[1]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, true, false, true, true );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f2*f8, f3, f4*f8^2, f7*f8, f9, f10*f11^3, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, f24*f36, f25*f37, f26*f38, f27*f39, f28*f40, f29*f41, f30*f42, f31*f43, f32*f44, f33*f45, f34*f46, f35*f47, f48, f49, f50, f51, f52, f53, f54*f60, f55*f61, f56*f62, f57*f63, f58*f64, f59*f65 ]) gap> s := Subgroup( g, n{[1]} );; gap> Print(CanonicalPcgsWrtHomePcgs( Normalizer( g, s ) ),"\n"); Pcgs([ f1, f2*f8, f3, f4*f8^2, f7*f8, f9, f10*f11^3, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, f24*f36, f25*f37, f26*f38, f27*f39, f28*f40, f29*f41, f30*f42, f31*f43, f32*f44, f33*f45, f34*f46, f35*f47, f48, f49, f50, f51, f52, f53, f54*f60, f55*f61, f56*f62, f57*f63, f58*f64, f59*f65 ]) gap> s := Subgroup( g, n{[1,20]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, false, false, false, false );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f2*f8, f3*f10^2*f11^6, f4*f8^2, f18, f19, f20, f21, f22, f23, f24*f36, f25*f37, f26*f38, f27*f39, f28*f40, f29*f41, f30*f42, f31*f43, f32*f44, f33*f45, f34*f46, f35*f47, f48, f49, f50, f51, f52, f53, f54*f60, f55*f61, f56*f62, f57*f63, f58*f64, f59*f65 ]) gap> s := Subgroup( g, n{[1,20]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, false, false, false, true );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f2*f8, f3*f10^2*f11^6, f4*f8^2, f18, f19, f20, f21, f22, f23, f24*f36, f25*f37, f26*f38, f27*f39, f28*f40, f29*f41, f30*f42, f31*f43, f32*f44, f33*f45, f34*f46, f35*f47, f48, f49, f50, f51, f52, f53, f54*f60, f55*f61, f56*f62, f57*f63, f58*f64, f59*f65 ]) gap> s := Subgroup( g, n{[1,20]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, false, false, true, false );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f2*f8, f3*f10^2*f11^6, f4*f8^2, f18, f19, f20, f21, f22, f23, f24*f36, f25*f37, f26*f38, f27*f39, f28*f40, f29*f41, f30*f42, f31*f43, f32*f44, f33*f45, f34*f46, f35*f47, f48, f49, f50, f51, f52, f53, f54*f60, f55*f61, f56*f62, f57*f63, f58*f64, f59*f65 ]) gap> s := Subgroup( g, n{[1,20]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, true, true, false, false );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f2*f8, f3*f10^2*f11^6, f4*f8^2, f18, f19, f20, f21, f22, f23, f24*f36, f25*f37, f26*f38, f27*f39, f28*f40, f29*f41, f30*f42, f31*f43, f32*f44, f33*f45, f34*f46, f35*f47, f48, f49, f50, f51, f52, f53, f54*f60, f55*f61, f56*f62, f57*f63, f58*f64, f59*f65 ]) gap> s := Subgroup( g, n{[1,20]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, true, false, true, true );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f2*f8, f3*f10^2*f11^6, f4*f8^2, f18, f19, f20, f21, f22, f23, f24*f36, f25*f37, f26*f38, f27*f39, f28*f40, f29*f41, f30*f42, f31*f43, f32*f44, f33*f45, f34*f46, f35*f47, f48, f49, f50, f51, f52, f53, f54*f60, f55*f61, f56*f62, f57*f63, f58*f64, f59*f65 ]) gap> s := Subgroup( g, n{[1,20]} );; gap> Print(CanonicalPcgsWrtHomePcgs( Normalizer( g, s ) ),"\n"); Pcgs([ f1, f2*f8, f3*f10^2*f11^6, f4*f8^2, f18, f19, f20, f21, f22, f23, f24*f36, f25*f37, f26*f38, f27*f39, f28*f40, f29*f41, f30*f42, f31*f43, f32*f44, f33*f45, f34*f46, f35*f47, f48, f49, f50, f51, f52, f53, f54*f60, f55*f61, f56*f62, f57*f63, f58*f64, f59*f65 ]) gap> s := Subgroup( g, n{[1,20,65]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, false, false, false, false );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f18, f19, f20, f21, f22, f23, f24*f36, f25*f37, f26*f38, f27*f39, f28*f40, f29*f41, f30*f42, f31*f43, f32*f44, f33*f45, f34*f46, f35*f47, f48, f49, f50, f51, f52, f53, f54*f60, f55*f61, f56*f62, f57*f63, f58*f64, f59, f65 ]) gap> s := Subgroup( g, n{[1,20,65]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, false, false, false, true );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f18, f19, f20, f21, f22, f23, f24*f36, f25*f37, f26*f38, f27*f39, f28*f40, f29*f41, f30*f42, f31*f43, f32*f44, f33*f45, f34*f46, f35*f47, f48, f49, f50, f51, f52, f53, f54*f60, f55*f61, f56*f62, f57*f63, f58*f64, f59, f65 ]) gap> s := Subgroup( g, n{[1,20,65]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, false, false, true, false );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f18, f19, f20, f21, f22, f23, f24*f36, f25*f37, f26*f38, f27*f39, f28*f40, f29*f41, f30*f42, f31*f43, f32*f44, f33*f45, f34*f46, f35*f47, f48, f49, f50, f51, f52, f53, f54*f60, f55*f61, f56*f62, f57*f63, f58*f64, f59, f65 ]) gap> s := Subgroup( g, n{[1,20,65]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, true, true, false, false );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f18, f19, f20, f21, f22, f23, f24*f36, f25*f37, f26*f38, f27*f39, f28*f40, f29*f41, f30*f42, f31*f43, f32*f44, f33*f45, f34*f46, f35*f47, f48, f49, f50, f51, f52, f53, f54*f60, f55*f61, f56*f62, f57*f63, f58*f64, f59, f65 ]) gap> s := Subgroup( g, n{[1,20,65]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, true, false, true, true );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f18, f19, f20, f21, f22, f23, f24*f36, f25*f37, f26*f38, f27*f39, f28*f40, f29*f41, f30*f42, f31*f43, f32*f44, f33*f45, f34*f46, f35*f47, f48, f49, f50, f51, f52, f53, f54*f60, f55*f61, f56*f62, f57*f63, f58*f64, f59, f65 ]) gap> s := Subgroup( g, n{[1,20,65]} );; gap> Print(CanonicalPcgsWrtHomePcgs( Normalizer( g, s ) ),"\n"); Pcgs([ f1, f18, f19, f20, f21, f22, f23, f24*f36, f25*f37, f26*f38, f27*f39, f28*f40, f29*f41, f30*f42, f31*f43, f32*f44, f33*f45, f34*f46, f35*f47, f48, f49, f50, f51, f52, f53, f54*f60, f55*f61, f56*f62, f57*f63, f58*f64, f59, f65 ]) gap> s := Subgroup( g, n{[1,10,11,12,16,18,20,21,24,26,65,30]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, false, false, false, false );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f2*f7*f8^2, f3, f4*f8^2*f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, f29, f30, f31*f33*f34, f32, f36, f37, f38, f39, f40, f41, f42, f43*f45*f46, f44, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57, f58, f59, f60, f61, f62, f63, f64, f65 ]) gap> s := Subgroup( g, n{[1,10,11,12,16,18,20,21,24,26,65,30]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, false, false, false, true );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f2*f7*f8^2, f3, f4*f8^2*f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, f29, f30, f31*f33*f34, f32, f36, f37, f38, f39, f40, f41, f42, f43*f45*f46, f44, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57, f58, f59, f60, f61, f62, f63, f64, f65 ]) gap> s := Subgroup( g, n{[1,10,11,12,16,18,20,21,24,26,65,30]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, false, false, true, false );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f2*f7*f8^2, f3, f4*f8^2*f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, f29, f30, f31*f33*f34, f32, f36, f37, f38, f39, f40, f41, f42, f43*f45*f46, f44, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57, f58, f59, f60, f61, f62, f63, f64, f65 ]) gap> s := Subgroup( g, n{[1,10,11,12,16,18,20,21,24,26,65,30]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, true, true, false, false );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f2*f7*f8^2, f3, f4*f8^2*f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, f29, f30, f31*f33*f34, f32, f36, f37, f38, f39, f40, f41, f42, f43*f45*f46, f44, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57, f58, f59, f60, f61, f62, f63, f64, f65 ]) gap> s := Subgroup( g, n{[1,10,11,12,16,18,20,21,24,26,65,30]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, true, false, true, true );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f2*f7*f8^2, f3, f4*f8^2*f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, f29, f30, f31*f33*f34, f32, f36, f37, f38, f39, f40, f41, f42, f43*f45*f46, f44, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57, f58, f59, f60, f61, f62, f63, f64, f65 ]) gap> s := Subgroup( g, n{[1,10,11,12,16,18,20,21,24,26,65,30]} );; gap> Print(CanonicalPcgsWrtHomePcgs( Normalizer( g, s ) ),"\n"); Pcgs([ f1, f2*f7*f8^2, f3, f4*f8^2*f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, f29, f30, f31*f33*f34, f32, f36, f37, f38, f39, f40, f41, f42, f43*f45*f46, f44, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57, f58, f59, f60, f61, f62, f63, f64, f65 ]) gap> s := Subgroup( g, n{[1,10,11,12,16,18,30,21,24,26,65]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, false, false, false, false );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f2*f7*f8^2, f3, f4*f8^2*f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, f29, f30, f31*f33*f34, f32, f36, f37, f38, f39, f40, f41, f42, f43*f45*f46, f44, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57, f58, f59, f60, f61, f62, f63, f64, f65 ]) gap> s := Subgroup( g, n{[1,10,11,12,16,18,30,21,24,26,65]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, false, false, false, true );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f2*f7*f8^2, f3, f4*f8^2*f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, f29, f30, f31*f33*f34, f32, f36, f37, f38, f39, f40, f41, f42, f43*f45*f46, f44, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57, f58, f59, f60, f61, f62, f63, f64, f65 ]) gap> s := Subgroup( g, n{[1,10,11,12,16,18,30,21,24,26,65]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, false, false, true, false );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f2*f7*f8^2, f3, f4*f8^2*f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, f29, f30, f31*f33*f34, f32, f36, f37, f38, f39, f40, f41, f42, f43*f45*f46, f44, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57, f58, f59, f60, f61, f62, f63, f64, f65 ]) gap> s := Subgroup( g, n{[1,10,11,12,16,18,30,21,24,26,65]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, true, true, false, false );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f2*f7*f8^2, f3, f4*f8^2*f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, f29, f30, f31*f33*f34, f32, f36, f37, f38, f39, f40, f41, f42, f43*f45*f46, f44, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57, f58, f59, f60, f61, f62, f63, f64, f65 ]) gap> s := Subgroup( g, n{[1,10,11,12,16,18,30,21,24,26,65]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, true, false, true, true );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f2*f7*f8^2, f3, f4*f8^2*f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, f29, f30, f31*f33*f34, f32, f36, f37, f38, f39, f40, f41, f42, f43*f45*f46, f44, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57, f58, f59, f60, f61, f62, f63, f64, f65 ]) gap> s := Subgroup( g, n{[1,10,11,12,16,18,30,21,24,26,65]} );; gap> Print(CanonicalPcgsWrtHomePcgs( Normalizer( g, s ) ),"\n"); Pcgs([ f1, f2*f7*f8^2, f3, f4*f8^2*f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28, f29, f30, f31*f33*f34, f32, f36, f37, f38, f39, f40, f41, f42, f43*f45*f46, f44, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57, f58, f59, f60, f61, f62, f63, f64, f65 ]) gap> s := Subgroup( g, n{[1,10,11,12,16,30,21,24,26,65]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, false, false, false, false );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f3, f10, f11, f12, f13, f14, f15, f16, f17, f19*f22*f23, f20*f22, f21, f24, f25, f26, f27, f28, f29, f30, f31*f33*f34, f32, f36, f37, f38, f39, f40, f41, f42, f43*f45*f46, f44, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57, f58, f59, f60, f61, f62, f63, f64, f65 ]) gap> s := Subgroup( g, n{[1,10,11,12,16,30,21,24,26,65]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, false, false, false, true );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f3, f10, f11, f12, f13, f14, f15, f16, f17, f19*f22*f23, f20*f22, f21, f24, f25, f26, f27, f28, f29, f30, f31*f33*f34, f32, f36, f37, f38, f39, f40, f41, f42, f43*f45*f46, f44, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57, f58, f59, f60, f61, f62, f63, f64, f65 ]) gap> s := Subgroup( g, n{[1,10,11,12,16,30,21,24,26,65]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, false, false, true, false );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f3, f10, f11, f12, f13, f14, f15, f16, f17, f19*f22*f23, f20*f22, f21, f24, f25, f26, f27, f28, f29, f30, f31*f33*f34, f32, f36, f37, f38, f39, f40, f41, f42, f43*f45*f46, f44, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57, f58, f59, f60, f61, f62, f63, f64, f65 ]) gap> s := Subgroup( g, n{[1,10,11,12,16,30,21,24,26,65]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, true, true, false, false );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f3, f10, f11, f12, f13, f14, f15, f16, f17, f19*f22*f23, f20*f22, f21, f24, f25, f26, f27, f28, f29, f30, f31*f33*f34, f32, f36, f37, f38, f39, f40, f41, f42, f43*f45*f46, f44, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57, f58, f59, f60, f61, f62, f63, f64, f65 ]) gap> s := Subgroup( g, n{[1,10,11,12,16,30,21,24,26,65]} );; gap> w := PcGroup_NormalizerWrtHomePcgs( s, true, false, true, true );; gap> Print(CanonicalPcgs(w),"\n"); Pcgs([ f1, f3, f10, f11, f12, f13, f14, f15, f16, f17, f19*f22*f23, f20*f22, f21, f24, f25, f26, f27, f28, f29, f30, f31*f33*f34, f32, f36, f37, f38, f39, f40, f41, f42, f43*f45*f46, f44, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57, f58, f59, f60, f61, f62, f63, f64, f65 ]) gap> s := Subgroup( g, n{[1,10,11,12,16,30,21,24,26,65]} );; gap> Print(CanonicalPcgsWrtHomePcgs( Normalizer( g, s ) ),"\n"); Pcgs([ f1, f3, f10, f11, f12, f13, f14, f15, f16, f17, f19*f22*f23, f20*f22, f21, f24, f25, f26, f27, f28, f29, f30, f31*f33*f34, f32, f36, f37, f38, f39, f40, f41, f42, f43*f45*f46, f44, f48, f49, f50, f51, f52, f53, f54, f55, f56, f57, f58, f59, f60, f61, f62, f63, f64, f65 ]) ############################################################################# gap> f := FreeGroup(IsSyllableWordsFamily,9);; gap> g := GeneratorsOfGroup(f);; gap> g1 := g[1];; g2 := g[2];; g3 := g[3];; g4 := g[4];; g5 := g[5];; gap> g6 := g[6];; g7 := g[7];; g8 := g[8];; g9 := g[9];; gap> rws := SingleCollector(f,[ 2, 2, 2, 3, 3, 3, 3, 3, 3 ]);; gap> r := [ [5,1,g6], [6,1,g6], [7,1,g7], [8,1,g8], [9,1,g9], [4,2,g4], > [5,2,g5*g7^2], [6,2,g6*g7^2], [8,2,g8], [9,2,g8], [5,3,g6], [6,3,g6], > [7,3,g7], [8,3,g8], [9,3,g9], [5,4,g6^2*g7], [6,4,g6^2*g7], > [7,4,g6^2*g7], [8,4,g8*g9^2], [9,4,g8*g9^2], [8,5,g7], [9,5,g6] ];; gap> for x in r do SetCommutator(rws,x[1],x[2],x[3]); od; gap> g := GroupByRwsNC(rws);; gap> u := Subgroup( g, GeneratorsOfGroup(g){[4]} );; gap> n := Normalizer( g, u );; gap> Print(CanonicalPcgsWrtFamilyPcgs(n),"\n"); Pcgs([ f1, f2, f3, f4, f5*f7^2, f6*f7^2, f8*f9^2 ]) gap> G:=function() local g1,g2,g3,g4,g5,g6,g7,g8,g9,g10,r,f,g,rws,x; > f:=FreeGroup(IsSyllableWordsFamily,10); g:=GeneratorsOfGroup(f); > g1:=g[1]; g2:=g[2]; g3:=g[3]; > g4:=g[4]; g5:=g[5]; g6:=g[6]; g7:=g[7]; g8:=g[8]; g9:=g[9]; g10:=g[10]; > rws:=SingleCollector(f,[ 2, 3, 2, 3, 2, 2, 2, 2, 2, 2 ]); > r:=[ ]; > for x in r do SetPower(rws,x[1],x[2]);od; > r:=[ [2,1,g2], [6,1,g5], [7,1,g5*g6*g9], [8,1,g5], [9,1,g5], > [10,1,g8*g9], [5,2,g5*g9], [6,2,g5], [7,2,g9], [8,2,g9], [9,2,g5], > [10,2,g5], [4,3,g4], [6,3,g5*g8*g9], [7,3,g5*g8*g10], [6,4,g5*g8*g9], > [7,4,g5*g8*g10], [8,4,g5*g6*g8], [10,4,g5*g6*g7*g9*g10] ]; > for x in r do SetCommutator(rws,x[1],x[2],x[3]);od; > return GroupByRwsNC(rws); end;; G:=G();; gap> Size(Normalizer(G,Subgroup(G,[G.1,G.2]))); 144 ############################################################################# gap> STOP_TEST( "grppcnrm.tst", 2333400000 ); ############################################################################# ## #E gap-4r6p5/tst/grpmat.tst0000644000175000017500000000341412172557256014007 0ustar billbill############################################################################# ## #W grpmat.tst GAP tests Heiko Theißen ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## To be listed in testinstall.g ## gap> START_TEST("grpmat.tst"); gap> i := E(4);; G := Group([[i,0],[0,-i]],[[0,1],[-1,0]]);; gap> gens := GeneratorsOfGroup( G );; IsSSortedList( gens ); false gap> TypeObj( ShallowCopy( gens ) ) = false; false gap> SetName( G, "Q8" ); gap> One( TrivialSubgroup( G ) ); [ [ 1, 0 ], [ 0, 1 ] ] gap> Size( G ); 8 gap> IsHandledByNiceMonomorphism( G ); true gap> pcgs := Pcgs( G );; gap> Print(pcgs,"\n"); Pcgs([ [ [ 0, 1 ], [ -1, 0 ] ], [ [ E(4), 0 ], [ 0, -E(4) ] ], [ [ -1, 0 ], [ 0, -1 ] ] ]) gap> cl := ConjugacyClasses( G );; gap> Collected(List(cl,i->[Size(i),Order(Representative(i))])); [ [ [ 1, 1 ], 1 ], [ [ 1, 2 ], 1 ], [ [ 2, 4 ], 3 ] ] gap> Set(List( cl, c -> ExponentsOfPcElement( pcgs, Representative( c ) ))); [ [ 0, 0, 0 ], [ 0, 0, 1 ], [ 0, 1, 1 ], [ 1, 0, 1 ], [ 1, 1, 0 ] ] gap> Size( AutomorphismGroup( G ) ); 24 gap> g:=GL(4,3);; gap> Length(ConjugacyClasses(g)); 78 gap> gd:=DerivedSubgroup(g);; gap> Index(g,gd); 2 gap> Length(ConjugacyClasses(gd)); 51 gap> hom:=NaturalHomomorphismByNormalSubgroup(gd,Centre(gd));; gap> u:=PreImage(hom,SylowSubgroup(Image(hom),3));; gap> Size(u); 1458 gap> Index(u,DerivedSubgroup(u)); 54 gap> g:= DerivedSubgroup( SO( 1, 8, 4 ) );; gap> Collected( Factors( Size( g ) ) ); [ [ 2, 24 ], [ 3, 5 ], [ 5, 4 ], [ 7, 1 ], [ 13, 1 ], [ 17, 2 ] ] gap> iso:= IsomorphismPermGroup( g );; gap> img:=Image( iso );; gap> Size(img); 67010895544320000 gap> STOP_TEST( "grpmat.tst", 481000000 ); ############################################################################# ## #E gap-4r6p5/tst/boolean.tst0000644000175000017500000000160312172557256014132 0ustar billbill############################################################################# ## #W boolean.tst GAP Library Thomas Breuer ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## Exclude from testinstall.g: too trivial? ## gap> START_TEST("boolean.tst"); gap> not true; false gap> not false; true gap> true = true; true gap> true = false; false gap> false = true; false gap> false = false; true gap> true < true; false gap> true < false; true gap> false < true; false gap> false < false; false gap> true or true; true gap> true or false; true gap> false or true; true gap> false or false; false gap> true and true; true gap> true and false; false gap> false and true; false gap> false and false; false gap> STOP_TEST( "boolean.tst", 100000 ); ############################################################################# ## #E gap-4r6p5/tst/relation.tst0000644000175000017500000001551112172557256014333 0ustar billbill############################################################################# ## #W relation.tst GAP library Robert F. Morse ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## To be listed in testinstall.g ## gap> START_TEST("relation.tst"); gap> ################################################## gap> ## gap> ## Categories gap> ## IsBinaryRelation (IsEndoGeneralMapping) gap> ## IsEquivalenceClass gap> ## gap> ################################################## gap> dom := Domain([1..10]);; gap> m := GeneralMappingByElements(dom,dom,List(dom,x->DirectProductElement([x,x])));; gap> IsBinaryRelation(m); true gap> IsEndoGeneralMapping(m); true gap> IsReflexiveBinaryRelation(m); true gap> HasIsTotal(m); true gap> IsSymmetricBinaryRelation(m); true gap> IsTransitiveBinaryRelation(m); true gap> m=IdentityMapping(dom); true gap> e := EquivalenceRelationByRelation(m);; gap> r := Random(dom);; gap> c := EquivalenceClassOfElement(e,r);; gap> IsEquivalenceClass(c); true gap> ################################################## gap> ## gap> ## Properties gap> ## IsEquivalenceRelation gap> ## IsSymmetricBinaryRelation gap> ## IsTransitiveBinaryRelation gap> ## IsReflexiveBinaryRelation (implies IsTotal) gap> ## gap> ################################################## gap> dom := Domain([1..10]);; tup:=[DirectProductElement([2,4])];; gap> m := GeneralMappingByElements(dom,dom,Concatenation(List(dom,x->DirectProductElement([x,x])),tup));; gap> IsReflexiveBinaryRelation(m); true gap> HasIsTotal(m); true gap> IsTotal(m); true gap> IsSymmetricBinaryRelation(m); false gap> IsTransitiveBinaryRelation(m); true gap> tup := [DirectProductElement([3,4]),DirectProductElement([4,3])];; gap> m := GeneralMappingByElements(dom,dom,Concatenation(List(dom,x->DirectProductElement([x,x])),tup));; gap> IsTransitiveBinaryRelation(m); true gap> IsReflexiveBinaryRelation(m); true gap> IsSymmetricBinaryRelation(m); true gap> IsEquivalenceRelation(m); true gap> m := GeneralMappingByElements(dom,dom,Concatenation(List(dom,x->DirectProductElement([x,x])),tup));; gap> IsEquivalenceRelation(m); true gap> e := EquivalenceRelationByPairs(dom,[[3,4]]);; gap> m=e; true gap> IsEquivalenceRelation(e); true gap> ################################################## gap> ## gap> ## Attributes gap> ## EquivalenceRelationPartition gap> ## GeneratorsOfEquivalenceRelationPartition gap> ## EquivalenceClassRelation gap> ## EquivalenceClasses gap> ## ImagesListOfBinaryRelation gap> ## gap> ################################################## gap> dom := Domain([1..10]);; tup:=[DirectProductElement([2,4]),DirectProductElement([4,2])];; gap> m := GeneralMappingByElements(dom,dom,Concatenation(List(dom,x->DirectProductElement([x,x])),tup));; gap> IsReflexiveBinaryRelation(m);; IsSymmetricBinaryRelation(m);; gap> IsTransitiveBinaryRelation(m);; IsEquivalenceRelation(m);; gap> e := EquivalenceRelationByPairs(dom,[[2,4]]);; gap> EquivalenceRelationPartition(e); [ [ 2, 4 ] ] gap> GeneratorsOfEquivalenceRelationPartition(e); [ [ 2, 4 ] ] gap> e := EquivalenceRelationByPairs(dom,[[2,4],[4,5], [4,5],[1,1]]);; gap> GeneratorsOfEquivalenceRelationPartition(e); [ [ 2, 4 ], [ 4, 5 ] ] gap> r := Random(dom);; gap> c:= EquivalenceClassOfElement(e,r);; gap> e = EquivalenceClassRelation(c); true gap> ec := EquivalenceClassOfElement(e,2); {2} gap> 4 in ec; true gap> 1 in ec; false gap> Images(e,2); [ 2, 4, 5 ] gap> Images(e,10); [ 10 ] gap> br:=BinaryRelationOnPoints([[1],[2,4,5],[3],[4,2,5],[2,4,5],[6],[7],[8],[9],[10]]);; gap> e=br; true gap> Successors(br); [ [ 1 ], [ 2, 4, 5 ], [ 3 ], [ 2, 4, 5 ], [ 2, 4, 5 ], [ 6 ], [ 7 ], [ 8 ], [ 9 ], [ 10 ] ] gap> EquivalenceRelationPartition(br); [ [ 2, 4, 5 ] ] gap> ################################################## gap> ## Operations (Constructors) gap> ## ReflexiveClosureBinaryRelation gap> ## SymmetricClosureBinaryRelation gap> ## TransitiveClosureBinaryRelation gap> ## JoinEquivalenceRelations gap> ## MeetEquivalenceRelations gap> ## EquivalenceClassOfElement gap> ################################################## gap> br := BinaryRelationOnPoints([[2],[3],[4],[5],[6],[7],[8],[9],[10],[]]);; gap> rc := ReflexiveClosureBinaryRelation(br);; gap> Successors(rc); [ [ 1, 2 ], [ 2, 3 ], [ 3, 4 ], [ 4, 5 ], [ 5, 6 ], [ 6, 7 ], [ 7, 8 ], [ 8, 9 ], [ 9, 10 ], [ 10 ] ] gap> sc := SymmetricClosureBinaryRelation(br);; gap> Successors(sc); [ [ 2 ], [ 1, 3 ], [ 2, 4 ], [ 3, 5 ], [ 4, 6 ], [ 5, 7 ], [ 6, 8 ], [ 7, 9 ], [ 8, 10 ], [ 9 ] ] gap> tc := TransitiveClosureBinaryRelation(br);; gap> Successors(tc); [ [ 2, 3, 4, 5, 6, 7, 8, 9, 10 ], [ 3, 4, 5, 6, 7, 8, 9, 10 ], [ 4, 5, 6, 7, 8, 9, 10 ], [ 5, 6, 7, 8, 9, 10 ], [ 6, 7, 8, 9, 10 ], [ 7, 8, 9, 10 ], [ 8, 9, 10 ], [ 9, 10 ], [ 10 ], [ ] ] gap> er := EquivalenceRelationByRelation(br);; gap> er1 := EquivalenceRelationByPairs(dom,[[2,3],[4,5],[6,5]]);; gap> UnderlyingRelation(MeetEquivalenceRelations(er,er1))=Intersection(UnderlyingRelation(er),UnderlyingRelation(er1)); true gap> er2 := EquivalenceRelationByPairs(dom,[[1,2],[3,4],[6,7],[7,8],[8,9],[9,10]]);; gap> j1 := JoinEquivalenceRelations(er1,er2);; gap> j2 := JoinEquivalenceRelations(er,er1);; gap> j1=j2; true gap> m1 := MeetEquivalenceRelations(j1,er2);; gap> m1=er2; true gap> m2 := MeetEquivalenceRelations (er1,er2);; gap> EquivalenceRelationByPairs(dom,[]) = m2; true gap> ################################################## gap> ## gap> ## Functions (Constructors) gap> ## BinaryRelationByListOfImages gap> ## EquivalenceRelationsByProperty gap> ## EquivalenceRelationByRelation gap> ## EquivalenceRelationByPairs gap> ## gap> ################################################## gap> n:=10;; dom := Domain([1..n]);; gap> el := List([1..n-1],x->DirectProductElement([x,x+1]));; gap> e := EquivalenceRelationByRelation(IdentityMapping(dom));; gap> EquivalenceRelationPartition(e)=[]; true gap> er := EquivalenceRelationByPairs(dom,el);; gap> Size(EquivalenceRelationPartition(er))=1; true gap> er := EquivalenceRelationByPairs(dom, el);; gap> Size(EquivalenceClasses(er)) =1; true gap> g := SymmetricGroup(4);; gap> sgs := Domain(NormalSubgroups(g));; gap> d := Size(sgs);; gap> el := List([1..d-1],x->DirectProductElement([AsList(sgs)[x],AsList(sgs)[x+1]]));; gap> er1 := EquivalenceRelationByRelation(GeneralMappingByElements(sgs,sgs,el));; gap> er := EquivalenceRelationByPairs(sgs,el);; gap> er=er1; true gap> el := List([1..n-1],x->DirectProductElement([x,x+1]));; gap> rel := TransitiveClosureBinaryRelation(GeneralMappingByElements(dom,dom,el));; gap> Size(UnderlyingRelation(rel)); 45 gap> Size(GeneratorsOfEquivalenceRelationPartition(EquivalenceRelationByPairs(dom,el))); 9 gap> STOP_TEST( "relation.tst", 7700000 ); ############################################################################# ## #E gap-4r6p5/tst/detest.awk0000644000175000017500000000016212172557256013752 0ustar billbill{if (substr($0,1,2)=="> ") { print substr($0,3); } else {if (substr($0,1,5)=="gap> ") { print substr($0,6); }}} gap-4r6p5/tst/onecohom.tst0000644000175000017500000000432712172557256014330 0ustar billbill############################################################################# ## #W onecohom.tst GAP tests Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file tests the automorphism routines ## ## To be listed in testinstall.g ## gap> START_TEST("onecohom.tst"); gap> g:=Group((16,18,17),(14,15)(17,18),(17,18),(13,14,15), > (11,12)(13,15)(16,18,17), > (10,12)(13,14),(8,9)(10,12),(7,8)(14,15)(16,18,17), > (5,6)(7,9,8)(10,11,12)(13,15)(16,18,17), > (4,6)(7,9,8)(10,12,11)(14,15)(16,17,18), > (2,3)(4,5,6)(7,9,8)(11,12)(13,15)(16,18), > (1,2,3)(10,12,11)(13,15,14),(1,9,4,18,12)(2,8,5,17,10) > (3,7,6,16,11),(1,16,2,18)(3,17)(4,6)(7,8)(10,14,12,13,11,15));; gap> n:=Group((10,12)(14,15),(10,11)(13,15),(10,12,11),(11,12), > (11,12)(13,15,14)(16,18),(11,12)(13,15)(16,17,18),(5,6)(11,12), > (4,5,6),(7,9),(4,6)(7,8)(10,12)(13,14)(17,18),(1,2), > (1,3,2)(4,5,6)(8,9)(10,11)(14,15),(1,3)(4,5,6)(7,9,8)(13,15,14), > (1,3)(7,8)(11,12)(13,15)(16,18,17), > (1,3)(4,6,5)(8,9)(10,11)(17,18),(4,6,5)(7,8,9)(14,15)(17,18), > (1,3)(7,8)(10,12)(13,15,14)(16,17));; gap> Length(ComplementClassesRepresentatives(g,n)); 2 gap> g:=PerfectGroup(IsPermGroup,120,1);; gap> n:=Filtered(NormalSubgroups(g),i->IsElementaryAbelian(i) and Size(i)>1)[1];; gap> ocr:=OneCocycles(g,n);; gap> ocr.isSplitExtension; false gap> Size(ocr.oneCoboundaries); 1 gap> Size(ocr.oneCocycles); 1 gap> g:=PerfectGroup(IsPermGroup,960,1);; gap> n:=Filtered(NormalSubgroups(g),i->IsElementaryAbelian(i) and Size(i)>1)[1];; gap> ocr:=OneCocycles(g,n);; gap> ocr.isSplitExtension; true gap> Size(ocr.complement); 60 gap> Size(Intersection(ocr.complement,n)); 1 gap> Size(ocr.oneCoboundaries); 16 gap> Size(ocr.oneCocycles); 64 gap> b:=BaseSteinitzVectors(BasisVectors(Basis(ocr.oneCocycles)),BasisVectors(Basis(ocr.oneCoboundaries)));; gap> b:=AsList(VectorSpace(GF(2),b.factorspace));; gap> com:=List(b,ocr.cocycleToComplement);; gap> List(com,Size); [ 60, 60, 60, 60 ] gap> List(com,i->Number(com,j->RepresentativeAction(g,i,j)<>fail)); [ 1, 1, 1, 1 ] # that's all, folks gap> STOP_TEST( "onecohom.tst", 50600000 ); ############################################################################# ## #E gap-4r6p5/tst/semigrp.tst0000644000175000017500000002112112172557256014156 0ustar billbill############################################################################# ## #W semigrp.tst GAP library Andrew Solomon ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## To be listed in testinstall.g ## gap> START_TEST("semigrp.tst"); gap> ############################################### gap> ## gap> ## AsTransformation - changing representation gap> ## gap> ## s := GeneralMappingByElements(g, g, [...]); gap> ## t := AsTransformation(g); gap> ## gap> ## t*t; t + t; etc. gap> ## gap> ############################################### gap> a := (1,2,3,4);; gap> g := Group(a);; gap> gap> u := TransformationRepresentation( > GeneralMappingByElements(g, g, > [DirectProductElement([a^1, a^1]), DirectProductElement([a^2, a^1]), > DirectProductElement([a^3, a^3]), DirectProductElement([a^4, a^4])]));; gap> gap> u*u;; gap> ()^u;; gap> gap> gap> gap> a := (1,2,3,4);; gap> g := Group(a);; gap> gap> s1 := GeneralMappingByElements(g, g, > [DirectProductElement([a^1, a^1]), DirectProductElement([a^2, a^1]), > DirectProductElement([a^3, a^3]), DirectProductElement([a^4, a^4])]);; gap> s1 := TransformationRepresentation(s1);; gap> gap> t1 := GeneralMappingByElements(g, g, > [DirectProductElement([a^1, a^2]), DirectProductElement([a^2, a^2]), > DirectProductElement([a^3, a^3]), DirectProductElement([a^4, a^4])]);; gap> t1 := TransformationRepresentation(t1);; gap> gap> s2 := GeneralMappingByElements(g, g, > [DirectProductElement([a^1, a^1]), DirectProductElement([a^2, a^2]), > DirectProductElement([a^3, a^2]), DirectProductElement([a^4, a^4])]);; gap> s2 := TransformationRepresentation(s2);; gap> gap> t2 := GeneralMappingByElements(g, g, > [DirectProductElement([a^1, a^1]), DirectProductElement([a^2, a^3]), > DirectProductElement([a^3, a^3]), DirectProductElement([a^4, a^4])]);; gap> t2 := TransformationRepresentation(t2);; gap> gap> s3 := GeneralMappingByElements(g, g, > [DirectProductElement([a^1, a^1]), DirectProductElement([a^2, a^2]), > DirectProductElement([a^3, a^3]), DirectProductElement([a^4, a^3])]);; gap> s3 := TransformationRepresentation(s3);; gap> gap> t3 := GeneralMappingByElements(g, g, > [DirectProductElement([a^1, a^1]), DirectProductElement([a^2, a^2]), > DirectProductElement([a^3, a^4]), DirectProductElement([a^4, a^4])]);; gap> t3 := TransformationRepresentation(t3);; gap> gap> o4 := Semigroup([s1,s2,s3,t1,t2,t3]);; gap> Size(o4); 34 gap> gap> IsSimpleSemigroup(o4); false gap> gap> gap> ############################################################## gap> ## To play with the semigroup as a transformation semigroup: gap> ############################################################## gap> i := IsomorphismTransformationSemigroup(o4);; gap> Size(Range(i)); 34 gap> gap> IsSimpleSemigroup(Range(i)); false gap> gap> ######################## gap> # gap> # Ideals gap> # gap> ######################## gap> a := Transformation([2,3,1]);; gap> b := Transformation([2,2,1]);; gap> M := Monoid([a,b]);; gap> IsTransformationSemigroup(M); true gap> IsTransformationMonoid(M); true gap> K := MagmaIdealByGenerators(M, [b]);; gap> L := SemigroupIdealByGenerators(M,[b]);; gap> K = L; true gap> ######################## gap> # gap> # Congruences gap> # gap> ######################## gap> # O_4 test gap> a := Transformation([1,1,3,4]);; gap> b := Transformation([2,2,3,4]);; gap> c := Transformation([1,2,2,4]);; gap> d := Transformation([1,3,3,4]);; gap> e := Transformation([1,2,3,3]);; gap> f := Transformation([1,2,4,4]);; gap> O4 := Monoid([a,b,c,d,e,f]);; gap> gap> J := MagmaIdealByGenerators(O4, [a*f]);; gap> C := SemigroupCongruenceByGeneratingPairs(O4, [[a*f, a*e]]);; gap> erp := EquivalenceRelationPartition(C);; gap> AsSSortedList(J) = AsSSortedList(erp[1]); # true true gap> Length(erp); 1 gap> IsReesCongruence(C); # true true gap> ######################## gap> # gap> # More Congruences gap> # gap> ######################## gap> f := FreeGroup("a");; gap> g := f/[f.1^4];; gap> phi := InjectionZeroMagma(g); MappingByFunction( , , function( g ) ... end ) gap> m := Range(phi); gap> el := Elements(m);; gap> Size(m)=5; true gap> c := MagmaCongruenceByGeneratingPairs(m,[[el[2],el[3]]]); gap> EquivalenceRelationPartition(c); [ [ , a, a^2, a^-1 ] ] gap> IsReesCongruence(c); false gap> MagmaIdealByGenerators(m,EquivalenceRelationPartition(c)[1]); gap> Size(last); 5 gap> ############################### gap> ## gap> ## testing generic factoring methods in semigrp.gd gap> ## gap> ## gap> gap> f := FreeSemigroup(["a","b","c"]);; gap> gens := GeneratorsOfSemigroup(f);; gap> rels:= [[gens[1],gens[2]]];; gap> cong := SemigroupCongruenceByGeneratingPairs(f, rels);; gap> g1 := HomomorphismFactorSemigroup(f, cong);; gap> g2 := HomomorphismFactorSemigroupByClosure(f, rels);; gap> g3 := FactorSemigroup(f, cong);; gap> g4 := FactorSemigroupByClosure(f, rels);; gap> # quotient of an fp semigroup gap> gens3 := GeneratorsOfSemigroup(g3);; gap> rels3 := [[gens3[1],gens3[2]]];; gap> cong3 := SemigroupCongruenceByGeneratingPairs(g3, rels3);; gap> q3 := FactorSemigroup(g3, cong3);; gap> # quotient of a transformation semigroup gap> a := Transformation([2,3,1,2]);; gap> s := Semigroup([a]);; gap> rels := [[a,a^2]];; gap> cong := SemigroupCongruenceByGeneratingPairs(s,rels);; gap> s/rels;; gap> s/cong;; gap> ################################## gap> # Basic finite examples gap> # gap> ################################## gap> gap> f := FreeSemigroup("x1","x2");; gap> x1 := GeneratorsOfSemigroup(f)[1];; gap> x2 := GeneratorsOfSemigroup(f)[2];; gap> g := f/[[x1^2,x1],[x2^2,x2],[x1*x2,x2*x1]];; gap> y1 := GeneratorsOfSemigroup(g)[1];; gap> y2 := GeneratorsOfSemigroup(g)[2];; gap> y1*y2 = y2*y1; # true true gap> y1 = y2; # false false gap> AsSSortedList(g);; # [ x1, x2, x1*x2 ] gap> k := KnuthBendixRewritingSystem(g);; gap> IsConfluent(k); # true true gap> phi := IsomorphismTransformationSemigroup(g);; gap> Size(Source(phi)) = Size(Range(phi)); # true true gap> csi := HomomorphismTransformationSemigroup(g, > RightMagmaCongruenceByGeneratingPairs(g, [[y1,y2]]));; gap> Size(Source(csi)) >= Size(Range(csi)); # true true gap> gap> a := Transformation([1,1,3,4]);; gap> b := Transformation([2,2,3,4]);; gap> c := Transformation([1,2,2,4]);; gap> d := Transformation([1,3,3,4]);; gap> e := Transformation([1,2,3,3]);; gap> f := Transformation([1,2,4,4]);; gap> M4 := Monoid([a,b,c,d,e,f]);; gap> eM4 := AsSSortedList(M4);; gap> Size(M4); 35 gap> congM4 := SemigroupCongruenceByGeneratingPairs(M4, [[eM4[6],eM4[9]]]);; gap> QM4 := M4/congM4;; gap> One(a);; gap> One(QM4);; gap> One(eM4[2]);; gap> eqm4 := AsSSortedList(QM4);; gap> Size(QM4); 2 gap> One(eqm4[2]);; gap> gap> ################################# gap> ## Testing equivalence relations gap> ################################## gap> gap> # first a set example gap> x := Domain([1,2,3]);; gap> er := EquivalenceRelationByPartition(x,[[1,2],[3]]);; gap> e2 := EquivalenceClassOfElement(er,2);; gap> f2 := EquivalenceClassOfElement(er,2);; gap> e2 = f2; true gap> f3 := EquivalenceClassOfElement(er,3);; gap> f3=f2; # should be false false gap> gap> # A semigroup example gap> t := Transformation([2,3,1]);; gap> s := Transformation([3,3,1]);; gap> S := Semigroup(s,t);; gap> e := AsSSortedList(S);; gap> c := SemigroupCongruenceByGeneratingPairs(S,[[e[9],e[12]]]);; gap> cc1 := EquivalenceClassOfElement(c,e[1]);; gap> cc2 := EquivalenceClassOfElement(c,e[2]);; gap> cc1=cc2; true gap> EquivalenceRelationPartition(c);; gap> cc1=cc2; # works true gap> Set([cc1,cc2]);; gap> gap> ############# Zeros gap> a := Transformation([1,2,1]);; gap> b := Transformation([1,1,1]);; gap> s := Semigroup([a,b]);; gap> HasMultiplicativeZero(s); false gap> IsMultiplicativeZero(s,a); false gap> HasMultiplicativeZero(s); false gap> IsMultiplicativeZero(s,b); true gap> HasMultiplicativeZero(s); true gap> MultiplicativeZero(s);; gap> gap> ## Adding zero to a magma gap> ########################################### gap> G := Group((1,2,3));; gap> i := InjectionZeroMagma(G);; gap> G0 := Range(i);; gap> IsMonoid(G0); true gap> g := AsSSortedList(G0);; gap> g[1]*g[2]; 0 gap> g[3]*g[2];; gap> g[3]*g[4];; gap> IsZeroGroup(G0); true gap> m := Monoid(g[3],g[4]);; gap> CategoryCollections(IsMultiplicativeElementWithZero)(m); true gap> gap> gap> STOP_TEST( "semigrp.tst", 11200000 ); ############################################################################# ## #E gap-4r6p5/tst/oprt.tst0000644000175000017500000000265012172557256013502 0ustar billbill############################################################################# ## #W oprt.tst GAP-4 library ALexander Hulpke ## ## #Y Copyright 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## To be listed in testinstall.g ## gap> START_TEST("oprt.tst"); gap> c5:=CyclicGroup(IsPermGroup,5);; gap> d:=Combinations([1..5],2);; gap> eo:=ExternalOrbit(c5,d,[1,2],OnSets); [ 1, 2 ]^G gap> IsTransitive(eo); true gap> Transitivity(eo); 1 gap> IsPrimitive(eo); true gap> Blocks(eo); [ [ [ 1, 2 ], [ 1, 5 ], [ 2, 3 ], [ 3, 4 ], [ 4, 5 ] ] ] gap> es:=ExternalSet(c5,d,OnSets);; gap> ess:=ExternalSubset(c5,es,[[1,2]],OnSets);; gap> IsTransitive(es); false gap> IsTransitive(ess); true gap> IsPrimitive(ess); true gap> Blocks(ess); [ [ [ 1, 2 ], [ 1, 5 ], [ 2, 3 ], [ 3, 4 ], [ 4, 5 ] ] ] gap> G:=AbelianGroup(IsPermGroup,[12,12]);; gap> eo:=ExternalOrbit(G,[1..24],1,OnPoints);; gap> IsTransitive(eo); true gap> Blocks(eo); [ [ 1, 5, 9 ], [ 2, 6, 10 ], [ 3, 7, 11 ], [ 4, 8, 12 ] ] gap> RepresentativesMinimalBlocks(eo); [ [ 1, 5, 9 ], [ 1, 7 ] ] gap> MaximalBlocks(eo); [ [ 1, 3, 5, 7, 9, 11 ], [ 2, 4, 6, 8, 10, 12 ] ] gap> eo:=ExternalOrbit(G,[1..12],1,OnPoints); 1^G gap> IsTransitive(eo); true gap> Blocks(eo); [ [ 1, 5, 9 ], [ 2, 6, 10 ], [ 3, 7, 11 ], [ 4, 8, 12 ] ] gap> STOP_TEST( "oprt.tst", 2000000 ); ############################################################################# ## #E gap-4r6p5/tst/unknown.tst0000644000175000017500000000237712172557256014223 0ustar billbill############################################################################# ## #W unknown.tst GAP Library Thomas Breuer ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## Exclude from testinstall.g: why? ## gap> START_TEST("unknown.tst"); gap> LargestUnknown:= 0;; gap> u:= Unknown(); Unknown(1) gap> IsUnknown( u ); true gap> IsUnknown( 1 ); false gap> u = Unknown( 1 ); true gap> u = Unknown(); false gap> Unknown() = u; false gap> u = 1; false gap> 1 = u; false gap> u < Unknown( 1 ); false gap> u < Unknown(); true gap> Unknown() < u; false gap> u < 1; false gap> 1 < u; true gap> u + u; Unknown(6) gap> u + 1; Unknown(7) gap> u + 0; Unknown(1) gap> 1 + u; Unknown(8) gap> 0 + u; Unknown(1) gap> u - u; 0 gap> u - Unknown(); Unknown(10) gap> u - 1; Unknown(11) gap> u - 0; Unknown(1) gap> 0 - u; Unknown(12) gap> u * Unknown(); Unknown(14) gap> u * 1; Unknown(1) gap> u * 2; Unknown(15) gap> 1 * u; Unknown(1) gap> 2 * u; Unknown(16) gap> u * 0; 0 gap> 0 * u; 0 gap> u / 1; Unknown(1) gap> u / 2; Unknown(17) gap> u ^ 0; 1 gap> u ^ 1; Unknown(1) gap> u ^ 2; Unknown(18) gap> STOP_TEST( "unknown.tst", 100000 ); ############################################################################# ## #E gap-4r6p5/tst/cyclotom.tst0000644000175000017500000002146012172557256014347 0ustar billbill############################################################################# ## #W cyclotom.tst GAP library Thomas Breuer ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file is being maintained by Thomas Breuer. ## Please do not make any changes without consulting him. ## (This holds also for minor changes such as the removal of whitespace or ## the correction of typos.) ## ## To be listed in testinstall.g ## gap> START_TEST("cyclotom.tst"); # Check basic arithmetic operations. gap> cyc:= E(5) + E(7); -E(35)^2-2*E(35)^12-E(35)^17-E(35)^19-E(35)^22-E(35)^26-E(35)^27-E(35)^32 -E(35)^33 gap> Int( 2/3 * cyc ); -E(35)^12 gap> RoundCyc( 2/3 * cyc ); -E(35)^2-E(35)^12-E(35)^17-E(35)^19-E(35)^22-E(35)^26-E(35)^27-E(35)^32 -E(35)^33 gap> String( cyc ); "-E(35)^2-2*E(35)^12-E(35)^17-E(35)^19-E(35)^22-E(35)^26-E(35)^27-E(35)^32-E(3\ 5)^33" gap> l1:= CoeffsCyc( cyc, 3 * Conductor( cyc ) );; gap> Print(l1,"\n"); [ 0, 2, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ] gap> l2:= CoeffsCyc( cyc, 2 * Conductor( cyc ) );; gap> Print(l2,"\n"); [ 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, -1, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, -1, 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, -1, 0, 0, 0 ] gap> l3:= CoeffsCyc( cyc, 1/2 * Conductor( cyc ) ); fail gap> CycList( l1 ) = cyc; true gap> CycList( l2 ) = cyc; true # Check atomic irrationalities. gap> EB(5); EB(7); EB(9); EB(11); E(5)+E(5)^4 E(7)+E(7)^2+E(7)^4 1 E(11)+E(11)^3+E(11)^4+E(11)^5+E(11)^9 gap> EC(13); EC(19); EC(37); EC(43); E(13)+E(13)^5+E(13)^8+E(13)^12 E(19)+E(19)^7+E(19)^8+E(19)^11+E(19)^12+E(19)^18 E(37)+E(37)^6+E(37)^8+E(37)^10+E(37)^11+E(37)^14+E(37)^23+E(37)^26+E(37)^27 +E(37)^29+E(37)^31+E(37)^36 E(43)+E(43)^2+E(43)^4+E(43)^8+E(43)^11+E(43)^16+E(43)^21+E(43)^22+E(43)^27 +E(43)^32+E(43)^35+E(43)^39+E(43)^41+E(43)^42 gap> ED(13); ED(17); E(13)+E(13)^3+E(13)^9 E(17)+E(17)^4+E(17)^13+E(17)^16 gap> EE(31); E(31)+E(31)^5+E(31)^6+E(31)^25+E(31)^26+E(31)^30 gap> EF(31); EF(37); E(31)+E(31)^2+E(31)^4+E(31)^8+E(31)^16 E(37)+E(37)^10+E(37)^11+E(37)^26+E(37)^27+E(37)^36 gap> EG(29); E(29)+E(29)^12+E(29)^17+E(29)^28 gap> EH(257); E(257)+E(257)^2+E(257)^4+E(257)^8+E(257)^15+E(257)^16+E(257)^17+E(257)^30 +E(257)^32+E(257)^34+E(257)^60+E(257)^64+E(257)^68+E(257)^120+E(257)^121 +E(257)^128+E(257)^129+E(257)^136+E(257)^137+E(257)^189+E(257)^193+E(257)^197 +E(257)^223+E(257)^225+E(257)^227+E(257)^240+E(257)^241+E(257)^242+E(257)^249 +E(257)^253+E(257)^255+E(257)^256 gap> EY(24); EY(44); EY(16,1); EY(24,1); EY(189,1); EY(40,2); EY(63,2); E(24)-E(24)^11 -E(44)^23+E(44)^43 E(16)+E(16)^7 E(24)-E(24)^17 -E(189)^64-E(189)^118-E(189)^127-E(189)^181 -E(40)^21+E(40)^31 E(63)+E(63)^55 gap> EX(19); EX(31); EX(171); EX(43); E(19)+E(19)^7+E(19)^11 E(31)+E(31)^5+E(31)^25 E(171)^7+E(171)^49-E(171)^58-E(171)^115 E(43)+E(43)^6+E(43)^36 gap> EX(333,1); -E(333)^112+E(333)^121-E(333)^223+E(333)^322 gap> EW(25); EW(40); EW(41); EW(80); -E(25)^4-E(25)^6+E(25)^7-E(25)^9-E(25)^11-E(25)^14-E(25)^16+E(25)^18-E(25)^19 -E(25)^21 -E(40)^7-E(40)^21-E(40)^23-E(40)^29 E(41)+E(41)^9+E(41)^32+E(41)^40 E(80)^3+E(80)^9-E(80)^41-E(80)^67 gap> EV(71); EV(41,3); E(71)+E(71)^5+E(71)^25+E(71)^54+E(71)^57 E(41)+E(41)^10+E(41)^16+E(41)^18+E(41)^37 gap> EU(56); EU(56,1); -E(56)^29-E(56)^31-E(56)^37-E(56)^47-E(56)^53-E(56)^55 0 gap> ET(29,1); E(29)+E(29)^7+E(29)^16+E(29)^20+E(29)^23+E(29)^24+E(29)^25 gap> ES(32,3); 0 gap> EM(16); EM(40,1); E(16)+E(16)^7 -E(40)^21+E(40)^29 gap> EL(50,1); EL(91,2); E(25)^9-E(25)^12-E(25)^13+E(25)^16 E(91)-E(91)^34+E(91)^64-E(91)^83 gap> EK(31); E(31)+E(31)^5-E(31)^6+E(31)^25-E(31)^26-E(31)^30 gap> EJ(17,3); E(17)-E(17)^2+E(17)^4-E(17)^8-E(17)^9+E(17)^13-E(17)^15+E(17)^16 gap> r:= Sqrt(2); r^2 = 2; E(8)-E(8)^3 true gap> r:= Sqrt(-6); r^2 = -6; E(24)+E(24)^11-E(24)^17-E(24)^19 true gap> r:= Sqrt(75); r^2 = 75; -5*E(12)^7+5*E(12)^11 true gap> r:= Sqrt(13); r^2 = 13; E(13)-E(13)^2+E(13)^3+E(13)^4-E(13)^5-E(13)^6-E(13)^7-E(13)^8+E(13)^9+E(13)^10 -E(13)^11+E(13)^12 true gap> r:= Sqrt(80); r^2 = 80; 4*E(5)-4*E(5)^2-4*E(5)^3+4*E(5)^4 true gap> EI(17); EI(16); EI(23); E(68)-E(68)^5+E(68)^9+E(68)^13+E(68)^21+E(68)^25-E(68)^29+E(68)^33-E(68)^37 -E(68)^41-E(68)^45+E(68)^49+E(68)^53-E(68)^57-E(68)^61-E(68)^65 4*E(4) E(23)+E(23)^2+E(23)^3+E(23)^4-E(23)^5+E(23)^6-E(23)^7+E(23)^8+E(23)^9-E(23)^10 -E(23)^11+E(23)^12+E(23)^13-E(23)^14-E(23)^15+E(23)^16-E(23)^17+E(23)^18 -E(23)^19-E(23)^20-E(23)^21-E(23)^22 # Check general Atlas irrationalities. gap> AtlasIrrationality( "b7*" ); E(7)^3+E(7)^5+E(7)^6 gap> AtlasIrrationality( "b7*3" ); E(7)^3+E(7)^5+E(7)^6 gap> AtlasIrrationality( "y'''24" ); E(24)-E(24)^19 gap> AtlasIrrationality( "-y'''24" ); -E(24)+E(24)^19 gap> AtlasIrrationality( "-y'''24*13" ); E(24)-E(24)^19 gap> AtlasIrrationality( "-3y'''24*13" ); 3*E(24)-3*E(24)^19 gap> AtlasIrrationality( "-3y'''24*13&5" ); 3*E(8)-3*E(8)^3 gap> AtlasIrrationality( "3y'''24*13-2&5" ); -3*E(24)-2*E(24)^11+2*E(24)^17+3*E(24)^19 gap> AtlasIrrationality( "3y'''24*13-&5" ); -3*E(24)-E(24)^11+E(24)^17+3*E(24)^19 gap> AtlasIrrationality( "3y'''24*13-4&5&7" ); -7*E(24)-4*E(24)^11+4*E(24)^17+7*E(24)^19 gap> AtlasIrrationality( "3y'''24&7" ); 6*E(24)-6*E(24)^19 gap> StarCyc( EB(7) ); E(7)^3+E(7)^5+E(7)^6 gap> StarCyc( Sqrt(13) ); -E(13)+E(13)^2-E(13)^3-E(13)^4+E(13)^5+E(13)^6+E(13)^7+E(13)^8-E(13)^9 -E(13)^10+E(13)^11-E(13)^12 gap> Quadratic( 4 ); rec( ATLAS := "4", a := 4, b := 0, d := 1, display := "4", root := 1 ) gap> Quadratic( EB(7) ); rec( ATLAS := "b7", a := -1, b := 1, d := 2, display := "(-1+Sqrt(-7))/2", root := -7 ) gap> Quadratic( E(4) ); rec( ATLAS := "i", a := 0, b := 1, d := 1, display := "Sqrt(-1)", root := -1 ) gap> Quadratic( E(3) ); rec( ATLAS := "b3", a := -1, b := 1, d := 2, display := "(-1+Sqrt(-3))/2", root := -3 ) gap> Quadratic( Sqrt(12) ); rec( ATLAS := "2r3", a := 0, b := 2, d := 1, display := "2*Sqrt(3)", root := 3 ) gap> Quadratic( StarCyc( EB(5) ) ); rec( ATLAS := "-1-b5", a := -1, b := -1, d := 2, display := "(-1-Sqrt(5))/2", root := 5 ) gap> GeneratorsPrimeResidues( 7^4 ); rec( exponents := [ 4 ], generators := [ 3 ], primes := [ 7 ] ) gap> GeneratorsPrimeResidues( 27*125 ); rec( exponents := [ 3, 3 ], generators := [ 1001, 2377 ], primes := [ 3, 5 ] ) gap> GeneratorsPrimeResidues( 2*9*5 ); rec( exponents := [ 1, 2, 1 ], generators := [ 1, 11, 37 ], primes := [ 2, 3, 5 ] ) gap> GeneratorsPrimeResidues( 4*3*25 ); rec( exponents := [ 2, 1, 2 ], generators := [ 151, 101, 277 ], primes := [ 2, 3, 5 ] ) gap> GeneratorsPrimeResidues( 8*49*11 ); rec( exponents := [ 3, 2, 1 ], generators := [ [ 1079, 2157 ], 3433, 3137 ], primes := [ 2, 7, 11 ] ) gap> GeneratorsPrimeResidues( 16*13*29 ); rec( exponents := [ 4, 1, 1 ], generators := [ [ 5279, 1509 ], 1393, 1249 ], primes := [ 2, 13, 29 ] ) gap> mat:= [ [ 1333, EB(7), -1, 0, 0 ], > [ 259775040, 0, 0, 2*Sqrt(3), 0 ], > [ 885257856, 0, 2*Sqrt(5)-1, 0, 0 ], > [ 1445942610, 0, 0, 0, EC(43) ] ];; gap> gm:= GaloisMat( mat ); rec( galoisfams := [ [ [ 1, 5 ], [ 1, 10321 ] ], [ [ 2, 6 ], [ 1, 9031 ] ], [ [ 3, 7 ], [ 1, 10837 ] ], [ [ 4, 8, 9 ], [ 1, 7141, 10501 ] ], 0, 0, 0, 0, 0 ], generators := [ (4,8,9), (3,7), (2,6), (1,5) ], mat := [ [ 1333, E(7)+E(7)^2+E(7)^4, -1, 0, 0 ], [ 259775040, 0, 0, -2*E(12)^7+2*E(12)^11, 0 ], [ 885257856, 0, 3*E(5)-E(5)^2-E(5)^3+3*E(5)^4, 0, 0 ], [ 1445942610, 0, 0, 0, E(43)+E(43)^2+E(43)^4+E(43)^8+E(43)^11+E(43)^16+E(43)^21+E(43)^22 +E(43)^27+E(43)^32+E(43)^35+E(43)^39+E(43)^41+E(43)^42 ], [ 1333, E(7)^3+E(7)^5+E(7)^6, -1, 0, 0 ], [ 259775040, 0, 0, 2*E(12)^7-2*E(12)^11, 0 ], [ 885257856, 0, -E(5)+3*E(5)^2+3*E(5)^3-E(5)^4, 0, 0 ], [ 1445942610, 0, 0, 0, E(43)^3+E(43)^5+E(43)^6+E(43)^10+E(43)^12+E(43)^19+E(43)^20+E(43)^23 +E(43)^24+E(43)^31+E(43)^33+E(43)^37+E(43)^38+E(43)^40 ], [ 1445942610, 0, 0, 0, E(43)^7+E(43)^9+E(43)^13+E(43)^14+E(43)^15+E(43)^17+E(43)^18 +E(43)^25+E(43)^26+E(43)^28+E(43)^29+E(43)^30+E(43)^34+E(43)^36 ] ] ) gap> Print(RationalizedMat( gm.mat ),"\n"); [ [ 2666, -1, -2, 0, 0 ], [ 519550080, 0, 0, 0, 0 ], [ 1770515712, 0, -2, 0, 0 ], [ 4337827830, 0, 0, 0, -1 ] ] gap> a := -E(4)*2^(8*GAPInfo.BytesPerVariable-4);; gap> TNUM_OBJ(COEFFS_CYC(-a)[2]) <> [ 0, "integer" ]; true gap> STOP_TEST( "cyclotom.tst", 900000 ); ############################################################################# ## #E gap-4r6p5/tst/arithlst.tst0000644000175000017500000007044112172557256014353 0ustar billbill############################################################################# ## #W arithlst.tst GAP library Thomas Breuer ## ## #Y Copyright (C) 2000, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## Exclude from testinstall.g because it runs too long. ## gap> START_TEST("arithlst.tst"); ############################################################################# ## ## Parametrize the output; if `error' has the value `Error' then only the ## first error in each call is printed in the `ReadTest' run, ## if the value is `Print' then all errors are printed. ## gap> error:= Print;; ############################################################################# ## ## Define auxiliary functions. ## gap> RandomSquareArray := function( dim, D ) > return List( [ 1 .. dim ], i -> List( [ 1 .. dim ], j -> Random( D ) ) ); > end;; gap> NestingDepthATest := function( obj ) > if not IsGeneralizedRowVector( obj ) then > return 0; > elif IsEmpty( obj ) then > return 1; > else > return 1 + NestingDepthATest( obj[ PositionBound( obj ) ] ); > fi; > end;; gap> NestingDepthMTest := function( obj ) > if not IsMultiplicativeGeneralizedRowVector( obj ) then > return 0; > elif IsEmpty( obj ) then > return 1; > else > return 1 + NestingDepthMTest( obj[ PositionBound( obj ) ] ); > fi; > end;; gap> ImmutabilityLevel2 := function( list ) > if not IsList( list ) then > if IsMutable( list ) then > Error( " is not a list" ); > else > return 0; > fi; > elif IsEmpty( list ) then > # The empty list is defined to have immutability level 0. > return 0; > elif IsMutable( list ) then > return ImmutabilityLevel2( list[ PositionBound( list ) ] ); > else > return 1 + ImmutabilityLevel2( list[ PositionBound( list ) ] ); > fi; > end;; gap> ImmutabilityLevel := function( list ) > if IsMutable( list ) then > return ImmutabilityLevel2( list ); > else > return infinity; > fi; > end;; ## Note that the two-argument version of `List' is defined only for ## dense lists. gap> ListWithPrescribedHoles := function( list, func ) > local result, i; > > result:= []; > for i in [ 1 .. Length( list ) ] do > if IsBound( list[i] ) then > result[i]:= func( list[i] ); > fi; > od; > return result; > end;; gap> SumWithHoles := function( list ) > local pos, result, i; > > pos:= PositionBound( list ); > result:= list[ pos ]; > for i in [ pos+1 .. Length( list ) ] do > if IsBound( list[i] ) then > result:= result + list[i]; > fi; > od; > return result; > end;; gap> ParallelOp := function( op, list1, list2, mode ) > local result, i; > > result:= []; > for i in [ 1 .. Maximum( Length( list1 ), Length( list2 ) ) ] do > if IsBound( list1[i] ) then > if IsBound( list2[i] ) then > result[i]:= op( list1[i], list2[i] ); > elif mode = "one" then > result[i]:= ShallowCopy( list1[i] ); > fi; > elif IsBound( list2[i] ) and mode = "one" then > result[i]:= ShallowCopy( list2[i] ); > fi; > od; > return result; > end;; gap> ErrorMessage := function( opname, operands, info, is, should ) > local str, i; > > str:= Concatenation( opname, "( " ); > for i in [ 1 .. Length( operands ) - 1 ] do > Append( str, operands[i] ); > Append( str, ", " ); > od; > error( str, operands[ Length( operands ) ], " ): ", info, ",\n", > "should be ", should, " but is ", is, "\n" ); > end;; gap> CheckMutabilityStatus := function( opname, list ) > local attr, op, val, sm; > > attr:= ValueGlobal( Concatenation( opname, "Attr" ) ); > if ImmutabilityLevel( attr( list ) ) <> infinity then > error( opname, "Attr: mutability problem for ", list, > " (", ImmutabilityLevel( list ), ")\n" ); > fi; > op:= ValueGlobal( Concatenation( opname, "Op" ) ); > val:= op( list ); > if val <> fail and IsCopyable( val ) and not IsMutable( val ) then > error( opname, "Op: mutability problem for ", list, > " (", ImmutabilityLevel( list ), ")\n" ); > fi; > sm:= ValueGlobal( Concatenation( opname, "SM" ) ); > val:= sm( list ); > if val <> fail > and IsCopyable( val ) > and ImmutabilityLevel( sm( list ) ) <> ImmutabilityLevel( list ) then > error( opname, "SM: mutability problem for ", list, > " (", ImmutabilityLevel( list ), ")\n" ); > fi; > end;; ## Check whether a unary operation preserves the compression status. gap> COMPRESSIONS := [ "Is8BitMatrixRep", "Is8BitVectorRep", > "IsGF2VectorRep", "IsGF2MatrixRep" ];; gap> CheckCompressionStatus := function( opname, list ) > local value, namefilter, filter; > > value:= ValueGlobal( opname )( list ); > if value <> fail then > for namefilter in COMPRESSIONS do > filter:= ValueGlobal( namefilter ); > if filter( list ) and not filter( value ) then > error( opname, " does not preserve `", namefilter, "'\n" ); > fi; > od; > fi; > end;; gap> CompareTest := function( opname, operands, result, desired ) > local i, j, val; > > # Check that the same positions are bound, > # and that corresponding entries are equal. > if IsList( result ) and IsList( desired ) then > if Length( result ) <> Length( desired ) then > ErrorMessage( opname, operands, "lengths differ", > Length( result ), Length( desired ) ); > fi; > for i in [ 1 .. Length( result ) ] do > if IsBound( result[i] ) then > if not IsBound( desired[i] ) then > ErrorMessage( opname, operands, > Concatenation( "bound at ", String( i ) ), > result[i], "unbound" ); > elif result[i] <> desired[i] then > ErrorMessage( opname, operands, > Concatenation( "error at ", String( i ) ), > result[i], desired[i] ); > fi; > elif IsBound( desired[i] ) then > ErrorMessage( opname, operands, > Concatenation( "unbound at ", String( i ) ), > "unbound", desired[i] ); > fi; > od; > elif IsList( result ) or IsList( desired ) then > ErrorMessage( opname, operands, "list vs. non-list", result, desired ); > elif result <> desired then > ErrorMessage( opname, operands, "two non-lists", result, desired ); > fi; > > # Check the mutability status. > if Length( operands ) = 2 > and IsList( result ) and IsCopyable( result ) > and ImmutabilityLevel( result ) > <> Minimum( List( operands, ImmutabilityLevel ) ) > and not (ImmutabilityLevel(result)=infinity and > NestingDepthM(result) = > Minimum( List( operands, ImmutabilityLevel ) )) then > error( opname, ": mutability problem for ", operands[1], " (", > ImmutabilityLevel( operands[1] ), ") and ", operands[2], " (", > ImmutabilityLevel( operands[2] ), ")\n" ); > fi; > end;; ############################################################################# ## #F ZeroTest( ) ## ## The zero of a list $x$ in `IsGeneralizedRowVector' is defined as ## the list whose entry at position $i$ is the zero of $x[i]$ ## if this entry is bound, and is unbound otherwise. ## gap> ZeroTest := function( list ) > if IsGeneralizedRowVector( list ) then > CompareTest( "Zero", [ list ], > Zero( list ), > ListWithPrescribedHoles( list, Zero ) ); > CheckMutabilityStatus( "Zero", list ); > CheckCompressionStatus( "ZeroAttr", list ); > CheckCompressionStatus( "ZeroSM", list ); > fi; > end;; ############################################################################# ## #F AdditiveInverseTest( ) ## ## The additive inverse of a list $x$ in `IsGeneralizedRowVector' is defined ## as the list whose entry at position $i$ is the additive inverse of $x[i]$ ## if this entry is bound, and is unbound otherwise. ## gap> AdditiveInverseTest := function( list ) > if IsGeneralizedRowVector( list ) then > CompareTest( "AdditiveInverse", [ list ], > AdditiveInverse( list ), > ListWithPrescribedHoles( list, AdditiveInverse ) ); > CheckMutabilityStatus( "AdditiveInverse", list ); > CheckCompressionStatus( "AdditiveInverseAttr", list ); > CheckCompressionStatus( "AdditiveInverseSM", list ); > fi; > end;; ############################################################################# ## #F AdditionTest( , ) ## ## If $x$ and $y$ are in `IsGeneralizedRowVector' and have the same ## additive nesting depth (see~"NestingDepthA"), ## % By definition, this depth is nonzero. ## the sum $x + y$ is defined *pointwise*, in the sense that the result is a ## list whose entry at position $i$ is $x[i] + y[i]$ if these entries are ## bound, ## is a shallow copy (see~"ShallowCopy") of $x[i]$ or $y[i]$ if the other ## argument is not bound at position $i$, ## and is unbound if both $x$ and $y$ are unbound at position $i$. ## ## If $x$ is in `IsGeneralizedRowVector' and $y$ is either not a list or is ## in `IsGeneralizedRowVector' and has lower additive nesting depth, ## the sum $x + y$ is defined as a list whose entry at position $i$ is ## $x[i] + y$ if $x$ is bound at position $i$, and is unbound if not. ## The equivalent holds in the reversed case, ## where the order of the summands is kept, ## as addition is not always commutative. ## ## For two {\GAP} objects $x$ and $y$ of which one is in ## `IsGeneralizedRowVector' and the other is either not a list or is ## also in `IsGeneralizedRowVector', ## $x - y$ is defined as $x + (-y)$. ## gap> AdditionTest := function( left, right ) > local depth1, depth2, desired; > > if IsGeneralizedRowVector( left ) and IsGeneralizedRowVector( right ) then > depth1:= NestingDepthATest( left ); > depth2:= NestingDepthATest( right ); > if depth1 = depth2 then > desired:= ParallelOp( \+, left, right, "one" ); > elif depth1 < depth2 then > desired:= ListWithPrescribedHoles( right, x -> left + x ); > else > desired:= ListWithPrescribedHoles( left, x -> x + right ); > fi; > elif IsGeneralizedRowVector( left ) and not IsList( right ) then > desired:= ListWithPrescribedHoles( left, x -> x + right ); > elif not IsList( left ) and IsGeneralizedRowVector( right ) then > desired:= ListWithPrescribedHoles( right, x -> left + x ); > else > return; > fi; > CompareTest( "Addition", [ left, right ], left + right, desired ); > if AdditiveInverse( right ) <> fail then > CompareTest( "Subtraction", [ left, right ], left - right, > left + ( - right ) ); > fi; > end;; ############################################################################# ## #F OneTest( ) ## gap> OneTest := function( list ) > if IsOrdinaryMatrix( list ) and Length( list ) = Length( list[1] ) then > CheckMutabilityStatus( "One", list ); > CheckCompressionStatus( "OneAttr", list ); > CheckCompressionStatus( "OneSM", list ); > fi; > end;; ############################################################################# ## #F InverseTest( ) ## gap> InverseTest := function( list ) > if IsOrdinaryMatrix( list ) and Length( list ) = Length( list[1] ) then > CheckMutabilityStatus( "Inverse", list ); > CheckCompressionStatus( "InverseAttr", list ); > CheckCompressionStatus( "InverseSM", list ); > fi; > end;; ############################################################################# ## #F TransposedMatTest( ) ## gap> TransposedMatTest := function( list ) > if IsOrdinaryMatrix( list ) then > CheckCompressionStatus( "TransposedMatAttr", list ); > CheckCompressionStatus( "TransposedMatOp", list ); > fi; > end;; ############################################################################# ## #F MultiplicationTest( , ) ## ## There are three possible computations that might be triggered by a ## multiplication involving a list in ## `IsMultiplicativeGeneralizedRowVector'. ## Namely, $x * y$ might be ## \beginlist ## \item{(I)} ## the inner product $x[1] * y[1] + x[2] * y[2] + \cdots + x[n] * y[n]$, ## where summands are omitted for which the entry in $x$ or $y$ is ## unbound ## (if this leaves no summand then the multiplication is an error), ## or ## \item{(L)} ## the left scalar multiple, i.e., a list whose entry at position $i$ is ## $x * y[i]$ if $y$ is bound at position $i$, and is unbound if not, or ## \item{(R)} ## the right scalar multiple, i.e., a list whose entry at position $i$ ## is $x[i] * y$ if $x$ is bound at position $i$, and is unbound if not. ## \endlist ## ## Our aim is to generalize the basic arithmetic of simple row vectors and ## matrices, so we first summarize the situations that shall be covered. ## ## \beginexample ## | scl vec mat ## --------------------- ## scl | (L) (L) ## vec | (R) (I) (I) ## mat | (R) (R) (R) ## \endexample ## ## This means for example that the product of a scalar (scl) ## with a vector (vec) or a matrix (mat) is computed according to (L). ## Note that this is asymmetric. ## ## Now we can state the general multiplication rules. ## ## If exactly one argument is in `IsMultiplicativeGeneralizedRowVector' ## then we regard the other argument (which is then not a list) as a scalar, ## and specify result (L) or (R), depending on ordering. ## ## In the remaining cases, both $x$ and $y$ are in ## `IsMultiplicativeGeneralizedRowVector', and we distinguish the ## possibilities by their multiplicative nesting depths. ## An argument with *odd* multiplicative nesting depth is regarded as a ## vector, and an argument with *even* multiplicative nesting depth is ## regarded as a scalar or a matrix. ## ## So if both arguments have odd multiplicative nesting depth, ## we specify result (I). ## ## If exactly one argument has odd nesting depth, ## the other is treated as a scalar if it has lower multiplicative nesting ## depth, and as a matrix otherwise. ## In the former case, we specify result (L) or (R), depending on ordering; ## in the latter case, we specify result (L) or (I), depending on ordering. ## ## We are left with the case that each argument has even multiplicative ## nesting depth. ## % By definition, this depth is nonzero. ## If the two depths are equal, we treat the computation as a matrix product, ## and specify result (R). ## Otherwise, we treat the less deeply nested argument as a scalar and the ## other as a matrix, and specify result (L) or (R), depending on ordering. ## ## For two {\GAP} objects $x$ and $y$ of which one is in ## `IsMultiplicativeGeneralizedRowVector' and the other is either not a list ## or is also in `IsMultiplicativeGeneralizedRowVector', ## $x / y$ is defined as $x * y^{-1}$. ## gap> MultiplicationTest := function( left, right ) > local depth1, depth2, par, desired; > > if IsMultiplicativeGeneralizedRowVector( left ) and > IsMultiplicativeGeneralizedRowVector( right ) then > depth1:= NestingDepthMTest( left ); > depth2:= NestingDepthMTest( right ); > if IsOddInt( depth1 ) then > if IsOddInt( depth2 ) or depth1 < depth2 then > # * or * > par:= ParallelOp( \*, left, right, "both" ); > if IsEmpty( par ) then > error( "vector multiplication * with empty ", > "support:\n", left, "\n", right, "\n" ); > else > desired:= SumWithHoles( par ); > fi; > else > # * > desired:= ListWithPrescribedHoles( left, x -> x * right ); > fi; > elif IsOddInt( depth2 ) then > if depth1 < depth2 then > # * > desired:= ListWithPrescribedHoles( right, x -> left * x ); > else > # * > desired:= ListWithPrescribedHoles( left, x -> x * right ); > fi; > elif depth1 = depth2 then > # * > desired:= ListWithPrescribedHoles( left, x -> x * right ); > elif depth1 < depth2 then > # * > desired:= ListWithPrescribedHoles( right, x -> left * x ); > else > # * > desired:= ListWithPrescribedHoles( left, x -> x * right ); > fi; > elif IsMultiplicativeGeneralizedRowVector( left ) and > not IsList( right ) then > desired:= ListWithPrescribedHoles( left, x -> x * right ); > elif IsMultiplicativeGeneralizedRowVector( right ) and > not IsList( left ) then > desired:= ListWithPrescribedHoles( right, x -> left * x ); > else > return; > fi; > CompareTest( "Multiplication", [ left, right ], left * right, desired ); > if IsMultiplicativeGeneralizedRowVector( right ) > and IsOrdinaryMatrix( right ) > and Length( right ) = Length( right[1] ) > and NestingDepthM( right ) = 2 > and Inverse( right ) <> fail then > CompareTest( "Division", [ left, right ], left / right, > left * ( right^-1 ) ); > fi; > end;; ############################################################################# ## #F RunTest( , , ... ) ## ## Call for the remaining arguments, or for shallow copies of them ## or immutable copies. ## gap> RunTest := function( arg ) > local combinations, i, entry; > > combinations:= [ ]; > for i in [ 2 .. Length( arg ) ] do > entry:= [ arg[i] ]; > if IsCopyable( arg[i] ) then > Add( entry, ShallowCopy( arg[i] ) ); > fi; > if IsMutable( arg[i] ) then > Add( entry, Immutable( arg[i] ) ); > fi; > Add( combinations, entry ); > od; > for entry in Cartesian( combinations ) do > CallFuncList( arg[1], entry ); > od; > end;; ############################################################################# ## #F TestOfAdditiveListArithmetic( , ) ## ## For a ring or list of ring elements (such that `Random( )' ## returns an element in and such that not all elements in are ## zero), ## `TestOfAdditiveListArithmetic' performs the following tests of additive ## arithmetic operations. ## \beginlist ## \item{1.} ## If the elements of are in `IsGeneralizedRowVector' then ## it is checked whether `Zero', `AdditiveInverse', and `\+' ## obey the definitions. ## \item{2.} ## If the elements of are in `IsGeneralizedRowVector' then ## it is checked whether the sum of elements in and (non-dense) ## plain lists of integers obeys the definitions. ## \item{3.} ## Check `Zero' and `AdditiveInverse' for nested plain lists of elements ## in , and `\+' for elements in and nested plain lists of ## elements in . ## \endlist ## gap> TestOfAdditiveListArithmetic := function( R, dim ) > local r, i, intlist, j, vec1, vec2, mat1, mat2, row; > > r:= Random( R ); > if IsGeneralizedRowVector( r ) then > > # tests of kind 1. > for i in [ 1 .. 10 ] do > RunTest( ZeroTest, Random( R ) ); > RunTest( AdditiveInverseTest, Random( R ) ); > RunTest( AdditionTest, Random( R ), Random( R ) ); > od; > > # tests of kind 2. > for i in [ 1 .. 10 ] do > RunTest( AdditionTest, Random( R ), [] ); > RunTest( AdditionTest, [], Random( R ) ); > r:= Random( R ); > intlist:= List( [ 1 .. Length( r ) + Random( [ -1 .. 1 ] ) ], > x -> Random( Integers ) ); > for j in [ 1 .. Int( Length( r ) / 3 ) ] do > Unbind( intlist[ Random( [ 1 .. Length( intlist ) ] ) ] ); > od; > RunTest( AdditionTest, r, intlist ); > RunTest( AdditionTest, intlist, r ); > od; > > fi; > > # tests of kind 3. > for i in [ 1 .. 10 ] do > > vec1:= List( [ 1 .. dim ], x -> Random( R ) ); > vec2:= List( [ 1 .. dim ], x -> Random( R ) ); > > RunTest( ZeroTest, vec1 ); > RunTest( AdditiveInverseTest, vec1 ); > RunTest( AdditionTest, vec1, Random( R ) ); > RunTest( AdditionTest, Random( R ), vec2 ); > RunTest( AdditionTest, vec1, vec2 ); > RunTest( AdditionTest, vec1, [] ); > RunTest( AdditionTest, [], vec2 ); > Unbind( vec1[ dim ] ); > RunTest( AdditionTest, vec1, vec2 ); > Unbind( vec2[ Random( [ 1 .. dim ] ) ] ); > RunTest( ZeroTest, vec2 ); > RunTest( AdditiveInverseTest, vec1 ); > RunTest( AdditiveInverseTest, vec2 ); > RunTest( AdditionTest, vec1, vec2 ); > Unbind( vec1[ Random( [ 1 .. dim ] ) ] ); > RunTest( AdditionTest, vec1, vec2 ); > > mat1:= RandomSquareArray( dim, R ); > mat2:= RandomSquareArray( dim, R ); > > RunTest( ZeroTest, mat1 ); > RunTest( AdditiveInverseTest, mat1 ); > RunTest( TransposedMatTest, mat1 ); > RunTest( AdditionTest, mat1, Random( R ) ); > RunTest( AdditionTest, Random( R ), mat2 ); > RunTest( AdditionTest, vec1, mat2 ); > RunTest( AdditionTest, mat1, vec2 ); > RunTest( AdditionTest, mat1, mat2 ); > RunTest( AdditionTest, mat1, [] ); > RunTest( AdditionTest, [], mat2 ); > Unbind( mat1[ dim ] ); > row:= mat1[ Random( [ 1 .. dim-1 ] ) ]; > if not IsLockedRepresentationVector( row ) then > Unbind( row[ Random( [ 1 .. dim ] ) ] ); > fi; > RunTest( AdditionTest, mat1, mat2 ); > Unbind( mat2[ Random( [ 1 .. dim ] ) ] ); > RunTest( ZeroTest, mat2 ); > RunTest( AdditiveInverseTest, mat1 ); > RunTest( AdditiveInverseTest, mat2 ); > RunTest( TransposedMatTest, mat2 ); > RunTest( AdditionTest, mat1, mat2 ); > Unbind( mat1[ Random( [ 1 .. dim ] ) ] ); > RunTest( AdditionTest, mat1, mat2 ); > > od; > end;; ############################################################################# ## #F TestOfMultiplicativeListArithmetic( , ) ## ## For a ring or list of ring elements (such that `Random( )' ## returns an element in and such that not all elements in are ## zero), ## `TestOfMultiplicativeListArithmetic' performs the following tests of ## multiplicative arithmetic operations. ## \beginlist ## \item{1.} ## If the elements of are in `IsMultiplicativeGeneralizedRowVector' ## then it is checked whether `One', `Inverse', and `\*' ## obey the definitions. ## \item{2.} ## If the elements of are in `IsMultiplicativeGeneralizedRowVector' ## then it is checked whether the product of elements in and ## (non-dense) plain lists of integers obeys the definitions. ## (Note that contrary to the additive case, we need not chack the ## special case of a multiplication with an empty list.) ## \item{3.} ## Check `One' and `Inverse' for nested plain lists of elements ## in , and `\*' for elements in and nested plain lists of ## elements in . ## \endlist ## gap> TestOfMultiplicativeListArithmetic := function( R, dim ) > local r, i, intlist, j, vec1, vec2, mat1, mat2, row; > > r:= Random( R ); > if IsMultiplicativeGeneralizedRowVector( r ) then > > # tests of kind 1. > for i in [ 1 .. 10 ] do > RunTest( OneTest, Random( R ) ); > RunTest( InverseTest, Random( R ) ); > RunTest( MultiplicationTest, Random( R ), Random( R ) ); > od; > > # tests of kind 2. > for i in [ 1 .. 10 ] do > r:= Random( R ); > intlist:= List( [ 1 .. Length( r ) + Random( [ -1 .. 1 ] ) ], > x -> Random( Integers ) ); > for j in [ 1 .. Int( Length( r ) / 3 ) ] do > Unbind( intlist[ Random( [ 1 .. Length( intlist ) ] ) ] ); > od; > RunTest( MultiplicationTest, r, intlist ); > RunTest( MultiplicationTest, intlist, r ); > od; > > fi; > > # tests of kind 3. > for i in [ 1 .. 10 ] do > > vec1:= List( [ 1 .. dim ], x -> Random( R ) ); > vec2:= List( [ 1 .. dim ], x -> Random( R ) ); > > RunTest( OneTest, vec1 ); > RunTest( InverseTest, vec1 ); > RunTest( MultiplicationTest, vec1, Random( R ) ); > RunTest( MultiplicationTest, Random( R ), vec2 ); > RunTest( MultiplicationTest, vec1, vec2 ); > Unbind( vec1[ dim ] ); > RunTest( MultiplicationTest, vec1, vec2 ); > Unbind( vec2[ Random( [ 1 .. dim ] ) ] ); > RunTest( OneTest, vec2 ); > RunTest( InverseTest, vec1 ); > RunTest( InverseTest, vec2 ); > RunTest( MultiplicationTest, vec1, vec2 ); > Unbind( vec1[ Random( [ 1 .. dim ] ) ] ); > RunTest( MultiplicationTest, vec1, vec2 ); > > mat1:= RandomSquareArray( dim, R ); > mat2:= RandomSquareArray( dim, R ); > > RunTest( OneTest, mat1 ); > RunTest( InverseTest, mat1 ); > RunTest( MultiplicationTest, mat1, Random( R ) ); > RunTest( MultiplicationTest, Random( R ), mat2 ); > RunTest( MultiplicationTest, vec1, mat2 ); > RunTest( MultiplicationTest, mat1, vec2 ); > RunTest( MultiplicationTest, mat1, mat2 ); > Unbind( mat1[ dim ] ); > row:= mat1[ Random( [ 1 .. dim-1 ] ) ]; > if not IsLockedRepresentationVector( row ) then > Unbind( row[ Random( [ 1 .. dim ] ) ] ); > fi; > RunTest( MultiplicationTest, vec1, mat2 ); > RunTest( MultiplicationTest, mat1, vec2 ); > RunTest( MultiplicationTest, mat1, mat2 ); > Unbind( mat2[ Random( [ 1 .. dim ] ) ] ); > RunTest( OneTest, mat2 ); > RunTest( InverseTest, mat1 ); > RunTest( InverseTest, mat2 ); > RunTest( MultiplicationTest, mat1, mat2 ); > Unbind( mat1[ Random( [ 1 .. dim ] ) ] ); > RunTest( MultiplicationTest, mat1, mat2 ); > > od; > end;; ############################################################################# ## #F TestOfListArithmetic( , ) ## gap> TestOfListArithmetic := function( R, dimlist ) > local n, len, bools, i; > > len:= 100; > bools:= [ true, false ]; > > for n in dimlist do > TestOfAdditiveListArithmetic( R, n ); > TestOfMultiplicativeListArithmetic( R, n ); > R:= List( [ 1 .. len ], x -> Random( R ) ); > if IsMutable( R[1] ) and not ForAll( R, IsZero ) then > for i in [ 1 .. len ] do > if Random( bools ) then > R[i]:= Immutable( R[i] ); > fi; > od; > TestOfAdditiveListArithmetic( R, n ); > TestOfMultiplicativeListArithmetic( R, n ); > fi; > od; > end;; ############################################################################# ## ## Here the tests start. ## (The dimension should always be at least 4, ## in order to avoid errors in inner products of non-dense lists.) ## # over `GF(2)', `GF(3)', `GF(4)' (compressed elements) gap> stddims:= [ 4, 5, 6, 8, 17, 32, 33 ];; gap> TestOfListArithmetic( GF(2), stddims ); gap> TestOfListArithmetic( GF(3), stddims ); gap> TestOfListArithmetic( GF(4), stddims ); # over another small finite field (compressed elements) gap> TestOfListArithmetic( GF(25), stddims ); # over a big finite (prime) field gap> p:= NextPrimeInt( MAXSIZE_GF_INTERNAL );; gap> TestOfListArithmetic( GF( p ), stddims ); # over the rationals gap> TestOfListArithmetic( Rationals, [ 4 ] ); # over a residue class ring gap> TestOfListArithmetic( Integers mod 12, [ 4 ] ); # over a ring of non-internal objects gap> A:= QuaternionAlgebra( Rationals );; gap> TestOfListArithmetic( A, [ 4 ] ); # over a matrix space/algebra over `GF(2)' (compressed elements) gap> TestOfListArithmetic( GF(2)^[2,3], [ 4, 5, 6 ] ); # over a matrix space/algebra over another small finite field # (compressed elements) gap> TestOfListArithmetic( GF(5)^[2,3], [ 4, 5, 6 ] ); # over a matrix space/algebra over a big finite (prime) field gap> p:= NextPrimeInt( MAXSIZE_GF_INTERNAL );; gap> TestOfListArithmetic( GF( p )^[2,3], [ 4, 5, 6 ] ); # over a matrix space/algebra over the rationals gap> TestOfListArithmetic( Rationals^[2,3], [ 4, 5, 6 ] ); # over a class function space (the elements are not mult. grvs) gap> TestOfAdditiveListArithmetic( Irr( SymmetricGroup( 4 ) ), 4 ); # over a space of Lie matrices (the elements are not mult. grvs) gap> TestOfAdditiveListArithmetic( LieAlgebra( GF(3)^[2,2] ), 4 ); # # over a group of block matrices # gap> hom:= IrreducibleRepresentations( SymmetricGroup( 4 ) )[3];; # gap> ind:= InducedRepresentation( hom, SymmetricGroup( 5 ) );; # gap> blockmats:= Elements( Image( ind ) );; # gap> # Note that `Random' for the matrix group would construct a matrix # gap> # via the homomorphism to a perm. group, and this would not be a # gap> # block matrix! # gap> TestOfAdditiveListArithmetic( blockmats, 4 ); # gap> TestOfMultiplicativeListArithmetic( blockmats, 4 ); gap> STOP_TEST( "arithlst.tst", 52558700000 ); ############################################################################# ## #E gap-4r6p5/tst/rwspcgrp.tst0000644000175000017500000011477512172557256014401 0ustar billbill############################################################################# ## #W rwspcgrp.tst GAP library Frank Celler ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## To be listed in testinstall.g ## gap> START_TEST("rwspcgrp.tst"); ############################################################################# # create a free group, 8 bits gap> f := FreeGroup(11);; # deliberately not syllable rep to test old version gap> g := GeneratorsOfGroup(f){[1..11]};; # use 'fn' as abbreviation of 'g[n]' gap> f1 := g[1];; gap> f2 := g[2];; gap> f3 := g[3];; gap> f4 := g[4];; gap> f5 := g[5];; gap> f6 := g[6];; gap> f7 := g[7];; gap> f8 := g[8];; gap> f9 := g[9];; gap> f10 := g[10];; gap> f11 := g[11];; # store the relators in gap> r := [ > # power relators > [ 1, f2*f9 ], > # commutator relators > [ 6, 1, f9*f10*f11 ], [ 7, 1, f9*f11 ], [ 8, 1, f9*f10 ], [ 3, 2, > f9*f11 ], [ 5, 2, f9*f10 ], [ 5, 3, f5 ], [ 7, 3, f8 ], [ 8, 3, > f7*f8 ], [ 9, 3, f9*f11 ], [ 10, 3, f9*f10 ], [ 11, 3, f10*f11 ], [ > 6, 5, f6*f8 ], [ 7, 5, f6*f7*f8 ], [ 8, 5, f7*f8 ], [ 9, 5, f9*f10 > ], [ 10, 5, f9*f11 ], [ 11, 5, f10 ] ];; # construct a new single collector gap> rws := SingleCollector( g, [ 2, 2, 3, 3, 7, 2, 2, 2, 2, 2, 2 ] ); <> # set the relators gap> for x in r do > if 2 = Length(x) then > SetPower( rws, x[1], x[2] ); > else > SetCommutator( rws, x[1], x[2], x[3] ); > fi; > od; # construct the group gap> grp := GroupByRwsNC(rws);; gap> g := GeneratorsOfGroup(grp);; gap> IsConfluent(grp); true # construct the maximal word gap> l := [1..11]*0;; gap> r := RelativeOrders(rws);; gap> w := Product( List( [1..11], x -> g[x]^(r[x]-1) ) );; gap> Print(ExtRepOfObj(w),"\n"); [ 1, 1, 2, 1, 3, 2, 4, 2, 5, 6, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 1 ] # start multiplying around with gap> Print(ExtRepOfObj( w*w ),"\n"); [ 2, 1, 3, 1, 4, 1, 5, 2, 9, 1, 11, 1 ] gap> Print(ExtRepOfObj( w^-1 ),"\n"); [ 1, 1, 3, 1, 4, 1, 5, 2, 6, 1, 7, 1, 8, 1, 9, 1, 11, 1 ] gap> Print(ExtRepOfObj( w^1000 ),"\n"); [ 3, 2, 4, 2, 5, 6, 9, 1, 10, 1, 11, 1 ] gap> l := GeneratorsOfGroup(grp);; gap> p := One(grp);; gap> for i in l do > p := p * w * i; > od; gap> Print(ExtRepOfObj(p),"\n"); [ 3, 2, 4, 2, 5, 3, 6, 1, 8, 1, 9, 1 ] gap> l := GeneratorsOfGroup(grp);; gap> p := One(grp);; gap> for i in l do > p := p * w * i * w; > od; gap> Print(ExtRepOfObj(p),"\n"); [ 1, 1, 6, 1, 8, 1, 11, 1 ] gap> Print(ExtRepOfObj( Comm( w, w ) ),"\n"); [ ] gap> a := w * w * w;; gap> Print(ExtRepOfObj(a),"\n"); [ 1, 1, 6, 1, 7, 1, 8, 1 ] gap> a := a * a;; gap> Print(ExtRepOfObj(a),"\n"); [ 2, 1 ] gap> a := a * a;; gap> Print(ExtRepOfObj(a),"\n"); [ ] gap> Print(ExtRepOfObj( LeftQuotient( w*w, w ) ),"\n"); [ 1, 1, 3, 1, 4, 1, 5, 2, 6, 1, 7, 1, 8, 1, 9, 1, 11, 1 ] gap> Print(ExtRepOfObj( w^-1 ),"\n"); [ 1, 1, 3, 1, 4, 1, 5, 2, 6, 1, 7, 1, 8, 1, 9, 1, 11, 1 ] gap> Print(ExtRepOfObj( w^0 ),"\n"); [ ] gap> Print(ExtRepOfObj( w^1 ),"\n"); [ 1, 1, 2, 1, 3, 2, 4, 2, 5, 6, 6, 1, 7, 1, 8, 1, 9, 1, 10, 1, 11, 1 ] gap> Print(ExtRepOfObj( w^2 ),"\n"); [ 2, 1, 3, 1, 4, 1, 5, 2, 9, 1, 11, 1 ] gap> Print(ExtRepOfObj( w^3 ),"\n"); [ 1, 1, 6, 1, 7, 1, 8, 1 ] gap> Print(ExtRepOfObj( w^4 ),"\n"); [ 3, 2, 4, 2, 5, 6, 9, 1, 10, 1, 11, 1 ] gap> Print(ExtRepOfObj( w^5 ),"\n"); [ 1, 1, 2, 1, 3, 1, 4, 1, 5, 2, 6, 1, 7, 1, 8, 1, 9, 1, 11, 1 ] gap> Print(ExtRepOfObj( Comm( w, w ) ),"\n"); [ ] gap> Print(ExtRepOfObj( Comm( w, l[1] ) ),"\n"); [ 9, 1 ] gap> Print(ExtRepOfObj( LeftQuotient( w, w ) ) ,"\n") ; [ ] gap> Print(ExtRepOfObj( LeftQuotient( w, l[1] ) ),"\n"); [ 2, 1, 3, 1, 4, 1, 5, 2, 6, 1, 7, 1, 8, 1, 9, 1, 11, 1 ] gap> Print(ExtRepOfObj( One(grp) ),"\n"); [ ] gap> Print(ExtRepOfObj( w / w ),"\n"); [ ] gap> Print(ExtRepOfObj( w / l[1] ),"\n"); [ 2, 1, 3, 2, 4, 2, 5, 6, 6, 1, 7, 1, 8, 1, 10, 1, 11, 1 ] ############################################################################# # create a free group, 16 bits gap> f := FreeGroup(IsSyllableWordsFamily,61);; gap> g := GeneratorsOfGroup(f){[1..61]};; # use 'fn' as abbreviation of 'g[n]' gap> f1 := g[1];; gap> f2 := g[2];; gap> f3 := g[3];; gap> f4 := g[4];; gap> f5 := g[5];; gap> f6 := g[6];; gap> f7 := g[7];; gap> f8 := g[8];; gap> f9 := g[9];; gap> f10 := g[10];; gap> f11 := g[11];; gap> f12 := g[12];; gap> f13 := g[13];; gap> f14 := g[14];; gap> f15 := g[15];; gap> f16 := g[16];; gap> f17 := g[17];; gap> f18 := g[18];; gap> f19 := g[19];; gap> f20 := g[20];; gap> f21 := g[21];; gap> f22 := g[22];; gap> f23 := g[23];; gap> f24 := g[24];; gap> f25 := g[25];; gap> f26 := g[26];; gap> f27 := g[27];; gap> f28 := g[28];; gap> f29 := g[29];; gap> f30 := g[30];; gap> f31 := g[31];; gap> f32 := g[32];; gap> f33 := g[33];; gap> f34 := g[34];; gap> f35 := g[35];; gap> f36 := g[36];; gap> f37 := g[37];; gap> f38 := g[38];; gap> f39 := g[39];; gap> f40 := g[40];; gap> f41 := g[41];; gap> f42 := g[42];; gap> f43 := g[43];; gap> f44 := g[44];; gap> f45 := g[45];; gap> f46 := g[46];; gap> f47 := g[47];; gap> f48 := g[48];; gap> f49 := g[49];; gap> f50 := g[50];; gap> f51 := g[51];; gap> f52 := g[52];; gap> f53 := g[53];; gap> f54 := g[54];; gap> f55 := g[55];; gap> f56 := g[56];; gap> f57 := g[57];; gap> f58 := g[58];; gap> f59 := g[59];; gap> f60 := g[60];; gap> f61 := g[61];; # store the relators in gap> r := [ > # power relators > [ 8, f9 ], [ 15, f16 ], [ 22, f23 ], [ 29, f30 ], [ 36, f37 ], [ 43, > f44 ], [ 50, f51 ], [ 57, f58 ], > # commutator relators > [ 2, 1, f2 ], [ 4, 1, f5 ], [ 5, 1, f4*f5 ], [ 13, 1, f13^2*f20 ], [ > 14, 1, f14^30*f21 ], [ 15, 1, f15*f16*f22 ], [ 16, 1, f16*f23 ], [ > 17, 1, f17^4*f24 ], [ 18, 1, f18^4*f25 ], [ 19, 1, f19^4*f26 ], [ > 20, 1, f20^2*f27 ], [ 21, 1, f21^30*f28 ], [ 22, 1, f22*f23*f29 ], [ > 23, 1, f23*f30 ], [ 24, 1, f24^4*f31 ], [ 25, 1, f25^4*f32 ], [ 26, > 1, f26^4*f33 ], [ 27, 1, f13*f27^2 ], [ 28, 1, f14*f28^30 ], [ 29, > 1, f15*f29*f30 ], [ 30, 1, f16*f30 ], [ 31, 1, f17*f31^4 ], [ 32, 1, > f18*f32^4 ], [ 33, 1, f19*f33^4 ], [ 41, 1, f41^2*f48 ], [ 42, 1, > f42^30*f49 ], [ 43, 1, f43*f44*f50 ], [ 44, 1, f44*f51 ], [ 45, 1, > f45^4*f52 ], [ 46, 1, f46^4*f53 ], [ 47, 1, f47^4*f54 ], [ 48, 1, > f48^2*f55 ], [ 49, 1, f49^30*f56 ], [ 50, 1, f50*f51*f57 ], [ 51, 1, > f51*f58 ], [ 52, 1, f52^4*f59 ], [ 53, 1, f53^4*f60 ], [ 54, 1, > f54^4*f61 ], [ 55, 1, f41*f55^2 ], [ 56, 1, f42*f56^30 ], [ 57, 1, > f43*f57*f58 ], [ 58, 1, f44*f58 ], [ 59, 1, f45*f59^4 ], [ 60, 1, > f46*f60^4 ], [ 61, 1, f47*f61^4 ], [ 3, 2, f3*f5 ], [ 4, 2, f3*f4*f5 > ], [ 5, 2, f4*f5 ], [ 13, 2, f13^2*f20 ], [ 14, 2, f14^30*f21 ], [ > 15, 2, f15*f16*f22 ], [ 16, 2, f16*f23 ], [ 17, 2, f17^4*f24 ], [ > 18, 2, f18^4*f25 ], [ 19, 2, f19^4*f26 ], [ 20, 2, f20^2*f41 ], [ > 21, 2, f21^30*f42 ], [ 22, 2, f22*f23*f43 ], [ 23, 2, f23*f44 ], [ > 24, 2, f24^4*f45 ], [ 25, 2, f25^4*f46 ], [ 26, 2, f26^4*f47 ], [ > 27, 2, f27^2*f55 ], [ 28, 2, f28^30*f56 ], [ 29, 2, f29*f30*f57 ], [ > 30, 2, f30*f58 ], [ 31, 2, f31^4*f59 ], [ 32, 2, f32^4*f60 ], [ 33, > 2, f33^4*f61 ], [ 34, 2, f13*f34^2 ], [ 35, 2, f14*f35^30 ], [ 36, > 2, f15*f36*f37 ], [ 37, 2, f16*f37 ], [ 38, 2, f17*f38^4 ], [ 39, 2, > f18*f39^4 ], [ 40, 2, f19*f40^4 ], [ 41, 2, f27*f41^2 ], [ 42, 2, > f28*f42^30 ], [ 43, 2, f29*f43*f44 ], [ 44, 2, f30*f44 ], [ 45, 2, > f31*f45^4 ], [ 46, 2, f32*f46^4 ], [ 47, 2, f33*f47^4 ], [ 48, 2, > f34*f48^2 ], [ 49, 2, f35*f49^30 ], [ 50, 2, f36*f50*f51 ], [ 51, 2, > f37*f51 ], [ 52, 2, f38*f52^4 ], [ 53, 2, f39*f53^4 ], [ 54, 2, > f40*f54^4 ], [ 55, 2, f48*f55^2 ], [ 56, 2, f49*f56^30 ], [ 57, 2, > f50*f57*f58 ], [ 58, 2, f51*f58 ], [ 59, 2, f52*f59^4 ], [ 60, 2, > f53*f60^4 ], [ 61, 2, f54*f61^4 ], [ 6, 3, f6^2*f34 ], [ 7, 3, > f7^30*f35 ], [ 8, 3, f8*f9*f36 ], [ 9, 3, f9*f37 ], [ 10, 3, > f10^4*f38 ], [ 11, 3, f11^4*f39 ], [ 12, 3, f12^4*f40 ], [ 13, 3, > f13^2*f41 ], [ 14, 3, f14^30*f42 ], [ 15, 3, f15*f16*f43 ], [ 16, 3, > f16*f44 ], [ 17, 3, f17^4*f45 ], [ 18, 3, f18^4*f46 ], [ 19, 3, > f19^4*f47 ], [ 20, 3, f20^2*f48 ], [ 21, 3, f21^30*f49 ], [ 22, 3, > f22*f23*f50 ], [ 23, 3, f23*f51 ], [ 24, 3, f24^4*f52 ], [ 25, 3, > f25^4*f53 ], [ 26, 3, f26^4*f54 ], [ 27, 3, f27^2*f55 ], [ 28, 3, > f28^30*f56 ], [ 29, 3, f29*f30*f57 ], [ 30, 3, f30*f58 ], [ 31, 3, > f31^4*f59 ], [ 32, 3, f32^4*f60 ], [ 33, 3, f33^4*f61 ], [ 34, 3, > f6*f34^2 ], [ 35, 3, f7*f35^30 ], [ 36, 3, f8*f36*f37 ], [ 37, 3, > f9*f37 ], [ 38, 3, f10*f38^4 ], [ 39, 3, f11*f39^4 ], [ 40, 3, > f12*f40^4 ], [ 41, 3, f13*f41^2 ], [ 42, 3, f14*f42^30 ], [ 43, 3, > f15*f43*f44 ], [ 44, 3, f16*f44 ], [ 45, 3, f17*f45^4 ], [ 46, 3, > f18*f46^4 ], [ 47, 3, f19*f47^4 ], [ 48, 3, f20*f48^2 ], [ 49, 3, > f21*f49^30 ], [ 50, 3, f22*f50*f51 ], [ 51, 3, f23*f51 ], [ 52, 3, > f24*f52^4 ], [ 53, 3, f25*f53^4 ], [ 54, 3, f26*f54^4 ], [ 55, 3, > f27*f55^2 ], [ 56, 3, f28*f56^30 ], [ 57, 3, f29*f57*f58 ], [ 58, 3, > f30*f58 ], [ 59, 3, f31*f59^4 ], [ 60, 3, f32*f60^4 ], [ 61, 3, > f33*f61^4 ], [ 6, 4, f6^2*f20 ], [ 7, 4, f7^30*f21 ], [ 8, 4, > f8*f9*f22 ], [ 9, 4, f9*f23 ], [ 10, 4, f10^4*f24 ], [ 11, 4, > f11^4*f25 ], [ 12, 4, f12^4*f26 ], [ 13, 4, f13^2*f27 ], [ 14, 4, > f14^30*f28 ], [ 15, 4, f15*f16*f29 ], [ 16, 4, f16*f30 ], [ 17, 4, > f17^4*f31 ], [ 18, 4, f18^4*f32 ], [ 19, 4, f19^4*f33 ], [ 20, 4, > f6*f20^2 ], [ 21, 4, f7*f21^30 ], [ 22, 4, f8*f22*f23 ], [ 23, 4, > f9*f23 ], [ 24, 4, f10*f24^4 ], [ 25, 4, f11*f25^4 ], [ 26, 4, > f12*f26^4 ], [ 27, 4, f13*f27^2 ], [ 28, 4, f14*f28^30 ], [ 29, 4, > f15*f29*f30 ], [ 30, 4, f16*f30 ], [ 31, 4, f17*f31^4 ], [ 32, 4, > f18*f32^4 ], [ 33, 4, f19*f33^4 ], [ 34, 4, f34^2*f48 ], [ 35, 4, > f35^30*f49 ], [ 36, 4, f36*f37*f50 ], [ 37, 4, f37*f51 ], [ 38, 4, > f38^4*f52 ], [ 39, 4, f39^4*f53 ], [ 40, 4, f40^4*f54 ], [ 41, 4, > f41^2*f55 ], [ 42, 4, f42^30*f56 ], [ 43, 4, f43*f44*f57 ], [ 44, 4, > f44*f58 ], [ 45, 4, f45^4*f59 ], [ 46, 4, f46^4*f60 ], [ 47, 4, > f47^4*f61 ], [ 48, 4, f34*f48^2 ], [ 49, 4, f35*f49^30 ], [ 50, 4, > f36*f50*f51 ], [ 51, 4, f37*f51 ], [ 52, 4, f38*f52^4 ], [ 53, 4, > f39*f53^4 ], [ 54, 4, f40*f54^4 ], [ 55, 4, f41*f55^2 ], [ 56, 4, > f42*f56^30 ], [ 57, 4, f43*f57*f58 ], [ 58, 4, f44*f58 ], [ 59, 4, > f45*f59^4 ], [ 60, 4, f46*f60^4 ], [ 61, 4, f47*f61^4 ], [ 6, 5, > f6^2*f13 ], [ 7, 5, f7^30*f14 ], [ 8, 5, f8*f9*f15 ], [ 9, 5, f9*f16 > ], [ 10, 5, f10^4*f17 ], [ 11, 5, f11^4*f18 ], [ 12, 5, f12^4*f19 ], > [ 13, 5, f6*f13^2 ], [ 14, 5, f7*f14^30 ], [ 15, 5, f8*f15*f16 ], [ > 16, 5, f9*f16 ], [ 17, 5, f10*f17^4 ], [ 18, 5, f11*f18^4 ], [ 19, > 5, f12*f19^4 ], [ 20, 5, f20^2*f27 ], [ 21, 5, f21^30*f28 ], [ 22, > 5, f22*f23*f29 ], [ 23, 5, f23*f30 ], [ 24, 5, f24^4*f31 ], [ 25, 5, > f25^4*f32 ], [ 26, 5, f26^4*f33 ], [ 27, 5, f20*f27^2 ], [ 28, 5, > f21*f28^30 ], [ 29, 5, f22*f29*f30 ], [ 30, 5, f23*f30 ], [ 31, 5, > f24*f31^4 ], [ 32, 5, f25*f32^4 ], [ 33, 5, f26*f33^4 ], [ 34, 5, > f34^2*f41 ], [ 35, 5, f35^30*f42 ], [ 36, 5, f36*f37*f43 ], [ 37, 5, > f37*f44 ], [ 38, 5, f38^4*f45 ], [ 39, 5, f39^4*f46 ], [ 40, 5, > f40^4*f47 ], [ 41, 5, f34*f41^2 ], [ 42, 5, f35*f42^30 ], [ 43, 5, > f36*f43*f44 ], [ 44, 5, f37*f44 ], [ 45, 5, f38*f45^4 ], [ 46, 5, > f39*f46^4 ], [ 47, 5, f40*f47^4 ], [ 48, 5, f48^2*f55 ], [ 49, 5, > f49^30*f56 ], [ 50, 5, f50*f51*f57 ], [ 51, 5, f51*f58 ], [ 52, 5, > f52^4*f59 ], [ 53, 5, f53^4*f60 ], [ 54, 5, f54^4*f61 ], [ 55, 5, > f48*f55^2 ], [ 56, 5, f49*f56^30 ], [ 57, 5, f50*f57*f58 ], [ 58, 5, > f51*f58 ], [ 59, 5, f52*f59^4 ], [ 60, 5, f53*f60^4 ], [ 61, 5, > f54*f61^4 ], [ 7, 6, f7^4 ], [ 10, 6, f11*f12 ], [ 11, 6, > f11^4*f12^3 ], [ 12, 6, f11^3*f12^3 ], [ 10, 7, f11^4*f12^3 ], [ 11, > 7, f10^4*f11^4*f12^2 ], [ 12, 7, f10^2*f11^4*f12^4 ], [ 10, 8, f10 > ], [ 11, 8, f11 ], [ 12, 8, f12 ], [ 10, 9, f10^3 ], [ 11, 9, f11^3 > ], [ 12, 9, f12^3 ], [ 14, 13, f14^4 ], [ 17, 13, f18*f19 ], [ 18, > 13, f18^4*f19^3 ], [ 19, 13, f18^3*f19^3 ], [ 17, 14, f18^4*f19^3 ], > [ 18, 14, f17^4*f18^4*f19^2 ], [ 19, 14, f17^2*f18^4*f19^4 ], [ 17, > 15, f17 ], [ 18, 15, f18 ], [ 19, 15, f19 ], [ 17, 16, f17^3 ], [ > 18, 16, f18^3 ], [ 19, 16, f19^3 ], [ 21, 20, f21^4 ], [ 24, 20, > f25*f26 ], [ 25, 20, f25^4*f26^3 ], [ 26, 20, f25^3*f26^3 ], [ 24, > 21, f25^4*f26^3 ], [ 25, 21, f24^4*f25^4*f26^2 ], [ 26, 21, > f24^2*f25^4*f26^4 ], [ 24, 22, f24 ], [ 25, 22, f25 ], [ 26, 22, f26 > ], [ 24, 23, f24^3 ], [ 25, 23, f25^3 ], [ 26, 23, f26^3 ], [ 28, > 27, f28^4 ], [ 31, 27, f32*f33 ], [ 32, 27, f32^4*f33^3 ], [ 33, 27, > f32^3*f33^3 ], [ 31, 28, f32^4*f33^3 ], [ 32, 28, f31^4*f32^4*f33^2 > ], [ 33, 28, f31^2*f32^4*f33^4 ], [ 31, 29, f31 ], [ 32, 29, f32 ], > [ 33, 29, f33 ], [ 31, 30, f31^3 ], [ 32, 30, f32^3 ], [ 33, 30, > f33^3 ], [ 35, 34, f35^4 ], [ 38, 34, f39*f40 ], [ 39, 34, > f39^4*f40^3 ], [ 40, 34, f39^3*f40^3 ], [ 38, 35, f39^4*f40^3 ], [ > 39, 35, f38^4*f39^4*f40^2 ], [ 40, 35, f38^2*f39^4*f40^4 ], [ 38, > 36, f38 ], [ 39, 36, f39 ], [ 40, 36, f40 ], [ 38, 37, f38^3 ], [ > 39, 37, f39^3 ], [ 40, 37, f40^3 ], [ 42, 41, f42^4 ], [ 45, 41, > f46*f47 ], [ 46, 41, f46^4*f47^3 ], [ 47, 41, f46^3*f47^3 ], [ 45, > 42, f46^4*f47^3 ], [ 46, 42, f45^4*f46^4*f47^2 ], [ 47, 42, > f45^2*f46^4*f47^4 ], [ 45, 43, f45 ], [ 46, 43, f46 ], [ 47, 43, f47 > ], [ 45, 44, f45^3 ], [ 46, 44, f46^3 ], [ 47, 44, f47^3 ], [ 49, > 48, f49^4 ], [ 52, 48, f53*f54 ], [ 53, 48, f53^4*f54^3 ], [ 54, 48, > f53^3*f54^3 ], [ 52, 49, f53^4*f54^3 ], [ 53, 49, f52^4*f53^4*f54^2 > ], [ 54, 49, f52^2*f53^4*f54^4 ], [ 52, 50, f52 ], [ 53, 50, f53 ], > [ 54, 50, f54 ], [ 52, 51, f52^3 ], [ 53, 51, f53^3 ], [ 54, 51, > f54^3 ], [ 56, 55, f56^4 ], [ 59, 55, f60*f61 ], [ 60, 55, > f60^4*f61^3 ], [ 61, 55, f60^3*f61^3 ], [ 59, 56, f60^4*f61^3 ], [ > 60, 56, f59^4*f60^4*f61^2 ], [ 61, 56, f59^2*f60^4*f61^4 ], [ 59, > 57, f59 ], [ 60, 57, f60 ], [ 61, 57, f61 ], [ 59, 58, f59^3 ], [ > 60, 58, f60^3 ], [ 61, 58, f61^3 ], ];; # construct a new single collector gap> rws := SingleCollector( g, [ 3, 7, 2, 2, 2, 3, 31, 2, 2, 5, 5, 5, 3, > 31, 2, 2, 5, 5, 5, 3, 31, 2, 2, 5, 5, 5, 3, 31, 2, 2, 5, 5, 5, 3, 31, > 2, 2, 5, 5, 5, 3, 31, 2, 2, 5, 5, 5, 3, 31, 2, 2, 5, 5, 5, 3, 31, 2, 2, > 5, 5, 5 ] ); <> # set the relators gap> for x in r do > if 2 = Length(x) then > SetPower( rws, x[1], x[2] ); > else > SetCommutator( rws, x[1], x[2], x[3] ); > fi; > od; # reduce the rules and update the collector gap> grp := GroupByRwsNC(rws);; gap> g := GeneratorsOfGroup(grp);; gap> IsConfluent(grp); true # construct the maximal word gap> l := [1..61]*0;; gap> r := RelativeOrders(rws);; gap> w := Product( List( [1..61], x -> g[x]^(r[x]-1) ) );; gap> Print(ExtRepOfObj(w),"\n"); [ 1, 2, 2, 6, 3, 1, 4, 1, 5, 1, 6, 2, 7, 30, 8, 1, 9, 1, 10, 4, 11, 4, 12, 4, 13, 2, 14, 30, 15, 1, 16, 1, 17, 4, 18, 4, 19, 4, 20, 2, 21, 30, 22, 1, 23, 1, 24, 4, 25, 4, 26, 4, 27, 2, 28, 30, 29, 1, 30, 1, 31, 4, 32, 4, 33, 4, 34, 2, 35, 30, 36, 1, 37, 1, 38, 4, 39, 4, 40, 4, 41, 2, 42, 30, 43, 1, 44, 1, 45, 4, 46, 4, 47, 4, 48, 2, 49, 30, 50, 1, 51, 1, 52, 4, 53, 4, 54, 4, 55, 2, 56, 30, 57, 1, 58, 1, 59, 4, 60, 4, 61, 4 ] # start multiplying around with gap> Print(ExtRepOfObj( w * w ),"\n"); [ 1, 1, 2, 2, 6, 1, 7, 5, 9, 1, 10, 3, 11, 3, 13, 1, 14, 5, 16, 1, 17, 3, 18, 3, 20, 1, 21, 5, 23, 1, 24, 3, 25, 3, 27, 1, 28, 5, 30, 1, 31, 3, 32, 3, 34, 1, 35, 5, 37, 1, 38, 3, 39, 3, 41, 1, 42, 5, 44, 1, 45, 3, 46, 3, 48, 1, 49, 5, 51, 1, 52, 3, 53, 3, 55, 1, 56, 5, 58, 1, 59, 3, 60, 3 ] gap> Print(ExtRepOfObj( w^-1 ),"\n"); [ 1, 1, 2, 2, 3, 1, 4, 1, 5, 1, 6, 1, 7, 5, 8, 1, 10, 4, 11, 4, 12, 2, 13, 1, 14, 5, 15, 1, 17, 4, 18, 4, 19, 2, 20, 1, 21, 5, 22, 1, 24, 4, 25, 4, 26, 2, 27, 1, 28, 5, 29, 1, 31, 4, 32, 4, 33, 2, 34, 1, 35, 5, 36, 1, 38, 4, 39, 4, 40, 2, 41, 1, 42, 5, 43, 1, 45, 4, 46, 4, 47, 2, 48, 1, 49, 5, 50, 1, 52, 4, 53, 4, 54, 2, 55, 1, 56, 5, 57, 1, 59, 4, 60, 4, 61, 2 ] gap> Print(ExtRepOfObj( w^1000 ),"\n"); [ 1, 2, 2, 6, 6, 2, 7, 30, 10, 3, 11, 3, 12, 4, 13, 2, 14, 30, 17, 3, 18, 3, 19, 4, 20, 2, 21, 30, 24, 3, 25, 3, 26, 4, 27, 2, 28, 30, 31, 3, 32, 3, 33, 4, 34, 2, 35, 30, 38, 3, 39, 3, 40, 4, 41, 2, 42, 30, 45, 3, 46, 3, 47, 4, 48, 2, 49, 30, 52, 3, 53, 3, 54, 4, 55, 2, 56, 30, 59, 3, 60, 3, 61, 4 ] gap> l := GeneratorsOfGroup(grp);; gap> p := One(grp);; gap> for i in l do > p := p * w * i; > od; gap> Print(ExtRepOfObj(p),"\n"); [ 4, 1, 5, 1, 6, 2, 7, 5, 8, 1, 9, 1, 11, 2, 12, 2, 14, 22, 17, 3, 18, 4, 20, 2, 21, 4, 22, 1, 24, 1, 26, 4, 28, 26, 31, 2, 32, 3, 33, 3, 34, 2, 35, 24, 36, 1, 38, 1, 39, 3, 42, 30, 43, 1, 44, 1, 45, 3, 46, 3, 47, 1, 48, 2, 50, 1, 51, 1, 52, 3, 54, 2, 55, 1, 56, 26, 57, 1, 59, 4, 60, 2 ] gap> l := GeneratorsOfGroup(grp);; gap> p := One(grp);; gap> for i in l do > p := p * w * i * w; > od; gap> Print(ExtRepOfObj(p),"\n"); [ 1, 2, 4, 1, 6, 2, 7, 3, 8, 1, 10, 1, 11, 2, 12, 3, 13, 1, 14, 21, 17, 4, 18, 4, 19, 1, 20, 2, 21, 30, 22, 1, 24, 2, 26, 1, 27, 1, 28, 5, 29, 1, 31, 4, 33, 2, 34, 2, 35, 19, 36, 1, 38, 1, 39, 2, 41, 1, 42, 5, 44, 1, 45, 3, 48, 2, 49, 6, 50, 1, 52, 3, 53, 1, 54, 4, 55, 2, 56, 19, 57, 1, 59, 2, 60, 2, 61, 1 ] gap> Print(ExtRepOfObj( Comm( w, w ) ),"\n"); [ ] gap> a := w * w * w;; gap> Print(ExtRepOfObj(a),"\n"); [ 3, 1, 4, 1, 5, 1, 8, 1, 12, 1, 15, 1, 19, 1, 22, 1, 26, 1, 29, 1, 33, 1, 36, 1, 40, 1, 43, 1, 47, 1, 50, 1, 54, 1, 57, 1, 61, 1 ] gap> a := a * a;; gap> Print(ExtRepOfObj(a),"\n"); [ 9, 1, 12, 3, 16, 1, 19, 3, 23, 1, 26, 3, 30, 1, 33, 3, 37, 1, 40, 3, 44, 1, 47, 3, 51, 1, 54, 3, 58, 1, 61, 3 ] gap> a := a * a;; gap> Print(ExtRepOfObj(a),"\n"); [ ] gap> Print(ExtRepOfObj( LeftQuotient( w*w, w ) ),"\n"); [ 1, 1, 2, 2, 3, 1, 4, 1, 5, 1, 6, 1, 7, 5, 8, 1, 10, 4, 11, 4, 12, 2, 13, 1, 14, 5, 15, 1, 17, 4, 18, 4, 19, 2, 20, 1, 21, 5, 22, 1, 24, 4, 25, 4, 26, 2, 27, 1, 28, 5, 29, 1, 31, 4, 32, 4, 33, 2, 34, 1, 35, 5, 36, 1, 38, 4, 39, 4, 40, 2, 41, 1, 42, 5, 43, 1, 45, 4, 46, 4, 47, 2, 48, 1, 49, 5, 50, 1, 52, 4, 53, 4, 54, 2, 55, 1, 56, 5, 57, 1, 59, 4, 60, 4, 61, 2 ] gap> Print(ExtRepOfObj( w^-1 ),"\n"); [ 1, 1, 2, 2, 3, 1, 4, 1, 5, 1, 6, 1, 7, 5, 8, 1, 10, 4, 11, 4, 12, 2, 13, 1, 14, 5, 15, 1, 17, 4, 18, 4, 19, 2, 20, 1, 21, 5, 22, 1, 24, 4, 25, 4, 26, 2, 27, 1, 28, 5, 29, 1, 31, 4, 32, 4, 33, 2, 34, 1, 35, 5, 36, 1, 38, 4, 39, 4, 40, 2, 41, 1, 42, 5, 43, 1, 45, 4, 46, 4, 47, 2, 48, 1, 49, 5, 50, 1, 52, 4, 53, 4, 54, 2, 55, 1, 56, 5, 57, 1, 59, 4, 60, 4, 61, 2 ] gap> Print(ExtRepOfObj( w^0 ),"\n"); [ ] gap> Print(ExtRepOfObj( w^1 ),"\n"); [ 1, 2, 2, 6, 3, 1, 4, 1, 5, 1, 6, 2, 7, 30, 8, 1, 9, 1, 10, 4, 11, 4, 12, 4, 13, 2, 14, 30, 15, 1, 16, 1, 17, 4, 18, 4, 19, 4, 20, 2, 21, 30, 22, 1, 23, 1, 24, 4, 25, 4, 26, 4, 27, 2, 28, 30, 29, 1, 30, 1, 31, 4, 32, 4, 33, 4, 34, 2, 35, 30, 36, 1, 37, 1, 38, 4, 39, 4, 40, 4, 41, 2, 42, 30, 43, 1, 44, 1, 45, 4, 46, 4, 47, 4, 48, 2, 49, 30, 50, 1, 51, 1, 52, 4, 53, 4, 54, 4, 55, 2, 56, 30, 57, 1, 58, 1, 59, 4, 60, 4, 61, 4 ] gap> Print(ExtRepOfObj( w^2 ),"\n"); [ 1, 1, 2, 2, 6, 1, 7, 5, 9, 1, 10, 3, 11, 3, 13, 1, 14, 5, 16, 1, 17, 3, 18, 3, 20, 1, 21, 5, 23, 1, 24, 3, 25, 3, 27, 1, 28, 5, 30, 1, 31, 3, 32, 3, 34, 1, 35, 5, 37, 1, 38, 3, 39, 3, 41, 1, 42, 5, 44, 1, 45, 3, 46, 3, 48, 1, 49, 5, 51, 1, 52, 3, 53, 3, 55, 1, 56, 5, 58, 1, 59, 3, 60, 3 ] gap> Print(ExtRepOfObj( w^3 ),"\n"); [ 3, 1, 4, 1, 5, 1, 8, 1, 12, 1, 15, 1, 19, 1, 22, 1, 26, 1, 29, 1, 33, 1, 36, 1, 40, 1, 43, 1, 47, 1, 50, 1, 54, 1, 57, 1, 61, 1 ] gap> Print(ExtRepOfObj( w^4 ),"\n"); [ 1, 2, 2, 6, 6, 2, 7, 30, 10, 3, 11, 3, 12, 4, 13, 2, 14, 30, 17, 3, 18, 3, 19, 4, 20, 2, 21, 30, 24, 3, 25, 3, 26, 4, 27, 2, 28, 30, 31, 3, 32, 3, 33, 4, 34, 2, 35, 30, 38, 3, 39, 3, 40, 4, 41, 2, 42, 30, 45, 3, 46, 3, 47, 4, 48, 2, 49, 30, 52, 3, 53, 3, 54, 4, 55, 2, 56, 30, 59, 3, 60, 3, 61, 4 ] gap> Print(ExtRepOfObj( w^5 ),"\n"); [ 1, 1, 2, 2, 3, 1, 4, 1, 5, 1, 6, 1, 7, 5, 8, 1, 9, 1, 10, 1, 11, 1, 12, 1, 13, 1, 14, 5, 15, 1, 16, 1, 17, 1, 18, 1, 19, 1, 20, 1, 21, 5, 22, 1, 23, 1, 24, 1, 25, 1, 26, 1, 27, 1, 28, 5, 29, 1, 30, 1, 31, 1, 32, 1, 33, 1, 34, 1, 35, 5, 36, 1, 37, 1, 38, 1, 39, 1, 40, 1, 41, 1, 42, 5, 43, 1, 44, 1, 45, 1, 46, 1, 47, 1, 48, 1, 49, 5, 50, 1, 51, 1, 52, 1, 53, 1, 54, 1, 55, 1, 56, 5, 57, 1, 58, 1, 59, 1, 60, 1, 61, 1 ] gap> Print(ExtRepOfObj( Comm( w, w ) ),"\n"); [ ] gap> Print(ExtRepOfObj( Comm( w, l[1] ) ),"\n"); [ 2, 6, 3, 1, 4, 1 ] gap> Print(ExtRepOfObj( LeftQuotient( w, w ) ) ,"\n"); [ ] gap> Print(ExtRepOfObj( LeftQuotient( w, l[1] ) ),"\n"); [ 1, 2, 2, 4, 3, 1, 5, 1, 6, 1, 7, 5, 8, 1, 10, 4, 11, 4, 12, 2, 13, 1, 14, 5, 15, 1, 17, 4, 18, 4, 19, 2, 20, 1, 21, 5, 22, 1, 24, 4, 25, 4, 26, 2, 27, 1, 28, 5, 29, 1, 31, 4, 32, 4, 33, 2, 34, 1, 35, 5, 36, 1, 38, 4, 39, 4, 40, 2, 41, 1, 42, 5, 43, 1, 45, 4, 46, 4, 47, 2, 48, 1, 49, 5, 50, 1, 52, 4, 53, 4, 54, 2, 55, 1, 56, 5, 57, 1, 59, 4, 60, 4, 61, 2 ] gap> Print(ExtRepOfObj( One(grp) ),"\n"); [ ] gap> Print(ExtRepOfObj( w / w ),"\n"); [ ] gap> Print(ExtRepOfObj( w / l[1] ),"\n"); [ 1, 1, 2, 3, 3, 1, 4, 1, 6, 2, 7, 30, 8, 1, 9, 1, 10, 4, 11, 4, 12, 4, 13, 2, 14, 30, 15, 1, 16, 1, 17, 4, 18, 4, 19, 4, 20, 2, 21, 30, 22, 1, 23, 1, 24, 4, 25, 4, 26, 4, 27, 2, 28, 30, 29, 1, 30, 1, 31, 4, 32, 4, 33, 4, 34, 2, 35, 30, 36, 1, 37, 1, 38, 4, 39, 4, 40, 4, 41, 2, 42, 30, 43, 1, 44, 1, 45, 4, 46, 4, 47, 4, 48, 2, 49, 30, 50, 1, 51, 1, 52, 4, 53, 4, 54, 4, 55, 2, 56, 30, 57, 1, 58, 1, 59, 4, 60, 4, 61, 4 ] ############################################################################# # create a free group, 32 bits gap> f := FreeGroup(IsSyllableWordsFamily,1200);; gap> g := GeneratorsOfGroup(f){[1..61]};; # use 'fn' as abbreviation of 'g[n]' gap> f1 := g[1];; gap> f2 := g[2];; gap> f3 := g[3];; gap> f4 := g[4];; gap> f5 := g[5];; gap> f6 := g[6];; gap> f7 := g[7];; gap> f8 := g[8];; gap> f9 := g[9];; gap> f10 := g[10];; gap> f11 := g[11];; gap> f12 := g[12];; gap> f13 := g[13];; gap> f14 := g[14];; gap> f15 := g[15];; gap> f16 := g[16];; gap> f17 := g[17];; gap> f18 := g[18];; gap> f19 := g[19];; gap> f20 := g[20];; gap> f21 := g[21];; gap> f22 := g[22];; gap> f23 := g[23];; gap> f24 := g[24];; gap> f25 := g[25];; gap> f26 := g[26];; gap> f27 := g[27];; gap> f28 := g[28];; gap> f29 := g[29];; gap> f30 := g[30];; gap> f31 := g[31];; gap> f32 := g[32];; gap> f33 := g[33];; gap> f34 := g[34];; gap> f35 := g[35];; gap> f36 := g[36];; gap> f37 := g[37];; gap> f38 := g[38];; gap> f39 := g[39];; gap> f40 := g[40];; gap> f41 := g[41];; gap> f42 := g[42];; gap> f43 := g[43];; gap> f44 := g[44];; gap> f45 := g[45];; gap> f46 := g[46];; gap> f47 := g[47];; gap> f48 := g[48];; gap> f49 := g[49];; gap> f50 := g[50];; gap> f51 := g[51];; gap> f52 := g[52];; gap> f53 := g[53];; gap> f54 := g[54];; gap> f55 := g[55];; gap> f56 := g[56];; gap> f57 := g[57];; gap> f58 := g[58];; gap> f59 := g[59];; gap> f60 := g[60];; gap> f61 := g[61];; # store the relators in gap> r := [ > # power relators > [ 8, f9 ], [ 15, f16 ], [ 22, f23 ], [ 29, f30 ], [ 36, f37 ], [ 43, > f44 ], [ 50, f51 ], [ 57, f58 ], > # commutator relators > [ 2, 1, f2 ], [ 4, 1, f5 ], [ 5, 1, f4*f5 ], [ 13, 1, f13^2*f20 ], [ > 14, 1, f14^30*f21 ], [ 15, 1, f15*f16*f22 ], [ 16, 1, f16*f23 ], [ > 17, 1, f17^4*f24 ], [ 18, 1, f18^4*f25 ], [ 19, 1, f19^4*f26 ], [ > 20, 1, f20^2*f27 ], [ 21, 1, f21^30*f28 ], [ 22, 1, f22*f23*f29 ], [ > 23, 1, f23*f30 ], [ 24, 1, f24^4*f31 ], [ 25, 1, f25^4*f32 ], [ 26, > 1, f26^4*f33 ], [ 27, 1, f13*f27^2 ], [ 28, 1, f14*f28^30 ], [ 29, > 1, f15*f29*f30 ], [ 30, 1, f16*f30 ], [ 31, 1, f17*f31^4 ], [ 32, 1, > f18*f32^4 ], [ 33, 1, f19*f33^4 ], [ 41, 1, f41^2*f48 ], [ 42, 1, > f42^30*f49 ], [ 43, 1, f43*f44*f50 ], [ 44, 1, f44*f51 ], [ 45, 1, > f45^4*f52 ], [ 46, 1, f46^4*f53 ], [ 47, 1, f47^4*f54 ], [ 48, 1, > f48^2*f55 ], [ 49, 1, f49^30*f56 ], [ 50, 1, f50*f51*f57 ], [ 51, 1, > f51*f58 ], [ 52, 1, f52^4*f59 ], [ 53, 1, f53^4*f60 ], [ 54, 1, > f54^4*f61 ], [ 55, 1, f41*f55^2 ], [ 56, 1, f42*f56^30 ], [ 57, 1, > f43*f57*f58 ], [ 58, 1, f44*f58 ], [ 59, 1, f45*f59^4 ], [ 60, 1, > f46*f60^4 ], [ 61, 1, f47*f61^4 ], [ 3, 2, f3*f5 ], [ 4, 2, f3*f4*f5 > ], [ 5, 2, f4*f5 ], [ 13, 2, f13^2*f20 ], [ 14, 2, f14^30*f21 ], [ > 15, 2, f15*f16*f22 ], [ 16, 2, f16*f23 ], [ 17, 2, f17^4*f24 ], [ > 18, 2, f18^4*f25 ], [ 19, 2, f19^4*f26 ], [ 20, 2, f20^2*f41 ], [ > 21, 2, f21^30*f42 ], [ 22, 2, f22*f23*f43 ], [ 23, 2, f23*f44 ], [ > 24, 2, f24^4*f45 ], [ 25, 2, f25^4*f46 ], [ 26, 2, f26^4*f47 ], [ > 27, 2, f27^2*f55 ], [ 28, 2, f28^30*f56 ], [ 29, 2, f29*f30*f57 ], [ > 30, 2, f30*f58 ], [ 31, 2, f31^4*f59 ], [ 32, 2, f32^4*f60 ], [ 33, > 2, f33^4*f61 ], [ 34, 2, f13*f34^2 ], [ 35, 2, f14*f35^30 ], [ 36, > 2, f15*f36*f37 ], [ 37, 2, f16*f37 ], [ 38, 2, f17*f38^4 ], [ 39, 2, > f18*f39^4 ], [ 40, 2, f19*f40^4 ], [ 41, 2, f27*f41^2 ], [ 42, 2, > f28*f42^30 ], [ 43, 2, f29*f43*f44 ], [ 44, 2, f30*f44 ], [ 45, 2, > f31*f45^4 ], [ 46, 2, f32*f46^4 ], [ 47, 2, f33*f47^4 ], [ 48, 2, > f34*f48^2 ], [ 49, 2, f35*f49^30 ], [ 50, 2, f36*f50*f51 ], [ 51, 2, > f37*f51 ], [ 52, 2, f38*f52^4 ], [ 53, 2, f39*f53^4 ], [ 54, 2, > f40*f54^4 ], [ 55, 2, f48*f55^2 ], [ 56, 2, f49*f56^30 ], [ 57, 2, > f50*f57*f58 ], [ 58, 2, f51*f58 ], [ 59, 2, f52*f59^4 ], [ 60, 2, > f53*f60^4 ], [ 61, 2, f54*f61^4 ], [ 6, 3, f6^2*f34 ], [ 7, 3, > f7^30*f35 ], [ 8, 3, f8*f9*f36 ], [ 9, 3, f9*f37 ], [ 10, 3, > f10^4*f38 ], [ 11, 3, f11^4*f39 ], [ 12, 3, f12^4*f40 ], [ 13, 3, > f13^2*f41 ], [ 14, 3, f14^30*f42 ], [ 15, 3, f15*f16*f43 ], [ 16, 3, > f16*f44 ], [ 17, 3, f17^4*f45 ], [ 18, 3, f18^4*f46 ], [ 19, 3, > f19^4*f47 ], [ 20, 3, f20^2*f48 ], [ 21, 3, f21^30*f49 ], [ 22, 3, > f22*f23*f50 ], [ 23, 3, f23*f51 ], [ 24, 3, f24^4*f52 ], [ 25, 3, > f25^4*f53 ], [ 26, 3, f26^4*f54 ], [ 27, 3, f27^2*f55 ], [ 28, 3, > f28^30*f56 ], [ 29, 3, f29*f30*f57 ], [ 30, 3, f30*f58 ], [ 31, 3, > f31^4*f59 ], [ 32, 3, f32^4*f60 ], [ 33, 3, f33^4*f61 ], [ 34, 3, > f6*f34^2 ], [ 35, 3, f7*f35^30 ], [ 36, 3, f8*f36*f37 ], [ 37, 3, > f9*f37 ], [ 38, 3, f10*f38^4 ], [ 39, 3, f11*f39^4 ], [ 40, 3, > f12*f40^4 ], [ 41, 3, f13*f41^2 ], [ 42, 3, f14*f42^30 ], [ 43, 3, > f15*f43*f44 ], [ 44, 3, f16*f44 ], [ 45, 3, f17*f45^4 ], [ 46, 3, > f18*f46^4 ], [ 47, 3, f19*f47^4 ], [ 48, 3, f20*f48^2 ], [ 49, 3, > f21*f49^30 ], [ 50, 3, f22*f50*f51 ], [ 51, 3, f23*f51 ], [ 52, 3, > f24*f52^4 ], [ 53, 3, f25*f53^4 ], [ 54, 3, f26*f54^4 ], [ 55, 3, > f27*f55^2 ], [ 56, 3, f28*f56^30 ], [ 57, 3, f29*f57*f58 ], [ 58, 3, > f30*f58 ], [ 59, 3, f31*f59^4 ], [ 60, 3, f32*f60^4 ], [ 61, 3, > f33*f61^4 ], [ 6, 4, f6^2*f20 ], [ 7, 4, f7^30*f21 ], [ 8, 4, > f8*f9*f22 ], [ 9, 4, f9*f23 ], [ 10, 4, f10^4*f24 ], [ 11, 4, > f11^4*f25 ], [ 12, 4, f12^4*f26 ], [ 13, 4, f13^2*f27 ], [ 14, 4, > f14^30*f28 ], [ 15, 4, f15*f16*f29 ], [ 16, 4, f16*f30 ], [ 17, 4, > f17^4*f31 ], [ 18, 4, f18^4*f32 ], [ 19, 4, f19^4*f33 ], [ 20, 4, > f6*f20^2 ], [ 21, 4, f7*f21^30 ], [ 22, 4, f8*f22*f23 ], [ 23, 4, > f9*f23 ], [ 24, 4, f10*f24^4 ], [ 25, 4, f11*f25^4 ], [ 26, 4, > f12*f26^4 ], [ 27, 4, f13*f27^2 ], [ 28, 4, f14*f28^30 ], [ 29, 4, > f15*f29*f30 ], [ 30, 4, f16*f30 ], [ 31, 4, f17*f31^4 ], [ 32, 4, > f18*f32^4 ], [ 33, 4, f19*f33^4 ], [ 34, 4, f34^2*f48 ], [ 35, 4, > f35^30*f49 ], [ 36, 4, f36*f37*f50 ], [ 37, 4, f37*f51 ], [ 38, 4, > f38^4*f52 ], [ 39, 4, f39^4*f53 ], [ 40, 4, f40^4*f54 ], [ 41, 4, > f41^2*f55 ], [ 42, 4, f42^30*f56 ], [ 43, 4, f43*f44*f57 ], [ 44, 4, > f44*f58 ], [ 45, 4, f45^4*f59 ], [ 46, 4, f46^4*f60 ], [ 47, 4, > f47^4*f61 ], [ 48, 4, f34*f48^2 ], [ 49, 4, f35*f49^30 ], [ 50, 4, > f36*f50*f51 ], [ 51, 4, f37*f51 ], [ 52, 4, f38*f52^4 ], [ 53, 4, > f39*f53^4 ], [ 54, 4, f40*f54^4 ], [ 55, 4, f41*f55^2 ], [ 56, 4, > f42*f56^30 ], [ 57, 4, f43*f57*f58 ], [ 58, 4, f44*f58 ], [ 59, 4, > f45*f59^4 ], [ 60, 4, f46*f60^4 ], [ 61, 4, f47*f61^4 ], [ 6, 5, > f6^2*f13 ], [ 7, 5, f7^30*f14 ], [ 8, 5, f8*f9*f15 ], [ 9, 5, f9*f16 > ], [ 10, 5, f10^4*f17 ], [ 11, 5, f11^4*f18 ], [ 12, 5, f12^4*f19 ], > [ 13, 5, f6*f13^2 ], [ 14, 5, f7*f14^30 ], [ 15, 5, f8*f15*f16 ], [ > 16, 5, f9*f16 ], [ 17, 5, f10*f17^4 ], [ 18, 5, f11*f18^4 ], [ 19, > 5, f12*f19^4 ], [ 20, 5, f20^2*f27 ], [ 21, 5, f21^30*f28 ], [ 22, > 5, f22*f23*f29 ], [ 23, 5, f23*f30 ], [ 24, 5, f24^4*f31 ], [ 25, 5, > f25^4*f32 ], [ 26, 5, f26^4*f33 ], [ 27, 5, f20*f27^2 ], [ 28, 5, > f21*f28^30 ], [ 29, 5, f22*f29*f30 ], [ 30, 5, f23*f30 ], [ 31, 5, > f24*f31^4 ], [ 32, 5, f25*f32^4 ], [ 33, 5, f26*f33^4 ], [ 34, 5, > f34^2*f41 ], [ 35, 5, f35^30*f42 ], [ 36, 5, f36*f37*f43 ], [ 37, 5, > f37*f44 ], [ 38, 5, f38^4*f45 ], [ 39, 5, f39^4*f46 ], [ 40, 5, > f40^4*f47 ], [ 41, 5, f34*f41^2 ], [ 42, 5, f35*f42^30 ], [ 43, 5, > f36*f43*f44 ], [ 44, 5, f37*f44 ], [ 45, 5, f38*f45^4 ], [ 46, 5, > f39*f46^4 ], [ 47, 5, f40*f47^4 ], [ 48, 5, f48^2*f55 ], [ 49, 5, > f49^30*f56 ], [ 50, 5, f50*f51*f57 ], [ 51, 5, f51*f58 ], [ 52, 5, > f52^4*f59 ], [ 53, 5, f53^4*f60 ], [ 54, 5, f54^4*f61 ], [ 55, 5, > f48*f55^2 ], [ 56, 5, f49*f56^30 ], [ 57, 5, f50*f57*f58 ], [ 58, 5, > f51*f58 ], [ 59, 5, f52*f59^4 ], [ 60, 5, f53*f60^4 ], [ 61, 5, > f54*f61^4 ], [ 7, 6, f7^4 ], [ 10, 6, f11*f12 ], [ 11, 6, > f11^4*f12^3 ], [ 12, 6, f11^3*f12^3 ], [ 10, 7, f11^4*f12^3 ], [ 11, > 7, f10^4*f11^4*f12^2 ], [ 12, 7, f10^2*f11^4*f12^4 ], [ 10, 8, f10 > ], [ 11, 8, f11 ], [ 12, 8, f12 ], [ 10, 9, f10^3 ], [ 11, 9, f11^3 > ], [ 12, 9, f12^3 ], [ 14, 13, f14^4 ], [ 17, 13, f18*f19 ], [ 18, > 13, f18^4*f19^3 ], [ 19, 13, f18^3*f19^3 ], [ 17, 14, f18^4*f19^3 ], > [ 18, 14, f17^4*f18^4*f19^2 ], [ 19, 14, f17^2*f18^4*f19^4 ], [ 17, > 15, f17 ], [ 18, 15, f18 ], [ 19, 15, f19 ], [ 17, 16, f17^3 ], [ > 18, 16, f18^3 ], [ 19, 16, f19^3 ], [ 21, 20, f21^4 ], [ 24, 20, > f25*f26 ], [ 25, 20, f25^4*f26^3 ], [ 26, 20, f25^3*f26^3 ], [ 24, > 21, f25^4*f26^3 ], [ 25, 21, f24^4*f25^4*f26^2 ], [ 26, 21, > f24^2*f25^4*f26^4 ], [ 24, 22, f24 ], [ 25, 22, f25 ], [ 26, 22, f26 > ], [ 24, 23, f24^3 ], [ 25, 23, f25^3 ], [ 26, 23, f26^3 ], [ 28, > 27, f28^4 ], [ 31, 27, f32*f33 ], [ 32, 27, f32^4*f33^3 ], [ 33, 27, > f32^3*f33^3 ], [ 31, 28, f32^4*f33^3 ], [ 32, 28, f31^4*f32^4*f33^2 > ], [ 33, 28, f31^2*f32^4*f33^4 ], [ 31, 29, f31 ], [ 32, 29, f32 ], > [ 33, 29, f33 ], [ 31, 30, f31^3 ], [ 32, 30, f32^3 ], [ 33, 30, > f33^3 ], [ 35, 34, f35^4 ], [ 38, 34, f39*f40 ], [ 39, 34, > f39^4*f40^3 ], [ 40, 34, f39^3*f40^3 ], [ 38, 35, f39^4*f40^3 ], [ > 39, 35, f38^4*f39^4*f40^2 ], [ 40, 35, f38^2*f39^4*f40^4 ], [ 38, > 36, f38 ], [ 39, 36, f39 ], [ 40, 36, f40 ], [ 38, 37, f38^3 ], [ > 39, 37, f39^3 ], [ 40, 37, f40^3 ], [ 42, 41, f42^4 ], [ 45, 41, > f46*f47 ], [ 46, 41, f46^4*f47^3 ], [ 47, 41, f46^3*f47^3 ], [ 45, > 42, f46^4*f47^3 ], [ 46, 42, f45^4*f46^4*f47^2 ], [ 47, 42, > f45^2*f46^4*f47^4 ], [ 45, 43, f45 ], [ 46, 43, f46 ], [ 47, 43, f47 > ], [ 45, 44, f45^3 ], [ 46, 44, f46^3 ], [ 47, 44, f47^3 ], [ 49, > 48, f49^4 ], [ 52, 48, f53*f54 ], [ 53, 48, f53^4*f54^3 ], [ 54, 48, > f53^3*f54^3 ], [ 52, 49, f53^4*f54^3 ], [ 53, 49, f52^4*f53^4*f54^2 > ], [ 54, 49, f52^2*f53^4*f54^4 ], [ 52, 50, f52 ], [ 53, 50, f53 ], > [ 54, 50, f54 ], [ 52, 51, f52^3 ], [ 53, 51, f53^3 ], [ 54, 51, > f54^3 ], [ 56, 55, f56^4 ], [ 59, 55, f60*f61 ], [ 60, 55, > f60^4*f61^3 ], [ 61, 55, f60^3*f61^3 ], [ 59, 56, f60^4*f61^3 ], [ > 60, 56, f59^4*f60^4*f61^2 ], [ 61, 56, f59^2*f60^4*f61^4 ], [ 59, > 57, f59 ], [ 60, 57, f60 ], [ 61, 57, f61 ], [ 59, 58, f59^3 ], [ > 60, 58, f60^3 ], [ 61, 58, f61^3 ], ];; # construct a new single collector gap> rws := SingleCollector( g, [ 3, 7, 2, 2, 2, 3, 31, 2, 2, 5, 5, 5, 3, > 31, 2, 2, 5, 5, 5, 3, 31, 2, 2, 5, 5, 5, 3, 31, 2, 2, 5, 5, 5, 3, 31, > 2, 2, 5, 5, 5, 3, 31, 2, 2, 5, 5, 5, 3, 31, 2, 2, 5, 5, 5, 3, 31, 2, 2, > 5, 5, 5 ] ); <> # set the relators gap> for x in r do > if 2 = Length(x) then > SetPower( rws, x[1], x[2] ); > else > SetCommutator( rws, x[1], x[2], x[3] ); > fi; > od; # reduce the rules and update the collector gap> grp := GroupByRwsNC(rws);; gap> g := GeneratorsOfGroup(grp);; gap> IsConfluent(grp); true # construct the maximal word gap> l := [1..61]*0;; gap> r := RelativeOrders(rws);; gap> w := Product( List( [1..61], x -> g[x]^(r[x]-1) ) );; gap> Print(ExtRepOfObj(w),"\n"); [ 1, 2, 2, 6, 3, 1, 4, 1, 5, 1, 6, 2, 7, 30, 8, 1, 9, 1, 10, 4, 11, 4, 12, 4, 13, 2, 14, 30, 15, 1, 16, 1, 17, 4, 18, 4, 19, 4, 20, 2, 21, 30, 22, 1, 23, 1, 24, 4, 25, 4, 26, 4, 27, 2, 28, 30, 29, 1, 30, 1, 31, 4, 32, 4, 33, 4, 34, 2, 35, 30, 36, 1, 37, 1, 38, 4, 39, 4, 40, 4, 41, 2, 42, 30, 43, 1, 44, 1, 45, 4, 46, 4, 47, 4, 48, 2, 49, 30, 50, 1, 51, 1, 52, 4, 53, 4, 54, 4, 55, 2, 56, 30, 57, 1, 58, 1, 59, 4, 60, 4, 61, 4 ] # start multiplying around with gap> Print(ExtRepOfObj( w * w ),"\n"); [ 1, 1, 2, 2, 6, 1, 7, 5, 9, 1, 10, 3, 11, 3, 13, 1, 14, 5, 16, 1, 17, 3, 18, 3, 20, 1, 21, 5, 23, 1, 24, 3, 25, 3, 27, 1, 28, 5, 30, 1, 31, 3, 32, 3, 34, 1, 35, 5, 37, 1, 38, 3, 39, 3, 41, 1, 42, 5, 44, 1, 45, 3, 46, 3, 48, 1, 49, 5, 51, 1, 52, 3, 53, 3, 55, 1, 56, 5, 58, 1, 59, 3, 60, 3 ] gap> Print(ExtRepOfObj( w^-1 ),"\n"); [ 1, 1, 2, 2, 3, 1, 4, 1, 5, 1, 6, 1, 7, 5, 8, 1, 10, 4, 11, 4, 12, 2, 13, 1, 14, 5, 15, 1, 17, 4, 18, 4, 19, 2, 20, 1, 21, 5, 22, 1, 24, 4, 25, 4, 26, 2, 27, 1, 28, 5, 29, 1, 31, 4, 32, 4, 33, 2, 34, 1, 35, 5, 36, 1, 38, 4, 39, 4, 40, 2, 41, 1, 42, 5, 43, 1, 45, 4, 46, 4, 47, 2, 48, 1, 49, 5, 50, 1, 52, 4, 53, 4, 54, 2, 55, 1, 56, 5, 57, 1, 59, 4, 60, 4, 61, 2 ] gap> Print(ExtRepOfObj( w^1000 ),"\n"); [ 1, 2, 2, 6, 6, 2, 7, 30, 10, 3, 11, 3, 12, 4, 13, 2, 14, 30, 17, 3, 18, 3, 19, 4, 20, 2, 21, 30, 24, 3, 25, 3, 26, 4, 27, 2, 28, 30, 31, 3, 32, 3, 33, 4, 34, 2, 35, 30, 38, 3, 39, 3, 40, 4, 41, 2, 42, 30, 45, 3, 46, 3, 47, 4, 48, 2, 49, 30, 52, 3, 53, 3, 54, 4, 55, 2, 56, 30, 59, 3, 60, 3, 61, 4 ] gap> l := GeneratorsOfGroup(grp);; gap> p := One(grp);; gap> for i in l do > p := p * w * i; > od; gap> Print(ExtRepOfObj(p),"\n"); [ 4, 1, 5, 1, 6, 2, 7, 5, 8, 1, 9, 1, 11, 2, 12, 2, 14, 22, 17, 3, 18, 4, 20, 2, 21, 4, 22, 1, 24, 1, 26, 4, 28, 26, 31, 2, 32, 3, 33, 3, 34, 2, 35, 24, 36, 1, 38, 1, 39, 3, 42, 30, 43, 1, 44, 1, 45, 3, 46, 3, 47, 1, 48, 2, 50, 1, 51, 1, 52, 3, 54, 2, 55, 1, 56, 26, 57, 1, 59, 4, 60, 2 ] gap> l := GeneratorsOfGroup(grp);; gap> p := One(grp);; gap> for i in l do > p := p * w * i * w; > od; gap> Print(ExtRepOfObj(p),"\n"); [ 1, 2, 4, 1, 6, 2, 7, 3, 8, 1, 10, 1, 11, 2, 12, 3, 13, 1, 14, 21, 17, 4, 18, 4, 19, 1, 20, 2, 21, 30, 22, 1, 24, 2, 26, 1, 27, 1, 28, 5, 29, 1, 31, 4, 33, 2, 34, 2, 35, 19, 36, 1, 38, 1, 39, 2, 41, 1, 42, 5, 44, 1, 45, 3, 48, 2, 49, 6, 50, 1, 52, 3, 53, 1, 54, 4, 55, 2, 56, 19, 57, 1, 59, 2, 60, 2, 61, 1 ] gap> Print(ExtRepOfObj( Comm( w, w ) ),"\n"); [ ] gap> a := w * w * w;; gap> Print(ExtRepOfObj(a),"\n"); [ 3, 1, 4, 1, 5, 1, 8, 1, 12, 1, 15, 1, 19, 1, 22, 1, 26, 1, 29, 1, 33, 1, 36, 1, 40, 1, 43, 1, 47, 1, 50, 1, 54, 1, 57, 1, 61, 1 ] gap> a := a * a;; gap> Print(ExtRepOfObj(a),"\n"); [ 9, 1, 12, 3, 16, 1, 19, 3, 23, 1, 26, 3, 30, 1, 33, 3, 37, 1, 40, 3, 44, 1, 47, 3, 51, 1, 54, 3, 58, 1, 61, 3 ] gap> a := a * a;; gap> Print(ExtRepOfObj(a),"\n"); [ ] gap> Print(ExtRepOfObj( LeftQuotient( w*w, w ) ),"\n"); [ 1, 1, 2, 2, 3, 1, 4, 1, 5, 1, 6, 1, 7, 5, 8, 1, 10, 4, 11, 4, 12, 2, 13, 1, 14, 5, 15, 1, 17, 4, 18, 4, 19, 2, 20, 1, 21, 5, 22, 1, 24, 4, 25, 4, 26, 2, 27, 1, 28, 5, 29, 1, 31, 4, 32, 4, 33, 2, 34, 1, 35, 5, 36, 1, 38, 4, 39, 4, 40, 2, 41, 1, 42, 5, 43, 1, 45, 4, 46, 4, 47, 2, 48, 1, 49, 5, 50, 1, 52, 4, 53, 4, 54, 2, 55, 1, 56, 5, 57, 1, 59, 4, 60, 4, 61, 2 ] gap> Print(ExtRepOfObj( w^-1 ),"\n"); [ 1, 1, 2, 2, 3, 1, 4, 1, 5, 1, 6, 1, 7, 5, 8, 1, 10, 4, 11, 4, 12, 2, 13, 1, 14, 5, 15, 1, 17, 4, 18, 4, 19, 2, 20, 1, 21, 5, 22, 1, 24, 4, 25, 4, 26, 2, 27, 1, 28, 5, 29, 1, 31, 4, 32, 4, 33, 2, 34, 1, 35, 5, 36, 1, 38, 4, 39, 4, 40, 2, 41, 1, 42, 5, 43, 1, 45, 4, 46, 4, 47, 2, 48, 1, 49, 5, 50, 1, 52, 4, 53, 4, 54, 2, 55, 1, 56, 5, 57, 1, 59, 4, 60, 4, 61, 2 ] gap> Print(ExtRepOfObj( w^0 ),"\n"); [ ] gap> Print(ExtRepOfObj( w^1 ),"\n"); [ 1, 2, 2, 6, 3, 1, 4, 1, 5, 1, 6, 2, 7, 30, 8, 1, 9, 1, 10, 4, 11, 4, 12, 4, 13, 2, 14, 30, 15, 1, 16, 1, 17, 4, 18, 4, 19, 4, 20, 2, 21, 30, 22, 1, 23, 1, 24, 4, 25, 4, 26, 4, 27, 2, 28, 30, 29, 1, 30, 1, 31, 4, 32, 4, 33, 4, 34, 2, 35, 30, 36, 1, 37, 1, 38, 4, 39, 4, 40, 4, 41, 2, 42, 30, 43, 1, 44, 1, 45, 4, 46, 4, 47, 4, 48, 2, 49, 30, 50, 1, 51, 1, 52, 4, 53, 4, 54, 4, 55, 2, 56, 30, 57, 1, 58, 1, 59, 4, 60, 4, 61, 4 ] gap> Print(ExtRepOfObj( w^2 ),"\n"); [ 1, 1, 2, 2, 6, 1, 7, 5, 9, 1, 10, 3, 11, 3, 13, 1, 14, 5, 16, 1, 17, 3, 18, 3, 20, 1, 21, 5, 23, 1, 24, 3, 25, 3, 27, 1, 28, 5, 30, 1, 31, 3, 32, 3, 34, 1, 35, 5, 37, 1, 38, 3, 39, 3, 41, 1, 42, 5, 44, 1, 45, 3, 46, 3, 48, 1, 49, 5, 51, 1, 52, 3, 53, 3, 55, 1, 56, 5, 58, 1, 59, 3, 60, 3 ] gap> Print(ExtRepOfObj( w^3 ),"\n"); [ 3, 1, 4, 1, 5, 1, 8, 1, 12, 1, 15, 1, 19, 1, 22, 1, 26, 1, 29, 1, 33, 1, 36, 1, 40, 1, 43, 1, 47, 1, 50, 1, 54, 1, 57, 1, 61, 1 ] gap> Print(ExtRepOfObj( w^4 ),"\n"); [ 1, 2, 2, 6, 6, 2, 7, 30, 10, 3, 11, 3, 12, 4, 13, 2, 14, 30, 17, 3, 18, 3, 19, 4, 20, 2, 21, 30, 24, 3, 25, 3, 26, 4, 27, 2, 28, 30, 31, 3, 32, 3, 33, 4, 34, 2, 35, 30, 38, 3, 39, 3, 40, 4, 41, 2, 42, 30, 45, 3, 46, 3, 47, 4, 48, 2, 49, 30, 52, 3, 53, 3, 54, 4, 55, 2, 56, 30, 59, 3, 60, 3, 61, 4 ] gap> Print(ExtRepOfObj( w^5 ),"\n"); [ 1, 1, 2, 2, 3, 1, 4, 1, 5, 1, 6, 1, 7, 5, 8, 1, 9, 1, 10, 1, 11, 1, 12, 1, 13, 1, 14, 5, 15, 1, 16, 1, 17, 1, 18, 1, 19, 1, 20, 1, 21, 5, 22, 1, 23, 1, 24, 1, 25, 1, 26, 1, 27, 1, 28, 5, 29, 1, 30, 1, 31, 1, 32, 1, 33, 1, 34, 1, 35, 5, 36, 1, 37, 1, 38, 1, 39, 1, 40, 1, 41, 1, 42, 5, 43, 1, 44, 1, 45, 1, 46, 1, 47, 1, 48, 1, 49, 5, 50, 1, 51, 1, 52, 1, 53, 1, 54, 1, 55, 1, 56, 5, 57, 1, 58, 1, 59, 1, 60, 1, 61, 1 ] gap> Print(ExtRepOfObj( Comm( w, w ) ),"\n"); [ ] gap> Print(ExtRepOfObj( Comm( w, l[1] ) ),"\n"); [ 2, 6, 3, 1, 4, 1 ] gap> Print(ExtRepOfObj( LeftQuotient( w, w ) ) ,"\n"); [ ] gap> Print(ExtRepOfObj( LeftQuotient( w, l[1] ) ),"\n"); [ 1, 2, 2, 4, 3, 1, 5, 1, 6, 1, 7, 5, 8, 1, 10, 4, 11, 4, 12, 2, 13, 1, 14, 5, 15, 1, 17, 4, 18, 4, 19, 2, 20, 1, 21, 5, 22, 1, 24, 4, 25, 4, 26, 2, 27, 1, 28, 5, 29, 1, 31, 4, 32, 4, 33, 2, 34, 1, 35, 5, 36, 1, 38, 4, 39, 4, 40, 2, 41, 1, 42, 5, 43, 1, 45, 4, 46, 4, 47, 2, 48, 1, 49, 5, 50, 1, 52, 4, 53, 4, 54, 2, 55, 1, 56, 5, 57, 1, 59, 4, 60, 4, 61, 2 ] gap> Print(ExtRepOfObj( One(grp) ),"\n"); [ ] gap> Print(ExtRepOfObj( w / w ),"\n"); [ ] gap> Print(ExtRepOfObj( w / l[1] ),"\n"); [ 1, 1, 2, 3, 3, 1, 4, 1, 6, 2, 7, 30, 8, 1, 9, 1, 10, 4, 11, 4, 12, 4, 13, 2, 14, 30, 15, 1, 16, 1, 17, 4, 18, 4, 19, 4, 20, 2, 21, 30, 22, 1, 23, 1, 24, 4, 25, 4, 26, 4, 27, 2, 28, 30, 29, 1, 30, 1, 31, 4, 32, 4, 33, 4, 34, 2, 35, 30, 36, 1, 37, 1, 38, 4, 39, 4, 40, 4, 41, 2, 42, 30, 43, 1, 44, 1, 45, 4, 46, 4, 47, 4, 48, 2, 49, 30, 50, 1, 51, 1, 52, 4, 53, 4, 54, 4, 55, 2, 56, 30, 57, 1, 58, 1, 59, 4, 60, 4, 61, 4 ] ############################################################################# gap> STOP_TEST( "rwspcgrp.tst", 59400000 ); ############################################################################# ## #E gap-4r6p5/tst/primsan.tst0000644000175000017500000000245712172557256014174 0ustar billbill############################################################################# ## #W primsan.tst GAP library Steve Linton ## ## #Y Copyright (C) 1999, School of Computer Science, St Andrews ## ## sanity test for primitive groups library -- takes 30-40 minutes on ## a PIII/500, and need 400MB of RAM ## ## Exclude from testinstall.g until the typical developer's desktop ## is big and fast enough. ## gap> START_TEST("primsan.tst"); # # Disable warnings which depend on Conway Polynomial databases # gap> iW := InfoLevel(InfoWarning);; gap> SetInfoLevel(InfoWarning,0); ############################################################################# ## ## Define a function to check the primitive groups of degree n and ## loop over a range of n ## gap> checkdegree := function(n) > local g; > for g in AllPrimitiveGroups(DegreeOperation,n) do > if MovedPoints(g) <> [1..n] or not IsTransitive(g,[1..n]) > or not IsPrimitive(g,[1..n]) then > Error("Failure at ",g," degree ",n,"\n"); > fi; > od; > end;; gap> for n in [2..999] do > checkdegree(n); > od; gap> SetInfoLevel(InfoWarning,iW); gap> STOP_TEST( "primsan.tst", 125486700000 ); ############################################################################# ## #E gap-4r6p5/tst/morpheus.tst0000644000175000017500000000356112172557256014362 0ustar billbill############################################################################# ## #W morpheus.tst GAP tests Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## This file tests the automorphism routines ## ## To be listed in testinstall.g ## gap> START_TEST("morpheus.tst"); gap> g:=Group((1,2,3,4),(1,3));; gap> LoadPackage("autpgrp", false);; gap> a:=AutomorphismGroup(g);; gap> inn:=InnerAutomorphismsAutomorphismGroup(a);; gap> iso1:=IsomorphismGroups(a,g);; gap> iso1=fail; false gap> iso2:=IsomorphismGroups(g,a);; gap> iso2=fail; false gap> iso3:=iso2*iso1;; gap> if not iso3 in inn then iso3:=iso3*iso3;fi; gap> r:=RepresentativeAction(g,GeneratorsOfGroup(g), > List(GeneratorsOfGroup(g),i->Image(iso3,i)),OnTuples);; gap> r=fail; false gap> iso4:=iso3*InnerAutomorphism(g,r^-1);; gap> iso4=IdentityMapping(g); true gap> g:=TransitiveGroup(6,7);; gap> IsSolvableGroup(g); true gap> Size(AutomorphismGroup(g)); 24 gap> g:=Group((1,2,3),(1,2));; gap> g:=Image(IsomorphismPcGroup(DirectProduct(g,g,g,g)));; gap> Size(g); 1296 gap> Size(AutomorphismGroup(g))/Size(g); 24 gap> g:=Group((1,2,3),(4,5,6),(7,8),(9,10),(11,12,13,14,15)); Group([ (1,2,3), (4,5,6), (7,8), (9,10), (11,12,13,14,15) ]) gap> a:=AutomorphismGroup(g);; gap> Size(a); 1152 gap> Size(DerivedSubgroup(a)); 72 gap> p:=IsomorphismPcGroup(a);; gap> Image(p,a.1);; gap> Image(p,a.1*a.2);; gap> Pcgs(a);; gap> s4 := Group( (3,4), (1,2,3,4) );; gap> d8 := Subgroup( s4, [ (1,2)(3,4), (1,2,3,4) ] );; gap> autd8 := AutomorphismGroup( d8 );; gap> Size(autd8); 8 gap> DisplayCompositionSeries(AutomorphismGroup(SymmetricGroup(3))); G (size 6) | Z(2) S (1 gens, size 3) | Z(3) 1 (size 1) # that's all, folks gap> STOP_TEST( "morpheus.tst", 87200000 ); ############################################################################# ## #E gap-4r6p5/tst/ctbl.tst0000644000175000017500000000343212172557256013441 0ustar billbill############################################################################# ## #W ctbl.tst GAP Library Thomas Breuer ## ## #Y Copyright (C) 1998, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## Exclude from testinstall.g: why? ## gap> START_TEST("ctbl.tst"); # `ClassPositionsOf...' for the trivial group (which usually causes trouble) gap> g:= TrivialGroup( IsPermGroup );; gap> t:= CharacterTable( g );; gap> ClassPositionsOfAgemo( t, 2 ); [ 1 ] gap> ClassPositionsOfCentre( t ); [ 1 ] gap> ClassPositionsOfDerivedSubgroup( t ); [ 1 ] gap> ClassPositionsOfDirectProductDecompositions( t ); [ ] gap> ClassPositionsOfElementaryAbelianSeries( t ); [ [ 1 ] ] gap> ClassPositionsOfFittingSubgroup( t ); [ 1 ] gap> ClassPositionsOfLowerCentralSeries( t ); [ [ 1 ] ] gap> ClassPositionsOfMaximalNormalSubgroups( t ); [ ] gap> ClassPositionsOfNormalClosure( t, [ 1 ] ); [ 1 ] gap> ClassPositionsOfNormalSubgroups( t ); [ [ 1 ] ] gap> ClassPositionsOfUpperCentralSeries( t ); [ [ 1 ] ] gap> ClassPositionsOfSolvableResiduum( t ); [ 1 ] gap> ClassPositionsOfSupersolvableResiduum( t ); [ 1 ] gap> ClassPositionsOfCentre( TrivialCharacter( t ) ); [ 1 ] gap> ClassPositionsOfKernel( TrivialCharacter( t ) ); [ 1 ] gap> LoadPackage("ctbllib", "1", false);; # `CharacterTableDirectProduct' in all four combinations. gap> t1:= CharacterTable( "Cyclic", 2 ); CharacterTable( "C2" ) gap> t2:= CharacterTable( "Cyclic", 3 ); CharacterTable( "C3" ) gap> t1 * t1; CharacterTable( "C2xC2" ) gap> ( t1 mod 2 ) * ( t1 mod 2 ); BrauerTable( "C2xC2", 2 ) gap> ( t1 mod 2 ) * t2; BrauerTable( "C2xC3", 2 ) gap> t2 * ( t1 mod 2 ); BrauerTable( "C3xC2", 2 ) gap> STOP_TEST( "ctbl.tst", 14300000 ); ############################################################################# ## #E gap-4r6p5/tst/semirel.tst0000644000175000017500000000767512172557256014172 0ustar billbill############################################################################# ## #W semirel.tst GAP library Robert F. Morse ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## To be listed in testinstall.g ## gap> START_TEST("semirel.tst"); ## ## Three non-commutative finite semigroups ## gap> f := FreeSemigroup(2);; gap> a := GeneratorsOfSemigroup(f)[1];; b := GeneratorsOfSemigroup(f)[2];; gap> rels := [[a^2,a],[b^2,b],[(a*b)^10,a*b],[(b*a)^10,b*a]];; gap> s1 := f/rels;; Size(s1); 38 gap> t1 := Range(IsomorphismTransformationSemigroup(s1));; gap> Size(t1); 38 gap> f := FreeSemigroup(2);; gap> a := GeneratorsOfSemigroup(f)[1];; b := GeneratorsOfSemigroup(f)[2];; gap> rels := [[a^5,a],[b^5,b],[(a*b)^5,a*b],[(b*a)^5,b*a],[a*b^2,a*b],[a^2*b,a*b]];; gap> s2 := f/rels;; gap> t2 := Range(IsomorphismTransformationSemigroup(s2));; gap> Size(t2); 108 gap> f := FreeSemigroup(2);; gap> a := GeneratorsOfSemigroup(f)[1];; b := GeneratorsOfSemigroup(f)[2];; gap> rels := [[a^4,a],[b^4,b],[(a*b)^2,a^2*b^2],[(b*a)^2,b^2*a^2]];; gap> s3 := f/rels;; gap> t3 := Range(IsomorphismTransformationSemigroup(s3));; gap> Size(t3); 294 ## ## A commutative finite semigroup ## gap> f := FreeSemigroup(2);; gap> a := GeneratorsOfSemigroup(f)[1];; b := GeneratorsOfSemigroup(f)[2];; gap> rels := [[a*b,b*a],[a^4,a],[b^4,b],[(a*b)^2,a^2*b^2],[(b*a)^2,b^2*a^2]];; gap> sc := f/rels;; gap> t4 := Range(IsomorphismTransformationSemigroup(sc));; gap> Size(t4); 15 ## ## Full transformation semigroup of elements of 3, 4, and 5 ## gap> t3 := FullTransformationSemigroup(3);; gap> t4 := FullTransformationSemigroup(4);; gap> t5 := FullTransformationSemigroup(5);; ## ## Size is known no computation required ## gap> t20 := FullTransformationSemigroup(20);; gap> Size(t20); 104857600000000000000000000 ## ## Green's relations ## gap> grp := EquivalenceRelationPartition(GreensRRelation(s1));; gap> grp1 := EquivalenceRelationPartition(GreensRRelation(t1));; gap> Set(List(grp,i->Size(i))) = Set(List(grp1,i->Size(i))); true gap> glp := EquivalenceRelationPartition(GreensLRelation(s1));; gap> glp1 := EquivalenceRelationPartition(GreensLRelation(t1));; gap> Set(List(glp,i->Size(i))) = Set(List(glp1,i->Size(i))); true gap> gjp := EquivalenceRelationPartition(GreensJRelation(s1));; gap> gjp1 := EquivalenceRelationPartition(GreensJRelation(t1));; gap> Set(List(gjp,i->Size(i))) = Set(List(gjp1,i->Size(i))); true ## ## See that Green's classes for full transformation semigroups ## are of the proper form ## gap> ForAll(GreensRClasses(t3), > i->ForAll(AsSSortedList(i),j->KernelOfTransformation(j) > = KernelOfTransformation(Representative(i)))); true gap> ForAll(GreensLClasses(t3), > i->ForAll(AsSSortedList(i),j->ImageSetOfTransformation(j) > = ImageSetOfTransformation(Representative(i)))); true gap> ForAll(GreensJClasses(t3), > i->ForAll(AsSSortedList(i),j->RankOfTransformation(j) > = RankOfTransformation(Representative(i)))); true gap> ForAll(GreensHClasses(t3), > i->ForAll(AsSSortedList(i),j->ImageSetOfTransformation(j) > = ImageSetOfTransformation(Representative(i)) > and KernelOfTransformation(j) = KernelOfTransformation(Representative(i)) > )); true gap> ForAll(GreensRClasses(t4), > i->ForAll(AsSSortedList(i),j->KernelOfTransformation(j) > = KernelOfTransformation(Representative(i)))); true gap> ForAll(GreensLClasses(t4), > i->ForAll(AsSSortedList(i),j->ImageSetOfTransformation(j) > = ImageSetOfTransformation(Representative(i)))); true gap> ForAll(GreensJClasses(t4), > i->ForAll(AsSSortedList(i),j->RankOfTransformation(j) > = RankOfTransformation(Representative(i)))); true gap> ForAll(GreensHClasses(t4), > i->ForAll(AsSSortedList(i),j->ImageSetOfTransformation(j) > = ImageSetOfTransformation(Representative(i)) > and KernelOfTransformation(j) = KernelOfTransformation(Representative(i)) > )); true gap> STOP_TEST( "semirel.tst", 10900000 ); ############################################################################# ## #E gap-4r6p5/tst/ctblfuns.tst0000644000175000017500000000222512172557256014334 0ustar billbill############################################################################# ## #W ctblfuns.tst GAP Library Thomas Breuer ## ## #Y Copyright (C) 1998, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## To be listed in testinstall.g ## gap> START_TEST("ctblfuns.tst"); gap> S4:= SymmetricGroup( 4 ); Sym( [ 1 .. 4 ] ) gap> V4:= Group( (1,2)(3,4), (1,3)(2,4) ); Group([ (1,2)(3,4), (1,3)(2,4) ]) gap> irr:= Irr( V4 ); [ Character( CharacterTable( Group([ (1,2)(3,4), (1,3)(2,4) ]) ), [ 1, 1, 1, 1 ] ), Character( CharacterTable( Group( [ (1,2)(3,4), (1,3)(2,4) ]) ), [ 1, -1, -1, 1 ] ), Character( CharacterTable( Group([ (1,2)(3,4), (1,3)(2,4) ]) ), [ 1, -1, 1, -1 ] ), Character( CharacterTable( Group( [ (1,2)(3,4), (1,3)(2,4) ]) ), [ 1, 1, -1, -1 ] ) ] gap> List( irr, x -> InertiaSubgroup( S4, x ) ); [ Sym( [ 1 .. 4 ] ), Group([ (1,4), (1,4)(2,3), (1,3)(2,4) ]), Group([ (1,4,3,2), (1,4)(2,3) ]), Group([ (3,4), (1,4)(2,3) ]) ] gap> List( last, Size ); [ 24, 8, 8, 8 ] gap> STOP_TEST( "ctblfuns.tst", 3900000 ); ############################################################################# ## #E gap-4r6p5/tst/bugfix.tst0000644000175000017500000023351712172557256014012 0ustar billbill############################################################################# ## #W bugfix.tst ## ## ## Exclude from testinstall.g: why? ## gap> START_TEST("bugfixes test"); ## Check if ConvertToMatrixRepNC works properly. BH ## gap> mat := [[1,0,1,1],[0,1,1,1]]*One(GF(2)); [ [ Z(2)^0, 0*Z(2), Z(2)^0, Z(2)^0 ], [ 0*Z(2), Z(2)^0, Z(2)^0, Z(2)^0 ] ] gap> ConvertToMatrixRepNC( mat, GF(2) ); 2 gap> DimensionsMat(mat); [ 2, 4 ] gap> mat := [[1,0,1,1],[0,1,1,1]]*One(GF(3)); [ [ Z(3)^0, 0*Z(3), Z(3)^0, Z(3)^0 ], [ 0*Z(3), Z(3)^0, Z(3)^0, Z(3)^0 ] ] gap> ConvertToMatrixRepNC( mat, GF(3) ); 3 gap> DimensionsMat(mat); [ 2, 4 ] ## Check that a new SpecialPcgs is created for which ## LGWeights can be set properly ## see my mail of 2011/02/22 to gap-dev for details. BH ## gap> G := PcGroupCode(640919430184532635765016241891519311\ > 98104010779278323886032740084599, 192200);; gap> ind := InducedPcgsByPcSequence(FamilyPcgs (G), > [ G.1*G.2*G.3*G.4^2*G.5^2, G.4^2*G.5^3, G.6, G.7 ]);; gap> H := GroupOfPcgs (ind);; gap> pcgs := SpecialPcgs (H);; gap> syl31 := SylowSystem( H )[3];; gap> w := LGWeights( SpecialPcgs( syl31 ) ); [ [ 1, 1, 31 ], [ 1, 1, 31 ] ] ## Check to see if the strongly connected component (Error 3) fix has been ## installed ## gap> M := Monoid([Transformation( [ 2, 3, 4, 5, 5 ] ), > Transformation( [ 3, 1, 4, 5, 5 ] ), > Transformation( [ 2, 1, 4, 3, 5 ] ) ]);; gap> Size(GreensLClasses(M)[2])=2; true ## Check the fix in OrbitStabilizerAlgorithm (Error 4) for infinite groups. ## gap> N:=GroupByGenerators( > [ [ [ 0, -1, 0, 0 ], [ 1, 0, 0, 0 ], [ 0, 0, 0, -1 ], [ 0, 0, 1, 0 ] ], > [ [ 0, 0, 1, 0 ], [ 0, 0, 0, 1 ], [ -1, 0, 0, 0 ], [ 0, -1, 0, 0 ] ], > [ [ 0, 0, 1, 0 ], [ 0, 0, 0, 1 ], [ -1, 0, 1, 0 ], [ 0, -1, 0, 1 ] ], > [ [ 0, 0, 1, 0 ], [ 0, 0, 0, 1 ], [ -1, 0, 0, -1 ], [ 0, -1, 1, 0 ] ], > [ [ 1, 0, 0, 0 ], [ 0, 1, 0, 0 ], [ 0, 0, 0, -1 ], [ 0, 0, 1, 0 ] ], > [ [ 0, 1, 0, 0 ], [ 1, 0, 0, 0 ], [ 0, 0, 0, 1 ], [ 0, 0, 1, 0 ] ] ] ); gap> IsFinite(N); false gap> G:=GroupByGenerators( [ [ [ 0, -1, 0, 0 ], [ 1, 0, 0, 0 ], > [ 0, 0, 0, -1 ], [ 0, 0, 1, 0 ] ] ] ); Group([ [ [ 0, -1, 0, 0 ], [ 1, 0, 0, 0 ], [ 0, 0, 0, -1 ], [ 0, 0, 1, 0 ] ] ]) gap> Centralizer(N,G); ## iterated autgp (5) gap> g:=Group((1,2,3),(4,5,6),(2,3)(5,6));; gap> aut:=AutomorphismGroup(g);; gap> ccu:=ConjugacyClasses(aut);; gap> aut2:=AutomorphismGroup(aut);; ## field conversion (6) gap> v := [];; gap> ConvertToVectorRep(v,3);; gap> ConvertToVectorRep(v,9);; ## EulerianFunction (10) gap> EulerianFunction( DihedralGroup(8), 2); 24 gap> EulerianFunction( CyclicGroup(6), 1 ); 2 gap> EulerianFunction( CyclicGroup(5), 1 ); 4 gap> g:=SmallGroup(1,1);; gap> ConjugacyClassesSubgroups(g);; gap> g:=Group([ (3,5), (1,3,5) ]);; gap> MaximalSubgroups(g);; ## GQuotients gap> s := SymmetricGroup(4);; gap> g := SmallGroup(48,1);; gap> GQuotients(g,s); [ ] ## Costantini bug, in inverting lists of compressed vectors gap> p := 3;; e := 16;; gap> g := ElementaryAbelianGroup(p^e);; gap> l := PCentralLieAlgebra(g);; gap> b := Basis(l);; gap> b2 := b;; gap> RelativeBasis(b,b2);; ## Testing if an element is in a Green's D equivalence class (fix 2 no. 12) gap> s := Semigroup(Transformation([1,1,3,4]),Transformation([1,2,2,4]));; gap> dc := GreensDClasses(s);; gap> ForAll(dc, c->Transformation([1,1,3,4]) in c); false ## Testing if Green's D classes can be compared for finite semigroups gap> s := Transformation([1,1,3,4,5]);; gap> c := Transformation([2,3,4,5,1]);; gap> op5 := Semigroup(s,c);; gap> dcl := GreensDClasses(op5);; gap> ForAny(Cartesian(dcl,dcl), x->IsGreensLessThanOrEqual(x[1],x[2])); true ## Testing that GroupHClassOfGreensDClass is implemented gap> h := GroupHClassOfGreensDClass(dcl[4]);; ## Testing AssociatedReesMatrixSemigroupOfDClass. ## IsZeroSimpleSemigroup, IsomorphismReesMatrixSemigroup, ## and SandwichMatrixOfReesZeroMatrixSemigroup ## create Greens D classes correctly. gap> rms := AssociatedReesMatrixSemigroupOfDClass(dcl[5]);; gap> s := Transformation([1,1,2]);; gap> c := Transformation([2,3,1]);; gap> op3 := Semigroup(s,c);; gap> IsRegularSemigroup(op3);; gap> dcl := GreensDClasses(op3);; gap> dcl := SortedList(ShallowCopy(dcl));; gap> d2 := dcl[2];; d1:= dcl[1];; gap> i2 := SemigroupIdealByGenerators(op3,[Representative(d2)]);; gap> GeneratorsOfSemigroup(i2);; gap> i1 := SemigroupIdealByGenerators(i2,[Representative(d1)]);; gap> GeneratorsOfSemigroup(i1);; gap> c1 := ReesCongruenceOfSemigroupIdeal(i1);; gap> q := i2/c1;; gap> IsZeroSimpleSemigroup(q);; gap> irms := IsomorphismReesMatrixSemigroup(q);; gap> SandwichMatrixOfReesZeroMatrixSemigroup(Source(irms));; gap> g := Group( (1,2),(1,2,3) );; gap> i := TrivialSubgroup( g );; gap> CentralizerModulo( g, i, (1,2) ); Group([ (1,2) ]) ## bugs 2, 3, 6, 7, 20 for fix 2. gap> x:= Sum( GeneratorsOfAlgebra( QuaternionAlgebra( Rationals, -2, -2 ) ) );; gap> x * Inverse( x ) = One( x ); true gap> LargestMovedPoint(ProjectiveSymplecticGroup(6,2)) = 63; true gap> t1:= CharacterTable( CyclicGroup( 2 ) );; SetIdentifier( t1, "C2" ); gap> t2:= CharacterTable( CyclicGroup( 3 ) );; SetIdentifier( t2, "C3" ); gap> t1 * t1; ( t1 mod 2 ) * ( t1 mod 2 ); CharacterTable( "C2xC2" ) BrauerTable( "C2xC2", 2 ) gap> ( t1 mod 2 ) * t2; t2 * ( t1 mod 2 ); BrauerTable( "C2xC3", 2 ) BrauerTable( "C3xC2", 2 ) gap> t:= CharacterTable( SymmetricGroup( 4 ) );; gap> chi:= TrivialCharacter( t );; gap> IntScalarProducts( t, [ chi ], chi ); true gap> NonnegIntScalarProducts( t, [ chi ], chi ); true gap> Representative( TrivialSubgroup( Group( (1,2) ) ) ); () gap> Representative( TrivialSubspace( GF(2)^2 ) ); [ 0*Z(2), 0*Z(2) ] gap> g:=SmallGroup(70,3);; gap> g:=GroupByPcgs(Pcgs(g));; gap> IdGroup(g); [ 70, 3 ] gap> G := Group(());;F := FreeGroup( 1, "f" );; gap> hom := GroupHomomorphismByImages(F,G,GeneratorsOfGroup(F), > GeneratorsOfGroup(G));; gap> PreImagesRepresentative(hom,()); ## bug 2 for fix 4. gap> 1 * One( Integers mod NextPrimeInt( 2^16 ) ); ZmodpZObj( 1, 65537 ) gap> f:=FreeGroup("a","b");;g:=f/[Comm(f.1,f.2),f.1^5,f.2^7];;Pcgs(g);; gap> n:=Subgroup(g,[g.2]);; m:=ModuloPcgs(g,n);; gap> ExponentsOfPcElement(m,m[1]); [ 1 ] ## bug 11 for fix 4. gap> x:= Indeterminate( Rationals );; gap> f:= x^4 + 3*x^2 + 1;; gap> F:= AlgebraicExtension( Rationals, f );; gap> Basis( F )[1];; # bug in ReducedSCTable: gap> T:= EmptySCTable( 1, 0, "antisymmetric" ); [ [ [ [ ], [ ] ] ], -1, 0 ] gap> ReducedSCTable( T, Z(3)^0 ); [ [ [ [ ], [ ] ] ], -1, 0*Z(3) ] ## Rees Matrix bug fix 4 gap> s := Semigroup(Transformation([2,3,1]));; gap> IsSimpleSemigroup(s);; gap> irms := IsomorphismReesMatrixSemigroup(s);; gap> Size(Source(irms)); 3 ## Semigroup/Monoid rewriting system bug for fix 4 gap> f := FreeSemigroup("a","b");; gap> a := f.1;; b := f.2;; gap> s := f/[[a*b,b],[b*a,a]];; gap> rws := KnuthBendixRewritingSystem(s); Knuth Bendix Rewriting System for Semigroup( [ a, b ] ) with rules [ [ a*b, b ], [ b*a, a ] ] gap> MakeConfluent(rws); gap> rws; Knuth Bendix Rewriting System for Semigroup( [ a, b ] ) with rules [ [ a*b, b ], [ b*a, a ], [ a^2, a ], [ b^2, b ] ] gap> HasReducedConfluentRewritingSystem(s); true gap> x:= Indeterminate( Rationals );; gap> a:= 1/(1+x);; gap> b:= 1/(x+x^2);; gap> a=b; false ## bugs 12 and 14 for fix 4 gap> IsRowVector( [ [ 1 ] ] ); false gap> IsRowModule( TrivialSubmodule( GF(2)^[2,2] ) ); false gap> g:=SL(2,5);;c:=Irr(g)[6];; gap> hom:=IrreducibleRepresentationsDixon(g,c);; gap> Size(Image(hom)); 60 ## bug 16 for fix 4 gap> Difference( [ 1, 1 ], [] ); [ 1 ] ## bug 17 for fix 4 gap> f := FreeGroup( 2 );; gap> g := f/[f.1^4,f.2^4,Comm(f.1,f.2)];; gap> Length(Elements(g)); 16 gap> NrPrimitiveGroups(441); 24 ## bug 2 for fix 5 gap> IsSubset( GF(2)^[2,2], GF(4)^[2,2] ); false gap> G:=Group((8,12)(10,14),(8,10)(12,14),(4,6)(12,14),(2,4)(10,12), > (4,8)(6,10), (9,13)(11,15),(9,11)(13,15),(5,7)(13,15),(3,5)(11,13), > (5,9)(7,11));; gap> x:=Group((1,8)(2,7)(3,6)(4,5)(9,16)(10,15)(11,14)(12,13), > (1,9)(2,10)(3,11)(4,12)(5,13)(6,14)(7,15)(8,16), > (1,4)(2,3)(5,8)(6,7)(9,12)(10,11)(13,16)(14,15), > (1,10)(2,9)(3,12)(4,11)(5,14)(6,13)(7,16)(8,15));; gap> y:=Group((1,8)(2,7)(3,6)(4,5)(9,14)(10,13)(11,16)(12,15), > (1,11)(2,10)(3,9)(4,12)(5,15)(6,14)(7,13)(8,16), > (1,4)(2,3)(5,8)(6,7)(9,10)(11,12)(13,14)(15,16), > (1,10)(2,11)(3,12)(4,9)(5,14)(6,15)(7,16)(8,13));; gap> RepresentativeAction(G,x,y)<>fail; true ## bug 5 for fix 5 gap> BaseOrthogonalSpaceMat( [ [ 1, 0 ] ] ); [ [ 0, 1 ] ] ## bug 7 for fix 5 gap> tbl:= CharacterTable( SL(2,3) );; irr:= Irr( tbl );; gap> lin:= Filtered( LinearCharacters( tbl ), x -> Order(x) = 3 );; gap> deg3:= First( irr, x -> DegreeOfCharacter( x ) = 3 );; gap> MolienSeries( tbl, lin[1] + deg3, lin[2] ); ( 2*z^2+z^3-z^4+z^6 ) / ( (1-z^3)^2*(1-z^2)^2 ) ## bug 8 for fix 5 gap> l:= [ 1, 2 ];; i:= Intersection( [ l ] );; gap> IsIdenticalObj( l, i ); false ## bug 9 for fix 5 gap> A:=FullMatrixLieAlgebra(Rationals,2); gap> B:=LieDerivedSubalgebra(A); gap> D:=Derivations(Basis(B)); ## bug 10 for fix 5 gap> k:=AbelianGroup([5,5,5]); gap> h:=SylowSubgroup(AutomorphismGroup(k),2); gap> g:=SemidirectProduct(h,k); gap> Centre(g); Group([ ]) ## bug 11 for fix 5 gap> m1:=[[0,1],[0,0]];; gap> m2:=[[0,0],[1,0]];; gap> m3:=[[1,0],[0,-1]];; gap> M1:=MatrixByBlockMatrix(BlockMatrix([[1,1,m1]],2,2));; gap> M2:=MatrixByBlockMatrix(BlockMatrix([[1,1,m2]],2,2));; gap> M3:=MatrixByBlockMatrix(BlockMatrix([[1,1,m3]],2,2));; gap> M4:=MatrixByBlockMatrix(BlockMatrix([[2,2,m1]],2,2));; gap> M5:=MatrixByBlockMatrix(BlockMatrix([[2,2,m2]],2,2));; gap> M6:=MatrixByBlockMatrix(BlockMatrix([[2,2,m3]],2,2));; gap> L:=LieAlgebra(Rationals,[M1,M2,M3,M4,M5,M6]); gap> DirectSumDecomposition(L); [ , (dimension 3)>, , (dimension 3)> ] ## bug 16 for fix 5 gap> IrrBaumClausen( Group(()));; ## bug 17 for fix 5 (example taken from `vspcmat.tst') gap> w:= LeftModuleByGenerators( GF(9), > [ [ [ Z(27), Z(3) ], [ Z(3), Z(3) ] ], > [ [ Z(27), Z(3) ], [ Z(3), Z(3) ] ], > [ [ 0*Z(3), Z(3) ], [ Z(3), Z(3) ] ] ] );; gap> w = AsVectorSpace( GF(3), w ); true ## bug 18 for fix 5 gap> List( Irr( AlternatingGroup( 5 ) ), TestMonomial );; ## bug 3 for fix 6 gap> Order( ZmodnZObj( 2, 7 ) );; Inverse( ZmodnZObj( 2, 7 ) );; ## bug 4 for fix 6 gap> tbl:= CharacterTable( SL(2,3) );; irr:= Irr( tbl );; gap> z := Indeterminate( Rationals : old ); x_1 gap> lin := Filtered( LinearCharacters( tbl ), x -> Order(x) = 3 );; gap> deg3 := First( irr, x -> DegreeOfCharacter( x ) = 3 );; gap> ser := MolienSeries( tbl, lin[1] + deg3, lin[2] );; gap> MolienSeriesWithGivenDenominator( ser, [ 6,6,4,4 ] ); ( 2*z^2+z^3+3*z^4+6*z^5+3*z^6+7*z^7+7*z^8+3*z^9+6*z^10+4*z^11+z^12+3*z^13+z^14\ +z^16 ) / ( (1-z^6)^2*(1-z^4)^2 ) ############################################################################# ## ## Fixes for GAP 4.4 ## ## bug 8 for fix 1 gap> q:= QuaternionAlgebra( Rationals );; gap> t:= TrivialSubspace( q );; gap> tt:= Subspace( q, [] );; gap> Intersection2( t, tt );; gap> g:=SmallGroup(6,2);; gap> f:=FreeGroup(3);; gap> f:=f/[f.2*f.3];; gap> q:=GQuotients(f,g);; gap> k:=List(q,Kernel);; gap> k:=Intersection(k);; gap> hom:=IsomorphismFpGroup(TrivialSubgroup(g));; gap> IsFpGroup(Range(hom)); true ## bug 3 for fix 2 gap> Order([[-E(7),0,0,0],[0,-E(7)^6,0,0],[0,0,E(21),0],[0,0,0,E(21)^20]]); 42 gap> Order(-E(7)*IdentityMat(14)); 14 ## bug 5 for fix 2 gap> t:= CharacterTable( SymmetricGroup( 4 ) );; gap> PowerMap( t, -1 );; PowerMap( t, -1, 2 );; gap> m:= t mod 2;; gap> PowerMap( m, -1 );; PowerMap( m, -1, 2 );; ## bug 9 for fix 2 gap> IsSimple(Ree(3)); false ## bug 10 for fix 2 gap> g:= GU(3,4);; g.1 in g; true gap> ForAll( GeneratorsOfGroup( Sp(4,4) ), x -> x in SP(4,2) ); false ## bug 12 for fix 2 gap> IsMatrix( Basis( VectorSpace( GF(2), Basis( GF(2)^2 ) ) ) ); true ## bug 13 for fix 2 gap> -1 in [1..2]; false ## bug 16-18 for fix 4 gap> AbelianInvariantsMultiplier(SL(3,2)); [ 2 ] gap> AllPrimitiveGroups(Size,60,NrMovedPoints,[2..2499]); [ A(5), PSL(2,5), A(5) ] gap> ix18:=X(GF(5),1);;f:=ix18^5-1;; gap> Discriminant(f); 0*Z(5) ## bug 3 for fix 5 gap> One( DirectProduct( Group( [], () ), Group( [], () ) ) );; ## bug 4 for fix 5 gap> emb:= Embedding( DirectProduct( Group( (1,2) ), Group( (1,2) ) ), 1 );; gap> PreImagesRepresentative( emb, (1,2)(3,4) ); fail ## bug 6 for fix 5 gap> v:= VectorSpace( Rationals, [ [ 1 ] ] );; gap> x:= LeftModuleHomomorphismByImages( v, v, Basis( v ), Basis( v ) );; gap> x + 0*x;; ## bug 7 for fix 5 gap> a:= GroupRing( GF(2), Group( (1,2) ) );; gap> 1/3 * a.1;; a.1 * (1/3);; ## bug 10 for fix 5 gap> R:= Integers mod 6;; gap> Size( Ideal( R, [ Zero( R ) ] ) + Ideal( R, [ 2 * One( R ) ] ) ); 3 ## for changes 4.4.4 -> 4.4.5 (extracted from corresponding dev/Update) # For fixes: # 2005/01/06 (TB) gap> One( DirectProduct( Group( [], () ), Group( [], () ) ) );; # 2005/01/06 (TB) gap> emb:= Embedding( DirectProduct( Group( (1,2) ), Group( (1,2) ) ), 1 );; gap> PreImagesRepresentative( emb, (1,2)(3,4) ); fail # 2005/02/21 (TB) gap> v:= VectorSpace( Rationals, [ [ 1 ] ] );; gap> x:= LeftModuleHomomorphismByImages( v, v, Basis( v ), Basis( v ) );; gap> x + 0*x;; # 2005/02/21 (TB) # 2006/03/13 (JJM) - removed this duplicate of 'bug 7 for fix 5' test #gap> a:= GroupRing( GF(2), Group( (1,2) ) );; #gap> 1/3 * a.1;; a.1 * (1/3);; # 2005/02/26 (AH) gap> Random(GF(26831423036065352611));; # 2005/03/05 (AH) gap> x:=X(Rationals);; gap> PowerMod(x,3,x^2); 0 gap> PowerMod(x,1,x); 0 # 2005/03/08 (AH) gap> p:=[0,1]; [ 0, 1 ] gap> UnivariatePolynomial(Rationals,p); x_1 gap> p; [ 0, 1 ] # 2005/03/31 (TB) gap> R:= Integers mod 6;; gap> Size( Ideal( R, [ Zero( R ) ] ) + Ideal( R, [ 2 * One( R ) ] ) ); 3 # 2005/04/12 (FL (includes a fix in dev-version by Burkhard)) ## the less memory GAP has, the earlier the following crashed GAP #out := OutputTextFile("/dev/null",false); #g := SymmetricGroup(1000000); #for i in [1..100] do # Print(i, " \c"); # r := PseudoRandom(g); # PrintTo(out, "Coset representative is ", r, "\n"); #od; # 2005/04/12 (FL) gap> IntHexString(['a','1']); 161 # 2005/04/12 (AH) gap> f:=FreeGroup(IsSyllableWordsFamily,8);; gap> g:=GeneratorsOfGroup(f);; gap> g1:=g[1];; gap> g2:=g[2];; gap> g3:=g[3];; gap> g4:=g[4];; gap> g5:=g[5];; gap> g6:=g[6];; gap> g7:=g[7];; gap> g8:=g[8];; gap> rws:=SingleCollector(f,[ 2, 3, 2, 3, 2, 3, 2, 3 ]);; gap> r:=[ > [1,g4*g6], > [3,g4], > [5,g6*g8^2], > [7,g8], > ];; gap> for x in r do SetPower(rws,x[1],x[2]);od; gap> G:= GroupByRwsNC(rws);; gap> f1:=G.1;; gap> f2:=G.2;; gap> f3:=G.3;; gap> f4:=G.4;; gap> f5:=G.5;; gap> f6:=G.6;; gap> f7:=G.7;; gap> f8:=G.8;; gap> a:=Subgroup(G,[f3*f6*f8^2, f5*f6*f8^2, f7*f8, f4*f6^2*f8 ]);; gap> b:=Subgroup(G,[f2^2*f4^2*f6*f7*f8^2, f2*f4*f6^2*f8^2, f5*f6^2*f8, > f2^2*f6^2*f8, f2*f3*f4, f2^2]);; gap> Size(Intersection(a,b))=Number(a,i->i in b); true # 2005/04/15 (TB) gap> CompareVersionNumbers( "1.0", ">=9.9" ); false # 2005/04/26 (SL) # too complicated to construct # 2005/04/27 (TB) gap> Iterator( Subspaces( VectorSpace( GF(2), [ X( GF(2) ) ] ) ) );; # 2005/04/27 (TB) gap> String( [ [ '1' ] ] ); String( rec( a:= [ '1' ] ) ); "[ \"1\" ]" "rec( a := \"1\" )" # 2005/05/03 (BE) gap> SmallGroupsInformation(512); There are 10494213 groups of order 512. 1 is cyclic. 2 - 10 have rank 2 and p-class 3. 11 - 386 have rank 2 and p-class 4. 387 - 1698 have rank 2 and p-class 5. 1699 - 2008 have rank 2 and p-class 6. 2009 - 2039 have rank 2 and p-class 7. 2040 - 2044 have rank 2 and p-class 8. 2045 has rank 3 and p-class 2. 2046 - 29398 have rank 3 and p-class 3. 29399 - 30617 have rank 3 and p-class 4. 30618 - 31239 have rank 3 and p-class 3. 31240 - 56685 have rank 3 and p-class 4. 56686 - 60615 have rank 3 and p-class 5. 60616 - 60894 have rank 3 and p-class 6. 60895 - 60903 have rank 3 and p-class 7. 60904 - 67612 have rank 4 and p-class 2. 67613 - 387088 have rank 4 and p-class 3. 387089 - 419734 have rank 4 and p-class 4. 419735 - 420500 have rank 4 and p-class 5. 420501 - 420514 have rank 4 and p-class 6. 420515 - 6249623 have rank 5 and p-class 2. 6249624 - 7529606 have rank 5 and p-class 3. 7529607 - 7532374 have rank 5 and p-class 4. 7532375 - 7532392 have rank 5 and p-class 5. 7532393 - 10481221 have rank 6 and p-class 2. 10481222 - 10493038 have rank 6 and p-class 3. 10493039 - 10493061 have rank 6 and p-class 4. 10493062 - 10494173 have rank 7 and p-class 2. 10494174 - 10494200 have rank 7 and p-class 3. 10494201 - 10494212 have rank 8 and p-class 2. 10494213 is elementary abelian. This size belongs to layer 7 of the SmallGroups library. IdSmallGroup is not available for this size. # 2005/05/04 (SL) gap> c := [1,1,0,1]*Z(2); [ Z(2)^0, Z(2)^0, 0*Z(2), Z(2)^0 ] gap> m := [1,1]*Z(2); [ Z(2)^0, Z(2)^0 ] gap> PowerModCoeffs(c, 1, m); [ Z(2)^0 ] gap> ConvertToVectorRep(c, 2); 2 gap> ConvertToVectorRep(m, 2); 2 gap> Print(PowerModCoeffs(c, 1, m), "\n"); [ Z(2)^0 ] # 2005/05/06 (SL) gap> A:=[[Z(2)]];; ConvertToMatrixRep(A,2);; gap> Sort(A); A; # 2005/05/09 (TB) # call: gap -A # gap> SaveWorkspace( "wsp" );; # call: gap -A -L wsp # 2005/05/09 (Colva, FL (for 4R4)) gap> L:=AllPrimitiveGroups(NrMovedPoints,26,Size,[1..2^28-1]); [ PSL(2, 25), PGL(2, 25), PSigmaL(2, 25), PSL(2, 25).2_3, PGammaL(2, 25) ] # For new features: # 2005/04/13 (FL) gap> IsCheapConwayPolynomial(5,96); false # 2005/04/21 (FL) gap> NormalBase( GF(3^6) ); [ Z(3^6)^2, Z(3^6)^6, Z(3^6)^18, Z(3^6)^54, Z(3^6)^162, Z(3^6)^486 ] gap> NormalBase( GF( GF(8), 2 ) ); [ Z(2^6), Z(2^6)^8 ] # 2005/04/26 (SL, FL) gap> AClosestVectorCombinationsMatFFEVecFFECoords; gap> ConstituentsPolynomial; function( p ) ... end # 2005/04/27 (TB) gap> IsBound( CycList ); true # 2005/05/03 (SK) gap> x := Indeterminate(Integers);; gap> ContinuedFractionExpansionOfRoot(x^2-7,20); [ 2, 1, 1, 1, 4, 1, 1, 1, 4, 1, 1, 1, 4, 1, 1, 1, 4, 1, 1, 1 ] gap> ContinuedFractionExpansionOfRoot(x^2-7,0); [ 2, 1, 1, 1, 4 ] gap> ContinuedFractionExpansionOfRoot(x^3-2,20); [ 1, 3, 1, 5, 1, 1, 4, 1, 1, 8, 1, 14, 1, 10, 2, 1, 4, 12, 2, 3 ] gap> ContinuedFractionExpansionOfRoot(x^5-x-1,50); [ 1, 5, 1, 42, 1, 3, 24, 2, 2, 1, 16, 1, 11, 1, 1, 2, 31, 1, 12, 5, 1, 7, 11, 1, 4, 1, 4, 2, 2, 3, 4, 2, 1, 1, 11, 1, 41, 12, 1, 8, 1, 1, 1, 1, 1, 9, 2, 1, 5, 4 ] gap> ContinuedFractionApproximationOfRoot(x^2-2,10); 3363/2378 gap> 3363^2-2*2378^2; 1 gap> z := ContinuedFractionApproximationOfRoot(x^5-x-1,20); 499898783527/428250732317 gap> z^5-z-1; 486192462527432755459620441970617283/ 14404247382319842421697357558805709031116987826242631261357 # 2005/05/03 (SK) gap> l := AllSmallGroups(12);; gap> List(l,StructureDescription);; l; [ C3 : C4, C12, A4, D12, C6 x C2 ] gap> List(AllSmallGroups(40),G->StructureDescription(G:short)); [ "5:8", "40", "5:8", "5:Q8", "4xD10", "D40", "2x(5:4)", "(10x2):2", "20x2", "5xD8", "5xQ8", "2x(5:4)", "2^2xD10", "10x2^2" ] gap> List(AllTransitiveGroups(DegreeAction,6),G->StructureDescription(G:short)); [ "6", "S3", "D12", "A4", "3xS3", "2xA4", "S4", "S4", "S3xS3", "(3^2):4", "2xS4", "A5", "(S3xS3):2", "S5", "A6", "S6" ] gap> StructureDescription(PSL(4,2)); "A8" # 2005/05/03 (BE) gap> NumberSmallGroups(5^6); 684 gap> NumberSmallGroups(5*7*9*11*13); 22 # 2005/05/05 (TB) gap> IsBound( ShowPackageVariables ); true # 2005/05/05 (TB) gap> IsReadableFile( Filename( DirectoriesLibrary( "tst" ), "testutil.g" ) ); true # 2005/05/06 (TB) gap> IsBound( HasMultiplicationTable ); true ############################################################################# ## ## for changes 4.4.5 -> 4.4.6 (extracted from corresponding dev/Update) # For fixes: # 2005/05/17 (AH) gap> IsConjugate(TransitiveGroup(9,19),Group([ (2,8,9,3)(4,6,7,5), > (2,9)(3,8)(4,7)(5 ,6), (1,2,9)(3,4,5)(6,7,8), (1,4,7)(2,5,8)(3,6,9) ]), > Group([ (3,7)(4,8)(5,6), (2,9)(3,8)(4,7)(5,6),(1,7,4)(2,8,5)(3,9,6), > (1,6,5)(2,7,3)(4,9,8) ]));; # 2005/05/18 (TB) gap> t:= Runtime();; gap> CayleyGraphSemigroup( Monoid( Transformation([2,3,4,5,6,1,7]), > Transformation([6,5,4,3,2,1,7]), Transformation([1,2,3,4,6,7,7]) ) );; gap> if Runtime() - t > 5000 then > Print( "#E efficiency problem with enumerators of semigroups!\n" ); > fi; # 2005/06/06 (AH) gap> Irr(SmallGroup(516,11));; # 2005/06/13 (AH) gap> IsSimple(AlternatingGroup(3)); true # 2005/06/17 (SL) gap> l := [1,2,3,4]; [ 1, 2, 3, 4 ] gap> COPY_LIST_ENTRIES(l,2,1,l,3,1,3); gap> l; [ 1, 2, 2, 3, 4 ] # 2005/07/09 (AH) gap> CompositionSeries(PerfectGroup(IsPermGroup,262440,1));; # 2005/07/13 (JS) gap> PerfectGroup(7800,1);; # load perf2.grp gap> PerfectGroup(7680,1);; # should load perf1.grp, gives error in 4.4.5 # 2005/07/13 (JS) gap> NrPerfectLibraryGroups(1); 0 # 2005/07/18 (FL) gap> TypeObj(IMPLICATIONS);; # 2005/07/20 (TB) gap> T:= EmptySCTable( 2, 0 );; gap> SetEntrySCTable( T, 1, 1, [ 1/2, 1, 2/3, 2 ] ); gap> A:= AlgebraByStructureConstants( Rationals, T, "A." );; gap> GeneratorsOfAlgebra( A ); [ A.1, A.2 ] # 2005/07/20 (TB) gap> F:= FreeAssociativeAlgebra( Rationals, 2 );; gap> IsAssociativeElement( F.1 ); true gap> F:= FreeAlgebra( Rationals, 2 );; gap> IsAssociativeElement( F.1 ); false # 2005/07/21 (JS) gap> G:=PerfectGroup(IsPermGroup,734832,1);; gap> H:=PerfectGroup(IsPermGroup,734832,2);; gap> K:=PerfectGroup(IsPermGroup,734832,3);; gap> Assert(0,H<>K); # Fails in 4.4.5 gap> Assert(0,Size(G)=734832 and IsPerfectGroup(G)); # Sanity check gap> Assert(0,Size(H)=734832 and IsPerfectGroup(H)); # Sanity check gap> Assert(0,Size(K)=734832 and IsPerfectGroup(K)); # Sanity check gap> Assert(0,Size(ComplementClassesRepresentatives(G,SylowSubgroup(FittingSubgroup(G),3)))=1); # Iso check gap> Assert(0,Size(ComplementClassesRepresentatives(H,SylowSubgroup(FittingSubgroup(H),3)))=3); # Iso check gap> Assert(0,Size(ComplementClassesRepresentatives(K,SylowSubgroup(FittingSubgroup(K),3)))=0); # Iso check # 2005/08/10 (TB) gap> ApplicableMethod( \in, [ 1, Rationals ] ); function( x, Rationals ) ... end # 2005/08/11 (JS) gap> List([1,2,3],k->IdGroup(SylowSubgroup(PerfectGroup(IsPermGroup,864000,k),2))); [ [ 256, 55700 ], [ 256, 55970 ], [ 256, 56028 ] ] # 2005/08/11 (TB) # gap> fam:= NewFamily( "fam" );; # gap> DeclareGlobalVariable( "TestFam" ); # gap> InstallValue( TestFam, CollectionsFamily( fam ) ); # #I please use `BindGlobal' for the family object CollectionsFamily(...), not \ # `InstallValue' # gap> IsIdenticalObj( TestFam, CollectionsFamily( fam ) ); # false # gap> MakeReadWriteGlobal( "TestFam" ); UnbindGlobal( "TestFam" ); # 2005/08/15 (AH) gap> Centre( MagmaByMultiplicationTable( [ [ 2, 2 ], [ 2, 1 ] ] ) ); [ ] # 2005/08/17 (Max) # Test code is not possible to provide because the error condition # cannot be tested in a platform independent way. # 2005/08/19 (JS) gap> PermutationCycle((1,2,3,4,5,6)^2,[1..6],1); # returns fail in 4.4.5 (1,3,5) # 2005/08/19 (JS) gap> f:=function() Assert(0,false); end;; g:=function() f(); end;; gap> ## The following should just trigger a normal error, but in 4.4.5 gap> ## it will send a few hundred lines before crashing: gap> # g(); # 2005/08/19 (JS) gap> g:= SmallGroup( 48, 30 );; gap> AbelianInvariantsMultiplier( g ); # returned [ 2, 2 ] in 4.4.5 [ 2 ] # 2005/08/19 (SL) gap> Inverse(0*Z(2)); fail gap> Inverse(0*Z(3)); fail # 2005/08/22 (JS+AH) gap> ## The mailing lists contain more specific test code that is longer. gap> ## The following should never terminate, but does in 4.4.5 gap> # repeat G:=PerfectGroup(IsPermGroup,79200,3); P:=SylowSubgroup(G,11); gap> # N:=Normalizer(G,P); Q:=N/P; until Size(DerivedSubgroup(Q)) <> 120; # 2005/08/23 (TB) gap> g:= SymmetricGroup( 4 );; IsSolvable( g );; Irr( g );; gap> meth:= ApplicableMethod( CharacterDegrees, [ g, 0 ] );; gap> meth( g, 0 ); "TRY_NEXT_METHOD" # 2005/08/23 (TB) gap> RereadLib( "debug.g" ); gap> Debug( Size ); Usage: Debug( [, ] ); where is a function but not an operation, and is a string. # 2005/08/23 (FL) # commented out the test and the error message, # since a different message is printed on 32 bit systems and 64 bit systems gap> a := 2^(8*GAPInfo.BytesPerVariable-4)-1;; gap> Unbind( x ); gap> # x := [-a..a];; # Range: the length of a range must be less than 2^28 gap> IsBound(x); false # 2005/08/25 (JS) gap> G := Group((1,2));; PrimePGroup(G); 2 gap> PrimePGroup(Subgroup(G,[])); # returns 2 in 4.4.5 fail # 2005/08/25 (JS) gap> HasIsPGroup( SylowSubgroup( SymmetricGroup( 5 ), 5 ) ); # false in 4.4.5 true # 2005/08/26 (Max) gap> IsOperation(MutableCopyMat); true # For new features: # 2005/06/08 (SL) gap> gamma := [[2,5],[3],[4,5],[1],[]]; [ [ 2, 5 ], [ 3 ], [ 4, 5 ], [ 1 ], [ ] ] gap> STRONGLY_CONNECTED_COMPONENTS_DIGRAPH(gamma); [ [ 5 ], [ 1, 2, 3, 4 ] ] # 2005/07/18 (FL) # takes too long in repeatedly running tests # IsProbablyPrimeInt(2^9689-1); # 2005/07/20 (SK), 2009/09/28 (AK) gap> Float("355")/Float("113"); 3.14159 gap> Rat(last); 355/113 gap> 1/4*last2; 0.785398 # 2005/07/20 (SK) gap> PadicValuation(288/17,2); 5 # 2005/07/20 (TB) gap> T:= EmptySCTable( 2, 0 );; gap> SetEntrySCTable( T, 1, 1, [ 1/2, 1, 2/3, 2 ] ); gap> A:= AlgebraByStructureConstants( Rationals, T );; A.1; v.1 # 2005/07/21 (FL) gap> IsCheapConwayPolynomial(5, 55); true gap> IsCheapConwayPolynomial(2, 108); true # 2005/07/22 (SK) gap> EpimorphismFromFreeGroup(SymmetricGroup(4)); [ x1, x2 ] -> [ (1,2,3,4), (1,2) ] # 2005/07/22 (SK) gap> ForAll([Lambda,Phi,Sigma,Tau],IsOperation); true # 2005/08/08 (CMRD) gap> AllPrimitiveGroups( Size, 60 );; #W AllPrimitiveGroups: Degree restricted to [ 1 .. 2499 ] # 2005/08/11 (TB) gap> DeclareGlobalVariable( "TestVariable" ); gap> InstallFlushableValue( TestVariable, rec() ); gap> MakeReadWriteGlobal( "TestVariable" ); UnbindGlobal( "TestVariable" ); # 2005/08/11 (TB) gap> DeclareOperation( "TestOperation", [ IsGroup, IsGroup ] ); gap> InstallMethod( TestOperation, [ "IsGroup and IsAbelian", "IsGroup" ], > function( G, H ) return true; end ); gap> MakeReadWriteGlobal( "TestOperation" ); UnbindGlobal( "TestOperation" ); # 2005/08/15 (SK) gap> List([0..5],i->PartialFactorization(7^64-1,i)); [ [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 5, 5, 17, 1868505648951954197516197706132003401892793036353 ], [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 5, 5, 17, 353, 5293217135841230021292344776577913319809612001 ], [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 5, 5, 17, 353, 134818753, 47072139617, 531968664833, 1567903802863297 ], [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 5, 5, 17, 353, 1201, 169553, 7699649, 134818753, 47072139617, 531968664833 ], [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 5, 5, 17, 353, 1201, 169553, 7699649, 134818753, 47072139617, 531968664833 ], [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 5, 5, 17, 353, 1201, 169553, 7699649, 134818753, 47072139617, 531968664833 ] ] # 2005/08/24 (SL, FL) gap> l:=[1,2];; gap> Remove(l,1); l; 1 [ 2 ] gap> Add(l, 100, 1); l; [ 100, 2 ] ############################################################################# ## ## for changes 4.4.6 -> 4.4.7 (extracted from corresponding dev/Update) # For fixes: # 2005/09/07 (TB) gap> Is8BitMatrixRep( InvariantQuadraticForm( SO( 7, 3 ) ).matrix ); true gap> Is8BitMatrixRep( InvariantBilinearForm( Sp( 4, 4 ) ).matrix ); true gap> Is8BitMatrixRep( InvariantSesquilinearForm( SU( 4, 2 ) ).matrix ); true # 2005/09/13 (AH) gap> r:=PolynomialRing(Rationals,3);; eo:=EliminationOrdering([2],[3,1]);; # 2005/09/20 (SK) gap> # None as the library methods for `NormalSubgroups' apparently obey gap> # the `rule' that the trivial subgroup appears in the first and the gap> # whole group appears in the last position. # 2005/10/05 (SL and MN) gap> p := PermList(Concatenation([2..10000],[1]));; gap> for i in [1..1000000] do a := p^0; od; time1 := time;; gap> for i in [1..1000000] do a := OneOp(p); od; time2 := time;; gap> if time1 <= 3 * time2 then Print("Fix worked\n"); fi; Fix worked # 2005/10/14 (BH) gap> IsBoundGlobal ("ComputedInducedPcgses"); true # 2005/10/26 (JS) gap> PolynomialByExtRep(FamilyObj(X(Rationals)),[[1,1],1,[2,1],1]); # x_2+x_1 in 4.4.6 x_1+x_2 # 2005/10/28 (TB) gap> fail in List( Irr( SymmetricGroup( 3 ) ), Inverse ); true # 2005/10/28 (TB) gap> Order( ClassFunction( CyclicGroup( 1 ), [ (1-EI(5))/ER(6) ] ) ); infinity # 2005/10/28 (TB) gap> rg:= GroupRing( GF(2), SymmetricGroup( 3 ) );; gap> i:= Ideal( rg, [ Sum( GeneratorsOfAlgebra( rg ){ [ 1, 2 ] } ) ] );; gap> Dimension( rg / i );; # 2005/11/22 (TB) gap> Z(4) in Group( Z(2) );; # 2005/11/25 (JS) gap> NrPerfectLibraryGroups(450000); 3 gap> NrPerfectLibraryGroups(962280); 1 gap> NrMovedPoints(PerfectGroup(IsPermGroup,129024,2)); 288 gap> NrMovedPoints(PerfectGroup(IsPermGroup,258048,2)); 576 gap> NrMovedPoints(PerfectGroup(IsPermGroup,516096,1)); 400 # 2005/11/28 (FL) gap> ConjugacyClasses(SL(2,3))[1]; [ [ Z(3)^0, 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ]^G # 2005/11/28 (TB) gap> t:= CharacterTable( SymmetricGroup( 4 ) );; gap> SetIdentifier( t, "Sym(4)" ); gap> Display( t, rec( classes:= [ 4 ] ) ); Sym(4) 2 . 3 1 3a 2P 3a 3P 1a X.1 1 X.2 . X.3 -1 X.4 . X.5 1 # 2005/11/29 (TB) gap> l:= [ [ 1, 2 ] ];; CheckFixedPoints( [ 1 ], l, [ 1, 1 ] );; l; [ 1 ] # 2005/11/29 (TB) gap> IsIdenticalObj( VectorSpace, FreeLeftModule ); false # 2005/11/29 (TB) gap> AsGroup( [ 1, -1 ] ); #I no groups of cyclotomics allowed because of incompatible ^ fail # 2005/12/21 (BH) gap> ApplicableMethod (CharacteristicPolynomial, [GF(2), GF(4), [[Z(2)]], 1])=fail; false # 2005/12/22 (Robert F. Morse) # 2011/09/13 (Updated by AK as suggested by JM) gap> t:=Transformation([1,2,3,3]);; gap> s:=FullTransformationSemigroup(4);; gap> ld:=GreensDClassOfElement(FullTransformationSemigroup(4), > Transformation([1,2,3,3]));; gap> rs:=AssociatedReesMatrixSemigroupOfDClass(ld);; gap> mat:=SandwichMatrixOfReesZeroMatrixSemigroup(rs);; gap> Length(mat); 4 gap> List(mat, x-> [Size(x), Number(x, y-> y=MultiplicativeZero(rs))]); [ [ 6, 3 ], [ 6, 3 ], [ 6, 3 ], [ 6, 3 ] ] gap> Size(UnderlyingSemigroupOfReesZeroMatrixSemigroup(rs)); 7 # 2006/01/11 (MC) gap> d := DirectoryCurrent();; gap> f := Filename(DirectoriesSystemPrograms(), "rev");; gap> if f <> fail then > s := InputOutputLocalProcess(d,f,[]);; > if PrintFormattingStatus(s) <> false then > Print( "unexpected PrintFormattingStatus value\n" ); > fi; > SetPrintFormattingStatus(s,false); > AppendTo(s,"The cat sat on the mat\n"); > if ReadLine(s) <> "tam eht no tas tac ehT\n" then > Print( "There is a problem concerning a cat on a mat.\n" ); > fi; > CloseStream(s); > fi; # 2006/01/18 (AH) gap> G:=WreathProduct(CyclicGroup(3),Group((1,2,3),(4,5,6)));; gap> Assert(0,Size(Group(GeneratorsOfGroup(G)))=6561); # 2006/01/25 (TB) gap> Basis( Rationals );; # 2006/02/14 (SK) gap> testG := > function ( a, b ) > local M1; > M1 := [ [ [ 0, -E(a)^-1 ], [ -E(a), 0 ] ], > [ [ 0, -1 ], [ 1, 0 ] ], > [ [ E(4*b), 0 ], [ 0, -E(4*b) ] ], > [ [ -1, 0 ], [ 0, -1 ] ]]; > return (Group(M1)); > end;; gap> StructureDescription(testG(8,2)); "(C8 x C4) : C2" gap> StructureDescription(testG(8,3)); "C3 x QD16" gap> StructureDescription(testG(8,4)); "(C16 x C4) : C2" # 2006/02/27 (AH) gap> RepresentativeAction(Group(()), [1], [2], OnSets);; # 2006/03/02 (AH) gap> x_1:=X(Rationals,"x_1":old);; gap> x_2:=X(Rationals,"x_2":old);; gap> x_3:=X(Rationals,"x_3":old);; gap> x_4:=X(Rationals,"x_4":old);; gap> x_5:=X(Rationals,"x_5":old);; gap> L:=[(x_3+x_4)*x_5-x_1,(x_3+x_4)*x_4-x_2,x_5^2+x_4^2-1];; gap> ReducedGroebnerBasis(L,MonomialLexOrdering([x_1,x_2,x_3,x_4,x_5])); [ x_4^2+x_5^2-1, -x_3*x_4+x_5^2+x_2-1, -x_3*x_5-x_4*x_5+x_1 ] gap> ReducedGroebnerBasis(L,MonomialLexOrdering([x_4,x_5,x_1,x_2,x_3])); [ x_1^4+2*x_1^2*x_2^2-x_1^2*x_3^2+x_2^4-x_2^2*x_3^2-2*x_1^2*x_2-2*x_2^3+x_2^2, -x_1^3-x_1*x_2^2+x_1*x_3^2+x_2*x_3*x_5+x_1*x_2, x_1^2*x_2+x_1*x_3*x_5+x_2^3-x_2*x_3^2-x_1^2-2*x_2^2+x_2, x_1^2*x_5+x_2^2*x_5-x_1*x_3-x_2*x_5, -x_1^2-x_2^2+x_3^2+x_5^2+2*x_2-1, -x_1^2-x_2^2+x_3^2+x_3*x_4+x_2, x_1*x_5+x_2*x_4-x_3-x_4, x_1*x_4-x_2*x_5, x_3*x_5+x_4*x_5-x_1, x_1^2+x_2^2-x_3^2+x_4^2-2*x_2 ] # 2006/03/03 (FL) gap> s := "";; str := OutputTextString(s, false);; gap> for i in [0..255] do WriteByte(str, i); od; gap> CloseStream(str); gap> s = List([0..255], CHAR_INT); true # 2006/2/20 (AH) gap> group1 := Group([ (1,3)(2,5)(4,7)(6,8), (1,4)(2,6)(3,7)(5,8), > (1,5)(2,3)(4,8)(6,7), (2,3,4,5,7,8,6), (3,4,7)(5,6,8) ]);; gap> group2 := Group([ (1,3,4,7,2,6,8), (1,8,7,5,3,6,2) ]);; gap> group3 := SymmetricGroup([1..8]);; gap> RepresentativeAction(group3,group1,group2); fail # 2006/03/08 (SL) gap> Z(3,30); z # For new features: # 2005/12/08 (TB, Michael Hartley (implementation of a prototype)) gap> LowIndexSubgroupsFpGroupIterator;; # 2005/12/22 (Robert F. Morse) gap> g := Image(IsomorphismFpGroup(SmallGroup(8,3)));; gap> h := Image(IsomorphismFpGroup(SmallGroup(120,5)));; gap> fp := FreeProduct(g,h);; gap> IsFpGroup(fp); true gap> emb := Embedding(fp,1);; gap> IsMapping(emb); true gap> dp := DirectProduct(g,h);; gap> IsFpGroup(dp); true gap> IdGroup(dp); [ 960, 5746 ] gap> IdGroup(Image(Projection(dp,2))); [ 120, 5 ] gap> IdGroup(Image(Embedding(dp,1))); [ 8, 3 ] # 2005/12/28 (FL) gap> IsCheapConwayPolynomial(2,114); true ############################################################################# ## ## for changes 4.4.7 -> 4.4.8 (extracted from corresponding dev/Update) # For fixes: # 2006/04/07 (TB) gap> G:= SymmetricGroup(3);; gap> m:= InnerAutomorphism( G, (1,2) );; gap> n:= TransformationRepresentation( InnerAutomorphism( G, (1,2,3) ) );; gap> m * n;; n * m;; # 2006/04/18 (SK) gap> gp := FreeGroup(1);; Size(gp);; gap> DirectProduct(gp,gp); # 2006/04/18 (TB) gap> Decomposition( [ [1,1], [E(3),E(3)^2] ], [ [1,-1] ], 1 ); [ fail ] # 2006/05/12 (TB) gap> Center( OctaveAlgebra( GF(13) ) );; # 2006/07/25 (AH) gap> g:=TransitiveGroup(10,8);; gap> ConjugatorOfConjugatorIsomorphism(ConjugatorAutomorphism(g,(4,9))); (1,6)(2,7)(3,8)(5,10) # 2006/07/27 (SK) gap> IsPolycyclicGroup(SymmetricGroup(4)); true gap> IsPolycyclicGroup(SymmetricGroup(5)); false gap> IsPolycyclicGroup(Group([[1,1],[0,1]])); true ## 2006/09/20 (JJM) ## comment out this test, since it will not complete without Polenta. #gap> IsPolycyclicGroup(Group([[1,1],[0,1]],[[0,1],[1,0]])); #false # 2006/07/28 (RFM) gap> g := CyclicGroup(1);; gap> SchurCover(g);; gap> sc := SchurCover(g);; gap> IdGroup(sc); [ 1, 1 ] gap> epi := EpimorphismSchurCover(g);; gap> Image(epi)=g; true gap> IdGroup(Source(epi)); [ 1, 1 ] gap> G := SmallGroup(27,3);; gap> IsCentralFactor(G); true gap> AbelianInvariantsMultiplier(G); [ 3, 3 ] gap> AbelianInvariants(Kernel(EpimorphismNonabelianExteriorSquare(G))); [ 3, 3 ] gap> ec := Epicentre(DirectProduct(CyclicGroup(25),CyclicGroup(5)));; gap> IsTrivial(ec); false gap> ec := Epicentre(DirectProduct(CyclicGroup(3),CyclicGroup(3)));; gap> IsTrivial(ec); true # 2006/08/19 (Max) gap> m := [[1]];; gap> IsMutable(m^1); true # 2006/08/19 (Max) gap> IsOperation(StripMemory); true # 2006/08/22 (Max) gap> "IsBlistRep" in NamesFilter(TypeObj(BlistList([1,2],[2]))![2]); true # 2006/08/28 (FL) gap> l:=List([1..100000],i->[i]);; gap> for i in [1..100000] do a := PositionSorted(l,[i]); od; time1 := time;; gap> l := Immutable(l);; gap> for i in [1..100000] do a := PositionSorted(l,[i]); od; time2 := time;; gap> time1 < 2*time2; # time1 and time2 should be about the same true # 2006/08/29 (FL (and AH)) gap> IsBound(ITER_POLY_WARN); true # 2006/08/28 (SL) gap> a := -70170876888665790351719387465587751111897440176;; gap> b := -24507694029460834590427275534096897425026491796;; gap> GcdInt(a,b); 4 # 2006/04/02 (AH) gap> F:=FreeGroup("x","y","z");; gap> x:=F.1;;y:=F.2;;z:=F.3;; gap> rels:=[x^2,y^2,z^4,Comm(z^-2,x),(z*x)^4,Comm(z^-1,y)^2, > (y*x)^4,(Comm(z,y)*x)^2,(Comm(y,z^-1)*x)^2,(y*z)^6, > z^-1*y*z^-1*x*z*y*z^-1*x*z*y*z^-1*x*z*y*z*x,y*z*x*z*y*x*y*z^-1*x*y*z^-1*x*y*z*x*y*z^-1*x];; gap> G:=F/rels;; gap> x:=G.1;;y:=G.2;;z:=G.3;; gap> s3:=Subgroup(G,[ z*y*z*y^-1, z^-1*y*z^-1*y^-1, y*z*x*z^-1*y^-1*x^-1, > z*x*y*z*x^-1*y^-1 ]);; gap> L:=LowIndexSubgroupsFpGroup(G,s3,4);; gap> Assert(0,Length(L)=27); # For new features: # 2006/06/19 (SK) gap> Positions([1,2,1,2,3,2,2],2); [ 2, 4, 6, 7 ] gap> Positions([1,2,1,2,3,2,2],4); [ ] # 2006/07/06 (SL) gap> z := Z(3,10);; gap> LogFFE(z,z^2); fail gap> z := Z(3,11);; gap> LogFFE(z,z^2); fail # 2006/08/16 (FL) gap> EvalString("1234\\\r\n567"); 1234567 # 2006/08/16 (FL) gap> IsBound(GAPInfo.SystemEnvironment); true # 2006/08/28 (FL) gap> Length(IDENTS_BOUND_GVARS());; gap> Length(ALL_RNAMES());; # 2006/08/28 (FL) gap> IsCheapConwayPolynomial(2,100); true # 2006/08/28 (FL) gap> Random(GlobalMersenneTwister,[1..6]);; ############################################################################# ## ## for changes 4.4.8 -> 4.4.9 (extracted from corresponding dev/Update) # 2006/10/04 (TB) gap> PseudoRandom( AutomorphismGroup( AlternatingGroup( 5 ) ) );; # 2006/10/23 (FL) gap> s := "";; for i in [0..255] do Add(s, CHAR_INT(i)); od; gap> fnam := Filename(DirectoryTemporary(), "guck");; gap> FileString(fnam, s);; gap> f := InputTextFile(fnam);; gap> a := [0..255];; if ARCH_IS_WINDOWS() then a[14]:=10; fi; gap> List([0..255], i-> ReadByte(f)) = a; true gap> RemoveFile(fnam); true # 2006/10/31 (FL) gap> Positions("abcdeca", 'c'); [ 3, 6 ] # 2006/10/4 (AH) gap> g:=SmallGroup(1800,646);;c:=CharacterTable(g);;Irr(c);; ############################################################################# ## ## for changes 4.4.9 -> 4.4.10 (extracted from corresponding dev/Update) # For fixes: # 2006/11/13 (AH) gap> Socle (Group ([[1]]));; # 2006/11/14 (FL) gap> DirectoryContents( Filename( DirectoriesLibrary( "" ), "lib" ) );; # 2007/01/17 (AH) gap> R := PolynomialRing(GF(4),1);; x := Z(4) * One(R);; gap> x in DefaultRing(x); true # 2007/01/22 (SL) gap> F := GF(7,3);; gap> F1 := GF(F,2);; gap> a := PrimitiveRoot(F1);; gap> B := Basis(F1);; gap> Coefficients(B,a^0); [ z0, 0z ] # 2007/02/14 (SL) gap> m:= [ [ Z(2,18)^0, 0*Z(2,18) ], > [ Z(2)^0+Z(2,18)+Z(2,18)^2+Z(2,18)^7+Z(2,18)^8+Z(2,18)^10+Z(2,18)^12 > +Z(2,18)^14+Z(2,18)^15, Z(2,18)^0 ] ];; gap> KroneckerProduct( [[Z(2)]], m ); [ , [ 1+z+z2+z7+z8+z10+z12+z14+z15, z0 ] ] # 2007/02/21 (TB) gap> v:= GF(2)^2;; bv:= BasisVectors( Basis( v ) );; gap> IsInjective( LeftModuleGeneralMappingByImages( v, v, bv, 0 * bv ) ); false gap> map:= LeftModuleGeneralMappingByImages( v, v, 0 * bv, bv );; gap> Print( ImagesRepresentative( map, Zero( v ) ), "\n" ); [ 0*Z(2), 0*Z(2) ] # 2007/02/23 (Max) gap> Enumerator(GF(74761)); # 2007/03/12 (SL) gap> z := Z(3,12)-Z(3,12); 0z gap> DegreeFFE(z); 1 gap> FFECONWAY.TryToWriteInSmallerField(z,2); 0*Z(3) # 2007/03/19 (SL) gap> GF(GF(7^3),2); AsField( GF(7^3), GF(7^6) ) # 2007/03/20 (SL) gap> x := Z(2,18)^((2^18-1)/511);; gap> b := Basis(GF(512));; gap> Coefficients(b,x); [ 0z, z0, 0z, 0z, 0z, 0z, 0z, 0z, 0z ] # 2007/03/26 (AH) gap> s:=ConjugacyClassSubgroups( > Group([ > (2,3)(6,7)(10,11)(14,15), > (5,9)(6,10)(7,11)(8,12), > (3,5)(4,6)(11,13)(12,14), > (1,2)(3,4)(5,6)(7,8)(9,10)(11,12)(13,14)(15,16), > (17,18) > ]), > Group([ > (1,16)(2,15)(3,14)(4,13)(5,12)(6,11)(7,10)(8,9), > (1,13,16,4)(2,5,15,12)(3,9,14,8)(6,7,11,10)(17,18), > (5,9)(6,10)(7,11)(8,12), > (2,3)(5,9)(6,11)(7,10)(8,12)(14,15) > ]))[1];; gap> IdGroup(s);; gap> ConjugacyClassesSubgroups(s);; # 2007/03/30 (TB) gap> IsSubset( [ [], [1] ], [ [] ] ); true # 2007/04/02 (FL) gap> Print(x -> 100000000000, "\n"); function ( x ) return 100000000000; end # 2007/06/14 (FL) gap> BlistList([1..10],[4234623462462464234242]); [ false, false, false, false, false, false, false, false, false, false ] # 2007/07/02 (SK) gap> GeneratorsOfRing(Rationals); Error, cannot compute elements list of infinite domain gap> GeneratorsOfRingWithOne(Rationals); Error, no method found! For debugging hints type ?Recovery from NoMethodFound Error, no 2nd choice method found for `GeneratorsOfRingWithOne' on 1 arguments # 2007/07/06 (JS) gap> PrimitiveGroup(50,4); PGL(2, 49) gap> Name(PrimitiveGroup(50,6)) = "PGL(2, 49)"; false # 2007/07/07 (FL) gap> OnTuples([,1],()); Error, OnTuples for perm: list must not contain holes # 2007/07/27 (AH) gap> H:=GroupByPcgs(Pcgs(AbelianGroup([6,6])));; gap> K:=SmallGroup(IdGroup(H));; gap> 1H:=TrivialGModule(H,GF(3));; gap> 1K:=TrivialGModule(K,GF(3));; gap> Assert(1,Rank(TwoCohomologySQ(CollectorSQ(H,1H,true),H,1H))= > Rank(TwoCohomologySQ(CollectorSQ(K,1K,true),K,1K))); # 2007/08/08 (SL) gap> l := [1,2,3];; gap> for i in [2] do Print(IsBound(l[10^20]),"\n"); od; false # 2007/08/15 (MN) gap> Print(ZmodpZObj(2,65537),"\n"); ZmodpZObj( 2, 65537 ) # For new features: # 2007/03/21 (TB) gap> IrreducibleModules( DihedralGroup(38), GF(2), 0 );; # 2007/06/14 (FL) gap> PositionSublist([1,2,3,4,5,6,7],[4,5,6]); 4 # 2007/08/15 (MN) gap> l := [1,2,3]; [ 1, 2, 3 ] gap> MakeImmutable(l); [ 1, 2, 3 ] # 2007/08/22 (AD) gap> f := UnivariatePolynomial( Rationals, [-4,0,0,1] );; gap> L := AlgebraicExtension( Rationals, f ); # 2007/08/29 (TB) gap> x:= TrivialCharacter( CharacterTable( SymmetricGroup(4) ) mod 2 );; gap> ScalarProduct( x, x );; # 2007/08/29 (TB) gap> a:= QuaternionAlgebra( [ EB(5) ] ); gap> IsSubset( a, QuaternionAlgebra( Rationals ) ); true # 2007/08/31 (FL) gap> # Quotient to yield the same on 32- and 64-bit systems gap> SHALLOW_SIZE([1])/GAPInfo.BytesPerVariable; 2 gap> SHALLOW_SIZE(List([1..160],i->i^2))/GAPInfo.BytesPerVariable; 161 gap> [ShrinkAllocationPlist, ShrinkAllocationString];; gap> [EmptyPlist, EmptyString];; # 2007/08/31 (FL) gap> IsCheapConwayPolynomial(2,150); true gap> IsCheapConwayPolynomial(3,52); true ############################################################################# ## ## for changes 4.4.10 -> 4.4.11 (extracted from corresponding dev/Update) # For fixes: # 2007/10/10 (TB) gap> IsomorphismTypeInfoFiniteSimpleGroup( 1 );; # 2007/10/15 (FL) gap> d:=NewDictionary(3213,true);; gap> LookupDictionary(d,4); fail # 2007/12/14 (MN) gap> a := [1..100];; gap> MemoryUsage(a)=MemoryUsage(a); true # 2008/01/02 (AH) gap> G:=SmallGroup(1308,1); gap> Length(Irr(G)); 48 # 2008/02/13 (TB) # 2008/03/19 (TB) gap> DefiningPolynomial( AsField( GF(9), GF(3^6) ) ); x_1^3+Z(3^2)^6*x_1^2+Z(3^2)*x_1+Z(3^2)^5 # 2008/04/03 (JS), updated on 2010/10/01 (AK) gap> g:=Group( (1,33)(2,12)(3,96)(4,37)(5,95)(6,11)(7,51)(8,42)(9,32)(10,80) > (13,17)(14,59)(15,62)(16,85)(18,22)(19,29)(20,24)(21,90)(23,72)(25,26) > (27,30)(28,70)(31,92)(34,100)(35,75)(36,82)(38,86)(39,77)(40,46)(41,44) > (43,61)(45,52)(47,78)(48,88)(49,57)(50,55)(53,97)(54,67)(56,91)(58,81) > (60,93)(63,71)(64,73)(65,89)(66,79)(68,98)(69,83)(74,87)(76,99)(84,94), > (1,10)(2,7,52,98)(3,68,75,12)(4,51,49,27)(5,18,29,91)(6,41,54,72) > (8,78,25,99)(9,95,67,55)(11,86,39,38)(13,17)(14,61,82,79)(15,97,28,46) > (16,56,74,83)(20,94,90,47)(21,65,66,58)(22,50,87,71)(23,93,31,85)(24,53) > (26,76,36,73)(30,37,44,69)(32,34)(33,70)(40,43)(42,88,64,80)(45,60,92,57) > (48,81)(59,62,84,89)(77,96) );; gap> c:=ConjugacyClassesMaximalSubgroups( g );; gap> Collected(List(c,x->[Size(Representative(x)),Size(x)])); [ [ [ 120, 336 ], 1 ], [ [ 144, 280 ], 1 ], [ [ 336, 120 ], 3 ], [ [ 384, 105 ], 1 ], [ [ 720, 56 ], 3 ], [ [ 20160, 1 ], 1 ] ] # 2008/04/23 (TB) gap> GeneratorsOfAlgebra( QuaternionAlgebra( GF(17) ) ); [ e, i, j, k ] gap> GeneratorsOfAlgebra( QuaternionAlgebra( GF(17) ) ); [ e, i, j, k ] # 2008/06/24 (FL) # none, we hope that the changed code is never needed! # 2008/07/20 (Laurent Bartholdi) gap> Intersection( [ -1 .. 1 ], [ -1 .. 1 ] ); # previously was empty [ -1 .. 1 ] gap> Intersection( [ 2, 4 .. 10 ], [ 3 .. 5 ] ); # previously was [ 4, 6 ] [ 4 ] # 2008/08/13 (SL) gap> Z(3,20) + Z(3,20)^0; 1+z gap> AA := Z(3^10)^30683; Z(3^10)^30683 gap> BB := Z(3)^0+Z(3^15)^3+Z(3^15)^4+2*Z(3^15)^5+2*Z(3^15)^8+2*Z(3^15)^10+2*Z(3^15)^11+Z(3^15)^13; 1+z3+z4+2z5+2z8+2z10+2z11+z13 gap> AA=BB; false gap> RT := Z(3^6); Z(3^6) gap> DD := Z(3^12)+Z(3^12)^2+2*Z(3^12)^3+2*Z(3^12)^4+Z(3^12)^5+Z(3^12)^6+Z(3^12)^7+Z(3^12)^8+2*Z(3^12)^9; z+z2+2z3+2z4+z5+z6+z7+z8+2z9 gap> LogFFE(DD,RT); 340 # 2008/09/02 (FL) gap> SmithNormalFormIntegerMatTransforms( > [ [ 2, 0, 0, 0, 0 ], [ 2, 2, 0, -2, 0 ], [ 0, -2, -2, -2, 0 ], > [ 3, 1, -1, 0, -1 ], [ 4, -2, 0, 2, 0 ], [ 3, -1, -1, 2, -1 ], > [ 0, 4, -2, 0, 2 ], [ 2, 2, 0, 2, 2 ], [ 0, 0, 0, 0, 0 ], > [ 2, 0, -4, -2, 0 ], [ 0, -2, 4, 2, -2 ], [ 2, -2, 0, -2, -1 ], > [ 3, -3, -1, 1, 0 ] ]).normal; [ [ 1, 0, 0, 0, 0 ], [ 0, 1, 0, 0, 0 ], [ 0, 0, 1, 0, 0 ], [ 0, 0, 0, 2, 0 ], [ 0, 0, 0, 0, 2 ], [ 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0 ] ] # 2008/09/10 (TB) gap> g:= AlternatingGroup( 10 );; gap> gens:= GeneratorsOfGroup( g );; gap> hom:= GroupHomomorphismByImagesNC( g, g, gens, gens );; gap> IsOne( hom ); # This took (almost) forever before the change ... true # 2008/09/10 (TB) gap> Display( StraightLineProgram( "a(ab)", [ "a", "b" ] ) ); # input: r:= [ g1, g2 ]; # program: r[3]:= r[1]; r[4]:= r[1]*r[2]; r[5]:= r[3]*r[4]; # return value: r[5] # 2008/09/11 (AH) gap> x:=Indeterminate(CF(7));; gap> K:=AlgebraicExtension(CF(7),x^2-3);; gap> a:=GeneratorsOfField(K)[1];; gap> x2 := E(7)+a*(E(7)^2+E(7)^3); (E(7)^2+E(7)^3)*a+E(7) # 2008/09/18 (AH) gap> g:=Group((14,15)(16,17), (12,13), (9,10,11), (4,8)(16,17), > (1,8)(2,3)(4,5)(6,7)(16,17), (1,3)(2,8)(4,6)(5,7)(16,17));; gap> IsNilpotent(g); true # For new features: # 2008/02/29 (TB) gap> f:= GF(2);; x:= Indeterminate( f );; p:= x^2+x+1;; gap> e:= AlgebraicExtension( f, p );; gap> GeneratorsOfLeftModule( e );; Basis( e );; Iterator( e );; # 2008/03/26 (TB) gap> FrobeniusCharacterValue( E(55), 2 ); z+z2+z3+z4+z5+z6+z8+z10+z12+z13+z14+z16+z17+z19 # 2008/04/14 (SK) gap> [[4,5],[5,6]] in GL(2,Integers); true gap> [[4,5],[5,6]] in SL(2,Integers); false # 2008/04/14 (SK) gap> String(Integers^3); "( Integers^3 )" gap> ViewString(GF(16)^3); "( GF(2^4)^3 )" gap> IsRowModule(1); false # 2008/04/14 (SK) gap> G := Group((1,2));; gap> SetName(G,"C2"); gap> ViewString(G); "C2" # 2008/04/15 (SK) gap> PolynomialRing(GF(2),1); GF(2)[x_1] gap> String(PolynomialRing(GF(8),4)); "PolynomialRing( GF(2^3), [ x_1, x_2, x_3, x_4 ] )" gap> ViewString(PolynomialRing(GF(2),1)); "GF(2)[x_1]" # 2008/06/05 (FL) gap> Binomial(2^80,3); 294474510796397388263882186039667753853121547637256443485296081974067200 # 2008/10/01 (TB) gap> QuaternionAlgebra( Field( [ EB(5) ] ) );; gap> IsDivisionRing( QuaternionAlgebra( Field( [ EB(5) ] ) ) ); true # 2008/11/16 (TB) gap> t:= [ [ 1, 2, 3, 4, 5 ], [ 2, 1, 4, 5, 3 ], [ 3, 5, 1, 2, 4 ], > [ 4, 3, 5, 1, 2 ], [ 5, 4, 2, 3, 1 ] ];; gap> m:= MagmaByMultiplicationTable( t );; gap> IsAssociative( m ); false gap> AsGroup( m ); fail # 2008/11/16 (TB) gap> att:= NewAttribute( "att", IsObject ); gap> prop1:= NewProperty( "prop1", IsObject ); gap> prop2:= NewProperty( "prop2", IsObject ); gap> InstallTrueMethod( prop2, prop1 ); gap> InstallImmediateMethod( att, Tester( prop2 ), 0, G -> 1 ); gap> # The intended behaviour is that `prop1' implies `prop2', gap> # and that a known value of `prop2' triggers a method call gap> # that yields the value for the attribute `att'. gap> g:= Group( (1,2,3,4), (1,2) );; gap> Tester( att )( g ); Tester( prop1 )( g ); Tester( prop2 )( g ); false false false gap> Setter( prop1 )( g, true ); gap> # Now `prop1' is `true', gap> # the logical implication sets also `prop2' to `true', gap> # thus the condition for the immediate method is satisfied. gap> Tester( prop1 )( g ); Tester( prop2 )( g ); true true gap> Tester( att )( g ); # Here we got `false' before the fix. true ############################################################################# ## ## Changes 4.4.12 -> 4.5.4 # 2008/12/15 (TB) gap> 0*Z(5) in Group( Z(5) ); false # 2009/02/04 (FL) gap> Intersection([1..3],[4..5],[6,7]); [ ] # 2009/02/23 (AH) gap> chi:=Irr(CyclicGroup(3))[2];; gap> IrreducibleRepresentationsDixon(UnderlyingGroup(chi),[chi]);; # 2009/02/25 (TB) gap> IndexNC( GL(30,17), SL(30,17) ); 16 # 2009/03/13 (FL) gap> b:=BlistList([1..4],[1,2]); [ true, true, false, false ] gap> b{[1,2]} := [false,false]; [ false, false ] gap> IsBlistRep(b); true # 2009/05/28 (BH) gap> G:=AlternatingGroup(4);; gap> N:=Subgroup(G,[(1,2)(3,4),(1,3)(2,4)]);; gap> H:=DirectProduct(CyclicGroup(2),CyclicGroup(2));; gap> A:=AutomorphismGroup(H);; gap> P:=SylowSubgroup(A,3);; gap> epi:=NaturalHomomorphismByNormalSubgroup(G,N);; gap> iso:=IsomorphismGroups(FactorGroup(G,N),P);; gap> f:=CompositionMapping(IsomorphismGroups(FactorGroup(G,N),P),epi);; gap> SemidirectProduct(G,f,H); # 2009/09/23 (AH) gap> g:=DirectProduct(DihedralGroup(14),SmallGroup(1440,120));; gap> PositionSublist(StructureDescription(g),"PSL"); fail # 2009/09/25 (TB) gap> lin:= LinearCharacters( CyclicGroup( 3 ) );; gap> lin[2] ^ One( GaloisGroup( CF(3) ) );; # 2009/09/30 (TB) gap> v:= GF(2)^1;; gap> Subspace( v, [] ) < Subspace( v, [] ); false gap> v:= GF(2)^[1,1];; gap> Subspace( v, [] ) < Subspace( v, [] ); false # 2010/09/06 (TB) gap> G:= SL( 2, 3 );; gap> x:= [ [ Z(9), 0*Z(3) ], [ 0*Z(3), Z(3)^0 ] ];; gap> y:= [ [ Z(3)^0, 0*Z(3) ], [ 0*Z(3), Z(9) ] ];; gap> IsConjugate( G, x, y ); true # Reported by Sohail Iqbal on 2008/10/15, added by AK on 2010/10/03 gap> f:=FreeGroup("s","t");; s:=f.1;; t:=f.2;; gap> g:=f/[s^4,t^4,(s*t)^2,(s*t^3)^2];; gap> CharacterTable(g); CharacterTable( ) gap> Length(Irr(g)); 10 # 2010/10/06 (TB) gap> EU(7,2); -1 # Reported by Laurent Bartholdi on 2008/11/14, added by AK on 2010/10/15 gap> f := FreeGroup(0);; g := FreeGroup(1);; gap> phi := GroupHomomorphismByImages(f,g,[],[]);; gap> One(f)^phi = One(g); true gap> One(f)^phi=One(f); false # 2010/10/20 (TB) gap> NormalizersTom( TableOfMarks( CyclicGroup( 3 ) ) ); [ 2, 2 ] # 2010/10/27 (TB) gap> PermChars( CharacterTable( SymmetricGroup( 3 ) ), 3 ); [ Character( CharacterTable( Sym( [ 1 .. 3 ] ) ), [ 3, 1, 0 ] ) ] # 2010/11/11 (AH) gap> x:=X(Rationals);;IsIrreducible(x^3-7381125*x^2-5*x+36905625); false # Reported by FL on 2010/05/05, added by AK on 2011/01/16 gap> Size(Set(List([1..10],i->Random(1,2^60-1))))=10; true gap> Size(Set(List([1..10],i->Random(1,2^60))))=10; true # Reported by MN on 2009/10/06, added by AK on 2011/01/16 gap> (Z(65536)^2)^LogFFE(Z(65536)^16386,Z(65536)^2) = Z(65536)^16386; true # Reported by TB on 2009/11/09, added by AK on 2011/01/20 # Log2Int(2^60) bug (a 64bit/GMP issue) gap> Log2Int( 2^60 ); 60 # Reported by WDeMeo on 2011/02/19, added by JS on 2011/03/09 # IntermediateSubgroups(G,normal) included non-maximal inclusions gap> g:=CyclicGroup(2^6);; IntermediateSubgroups( g, TrivialSubgroup(g) ).inclusions; [ [ 0, 1 ], [ 1, 2 ], [ 2, 3 ], [ 3, 4 ], [ 4, 5 ], [ 5, 6 ] ] # Problem with printing when GAP is compiled with GMP 5.0.1 under Mac OS X # in 32-bit mode. Does not occur with GMP 4.3.2 or in 64-bit mode. # Reported by BH on 2011/02/06, added by AK on 2011/03/24 gap> 2*10^201*10; 200000000000000000000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000000000000000000000\ 00000000000000000000000000000000000000000000000 # 2011/04/29 (TB) gap> t:= CharacterTable( SmallGroup( 72, 26 ) );; gap> Set( List( Irr( t ), x -> Size( CentreOfCharacter( x ) ) ) ); [ 6, 12, 18, 72 ] # 2011/06/01 (TB) gap> F2:= GF( 2 );; gap> x:= Indeterminate( F2 );; gap> F:= AlgebraicExtension( F2, x^2+x+1 );; gap> Trace( RootOfDefiningPolynomial( F ) ); Z(2)^0 # Reported by Radoslav Kirov on 2011/06/11, added by MH on 2011/09/29 gap> H := [ > [ Z(5)^3, Z(5)^0, Z(5)^0, 0*Z(5), 0*Z(5), 0*Z(5) ], > [ Z(5)^0, Z(5)^0, 0*Z(5), Z(5)^0, 0*Z(5), 0*Z(5) ], > [ Z(5)^2, Z(5), 0*Z(5), 0*Z(5), Z(5)^0, 0*Z(5) ], > [ Z(5)^3, Z(5), 0*Z(5), 0*Z(5), 0*Z(5), Z(5)^0 ]] ;; gap> cl:=CosetLeadersMatFFE(H, GF(5));; Size(cl); 625 gap> [0,0,3,0,0,2]*Z(5)^0 in cl; true gap> [4,0,1,1,4,0]*Z(5)^0 in cl; false # 2011/09/29 (FL) gap> List([1,,3],x->x^2); [ 1,, 9 ] # Reported by Izumi Miyamoto on 2011/12/17, added by MH on 2011/12/18 # Computing normalizers inside the trivial group could error out. gap> Normalizer(Group(()),Group((1,2,3))); Group(()) gap> Normalizer(Group(()),TransitiveGroup(3,1)); Group(()) # Reported by Ilko Brauch on 2011/12/16, added by MH on 2011/12/18 gap> G := CyclicGroup(IsFpGroup,3); gap> Elements(G); [ , a, a^2 ] # 2011/12/20 (FL) gap> 2^1000000; # Reported by Burkhard Hoefling on 2012/3/14, added by SL on 2012/3/16 # SHIFT_LEFT_VEC8BIT can fail to clean space to its right, which can then # be picked up by a subsequent add to a longer vector gap> v := [0*Z(4), 0*Z(4), 0*Z(4), 0*Z(4), Z(4)]; [ 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), Z(2^2) ] gap> ConvertToVectorRep (v, 4); 4 gap> SHIFT_VEC8BIT_LEFT(v,1); gap> w := [0*Z(4), 0*Z(4), 0*Z(4), 0*Z(4),0*Z(4), 0*Z(4), Z(4)]; [ 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), Z(2^2) ] gap> ConvertToVectorRep (w, 4); 4 gap> v+w; [ 0*Z(2), 0*Z(2), 0*Z(2), Z(2^2), 0*Z(2), 0*Z(2), Z(2^2) ] # Reported by Burkhard Hoefling on 2012/3/17, added by SL on 2012/3/17 # Converting a compressed vector of length 0 to a bigger field failed. gap> v := [0*Z(3)]; [ 0*Z(3) ] gap> ConvertToVectorRep(v); 3 gap> Unbind(v[1]); gap> ConvertToVectorRep(v,9); 9 # Bug with non-square matrices in ElementaryDivisorsMat, added by MH on 2012/4/3. # Since ElementaryDivisorsMat just calls SmithNormalFormIntegerMat when # the base ring R equals Integers, we use GaussianIntegers instead to # ensure the generic ElementaryDivisorsMat method is tested. gap> ElementaryDivisorsMat(GaussianIntegers, [ [ 20, -25, 5 ] ]); [ 5, 0, 0 ] # 2012/04/13 (MN) gap> Characteristic(Z(2)); 2 gap> Characteristic(0*Z(2)); 2 gap> Characteristic(0*Z(5)); 5 gap> Characteristic(Z(5)); 5 gap> Characteristic(Z(257)); 257 gap> Characteristic(Z(2^60)); 2 gap> Characteristic(Z(3^20)); 3 gap> Characteristic(0); 0 gap> Characteristic(12); 0 gap> Characteristic(12123123123); 0 gap> Characteristic(E(4)); 0 gap> Characteristic([Z(2),Z(4)]); 2 gap> v := [Z(2),Z(4)]; [ Z(2)^0, Z(2^2) ] gap> ConvertToVectorRep(v,4); 4 gap> Characteristic(v); 2 gap> Characteristic([Z(257),Z(257)^47]); 257 gap> Characteristic([[Z(257),Z(257)^47]]); 257 gap> Characteristic(ZmodnZObj(2,6)); 6 gap> Characteristic(ZmodnZObj(2,5)); 5 gap> Characteristic(ZmodnZObj(2,5123123123)); 5123123123 gap> Characteristic(ZmodnZObj(0,5123123123)); 5123123123 gap> Characteristic(GF(2,3)); 2 gap> Characteristic(GF(2)); 2 gap> Characteristic(GF(3,7)); 3 gap> Characteristic(GF(1031)); 1031 gap> Characteristic(Cyclotomics); 0 gap> Characteristic(Integers); 0 gap> T:= EmptySCTable( 2, 0 );; gap> SetEntrySCTable( T, 1, 1, [ 1/2, 1, 2/3, 2 ] ); gap> a := AlgebraByStructureConstants(Rationals,T); gap> Characteristic(a); 0 gap> a := AlgebraByStructureConstants(Cyclotomics,T); gap> Characteristic(a); 0 gap> a := AlgebraByStructureConstants(GF(7),T); gap> Characteristic(a); 7 gap> T:= EmptySCTable( 2, 0 );; gap> SetEntrySCTable( T, 1, 1, [ 1, 1, 2, 2 ] ); gap> r := RingByStructureConstants([7,7],T); gap> Characteristic(r); 7 gap> r := RingByStructureConstants([7,5],T); gap> Characteristic(r); 35 ############################################################################# ## ## Changes 4.5.4 -> 4.5.5 # Bug with commutator subgroups of fp groups, was causing infinite recursion, # also when computing automorphism groups # Fix and test case added by MH on 2012-06-05. gap> F:=FreeGroup(3);; gap> G:=F/[F.1^2,F.2^2,F.3^2,(F.1*F.2)^3, (F.2*F.3)^3, (F.1*F.3)^2];; gap> U:=Subgroup(G, [G.3*G.1*G.3*G.2*G.1*G.3*G.2*G.3*G.1*G.3*G.1*G.3]);; gap> StructureDescription(CommutatorSubgroup(G, U)); "C2 x C2" gap> StructureDescription(AutomorphismGroup(G)); "S4" # 2012/06/15 (AH) gap> gens:=[[[1,1],[0,1]], [[1,0],[1,1]]] * ZmodnZObj(1,7); [ [ [ Z(7)^0, Z(7)^0 ], [ 0*Z(7), Z(7)^0 ] ], [ [ Z(7)^0, 0*Z(7) ], [ Z(7)^0, Z(7)^0 ] ] ] gap> gens:=List(Immutable(gens),i->ImmutableMatrix(GF(7),i));; # 2012/06/15 (AH) gap> rng := PolynomialRing(Rationals,2); Rationals[x_1,x_2] gap> ind := IndeterminatesOfPolynomialRing(rng); [ x_1, x_2 ] gap> x := ind[1]; x_1 gap> y := ind[2]; x_2 gap> pol:=5*(x_1+1)^2; 5*x_1^2+10*x_1+5 gap> factors := Factors(pol); [ 5*x_1+5, x_1+1 ] gap> factors[2] := x_2; x_2 gap> factors[1] := []; [ ] gap> Factors( pol ); [ 5*x_1+5, x_1+1 ] # 2012/07/13 (TB) gap> IsDocumentedWord( "d" ); false gap> # "d_N" is documented gap> IsDocumentedWord( "last2" ); true ############################################################################# ## ## Changes 4.5.5 -> 4.5.6 ## For bugfixes # The GL and SL constructors did not correctly handle GL(filter,dim,ring). # Reported and fixed by JS on 2012-06-24 gap> GL(IsMatrixGroup,3,GF(2));; gap> SL(IsMatrixGroup,3,GF(2));; # The names of two primitive groups of degree 64 were incorrect. # Reported and fixed by JS on 2012-08-12 gap> PrimitiveGroup(64,53); 2^6:(S3 x GL(3, 2)) gap> PrimitiveGroup(64,64); 2^6:PGL(2, 7) gap> # Fix of very large (more than 1024 digit) integers not being coded # correctly in function bodies unless the integer limb size was 16 bits. # Reported by Stefan Kohl, fixed by SL on 2012-08-12 gap> f := function() return > 100000000000000000000000000000000000000000000000000000000000000000000000000000\ > 000000000000000000000000000000000000000000000000000000000000000000000000000000\ > 000000000000000000000000000000000000000000000000000000000000000000000000000000\ > 000000000000000000000000000000000000000000000000000000000000000000000000000000\ > 000000000000000000000000000000000000000000000000000000000000000000000000000000\ > 000000000000000000000000000000000000000000000000000000000000000000000000000000\ > 000000000000000000000000000000000000000000000000000000000000000000000000000000\ > 000000000000000000000000000000000000000000000000000000000000000000000000000000\ > 000000000000000000000000000000000000000000000000000000000000000000000000000000\ > 000000000000000000000000000000000000000000000000000000000000000000000000000000\ > 000000000000000000000000000000000000000000000000000000000000000000000000000000\ > 000000000000000000000000000000000000000000000000000000000000000000000000000000\ > 000000000000000000000000000000000000000000000000000000000000000000000000000000\ > 000000000000000000000000000000000000000000000000000000000000000000000000000000\ > 00000000; end; function( ) ... end gap> f(); 100000000000000000000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000000000000000000000\ 000000000000000000000000000000000000000000000000000000000000000000000000000000\ 00000000 # Fix of Crash in garbage collection following call to AClosVec for a GF(2) code # Reported by Volker Brown, fixed by SL on 2012-08-31 gap> x:= > [ [ Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), > Z(2)^0, 0*Z(2), Z(2)^0, 0*Z(2), Z(2)^0, Z(2)^0, Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0 ], > [ 0*Z(2), Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), > Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0, 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2), 0*Z(2), Z(2)^0 ], > [ 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), > Z(2)^0, Z(2)^0, 0*Z(2), Z(2)^0, 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2), Z(2)^0, 0*Z(2), Z(2)^0 ], > [ 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), > Z(2)^0, Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0, Z(2)^0, Z(2)^0, 0*Z(2), Z(2)^0, Z(2)^0 ], > [ 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), > Z(2)^0, Z(2)^0, 0*Z(2), 0*Z(2), Z(2)^0, Z(2)^0, 0*Z(2), Z(2)^0, Z(2)^0, 0*Z(2), 0*Z(2) ], > [ 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), > 0*Z(2), Z(2)^0, Z(2)^0, 0*Z(2), 0*Z(2), Z(2)^0, Z(2)^0, 0*Z(2), Z(2)^0, Z(2)^0, 0*Z(2) ], > [ 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), > 0*Z(2), 0*Z(2), Z(2)^0, Z(2)^0, 0*Z(2), 0*Z(2), Z(2)^0, Z(2)^0, 0*Z(2), Z(2)^0, Z(2)^0 ], > [ 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), > Z(2)^0, 0*Z(2), Z(2)^0, Z(2)^0, 0*Z(2), Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0, 0*Z(2), 0*Z(2) ], > [ 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2), > 0*Z(2), Z(2)^0, 0*Z(2), Z(2)^0, Z(2)^0, 0*Z(2), Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0, 0*Z(2) ], > [ 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2), 0*Z(2), > 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2), Z(2)^0, Z(2)^0, 0*Z(2), Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0 ], > [ 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2), > Z(2)^0, 0*Z(2), Z(2)^0, Z(2)^0, Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0, Z(2)^0, 0*Z(2) ], > [ 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0, > 0*Z(2), Z(2)^0, 0*Z(2), Z(2)^0, Z(2)^0, Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0, Z(2)^0 ] ];; gap> P:=AClosestVectorDriver(x, GF(2), Z(2)*[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],11,0, true);; gap> GASMAN("collect");; # Crash when reading certain pieces of syntactically invalid code # Fix and test case added by MH on 2012-09-06. gap> str := Concatenation("function()\n", > "local e, v;\n", > "for e in [] do\n", > " v := rec(a := [];);\n", > "od;\n" > ); "function()\nlocal e, v;\nfor e in [] do\n v := rec(a := [];);\nod;\n" gap> s:=InputTextString(str); InputTextString(0,66) gap> Read(s); Syntax error: ) expected in stream line 4 v := rec(a := [];); ^ Syntax error: end expected in stream line 5 od; ^ # Check that \in method works for groups handled by a nice monomorphism # created with a custom SeedFaithfulAction. # Fix and test case added by MH on 2012-09-07. gap> m1:=PermutationMat( (1,2), 5, GF(5) );; gap> m2:=PermutationMat( (3,4), 5, GF(5) );; gap> n:=PermutationMat( (1,4,5), 5, GF(5) );; gap> G:=Group(m1, m2);; gap> SetSeedFaithfulAction(G,rec(points:=[m1[1],m1[3]], ops:=[OnPoints,OnPoints])); gap> n in G; false # Check that overloading of a loaded help book by another one works. This # makes sense if a book of a not loaded package is loaded in a workspace # and GAP is started with a root path that contains a newer version. # Reported by Sebastian Gutsche, fixed by FL on 2012-09-11 gap> old := ShallowCopy(HELP_KNOWN_BOOKS[2][1]);; gap> HELP_KNOWN_BOOKS[2][1][3] := > Concatenation(HELP_KNOWN_BOOKS[2][1][3], "blabla");; gap> CallFuncList(HELP_ADD_BOOK, old); #I Overwriting already installed help book 'tutorial'. # Check of the membership test after fixing a method for coefficients # to check after Gaussian elimination that the coefficients actually # lie in the left-acting-domain of the vector space. # Reported by Kevin Watkins, fixed by TB (via AK) on 2012-09-13 gap> Sqrt(5)*IdentityMat(2) in VectorSpace(Rationals,[IdentityMat(2)]); false # Check that removing wrong PrintObj method fixes delegations accordingly # to documented behaviour for PrintObj/ViewObj/Display. # Reported by TB, fixed by MN on 2012-08-20. gap> if IsBound(IsXYZ) then MakeReadWriteGlobal("IsXYZ"); Unbind(IsXYZ); fi; gap> fam := NewFamily("XYZsFamily");; gap> DeclareCategory("IsXYZ",IsObject); gap> type := NewType(fam,IsXYZ and IsPositionalObjectRep);; gap> o := Objectify(type,[]);; gap> InstallMethod(String,[IsXYZ],function(o) return "XYZ"; end); gap> o; XYZ gap> Print(o,"\n"); XYZ gap> String(o); "XYZ" ## For new features # 2012/08/13 (AK) gap> First(PositiveIntegers,IsPrime); 2 ############################################################################# ## ## Changes 4.5.6 -> 4.5.7 ## For bugfixes # 2012/11/02 (FL) # Fix a crash on 32-bit systems when Log2Int(n) is not an immediate integer. gap> a:=(2^(2^15))^(2^14);; gap> Log2Int(a); 536870912 # 2012/09/26 (AH) gap> p:=7;; gap> F:=FreeGroup("a","b","c","d","e","f");; gap> G:=F/[ F.1^p, F.2^p, F.3^p, F.4^p, F.5^p, F.6^p, > Comm(F.2,F.1)*F.3^-1, Comm(F.3,F.1)*F.4^-1, > Comm(F.4,F.1)*F.5^-1, Comm(F.4,F.2)*F.6^-1, > Comm(F.5,F.2)*F.6^-1, Comm(F.4,F.3)*F.6, > Comm(F.1,F.5), Comm(F.1,F.6), Comm(F.2,F.3), > Comm(F.2,F.6), Comm(F.3,F.5), Comm(F.3,F.6), > Comm(F.4,F.5), Comm(F.4,F.6), Comm(F.5,F.6)];; gap> G:=Image(IsomorphismPermGroup(G));; gap> DerivedSubgroup(G)=FrattiniSubgroup(G); true gap> sd1:=StructureDescription(DerivedSubgroup(G));; gap> sd2:=StructureDescription(FrattiniSubgroup(G));; gap> sd1=sd2; true # 2012/10/05 (AH) gap> G:=DirectProduct(CyclicGroup(2),PSL(3,4));; gap> NaturalHomomorphismByNormalSubgroup(G,TrivialSubgroup(G));; # 2012/10/26 (SL) # Fix a crash when a logfile opened with LogTo() is closed with LogInputTo() gap> LogTo( Filename( DirectoryTemporary(), "foo" ) ); gap> LogInputTo(); Error, InputLogTo: can not close the logfile gap> LogTo(); # 2012/11/15 (SL) gap> x := ZmodnZObj(2,10); ZmodnZObj( 2, 10 ) gap> y := ZmodnZObj(0,10); ZmodnZObj( 0, 10 ) gap> x/y; fail gap> y/x; ZmodnZObj( 0, 10 ) gap> x/0; fail gap> 3/y; fail # 2012/11/21 (SL) gap> s := FreeSemigroup("a","b"); gap> t := Subsemigroup(s,[s.1]); gap> t := Subsemigroup(s,[s.1]); gap> HasSize(t); true gap> Size(t); infinity gap> t := Subsemigroup(s,[]); gap> HasSize(t); true gap> Size(t); 0 # 2012/11/25 (AK) # Fix of a bug that was reproducible in GAP 4.5.6 with FGA 1.1.1 gap> f := FreeGroup(2); gap> iso:=GroupHomomorphismByImagesNC(f,f,[f.1*f.2,f.1*f.2^2],[f.2^2*f.1,f.2*f.1]); [ f1*f2, f1*f2^2 ] -> [ f2^2*f1, f2*f1 ] gap> SetIsSurjective(iso,true); gap> Image(iso,PreImagesRepresentative(iso,f.1)); f1 # 2012/11/26 (MN) gap> 10^20000+12345; gap> -(10^20000+12345); # 2012/12/06 (AK) gap> x := Indeterminate(Rationals); x_1 gap> InverseSM(Zero(x)); fail gap> Inverse(Zero(x)); fail gap> InverseOp(Zero(x)); fail ############################################################################# ## ## Changes 4.5.7 -> 4.6.2 ## For bugfixes # 2012/10/26 (SL) gap> r := rec(1 := rec(x := true));; gap> r.1.x; true # 2012/11/01 (SL) gap> m := IdentityMat(10,GF(7));; gap> m[3][3] := 0*Z(7,6);; gap> Display(m); 1 . . . . . . . . . . 1 . . . . . . . . . . . . . . . . . . . . . 1 . . . . . . . . . . 1 . . . . . . . . . . 1 . . . . . . . . . . 1 . . . . . . . . . . 1 . . . . . . . . . . 1 . . . . . . . . . . 1 # 2012/12/17 (SL) gap> l := [1,2,3];; gap> Unbind(l,1); Syntax error: 'Unbind': argument should be followed by ')' in stream line 1 Unbind(l,1); ^ gap> l; [ 1, 2, 3 ] # 2013/01/07 (MH) gap> m:=IdentityMat(8,GF(3));; gap> m2:=m + List([1..8],i->List([1..8], j->Zero(GF(3))));; gap> DefaultScalarDomainOfMatrixList([m,m2]); GF(3) gap> DefaultScalarDomainOfMatrixList([m2,m]); GF(3) ## For new features # 2012/08/14 (AK) gap> R:=PolynomialRing(GF(5),"mu");; gap> mu:=Indeterminate(GF(5));; gap> T:=AlgebraicExtension(GF(5),mu^5-mu+1);; gap> A:=PolynomialRing(T,"x"); [x] # 2012/09/14 (SL) gap> a := BlistList([1,2,3],[1]);; gap> b := BlistList([1,2,3],[2]);; gap> c := BlistList([1,2,3],[2,3]);; gap> MEET_BLIST(a,b); false gap> MEET_BLIST(a,c); false gap> MEET_BLIST(b,c); true gap> MEET_BLIST(a,a); true # 2012/11/10 (SL) gap> l := [ 2, 3, 4, 1, 5, 10, 9, 7, 8, 6, 11 ];; gap> SortBy(l,AINV); gap> l; [ 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ] # 2012/11/20 (BH) gap> G := WreathProduct (CyclicGroup (IsPermGroup, 7), SymmetricGroup (5)); gap> IsPSolvable (G, 2); false gap> IsPSolvable (G, 3); false gap> IsPSolvable (G, 5); false gap> IsPSolvable (G, 7); true gap> IsPNilpotent(GL(3,2),2); false # 2012/12/17 (SL) gap> DeclareOperation("MyOp",[IsObject, IsObject]); gap> DeclareAttribute("MyOp",IsObject); # 2013/01/17 (AK) gap> lo:= LieObject( [ [ 1, 0 ], [ 0, 1 ] ] ); LieObject( [ [ 1, 0 ], [ 0, 1 ] ] ) gap> m:=UnderlyingRingElement(lo); [ [ 1, 0 ], [ 0, 1 ] ] gap> lo*lo; LieObject( [ [ 0, 0 ], [ 0, 0 ] ] ) gap> m*m; [ [ 1, 0 ], [ 0, 1 ] ] # 2013/01/20 (SL) gap> DistancePerms((1,2,3,4,5,6),(1,2,3)); 4 ############################################################################# ## ## Changes 4.6.2 -> 4.6.3 ## For bugfixes # 2013/02/07 (AK) gap> PowerModInt(3,0,1); 0 # 2013/02/27 (SL) gap> m:= [[Z(3^16),0],[1,Z(3)]] * One( Z(3) ); [ [ z, 0*Z(3) ], [ Z(3)^0, Z(3) ] ] gap> Display(m); z = Z( 3, 16); z2 = z^2, etc. z . 1 2 gap> m[1][1]:= m[1][1] + 1; 1+z gap> Display( m ); z = Z( 3, 16); z2 = z^2, etc. 1+z . 1 2 # 2013/02/27 (AK) gap> G:=SymmetricGroup(8); Sym( [ 1 .. 8 ] ) gap> H:=SylowSubgroup(G,3);; gap> HasIsPGroup(H); true gap> HasPrimePGroup(H); true # 2013/02/28 (BH). More tests added by AK gap> Length( AbsolutIrreducibleModules( AlternatingGroup(5), GF(4), 120) ); 2 gap> Length( IrreducibleRepresentations( DihedralGroup(10), GF(2^2) ) ); 3 gap> Length( AbsoluteIrreducibleModules( CyclicGroup(3), GF(4), 1) ); 2 gap> G:=DihedralGroup(20);; b:=G.1*G.2;; Order(b); 2 gap> ForAll( IrreducibleRepresentations(G,GF(8)), phi -> IsOne(Image(phi,b)^2)); true # 2013/03/06 (MH) gap> PermutationMat((1,2),2,GF(3^6)); [ [ 0*Z(3), Z(3)^0 ], [ Z(3)^0, 0*Z(3) ] ] # 2013/03/07 (MH) gap> s:="cba"; "cba" gap> IsSSortedList(s); false gap> IsInt(RNamObj(s)); true gap> r:=rec(cba := 1);; gap> IsBound(r.(s)); true # 2013/03/08 (MH) gap> v:=[ Z(2^4)^3, Z(2^4)^6, Z(2)^0 ]; [ Z(2^4)^3, Z(2^4)^6, Z(2)^0 ] gap> ConvertToVectorRepNC(v,256); 256 gap> RepresentationsOfObject(v); [ "IsDataObjectRep", "Is8BitVectorRep" ] gap> R:=PolynomialRing( GF(2^8) ); GF(2^8)[x_1] gap> x := Indeterminate(GF(2^8)); x_1 gap> f := x^2+Z(2^4)^6*x+Z(2^4)^3; x_1^2+Z(2^4)^6*x_1+Z(2^4)^3 gap> Length( FactorsSquarefree( R, f, rec() ) ); 2 # 2013/03/12 (MH) gap> v:=IdentityMat(28,GF(2))[1]; gap> v{[1..Length(v)]}{[1..5]}; Error, List Elements: must be a list (not a object (data)) ## For new features # 2013/02/27 (AK) gap> F := FreeGroup("a","b");; gap> G := F/[F.1*F.2*F.1*F.2*F.1];; gap> IsAbelian(G); true gap> DerivedSubgroup(G); Group([ ]) # 2013/02/28 (MH) gap> NullMat(2,1,ZmodnZObj(1,15)); [ [ ZmodnZObj( 0, 15 ) ], [ ZmodnZObj( 0, 15 ) ] ] gap> IdentityMat(10,Z(4)); < mutable compressed matrix 10x10 over GF(4) > ############################################################################# ## ## Changes 4.6.3 -> 4.6.4 ## For bugfixes # 2013/03/27 (AK) gap> im := [ [ [E(3)^2,0], [0,E(3)] ], [ [0,E(3)], [E(3)^2,0] ] ];; gap> hom := GroupHomomorphismByImages( SymmetricGroup(3), Group(im), im );; gap> NaturalCharacter(hom); Character( CharacterTable( Sym( [ 1 .. 3 ] ) ), [ 2, 0, -1 ] ) # 2013/04/01 (MN) gap> slp := StraightLineProgram( > [ [ 1, -1 ], [ 2, -1 ], [ 3, -1 ], [ 4, -1 ], [ 5, -1 ], [ 4, 1, 10, 1 ], > [ 11, -1 ], [ 1, 0 ], [ 1, 0 ], [ 1, 0 ], [ 1, 0 ], [ 1, 0 ], [ 1, 0 ], > [ 1, 0 ], [ 1, 0 ], [ 1, 0 ], [ 8, 0, 10, 1, 8, 0, 5, 1 ], > [ 22, 1, 1, 1, 7, 1, 6, 1, 22, -1 ], [ 1, 0 ], [ 1, 0 ], [ 1, 0 ], > [ 23, 1 ], [ 27, 4 ], [ 28, 1, 13, 1 ], [ 27, 1 ] ],5);; gap> SlotUsagePattern(slp);; ############################################################################# ## ## Changes 4.6.4 -> 4.6.5 ## For bugfixes # 2013/05/02 (BH) gap> a := IntHexString("0000000000000000000000"); 0 gap> a = 0; true gap> IsSmallIntRep(a); true gap> a := IntHexString("0000000000000000000001"); 1 gap> a = 1; true gap> IsSmallIntRep(a); true # 2013/05/16 (AH) gap> TransitiveIdentification(TransitiveGroup(30,4064)^(1,4,5,2) > (6,20,15,21,7,16,12,24)(8,18,14,22,10,17,13,23,9,19,11,25)(26,30,29,28)); 4064 ############################################################################# # # Tests requiring loading some packages must be performed at the end. # Do not put tests that do not need any packages below this line. # ############################################################################# # # Tests requiring TomLib ## bug 2 for fix 6 gap> if LoadPackage("tomlib", false) <> fail then > DerivedSubgroupsTom( TableOfMarks( "A10" ) ); > fi; ############################################################################# # # Tests requiring CTblLib # 2005/08/29 (TB) gap> LoadPackage("ctbllib", "=0.0"); fail ## Bug 18 for fix 4 gap> if LoadPackage("ctbllib", false) <> fail then > if Irr( CharacterTable( "WeylD", 4 ) )[1] <> > [ 3, -1, 3, -1, 1, -1, 3, -1, -1, 0, 0, -1, 1 ] then > Print( "problem with Irr( CharacterTable( \"WeylD\", 4 ) )[1]\n" ); > fi; > fi; # 2005/08/23 (TB) gap> tbl:= CharacterTable( ElementaryAbelianGroup( 4 ) );; gap> IsElementaryAbelian( tbl ); true gap> ClassPositionsOfMinimalNormalSubgroups( tbl ); [ [ 1, 2 ], [ 1, 3 ], [ 1, 4 ] ] gap> if LoadPackage("ctbllib", false) <> fail then > tbl:= CharacterTableIsoclinic( CharacterTable( "2.A5.2" ) ); > if tbl mod 3 = fail then > Error( CharacterTable( "Isoclinic(2.A5.2)" ), " mod 3" ); > fi; > SourceOfIsoclinicTable( tbl ); > fi; gap> tbl:= CharacterTable( Group( () ) );; gap> ClassPositionsOfElementaryAbelianSeries( tbl );; # 2005/10/29 (TB) gap> if LoadPackage("ctbllib", false) <> fail then > t:= CharacterTable( "S12(2)" ); p:= PrevPrimeInt( Exponent( t ) ); > if not IsSmallIntRep( p ) then > PowerMap( t, p ); > fi; > fi; # 2005/12/08 (TB) gap> if LoadPackage("ctbllib", false) <> fail then > if List( Filtered( Irr( CharacterTable( "Sz(8).3" ) mod 3 ), > x -> x[1] = 14 ), ValuesOfClassFunction ) > <> [ [ 14, -2, 2*E(4), -2*E(4), -1, 0, 1 ], > [ 14, -2, -2*E(4), 2*E(4), -1, 0, 1 ] ] then > Print( "ordering problem in table of Sz(8).3 mod 3\n" ); > fi; > fi; # 2005/12/08 (TB) gap> LoadPackage("ctbllib", false);; gap> t:= CharacterTable( SymmetricGroup( 4 ) );; gap> SetIdentifier( t, "Sym(4)" ); Display( t, > rec( powermap:= "ATLAS", centralizers:= "ATLAS", chars:= false ) ); Sym(4) 24 4 8 3 4 p A A A B p' A A A A 1A 2A 2B 3A 4A ############################################################################# # # Tests requiring Crisp # 2005/05/03 (BH) gap> if LoadPackage("crisp", false) <> fail then > F:=FreeGroup("a","b","c");; > a:=F.1;;b:=F.2;;c:=F.3;; > G:=F/[a^12,b^2*a^6,c^2*a^6,b^-1*a*b*a,c^-1*a*c*a^-7,c^-1*b*c*a^-9*b^-1];; > pcgs := PcgsElementaryAbelianSeries (G);; > ser := ChiefSeries (G);; > if ForAny (ser, H -> ParentPcgs (InducedPcgs (pcgs, H)) > <> ParentPcgs (pcgs)) then > Print( "problem with crisp (1)\n" ); > fi; > if ForAny (ser, H -> ParentPcgs (InducedPcgsWrtHomePcgs (H)) > <> ParentPcgs(HomePcgs (H))) then > Print( "problem with crisp (2)\n" ); > fi; > if ForAny (ser, H -> ParentPcgs (InducedPcgsWrtHomePcgs (H)) > <> HomePcgs (H)) then > Print( "problem with crisp (3)\n" ); > fi; > G2:=Image(IsomorphismPermGroup(G)); > pcgs := PcgsElementaryAbelianSeries (G2); > ser := ChiefSeries (G2); > if ForAny (ser, H -> ParentPcgs (InducedPcgs (pcgs, H)) > <> pcgs) then > Print( "problem with crisp (4)\n" ); > fi; > if ForAny (ser, H -> ParentPcgs (InducedPcgsWrtHomePcgs (H)) > <> ParentPcgs(HomePcgs (H))) then > Print( "problem with crisp (5)\n" ); > fi; > if ForAny (ser, H -> ParentPcgs (InducedPcgsWrtHomePcgs (H)) > <> HomePcgs (H)) then > Print( "problem with crisp (6)\n" ); > fi; > fi; # 2005/06/23 (AH) gap> if LoadPackage("crisp", false) <> fail then > h:=Source(EpimorphismSchurCover(SmallGroup(64,150))); > NormalSubgroups( Centre( h ) ); > fi; # 2005/10/14 (BH) gap> if LoadPackage("crisp", "1.2.1", false) <> fail then > G := DirectProduct(CyclicGroup(2), CyclicGroup(3), SymmetricGroup(4)); > AllInvariantSubgroupsWithQProperty (G, G, ReturnTrue, ReturnTrue, rec()); > if ( (1, 5) in EnumeratorByPcgs ( Pcgs( SymmetricGroup (4) ) ) ) then > Print( "problem with crisp (7)\n" ); > fi; > fi; # 2012/06/18 (FL) gap> if LoadPackage("cvec",false) <> fail then mat := [[Z(2)]]; > ConvertToMatrixRep(mat,2); cmat := CMat(mat); cmat := cmat^1000; fi; # 2012/06/18 (MH) gap> if LoadPackage("anupq",false) <> fail then > for i in [1..192] do Q:=Pq( FreeGroup(2) : Prime:=3, ClassBound:=1 ); od; fi; ############################################################################# gap> STOP_TEST( "bugfix.tst", 15319000000*10 ); ############################################################################# ## #E gap-4r6p5/tst/mgmring.tst0000644000175000017500000000243112172557256014153 0ustar billbill############################################################################# ## #W mgmring.tst GAP library Thomas Breuer ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## To be listed in testinstall.g ## gap> START_TEST("mgmring.tst"); gap> r:= GF(3);; gap> m:= Group( (1,2,3), (1,2) );; gap> rm:= FreeMagmaRing( r, m ); gap> ElementOfMagmaRing( ElementsFamily( FamilyObj( rm ) ), 0*Z(3), > [ 0, 1, 1, 1, -1, 1, -1 ]*Z(3)^0, > [ (), (2,3), (1,2,3), (2,3), (1,2), (1,2), (1,3,2) ] ); (Z(3))*(2,3)+(Z(3)^0)*(1,2,3)+(Z(3))*(1,3,2) gap> IsGroupRing( rm ); true gap> centre:= Centre( rm ); gap> GeneratorsOfAlgebra( centre ); [ (Z(3)^0)*(), (Z(3)^0)*(), (Z(3)^0)*(2,3)+(Z(3)^0)*(1,2)+(Z(3)^0)*(1,3), (Z(3)^0)*(1,2,3)+(Z(3)^0)*(1,3,2) ] gap> membrm:= Embedding( m, rm );; gap> img:= Image( membrm, (1,2) ); (Z(3)^0)*(1,2) gap> PreImagesRepresentative( membrm, img ); (1,2) gap> rembrm:= Embedding( r, rm );; gap> img:= Image( rembrm, Z(3) ); (Z(3))*() gap> PreImagesRepresentative( rembrm, img ); Z(3) gap> STOP_TEST( "mgmring.tst", 1800000 ); ############################################################################# ## #E gap-4r6p5/tst/matblock.tst0000644000175000017500000000727012172557256014315 0ustar billbill############################################################################# ## #W matblock.tst GAP Library Thomas Breuer ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## Exclude from testinstall.g: why? ## gap> START_TEST("matblock.tst"); gap> m1 := BlockMatrix( [ [ 1, 1, [[1,1],[0,1]] ], > [ 1, 3, [[1,0],[0,1]] ], > [ 2, 2, [[0,1],[1,0]] ], > [ 3, 4, [[1,0],[0,0]] ] ], 3, 4 ); gap> m2 := BlockMatrix( [ [ 1, 3, [[1,0],[0,1]] ], > [ 2, 1, [[1,0],[0,1]] ], > [ 3, 2, [[1,0],[0,1]] ] ], 3, 3 ); gap> m3 := AsBlockMatrix( m2, 2, 2 ); gap> z := BlockMatrix( [], 3, 3, 2, 2, 0 ); gap> Length( m1 ); DimensionsMat( m1 ); 6 [ 6, 8 ] gap> Length( m2 ); DimensionsMat( m2 ); 6 [ 6, 6 ] gap> Length( m3 ); DimensionsMat( m3 ); 6 [ 6, 6 ] gap> Length( z ); DimensionsMat( z ); 6 [ 6, 6 ] gap> m1[3]; [ 0, 0, 0, 1, 0, 0, 0, 0 ] gap> z[2]; [ 0, 0, 0, 0, 0, 0 ] gap> m2 = m3; true gap> p1:= m2 * m1; gap> p2:= m3 * m1; [ [ 0, 0, 0, 0, 0, 0, 1, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 1, 0, 0, 1, 0, 0, 0 ], [ 0, 1, 0, 0, 0, 1, 0, 0 ], [ 0, 0, 0, 1, 0, 0, 0, 0 ], [ 0, 0, 1, 0, 0, 0, 0, 0 ] ] gap> p1 = p2; true gap> p3:= m1 * TransposedMat( m1 ); gap> mm:= MatrixByBlockMatrix( m1 ); [ [ 1, 1, 0, 0, 1, 0, 0, 0 ], [ 0, 1, 0, 0, 0, 1, 0, 0 ], [ 0, 0, 0, 1, 0, 0, 0, 0 ], [ 0, 0, 1, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 1, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0 ] ] gap> mm * TransposedMat( mm ) = p3; true gap> p4:= TransposedMat( m1 ) * m2; gap> p3 = p4; false gap> z = AsBlockMatrix( z, 2, 2 ); true gap> MatrixByBlockMatrix( m1 ); [ [ 1, 1, 0, 0, 1, 0, 0, 0 ], [ 0, 1, 0, 0, 0, 1, 0, 0 ], [ 0, 0, 0, 1, 0, 0, 0, 0 ], [ 0, 0, 1, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 1, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0 ] ] gap> MatrixByBlockMatrix( m2 ); [ [ 0, 0, 0, 0, 1, 0 ], [ 0, 0, 0, 0, 0, 1 ], [ 1, 0, 0, 0, 0, 0 ], [ 0, 1, 0, 0, 0, 0 ], [ 0, 0, 1, 0, 0, 0 ], [ 0, 0, 0, 1, 0, 0 ] ] gap> Print( m1 + m1, "\n" ); BlockMatrix( [ [ 1, 1, [ [ 2, 2 ], [ 0, 2 ] ] ], [ 1, 3, [ [ 2, 0 ], [ 0, 2 ] ] ], [ 2, 2, [ [ 0, 2 ], [ 2, 0 ] ] ], [ 3, 4, [ [ 2, 0 ], [ 0, 0 ] ] ] ],3,4,2,2,0 ) gap> m2 + m3; [ [ 0, 0, 0, 0, 2, 0 ], [ 0, 0, 0, 0, 0, 2 ], [ 2, 0, 0, 0, 0, 0 ], [ 0, 2, 0, 0, 0, 0 ], [ 0, 0, 2, 0, 0, 0 ], [ 0, 0, 0, 2, 0, 0 ] ] gap> Print( AdditiveInverse( m3 ), "\n" ); BlockMatrix( [ [ 1, 1, [ [ 0, 0, 0 ], [ 0, 0, 0 ], [ -1, 0, 0 ] ] ], [ 1, 2, [ [ 0, -1, 0 ], [ 0, 0, -1 ], [ 0, 0, 0 ] ] ], [ 2, 1, [ [ 0, -1, 0 ], [ 0, 0, -1 ], [ 0, 0, 0 ] ] ], [ 2, 2, [ [ 0, 0, 0 ], [ 0, 0, 0 ], [ -1, 0, 0 ] ] ] ],2,2,3,3,0 ) gap> m1 * [ 1, 2, 3, 4, 5, 6, 7, 8 ]; [ 8, 8, 4, 3, 7, 0 ] gap> m2 * [ 1, 2, 3, 4, 5, 6 ]; [ 5, 6, 1, 2, 3, 4 ] gap> [ 1, 2, 3, 4, 5, 6 ] * m1; [ 1, 3, 4, 3, 1, 2, 5, 0 ] gap> z * [ 1, 2, 3, 4, 5, 6 ]; [ 0, 0, 0, 0, 0, 0 ] gap> [ 1, 2, 3, 4, 5, 6 ] * z; [ 0, 0, 0, 0, 0, 0 ] gap> 3 * m1; gap> Print( m2 * 5, "\n" ); BlockMatrix( [ [ 1, 3, [ [ 5, 0 ], [ 0, 5 ] ] ], [ 2, 1, [ [ 5, 0 ], [ 0, 5 ] ] ], [ 3, 2, [ [ 5, 0 ], [ 0, 5 ] ] ] ],3,3,2, 2,0 ) gap> o1:= One( m2 ); gap> o2:= One( z ); gap> o1 = o2; true gap> STOP_TEST( "matblock.tst", 700000 ); ############################################################################# ## #E gap-4r6p5/tst/modfree.tst0000644000175000017500000001246012172557256014137 0ustar billbill############################################################################# ## #W modfree.tst GAP library Thomas Breuer ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## To be listed in testinstall.g ## gap> START_TEST("modfree.tst"); gap> u:= LeftModuleByGenerators( GF(3), [ [ Z(3), 0*Z(3) ] ] ); gap> v:= LeftModuleByGenerators( GF(2), [ [ Z(2), Z(2) ], [ Z(4), Z(4) ] ] ); gap> w:= LeftModuleByGenerators( GF(4), [ [ Z(2), Z(2) ] ] ); gap> u = v; false gap> v = u; false gap> v = w; true gap> v1:= LeftModuleByGenerators( GF(2), [ [Z(2),0*Z(2)], [0*Z(2),Z(2)] ] ); gap> v2:= LeftModuleByGenerators( GF(2), [ [Z(2),Z(2)], [Z(2),0*Z(2)] ] ); gap> v1 = v2; true gap> v < w; false gap> w < v; false gap> w < v1; false gap> v2 < w; true gap> Zero( v ) in v; true gap> IsFiniteDimensional( v ); true gap> IsFiniteDimensional( Integers^3 ); true gap> IsFinite( v ); true gap> IsFinite( Integers^3 ); false gap> IsTrivial( v ); false gap> IsTrivial( TrivialSubspace( v ) ); true gap> Size( v ); 4 gap> Size( Integers^4 ); infinity gap> enum:= Enumerator( v ); > gap> len:= Length( enum ); 4 gap> l:= [];; gap> for i in [ 1 .. len ] do > l[i]:= enum[i]; > od; gap> Print(l,"\n"); [ [ 0*Z(2), 0*Z(2) ], [ Z(2^2), Z(2^2) ], [ Z(2)^0, Z(2)^0 ], [ Z(2^2)^2, Z(2^2)^2 ] ] gap> ForAll( [ 1 .. len ], i -> i = Position( enum, enum[i], 0 ) ); true gap> v:= LeftModuleByGenerators( GF(2), [ [ Z(2), Z(2) ], [ Z(4), Z(4) ] ] ); gap> Print(AsList( v ),"\n"); [ [ 0*Z(2), 0*Z(2) ], [ Z(2)^0, Z(2)^0 ], [ Z(2^2), Z(2^2) ], [ Z(2^2)^2, Z(2^2)^2 ] ] gap> Print(AsSSortedList( v ),"\n"); [ [ 0*Z(2), 0*Z(2) ], [ Z(2)^0, Z(2)^0 ], [ Z(2^2), Z(2^2) ], [ Z(2^2)^2, Z(2^2)^2 ] ] gap> IsSubset( v, w ); true gap> IsSubset( w, v ); true gap> IsSubset( v, v1 ); false gap> IsSubset( v, v2 ); false gap> IsSubset( v1, GF(2)^2 ); true gap> IsSubset( GF(2)^2, v1 ); true gap> IsSubset( w, GF(2)^2 ); false gap> IsSubset( GF(2)^2, w ); false gap> IsSubset( w, GF(4)^2 ); false gap> IsSubset( GF(4)^2, w ); true gap> Dimension( v ); 2 gap> Dimension( Integers^4 ); 4 gap> GeneratorsOfLeftModule( Rationals^2 ); [ [ 1, 0 ], [ 0, 1 ] ] gap> enum:= Enumerator( v );; gap> Print(enum,"\n"); [ [ 0*Z(2), 0*Z(2) ], [ Z(2)^0, Z(2)^0 ], [ Z(2^2), Z(2^2) ], [ Z(2^2)^2, Z(2^2)^2 ] ] gap> iter:= Iterator( v ); gap> l:= [];; gap> for i in [ 1 .. len ] do > l[i]:= NextIterator( iter ); > od; gap> IsDoneIterator( iter ); true gap> enum:= Enumerator( Integers^3 ); gap> l:= [];; gap> for i in [ 1000 .. 1100 ] do > Add( l, enum[i] ); > od; gap> Print(l{ [ 17 .. 25 ] },"\n"); [ [ -5, 3, 1 ], [ -5, -3, 1 ], [ -5, 4, 1 ], [ -5, -4, 1 ], [ -5, 5, 1 ], [ -5, 0, -1 ], [ -5, 1, -1 ], [ -5, -1, -1 ], [ -5, 2, -1 ] ] gap> ForAll( [ 1 .. 1000 ], i -> i = Position( enum, enum[i], 0 ) ); true gap> iter:= Iterator( Integers^3 ); gap> NextIterator( iter ); [ 0, 0, 0 ] gap> NextIterator( iter ); [ 1, 0, 0 ] gap> NextIterator( iter ); [ 0, 1, 0 ] gap> for i in [ 1 .. 1000 ] do > NextIterator( iter ); > od; gap> l:= [];; gap> for i in [ 1 .. 10 ] do > l[i]:= NextIterator( iter ); > od; gap> Print(l,"\n"); [ [ -5, 2, 0 ], [ -5, -2, 0 ], [ -5, 3, 0 ], [ -5, -3, 0 ], [ -5, 4, 0 ], [ -5, -4, 0 ], [ -5, 5, 0 ], [ -5, 0, 1 ], [ -5, 1, 1 ], [ -5, -1, 1 ] ] gap> IsDoneIterator( iter ); false gap> v:= LeftModuleByGenerators( GF(2), [ [ Z(2), Z(2) ], [ Z(4), Z(4) ] ] ); gap> c:= ClosureLeftModule( v, [ 0*Z(2), Z(2) ] ); gap> c:= ClosureLeftModule( c, [ Z(4), 0*Z(2) ] ); gap> Dimension( c ); 4 gap> FreeLeftModule( Integers, [ [ 1, 0 ], [ 1, 1 ] ] ); gap> f:= FreeLeftModule( Integers, [ [ 1, 0 ], [ 1, 1 ] ], "basis" ); gap> FreeLeftModule( Integers, [ [ 1, 0 ], [ 1, 1 ] ], [ 0, 0 ] ); gap> FreeLeftModule( Integers, [ [ 1, 0 ], [ 1, 1 ] ], [ 0, 0 ], "basis" ); gap> IsRowModule( f ); true gap> IsFullRowModule( f ); true gap> FullRowModule( Integers, 27 ); ( Integers^27 ) gap> f:= FullRowModule( GF(27), 27 ); ( GF(3^3)^27 ) gap> GF(27)^27 = f; true gap> Dimension( f ); 27 gap> v:= Integers^4; ( Integers^4 ) gap> GeneratorsOfLeftModule( v ); [ [ 1, 0, 0, 0 ], [ 0, 1, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 0, 0, 1 ] ] gap> [ 1, 2, 3, 4 ] in v; true gap> [ 1, 2, 3, 4 ] / 2 in v; false gap> [ 1, 2, 3, 4 ] / 2 in Rationals^4; true gap> c:= CanonicalBasis( v ); CanonicalBasis( ( Integers^4 ) ) gap> BasisVectors( c ); [ [ 1, 0, 0, 0 ], [ 0, 1, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 0, 0, 1 ] ] gap> Coefficients( c, [ 1, 2, 3, 4 ] ); [ 1, 2, 3, 4 ] gap> Basis( Integers^2 ); CanonicalBasis( ( Integers^2 ) ) gap> STOP_TEST( "modfree.tst", 5800000 ); ############################################################################# ## #E gap-4r6p5/tst/remake.sh0000755000175000017500000000105612172557256013564 0ustar billbill#! /bin/sh input0=/tmp/gapinput0.$$ input=/tmp/gapinput.$$ logfile=/tmp/gaplog.$$ prelogfile=/tmp/gapprelog.$$ sedscript=/tmp/sedfile.$$ cat > $sedscript < / !d s/^\(gap\)\?> // EOF sed -f $sedscript < $1 > $input0 cat - $input0 > $input < $input0 < /dev/null cat > $sedscript < #/#/ s/^gap> \+$// /^GAP4stones: / d /^gap> LogTo();/ d EOF sed -f $sedscript < $prelogfile > $logfile echo result in $logfile gap-4r6p5/tst/algsc.tst0000644000175000017500000007026712172557256013620 0ustar billbill############################################################################# ## #W algsc.tst GAP library Thomas Breuer ## ## #Y Copyright 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## To be listed in testinstall.g ## gap> START_TEST("algsc.tst"); ############################################################################# ## ## Expl. 0: Quaternion algebra ## gap> T0 := [ > [[[1],[1]],[[2],[ 1]],[[3],[ 1]],[[4],[ 1]]], > [[[2],[1]],[[1],[-1]],[[4],[ 1]],[[3],[-1]]], > [[[3],[1]],[[4],[-1]],[[1],[-1]],[[2],[ 1]]], > [[[4],[1]],[[3],[ 1]],[[2],[-1]],[[1],[-1]]], > 0, 0 ];; gap> id:= IdentityFromSCTable( T0 ); [ 1, 0, 0, 0 ] gap> v:= [ 0, 1, 1, 1 ];; gap> v = QuotientFromSCTable( T0, v, id ); true gap> q:= QuotientFromSCTable( T0, id, v ); [ 0, -1/3, -1/3, -1/3 ] gap> v = QuotientFromSCTable( T0, id, q ); true gap> a:= AlgebraByStructureConstants( Rationals, T0 ); gap> Dimension( a ); 4 gap> v:= ObjByExtRep( ElementsFamily( FamilyObj( a ) ), [ 0, 1, 0, 1 ] ); v.2+v.4 gap> One( v ); v^0; v.1 v.1 gap> Zero( v ); 0*v; 0*v.1 0*v.1 gap> Inverse( v ); v^-1; (-1/2)*v.2+(-1/2)*v.4 (-1/2)*v.2+(-1/2)*v.4 gap> AdditiveInverse( v ); -v; (-1)*v.2+(-1)*v.4 (-1)*v.2+(-1)*v.4 gap> b:= Basis( a ); CanonicalBasis( ) gap> Coefficients( b, v ); [ 0, 1, 0, 1 ] gap> w:= LinearCombination( b, [ 1, 2, 3, 4 ] ); v.1+(2)*v.2+(3)*v.3+(4)*v.4 gap> v + w; v.1+(3)*v.2+(3)*v.3+(5)*v.4 gap> v * w; (-6)*v.1+(-2)*v.2+(-2)*v.3+(4)*v.4 gap> v = w; false gap> v < w; true gap> w < v; false gap> s:= Subalgebra( a, [ v, 0*v, v^0, w ] ); gap> Dimension( s ); 4 gap> v:= Subspace( a, [ v, 0*v, v^0, w ] ); gap> Dimension( v ); 3 ############################################################################# ## ## Expl. 1: $2.A6$, gen. by 20 quaternionic reflections over $H(\sqrt{3})$ ## gap> q:= QuaternionAlgebra( FieldByGenerators( Rationals, [ Sqrt(3) ] ) ); gap> gens:= GeneratorsOfAlgebra( q ); [ e, i, j, k ] gap> z:= Zero( q );; gap> e:= gens[1];; i:= gens[2];; j:= gens[3];; k:= gens[4];; gap> theta:= Sqrt(3) * j; (-E(12)^7+E(12)^11)*j gap> w:= ( -e + theta ) / 2; (-1/2)*e+(-1/2*E(12)^7+1/2*E(12)^11)*j gap> vectors:= [ [ theta, z ], [ (i+e)*w, w ], [ w, (i-e)*w ] ];; gap> gens:= List( vectors, x -> ReflectionMat( x, w ) );; gap> g:= GroupByGenerators( gens );; gap> orb:= Orbit( g, vectors[1] );; gap> permgrp:= Action( g, orb, OnRight );; gap> Size( permgrp ); 720 ############################################################################# ## ## Expl. 2: Poincare Lie algebra ## gap> T1:= EmptySCTable( 10, 0, "antisymmetric" );; gap> SetEntrySCTable( T1, 1, 3, [2,4] ); gap> SetEntrySCTable( T1, 1, 4, [-2,3] ); gap> SetEntrySCTable( T1, 1, 5, [-2,6] ); gap> SetEntrySCTable( T1, 1, 6, [2,5] ); gap> SetEntrySCTable( T1, 1, 8, [2,9] ); gap> SetEntrySCTable( T1, 1, 9, [-2,8] ); gap> SetEntrySCTable( T1, 2, 3, [2,3] ); gap> SetEntrySCTable( T1, 2, 4, [2,4] ); gap> SetEntrySCTable( T1, 2, 5, [-2,5] ); gap> SetEntrySCTable( T1, 2, 6, [-2,6] ); gap> SetEntrySCTable( T1, 2, 7, [2,7] ); gap> SetEntrySCTable( T1, 2, 10, [-2,10] ); gap> SetEntrySCTable( T1, 3, 5, [1,2] ); gap> SetEntrySCTable( T1, 3, 6, [1,1] ); gap> SetEntrySCTable( T1, 3, 9, [2,7] ); gap> SetEntrySCTable( T1, 3, 10, [1,9] ); gap> SetEntrySCTable( T1, 4, 5, [1,1] ); gap> SetEntrySCTable( T1, 4, 6, [-1,2] ); gap> SetEntrySCTable( T1, 4, 8, [-2,7] ); gap> SetEntrySCTable( T1, 4, 10, [-1,8] ); gap> SetEntrySCTable( T1, 5, 7, [1,9] ); gap> SetEntrySCTable( T1, 5, 9, [2,10] ); gap> SetEntrySCTable( T1, 6, 7, [1,8] ); gap> SetEntrySCTable( T1, 6, 8, [2,10] ); gap> IdentityFromSCTable( T1 ); fail gap> l1:= AlgebraByStructureConstants( Rationals, T1 ); gap> IsLieAlgebra( l1 ); true gap> IsCommutative( l1 ); false gap> IsAssociative( l1 ); false gap> Dimension( l1 ); 10 gap> ucs:= LieUpperCentralSeries( l1 ); [ ] gap> lcs:= LieLowerCentralSeries( l1 ); [ ] gap> IsLieSolvable( l1 ); false gap> IsLieNilpotent( l1 ); false gap> IsLieAbelian( l1 ); false gap> c:= LieCentre( l1 ); gap> gens:= GeneratorsOfAlgebra( l1 ); [ v.1, v.2, v.3, v.4, v.5, v.6, v.7, v.8, v.9, v.10 ] gap> s1:= Subalgebra( l1, [ gens[1] ] ); gap> Dimension( s1 ); 1 gap> IsLieSolvable( s1 ); true gap> IsLieNilpotent( s1 ); true gap> IsLieAbelian( s1 ); true gap> LieCentre( s1 ); , (dimension 1 )> gap> LieCentralizer( l1, s1 ); gap> ps:= ProductSpace( l1, s1 ); gap> LieCentralizer( l1, ps ); gap> LieNormalizer( l1, ps ); # use AsAlgebra etc. gap> KappaPerp( l1, ps ); gap> b:= Basis( l1 ); CanonicalBasis( ) gap> Print(AdjointMatrix( b, gens[1] ),"\n"); [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, -2, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 2, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 2, 0, 0, 0, 0 ], [ 0, 0, 0, 0, -2, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, -2, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 2, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ] gap> der:= Derivations( b ); gap> IsLieAlgebra( der ); true gap> IsMatrixSpace( der ); true gap> Dimension( der ); 11 gap> Print(KillingMatrix( b ),"\n"); [ [ -24, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 24, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 12, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, -12, 0, 0, 0, 0 ], [ 0, 0, 12, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, -12, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ] gap> IsNilpotentElement( l1, gens[1] ); false gap> IsNilpotentElement( s1, Random( s1 ) ); true gap> IsRestrictedLieAlgebra( l1 ); false # PthPowerImages( l1 ); gap> NonNilpotentElement( l1 ); v.1 gap> Print(AdjointBasis( b ),"\n"); Basis( VectorSpace( Rationals, [ [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, -2, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 2, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 2, 0, 0, 0, 0 ], [ 0, 0, 0, 0, -2, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, -2, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 2, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ], [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 2, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 2, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, -2, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, -2, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 2, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, -2 ] ], [ [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ], [ 0, -2, 0, 0, 0, 0, 0, 0, 0, 0 ], [ -2, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 2, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ], [ [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, -1, 0, 0, 0, 0 ], [ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, -2, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, -2, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, -1 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ], [ [ 0, 0, 0, -1, 0, 0, 0, 0, 0, 0 ], [ 0, 0, -1, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 2, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 2, 0 ] ], [ [ 0, 0, -1, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ -2, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 2, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 2, 0, 0 ] ], [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, -2, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, -1, 0, 0, 0, 0 ], [ 0, 0, 0, 0, -1, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ], [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 2, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ -2, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, -2, 0, 0, 0, 0 ] ], [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, -2, 0, 0, 0, 0, 0, 0, 0 ], [ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, -2, 0, 0, 0, 0, 0 ] ], [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ], [ 0, 0, -1, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 2, 0, 0, 0, 0, 0, 0, 0, 0 ] ] ] ), [ [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, -2, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 2, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 2, 0, 0, 0, 0 ], [ 0, 0, 0, 0, -2, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, -2, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 2, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ], [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 2, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 2, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, -2, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, -2, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 2, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, -2 ] ], [ [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ], [ 0, -2, 0, 0, 0, 0, 0, 0, 0, 0 ], [ -2, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 2, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ], [ [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, -1, 0, 0, 0, 0 ], [ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, -2, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, -2, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, -1 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ], [ [ 0, 0, 0, -1, 0, 0, 0, 0, 0, 0 ], [ 0, 0, -1, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 2, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 2, 0 ] ], [ [ 0, 0, -1, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ -2, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 2, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 2, 0, 0 ] ], [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, -2, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, -1, 0, 0, 0, 0 ], [ 0, 0, 0, 0, -1, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ], [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 2, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ -2, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, -2, 0, 0, 0, 0 ] ], [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, -2, 0, 0, 0, 0, 0, 0, 0 ], [ 2, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, -2, 0, 0, 0, 0, 0 ] ], [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 ], [ 0, 0, -1, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 2, 0, 0, 0, 0, 0, 0, 0, 0 ] ] ] ) ############################################################################# ## ## Expl. 3: Second example of Willem de Graaf ## gap> T2:= EmptySCTable( 15, 0, "antisymmetric" );; gap> SetEntrySCTable( T2, 1, 2, [-1,5] ); gap> SetEntrySCTable( T2, 1, 4, [-1,6] ); gap> SetEntrySCTable( T2, 1, 5, [-2,1] ); gap> SetEntrySCTable( T2, 1, 6, [-6,1] ); gap> SetEntrySCTable( T2, 1, 7, [-1,9] ); gap> SetEntrySCTable( T2, 1, 8, [-1,10] ); gap> SetEntrySCTable( T2, 1, 11, [3,5,1,6] ); gap> SetEntrySCTable( T2, 1, 12, [-1,13] ); gap> SetEntrySCTable( T2, 1, 13, [8,1] ); gap> SetEntrySCTable( T2, 1, 14, [4,1,1,10] ); gap> SetEntrySCTable( T2, 1, 15, [-3,9,1,10] ); gap> SetEntrySCTable( T2, 2, 3, [-1,7] ); gap> SetEntrySCTable( T2, 2, 5, [2,2] ); gap> SetEntrySCTable( T2, 2, 6, [-1,11] ); gap> SetEntrySCTable( T2, 2, 7, [-2,2] ); gap> SetEntrySCTable( T2, 2, 8, [-1,12] ); gap> SetEntrySCTable( T2, 2, 9, [-1,5,1,7] ); gap> SetEntrySCTable( T2, 2, 10, [-1,14] ); gap> SetEntrySCTable( T2, 2, 13, [-4,2,1,12] ); gap> SetEntrySCTable( T2, 2, 14, [-8,2] ); gap> SetEntrySCTable( T2, 2, 15, [-4,2,1,11] ); gap> SetEntrySCTable( T2, 3, 4, [-1,8] ); gap> SetEntrySCTable( T2, 3, 5, [1,9] ); gap> SetEntrySCTable( T2, 3, 6, [-1,10] ); gap> SetEntrySCTable( T2, 3, 7, [2,3] ); gap> SetEntrySCTable( T2, 3, 8, [-2,3] ); gap> SetEntrySCTable( T2, 3, 11, [1,5,1,6,-3,7,1,8,1,13] ); gap> SetEntrySCTable( T2, 3, 12, [-1,7,1,8] ); gap> SetEntrySCTable( T2, 3, 13, [-1,9,1,10] ); gap> SetEntrySCTable( T2, 3, 14, [4,3,1,10] ); gap> SetEntrySCTable( T2, 3, 15, [8,3] ); gap> SetEntrySCTable( T2, 4, 5, [-1,11] ); gap> SetEntrySCTable( T2, 4, 6, [6,4] ); gap> SetEntrySCTable( T2, 4, 7, [1,12] ); gap> SetEntrySCTable( T2, 4, 8, [2,4] ); gap> SetEntrySCTable( T2, 4, 9, [-1,5,-1,6,3,7,-1,8,-1,14] ); gap> SetEntrySCTable( T2, 4, 10, [1,6,3,8] ); gap> SetEntrySCTable( T2, 4, 13, [-4,4,3,12] ); gap> SetEntrySCTable( T2, 4, 14, [1,11,3,12] ); gap> SetEntrySCTable( T2, 4, 15, [-4,4,1,11] ); gap> SetEntrySCTable( T2, 5, 6, [-3,5,1,6] ); gap> SetEntrySCTable( T2, 5, 7, [-1,5,-1,7] ); gap> SetEntrySCTable( T2, 5, 8, [-1,13,1,14] ); gap> SetEntrySCTable( T2, 5, 9, [-2,1,1,9] ); gap> SetEntrySCTable( T2, 5, 10, [4,1,1,10] ); gap> SetEntrySCTable( T2, 5, 11, [6,2,-1,11] ); gap> SetEntrySCTable( T2, 5, 12, [4,2,-1,12] ); gap> SetEntrySCTable( T2, 5, 13, [4,5,1,13] ); gap> SetEntrySCTable( T2, 5, 14, [-4,5,-1,14] ); gap> SetEntrySCTable( T2, 5, 15, [-4,5,-1,6,-3,7,-1,14] ); gap> SetEntrySCTable( T2, 6, 7, [1,5,1,6,-3,7,1,8,1,13,1,14] ); gap> SetEntrySCTable( T2, 6, 8, [1,6,-3,8] ); gap> SetEntrySCTable( T2, 6, 9, [-4,1,3,9] ); gap> SetEntrySCTable( T2, 6, 10, [6,1,3,10] ); gap> SetEntrySCTable( T2, 6, 11, [6,4,-3,11] ); gap> SetEntrySCTable( T2, 6, 12, [4,4,-3,12] ); gap> SetEntrySCTable( T2, 6, 13, [4,6,3,13] ); gap> SetEntrySCTable( T2, 6, 14, [-3,5,4,6,3,8,3,13] ); gap> SetEntrySCTable( T2, 6, 15, [-1,6,-9,7,6,8,3,14] ); gap> SetEntrySCTable( T2, 7, 8, [-1,7,-1,8] ); gap> SetEntrySCTable( T2, 7, 9, [2,3,-1,9] ); gap> SetEntrySCTable( T2, 7, 10, [-4,3,-1,10] ); gap> SetEntrySCTable( T2, 7, 11, [-4,2,1,11] ); gap> SetEntrySCTable( T2, 7, 12, [-2,2,1,12] ); gap> SetEntrySCTable( T2, 7, 13, [-1,5,-4,7,1,8,1,14] ); gap> SetEntrySCTable( T2, 7, 14, [-4,7,1,14] ); gap> SetEntrySCTable( T2, 7, 15, [1,5,1,6,1,7,1,8,1,13] ); gap> SetEntrySCTable( T2, 8, 9, [-4,3,1,9] ); gap> SetEntrySCTable( T2, 8, 10, [6,3,1,10] ); gap> SetEntrySCTable( T2, 8, 11, [4,4,-1,11] ); gap> SetEntrySCTable( T2, 8, 12, [2,4,-1,12] ); gap> SetEntrySCTable( T2, 8, 13, [1,5,2,6,-3,8,1,14] ); gap> SetEntrySCTable( T2, 8, 14, [-1,5,6,7,3,8,-1,13] ); gap> SetEntrySCTable( T2, 8, 15, [-1,5,-1,6,3,7,3,8,-1,13] ); gap> SetEntrySCTable( T2, 9, 11, [-5,5,-2,6,6,7,-1,8,-1,13,-1,14] ); gap> SetEntrySCTable( T2, 9, 12, [-1,5,4,7,-1,8,1,13,-1,14] ); gap> SetEntrySCTable( T2, 9, 13, [-6,1,4,9] ); gap> SetEntrySCTable( T2, 9, 14, [-4,1,-4,3,-2,10] ); gap> SetEntrySCTable( T2, 9, 15, [-10,3,4,9] ); gap> SetEntrySCTable( T2, 10, 11, [3,5,4,6,3,8,3,13,-3,14] ); gap> SetEntrySCTable( T2, 10, 12, [-1,5,3,8,-1,13,-1,14] ); gap> SetEntrySCTable( T2, 10, 13, [10,1,4,10] ); gap> SetEntrySCTable( T2, 10, 14, [6,1,6,3,6,9,8,10] ); gap> SetEntrySCTable( T2, 10, 15, [18,3,4,10] ); gap> SetEntrySCTable( T2, 11, 13, [12,2,4,4,-6,12] ); gap> SetEntrySCTable( T2, 11, 14, [18,2,-4,11] ); gap> SetEntrySCTable( T2, 11, 15, [6,2,6,4,-8,11,6,12] ); gap> SetEntrySCTable( T2, 12, 13, [6,2,2,4,2,11,-8,12] ); gap> SetEntrySCTable( T2, 12, 14, [10,2,-4,12] ); gap> SetEntrySCTable( T2, 12, 15, [4,2,4,4,-2,11] ); gap> SetEntrySCTable( T2, 13, 14, [11,5,-3,8,1,13,1,14] ); gap> SetEntrySCTable( T2, 13, 15, [8,5,6,6,12,7,-6,8,4,13,-2,14] ); gap> SetEntrySCTable( T2, 14, 15, [3,5,4,6,18,7,3,8,3,13,-3,14] ); gap> l2:= AlgebraByStructureConstants( Rationals, T2 ); gap> IsLieAlgebra( l2 ); true gap> IsCommutative( l2 ); false gap> IsAssociative( l2 ); false gap> Dimension( l2 ); 15 gap> ucs:= LieUpperCentralSeries( l2 ); [ , (dimension 1)>, ] gap> lcs:= LieLowerCentralSeries( l2 ); [ , ] gap> IsLieSolvable( l2 ); false gap> IsLieNilpotent( l2 ); false gap> IsLieAbelian( l2 ); false gap> LieCentre( l2 ); , (dimension 1 )> gap> gens:= GeneratorsOfAlgebra( l2 );; gap> Print(gens,"\n"); [ v.1, v.2, v.3, v.4, v.5, v.6, v.7, v.8, v.9, v.10, v.11, v.12, v.13, v.14, v.15 ] gap> s2:= Subalgebra( l2, [ gens[1] ] ); gap> Dimension( s2 ); 1 gap> IsLieSolvable( s2 ); true gap> IsLieNilpotent( s2 ); true gap> IsLieAbelian( s2 ); true gap> LieCentre( s2 ); , (dimension 1 )> gap> LieCentralizer( l2, s2 ); gap> ps:= ProductSpace( l2, s2 ); gap> LieCentralizer( l2, ps ); gap> LieNormalizer( l2, ps ); gap> Print( KappaPerp( l2, ps ), "\n" ); VectorSpace( Rationals, [ v.1, v.3, (-3)*v.5+v.6, v.5+(3)*v.7+v.8, v.9, v.10, (3)*v.2+v.4+v.11, v.2+v.4+v.12, (4)*v.5+v.13, v.5+(-3)*v.7+v.14, (-1)*v.5+(-6)*v.7+v.15 ] ) gap> b:= Basis( l2 ); CanonicalBasis( ) gap> Print(AdjointMatrix( b, gens[1] ),"\n"); [ [ 0, 0, 0, 0, -2, -6, 0, 0, 0, 0, 0, 0, 8, 4, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, -1, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0 ], [ 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, -3 ], [ 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, 0, 1, 1 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ] gap> der:= Derivations( b ); gap> IsLieAlgebra( der ); true gap> IsMatrixSpace( der ); true gap> Dimension( der ); 17 gap> Print(KillingMatrix( b ),"\n"); [ [ 0, -8, 0, -24, 0, 0, 0, 0, 0, 0, 48, 32, 0, 0, 0 ], [ -8, 0, -8, 0, 0, 0, 0, 0, 16, -32, 0, 0, 0, 0, 0 ], [ 0, -8, 0, -8, 0, 0, 0, 0, 0, 0, 32, 16, 0, 0, 0 ], [ -24, 0, -8, 0, 0, 0, 0, 0, 32, -48, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 16, 48, -16, 32, 0, 0, 0, 0, -64, -64, -80 ], [ 0, 0, 0, 0, 48, 144, -32, 48, 0, 0, 0, 0, -192, -144, -144 ], [ 0, 0, 0, 0, -16, -32, 16, -16, 0, 0, 0, 0, 48, 64, 64 ], [ 0, 0, 0, 0, 32, 48, -16, 16, 0, 0, 0, 0, -80, -80, -64 ], [ 0, 16, 0, 32, 0, 0, 0, 0, 0, 0, -80, -48, 0, 0, 0 ], [ 0, -32, 0, -48, 0, 0, 0, 0, 0, 0, 144, 80, 0, 0, 0 ], [ 48, 0, 32, 0, 0, 0, 0, 0, -80, 144, 0, 0, 0, 0, 0 ], [ 32, 0, 16, 0, 0, 0, 0, 0, -48, 80, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, -64, -192, 48, -80, 0, 0, 0, 0, 256, 208, 224 ], [ 0, 0, 0, 0, -64, -144, 64, -80, 0, 0, 0, 0, 208, 256, 272 ], [ 0, 0, 0, 0, -80, -144, 64, -64, 0, 0, 0, 0, 224, 272, 256 ] ] gap> IsNilpotentElement( l2, gens[1] ); true gap> IsNilpotentElement( s2, Random( s2 ) ); true gap> IsRestrictedLieAlgebra( l2 ); false gap> NonNilpotentElement( l2 ); v.5 ############################################################################# ## ## Expl. 4: Third example of Willem de Graaf (solvable Lie algebra) ## gap> T3:= EmptySCTable( 14, 0, "antisymmetric" );; gap> SetEntrySCTable( T3, 1, 5, [1,2] ); gap> SetEntrySCTable( T3, 1, 6, [1,3] ); gap> SetEntrySCTable( T3, 1, 7, [1,4] ); gap> SetEntrySCTable( T3, 1, 11, [-2,1] ); gap> SetEntrySCTable( T3, 1, 12, [-1,1] ); gap> SetEntrySCTable( T3, 1, 13, [-1,1] ); gap> SetEntrySCTable( T3, 1, 14, [-1,1] ); gap> SetEntrySCTable( T3, 2, 8, [1,3] ); gap> SetEntrySCTable( T3, 2, 9, [1,4] ); gap> SetEntrySCTable( T3, 2, 11, [-1,2] ); gap> SetEntrySCTable( T3, 2, 12, [-2,2] ); gap> SetEntrySCTable( T3, 2, 13, [-1,2] ); gap> SetEntrySCTable( T3, 2, 14, [-1,2] ); gap> SetEntrySCTable( T3, 3, 10, [1,4] ); gap> SetEntrySCTable( T3, 3, 11, [-1,3] ); gap> SetEntrySCTable( T3, 3, 12, [-1,3] ); gap> SetEntrySCTable( T3, 3, 13, [-2,3] ); gap> SetEntrySCTable( T3, 3, 14, [-1,3] ); gap> SetEntrySCTable( T3, 4, 11, [-1,4] ); gap> SetEntrySCTable( T3, 4, 12, [-1,4] ); gap> SetEntrySCTable( T3, 4, 13, [-1,4] ); gap> SetEntrySCTable( T3, 4, 14, [-2,4] ); gap> SetEntrySCTable( T3, 5, 8, [1,6] ); gap> SetEntrySCTable( T3, 5, 9, [1,7] ); gap> SetEntrySCTable( T3, 5, 11, [1,5] ); gap> SetEntrySCTable( T3, 5, 12, [-1,5] ); gap> SetEntrySCTable( T3, 6, 10, [1,7] ); gap> SetEntrySCTable( T3, 6, 11, [1,6] ); gap> SetEntrySCTable( T3, 6, 13, [-1,6] ); gap> SetEntrySCTable( T3, 7, 11, [1,7] ); gap> SetEntrySCTable( T3, 7, 14, [-1,7] ); gap> SetEntrySCTable( T3, 8, 10, [1,9] ); gap> SetEntrySCTable( T3, 8, 12, [1,8] ); gap> SetEntrySCTable( T3, 8, 13, [-1,8] ); gap> SetEntrySCTable( T3, 9, 12, [1,9] ); gap> SetEntrySCTable( T3, 9, 14, [-1,9] ); gap> SetEntrySCTable( T3, 10, 13, [1,10] ); gap> SetEntrySCTable( T3, 10, 14, [-1,10] ); gap> l3:= AlgebraByStructureConstants( Rationals, T3 ); gap> IsLieAlgebra( l3 ); true gap> IsCommutative( l3 ); false gap> IsAssociative( l3 ); false gap> Dimension( l3 ); 14 gap> ucs:= LieUpperCentralSeries( l3 ); [ ] gap> lcs:= LieLowerCentralSeries( l3 ); [ , ] gap> IsLieSolvable( l3 ); true gap> IsLieNilpotent( l3 ); false gap> IsLieAbelian( l3 ); false gap> LieCentre( l3 ); gap> gens:= GeneratorsOfAlgebra( l3 ); [ v.1, v.2, v.3, v.4, v.5, v.6, v.7, v.8, v.9, v.10, v.11, v.12, v.13, v.14 ] gap> s3:= Subalgebra( l3, [ gens[1] ] ); gap> Dimension( s3 ); 1 gap> IsLieSolvable( s3 ); true gap> IsLieNilpotent( s3 ); true gap> IsLieAbelian( s3 ); true gap> LieCentre( s3 ); , (dimension 1 )> gap> LieCentralizer( l3, s3 ); gap> ps:= ProductSpace( l3, s3 );; gap> Print( ps, "\n" ); VectorSpace( Rationals, [ v.2, v.3, v.4, v.1 ] ) gap> LieCentralizer( l3, ps ); gap> LieNormalizer( l3, ps ); gap> KappaPerp( l3, ps ); gap> b:= Basis( l3 ); CanonicalBasis( ) gap> Print(AdjointMatrix( b, gens[1] ),"\n"); [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -2, -1, -1, -1 ], [ 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] ] gap> der:= Derivations( b ); gap> IsLieAlgebra( der ); true gap> IsMatrixSpace( der ); true gap> Dimension( der ); 14 gap> Print(KillingMatrix( b ),"\n"); [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 5, 5, 5 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 10, 5, 5 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 10, 5 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 10 ] ] gap> IsNilpotentElement( l3, gens[1] ); true gap> IsNilpotentElement( s3, Random( s3 ) ); true gap> IsRestrictedLieAlgebra( l3 ); false gap> NonNilpotentElement( l3 ); v.11 ############################################################################# ## ## Expl. 5: Trivial s.c. algebra ## gap> t:= AlgebraByStructureConstants( Rationals, [ 0, 0 ] ); gap> z:= Zero( t ); gap> Random( t ); gap> b:=Basis( t ); CanonicalBasis( ) gap> coeff:= Coefficients( b, z ); gap> LinearCombination( b, coeff ); gap> LinearCombination( b, [] ); gap> c:= Centre( t ); gap> c = t; true ############################################################################# gap> STOP_TEST( "algsc.tst", 59000000 ); ############################################################################# ## #E gap-4r6p5/tst/vspchom.tst0000644000175000017500000003672412172557256014206 0ustar billbill############################################################################# ## #W vspchom.tst GAP library Thomas Breuer ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## To be listed in testinstall.g ## gap> START_TEST("vspchom.tst"); ############################################################################# ## ## tests for linear mappings given by images ## gap> f:= GF(3); GF(3) gap> v:= GF(27); GF(3^3) gap> w:= f^2; ( GF(3)^2 ) gap> map1:= LeftModuleGeneralMappingByImages( f, v, [ Z(3)^0 ], [ Z(27) ] ); [ Z(3)^0 ] -> [ Z(3^3) ] gap> ImagesSource( map1 ); gap> PreImagesRange( map1 ); gap> CoKernelOfAdditiveGeneralMapping( map1 ); gap> KernelOfAdditiveGeneralMapping( map1 ); gap> IsSingleValued( map1 ); true gap> IsInjective( map1 ); true gap> ImagesRepresentative( map1, 0*Z(3)^0 ); 0*Z(3) gap> ImagesRepresentative( map1, Z(3)^0 ); Z(3^3) gap> PreImagesRepresentative( map1, 0*Z(3) ); 0*Z(3) gap> PreImagesRepresentative( map1, Z(27) ); Z(3)^0 gap> 2 * map1 = - map1; true gap> Z(3) * map1 = - map1; true gap> map2:= LeftModuleGeneralMappingByImages( v, w, > CanonicalBasis( v ), > [ [ Z(3)^0, 0*Z(3)^0 ], [ Z(3)^0, Z(3)^0 ], [ 0*Z(3)^0, Z(3)^0 ] ] ); CanonicalBasis( GF(3^3) ) -> [ [ Z(3)^0, 0*Z(3) ], [ Z(3)^0, Z(3)^0 ], [ 0*Z(3), Z(3)^0 ] ] gap> ImagesSource( map2 ); gap> PreImagesRange( map2 ); GF(3^3) gap> CoKernelOfAdditiveGeneralMapping( map2 ); gap> KernelOfAdditiveGeneralMapping( map2 ); gap> IsSingleValued( map2 ); true gap> IsInjective( map2 ); false gap> ImagesRepresentative( map2, Z(27) ); [ Z(3)^0, Z(3)^0 ] gap> ImagesRepresentative( map2, Z(9) ); fail gap> PreImagesRepresentative( map2, [ Z(3)^0, Z(3)^0 ] ); Z(3^3) gap> PreImagesRepresentative( map2, [ 0*Z(3)^0, 0*Z(3)^0 ] ); 0*Z(3) gap> 2 * map2 = - map2; true gap> Z(3) * map2 = - map2; true gap> map3:= LeftModuleGeneralMappingByImages( w, v, > [ [ Z(3)^0, 0*Z(3)^0 ], [ Z(3)^0, Z(3)^0 ], [ 0*Z(3)^0, Z(3)^0 ] ], > CanonicalBasis( v ) ); [ [ Z(3)^0, 0*Z(3) ], [ Z(3)^0, Z(3)^0 ], [ 0*Z(3), Z(3)^0 ] ] -> CanonicalBasis( GF(3^3) ) gap> ImagesSource( map3 ); GF(3^3) gap> PreImagesRange( map3 ); gap> CoKernelOfAdditiveGeneralMapping( map3 ); gap> KernelOfAdditiveGeneralMapping( map3 ); gap> IsSingleValued( map3 ); false gap> IsInjective( map3 ); true gap> ImagesRepresentative( map3, [ Z(3)^0, 0*Z(3)^0 ] ); Z(3)^0 gap> ImagesRepresentative( map3, [ 0*Z(3)^0, Z(3)^0 ] ); Z(3^3)^3 gap> PreImagesRepresentative( map3, Z(27) ); [ Z(3)^0, Z(3)^0 ] gap> PreImagesRepresentative( map3, Z(3)^0 ); [ Z(3)^0, 0*Z(3) ] gap> 2 * map3 = - map3; true gap> Z(3) * map3 = - map3; true gap> comp1:= CompositionMapping( map3, map2 ); CompositionMapping( [ [ Z(3)^0, 0*Z(3) ], [ Z(3)^0, Z(3)^0 ], [ 0*Z(3), Z(3)^0 ] ] -> CanonicalBasis( GF(3^3) ), CanonicalBasis( GF(3^3) ) -> [ [ Z(3)^0, 0*Z(3) ], [ Z(3)^0, Z(3)^0 ], [ 0*Z(3), Z(3)^0 ] ] ) gap> IsInjective( comp1 ); false gap> IsSingleValued( comp1 ); false gap> IsSurjective( comp1 ); true gap> comp2:= CompositionMapping( map2, map3 ); CompositionMapping( CanonicalBasis( GF(3^3) ) -> [ [ Z(3)^0, 0*Z(3) ], [ Z(3)^0, Z(3)^0 ], [ 0*Z(3), Z(3)^0 ] ], [ [ Z(3)^0, 0*Z(3) ], [ Z(3)^0, Z(3)^0 ], [ 0*Z(3), Z(3)^0 ] ] -> CanonicalBasis( GF(3^3) ) ) gap> IsInjective( comp2 ); true gap> IsSingleValued( comp2 ); true gap> IsSurjective( comp2 ); true gap> comp3:= CompositionMapping( FrobeniusAutomorphism( v ), map1 ); [ Z(3)^0 ] -> [ Z(3^3)^3 ] gap> IsInjective( comp3 ); true gap> IsSingleValued( comp3 ); true gap> IsSurjective( comp3 ); false gap> 2 * comp3; [ Z(3)^0 ] -> [ Z(3^3)^16 ] gap> ImagesRepresentative( comp3, 0*Z(3)^0 ); 0*Z(3) gap> ImagesRepresentative( comp3, Z(3)^0 ); Z(3^3)^3 gap> sum:= map1 + map1; [ Z(3)^0 ] -> [ Z(3^3)^14 ] gap> sum + map1 = ZeroMapping( f, v ); true gap> map4:= LeftModuleGeneralMappingByImages( v, v, CanonicalBasis( v ), > [ Z(27)^8, Z(3), Z(27) ] ); CanonicalBasis( GF(3^3) ) -> [ Z(3^3)^8, Z(3), Z(3^3) ] gap> map4 + IdentityMapping( v ); CanonicalBasis( GF(3^3) ) -> [ Z(3^3)^15, Z(3^3)^3, Z(3^3)^10 ] gap> IdentityMapping( v ) + map4; CanonicalBasis( GF(3^3) ) -> [ Z(3^3)^15, Z(3^3)^3, Z(3^3)^10 ] # some tests involving zero mappings gap> m:= GroupRing( GF(3), CyclicGroup( 2 ) );; gap> t:= TrivialSubspace( m );; gap> bm:= BasisVectors( Basis( m ) );; gap> bt:= BasisVectors( Basis( t ) );; gap> funs:= [ IsInjective, IsSurjective, IsTotal, IsSingleValued ];; gap> map:= LeftModuleGeneralMappingByImages( m, m, bm, 0 * bm );; gap> List( funs, f -> f( map ) ); [ false, false, true, true ] gap> map:= LeftModuleGeneralMappingByImages( m, t, bm, 0 * bm );; gap> List( funs, f -> f( map ) ); [ false, true, true, true ] gap> map:= LeftModuleGeneralMappingByImages( t, t, bt, 0 * bt );; gap> List( funs, f -> f( map ) ); [ true, true, true, true ] gap> map:= LeftModuleGeneralMappingByImages( t, m, bt, 0 * bt );; gap> List( funs, f -> f( map ) ); [ true, false, true, true ] gap> map:= LeftModuleGeneralMappingByImages( m, m, 0 * bm, bm );; gap> List( funs, f -> f( map ) ); [ true, true, false, false ] gap> map:= LeftModuleGeneralMappingByImages( m, t, bt, 0 * bt );; gap> List( funs, f -> f( map ) ); [ true, true, false, true ] gap> map:= LeftModuleGeneralMappingByImages( t, m, 0 * bm, bm );; gap> List( funs, f -> f( map ) ); [ true, true, true, false ] ############################################################################# ## ## tests for linear mappings given by matrices ## (same tests as above, ## except those that would involve matrices with zero rows or columns) ## gap> bf:= CanonicalBasis( GF(3) ); CanonicalBasis( GF(3) ) gap> bv:= CanonicalBasis( GF(27) ); CanonicalBasis( GF(3^3) ) gap> bw:= CanonicalBasis( f^2 ); CanonicalBasis( ( GF(3)^2 ) ) gap> map5:= LeftModuleHomomorphismByMatrix( bf, > [ [ Z(3), Z(3), Z(3) ] ], bv ); GF(3^3)> gap> ImagesSource( map5 ); gap> PreImagesRange( map5 ); GF(3) gap> CoKernelOfAdditiveGeneralMapping( map5 ); gap> KernelOfAdditiveGeneralMapping( map5 ); gap> IsSingleValued( map5 ); true gap> IsInjective( map5 ); true gap> ImagesRepresentative( map5, 0*Z(3)^0 ); 0*Z(3) gap> ImagesRepresentative( map5, Z(3)^0 ); Z(3^3)^19 gap> PreImagesRepresentative( map5, 0*Z(3) ); 0*Z(3) gap> PreImagesRepresentative( map5, Z(27) ); fail gap> 2 * map5 = - map5; true gap> Z(3) * map5 = - map5; true gap> map6:= LeftModuleHomomorphismByMatrix( bv, > [ [ Z(3), Z(3) ], [ 0*Z(3), 0*Z(3) ], [ Z(3), 0*Z(3) ] ], > bw ); ( GF(3)^2 )> gap> ImagesSource( map6 ); gap> PreImagesRange( map6 ); GF(3^3) gap> CoKernelOfAdditiveGeneralMapping( map6 ); gap> KernelOfAdditiveGeneralMapping( map6 ); gap> IsSingleValued( map6 ); true gap> IsInjective( map6 ); false gap> ImagesRepresentative( map6, Z(27) ); [ 0*Z(3), 0*Z(3) ] gap> ImagesRepresentative( map6, Z(9) ); fail gap> PreImagesRepresentative( map6, [ Z(3)^0, Z(3)^0 ] ); Z(3) gap> PreImagesRepresentative( map6, [ 0*Z(3)^0, 0*Z(3)^0 ] ); 0*Z(3) gap> 2 * map6 = - map6; true gap> Z(3) * map6 = - map6; true gap> map7:= LeftModuleHomomorphismByMatrix( bw, > [ [ Z(3)^0, 0*Z(3)^0, Z(3)^0 ], [ Z(3)^0, 0*Z(3)^0, Z(3)^0 ] ], > bv ); GF(3^3)> gap> ImagesSource( map7 ); gap> PreImagesRange( map7 ); ( GF(3)^2 ) gap> CoKernelOfAdditiveGeneralMapping( map7 ); gap> KernelOfAdditiveGeneralMapping( map7 ); gap> IsSingleValued( map7 ); true gap> IsInjective( map7 ); false gap> ImagesRepresentative( map7, [ Z(3)^0, 0*Z(3)^0 ] ); Z(3^3)^21 gap> ImagesRepresentative( map7, [ 0*Z(3)^0, Z(3)^0 ] ); Z(3^3)^21 gap> PreImagesRepresentative( map7, Z(27) ); fail gap> PreImagesRepresentative( map7, Z(3)^0 ); fail gap> 2 * map7 = - map7; true gap> Z(3) * map7 = - map7; true gap> comp1:= CompositionMapping( map7, map6 ); GF(3^3)> gap> IsInjective( comp1 ); false gap> IsSingleValued( comp1 ); true gap> IsSurjective( comp1 ); false gap> comp2:= CompositionMapping( map6, map7 ); ( GF(3)^2 )> gap> IsInjective( comp2 ); false gap> IsSingleValued( comp2 ); true gap> IsSurjective( comp2 ); false gap> comp3:= CompositionMapping( FrobeniusAutomorphism( v ), map5 ); GF(3^3)> gap> IsInjective( comp3 ); true gap> IsSingleValued( comp3 ); true gap> IsSurjective( comp3 ); false gap> 2 * comp3; GF(3^3)> gap> ImagesRepresentative( comp3, 0*Z(3)^0 ); 0*Z(3) gap> ImagesRepresentative( comp3, Z(3)^0 ); Z(3^3)^5 gap> sum:= map1 + map1; [ Z(3)^0 ] -> [ Z(3^3)^14 ] gap> sum + map1 = ZeroMapping( f, v ); true gap> map8:= LeftModuleHomomorphismByMatrix( bv, > [ [ Z(3), Z(3), Z(3) ], > [ 0*Z(3), 0*Z(3), Z(3)^0 ], > [ Z(3), 0*Z(3), 0*Z(3) ] ], > bv ); GF(3^3)> gap> map8 + IdentityMapping( v ); GF(3^3)> gap> IdentityMapping( v ) + map8; GF(3^3)> ############################################################################# ## ## tests for mixed cases ## gap> map2 + map6; CanonicalBasis( GF(3^3) ) -> [ [ 0*Z(3), Z(3) ], [ Z(3)^0, Z(3)^0 ], [ Z(3), Z(3)^0 ] ] gap> map6 + map2; CanonicalBasis( GF(3^3) ) -> [ [ 0*Z(3), Z(3) ], [ Z(3)^0, Z(3)^0 ], [ Z(3), Z(3)^0 ] ] gap> # id:= IdentityMapping( v ); gap> # 2 * id; gap> # id + id; gap> # - id; gap> # zero:= ZeroMapping( v, v ); gap> # 2 * zero; gap> # zero + zero; gap> # id + zero; gap> # - zero; ############################################################################# ## ## tests for natural homomorphisms ## gap> NaturalHomomorphismBySubspace( v, TrivialSubspace( v ) ) > = IdentityMapping( v ); true gap> IsZero( NaturalHomomorphismBySubspace( v, v ) ); true gap> nathom:= NaturalHomomorphismBySubspace( w, > Subspace( w, [ [ Z(3), Z(3) ] ] ) ); ( GF(3)^1 )> gap> ImagesSource( nathom ); ( GF(3)^1 ) gap> PreImagesRange( nathom ); ( GF(3)^2 ) gap> CoKernelOfAdditiveGeneralMapping( nathom ); gap> KernelOfAdditiveGeneralMapping( nathom ); gap> IsInjective( nathom ); false gap> IsSingleValued( nathom ); true gap> IsSurjective( nathom ); true gap> IsTotal( nathom ); true gap> ImagesRepresentative( nathom, [ Z(3), Z(3)^0 ] ); [ Z(3)^0 ] gap> ImagesRepresentative( nathom, [ Z(3)^0, Z(3)^0 ] ); [ 0*Z(3) ] gap> PreImagesRepresentative( nathom, [ Z(3)^0 ] ); [ Z(3)^0, 0*Z(3) ] gap> PreImagesRepresentative( nathom, [ 0*Z(3) ] ); [ 0*Z(3), 0*Z(3) ] gap> 2 * nathom = - nathom; true gap> Z(3) * nathom = - nathom; true ############################################################################# ## ## tests for spaces of linear mappings ## gap> hom:= Hom( f, v, w ); Hom( GF(3), GF(3^3), ( GF(3)^2 ) ) gap> IsFullHomModule( hom ); true gap> Dimension( hom ); 6 gap> Random( hom ) in hom; true gap> map6 in hom; true gap> sub:= Subspace( hom, [ map6 ] ); gap> BasisVectors( Basis( sub ) ); [ ( GF(3)^2 )> ] gap> sub:= LeftModuleByGenerators( f, [ map6 ] ); gap> Dimension( sub ); 1 gap> zero:= ZeroMapping( v, w ); ZeroMapping( GF(3^3), ( GF(3)^2 ) ) gap> triv:= LeftModuleByGenerators( f, [], zero ); gap> IsSubset( hom, triv ); true gap> mb:= MutableBasis( f, [], zero ); gap> CloseMutableBasis( mb, map6 ); gap> ImmutableBasis( mb ); Basis( , ... ) ############################################################################# ## ## tests for algebras of linear mappings ## gap> endo:= End( f, v ); End( GF(3), GF(3^3) ) gap> id:= IdentityMapping( v ); IdentityMapping( GF(3^3) ) gap> zero:= ZeroMapping( v, v ); ZeroMapping( GF(3^3), GF(3^3) ) gap> id in endo; true gap> zero in endo; true gap> RingByGenerators( [ id ] ); gap> DefaultRingByGenerators( [ id ] ); gap> RingWithOneByGenerators( [ id ] ); gap> a:= AlgebraByGenerators( f, [], zero ); gap> Dimension( a ); 0 gap> a:= AlgebraByGenerators( f, [ id ] ); gap> Dimension( a ); 1 gap> a:= AlgebraWithOneByGenerators( f, [], zero ); gap> Dimension( a ); 1 gap> a:= AlgebraWithOneByGenerators( f, [ id ] ); gap> Dimension( a ); 1 gap> IsFullHomModule( a ); false gap> IsFullHomModule( endo ); true gap> Dimension( endo ); 9 gap> Random( endo ) in endo; true gap> GeneratorsOfLeftModule( endo ); [ GF(3^3)>, GF(3^3)>, GF(3^3)>, GF(3^3)>, GF(3^3)>, GF(3^3)>, GF(3^3)>, GF(3^3)>, GF(3^3)> ] gap> b:= Basis( endo ); Basis( End( GF(3), GF(3^3) ), [ GF(3^3)>, GF(3^3)>, GF(3^3)>, GF(3^3)>, GF(3^3)>, GF(3^3)>, GF(3^3)>, GF(3^3)>, GF(3^3)> ] ) gap> BasisVectors( b ); [ GF(3^3)>, GF(3^3)>, GF(3^3)>, GF(3^3)>, GF(3^3)>, GF(3^3)>, GF(3^3)>, GF(3^3)>, GF(3^3)> ] gap> Coefficients( b, id ); [ Z(3)^0, 0*Z(3), 0*Z(3), 0*Z(3), Z(3)^0, 0*Z(3), 0*Z(3), 0*Z(3), Z(3)^0 ] gap> map:= LeftModuleHomomorphismByMatrix( bv, 2 * IdentityMat( 3, f ), bv ); GF(3^3)> gap> Coefficients( b, map ); [ Z(3), 0*Z(3), 0*Z(3), 0*Z(3), Z(3), 0*Z(3), 0*Z(3), 0*Z(3), Z(3) ] gap> endoendo:= End( f, endo ); End( GF(3), End( GF(3), GF(3^3) ) ) gap> Dimension( endoendo ); 81 gap> STOP_TEST( "vspchom.tst", 10500000 ); ############################################################################# ## #E gap-4r6p5/tst/ctblmoli.tst0000644000175000017500000000266612172557256014332 0ustar billbill############################################################################# ## #W ctblmoli.tst GAP Library Thomas Breuer ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## To be listed in testinstall.g ## gap> START_TEST("ctblmoli.tst"); gap> G:= AlternatingGroup( 5 );; gap> psi:= First( Irr( G ), x -> Degree( x ) = 3 );; gap> molser:= MolienSeries( psi ); ( 1-z^2-z^3+z^6+z^7-z^9 ) / ( (1-z^5)*(1-z^3)*(1-z^2)^2 ) gap> List( [ 0 .. 20 ], i -> ValueMolienSeries( molser, i ) ); [ 1, 0, 1, 0, 1, 0, 2, 0, 2, 0, 3, 0, 4, 0, 4, 1, 5, 1, 6, 1, 7 ] gap> MolienSeriesWithGivenDenominator( molser, [ 2, 6, 10 ] ); ( 1+z^15 ) / ( (1-z^10)*(1-z^6)*(1-z^2) ) gap> y:= E(3);; x:= E(3)^2;; gap> G:= Group( > [ [ 0, y, 0, 0, 0, 0 ], > [ x, 0, 0, 0, 0, 0 ], > [ 0, 0, 1, 0, 0, 0 ], > [ 0, 0, 0, 1, 0, 0 ], > [ 0, 0, 0, 0, 1, 0 ], > [ 0, 0, 0, 0, 0, 1 ] ], > PermutationMat( (1,2), 6, Rationals ), > PermutationMat( (2,3), 6, Rationals ), > PermutationMat( (3,4), 6, Rationals ), > PermutationMat( (4,5), 6, Rationals ) );; gap> Size( G ); 9720 gap> MolienSeries( NaturalCharacter( G ) ); ( 1 ) / ( (1-z^12)*(1-z^9)*(1-z^6)*(1-z^5)*(1-z^3)*(1-z) ) gap> STOP_TEST( "ctblmoli.tst", 98500000 ); ############################################################################# ## #E gap-4r6p5/tst/grpfp.tst0000644000175000017500000000725612172557256013643 0ustar billbill############################################################################# ## #W grpfp.tst GAP library Thomas Breuer ## ## #Y Copyright 2005, Lehrstuhl D für Mathematik, RWTH Aachen, Germany ## ## To be listed in testinstall.g ## gap> START_TEST("grpfp.tst"); gap> f:= FreeGroup( "a", "b" );; a := f.1;; b := f.2;; gap> c2:= f / [ a*b*a^-2*b*a/b, (b^-1*a^3*b^-1*a^-3)^2*a ];; # Prescribe just the index. gap> iter:= LowIndexSubgroupsFpGroupIterator( c2, 11 );; gap> l:= [];; gap> while not IsDoneIterator( iter ) do > Add( l, NextIterator( iter ) ); > od; gap> Print( Collected( List( l, x -> Index( c2, x ) ) ), "\n" ); [ [ 1, 1 ], [ 11, 10 ] ] gap> Print( Collected( List( LowIndexSubgroupsFpGroup( c2, 11 ), > x -> Index( c2, x ) ) ), "\n" ); [ [ 1, 1 ], [ 11, 10 ] ] # Prescribe the index and a subgroup. gap> e:= GQuotients( c2, PSL(2,11) );; gap> e:= e[1];; gap> iter:= LowIndexSubgroupsFpGroupIterator( c2, Kernel( e ), 11 );; gap> l:= [];; gap> while not IsDoneIterator( iter ) do > Add( l, NextIterator( iter ) ); > od; gap> Print( Collected( List( l, x -> Index( c2, x ) ) ), "\n" ); [ [ 1, 1 ], [ 11, 2 ] ] gap> Print( Collected( List( LowIndexSubgroupsFpGroup( c2, Kernel( e ), 11 ), > x -> Index( c2, x ) ) ), "\n" ); [ [ 1, 1 ], [ 11, 2 ] ] # Prescribe the index and an exclusion list gap> iter:= LowIndexSubgroupsFpGroupIterator( c2, 11, [ b ] );; gap> l:= [];; gap> while not IsDoneIterator( iter ) do > Add( l, NextIterator( iter ) ); > od; gap> Length( l ); 4 gap> Length( LowIndexSubgroupsFpGroup( c2, 11, [ b ] ) ); 4 gap> iter:= LowIndexSubgroupsFpGroupIterator( c2, 11, [ a*b ] );; gap> l:= [];; gap> while not IsDoneIterator( iter ) do > Add( l, NextIterator( iter ) ); > od; gap> Length( l ); 2 gap> Length( LowIndexSubgroupsFpGroup( c2, 11, [ a*b ] ) ); 2 gap> iter:= LowIndexSubgroupsFpGroupIterator( c2, 11, [ b, a*b ] );; gap> l:= [];; gap> while not IsDoneIterator( iter ) do > Add( l, NextIterator( iter ) ); > od; gap> Length( l ); 0 gap> Length( LowIndexSubgroupsFpGroup( c2, 11, [ b, a*b ] ) ); 0 # Prescribe the index, a subgroup, and an exclusion list gap> iter:= LowIndexSubgroupsFpGroupIterator( c2, Kernel( e ), 11, [ a ] );; gap> l:= [];; gap> while not IsDoneIterator( iter ) do > Add( l, NextIterator( iter ) ); > od; gap> Length( l ); 2 gap> Length( LowIndexSubgroupsFpGroup( c2, Kernel( e ), 11, [ a ] ) ); 2 # Work in a subgroup of the whole group, prescribe just the index. gap> g:= PreImage( e, Stabilizer( Image(e), 1 ) );; gap> iter:= LowIndexSubgroupsFpGroupIterator( g, 5 );; gap> l:= [];; gap> while not IsDoneIterator( iter ) do > Add( l, NextIterator( iter ) ); > od; gap> Print( Collected( List( l, x -> Index( c2, x ) ) ), "\n" ); [ [ 12, 1 ], [ 24, 7 ], [ 36, 4 ], [ 48, 19 ], [ 60, 6 ] ] gap> Print( Collected( List( LowIndexSubgroupsFpGroup( g, 5 ), > x -> Index( c2, x ) ) ), "\n" ); [ [ 12, 1 ], [ 24, 7 ], [ 36, 4 ], [ 48, 19 ], [ 60, 6 ] ] # Work in a subgroup of the whole group, prescribe index and subgroup. gap> s:= l[25];; Index( g, s ); 4 gap> iter:= LowIndexSubgroupsFpGroupIterator( g, s, 5 );; gap> l:= [];; gap> while not IsDoneIterator( iter ) do > Add( l, NextIterator( iter ) ); > od; gap> Print( Collected( List( l, x -> Index( c2, x ) ) ), "\n" ); [ [ 12, 1 ], [ 24, 1 ], [ 48, 1 ] ] gap> Print( Collected( List( LowIndexSubgroupsFpGroup( g, s, 5 ), > x -> Index( c2, x ) ) ), "\n" ); [ [ 12, 1 ], [ 24, 1 ], [ 48, 1 ] ] gap> STOP_TEST( "grpfp.tst", 146700000 ); ############################################################################# ## #E gap-4r6p5/tst/mapphomo.tst0000644000175000017500000000401612172557256014334 0ustar billbill############################################################################# ## #W mapphomo.tst GAP Tests Max Horn ## gap> START_TEST("mapphomo.tst"); gap> G:=SymmetricGroup(4);; gens:=[(1,2,3), (2,3,4)];; G0 := Subgroup(G, gens);; gap> H:=AbelianGroup(IsPcGroup, [3,3,4]);; imgs:=[H.1, H.2];; H0 := Subgroup(H, imgs);; gap> Size(H0); 9 gap> hom:=GroupGeneralMappingByImages(G, H, gens, imgs);; gap> Size(CoKernel(hom)); 3 gap> Size(Kernel(hom)); 4 gap> Size(ImagesSource(hom)); 9 gap> H:=AbelianGroup(IsPermGroup, [3,3,4]);; imgs:=[H.1, H.2];; H0 := Subgroup(H, imgs);; gap> Size(H0); 9 gap> hom:=GroupGeneralMappingByImages(G, H, gens, imgs);; gap> Size(CoKernel(hom)); 3 gap> Size(Kernel(hom)); 4 gap> Size(ImagesSource(hom)); 9 gap> H:=AbelianGroup(IsFpGroup, [3,3,4]);; imgs:=[H.1, H.2];; H0 := Subgroup(H, imgs);; gap> Size(H0); 9 gap> hom:=GroupGeneralMappingByImages(G, H, gens, imgs);; gap> Size(CoKernel(hom)); 3 gap> Size(Kernel(hom)); 4 gap> Size(ImagesSource(hom)); 9 gap> # Another test: map is total, but not single valued gap> G:=SymmetricGroup(4);; gap> H:=AbelianGroup(IsPermGroup, [3,3,4]);; gap> hom:=GroupGeneralMappingByImages(G, H, [(1,2,3), (2,3,4), (1,2)], [H.1, H.2, One(H)]);; gap> a:=Group( (1,2,3) );; gap> Size(a); 3 gap> b:=ImagesSet(hom, a);; gap> Size(CoKernel(hom)); 9 gap> not IsBound(StabChainOptions(b).limit) or StabChainOptions(b).limit>=9; true gap> Size(b) = Size(CoKernel(hom)); true gap> G:=CyclicGroup(IsPermGroup,15);; gap> hom:=GroupGeneralMappingByImages(G, G, GeneratorsOfGroup(G), [G.1^3]);; gap> HasIsTotal(hom); IsTotal(hom); true true gap> HasIsSurjective(hom); IsSurjective(hom); false false gap> hom:=GroupGeneralMappingByImages(G, G, [G.1^3], GeneratorsOfGroup(G));; gap> HasIsTotal(hom); IsTotal(hom); false false gap> HasIsSurjective(hom); IsSurjective(hom); true true gap> STOP_TEST( "mapphomo.tst", 4800000 ); ############################################################################# ## #E gap-4r6p5/configure.in0000644000175000017500000001124012172557252013450 0ustar billbillAC_INIT(configure) #if test "x$CFLAGS" = "x" ; then # CFLAGS=${COPTS} #fi AC_SUBST(COPTS) AC_CHECK_SIZEOF(void *, 4) AC_ARG_VAR(ABI, [Set this equal to 32 or 64 to build GAP (and GMP provided you do not deselect it) in 32- or 64-bit mode. The default value for this option is determined by testing the behaviour of your compiler, so should be 32 on a 32-bit system and 64 on one which is 64-bit. On ARM processors, leave this unset (the build system will set it to "standard" for GMP).]) AC_MSG_CHECKING([ABI bit size]) if test "x$ABI" = "x" ; then if test $ac_cv_sizeof_void_p = 8; then ABI="64" else ABI="32" fi ABI_CFLAGS="" elif test "$ABI" = "64"; then if test $ac_cv_sizeof_void_p = 4; then AC_MSG_ERROR([ ABI=64 cannot be used on a 32-bit system. Please replace this value with 32 and retry configure. If you think this error is wrong, email support@gap-system.org with full details.]) else ABI_CFLAGS="-m64" fi elif test "$ABI" = "32"; then ABI_CFLAGS="-m32" else AC_MSG_ERROR([ $ABI is not a supported value for ABI. Please use ABI=64 or 32, or leave it unset.]) fi AC_MSG_RESULT([$ABI]) AC_SUBST(ABI) AC_SUBST(ABI_CFLAGS) gp_configure_options=$ac_configure_args AC_SUBST(gp_configure_options) AC_CONFIG_AUX_DIR(cnf) AC_CANONICAL_TARGET AC_PROG_CC BASECC=`basename ${CC}` AC_SUBST(BASECC) AC_PROG_MAKE_SET AC_SUBST(gapdir) gapdir=`pwd` AC_ARG_VAR(CONFIGNAME,[Supply a (meaningful) name for the configuration you are building. This name will be appended to the architecture-dependent named sub-directory of bin/. Allows for multiple configurations side by side. Default value is "defaultXX" where "XX" is 32 or 64.]) AC_MSG_CHECKING([GAP config name]) if test "x$CONFIGNAME" = "x"; then CONFIGNAME="default${ABI}" fi AC_MSG_RESULT([$CONFIGNAME]) AC_SUBST(CONFIGNAME) GAPARCH=$target-$BASECC-${CONFIGNAME} AC_SUBST(GAPARCH) AC_ARG_WITH(gmp, AC_HELP_STRING( [--with-gmp], [ Use GMP library. If the argument you supply is "yes" or , then the version of GMP bundled with this GAP will be used (default). If the argument is "system" that means the library is reachable with the standard search path "/usr" or "/usr/local". Otherwise you give the to the directory which contains the library. If the argument is no, use original GAP large integers instead of GMP. [[default=yes]] ]), [ ], [ with_gmp=yes ] ) USE_GMP=yes case "$with_gmp" in no) GMP_CFLAGS="" GMP_LIBS="" MAKE_GMP="" USE_GMP=no ;; yes | 5.0.5 | 5.0.4) if test "$with_gmp" = "yes" ; then with_gmp="5.0.5" fi; GMP_HOME="`pwd`/bin/$GAPARCH/extern/gmp" GMP_CFLAGS="-I${GMP_HOME}/include" GMP_LIBS="${GMP_HOME}/lib/libgmp.a" MAKE_GMP="gmp" GMP_VER="$with_gmp" ;; system) GMP_CFLAGS="-m${ABI}" GMP_LIBS="-lgmp" MAKE_GMP="" ;; *) # user specified directory GMP_HOME="$with_gmp" if test -d ${GMP_HOME}/include && test -f ${GMP_HOME}/lib/libgmp.a ; then GMP_CFLAGS="-I${GMP_HOME}/include" GMP_LIBS="${GMP_HOME}/lib/libgmp.a" else AC_MSG_ERROR([Could not locate GMP in the specified location]) fi; MAKE_GMP="" ;; esac if test "$MAKE_GMP" = "gmp" ; then if ! test $ac_cv_sizeof_void_p = 4; then if test "$ac_cv_prog_ac_ct_CC" = gcc ; then if test `gcc -dumpversion` = "4.3.2" ; then AC_MSG_ERROR([The version of gcc found on your system is known to miscompile GMP on 64-bit machines. Please use another compiler or build GAP without GMP.]) fi fi fi AC_CHECK_PROG(m4_PRESENT,m4,yes,no) if test "$m4_PRESENT" = "no"; then AC_MSG_ERROR([You have requested that GAP be built with GMP but this requires m4, which has not been detected on your system. Please install m4 or build without GMP.]) fi case "$target" in arm*) ABI="standard" ABI_CFLAGS="" ;; esac fi # Enabling/disabling readline is handled by the "inner" configure # script in cnf/, so we do nothing here (the command line flag # is automatically passed on to the "inner" configure script anyway. AC_ARG_WITH(readline,[ --with-readline=yes|no| Use readline library for command line editing. ],[],[]) AC_SUBST(GMP_CFLAGS) AC_SUBST(GMP_LIBS) AC_SUBST(MAKE_GMP) AC_SUBST(USE_GMP) AC_SUBST(GMP_VER) mkdir -p bin AC_OUTPUT(Makefile-${CONFIGNAME}:Makefile.in sysinfo.gap-${CONFIGNAME}:sysinfo.in bin/gap-${CONFIGNAME}.sh:gap.shi) ln -sf gap-${CONFIGNAME}.sh bin/gap.sh ln -sf Makefile-${CONFIGNAME} Makefile ln -sf sysinfo.gap-${CONFIGNAME} sysinfo.gap gap-4r6p5/sysinfo.in0000644000175000017500000000010112172557256013157 0ustar billbillGAParch=@GAPARCH@ GAParch_system=@GAPARCH@ GAParch_abi=@ABI@-bit gap-4r6p5/prim/0000755000175000017500000000000012174560030012076 5ustar billbillgap-4r6p5/prim/irredsol.gd0000644000175000017500000002364612174560030014250 0ustar billbill############################################################################# ## #W irredsol.gd GAP group library Mark Short #W Burkhard Höfling ## ## #Y Copyright (C) 1993, Murdoch University, Perth, Australia ## ## This file contains the functions and data for the irreducible solvable ## matrix group library. It contains exactly one member for each of the ## 372 conjugacy classes of irreducible solvable subgroups of $GL(n,p)$ ## where $1 < n$, $p$ is a prime, and $p^n < 256$. ## ## By well-known theory, this data also doubles as a library of primitive ## solvable permutation groups of non-prime degree $<256$. ## ## This file contains the data from Mark Short's thesis, plus two groups ## missing from that list, subsequently discovered by Alexander Hulpke. ## ############################################################################# ## #V IrredSolJSGens[] . . . . . . . . . . . . . . . generators for the groups ## ## ## ## ## ## IrredSolJSGens[n][p][k] is a generating set ## for the k-th JS-maximal of GL(n,p). ## This generating set is polycyclic, i.e. forms an AG-system for the group. ## A JS-maximal is a maximal irreducible solvable subgroup of ## GL(n,p) ## (for a few exceptional small values of n and p this group isn't maximal). ## Every group in the library is generated with reference to the generating ## set of one of these JS-maximals, called its guardian (a group may be a ## subgroup of several JS-maximals but it only has one guardian). ## ## ## DeclareGlobalVariable("IrredSolJSGens"); ############################################################################# ## #V IrredSolGroupList[] . . . . . . . . . . . . . . description of the groups ## ## ## ## ## ## IrredSolGroupList[n][p][i] is a list containing the information ## about the i-th group from GL(n,p). ## The groups are ordered with respect to the following criteria: ## 1. Increasing size ## 2. Increasing guardian number ## If two groups have the same size and guardian, they are in no particular ## order. ##

## The list IrredSolGroupList[n][p][i] contains the following info: ## Position: [1]: the size of the group ## [2]: 0 if group is linearly primitive, ## otherwise its minimal block size ## [3]: the absolute value is the number of the group's guardian, ## i.e. its position in 'IrredSolJSGens[n][p]', ## it's negative iff it equals its guardian ## [4..]: the group's generators in normal form ## (with respect to its guardian's AG-system) ## ## ## DeclareGlobalVariable ("IrredSolGroupList"); ############################################################################# ## #F IrreducibleSolvableGroup( ,

, ) ## ## <#GAPDoc Label="IrreducibleSolvableGroup"> ## ## ## ## ## This function is obsolete, because for n = 2, ## p = 13, two groups were missing from the ## underlying database. It has been replaced by the function ## . Please note that the latter ## function does not guarantee any ordering of the groups in the database. ## However, for values of n, p, and i admissible to ## , ## returns a representative of the ## same conjugacy class of subgroups of GL(n, p) as ## did before. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("IrreducibleSolvableGroup"); ############################################################################# ## #F IrreducibleSolvableGroupMS( ,

, ) ## ## <#GAPDoc Label="IrreducibleSolvableGroupMS"> ## ## ## ## ## This function returns a representative of the i-th conjugacy class ## of irreducible solvable subgroup of GL(n, p), ## where n is an integer > 1, p is a prime, ## and p^{n} < 256. ##

## The numbering of the representatives should be ## considered arbitrary. However, it is guaranteed that the i-th ## group on this list will lie in the same conjugacy class in all future ## versions of &GAP;, unless two (or more) groups on the list are discovered ## to be duplicates, ## in which case will return ## fail for all but one of the duplicates. ##

## For values of n, p, and i admissible to ## , ## returns a representative of ## the same conjugacy class of subgroups of GL(n, p) as ## . ## Note that it currently adds two more groups (missing from the ## original list by Mark Short) for n = 2, ## p = 13. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("IrreducibleSolvableGroupMS"); ############################################################################# ## #F NumberIrreducibleSolvableGroups( ,

) ## ## <#GAPDoc Label="NumberIrreducibleSolvableGroups"> ## ## ## ## ## This function returns the number of conjugacy classes of ## irreducible solvable subgroup of ## GL(n, p). ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("NumberIrreducibleSolvableGroups"); DeclareSynonym("NrIrreducibleSolvableGroups",NumberIrreducibleSolvableGroups); ############################################################################# ## #F AllIrreducibleSolvableGroups( , , , , ... ) ## ## <#GAPDoc Label="AllIrreducibleSolvableGroups"> ## ## ## ## ## This function returns a list of conjugacy class representatives G ## of matrix groups over a prime field such that ## f(G) = v or f(G) \in v, for all pairs (f,v) in ## (func1, val1), (func2, val2), \ldots. ## The following possibilities for the functions f ## are particularly efficient, because the values can be read off the ## information in the data base: ## DegreeOfMatrixGroup (or ## or ) for the ## linear degree, ## for the field characteristic, ## , IsPrimitiveMatrixGroup ## (or IsLinearlyPrimitive), and ## MinimalBlockDimension>. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("AllIrreducibleSolvableGroups"); ############################################################################# ## #F OneIrreducibleSolvableGroup( , , , , ...) ## ## <#GAPDoc Label="OneIrreducibleSolvableGroup"> ## ## ## ## ## This function returns one solvable subgroup G of a ## matrix group over a prime field such that ## f(G) = v or f(G) \in v, for all pairs (f,v) in ## (func1, val1), (func2, val2), \ldots. ## The following possibilities for the functions f ## are particularly efficient, because the values can be read off the ## information in the data base: ## DegreeOfMatrixGroup (or ## or ) for the ## linear degree, ## for the field characteristic, ## , IsPrimitiveMatrixGroup ## (or IsLinearlyPrimitive), and ## MinimalBlockDimension>. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("OneIrreducibleSolvableGroup"); ############################################################################# ## #A DegreeOfMatrixGroup() ## ## ## ## ## ## This function returns the dimension of the underlying vector space, ## same as DimensionOfMatrixGroup ## ## ## DeclareSynonymAttr ("DegreeOfMatrixGroup", DimensionOfMatrixGroup); ############################################################################# ## #A MinimalBlockDimension() ## ## ## ## ## ## The minimum integer n such that the matrix group has an imprimitivity ## system consisting of n-dimensional subspaces of the underlying vector ## space over FieldOfMatrixGroup(G) ## ## ## DeclareAttribute("MinimalBlockDimension", IsMatrixGroup); ############################################################################# ## #P IsPrimitiveMatrixGroup() ## ## ## ## ## ## true if G is primitive over FieldOfMatrixGroup(G) ## ## ## DeclareProperty("IsPrimitiveMatrixGroup", IsMatrixGroup); DeclareSynonymAttr ("IsLinearlyPrimitive", IsPrimitiveMatrixGroup); ############################################################################# ## #E gap-4r6p5/prim/primitiv.gd0000644000175000017500000002220512174560030014256 0ustar billbill############################################################################# ## #W primitiv.gd GAP group library Heiko Theißen #W Alexander Hulpke #W Colva Roney-Dougal ## ## ## ## ## <#GAPDoc Label="[1]{primitiv}"> ## &GAP; contains a library of primitive permutation groups which includes, ## up to permutation isomorphism (i.e., up to conjugacy in the corresponding ## symmetric group), ## all primitive permutation groups of degree < 2500, ## calculated in , ## in particular, ## ## ## the primitive permutation groups up to degree 50, ## calculated by C. Sims, ## ## ## the primitive groups with insoluble socles of degree ## < 1000 as calculated in , ## ## ## the solvable (hence affine) primitive permutation groups of degree ## < 256 as calculated by M. Short , ## ## ## some insolvable affine primitive permutation groups of degree ## < 256 as calculated in . ## ## ## The solvable primitive groups of degree up to 999 as calculated ## in . ## ## ## The primitive groups of affine type of degree up to 999 as ## calculated in . ## ## ##

## Not all groups are named, those which do have names use ATLAS notation. ## Not all names are necessary unique! ##

## The list given in is believed to be complete, ## correcting various omissions in , ## and . ##

## In detail, we guarantee the following properties for this and further ## versions (but not versions which came before &GAP; 4.2) ## of the library: ##

## ## ## All groups in the library are primitive permutation groups ## of the indicated degree. ## ## ## The positions of the groups in the library are stable. ## That is PrimitiveGroup(n,nr) will always give you ## a permutation isomorphic group. ## Note however that we do not guarantee to keep the chosen ## S_n-representative, the generating set or the name for eternity. ## ## ## Different groups in the library are not conjugate in S_n. ## ## ## If a group in the library has a primitive subgroup with the same socle, ## this group is in the library as well. ## ## ##

## (Note that the arrangement of groups is not guaranteed to be in ## increasing size, though it holds for many degrees.) ## <#/GAPDoc> ############################################################################# ## ## tell GAP about the component ## DeclareComponent("prim","2.1"); ############################################################################# ## #F PrimitiveGroup(,) ## ## <#GAPDoc Label="PrimitiveGroup"> ## ## ## ## ## returns the primitive permutation group of degree deg with number nr ## from the list. ##

## The arrangement of the groups differs from the arrangement of primitive ## groups in the list of C. Sims, which was used in &GAP; 3. See ## . ## ## ## <#/GAPDoc> ## UnbindGlobal("PrimitiveGroup"); DeclareGlobalFunction( "PrimitiveGroup" ); ############################################################################# ## #F NrPrimitiveGroups() ## ## <#GAPDoc Label="NrPrimitiveGroups"> ## ## ## ## ## returns the number of primitive permutation groups of degree deg in the ## library. ## NrPrimitiveGroups(25); ## 28 ## gap> PrimitiveGroup(25,19); ## 5^2:((Q(8):3)'4) ## gap> PrimitiveGroup(25,20); ## ASL(2, 5) ## gap> PrimitiveGroup(25,22); ## AGL(2, 5) ## gap> PrimitiveGroup(25,23); ## (A(5) x A(5)):2 ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "NrPrimitiveGroups" ); ## <#GAPDoc Label="[2]{primitiv}"> ## The selection functions (see ) for ## the primitive groups library are AllPrimitiveGroups and ## OnePrimitiveGroup. ## They obtain the following properties from the database without having to ## compute them anew: ##

## , ## , ## , ## , ## , ## , ## and . ##

## (Note, that for groups of degree up to 2499, O'Nan-Scott types 4a, 4b and ## 5 cannot occur.) ## <#/GAPDoc> ############################################################################# ## #F PrimitiveGroupsIterator(,,,,...) ## ## <#GAPDoc Label="PrimitiveGroupsIterator"> ## ## ## ## ## returns an iterator through ## AllPrimitiveGroups(attr1,val1,attr2,val2,...) without creating ## all these groups at the same time. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "PrimitiveGroupsIterator" ); ############################################################################# ## #F AllPrimitiveGroups(,,,,...) ## ## ## ## ## ## ## ## DeclareGlobalFunction( "AllPrimitiveGroups" ); ############################################################################# ## #F OnePrimitiveGroup(,,,,...) ## ## ## ## ## ## ## ## DeclareGlobalFunction( "OnePrimitiveGroup" ); ############################################################################# ## #A SimsNo() ## ## <#GAPDoc Label="SimsNo"> ## ## ## ## ## If G is a primitive group obtained by ## (respectively one of the selection functions) this attribute contains the ## number of the isomorphic group in the original list of C. Sims. ## (This is the arrangement as it was used in &GAP; 3.) ##

## g:=PrimitiveGroup(25,2); ## 5^2:S(3) ## gap> SimsNo(g); ## 3 ## ]]> ##

## As mentioned in the previous section, the index numbers of primitive ## groups in &GAP; are guaranteed to remain stable. (Thus, missing groups ## will be added to the library at the end of each degree.) ## In particular, it is safe to refer to a primitive group of type ## deg, nr in the &GAP; library. ## ## ## <#/GAPDoc> ## DeclareAttribute( "SimsNo", IsPermGroup ); ############################################################################# ## #V PrimitiveIndexIrreducibleSolvableGroup ## ## <#GAPDoc Label="PrimitiveIndexIrreducibleSolvableGroup"> ## ## ## ## ## This variable provides a way to get from irreducible solvable groups to ## primitive groups and vice versa. For the group ## G = IrreducibleSolvableGroup( n, p, k ) ## and d = p^n, the entry ## PrimitiveIndexIrreducibleSolvableGroup[d][i] gives the index ## number of the semidirect product p^n:G in the library of primitive ## groups. ##

## Searching for an index in this list with gives the ## translation in the other direction. ## ## ## <#/GAPDoc> ## DeclareGlobalVariable("PrimitiveIndexIrreducibleSolvableGroup"); ############################################################################# ## #F MaximalSubgroupsSymmAlt( [,] ) ## ## ## ## ## ## For a symmetric or alternating group grp, this function returns ## representatives of the classes of maximal subgroups. ##

## If the parameter onlyprimitive is given and set to true only the ## primitive maximal subgroups are computed. ##

## No parameter test is performed. (The function relies on the primitive ## groups library for its functionality.) ## ## ## DeclareGlobalFunction("MaximalSubgroupsSymmAlt"); ############################################################################# ## #E gap-4r6p5/Makefile.in0000644000175000017500000004266112172557252013217 0ustar billbill############################################################################# ## #W Makefile GAP source Frank Celler ## ## #Y Copyright (C) 1997, Lehrstuhl D fuer Mathematik, RWTH Aachen, Germany ## ## This file is the top level make file. It is generated from `Makefile.in' ## by the `configure' script. After unpacking GAP you simply type ## ## ./configure ## ## to create a make file and then ## ## make ## ## to compile and link GAP. ## ## The "default" target: ## - creates a subdirectory CPU-VENDOR-OS in the directory `bin', ## - copies the configuration script into this directory, ## - it switches into this directory and executes the configure script, ## - it makes GAP in this directory. ## ## The "clean" target: ## - removes the subdirectory CPU-VENDOR-OS in the directory `bin' ## - removes any files created by `configure' ## ## The "testinstall" target: ## - starts GAP and reads `tst/testinstall.g' ## ## The "teststandard" target: ## - starts GAP and reads all files `tst/*.tst' ## ## The "teststandardrenormalize" target: ## - starts GAP, reads all files `tst/*.tst', and replaces the scaling ## factors in the `STOP_TEST' statements ## ## The "testinstall.g" target: ## - creates `tst/testinstall.g' based on the existing version and the ## preselected `tst/*.tst' files ## ## The "testpackages" target: ## - runs the tests provided by the available packages ## ## The "testpackagesload" target: ## - tests loading of each available package ## ## The "testmanuals" target: ## - runs the examples in the main GAP documentation ## SHELL=/bin/sh CC=@CC@ BASECC=@BASECC@ TARGET=@target@ @SET_MAKE@ GMP_CFLAGS=@GMP_CFLAGS@ GMP_LIBS=@GMP_LIBS@ MAKE_GMP=@MAKE_GMP@ USE_GMP=@USE_GMP@ ifndef GMP_VER GMP_VER=@GMP_VER@ endif ifndef ABI ABI=@ABI@ endif ABI_CFLAGS=@ABI_CFLAGS@ export CFLAGS+=@ABI_CFLAGS@ @CFLAGS@ export COPTS=@COPTS@ ifndef CONFIGNAME CONFIGNAME=@CONFIGNAME@ endif GAPARCH=@GAPARCH@ GAPARGS= TESTGAP = ./bin/gap-$(CONFIGNAME).sh -b -m 100m -o 512m -A -N -q -x 80 -r $(GAPARGS) TESTGAPauto = ./bin/gap-$(CONFIGNAME).sh -b -m 100m -o 512m -N -q -x 80 -r $(GAPARGS) default: compile setconfig: if test -e sysinfo.gap-$(CONFIGNAME); then \ rm -f Makefile sysinfo.gap bin/gap.sh; \ ln -s sysinfo.gap-$(CONFIGNAME) sysinfo.gap; \ ln -s Makefile-$(CONFIGNAME) Makefile; \ ln -s gap-$(CONFIGNAME).sh bin/gap.sh; \ else \ echo "There is no config with name: "$(CONFIGNAME); \ fi; config: bin/$(GAPARCH)/configure bin/$(GAPARCH)/Makefile bin/$(GAPARCH)/extern/Makefile bin/$(GAPARCH)/configure: cnf/configure.out mkdir -p bin/$(GAPARCH) @rm -f bin/$(GAPARCH)/configure cp cnf/configure.out bin/$(GAPARCH)/configure bin/$(GAPARCH)/Makefile bin/$(GAPARCH)/extern/Makefile : bin/$(GAPARCH)/configure cnf/config.hin cnf/gac.in extern/Makefile.in cnf/Makegap.in mkdir -p bin/$(GAPARCH)/extern ( cd bin/$(GAPARCH) ; CC='$(CC)' ABI='$(ABI)' ABI_CFLAGS='$(ABI_CFLAGS)' GMP_LIBS='$(GMP_LIBS)' GMP_CFLAGS='$(GMP_CFLAGS)' CONFIGNAME='$(CONFIGNAME)' USE_GMP='$(USE_GMP)' GAPARCH='$(GAPARCH)' ./configure --target=@target@ @gp_configure_options@ ) extern: config ( cd bin/$(GAPARCH)/extern ; $(MAKE) TARGET='$(TARGET)' BASECC='$(BASECC)' ABI='$(ABI)' ABI_CFLAGS='$(ABI_CFLAGS)' CC='$(CC)' GMP_VER='$(GMP_VER)' MAKE_GMP='$(MAKE_GMP)' CONFIGNAME='$(CONFIGNAME)' ) compile: extern ( cd bin/$(GAPARCH); $(MAKE) ABI='$(ABI)' CC='$(CC)' GMP_VER='$(GMP_VER)' GMP_CFLAGS='$(GMP_CFLAGS)' GMP_LIBS='$(GMP_LIBS)' CONFIGNAME='$(CONFIGNAME)' ) chmod +x bin/gap-$(CONFIGNAME).sh static: extern ( cd bin/$(GAPARCH) ; $(MAKE) static CC='$(CC)' ABI='$(ABI)' ) chmod +x bin/gap-$(CONFIGNAME).sh ( cd bin/$(GAPARCH) ; strip gap@EXEEXT@) strip: compile if ! grep darwin sysinfo.gap ; then ( cd bin/$(GAPARCH); strip gap@EXEEXT@) ; fi removewin: strip ( rm -f bin/*.exe bin/*.dll bin/*.bat bin/*.pif "bin/GAP 4 PPC") rebuild: rm -f config.cache config.log config.status touch src/* ifndef CLEANME CLEANME=@CONFIGNAME@ endif clean: clean_$(CLEANME) clean_$(CLEANME): clean_gap_$(CLEANME) clean_gmp_$(CLEANME) rm -rf bin/$(GAPARCH) clean_gap: clean_gap_$(CLEANME) clean_gap_$(CLEANME): rebuild rm -f bin/$(GAPARCH)/*.o rm -f bin/$(GAPARCH)/Makefile rm -f bin/$(GAPARCH)/config* rm -f bin/$(GAPARCH)/gac rm -f bin/$(GAPARCH)/gap rm -f bin/$(GAPARCH)/sysinfo* rm -f bin/gap-$(CONFIGNAME).sh rm -f sysinfo.gap-$(CONFIGNAME) (if ! test -h sysinfo.gap -a -e sysinfo.gap; then \ nextconf=`ls sysinfo.gap-* 2>/dev/null | head -1 | \ sed -e "s/sysinfo.gap-//g"`; \ if [ "x$$nextconf" != "x" ]; then \ echo "changing config to "$$nextconf; \ make setconfig CONFIGNAME=$$nextconf; \ else \ rm -f Makefile sysinfo.gap bin/gap.sh; \ fi; \ fi) rm -f Makefile-$(CONFIGNAME) clean_gmp: clean_gmp_$(CLEANME) clean_gmp_$(CLEANME): if test -d bin/$(GAPARCH)/extern/gmp-$(GMP_VER); then \ rm -rf bin/$(GAPARCH)/extern/gmp-$(GMP_VER); fi if test -h bin/$(GAPARCH)/extern/gmp; then \ rm -f bin/$(GAPARCH)/extern/gmp; fi if test -d extern/gmp-$(GMP_VER); then \ (cd extern/gmp-$(GMP_VER); rm -f LASTBUILD.*; \ if test -r Makefile; then make distclean; fi ); fi distclean: while test -e Makefile; do make clean; done manuals: ( echo 'SaveWorkspace( "doc/wsp.g" );' | $(TESTGAPauto) ) ( cd doc/ref; echo 'Read( "makedocrel.g" );' | \ ../../$(TESTGAP) -L ../wsp.g > make_manuals.out ) ( cd doc/tut; echo 'Read( "makedocrel.g" );' | \ ../../$(TESTGAP) -L ../wsp.g > make_manuals.out ) ( cd doc/changes; echo 'Read( "makedocrel.g" );' | \ ../../$(TESTGAP) -L ../wsp.g > make_manuals.out ) ( cd doc/ref; echo 'Read( "makedocrel.g" );' | \ ../../$(TESTGAP) -L ../wsp.g > make_manuals.out ) ( cd doc/tut; echo 'Read( "makedocrel.g" );' | \ ../../$(TESTGAP) -L ../wsp.g > make_manuals.out ) ( cd doc/changes; echo 'Read( "makedocrel.g" );' | \ ../../$(TESTGAP) -L ../wsp.g > make_manuals.out ) ( rm doc/wsp.g ) testinstall: mkdir -p dev/log ( echo 'SetUserPreference("UseColorsInTerminal",false); \ ReadGapRoot( "tst/testutil.g" ); \ ReadGapRoot( "tst/testinstall.g" );' | $(TESTGAP) > \ `date -u +dev/log/testinstall1_%Y-%m-%d-%H-%M` ) ( echo 'SetUserPreference("UseColorsInTerminal",false); \ ReadGapRoot( "tst/testutil.g" ); LoadAllPackages(); \ ReadGapRoot( "tst/testinstall.g" );' | $(TESTGAP) > \ `date -u +dev/log/testinstall2_%Y-%m-%d-%H-%M` ) teststandard: mkdir -p dev/log ( echo 'ShowSystemInformation(); RunStandardTests( [' > test.tmp; \ grep -h "STOP_TEST" tst/*.tst | sed -e 's/^gap> STOP_TEST(/[/;s/);/],/' >> test.tmp; \ echo '] ); ' >> test.tmp ) ( echo 'SetUserPreference("UseColorsInTerminal",false); \ ReadGapRoot( "tst/testutil.g" ); Read( "test.tmp" );' | $(TESTGAP) > \ `date -u +dev/log/teststandard1_%Y-%m-%d-%H-%M` ) ( echo 'SetUserPreference("UseColorsInTerminal",false); \ ReadGapRoot( "tst/testutil.g" ); LoadAllPackages(); Read( "test.tmp" );' | $(TESTGAP) > \ `date -u +dev/log/teststandard2_%Y-%m-%d-%H-%M` ) ( rm test.tmp ) teststandardrenormalize: mkdir -p dev/log ( echo 'RunStandardTests( [' > test.tmp; \ grep -h "STOP_TEST" tst/*.tst | \ sed -e 's/^gap> STOP_TEST(/[/;s/);/],/' >> test.tmp; \ echo '], true ); ShowSystemInformation();' \ >> test.tmp; \ echo 'ReadGapRoot( "tst/testutil.g" ); Read( "test.tmp" ); \ CreateTestinstallFile(); Runtime();' | $(TESTGAP) > \ `date -u +dev/log/teststandardrenormalize_%Y-%m-%d-%H-%M` ) ( rm test.tmp ) testinstall.g: ( echo 'ReadGapRoot( "tst/testutil.g" ); \ CreateTestinstallFile();' | $(TESTGAP) ) testpackages: mkdir -p dev/log ( echo 'SetAssertionLevel( 2 ); ReadGapRoot( "tst/testutil.g" ); \ SaveWorkspace( "wsp.g" );' | $(TESTGAP) ) ( echo 'CreatePackageTestsInput( "testpackages.in", \ "dev/log/testpackages1", \ "$(TESTGAP) -L wsp.g", "false" );'\ | $(TESTGAP) -L wsp.g > /dev/null ) ( chmod 777 testpackages.in; ./testpackages.in; rm testpackages.in ) ( rm wsp.g ) ( echo 'SetAssertionLevel( 2 ); ReadGapRoot( "tst/testutil.g" ); \ SaveWorkspace( "wsp.g" );' | $(TESTGAPauto) ) ( echo 'CreatePackageTestsInput( "testpackages.in", \ "dev/log/testpackagesA", \ "$(TESTGAPauto) -L wsp.g", "auto" );'\ | $(TESTGAPauto) -L wsp.g > /dev/null ) ( chmod 777 testpackages.in; ./testpackages.in; rm testpackages.in ) ( rm wsp.g ) ( echo 'SetAssertionLevel( 2 ); ReadGapRoot( "tst/testutil.g" ); \ SaveWorkspace( "wsp.g" );' | $(TESTGAP) ) ( echo 'CreatePackageTestsInput( "testpackages.in", \ "dev/log/testpackages2", \ "$(TESTGAP) -L wsp.g", "true" );'\ | $(TESTGAP) -L wsp.g > /dev/null ) ( chmod 777 testpackages.in; ./testpackages.in; rm testpackages.in ) ( rm wsp.g ) testpackagesload: mkdir -p dev/log ( echo 'ReadGapRoot( "tst/testutil.g" ); \ SaveWorkspace( "wsp.g" );' | $(TESTGAP) ) ( echo 'CreatePackageLoadTestsInput( "testpackagesload.in", \ "dev/log/testpackagesload1", \ "$(TESTGAP) -L wsp.g", false, false );'\ | $(TESTGAP) -L wsp.g > /dev/null ) ( chmod 777 testpackagesload.in; ./testpackagesload.in > \ `date -u +dev/log/testpackagesload1_%Y-%m-%d-%H-%M`; rm testpackagesload.in ) ( rm wsp.g ) ( echo 'ReadGapRoot( "tst/testutil.g" ); \ SaveWorkspace( "wsp.g" );' | $(TESTGAP) ) ( echo 'CreatePackageLoadTestsInput( "testpackagesload.in", \ "dev/log/testpackagesloadN1", \ "$(TESTGAP) -L wsp.g", false, true );'\ | $(TESTGAP) -L wsp.g > /dev/null ) ( chmod 777 testpackagesload.in; ./testpackagesload.in > \ `date -u +dev/log/testpackagesloadN1_%Y-%m-%d-%H-%M`; rm testpackagesload.in ) ( rm wsp.g ) ( echo 'ReadGapRoot( "tst/testutil.g" ); \ SaveWorkspace( "wsp.g" );' | $(TESTGAPauto) ) ( echo 'CreatePackageLoadTestsInput( "testpackagesload.in", \ "testpackagesloadA", \ "$(TESTGAPauto) -L wsp.g", true, false );'\ | $(TESTGAPauto) -L wsp.g > /dev/null ) ( chmod 777 testpackagesload.in; ./testpackagesload.in > \ `date -u +dev/log/testpackagesloadA_%Y-%m-%d-%H-%M`; rm testpackagesload.in ) ( rm wsp.g ) ( echo 'ReadGapRoot( "tst/testutil.g" ); \ SaveWorkspace( "wsp.g" );' | $(TESTGAPauto) ) ( echo 'CreatePackageLoadTestsInput( "testpackagesload.in", \ "testpackagesloadNA", \ "$(TESTGAPauto) -L wsp.g", true, true );'\ | $(TESTGAPauto) -L wsp.g > /dev/null ) ( chmod 777 testpackagesload.in; ./testpackagesload.in > \ `date -u +dev/log/testpackagesloadNA_%Y-%m-%d-%H-%M`; rm testpackagesload.in ) ( rm wsp.g ) testpackagesvars: mkdir -p dev/log ( echo 'ReadGapRoot( "tst/testutil.g" ); \ SaveWorkspace( "wsp.g" );' | $(TESTGAP) ) ( echo 'CreatePackageVarsTestsInput( "testpackagesvars.in", \ "dev/log/testpackagesvars", \ "$(TESTGAP) -L wsp.g" );'\ | $(TESTGAP) -L wsp.g > /dev/null ) ( chmod 777 testpackagesvars.in; ./testpackagesvars.in > \ `date -u +dev/log/testpackagesvars_%Y-%m-%d-%H-%M`; rm testpackagesvars.in ) ( rm wsp.g ) testmanuals1: (cd doc/ref; ../../bin/gap.sh -r extractexamples.g runexamples.g) (cd doc/tut; ../../bin/gap.sh -r extractexamples.g runexamples.g) testmanuals: mkdir -p dev/log ((cd doc/tut ; \ echo 'SetUserPreference("UseColorsInTerminal",false); SetAssertionLevel( 2 ); \ Read("extractexamples.g"); Read("runexamples.g"); ' | ../../$(TESTGAP);\ echo '============================================================';\ cd ../.. ; ff=(`ls doc/tut/EXAMPLEDIFFS* 2> /dev/null | wc -l`); \ if [ $$ff != "0" ] ; then cat doc/tut/EXAMPLEDIFFS*; \ else echo "NO DIFFERENCES IN TUTORIAL EXAMPLES (NO PACKAGES)"; fi ; \ echo '============================================================';\ cd doc/ref ; \ echo 'SetUserPreference("UseColorsInTerminal",false); SetAssertionLevel( 2 ); \ Read("extractexamples.g"); Read("runexamples.g"); ' | ../../$(TESTGAP);\ echo '============================================================';\ cd ../.. ; ff=(`ls doc/ref/EXAMPLEDIFFS* 2> /dev/null | wc -l`); \ if [ $$ff != "0" ] ; then cat doc/ref/EXAMPLEDIFFS*; \ else echo "NO DIFFERENCES IN REFERENCE MANUAL EXAMPLES (NO PACKAGES)"; fi ) \ > `date -u +dev/log/testmanuals1_%Y-%m-%d-%H-%M` 2>&1 ) ( rm -rf doc/tut/EXAMPLEDIFFS*; rm -rf doc/ref/EXAMPLEDIFFS* ) ((cd doc/tut ; \ echo 'SetUserPreference("UseColorsInTerminal",false); SetAssertionLevel( 2 ); \ Read("extractexamples.g"); Read("runexamples.g"); ' | ../../$(TESTGAPauto);\ echo '============================================================';\ cd ../.. ; ff=(`ls doc/tut/EXAMPLEDIFFS* 2> /dev/null | wc -l`); \ if [ $$ff != "0" ] ; then cat doc/tut/EXAMPLEDIFFS*; \ else echo "NO DIFFERENCES IN TUTORIAL EXAMPLES (DEFAULT PACKAGES)"; fi ; \ echo '============================================================';\ cd doc/ref ; \ echo 'SetUserPreference("UseColorsInTerminal",false); SetAssertionLevel( 2 ); \ Read("extractexamples.g"); Read("runexamples.g"); ' | ../../$(TESTGAPauto);\ echo '============================================================';\ cd ../.. ; ff=(`ls doc/ref/EXAMPLEDIFFS* 2> /dev/null | wc -l`); \ if [ $$ff != "0" ] ; then cat doc/ref/EXAMPLEDIFFS*; \ else echo "NO DIFFERENCES IN REFERENCE MANUAL EXAMPLES (DEFAULT PACKAGES)"; fi ) \ > `date -u +dev/log/testmanualsA_%Y-%m-%d-%H-%M` 2>&1 ) ( rm -rf doc/tut/EXAMPLEDIFFS*; rm -rf doc/ref/EXAMPLEDIFFS* ) ((cd doc/tut ; \ echo 'SetUserPreference("UseColorsInTerminal",false); SetAssertionLevel( 2 ); \ LoadAllPackages() ; \ Read("extractexamples.g"); Read("runexamples.g"); ' | ../../$(TESTGAP);\ echo '============================================================';\ cd ../.. ; ff=(`ls doc/tut/EXAMPLEDIFFS* 2> /dev/null | wc -l`); \ if [ $$ff != "0" ] ; then cat doc/tut/EXAMPLEDIFFS*; \ else echo "NO DIFFERENCES IN TUTORIAL EXAMPLES (ALL PACKAGES)"; fi ; \ echo '============================================================';\ cd doc/ref ; \ echo 'SetUserPreference("UseColorsInTerminal",false); SetAssertionLevel( 2 ); \ LoadAllPackages() ; \ Read("extractexamples.g"); Read("runexamples.g"); ' | ../../$(TESTGAP);\ echo '============================================================';\ cd ../.. ; ff=(`ls doc/ref/EXAMPLEDIFFS* 2> /dev/null | wc -l`); \ if [ $$ff != "0" ] ; then cat doc/ref/EXAMPLEDIFFS*; \ else echo "NO DIFFERENCES IN REFERENCE MANUAL EXAMPLES (ALL PACKAGES)"; fi ) \ > `date -u +dev/log/testmanuals2_%Y-%m-%d-%H-%M` 2>&1 ) ( rm -rf doc/tut/EXAMPLEDIFFS*; rm -rf doc/ref/EXAMPLEDIFFS* ) testupdates: mkdir -p dev/log ( echo 'SetUserPreference("UseColorsInTerminal",false); \ ReadGapRoot( "tst/testutil.g" ); \ SetAssertionLevel( 2 ); RunDevUpdateTests();' | $(TESTGAP) > \ `date -u +dev/log/testupdates1_%Y-%m-%d-%H-%M` ) ( echo 'SetUserPreference("UseColorsInTerminal",false); \ ReadGapRoot( "tst/testutil.g" ); LoadAllPackages(); \ SetAssertionLevel( 2 ); RunDevUpdateTests();' | $(TESTGAP) > \ `date -u +dev/log/testupdates2_%Y-%m-%d-%H-%M` ) testobsoletes: mkdir -p dev/log ( echo 'ReadGapRoot( "tst/testutil.g" ); \ SaveWorkspace( "wsp.g" );' | $(TESTGAP) -O ) ( echo 'CreatePackageLoadTestsInput( "testobsoletes1.in", \ "dev/log/testobsoletes1", \ "$(TESTGAP) -O -L wsp.g", false, false );'\ | $(TESTGAP) -O -L wsp.g > /dev/null ) ( chmod 777 testobsoletes1.in; ./testobsoletes1.in > \ `date -u +dev/log/testobsoletes1_%Y-%m-%d-%H-%M`; rm testobsoletes1.in ) ( rm wsp.g ) ( echo 'ReadGapRoot( "tst/testutil.g" ); \ SaveWorkspace( "wsp.g" );' | $(TESTGAP) -O ) ( echo 'CreatePackageLoadTestsInput( "testobsoletesN1.in", \ "dev/log/testobsoletesN1", \ "$(TESTGAP) -O -L wsp.g", false, true );'\ | $(TESTGAP) -O -L wsp.g > /dev/null ) ( chmod 777 testobsoletesN1.in; ./testobsoletesN1.in > \ `date -u +dev/log/testobsoletesN1_%Y-%m-%d-%H-%M`; rm testobsoletesN1.in ) ( rm wsp.g ) cygwin: extern ( cd bin/$(GAPARCH) ; $(MAKE) gapdll ABI='$(ABI)' CC='$(CC)' GMP_VER='$(GMP_VER)' GMP_CFLAGS='$(GMP_CFLAGS)' GMP_LIBS='$(GMP_LIBS)' CONFIGNAME='$(CONFIGNAME)' ) chmod +x bin/gap-$(CONFIGNAME).sh chmod +x bin/*.bat cp bin/$(GAPARCH)/gapw95.exe bin cp bin/$(GAPARCH)/gap.dll bin cp /bin/cygncurses-10.dll /bin/cygncursesw-10.dll \ /bin/cygpanel-10.dll /bin/cygwin1.dll \ /bin/libW11.dll /usr/bin/rxvt.exe /usr/bin/regtool.exe \ /bin/cygreadline7.dll /bin/cyggcc_s-1.dll /bin/cygpopt-0.dll \ /bin/cygstart.exe /bin/mintty.exe bin chmod +x cnf/instcygwinterminfo.sh cnf/instcygwinterminfo.sh ( if which peflags ; then peflags --cygwin-heap=2048 bin/gapw95.exe ; fi ) winbinp: ( tar cfz ../winbin.tgz bin/*.dll bin/*.exe \ bin/$(GAPARCH)/gac \ bin/$(GAPARCH)/config.h \ terminfo ) packages: ./makepkgs .PHONY: clean clean_$(CLEANME) clean_gap clean_gap_$(CLEANME) clean_gmp clean_gmp_$(CLEANME) compile config cygwin default distclean extern manuals packages rebuild removewin setconfig static strip testinstall testinstall.g testmanuals testpackages testpackagesload testpackagesvars teststandard teststandardrenormalize winbinp gap-4r6p5/trans/0000755000175000017500000000000012174560030012256 5ustar billbillgap-4r6p5/trans/trans.gd0000644000175000017500000000432712174560030013727 0ustar billbill############################################################################# ## #W trans.gd GAP transitive groups library Alexander Hulpke ## ## #Y Copyright (C) 2001, Alexander Hulpke, Colorado State University #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland ## ## This file contains the declarations for the transitive groups library ## ############################################################################# ## #F TransitiveGroup(,) ## ## <#GAPDoc Label="TransitiveGroup"> ## ## ## ## ## returns the nr-th transitive group of degree deg. Both deg and ## nr must be positive integers. The transitive groups of equal degree ## are sorted with respect to their size, so for example ## TransitiveGroup( deg, 1 ) is a transitive group of degree and ## size deg, e.g, the cyclic group of size deg, if deg is a ## prime. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("TransitiveGroup"); ############################################################################# ## #F NrTransitiveGroups() ## ## <#GAPDoc Label="NrTransitiveGroups"> ## ## ## ## ## returns the number of transitive groups of degree deg stored in ## the library of transitive groups. ## The function returns fail if deg is ## beyond the range of the library. ##

## TransitiveGroup(10,22); ## S(5)[x]2 ## gap> l:=AllTransitiveGroups(NrMovedPoints,12,Size,1440,IsSolvable,false); ## [ S(6)[x]2, M_10.2(12)=A_6.E_4(12)=[S_6[1/720]{M_10}S_6]2 ] ## gap> List(l,IsSolvable); ## [ false, false ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("NrTransitiveGroups"); DeclareGlobalVariable( "TRANSCOMBCACHE", "combinations cache" ); DeclareGlobalVariable( "TRANSARRCACHE", "arrangements cache" ); DeclareGlobalVariable( "TRANSSHAPEFREQS", "frequencies of shapes" ); ############################################################################# ## #E gap-4r6p5/lib/0000755000175000017500000000000012174560027011703 5ustar billbillgap-4r6p5/lib/polyfinf.gi0000644000175000017500000005252012172557254014064 0ustar billbill############################################################################# ## #W polyfinf.gi GAP Library Frank Celler #W & Alexander Hulpke ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1999 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains functions for polynomials over finite fields ## ############################################################################# ## #F FactorsCommonDegreePol( , , ) . . . . . . . . . . . . . factors ## ## must be a square free product of irreducible factors of degree ## and leading coefficient 1. must be a polynomial ring over a finite ## field of size p^k. ## InstallGlobalFunction(FactorsCommonDegreePol,function( R, f, d ) local c, ind, br, g, h, k, i,dou; # if has degree 0, return f dou:=DegreeOfLaurentPolynomial(f); if dou has degree , return irreducible elif dou=d then return [f]; fi; c := CoefficientsOfLaurentPolynomial(f); ind := IndeterminateNumberOfLaurentPolynomial(f); br := CoefficientsRing(R); # if has a trivial constant term signal an error if c[2] <> 0 then Error(" must have a non-trivial constant term"); fi; # choose a random polynomial of degree less than 2* repeat g := RandomPol(br,2*d-1,ind); until DegreeOfLaurentPolynomial(g)<>DEGREE_ZERO_LAURPOL; # if p = 2 take + ^2 + ^(2^2) + ... + ^(2^(k*-1)) if Characteristic(br) = 2 then g := CoefficientsOfLaurentPolynomial(g); h := ShiftedCoeffs(g[1],g[2]); k := ShiftedCoeffs(c[1],c[2]); g := g[1]; for i in [1..DegreeOverPrimeField(br)*d-1] do g := ProductCoeffs(g,g); ReduceCoeffs(g,k); ShrinkRowVector(g); AddCoeffs(h,g); od; h := LaurentPolynomialByCoefficients( FamilyObj(h[1]), h, 0, ind ); # if p > 2 take ^ ((p ^ (k*) - 1) / 2) - 1 else h:=PowerMod(g,(Characteristic(br)^(DegreeOverPrimeField(br)*d)-1)/2,f) - One(br); fi; # gcd of and is with probability > 1/2 a proper factor g := GcdOp(f,h); return Concatenation( FactorsCommonDegreePol( R, Quotient(R,f,g), d ), FactorsCommonDegreePol( R, g, d ) ); end); ############################################################################# ## #M FactorsSquarefree( , , ) . . . . . . . . . . . . . . factors ## ## must be square free and must have leading coefficient 1. must be ## a polynomial ring over a finite field of size q. ## InstallMethod( FactorsSquarefree,"univariate polynomial over finite field", true, [ IsFiniteFieldPolynomialRing, IsUnivariatePolynomial, IsRecord ],0, function( R, f, opt ) local br, ind, c, facs, deg, px, pow, cyc, gcd,d,powc,fc,fam; br := CoefficientsRing(R); ind := IndeterminateNumberOfLaurentPolynomial(f); c := CoefficientsOfLaurentPolynomial(f); # if has a trivial constant term signal an error if c[2] <> 0 then Error(" must have a non-trivial constant term"); fi; # will contain factorisation facs := []; # in the following = x ^ (q ^ (+1)) deg := 0; #px := LaurentPolynomialByExtRepNC( # FamilyObj(f), [One(br)],1, ind ); # pow := px; px:=[Zero(br),-One(br)]; ConvertToVectorRep(px,br); powc:=-px; fc:=CoefficientsOfLaurentPolynomial(f)[1]; fam:=FamilyObj(One(br)); # while could still have two irreducible factors while 2*(deg+1) <= DegreeOfLaurentPolynomial(f) do #pow := PowerMod(pow,Size(br),f); powc:=PowerModCoeffs(powc,Length(powc),Size(br),fc,Length(fc)); # next degree and next cyclotomic polynomial x^(q^(+1))-x deg := deg + 1; if not IsBound(opt.onlydegs) or deg in opt.onlydegs then #cyc := pow - px; cyc:=ShallowCopy(powc); AddCoeffs(cyc,px); cyc:=LaurentPolynomialByCoefficients(fam,cyc,0,ind); # compute the gcd of and gcd := GcdOp( f, cyc ); # split the gcd with 'FactorsCommonDegree' d:=DegreeOfLaurentPolynomial(gcd); if 0=deg then Info(InfoPoly,3,"Factor Common Deg.",deg ); Append(facs,FactorsCommonDegreePol(R,gcd,deg)); f := Quotient(f,gcd); fi; fi; od; # if neccessary add irreducible to the list of factors if 0 < DegreeOfLaurentPolynomial(f) then Add(facs,f); fi; # return the factorisation return facs; end ); ############################################################################# ## #F RootsRepresentativeFFPol( , , ) ## InstallGlobalFunction(RootsRepresentativeFFPol,function( R, f, n ) local r, br, nu, ind, p, d, z, v, o, i, e; r := []; br := CoefficientsRing(R); nu := Zero(br); ind := IndeterminateNumberOfLaurentPolynomial(f); p := Characteristic(br); d := DegreeOverPrimeField(br); z := PrimitiveRoot(br); f := CoefficientsOfLaurentPolynomial(f); v := f[2]; f := f[1]; o := p^d-1; for i in [0..(Length(f)-1)/n] do e := f[i*n+1]; if e = nu then r[i+1] := nu; else r[i+1] := z ^ ((LogFFE(e,z) / n) mod o); fi; od; return LaurentPolynomialByCoefficients( FamilyObj(nu), r, v/n, ind ); end); ############################################################################# ## #M Factors( , ) . . . . . . . . . . . . . . factors of ## InstallMethod( Factors, "polynomial over a finite field", IsCollsElms, [ IsFiniteFieldPolynomialRing, IsUnivariatePolynomial ],0, function(R,f) local cr, opt, irf, i, ind, v, l, g, k, d, facs, h, q, char, r; # parse the arguments cr := CoefficientsRing(R); opt:=ValueOption("factoroptions"); PushOptions(rec(factoroptions:=rec())); # options do not hold for # subsequent factorizations if opt=fail then opt:=rec(); fi; # check if we already know a factorisation irf := IrrFacsPol(f); i := PositionProperty( irf, i -> i[1] = cr ); if i <> fail then PopOptions(); return ShallowCopy(irf[i][2]); fi; # handle the trivial cases ind := IndeterminateNumberOfLaurentPolynomial(f); v := CoefficientsOfLaurentPolynomial(f); #fam := FamilyObj(v[1][1]); if DegreeOfLaurentPolynomial(f) < 2 or DegreeOfLaurentPolynomial(f)=DEGREE_ZERO_LAURPOL then Add( irf, [cr,[f]] ); PopOptions(); return [f]; elif Length(v[1]) = 1 then l:= ListWithIdenticalEntries( v[2], IndeterminateOfUnivariateRationalFunction( f ) ); l[1] := l[1]*v[1][1]; Add( irf, [cr,l] ); PopOptions(); return l; fi; # make the polynomial normed, remember the leading coefficient for later l:=LeadingCoefficient(f); #g := StandardAssociate(R,f); #l := Quotient(f,g); v := CoefficientsOfLaurentPolynomial(f); if v[2]=0 then k:=1/l*f; else k:=LaurentPolynomialByExtRepNC( FamilyObj(f), 1/l*v[1],0, ind ); fi; v := v[2]; # compute the derivative d := Derivative(k); # if the derivative is nonzero then $k / Gcd(k,d)$ is squarefree if d <> Zero(R) then # compute the gcd of and the derivative g := GcdOp( k, d ); if DegreeOfLaurentPolynomial(g)>0 then # factor the squarefree quotient and the remainder facs := FactorsSquarefree( R, Quotient(k,g), opt ); else facs := FactorsSquarefree( R, k, opt ); fi; if not (IsBound(opt.onlydegs) or IsBound(opt.stopdegs)) then # tell the factors they are factors for h in facs do StoreFactorsPol(cr,h,[h]); od; fi; if DegreeOfLaurentPolynomial(g)>0 then for h in ShallowCopy(facs) do q := Quotient( g, h ); while q <> fail do Add( facs, h ); g := q; q := Quotient( g, h ); od; od; fi; if 0=DegreeOfLaurentPolynomial(g) then if not IsOne(g) then facs[1]:=facs[1]*g; fi; else #T how shall this ever happen? Append( facs, Factors(R,g:factoroptions:=opt) ); fi; # otherwise is the

-th power of another polynomial else # compute the

-th root of char := Characteristic(cr); r := RootsRepresentativeFFPol( R, k, char ); # factor this polynomial h := Factors( R, r: factoroptions:=opt ); # each factor appears

times in facs := []; for i in [ 1 .. char ] do Append( facs, h ); od; fi; # Sort the factorization Sort(facs); if v>0 then ind := IndeterminateOfUnivariateRationalFunction(f); facs:=Concatenation(List( [ 1 .. v ], x -> ind ),facs ); fi; # return the factorization and store it if l<>l^0 then facs[1] := facs[1]*l; fi; if not (IsBound(opt.onlydegs) or IsBound(opt.stopdegs)) then StoreFactorsPol(cr,f,facs); fi; Assert(2,Product(facs)=f); PopOptions(); return facs; end); ############################################################################# ## #F ProductPP( , ) . . . . . . . . . . . . product of two prime powers ## BindGlobal("ProductPP",function( l, r ) local res, p1, p2, ps, p, i, n; if IsEmpty(l) then return r; elif IsEmpty(r) then return l; fi; res := []; p1 := l{ 2 * [ 1 .. Length( l ) / 2 ] - 1 }; p2 := r{ 2 * [ 1 .. Length( r ) / 2 ] - 1 }; ps := Set( Union( p1, p2 ) ); for p in ps do n := 0; Add( res, p ); i := Position( p1, p ); if i <> fail then n := l[ 2*i ]; fi; i := Position( p2, p ); if i <> fail then n := n + r[ 2*i ]; fi; Add( res, n ); od; return res; end); ############################################################################# ## #F LcmPP( , ) . . . . . . . . . . . . lcm of prime powers and ## BindGlobal("LcmPP",function( l, r ) local res, p1, p2, ps, p, i, n; if l = [] then return r; elif r = [] then return l; fi; res := []; p1 := l{ 2 * [ 1 .. Length( l ) / 2 ] - 1 }; p2 := r{ 2 * [ 1 .. Length( r ) / 2 ] - 1 }; ps := Set( Union( p1, p2 ) ); for p in ps do n := 0; Add( res, p ); i := Position( p1, p ); if i <> false then n := l[ 2*i ]; fi; i := Position( p2, p ); if i <> false and n < r[ 2*i ] then n := r[ 2*i ]; fi; Add( res, n ); od; return res; end); ############################################################################# ## #F FFPPowerModCheck(, , ) . . . . . . . . . . . . . . local ## BindGlobal("FFPPowerModCheck",function( g, pp, f ) local qq, i; qq := []; for i in [ 1 .. Length(pp)/2 ] do Add( qq, pp[2*i-1] ); Add( qq, pp[2*i] ); g := PowerMod( g, pp[2*i-1] ^ pp[2*i], f ); if DegreeOfLaurentPolynomial(g) = 0 then return [ g, qq ]; fi; od; return [ g, qq ]; end); ############################################################################# ## #F OrderKnownDividendList( , ) . . . . . . . . . . . . . . . . local ## ## Computes an integer n such that OnSets( , n ) contains only one ## element e. must be a list of prime powers of an integer d such that ## n divides d. The functions returns the integer n and the element e. ## InstallGlobalFunction(OrderKnownDividendList,function( l, pp ) local pp1, # first half of pp2, # second half of a, # half exponent of first prime power k, # power of o, o1, # computed order of i; # loop # if contains no element return order 1 if Length(pp) = 0 then return [ 1, l[1] ]; # if contains only one element return order 1 elif Length(l) = 1 then return [ 1, l[1] ]; # if the dividend is a prime return elif Length(pp) = 2 and pp[2] = 1 then return [ pp[1], l[1]^pp[1] ]; # if the dividend is a prime power divide and conquer elif Length(pp) = 2 then pp := ShallowCopy(pp); a := QuoInt( pp[2], 2 ); k := OnSets( l, pp[1]^a ); # if is trivial try smaller dividend if Length(k) = 1 then pp[2] := a; return OrderKnownDividendList( l, pp ); # otherwise try to find order of else pp[2] := pp[2] - a; o := OrderKnownDividendList( k, pp ); return [ pp[1]^a*o[1], o[2] ]; fi; # split different primes into two parts else a := 2 * QuoInt( Length(pp), 4 ); pp1 := pp{[ 1 .. a ]}; pp2 := pp{[ a+1 .. Length(pp) ]}; # compute the order of ^ k := l; for i in [ 1 .. Length(pp2)/2 ] do k := OnSets( k, pp2[2*i-1]^pp2[2*i] ); od; o1 := OrderKnownDividendList( k, pp1 ); # compute the order of ^ and return o := OrderKnownDividendList( OnSets( l, o1[1] ), pp2 ); return [ o1[1]*o[1], o[2] ]; fi; end); ############################################################################# ## #F FFPOrderKnownDividend( , , , ) . . . . . . . . . . . local ## ## Computes an integer n such that ^n = const mod where and ## are polynomials in and is list of prime powers of an integer d ## such that n divides d. The functions returns the integer n and the ## element const. ## InstallGlobalFunction(FFPOrderKnownDividend,function ( R, g, f, pp ) local l, a, h, n1, pp1, pp2, k, o, q; #Info( InfoPoly, 3, "FFPOrderKnownDividend started with:" ); #Info( InfoPoly, 3, " = ", g ); #Info( InfoPoly, 3, " = ", f ); #Info( InfoPoly, 3, " = ", pp ); # if is constant return order 1 if 0 = DegreeOfLaurentPolynomial(g) then #Info( InfoPoly, 3, " is constant" ); l := CoefficientsOfUnivariatePolynomial(g); l := [ 1, l[1] ]; #Info( InfoPoly, 3, "FFPOrderKnownDividend returns ", l ); return l; # if the dividend is a prime, we must compute g^pp[1] to get the constant elif Length(pp) = 2 and pp[2] = 1 then k := PowerMod( g, pp[1], f ); l := CoefficientsOfUnivariatePolynomial(k); l := [ pp[1], l[1] ]; #Info( InfoPoly, 3, "FFPOrderKnownDividend returns ", l ); return l; # if the dividend is a prime power find the necessary power elif Length(pp) = 2 then #Info( InfoPoly, 3, "prime power, divide and conquer" ); pp := ShallowCopy( pp ); a := QuoInt( pp[2], 2 ); q := pp[1] ^ a; h := PowerMod( g, q, f ); # if is constant try again with smaller dividend if 0 = DegreeOfLaurentPolynomial(h) then pp[2] := a; o := FFPOrderKnownDividend( R, g, f, pp ); else pp[2] := pp[2] - a; l := FFPOrderKnownDividend( R, h, f, pp ); o := [ q*l[1], l[2] ]; fi; #Info( InfoPoly, 3, "FFPOrderKnownDividend returns ", o ); return o; # split different primes. else # divide primes #Info( InfoPoly, 3, " ", Length(pp)/2, " different primes" ); n1 := QuoInt( Length(pp), 4 ); pp1 := pp{[ n1*2+1 .. Length(pp) ]}; pp2 := pp{[ 1 .. n1*2 ]}; #Info( InfoPoly, 3, " = ", pp1 ); #Info( InfoPoly, 3, " = ", pp2 ); # raise to the power k := FFPPowerModCheck( g, pp2, f ); pp2 := k[2]; k := k[1]; # compute order for o := FFPOrderKnownDividend( R, k, f, pp1 ); # compute order for k := PowerMod( g, o[1], f ); l := FFPOrderKnownDividend( R, k, f, pp2 ); o := [ o[1]*l[1], l[2] ]; #Info( InfoPoly, 3, "FFPOrderKnownDividend returns ", o ); return o; fi; end); ############################################################################# ## #F FFPUpperBoundOrder( , ) . . . . . . . . . . . . . . . . . . local ## ## Computes the irreducible factors f_i of a polynomial over a field ## with p^n elements. It returns a list l of quadruples (f_i,a_i,pp_i,pb_i) such ## that the p-part of x mod f_i is p^a_i and the p'-part divides d_i for ## which the prime powers pp_i and not-yet-prime powers pb_i (in case ## factorization fails) are given. ## BindGlobal("FFPUpperBoundOrder",function( R, f ) local fs, F, L, phi, B, i, d, pp, a, deg,t,pb; # factorize into irreducible factors fs := Collected( Factors( R, f ) ); # get the field over which the polynomials are written F := CoefficientsRing(R); # (m) gives ( minpol of 1^(1/m) )( F.char ) # cache values if not IsBound(F!.FFPUBOVAL) then F!.FFPUBOVAL:=[ [PrimePowersInt( Characteristic(F)-1 ),[]] ]; fi; L:=F!.FFPUBOVAL; phi := function( m ) local x, pp, a, good,bad, d, i,primes; if not IsBound( L[m] ) then bad:=[]; x := Characteristic(F)^m-1; primes:=Set(Factors(x)); # use the Cunningham tables, and then store the prime # factors such that they end up cached below. In fact, since we # only divide off some known primes, this factorization really # shouldn't be harder than the one below. for d in Difference( DivisorsInt( m ), [m] ) do pp := phi( d ); if Length(pp[2])>0 then bad:=ProductPP(pp[2],bad); fi; pp:=pp[1]; # nothing bad can happen here as d is small for i in [ 1 .. Length(pp)/2 ] do x := x / pp[2*i-1]^pp[2*i]; od; od; a := PrimePowersInt( x:quiet ); good:=[]; for i in [1,3..Length(a)-1] do if a[i] in primes # we assume that the factorization above really gave # prime factors. or IsPrimeInt(a[i]) then Add(good,a[i]); Add(good,a[i+1]); else Add(bad,a[i]); Add(bad,a[i+1]); fi; od; good:=[good,bad]; if Length(good[1]) 1 then a := 1+LogInt(fs[i][2]-1,Characteristic(F)); fi; # p'-part: (p^n)^d_i-1/(p^n-1) where d_i is the degree of f_i d := DegreeOfLaurentPolynomial(fs[i][1]); pp := []; pb:=[]; deg := DegreeOverPrimeField(F); for f in DivisorsInt( d*deg ) do if deg mod f <> 0 then t:=phi(f); pp := ProductPP( t[1], pp ); pb := ProductPP( t[2], pb ); fi; od; # add and to Add( B, [fs[i][1],a,pp,pb] ); od; # OK, that's it return B; end); ############################################################################# ## #M ProjectiveOrder( ) . . . . . . . . . . . . . projective order of ## ## Return an integer n and a finite field element const such that x^n = ## const mod . ## InstallOtherMethod( ProjectiveOrder, "divide and conquer for univariate polynomials", true, [ IsUnivariatePolynomial ],0, function( f ) local v, R, U, x, O, n, g, q, o,rem,bas; # must not be divisible by x. v := CoefficientsOfLaurentPolynomial(f); if 0 < v[2] then Error( " must have a non zero constant term" ); fi; # if degree is zero, return if 0 = DegreeOfLaurentPolynomial(f) then return [ 1, v[1][1] ]; fi; # use 'UpperBoundOrder' to split into irreducibles #R := DefaultRing(f); R:=PolynomialRing( DefaultField(CoefficientsOfUnivariateLaurentPolynomial(f)[1]), [IndeterminateNumberOfLaurentPolynomial(f)]); U := FFPUpperBoundOrder( R, f ); # run through the irrducibles and compute their order x := IndeterminateOfUnivariateRationalFunction(f); O := []; n := 1; for g in U do if Length(g[3])=0 and Length(g[4])>0 then # in this case `FFPOrderKnownDividend' might run in an infinite # recursion. Error("cannot compute order due to limits in the integer factorization!"); fi; #o := FFPOrderKnownDividend(R,EuclideanRemainder(R,x,g[1]),g[1],g[3]); bas:=QuotRemLaurpols(x,g[1],2); o := FFPOrderKnownDividend(R,bas,g[1],g[3]); if Length(g[4])>0 then q:=DegreeOfLaurentPolynomial(PowerMod(bas,o[1],g[1])); if not(q=0 or q=DEGREE_ZERO_LAURPOL) then # in fact x^o[1] is not congruent to a constant -- we really need the # primes. Error("cannot compute order due to limits in the integer factorization!"); fi; fi; q := Characteristic(CoefficientsRing(R))^g[2]; n := LcmInt( n, o[1]*q ); Add( O, [ o[1]*q, o[2]^q ] ); od; # try to get the same constant in each block U := []; q := Size( CoefficientsRing(R) ) - 1; for g in O do AddSet( U, g[2]^((n/g[1]) mod q) ); od; # return the order times the order of o := OrderKnownDividendList( U, PrimePowersInt(q) ); return [ n*o[1], o[2] ]; end ); RedispatchOnCondition(ProjectiveOrder,true, [IsRationalFunction],[IsUnivariatePolynomial],0); ############################################################################# ## #M SplittingField( ) ## InstallMethod( SplittingField,"finite field polynomials",true, [ IsUnivariatePolynomial ],0, function( f ) local c,b,l; if Characteristic(f)=0 then TryNextMethod(); fi; c:=CoefficientsOfUnivariatePolynomial(f); if Length(c)=0 then return GF(Characteristic(f)); fi; b:=DefaultField(c); l:=List(Factors(PolynomialRing(b),f),DegreeOfLaurentPolynomial); l:=Filtered(l,i->i>0); # lcm otherwise returns 0 l:=Lcm(l); return GF(Characteristic(f)^(l*DegreeOverPrimeField(b))); end); ############################################################################# ## #E polyfinf.gi . . . . . . . . . . . . . . . . . . . . . . . . . . ends here ## gap-4r6p5/lib/cyclotom.gd0000644000175000017500000010012512172557252014053 0ustar billbill############################################################################# ## #W cyclotom.gd GAP library Thomas Breuer ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file is being maintained by Thomas Breuer. ## Please do not make any changes without consulting him. ## (This holds also for minor changes such as the removal of whitespace or ## the correction of typos.) ## ## This file declares operations for cyclotomics. ## ############################################################################# ## ## <#GAPDoc Label="DefaultField:cyclotomics"> ## ## ## ## ## for cyclotomics ## is defined to return the smallest cyclotomic field containing ## the given elements. ##

## Note that returns ## the smallest field containing all given elements, ## which need not be a cyclotomic field. ## In both cases, the fields represent vector spaces over the rationals ## (see ). ##

## Field( E(5)+E(5)^4 ); DefaultField( E(5)+E(5)^4 ); ## NF(5,[ 1, 4 ]) ## CF(5) ## ]]> ## ## ## ## <#/GAPDoc> ## ############################################################################# ## #M IsIntegralRing( ) . . . . . . Every ring of cyclotomics is integral. ## InstallTrueMethod( IsIntegralRing, IsCyclotomicCollection and IsRing and IsNonTrivial ); ############################################################################# ## #A AbsoluteValue( ) ## ## <#GAPDoc Label="AbsoluteValue"> ## ## ## ## ## returns the absolute value of a cyclotomic number cyc. ## At the moment only methods for rational numbers exist. ## AbsoluteValue(-3); ## 3 ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "AbsoluteValue" , IsCyclotomic ); ############################################################################# ## #O RoundCyc( ) ## ## <#GAPDoc Label="RoundCyc"> ## ## ## ## ## is a cyclotomic integer z (see ) ## near to the cyclotomic cyc in the following sense: ## Let c be the i-th coefficient in the external ## representation (see ) of cyc. ## Then the i-th coefficient in the external representation of ## z is Int( c + 1/2 ) or Int( c - 1/2 ), ## depending on whether c is nonnegative or negative, respectively. ##

## Expressed in terms of the Zumbroich basis ## (see ), ## rounding the coefficients of cyc w.r.t. this basis to the ## nearest integer yields the coefficients of z. ##

## RoundCyc( E(5)+1/2*E(5)^2 ); RoundCyc( 2/3*E(7)+3/2*E(4) ); ## E(5)+E(5)^2 ## -2*E(28)^3+E(28)^4-2*E(28)^11-2*E(28)^15-2*E(28)^19-2*E(28)^23 ## -2*E(28)^27 ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "RoundCyc" , [ IsCyclotomic ] ); ############################################################################# ## #O RoundCycDown( ) ## ## ## ## ## ## Performs much the same as RoundCyc, but rounds halves down. ## ## ## DeclareOperation( "RoundCycDown" , [ IsCyclotomic ] ); ############################################################################# ## #F CoeffsCyc( , ) ## ## <#GAPDoc Label="CoeffsCyc"> ## ## ## ## ## coefficients ## Let cyc be a cyclotomic with conductor n ## (see ). ## If N is not a multiple of n then ## returns fail because cyc cannot be expressed in terms of ## N-th roots of unity. ## Otherwise returns a list of length N with ## entry at position j equal to the coefficient of ## \exp(2 \pi i (j-1)/N) if this root ## belongs to the N-th Zumbroich basis ## (see ), ## and equal to zero otherwise. ## So we have ## cyc = CoeffsCyc( cyc, N ) * ## List( [1..N], j -> E(N)^(j-1) ). ##

## cyc:= E(5)+E(5)^2; ## E(5)+E(5)^2 ## gap> CoeffsCyc( cyc, 5 ); CoeffsCyc( cyc, 15 ); CoeffsCyc( cyc, 7 ); ## [ 0, 1, 1, 0, 0 ] ## [ 0, -1, 0, 0, 0, 0, 0, 0, -1, 0, 0, -1, 0, -1, 0 ] ## fail ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "CoeffsCyc" ); ############################################################################# ## #F IsGaussInt( ) . . . . . . . . test if an object is a Gaussian integer ## ## <#GAPDoc Label="IsGaussInt"> ## ## ## ## ## returns true if the object x is ## a Gaussian integer (see ), ## and false otherwise. ## Gaussian integers are of the form a + b*E(4), ## where a and b are integers. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "IsGaussInt" ); ############################################################################# ## #F IsGaussRat( ) . . . . . . . test if an object is a Gaussian rational ## ## <#GAPDoc Label="IsGaussRat"> ## ## ## ## ## returns true if the object x is ## a Gaussian rational (see ), ## and false otherwise. ## Gaussian rationals are of the form a + b*E(4), ## where a and b are rationals. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "IsGaussRat" ); ############################################################################## ## #F DescriptionOfRootOfUnity( ) ## ## <#GAPDoc Label="DescriptionOfRootOfUnity"> ## ## ## ## ## logarithm ##

## Given a cyclotomic root that is known to be a root of unity ## (this is not checked), ## returns a list [ n, e ] ## of coprime positive integers such that ## root = E(n)^e holds. ##

## E(9); DescriptionOfRootOfUnity( E(9) ); ## -E(9)^4-E(9)^7 ## [ 9, 1 ] ## gap> DescriptionOfRootOfUnity( -E(3) ); ## [ 6, 5 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "DescriptionOfRootOfUnity" ); ############################################################################# ## #F EB( ) . . . . . . . . . . . . . . . some atomic ATLAS irrationalities #F EC( ) #F ED( ) #F EE( ) #F EF( ) #F EG( ) #F EH( ) ## ## <#GAPDoc Label="EB"> ## ## EB, EC, \ldots, EH ## ## ## ## ## ## ## ## ## ## b_N (irrational value) ## c_N (irrational value) ## d_N (irrational value) ## e_N (irrational value) ## f_N (irrational value) ## g_N (irrational value) ## h_N (irrational value) ## For a positive integer N, ## let z = E(N) = \exp(2 \pi i/N). ## The following so-called atomic irrationalities ## (see ) ## can be entered using functions. ## (Note that the values are not necessary irrational.) ##

## ## ## EB(N) ## = ## b_{N} ## = ## \left( \sum_{{j = 1}}^{{N-1}} z^{{j^2}} \right) / 2 ## ## , ## N \equiv 1 \pmod{2} ## ## ## EC(N) ## = ## c_{N} ## = ## \left( \sum_{{j = 1}}^{{N-1}} z^{{j^3}} \right) / 3 ## ## , ## N \equiv 1 \pmod{3} ## ## ## ED(N) ## = ## d_{N} ## = ## \left( \sum_{{j = 1}}^{{N-1}} z^{{j^4}} \right) / 4 ## ## , ## N \equiv 1 \pmod{4} ## ## ## EE(N) ## = ## e_{N} ## = ## \left( \sum_{{j = 1}}^{{N-1}} z^{{j^5}} \right) / 5 ## ## , ## N \equiv 1 \pmod{5} ## ## ## EF(N) ## = ## f_{N} ## = ## \left( \sum_{{j = 1}}^{{N-1}} z^{{j^6}} \right) / 6 ## ## , ## N \equiv 1 \pmod{6} ## ## ## EG(N) ## = ## g_{N} ## = ## \left( \sum_{{j = 1}}^{{N-1}} z^{{j^7}} \right) / 7 ## ## , ## N \equiv 1 \pmod{7} ## ## ## EH(N) ## = ## h_{N} ## = ## \left( \sum_{{j = 1}}^{{N-1}} z^{{j^8}} \right) / 8 ## ## , ## N \equiv 1 \pmod{8} ## ##
## (Note that in EC(N), \ldots, ## EH(N), N must be a prime.) ##

## EB(5); EB(9); ## E(5)+E(5)^4 ## 1 ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "EB" ); DeclareGlobalFunction( "EC" ); DeclareGlobalFunction( "ED" ); DeclareGlobalFunction( "EE" ); DeclareGlobalFunction( "EF" ); DeclareGlobalFunction( "EG" ); DeclareGlobalFunction( "EH" ); ############################################################################# ## #F EI( ) . . . . ATLAS irrationality $i_{}$ (the square root of -) #F ER( ) . . . . ATLAS irrationality $r_{}$ (pos. square root of ) ## ## <#GAPDoc Label="EI"> ## ## EI and ER ## ## ## ## ## i_N (irrational value) ## r_N (irrational value) ## For a rational number N, ## returns the square root \sqrt{{N}} of ## N, ## and returns \sqrt{{-N}}. ## By the chosen embedding of cyclotomic fields into the complex numbers, ## returns the positive square root if N is ## positive, and if N is negative then ## ER(N) = EI(-N) holds. ## In any case, EI(N) = E(4) * ER(N). ##

## is installed as method for the operation ## , for rational argument. ##

## From a theorem of Gauss we know that ## b_{N} = ## ## ## (-1 + \sqrt{{N}}) / 2 ## if ## N \equiv 1 \pmod 4 ## ## ## (-1 + i \sqrt{{N}}) / 2 ## if ## N \equiv -1 \pmod 4 ## ##
## So \sqrt{{N}} can be computed from b_{N}, ## see . ##

## ER(3); EI(3); ## -E(12)^7+E(12)^11 ## E(3)-E(3)^2 ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "EI" ); DeclareGlobalFunction( "ER" ); ############################################################################# ## #F EY( [, ] ) #F EX( [, ] ) #F EW( [, ] ) #F EV( [, ] ) #F EU( [, ] ) #F ET( [, ] ) #F ES( [, ] ) ## ## <#GAPDoc Label="EY"> ## ## EY, EX, \ldots, ES ## ## ## ## ## ## ## ## ## ## s_N (irrational value) ## t_N (irrational value) ## u_N (irrational value) ## v_N (irrational value) ## w_N (irrational value) ## x_N (irrational value) ## y_N (irrational value) ## For the given integer N > 2, ## let N_k denote the first integer ## with multiplicative order exactly k modulo N, ## chosen in the order of preference ## ## 1, -1, 2, -2, 3, -3, 4, -4, \ldots . ## ##

## We define (with z = \exp(2 \pi i/N)) ## ## ## EY(N) ## = ## y_{N} ## = ## z + z^n ## (n = N_2) ## ## ## EX(N) ## = ## x_{N} ## = ## z + z^n + z^{{n^2}} ## (n = N_3) ## ## ## EW(N) ## = ## w_{N} ## = ## z + z^n + z^{{n^2}} + z^{{n^3}} ## (n = N_4) ## ## ## EV(N) ## = ## v_{N} ## = ## z + z^n + z^{{n^2}} + z^{{n^3}} + z^{{n^4}} ## (n = N_5) ## ## ## EU(N) ## = ## u_{N} ## = ## z + z^n + z^{{n^2}} + \ldots + z^{{n^5}} ## (n = N_6) ## ## ## ET(N) ## = ## t_{N} ## = ## z + z^n + z^{{n^2}} + \ldots + z^{{n^6}} ## (n = N_7) ## ## ## ES(N) ## = ## s_{N} ## = ## z + z^n + z^{{n^2}} + \ldots + z^{{n^7}} ## (n = N_8) ## ##
##

## For the two-argument versions of the functions, ## see Section . ##

## EY(5); ## E(5)+E(5)^4 ## gap> EW(16,3); EW(17,2); ## 0 ## E(17)+E(17)^4+E(17)^13+E(17)^16 ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "EY" ); DeclareGlobalFunction( "EX" ); DeclareGlobalFunction( "EW" ); DeclareGlobalFunction( "EV" ); DeclareGlobalFunction( "EU" ); DeclareGlobalFunction( "ET" ); DeclareGlobalFunction( "ES" ); ############################################################################# ## #F EM( [, ] ) #F EL( [, ] ) #F EK( [, ] ) #F EJ( [, ] ) ## ## <#GAPDoc Label="EM"> ## ## EM, EL, \ldots, EJ ## ## ## ## ## ## ## Let N be an integer, N > 2. ## We define (with z = \exp(2 \pi i/N)) ## j_N (irrational value) ## k_N (irrational value) ## l_N (irrational value) ## m_N (irrational value) ## ## ## EM(N) ## = ## m_{N} ## = ## z - z^n ## (n = N_2) ## ## ## EL(N) ## = ## l_{N} ## = ## z - z^n + z^{{n^2}} - z^{{n^3}} ## (n = N_4) ## ## ## EK(N) ## = ## k_{N} ## = ## z - z^n + \ldots - z^{{n^5}} ## (n = N_6) ## ## ## EJ(N) ## = ## j_{N} ## = ## z - z^n + \ldots - z^{{n^7}} ## (n = N_8) ## ##
##

## For the two-argument versions of the functions, ## see Section . ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "EM" ); DeclareGlobalFunction( "EL" ); DeclareGlobalFunction( "EK" ); DeclareGlobalFunction( "EJ" ); ############################################################################# ## #F NK( , , ) . . . . . . . . . . utility for ATLAS irrationalities ## ## <#GAPDoc Label="NK"> ## ## ## ## ## Let N_{k}^{(d)} be the (d+1)-th ## integer with multiplicative order exactly k modulo N, ## chosen in the order of preference defined in Section ; ## returns N_{k}^{(d)}; ## if there is no integer with the required multiplicative order, ## returns fail. ##

## We write N_{k} = N_{k}^{(0)}, ## N_{k}^{\prime} = N_{k}^{(1)}, ## N_{k}^{\prime\prime} = N_{k}^{(2)} ## and so on. ##

## The algebraic numbers ## ## y_{N}^{\prime} = y_{N}^{(1)}, ## y_{N}^{\prime\prime} = y_{N}^{(2)}, \ldots, ## x_{N}^{\prime}, x_{N}^{\prime\prime}, \ldots, ## j_{N}^{\prime}, j_{N}^{\prime\prime}, \ldots ## ## are obtained on replacing N_{k} in the ## definitions in the sections and ## by N_{k}^{\prime}, ## N_{k}^{\prime\prime}, \ldots; ## they can be entered as ##

## ## ## EY(N,d) ## = ## y_{N}^{(d)} ## ## ## EX(N,d) ## = ## x_{N}^{(d)} ## ## ## ## \ldots ## ## ## ## EJ(N,d) ## = ## j_{N}^{(d)} ## ##
## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "NK" ); ############################################################################# ## #F AtlasIrrationality( ) ## ## <#GAPDoc Label="AtlasIrrationality"> ## ## ## ## ## Let irratname be a string that describes an irrational value as ## a linear combination in terms of the atomic irrationalities introduced in ## the sections , , ## , . ## These irrational values are defined in ## , and the following ## description is mainly copied from there. ## If q_N is such a value (e.g. y_{24}^{\prime\prime}) ## then linear combinations of algebraic conjugates of q_N are ## abbreviated as in the following examples: ##

## ## ## 2qN+3&5-4&7+&9 ## means ## 2 q_N + 3 q_N^{{*5}} - 4 q_N^{{*7}} + q_N^{{*9}} ## ## ## ## 4qN&3&5&7-3&4 ## means ## 4 (q_N + q_N^{{*3}} + q_N^{{*5}} + q_N^{{*7}}) ## - 3 q_N^{{*11}} ## ## ## 4qN*3&5+&7 ## means ## 4 (q_N^{{*3}} + q_N^{{*5}}) + q_N^{{*7}} ## ##
##

## To explain the ampersand syntax in general we remark that ## &k is interpreted as q_N^{{*k}}, ## where q_N is the most recently named atomic irrationality, ## and that the scope of any premultiplying coefficient is broken by a ## + or - sign, but not by \& or *k. ## The algebraic conjugations indicated by the ampersands apply directly to ## the atomic irrationality q_N, even when, ## as in the last example, ## q_N first appears with another conjugacy *k. ##

## AtlasIrrationality( "b7*3" ); ## E(7)^3+E(7)^5+E(7)^6 ## gap> AtlasIrrationality( "y'''24" ); ## E(24)-E(24)^19 ## gap> AtlasIrrationality( "-3y'''24*13&5" ); ## 3*E(8)-3*E(8)^3 ## gap> AtlasIrrationality( "3y'''24*13-2&5" ); ## -3*E(24)-2*E(24)^11+2*E(24)^17+3*E(24)^19 ## gap> AtlasIrrationality( "3y'''24*13-&5" ); ## -3*E(24)-E(24)^11+E(24)^17+3*E(24)^19 ## gap> AtlasIrrationality( "3y'''24*13-4&5&7" ); ## -7*E(24)-4*E(24)^11+4*E(24)^17+7*E(24)^19 ## gap> AtlasIrrationality( "3y'''24&7" ); ## 6*E(24)-6*E(24)^19 ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "AtlasIrrationality" ); ############################################################################# ## #F StarCyc( ) . . . . the unique nontrivial Galois conjugate of ## ## <#GAPDoc Label="StarCyc"> ## ## ## ## ## If the cyclotomic cyc is an irrational element of a quadratic ## extension of the rationals then returns the unique ## Galois conjugate of cyc that is different from cyc, ## otherwise fail is returned. ## In the first case, the return value is often called cyc* ## (see ). ##

## StarCyc( EB(5) ); StarCyc( E(5) ); ## E(5)^2+E(5)^3 ## fail ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "StarCyc" ); ############################################################################# ## #F Quadratic( ) . . . . . information about quadratic irrationalities ## ## <#GAPDoc Label="Quadratic"> ## ## ## ## ## Let cyc be a cyclotomic integer that lies in a quadratic extension ## field of the rationals. ## Then we have cyc = (a + b \sqrt{{n}}) / d, ## for integers a, b, n, d, ## such that d is either 1 or 2. ## In this case, returns a record with the ## components a, b, root, d, ATLAS, ## and display; ## the values of the first four are a, b, n, ## and d, ## the ATLAS value is a (not necessarily shortest) representation of ## cyc in terms of the &ATLAS; irrationalities ## b_{{|n|}}, i_{{|n|}}, r_{{|n|}}, ## and the display value is a string that expresses cyc in ## &GAP; notation, corresponding to the value of the ATLAS component. ##

## If cyc is not a cyclotomic integer or does not lie in a quadratic ## extension field of the rationals then fail is returned. ##

## If the denominator d is 2 then necessarily n is ## congruent to 1 modulo 4, ## and r_n, i_n are not possible; ## we have cyc = x + y * EB( root ) ## with y = b, x = ( a + b ) / 2. ##

## If d = 1, we have the possibilities ## i_{{|n|}} for n < -1, ## a + b * i for n = -1, a + b * r_n ## for n > 0. ## Furthermore if n is congruent to 1 modulo 4, ## also cyc = (a+b) + 2 * b * b_{{|n|}} is possible; ## the shortest string of these is taken as the value for the component ## ATLAS. ##

## Quadratic( EB(5) ); Quadratic( EB(27) ); ## rec( ATLAS := "b5", a := -1, b := 1, d := 2, ## display := "(-1+Sqrt(5))/2", root := 5 ) ## rec( ATLAS := "1+3b3", a := -1, b := 3, d := 2, ## display := "(-1+3*Sqrt(-3))/2", root := -3 ) ## gap> Quadratic(0); Quadratic( E(5) ); ## rec( ATLAS := "0", a := 0, b := 0, d := 1, display := "0", root := 1 ) ## fail ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "Quadratic" ); ############################################################################# ## #A GaloisMat( ) ## ## <#GAPDoc Label="GaloisMat"> ## ## ## ## ## Let mat be a matrix of cyclotomics. ## calculates the complete orbits under ## the operation of the Galois group of the (irrational) entries of ## mat, ## and the permutations of rows corresponding to the generators of the ## Galois group. ##

## If some rows of mat are identical, ## only the first one is considered for the permutations, ## and a warning will be printed. ##

## returns a record with the components mat, ## galoisfams, and generators. ##

## ## mat ## ## a list with initial segment being the rows of mat ## (not shallow copies of these rows); ## the list consists of full orbits under the action of the Galois ## group of the entries of mat defined above. ## The last rows in the list are those not contained in mat but ## must be added in order to complete the orbits; ## so if the orbits were already complete, mat and mat have ## identical rows. ## ## galoisfams ## ## a list that has the same length as the mat component, ## its entries are either 1, 0, -1, or lists. ## ## galoisfams[i] = 1 ## ## means that mat[i] consists of rationals, ## i.e., [ mat[i] ] forms an orbit; ## ## galoisfams[i] = -1 ## ## means that mat[i] contains unknowns ## (see Chapter ); ## in this case [ mat[i] ] is regarded as an orbit, too, ## even if mat[i] contains irrational entries; ## ## galoisfams[i] = [ l_1, l_2 ] ## ## (a list) means that mat[i] is the first element of its orbit ## in mat, ## l_1 is the list of positions of rows that form the orbit, ## and l_2 is the list of corresponding Galois automorphisms ## (as exponents, not as functions); ## so we have mat[ l_1[j] ][k] = ## GaloisCyc( mat[i][k], l_2[j] ); ## ## galoisfams[i] = 0 ## ## means that mat[i] is an element of a ## nontrivial orbit but not the first element of it. ## ## ## ## generators ## ## a list of permutations generating the permutation group ## corresponding to the action of the Galois group on the rows of ## mat. ## ## ##

## GaloisMat( [ [ E(3), E(4) ] ] ); ## rec( galoisfams := [ [ [ 1, 2, 3, 4 ], [ 1, 7, 5, 11 ] ], 0, 0, 0 ], ## generators := [ (1,2)(3,4), (1,3)(2,4) ], ## mat := [ [ E(3), E(4) ], [ E(3), -E(4) ], [ E(3)^2, E(4) ], ## [ E(3)^2, -E(4) ] ] ) ## gap> GaloisMat( [ [ 1, 1, 1 ], [ 1, E(3), E(3)^2 ] ] ); ## rec( galoisfams := [ 1, [ [ 2, 3 ], [ 1, 2 ] ], 0 ], ## generators := [ (2,3) ], ## mat := [ [ 1, 1, 1 ], [ 1, E(3), E(3)^2 ], [ 1, E(3)^2, E(3) ] ] ) ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "GaloisMat", IsMatrix ); ############################################################################# ## #A RationalizedMat( ) . . . . . . list of rationalized rows of ## ## <#GAPDoc Label="RationalizedMat"> ## ## ## ## ## returns the list of rationalized rows of mat, ## which must be a matrix of cyclotomics. ## This is the set of sums over orbits under the action of the Galois group ## of the entries of mat (see ), ## so the operation may be viewed as a kind of trace on the rows. ##

## Note that no two rows of mat should be equal. ##

## mat:= [ [ 1, 1, 1 ], [ 1, E(3), E(3)^2 ], [ 1, E(3)^2, E(3) ] ];; ## gap> RationalizedMat( mat ); ## [ [ 1, 1, 1 ], [ 2, -1, -1 ] ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "RationalizedMat", IsMatrix ); ############################################################################# ## #F DenominatorCyc( ) ## ## <#GAPDoc Label="DenominatorCyc"> ## ## ## ## ## For a cyclotomic number cyc (see ), ## this function returns the smallest positive integer n such that ## n * cyc is a cyclotomic integer ## (see ). ## For rational numbers cyc, the result is the same as that of ## . ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "DenominatorCyc" ); ############################################################################# ## #E gap-4r6p5/lib/matobj1.gd0000644000175000017500000000536012172557252013564 0ustar billbill############################################################################ # # matobj1.gd # by Max Neunhöffer # ## Copyright (C) 2007 Max Neunhöffer, Lehrstuhl D f. Math., RWTH Aachen ## This file is free software, see license information at the end. # # This file together with matobj2.gd formally define the interface to the # new style vectors and matrices in GAP. # In this file the categories are defined, it is read earlier in the # GAP library reading process. # ############################################################################ ############################################################################ ############################################################################ # Categories for vectors and matrices: ############################################################################ ############################################################################ DeclareCategory( "IsRowVectorObj", IsVector and IsCopyable ); # All the arithmetical filters come from IsVector. # RowVectors are no longer necessarily lists, since they do not promise all # list operations. Of course, in specific implementations the objects # may still be lists. But beware: Some matrix representations might # rely on the fact that vectors cannot change their length! # The family of an object in IsRowVectorObj is the same as the family of # the base domain. # There are one main category for matrices and two disjoint sub-categories: DeclareCategory( "IsMatrixObj", IsVector and IsScalar and IsCopyable ); # All the arithmetical filters come from IsVector and IsScalar. # In particular, matrices are in "IsMultiplicativeElement" which defines # powering with a positive integer by the (kernel) method for POW_OBJ_INT. # Note that this is at least strange for non-associative base domains. # Matrices are no longer necessarily lists, since they do not promise all list # operations! Of course, in specific implementations the objects may # still be lists. # The family of an object in IsMatrixObj is the collections family of # the family of its base domain. DeclareCategory( "IsRowListMatrix", IsMatrixObj ); # The category of matrices behaving like lists of rows which are GAP objects. # Different matrices in this category can share rows and the same row can # occur more than once in a matrix. Row access just gives a reference # to the row object. DeclareCategory( "IsFlatMatrix", IsMatrixObj ); # The category of "flatly" stored matrices. They behave as if all their rows # were in one single chunk of memory, such that rows are not individual # GAP objects. Writing row access and slicing always copies. # Note that read-accessing the i-th row of a flat matrix twice can # yield two non-identical objects! gap-4r6p5/lib/ffeconway.gi0000644000175000017500000013216112172557252014215 0ustar billbill############################################################################# ## #W ffeconway.gi GAP library Steve Linton ## ## #Y Copyright (C) 2005 The GAP Group ## ## This file contains methods for `FFE's represented as library objects by ## coefficients of polynomials modulo the Conway polynomial. ## ############################################################################# ## #R IsCoeffsModConwayPolRep( ) ## ## An element in this representation is stored a three component ## PositionalObject ## ## The first component is a mutable vector giving the coefficients of a polynomial ## over a prime field. Where appropriate, this should be compressed. ## ## The second component is an integer specifying the degree of the field extension ## over the prime field in which this element is written. ## ## The third component may hold the representation of the element written over ## the field extension that it generates. If this is 'fail' then this is not known ## if it is 'false' then the element is known to be irreducible. This value may be ## an internal FFE or a ZmodpZ object. ## ## ## BindGlobal("IsCoeffsModConwayPolRep", NewRepresentation( "IsCoeffsModConwayPolRep", IsPositionalObjectRep,3)); ############################################################################# ## #V FFECONWAY is a holder for private function ## BindGlobal("FFECONWAY", rec()); ############################################################################# ## #F FFECONWAY.ZNC(

,) .. construct a primitive root ## ## this function also deals with construction and caching of the ## Conway Polynomial and associated data. It must always be called before ## any computation with elements of GF(p^d) ## ## To support computing with these objects, a variety of data is stored in the ## FFEFamily: ## ## 'fam!.ConwayFldEltDefaultType' contains the type of the field elements in this ## characteristic and representation ## 'fam!.ConwayPolCoeffs[d]' contains the coefficients of the Conway Polynomial ## for GF(p^d) ## 'fam!.ConwayFldEltReducers[d]' contains a function which will take a mutable ## vector of FFEs in compressed format (if appropriate) ## reduce it modulo the Conway polynomial and fix its ## length to be exactly 'd' ## 'fam!.ZCache[d]' contains 'Z(p,d)' once it has been computed. ## FFECONWAY.SetUpConwayStuff := function(p,d) local fam, cp, cps, i; fam := FFEFamily(p); if not IsBound(fam!.ConwayPolCoeffs) then fam!.ConwayPolCoeffs := []; fam!.ConwayFldEltReducers := []; fi; if not IsBound(fam!.ConwayPolCoeffs[d]) then if not IsCheapConwayPolynomial(p,d) then Error("Conway Polynomial ",p,"^",d, " will need to computed and might be slow\n", "return to continue"); fi; cp := CoefficientsOfUnivariatePolynomial(ConwayPolynomial(p,d)); fam!.ConwayPolCoeffs[d] := cp; # # various cases for reducers # if p = 2 then fam!.ConwayFldEltReducers[d] := function(v) REDUCE_COEFFS_GF2VEC(v,Length(v),cp,d+1); RESIZE_GF2VEC(v,d); end; elif p <= 256 then # # We can save time on repeated reductions using # pre-computed shifts # cps := MAKE_SHIFTED_COEFFS_VEC8BIT(cp,d+1); fam!.ConwayFldEltReducers[d] := function(v) REDUCE_COEFFS_VEC8BIT(v,Length(v),cps); RESIZE_VEC8BIT(v,d); end; else # # Need to adjust the length "by hand" # fam!.ConwayFldEltReducers[d] := function(v) ReduceCoeffs(v,Length(v),cp,d+1); if Length(v) < d then PadCoeffs(v,d); elif Length(v) > d then for i in [d+1..Length(v)] do Unbind(v[i]); od; fi; end; fi; fi; end; FFECONWAY.ZNC := function(p,d) local fam, zc, v; fam := FFEFamily(p); if not IsBound(fam!.ZCache) then fam!.ZCache := []; fi; zc := fam!.ZCache; if not IsBound(zc[d]) then if not IsBound(fam!.ConwayFldEltDefaultType) then fam!.ConwayFldEltDefaultType := NewType(fam, IsCoeffsModConwayPolRep and IsLexOrderedFFE); fi; FFECONWAY.SetUpConwayStuff(p,d); # # Finally make the element # 'false' in the third component because we know it is # irreducible # v := ListWithIdenticalEntries(d,0*Z(p)); v[2] := Z(p)^0; ConvertToVectorRep(v,p); zc[d] := Objectify(fam!.ConwayFldEltDefaultType, [v,d,false]); fi; return zc[d]; end; ############################################################################# ## #M Z(p,d), Z(q) .. ## ## check various things and call FFECONWAY.ZNC InstallOtherMethod(ZOp, [IsPosInt, IsPosInt], function(p,d) local q; q := p^d; if q <= MAXSIZE_GF_INTERNAL or d =1 then return Z(q); fi; return FFECONWAY.ZNC(p,d); end); InstallMethod(ZOp, [IsPosInt], function(q) local p, d; if q <= MAXSIZE_GF_INTERNAL then TryNextMethod(); # should never happen fi; p := SmallestRootInt(q); d := LogInt(q,p); Assert(1, q=p^d); Assert(2, IsProbablyPrimeInt(p)); if d > 1 then return FFECONWAY.ZNC(p,d); fi; TryNextMethod(); end); ############################################################################# ## #M PrintObj( ) #M String( ) #M ViewObj( ) #M ViewString( ) #M Display( ) #M DisplayString( ) ## ## output methods ## InstallMethod(String,"For large finite field elements", [IsFFE and IsCoeffsModConwayPolRep], function(x) local started, coeffs, fam, s, str, i; if not IsBool(x![3]) then return String(x![3]); fi; started := false; coeffs := x![1]; fam := FamilyObj(x); s := Concatenation("Z(",String(fam!.Characteristic),",",String(x![2]),")"); if Length(coeffs) = 0 then str := "0*"; Append(str,s); return str; fi; str := ""; if not IsZero(coeffs[1]) then Append(str,String(coeffs[1])); started := true; fi; for i in [2..Length(coeffs)] do if not IsZero(coeffs[i]) then if started then Add(str,'+'); fi; if not IsOne(coeffs[i]) then Append(str,String(IntFFE(coeffs[i]))); Add(str,'*'); fi; Append(str,s); if i > 2 then Add(str,'^'); Append(str,String(i-1)); fi; started := true; fi; od; if not started then str := "0*"; Append(str,s); fi; return str; end); InstallMethod(PrintObj, "for large finite field elements (use String)", [IsFFE and IsCoeffsModConwayPolRep], function(x) Print(String(x)); end); BindGlobal( "DisplayStringForLargeFiniteFieldElements", function(x) local s, j, a; if IsZero(x) then return "0z\n"; elif IsOne(x) then return "z0\n"; fi; s := ""; for j in [0..x![2]-1] do a := IntFFE(x![1][j+1]); if a <> 0 then if Length(s) <> 0 then Append(s,"+"); fi; if a <> 1 or j = 0 then Append(s,String(a)); fi; if j <> 0 then Append(s,"z"); if j <> 1 then Append(s,String(j)); fi; fi; fi; od; Add(s,'\n'); return s; end ); InstallMethod(DisplayString,"For large finite field elements", [IsFFE and IsCoeffsModConwayPolRep], DisplayStringForLargeFiniteFieldElements ); InstallMethod(Display,"For large finite field elements", [IsFFE and IsCoeffsModConwayPolRep], function(x) Print(DisplayString(x)); end); InstallMethod(ViewString,"For large finite field elements", [IsFFE and IsCoeffsModConwayPolRep], function(x) local s; s := DisplayStringForLargeFiniteFieldElements(x); if Length(s) > ViewLength()*SizeScreen()[1] then return Concatenation("<>"); else Remove(s); # get rid of trailing newline return s; fi; end); InstallMethod(ViewObj, "For large finite field elements", [IsFFE and IsCoeffsModConwayPolRep], function(x) Print(ViewString(x)); end); ############################################################################# ## #F FFECONWAY.GetConwayPolCoeffs( , ) ## ## returns stored Conway Polynomial coefficients from family ## triggers computation if needed. ## FFECONWAY.GetConwayPolCoeffs := function(f,d) local p; if not IsBound(f!.ConwayPolCoeffs) then f!.ConwayPolCoeffs := []; fi; if not IsBound(f!.ConwayPolCoeffs[d]) then p := f!.Characteristic; FFECONWAY.SetUpConwayStuff(p,d); fi; return f!.ConwayPolCoeffs[d]; end; ############################################################################# ## #F FFECONWAY.FiniteFieldEmbeddingRecord(, , ) ## ## returns a record (stored in the family after it is first computed) ## describing the embedding of F1 = GF(p^d1) into F2= GF(p^d2). The components ## of this record are: ## ## mat: a x matrix whose rows are the canonical basis of F1 ## semi: a semi-echelonized version of mat ## convert: a x matrix such that * = ## pivots: a vector giving the position of the first non-zero entry in each ## row of ## FFECONWAY.FiniteFieldEmbeddingRecord := function(p, d1,d2) local fam, c, n, zz, x, z1, m, z, i, r, res; fam := FFEFamily(p); if not IsBound(fam!.embeddingRecords) then fam!.embeddingRecords := []; fi; if not IsBound(fam!.embeddingRecords[d2]) then fam!.embeddingRecords[d2] := []; fi; if not IsBound(fam!.embeddingRecords[d2][d1]) then c := FFECONWAY.GetConwayPolCoeffs(fam,d2); n := (p^d2-1)/(p^d1-1); zz := 0*Z(p); x := [zz,Z(p)^0]; ConvertToVectorRep(x,p); z1 := PowerModCoeffs(x,n,c); fam!.ConwayFldEltReducers[d2](z1); m := [ZeroMutable(z1),z1]; m[1][1] := Z(p)^0; z := z1; for i in [2..d1-1] do z := ProductCoeffs(z,z1); fam!.ConwayFldEltReducers[d2](z); Add(m,z); od; ConvertToMatrixRep(m,p); r := rec( mat := m); res := SemiEchelonMatTransformation(r.mat); r.semi := res.vectors; r.convert := res.coeffs; r.pivots := []; for i in [1..Length(res.heads)] do if res.heads[i] > 0 then r.pivots[res.heads[i]] := i; fi; od; Assert(2,d1 = 1 or res.relations = []); fam!.embeddingRecords[d2][d1] := r; fi; return fam!.embeddingRecords[d2][d1]; end; ############################################################################# ## #F FFECONWAY.WriteOverLargerField( , ) ## ## returns an element written over a field of degree , but equal to ## can be an internal FFE or a ZmodpZ object ## FFECONWAY.WriteOverLargerField := function(x,d2) local fam, p, d1, v, f, y; fam := FamilyObj(x); p := fam!.Characteristic; if p^d2 <= MAXSIZE_GF_INTERNAL then return x; fi; if not IsCoeffsModConwayPolRep(x) then d1 := DegreeFFE(x); if d1 = d2 then return x; fi; v := Coefficients(CanonicalBasis(AsField(GF(p,1),GF(p,d1))),x); else d1 := x![2]; if d1 = d2 then return x; fi; v := x![1]; fi; Assert(1,d2 mod d1 = 0); f := FFECONWAY.FiniteFieldEmbeddingRecord(p,d1,d2); if not IsCoeffsModConwayPolRep(x) or x![3] = false then y := x; elif x![3] <> fail then y := x![3]; else y := fail; fi; return Objectify(fam!.ConwayFldEltDefaultType, [v*f!.mat,d2,y]); end; ############################################################################# ## #F FFECONWAY.TryToWriteInSmallerField( , ) ## ## returns an element written over a field of degree , but equal to ## if possibe, otherwise fail. The returned element may be an internal FFE ## or a ZmodpZ object. ## FFECONWAY.TryToWriteInSmallerField := function(x,d1) local dmin, fam, p, d2, smalld, r, v, v2, i, piv, w, oversmalld, z; if IsInternalRep(x) then return fail; fi; if IsZmodpZObj(x) then return fail; fi; if d1 = x![2] then return fail; fi; if x![3] = false then return fail; fi; if x![3] <> fail then if IsCoeffsModConwayPolRep(x![3]) then dmin := x![3]![2]; else dmin := DegreeFFE(x![3]); fi; if dmin = d1 then return x![3]; elif d1 mod dmin = 0 then return FFECONWAY.WriteOverLargerField(x![3],d1); else return fail; fi; fi; fam := FamilyObj(x); p := fam!.Characteristic; d2 := x![2]; if not IsMutable(x![1]) then x![1] := ShallowCopy(x![1]); fi; PadCoeffs(x![1],d2); smalld := Gcd(d1,d2); r := FFECONWAY.FiniteFieldEmbeddingRecord(p, smalld,d2); v := ShallowCopy(x![1]); v2 := ZeroMutable(r.convert[1]); for i in [1..smalld] do piv := r.pivots[i]; w := r.semi[i]; x := v[piv]/w[piv]; AddCoeffs(v,w,-x); AddCoeffs(v2,r.convert[i],x); od; if not IsZero(v) then return fail; fi; if d1 = 1 then oversmalld := v2[1]; elif p^d1 <= MAXSIZE_GF_INTERNAL then z := Z(p^smalld); oversmalld := Sum([1..smalld], i-> z^(i-1)*v2[i]); else oversmalld := Objectify(fam!.ConwayFldEltDefaultType,[v2,d1,fail]); fi; if smalld < d1 then return FFECONWAY.WriteOverLargerField(oversmalld, d1); else return oversmalld; fi; end; ############################################################################# ## #F FFECONWAY.WriteOverSmallestField( ) ## ## Returns written over the field it generates. ## FFECONWAY.WriteOverSmallestField := function(x) local d, f, fac, l, d1, x1, x2; if IsInternalRep(x) or IsZmodpZObj(x) then return x; fi; if x![3] = false then return x; elif x![3] <> fail then return x![3]; fi; d := x![2]; f := Collected(FactorsInt(d)); for fac in f do l := fac[1]; d1 := d/l; x1 := FFECONWAY.TryToWriteInSmallerField(x,d1); if x1 <> fail then x2 := FFECONWAY.WriteOverSmallestField(x1); x![3] := x2; return x2; fi; od; x![3] := false; return x; end; ############################################################################# ## #M DegreeFFE( ) InstallMethod(DegreeFFE, [IsCoeffsModConwayPolRep and IsFFE], function(x) local y; y := FFECONWAY.WriteOverSmallestField(x); if IsCoeffsModConwayPolRep(y) then return y![2]; else return DegreeFFE(y); fi; end); ############################################################################# ## #M \=(,) ## ## Includes equality with internal FFE and ZmodpZ objects ## InstallMethod(\=, IsIdenticalObj, [IsCoeffsModConwayPolRep and IsFFE, IsCoeffsModConwayPolRep and IsFFE], function(x1,x2) local d1, d2, y2, y1, d; d1 := x1![2]; d2 := x2![2]; if d1 = d2 then return x1![1] = x2![1]; fi; if d2 mod d1 = 0 then y2 := FFECONWAY.TryToWriteInSmallerField(x2,d1); if y2 = fail then return false; else return y2![1] = x1![1]; fi; elif d1 mod d2 = 0 then y1 := FFECONWAY.TryToWriteInSmallerField(x1,d2); if y1 = fail then return false; else return y1![1] = x2![1]; fi; else d := Gcd(d1,d2); y1 := FFECONWAY.TryToWriteInSmallerField(x1,d); if y1 = fail then return false; fi; y2 := FFECONWAY.TryToWriteInSmallerField(x2,d); if y2 = fail then return false; fi; return y1 = y2; fi; end); InstallMethod(\=, IsIdenticalObj, [IsCoeffsModConwayPolRep and IsFFE, IsFFE], function(x1,x2) local d2, y1; d2 := DegreeFFE(x2); y1 := FFECONWAY.TryToWriteInSmallerField(x1,d2); if y1 = fail then return false; else return y1 = x2; fi; end); InstallMethod(\=, IsIdenticalObj, [ IsFFE, IsCoeffsModConwayPolRep and IsFFE], function(x1,x2) local d1, y2; d1 := DegreeFFE(x1); y2 := FFECONWAY.TryToWriteInSmallerField(x2,d1); if y2 = fail then return false; else return y2 = x1; fi; end); ############################################################################# ## #F FFECONWAY.CoeffsOverCommonField(,) .. utility function ## ## Returns a length 3 list. The first and second entries of the ## list are the coefficient vectors of the two arguments written over ## a field which contains both of them, whose degree is the third entry ## FFECONWAY.CoeffsOverCommonField := function(x1,x2) local fam, d1, d2, v1, v2, d, y2, y1; fam := FamilyObj(x1); if IsCoeffsModConwayPolRep(x1) then d1 := x1![2]; v1 := x1![1]; else d1 := DegreeFFE(x1); fi; if IsCoeffsModConwayPolRep(x2) then d2 := x2![2]; v2 := x2![1]; else d2 := DegreeFFE(x2); fi; if d1 = d2 then d := d1; elif d1 mod d2 = 0 then y2 := FFECONWAY.WriteOverLargerField(x2,d1); v2 := y2![1]; d := d1; elif d2 mod d1 = 0 then y1 := FFECONWAY.WriteOverLargerField(x1,d2); v1 := y1![1]; d := d2; else d := Lcm(d1,d2); Z(Characteristic(fam),d); y1 := FFECONWAY.WriteOverLargerField(x1,d); v1 := y1![1]; y2 := FFECONWAY.WriteOverLargerField(x2,d); v2 := y2![1]; fi; return [v1,v2,d]; end; ############################################################################# ## #F FFECONWAY.SumConwayOtherFFEs( , ) .. Sum method ## this is the sum method for cases where one of the summands might ## not be in the Conway field representation. ## FFECONWAY.SumConwayOtherFFEs := function(x1,x2) local fam, cc, v; fam := FamilyObj(x1); cc := FFECONWAY.CoeffsOverCommonField(x1,x2); v := cc[1]+cc[2]; return Objectify(fam!.ConwayFldEltDefaultType, [v,cc[3],fail]); end; ############################################################################# ## #M \+(,) ## ## try and be quick in the common case of two Conway elements over the same field. ## also handle all other cases. InstallMethod(\+, IsIdenticalObj, [ IsCoeffsModConwayPolRep and IsFFE, IsCoeffsModConwayPolRep and IsFFE], function(x1,x2) local v, d, cc, fam; if x1![2] = x2![2] then v := x1![1]+x2![1]; d := x1![2]; else cc := FFECONWAY.CoeffsOverCommonField(x1,x2); v := cc[1]+cc[2]; d := cc[3]; fi; fam := FamilyObj(x1); return Objectify(fam!.ConwayFldEltDefaultType, [v,d,fail]); end); InstallMethod(\+, IsIdenticalObj, [ IsCoeffsModConwayPolRep and IsFFE, IsFFE], FFECONWAY.SumConwayOtherFFEs ); InstallMethod(\+, IsIdenticalObj, [ IsFFE, IsCoeffsModConwayPolRep and IsFFE], FFECONWAY.SumConwayOtherFFEs ); InstallMethod(SUM_FFE_LARGE, IsIdenticalObj, [ IsFFE and IsInternalRep, IsFFE and IsInternalRep], FFECONWAY.SumConwayOtherFFEs); FFECONWAY.CATCH_UNEQUAL_CHARACTERISTIC := function(x,y) if Characteristic(x) <> Characteristic(y) then Error("Binary operation on finite field elements: characteristics must match\n"); fi; TryNextMethod(); end; InstallMethod(\+, [IsFFE,IsFFE], FFECONWAY.CATCH_UNEQUAL_CHARACTERISTIC); ############################################################################# ## #F FFECONWAY.DiffConwayOtherFFEs( , ) .. Sum method ## this is the sum method for cases where one of the summands might ## not be in the Conway field representation. ## FFECONWAY.DiffConwayOtherFFEs := function(x1,x2) local fam, cc, v; fam := FamilyObj(x1); cc := FFECONWAY.CoeffsOverCommonField(x1,x2); v := cc[1]-cc[2]; return Objectify(fam!.ConwayFldEltDefaultType, [v,cc[3],fail]); end; ############################################################################# ## #M \-(,) ## ## try and be quick in the common case of two Conway elements over the same field. ## also handle all other cases. InstallMethod(\-, IsIdenticalObj, [ IsCoeffsModConwayPolRep and IsFFE, IsCoeffsModConwayPolRep and IsFFE], function(x1,x2) local v, d, cc, fam; if x1![2] = x2![2] then v := x1![1]-x2![1]; d := x1![2]; else cc := FFECONWAY.CoeffsOverCommonField(x1,x2); v := cc[1]-cc[2]; d := cc[3]; fi; fam := FamilyObj(x1); return Objectify(fam!.ConwayFldEltDefaultType, [v,d,fail]); end); InstallMethod(\-, IsIdenticalObj, [ IsCoeffsModConwayPolRep and IsFFE, IsFFE], FFECONWAY.DiffConwayOtherFFEs ); InstallMethod(\-, IsIdenticalObj, [ IsFFE, IsCoeffsModConwayPolRep and IsFFE], FFECONWAY.DiffConwayOtherFFEs ); InstallMethod(DIFF_FFE_LARGE, IsIdenticalObj, [ IsFFE and IsInternalRep, IsFFE and IsInternalRep], FFECONWAY.DiffConwayOtherFFEs); InstallMethod(\-, [IsFFE,IsFFE], FFECONWAY.CATCH_UNEQUAL_CHARACTERISTIC); ############################################################################# ## #F FFECONWAY.ProdConwayOtherFFEs(,) general product method ## FFECONWAY.ProdConwayOtherFFEs := function(x1,x2) local fam, cc, v, c; fam := FamilyObj(x1); cc := FFECONWAY.CoeffsOverCommonField(x1,x2); v := ProductCoeffs(cc[1],cc[2]); fam!.ConwayFldEltReducers[cc[3]](v); return Objectify(fam!.ConwayFldEltDefaultType, [v,cc[3], fail]); end; ############################################################################# ## #M \*(, ) InstallMethod(\*, IsIdenticalObj, [ IsCoeffsModConwayPolRep and IsFFE, IsCoeffsModConwayPolRep and IsFFE], function(x1,x2) local v, d, cc, fam; if x1![2] = x2![2] then v := ProductCoeffs(x1![1],x2![1]); d := x1![2]; else cc := FFECONWAY.CoeffsOverCommonField(x1,x2); v := ProductCoeffs(cc[1],cc[2]); d := cc[3]; fi; fam := FamilyObj(x1); fam!.ConwayFldEltReducers[d](v); return Objectify(fam!.ConwayFldEltDefaultType, [v,d,fail]); end ); InstallMethod(\*, IsIdenticalObj, [ IsFFE, IsCoeffsModConwayPolRep and IsFFE], FFECONWAY.ProdConwayOtherFFEs ); InstallMethod(\*, IsIdenticalObj, [ IsCoeffsModConwayPolRep and IsFFE, IsFFE ], FFECONWAY.ProdConwayOtherFFEs ); InstallMethod(PROD_FFE_LARGE, IsIdenticalObj, [ IsFFE and IsInternalRep, IsFFE and IsInternalRep], FFECONWAY.ProdConwayOtherFFEs); InstallMethod(\*, [IsFFE,IsFFE], FFECONWAY.CATCH_UNEQUAL_CHARACTERISTIC); InstallMethod(QUO, [IsFFE,IsFFE], FFECONWAY.CATCH_UNEQUAL_CHARACTERISTIC); ############################################################################# ## #M AdditiveInverse InstallMethod(AdditiveInverseOp, [ IsCoeffsModConwayPolRep and IsFFE], function(x) local fam, y; fam := FamilyObj(x); if IsBool(x![3]) then y := x![3]; else y := -x![3]; fi; return Objectify(fam!.ConwayFldEltDefaultType, [AdditiveInverseMutable(x![1]),x![2],y]); end); ############################################################################# ## #M Inverse -- uses Euclids algorithm to express the GCD of x and the ConwayPolynomial ## (which had better be 1!) as r.x + s.c (actually don't compute s). Then r is ## the inverse of x. ## InstallMethod(InverseOp, [ IsCoeffsModConwayPolRep and IsFFE], function(x) local t, fam, p, d, c, a, b, r, s, qr, y; fam := FamilyObj(x); p := fam!.Characteristic; d := x![2]; c := FFECONWAY.GetConwayPolCoeffs(fam,d); a := ShallowCopy(x![1]); b := ShallowCopy(c); r := [Z(p)^0]; ConvertToVectorRep(r,p); s := ZeroMutable(r); ShrinkRowVector(a); if Length(a) = 0 then return fail; fi; while Length(a) > 1 do qr := QuotRemCoeffs(b,a); b := a; a := qr[2]; ShrinkRowVector(a); t := r; r := s-ProductCoeffs(r,qr[1]); s := t; od; Assert(1,Length(a) = 1); MultRowVector(r,Inverse(a[1])); if AssertionLevel() >= 2 then t := ProductCoeffs(x![1],r); fam!.ConwayFldEltReducers[d](t); if not IsOne(t[1]) or ForAny([2..Length(t)], i->not IsZero(t[i])) then Error("Inverse has failed"); fi; fi; fam!.ConwayFldEltReducers[d](r); if IsBool(x![3]) then y := x![3]; else y := Inverse(x![3]); fi; return Objectify(fam!.ConwayFldEltDefaultType,[r,d,y]); end); InstallMethod(QUO_FFE_LARGE, IsIdenticalObj, [ IsFFE and IsInternalRep, IsFFE and IsInternalRep], function(x,y) return FFECONWAY.ProdConwayOtherFFEs(x,y^-1); end); ############################################################################# ## #M IsZero ## InstallMethod(IsZero, [ IsCoeffsModConwayPolRep and IsFFE], x-> IsZero(x![1])); ############################################################################# ## #M IsOne -- coefficients vector must be [1,0,..0] ## InstallMethod(IsOne, [ IsCoeffsModConwayPolRep and IsFFE], function(x) local v, i; v := x![1]; if not IsOne(v[1]) then return false; fi; for i in [2..Length(v)] do if not IsZero(v![i]) then return false; fi; od; return true; end); ############################################################################# ## #M ZeroOp -- Make a zero. ## FFECONWAY.Zero := function(x) local fam, d; fam := FamilyObj(x); if not IsBound(fam!.ZeroConwayFFEs) then fam!.ZeroConwayFFEs := []; fi; d := x![2]; if not IsBound(fam!.ZeroConwayFFEs[d]) then fam!.ZeroConwayFFEs[d] := Objectify(fam!.ConwayFldEltDefaultType,[ZeroMutable(x![1]),d, 0*Z(fam!.Characteristic)]); fi; return fam!.ZeroConwayFFEs[d]; end; InstallMethod(ZeroOp, [ IsCoeffsModConwayPolRep and IsFFE], FFECONWAY.Zero); InstallMethod(ZeroAttr, [ IsCoeffsModConwayPolRep and IsFFE], FFECONWAY.Zero); ############################################################################# ## #M OneOp ## FFECONWAY.One := function(x) local fam, d, v; fam := FamilyObj(x); if not IsBound(fam!.OneConwayFFEs) then fam!.OneConwayFFEs := []; fi; d := x![2]; if not IsBound(fam!.OneConwayFFEs[d]) then v := ZeroMutable(x![1]); v[1] := Z(fam!.Characteristic)^0; fam!.OneConwayFFEs[d] := Objectify(fam!.ConwayFldEltDefaultType,[v,d, Z(fam!.Characteristic)^0]); fi; return fam!.OneConwayFFEs[d]; end; InstallMethod(OneOp, [ IsCoeffsModConwayPolRep and IsFFE], FFECONWAY.One); InstallMethod(OneAttr, [ IsCoeffsModConwayPolRep and IsFFE], FFECONWAY.One); ############################################################################# ## #M \< this is a bit complicated due to the rules for comparing FFEs in GAP ## We have to identify the smallest field representation of our elements ## then deal with the possibility that that is in another representation ## InstallMethod(\<, IsIdenticalObj, [ IsCoeffsModConwayPolRep and IsLexOrderedFFE, IsCoeffsModConwayPolRep and IsLexOrderedFFE ], function(x1,x2) local y1, y2, d1, d2; y1 := FFECONWAY.WriteOverSmallestField(x1); y2 := FFECONWAY.WriteOverSmallestField(x2); if IsInternalRep(y1) then if IsInternalRep(y2) then return y1 d2 then return false; fi; return y1![1] < y2![1]; end); InstallMethod(\<, IsIdenticalObj, [ IsCoeffsModConwayPolRep, IsFFE and IsInternalRep ], function(x1,x2) local y1; y1 := FFECONWAY.WriteOverSmallestField(x1); if not IsInternalRep(y1) then return false; else return y1 < x2; fi; end); InstallMethod(\<, IsIdenticalObj, [ IsFFE and IsInternalRep, IsCoeffsModConwayPolRep], function(x1,x2) local y2; y2 := FFECONWAY.WriteOverSmallestField(x2); if not IsInternalRep(y2) then return true; else return x1 < y2; fi; end); InstallMethod(\<, IsIdenticalObj, [ IsCoeffsModConwayPolRep, IsFFE and IsModulusRep ], function(x1,x2) local y1; y1 := FFECONWAY.WriteOverSmallestField(x1); if not IsModulusRep(y1) then return false; else return y1 < x2; fi; end); InstallMethod(\<, IsIdenticalObj, [ IsFFE and IsModulusRep, IsCoeffsModConwayPolRep], function(x1,x2) local y2; y2 := FFECONWAY.WriteOverSmallestField(x2); if not IsModulusRep(y2) then return true; else return x1 < y2; fi; end); ############################################################################# ## #M IntFFE ## InstallMethod(IntFFE, [IsFFE and IsCoeffsModConwayPolRep], function(x) local i; for i in [2..Length(x![1])] do if not IsZero(x![1][i]) then Error("IntFFE: element must lie in prime field"); fi; od; return IntFFE(x![1][1]); end); ############################################################################# ## #M LogFFE ## # # Adapted from the integer code by AH and Sean Gage # FFECONWAY.LogFFERhoIterate := function(y,z,q) local p, p3, zp3, k, x, xd, a, ad, b, bd, n, nd, m, r; p := Characteristic(y); p3:=QuoInt(q,3); zp3:=QuoInt(2*q,3); k := q-1; x := One(y); xd := One(y); a := 0; ad := 0; b := 0; bd := 0; repeat if not IsCoeffsModConwayPolRep(x) then n := 0; else n := NumberFFVector(x![1],p); fi; if n < p3 then x := x * y; a := (a + 1) mod k; elif n < zp3 then x := x * x; a := (a*2) mod k; b := (b*2) mod k; else x := x * z; b := (b + 1) mod k; fi; if not IsCoeffsModConwayPolRep(xd) then nd := 0; else nd := NumberFFVector(xd![1],p); fi; if nd 1 then d:=ord; while (d=ord) and Length(fact)>0 do s:=Remove(fact); t:=ord/s; Q:=y^s; R:=z^s; # iterate MN:=FFECONWAY.LogFFERhoIterate(Q,R,q); M:=MN[1]; N:=MN[2]; rep:=GcdRepresentation(ord,s*M); d:=rep[1]*ord+rep[2]*s*M; od; if d < ord then k:=(rep[2]*s*N/d); if Gcd(DenominatorRat(k),ord)<>1 then return fail; # can't invert (can't happen if not primitive root) fi; k:=k mod ord; theta:= z^(ord/d); Qp:=y/(z^k); i:=FFECONWAY.DoLogFFERho(Qp,theta,d,f,q); if i=fail then return i;fi; # bail out o:=(k+i*(ord/d)) mod ord; Assert(1,z^o=y); return o; fi; fi; # naive case, iterate MN:=FFECONWAY.LogFFERhoIterate(y,z,q); M:=MN[1]; N:=MN[2]; rep:=GcdRepresentation(ord,M); d:=rep[1]*ord+rep[2]*M; k:=(rep[2]*N/d); if Gcd(DenominatorRat(k),ord)<>1 then return fail; # can't invert (can't happen if not primitive root) fi; k:=k mod ord; theta:= z^(ord/d); Qp:= y/(z^k); i := 0; while i < d do i := i + 1; if IsOne(Qp) then Assert(1,z^k = y); return k; fi; k:=(k+ord/d) mod ord; Qp:=Qp/theta; od; # process failed (because z was not a primitive root) return fail; end; FFECONWAY.DoLogFFE := function(y,z) local d, p, q, dy, o, ix, f; if IsZero(z) then Error("LogFFE: element is not a power of base"); fi; # # Reduce to smallest possible fields. # y := FFECONWAY.WriteOverSmallestField(y); z := FFECONWAY.WriteOverSmallestField(z); # # If we're in the Zech range then all is good # if IsInternalRep(z) then if not IsInternalRep(y) then Error("LogFFE: element is not a power of base"); else return LogFFE(y,z); fi; fi; d := DegreeFFE(z); p := Characteristic(z); q := p^d; dy := DegreeFFE(y); if d mod dy <> 0 then Error("LogFFE: element is not a power of base"); fi; # # If elements are not over same field then I can find the smallest power of z # that lies in the right field and recurse. This handles the case that y is in internal rep # if d <> dy then o := Order(z); ix := o/Gcd(o,p^dy-1); return LogFFE(y,z^ix)*ix; fi; # use rho method f:=FactorsInt(q-1:quiet); # Quick factorization, don't stop if its too hard return FFECONWAY.DoLogFFERho(y,z,q-1,f,q); end; InstallMethod( LogFFE, IsIdenticalObj, [IsFFE and IsCoeffsModConwayPolRep, IsFFE and IsCoeffsModConwayPolRep], FFECONWAY.DoLogFFE ); InstallMethod( LogFFE, IsIdenticalObj, [IsFFE and IsInternalRep, IsFFE and IsCoeffsModConwayPolRep], FFECONWAY.DoLogFFE ); InstallMethod( LogFFE, IsIdenticalObj, [ IsFFE and IsCoeffsModConwayPolRep, IsFFE and IsInternalRep], FFECONWAY.DoLogFFE ); ############################################################################# ## #M Order -- multiplicative order of an FFE ## InstallMethod( Order, [IsFFE], function(z) local p, d, ord, facs, f, i, o; p := Characteristic(z); d := DegreeFFE(z); ord := p^d-1; facs := Collected(FactorsInt(ord)); for f in facs do for i in [1..f[2]] do o := ord/f[1]; if not IsOne(z^o) then break; fi; ord := o; od; od; return ord; end); ############################################################################# ## #M LargeGaloisField(p,d) -- construct GFs in this size range ## try next method if it goes wrong, to avoid dependency on ## method selection sequence. ## ## Cache fields in the family. ## Assuming we came via GF we have already passed a cache for last case called ## InstallMethod( LargeGaloisField, [IsPosInt, IsPosInt], function(p,d) local fam; if not IsPrimeInt(p) then Error("LargeGaloisField: Characteristic must be prime"); fi; if d =1 or p^d <= MAXSIZE_GF_INTERNAL then TryNextMethod(); fi; fam := FFEFamily(p); if not IsBound(fam!.ConwayFieldCache) then fam!.ConwayFieldCache := []; fi; if not IsBound(fam!.ConwayFieldCache[d]) then fam!.ConwayFieldCache[d] := FieldByGenerators(GF(p,1),[FFECONWAY.ZNC(p,d)]); fi; return fam!.ConwayFieldCache[d]; end); ############################################################################# ## #M PrimitiveRoot for Galois fields ## InstallMethod(PrimitiveRoot, [IsField and IsFFECollection and IsFinite], function(f) local p, d; p := Characteristic(f); d := DegreeOverPrimeField(f); if d > 1 and p^d > MAXSIZE_GF_INTERNAL then return FFECONWAY.ZNC(p,d); else TryNextMethod(); fi; end); ############################################################################# ## #M Coefficients of an element wrt the canonical basis -- are stored in the ## element InstallMethod(Coefficients, "For a FFE in Conway polynomial represntation wrt the canonical basis of its natural field", IsCollsElms, [IsCanonicalBasis and IsBasisFiniteFieldRep, IsFFE and IsCoeffsModConwayPolRep], function(cb,x) if not IsPrimeField(LeftActingDomain(UnderlyingLeftModule(cb))) then TryNextMethod(); fi; if DegreeOverPrimeField(UnderlyingLeftModule(cb)) <> x![2] then TryNextMethod(); fi; PadCoeffs(x![1],x![2]); return Immutable(x![1]); end); ############################################################################# ## #M Enumerator -- for a GF -- use an Enumerator for the equivalent rowspace ## ## when looking up elements, we may have to promote them to the right field InstallMethod(Enumerator, [IsField and IsFinite and IsFFECollection], function(f) local p, fam, d, e, x; if Size(f) <= MAXSIZE_GF_INTERNAL then TryNextMethod(); fi; p := Characteristic(f); fam := FFEFamily(p); d := DegreeOverPrimeField(f); if d = 1 then TryNextMethod(); fi; e := Enumerator(RowSpace(GF(p,1),d)); return EnumeratorByFunctions(f, rec( ElementNumber := function(en,n) return Objectify(fam!.ConwayFldEltDefaultType, [ e[n], d, fail]); end, NumberElement := function(en,x) x := FFECONWAY.WriteOverLargerField(x,d); return Position(e,x![1]); end)); end); ############################################################################# ## #M AsList, Iterator ## ## since we have a really efficient Enumerator method, lets use it. InstallMethod(AsList, [IsField and IsFinite and IsFFECollection], function(f) if Size(f) <= MAXSIZE_GF_INTERNAL then TryNextMethod(); fi; return AsList(Enumerator(f)); end); InstallMethod(Iterator, [IsField and IsFinite and IsFFECollection], function(f) if Size(f) <= MAXSIZE_GF_INTERNAL then TryNextMethod(); fi; return IteratorList(Enumerator(f)); end); ############################################################################# ## #M Random -- use Rowspace ## InstallMethod(Random, [IsField and IsFFECollection and IsFinite], function(f) local d, p, v, fam; if Size(f) <= MAXSIZE_GF_INTERNAL then TryNextMethod(); fi; if IsPrimeField(f) then TryNextMethod(); fi; d := DegreeOverPrimeField(f); p := Characteristic(f); v := Random(RowSpace(GF(p,1),d)); fam := FFEFamily(Characteristic(f)); return Objectify(fam!.ConwayFldEltDefaultType, [v,d,fail]); end); ############################################################################# ## #M MinimalPolynomial(,,) ## InstallMethod(MinimalPolynomial, IsCollsElmsX, [IsPrimeField, IsCoeffsModConwayPolRep and IsFFE, IsPosInt], function(fld, elm, ind) local fam, d, dd, x, y, p, o, m, i, r; fam := FamilyObj(elm); d := DegreeFFE(elm); dd := elm![2]; x := elm![1]; y := x; p := Characteristic(elm); o := ListWithIdenticalEntries(dd,Z(p)*0); o[1] := Z(p)^0; ConvertToVectorRep(o,p); m := [o,y]; for i in [2..d] do y := ProductCoeffs(y,x); fam!.ConwayFldEltReducers[dd](y); Add(m,y); od; ConvertToMatrixRep(m,p); r := SemiEchelonMatTransformation(m); Assert(1, Length(r.relations) = 1); return UnivariatePolynomialByCoefficients(fam, r.relations[1],ind); end); ############################################################################# ## #M Display for matrix of ffes ## InstallMethod( Display, "for matrix of FFEs (for larger fields)", [ IsFFECollColl and IsMatrix ], 10, # prefer this to existing method function(m) local deg, chr, zero, d, w, r, dr, x, s, y, j, a; if Length(m) = 0 or Length(m[1])= 0 then TryNextMethod(); fi; deg := Lcm( List( m, DegreeFFE ) ); chr := Characteristic(m[1][1]); if deg = 1 or chr^deg <= MAXSIZE_GF_INTERNAL then TryNextMethod(); fi; zero := Zero(m[1][1]); Print("z = Z( ",chr,", ",deg,"); z2 = z^2, etc.\n"); d := []; w := 1; for r in m do dr := []; for x in r do if IsZero(x) then Add(dr,"."); else s := ""; y := FFECONWAY.WriteOverLargerField(x,deg); for j in [0..deg-1] do a := IntFFE(y![1][j+1]); if a <> 0 then if Length(s) <> 0 then Append(s,"+"); fi; if a = 1 and j = 0 then Append(s,"1"); else if a <> 1 then Append(s,String(a)); fi; if j <> 0 then Append(s,"z"); if j <> 1 then Append(s,String(j)); fi; fi; fi; fi; od; Add(dr,s); if Length(s) > w then w := Length(s); fi; fi; od; Add(d,dr); od; for dr in d do for s in dr do Print(String(s,-w-1)); od; Print("\n"); od; end); ############################################################################# ## #F FFECONWAY.WriteOverSmallestCommonField( ) ## FFECONWAY.WriteOverSmallestCommonField := function(v) local d, degs, p, x, dx, i; d := 1; degs := []; p := Characteristic(v[1]); for x in v do if not IsFFE(x) or Characteristic(x) <> p then return fail; fi; dx := DegreeFFE(x); Add(degs, dx); od; d := Lcm(Set(degs)); for i in [1..Length(v)] do if IsCoeffsModConwayPolRep(v[i]) then if d < v[i]![2] then v[i] := FFECONWAY.TryToWriteInSmallerField(v[i],d); elif d > v[i]![2] then v[i] := FFECONWAY.WriteOverLargerField(v[i],d); fi; fi; od; return p^d; end; ############################################################################# ## #M AsInternalFFE( ) ## InstallMethod( AsInternalFFE, [IsFFE and IsCoeffsModConwayPolRep], function (x) local y; y := FFECONWAY.WriteOverSmallestField(x); if IsInternalRep(y) then return y; else return fail; fi; end); SetNamesForFunctionsInRecord("FFECONWAY"); gap-4r6p5/lib/factgrp.gd0000644000175000017500000004015112172557252013652 0ustar billbill############################################################################# ## #W factgrp.gd GAP library Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the declarations of operations for factor group maps ## ## ## To implement new factor group methods, one does not need to deal with ## most of the following operations (which are only used to cache known ## homomorphisms and extend them to subdirect factors). Instead only methods ## for the following three operations might need to be supplied: ## If a suitable homomorphism cannot be found from the cached homomorphisms ## pool, `NaturalHomomorphismByNormalSubgroupOp(,)' is called to ## construct one. ## The default method for `NaturalHomomorphismByNormalSubgroupOp' then uses ## two other operations: `DoCheapActionImages' computes actions that come ## naturally from a groups representation (for example permutation action ## on orbits and blocks) and can be computed quickly. This is intended ## as a first test to avoid hard work for homomorphisms that are easy to ## get. ## If this fails, `FindActionKernel' is called which will try to find some ## action which will give a suitable homomorphism. (This can be very time ## consuming.) ## The existing methods seem to work reasonably well for permutation groups ## and pc groups, for other kinds of groups it might be necessary to ## implement completely new methods. ## ############################################################################# ## #O DoCheapActionImages() ## ## ## ## ## ## computes natural actions for G and stores the resulting ## NaturalHomomorphismByNormalSubgroup. The type of the natural actions ## varies with the representation of G, for permutation groups it are for ## example constituent and block homomorphisms. ## A method for DoCheapActionImages must register all found actions with ## AddNaturalHomomorphismsPool so they become available. ## ## ## DeclareOperation("DoCheapActionImages",[IsGroup]); DeclareSynonym("DoCheapOperationImages",DoCheapActionImages); ############################################################################# ## #O FindActionKernel( , ) . . . . . . . . . . . . . . . . local ## ## ## ## ## ## This operation tries to find a suitable action for the group G such ## that its kernel is N. This is used to construct faithful permutation ## representations for the factor group. ## ## ## DeclareOperation( "FindActionKernel",[IsGroup,IsGroup]); DeclareSynonym( "FindOperationKernel",FindActionKernel); ############################################################################# ## #V InfoFactor ## ## ## ## ## ## ## ## DeclareInfoClass("InfoFactor"); ############################################################################# ## #A NaturalHomomorphismsPool() ## ## ## ## ## ## The NaturalHomomorphismsPool is a record which contains the following ## components: ## group is the corresponding group. ## ker is a list of normal subgroups, which defines the arrangements. ## It is sorted. ## ops is a list which gives the best know actions for each normal ## subgroup. Its entries are either Homomorphisms from G or ## generator lists (G.generators images) or lists of integers. In the ## latter case the factor is subdirect product of the factors with ## the given numbers. ## cost gives the difficulty for each actions (degree of permgroup). It ## is used to check whether a new actions is better. ## lock is a bitlist, which indicates whether certain actions are ## locked. If this happens, a better new actions is not entered. ## This allows a computation to access the pool several times and to ## be guaranteed to be returned the same object. Usually a routine ## initially locks and finally unlocks. ## ## GopDone indicates whether all obvious actions have been tried ## already ## intersects is a list of all intersections that have already been ## formed. ## blocksdone indicates if the actions already has been improved ## using blocks ## in_code can be set by the code to avoid addition of new actions ## (and thus resorting) ## ## ## DeclareAttribute("NaturalHomomorphismsPool",IsGroup, "mutable"); ############################################################################# ## #O FactorCosetAction( , [, ] ) action on the right cosets Ug ## ## <#GAPDoc Label="FactorCosetAction"> ## ## ## ## ## This command computes the action of the group G on the ## right cosets of the subgroup U. ## If a normal subgroup N of G is given, ## it is stored as kernel of this action. ## g:=Group((1,2,3,4,5),(1,2));;u:=SylowSubgroup(g,2);;Index(g,u); ## 15 ## gap> FactorCosetAction(g,u); ## ## gap> Range(last); ## Group([ (1,9,13,10,4)(2,8,14,11,5)(3,7,15,12,6), ## (1,7)(2,8)(3,9)(5,6)(10,11)(14,15) ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "FactorCosetAction", [IsGroup,IsGroup] ); ############################################################################# ## #F ImproveActionDegreeByBlocks( , , [,forceblocks] ) #F ImproveActionDegreeByBlocks( , , [,forceblocks] ) ## ## ## ## ## ## ## In the first usage, N is a normal subgroup of G and hom a ## homomorphism from G to a permutation group with kernel N. In the second ## usage, hom is taken to be the action of G on the cosets of U by right ## multiplication. ## The function tries to find another homomorphism with the same kernel but ## image group of smaller degree by looking for block systems of the image ## group. An improved result is stored in the NaturalHomomorphismsPool, the ## function returns the degree of this image (or the degree of the original ## image). ## If the image degree is larger than 500, only one block system is tested by ## standard. A test of all block systems is enforced by the optional boolean ## parameter forceblocks ## ## ## DeclareGlobalFunction( "ImproveActionDegreeByBlocks" ); DeclareSynonym( "ImproveOperationDegreeByBlocks", ImproveActionDegreeByBlocks ); ############################################################################# ## #F SmallerDegreePermutationRepresentation( ) ## ## <#GAPDoc Label="SmallerDegreePermutationRepresentation"> ## ## ## ## ## Let G be a permutation group that acts transitively ## on its moved points. ## tries to find a ## faithful permutation representation of smaller degree. ## The result is a group homomorphism onto a permutation group, ## in the worst case this is the identity mapping on G. ##

## If the cheap option is given, the function only tries to reduce ## to orbits or actions on blocks, otherwise also actions on cosets of ## random subgroups are tried. ##

## Note that the result is not guaranteed to be a faithful permutation ## representation of smallest degree, ## or of smallest degree among the transitive permutation representations ## of G. ## Using &GAP; interactively, one might be able to choose subgroups ## of small index for which the cores intersect trivially; ## in this case, the actions on the cosets of these subgroups give rise to ## an intransitive permutation representation ## the degree of which may be smaller than the original degree. ##

## The methods used might involve the use of random elements and the ## permutation representation (or even the degree of the representation) is ## not guaranteed to be the same for different calls of ## . ##

## If the option cheap is given less work is spent on trying to get a small ## degree representation, if the value of this option is set to the string ## "skip" the identity mapping is returned. (This is useful if a function ## called internally might try a degree reduction.) ##

## image:= Image( iso );; NrMovedPoints( image ); ## 24 ## gap> small:= SmallerDegreePermutationRepresentation( image );; ## gap> Image( small ); ## Group([ (2,3), (2,3,4), (1,2)(3,4), (1,3)(2,4) ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "SmallerDegreePermutationRepresentation" ); ############################################################################# ## #F AddNaturalHomomorphismsPool(G,N,op[,cost[,blocksdone]]) ## ## ## ## ## ## This function stores a computed action of G with kernel N in the ## NaturalHomomorphismsPool of G, unless a better action is already ## known. op usually is a homomorphism of G with kernel N. It may also ## be a subgroup of G, in which case the action of G on its cosets is ## taken. ## If the optional parameter cost is not given, cost is taken to be the ## degree of the image representation (or 1 if the image is a pc group). This ## cost is stored with the action to determine later whether another ## action is better. ## The optional boolean parameter blocksdone indicates if set to true, that ## all block systems of the image of op have already been computed and the ## resulting (lower degree, but not necessarily faithful for G/N) actions ## have been already considered. (Otherwise such a test may be done later by ## DoCheapActionImages.) ## The function internally re-sorts the list of normal subgroups to permit ## binary search among them. If a new action is returns the re-sorting ## permutation applied there. If returns false if a better action was ## already known, it returns fail if this factor is locked. ## ## ## DeclareGlobalFunction("AddNaturalHomomorphismsPool"); ############################################################################# ## #F LockNaturalHomomorphismsPool(,) . . store flag to prohibit changes ## ## ## ## ## ## Calling this function stores a flag in the NaturalHomomorphismsPool of ## G to prohibit it to store new (even better) faithful actions for G/N. ## This can be used in algorithms to ensure that ## NaturalHomomorphismByNormalSubgroup(G,N) will always return the same ## mapping, even if in the meantime other homomorphisms are computed anew, ## which –as a side effect– obtained a better action for G/N which &GAP; ## normally would store. ## The locking can be reverted by UnlockNaturalHomomorphismsPool(G,N). ## ## ## DeclareGlobalFunction("LockNaturalHomomorphismsPool"); ############################################################################# ## #F UnlockNaturalHomomorphismsPool(,) . clear flag to allow changes of ## ## ## ## ## ## clears the flag set by LockNaturalHomomorphismsPool(G,N). ## ## ## DeclareGlobalFunction("UnlockNaturalHomomorphismsPool"); ############################################################################# ## #F KnownNaturalHomomorphismsPool(,) . . . check whether Hom is stored ## ## ## ## ## ## This function tests whether an homomorphism for ## NaturalHomomorphismByNormalSubgroup(G,N) is already known (or ## computed trivially for G=N or N=\langle1\rangle). ## ## ## DeclareGlobalFunction("KnownNaturalHomomorphismsPool"); ############################################################################# ## #F GetNaturalHomomorphismsPool(,) . . . get action for G/N if known ## ## ## ## ## ## returns a NaturalHomomorphismByNormalSubgroup(G,N) if one is ## stored already in the NaturalHomomorphismsPool of G. ## (As the homomorphism may be stored by a recipe this command can ## still take some time when called the first time.) ## ## ## DeclareGlobalFunction("GetNaturalHomomorphismsPool"); ############################################################################# ## #F DegreeNaturalHomomorphismsPool(,) degree for action for G/N ## ## ## ## ## ## returns the cost (see ) of a stored action ## for G/N and fail if no such action is stored. ## ## ## DeclareGlobalFunction("DegreeNaturalHomomorphismsPool"); ############################################################################# ## #F CloseNaturalHomomorphismsPool([,]) . . calc intersections of known ## ## ## ## ## ## This command tries to build actions for (new) factor groups from the ## already known actions in the NaturalHomomorphismsPool(G) by considering ## intransitive representations for subdirect products. Any new or better ## homomorphism obtained this way is stored (see ## ). ## If the optional parameter N is given, only actions which have N in their ## kernel are considered. ## The function keeps track of already considered subdirect products, thus ## there is no overhead in calling it several times. ## ## ## DeclareGlobalFunction("CloseNaturalHomomorphismsPool"); ############################################################################# ## #F PullBackNaturalHomomorphismsPool(]) . . transfer nathoms of image ## ## ## ## ## ## If hom is a homomorphism, this command transfers the natural ## homomorphisms of the image of hom to the source of hom. ## ## ## DeclareGlobalFunction("PullBackNaturalHomomorphismsPool"); ############################################################################# ## #F EraseNaturalHomomorphismsPool() ## ## ## ## ## ## This command erases all stored natural homomorphisms associated to the ## group G. It is used to recover memory. ## ## ## DeclareGlobalFunction("EraseNaturalHomomorphismsPool"); ############################################################################# ## #E gap-4r6p5/lib/ctblpc.gi0000644000175000017500000000530612172557252013503 0ustar billbill############################################################################# ## #W ctblpc.gi GAP library Alexander Hulpke ## ## #Y Copyright (C) 1993, 1997 #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the parts of the Dixon-Schneider specific to pc groups ## ############################################################################# ## #F PcGroupClassMatrixColumn(,,,) . calculate the t-th column #F of the r-th class matrix and store it in the appropriate column of M ## PcGroupClassMatrixColumn := function(D,M,r,t) local c,s,z,i,T,p,orb; if t=1 then M[D.inversemap[r]][t]:=D.classiz[r]; else orb:=DxGaloisOrbits(D,r); z:=D.classreps[t]; c:=orb.orbits[t][1]; if c<>t then p:=RepresentativeAction(orb.group,c,t); # was the first column of the galois class active? if ForAny(M,i->i[c]>0) then for i in D.classrange do M[i^p][t]:=M[i][c]; od; Info(InfoCharacterTable,2,"by GaloisImage"); return; fi; fi; T:=DoubleCentralizerOrbit(D,r,t); Info(InfoCharacterTable,2,Length(T[1])," instead of ",D.classiz[r]); for i in [1..Length(T[1])] do T[1][i]:=T[1][i]*z; od; #T AH: Here something goes wrong in the solvable group class #T computation. Workaround T[1]:=List(T[1],i->Position(D.ids,D.identification(D,i))); #T[1]:=List(ClassesSolvableGroup(D.group,0,rec(candidates:=T[1])), # i->Position(D.ids,i.representative)); for i in [1..Length(T[1])] do s:=T[1][i]; M[s][t]:=M[s][t]+T[2][i]; od; fi; end; ############################################################################# ## #F IdentificationSolvableGroup(,) . . class invariants for el in G ## IdentificationSolvableGroup := function(D,el) return ClassesSolvableGroup(D.group,0,rec(candidates:=[el]))[1].representative; end; ############################################################################# ## #M DxPreparation() ## InstallMethod(DxPreparation,"pc group",true,[IsPcGroup,IsRecord],0, function(G,D) local i,cl; if not IsDxLargeGroup(G) then TryNextMethod(); fi; D.ClassElement:=ClassElementLargeGroup; D.identification:=IdentificationSolvableGroup; D.rationalidentification:=IdentificationGenericGroup; D.ClassMatrixColumn:=PcGroupClassMatrixColumn; cl:=D.classes; D.ids:=[]; D.rids:=[]; for i in D.classrange do D.ids[i]:=D.identification(D,D.classreps[i]); D.rids[i]:=D.rationalidentification(D,D.classreps[i]); od; return D; end); ############################################################################# ## #E ctblpc.gi ## gap-4r6p5/lib/dict.gi0000644000175000017500000010066312172557252013161 0ustar billbill############################################################################# ## #W dict.gi GAP Library Gene Cooperman #W Scott Murray #W Alexander Hulpke ## ## #Y Copyright (C) 1999, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1999 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the implementations for dictionaries. ## ## ## List and Sort dictionaries ## BindGlobal("DictionaryByList",function(look) local d,rep; d:=rec(); if look then rep:=IsListLookupDictionary; d.entries:=[]; else rep:=IsListDictionary; d.list:=[]; fi; Objectify(NewType(DictionariesFamily,rep and IsMutable and IsCopyable),d); return d; end); BindGlobal("DictionaryBySort",function(look) local d,rep; d:=rec(); if look then rep:=IsSortLookupDictionary; d.entries:=[]; else rep:=IsSortDictionary; d.list:=[]; fi; Objectify(NewType(DictionariesFamily,rep and IsMutable and IsCopyable),d); return d; end); ############################################################################# ## #M ShallowCopy (for list dictionaries) ## InstallMethod(ShallowCopy, [IsListLookupDictionary and IsCopyable], function(dict) local c; c := rec( entries := ShallowCopy(dict!.entries) ); return Objectify( NewType(DictionariesFamily, IsListLookupDictionary and IsMutable), c); end); InstallMethod(ShallowCopy, [IsListDictionary and IsCopyable], function(dict) local c; c := rec( list := ShallowCopy(dict!.list) ); return Objectify( NewType(DictionariesFamily, IsListDictionary and IsMutable), c); end); InstallMethod(ShallowCopy, [IsSortLookupDictionary and IsCopyable], function(dict) local c; c := rec( entries := ShallowCopy(dict!.entries) ); return Objectify( NewType(DictionariesFamily, IsSortLookupDictionary and IsMutable), c); end); InstallMethod(ShallowCopy, [IsSortDictionary and IsCopyable], function(dict) local c; c := rec( list := ShallowCopy(dict!.list) ); return Objectify( NewType(DictionariesFamily, IsSortDictionary and IsMutable), c); end); ############################################################################# ## #M AddDictionary(,,) ## InstallOtherMethod(AddDictionary,"for lookup list dictionaries",true, [IsListLookupDictionary and IsMutable,IsObject,IsObject],0, function(d, x, val) x:=[Immutable(x),val]; MakeImmutable(x); # to be able to store sortedness Add(d!.entries,x); end); InstallMethod(AddDictionary,"for list dictionaries",true, [IsListDictionary and IsMutable,IsObject],0, function(d, x) x:=Immutable(x); # to be able to store sortedness Add(d!.list,x); end); ############################################################################# ## #M AddDictionary(,,) ## InstallOtherMethod(AddDictionary,"for lookup sort dictionaries",true, [IsSortLookupDictionary and IsMutable,IsObject,IsObject],0, function(d, x, val) local pair, p; pair:=[Immutable(x),val]; MakeImmutable(pair); # to be able to store sortedness p := PositionFirstComponent(d!.entries,x); if p <= Length(d!.entries) and d!.entries[p][1] = x then d!.entries[p] := pair; else AddSet(d!.entries, pair); fi; end); InstallMethod(AddDictionary,"for sort dictionaries",true, [IsSortDictionary and IsMutable,IsObject],0, function(d, x) x:=Immutable(x); # to be able to store sortedness AddSet(d!.list,x); end); ############################################################################# ## #M KnowsDictionary(,) ## InstallMethod(KnowsDictionary,"for list lookup dictionaries",true, [IsListLookupDictionary,IsObject],0, function(d,x) local p; p:=PositionFirstComponent(d!.entries,x); return p <= Length(d!.entries) and d!.entries[p][1] = x; end); InstallMethod(KnowsDictionary,"for list dictionaries",true, [IsListDictionary,IsObject],0, function(d,x) local p; return x in d!.list; end); ############################################################################# ## #M LookupDictionary(,) ## InstallMethod(LookupDictionary,"for list dictionaries",true, [IsListLookupDictionary,IsObject],0, function(d,x) local p; p:=PositionFirstComponent(d!.entries,x); if p > Length(d!.entries) or d!.entries[p][1] <> x then return fail; else return d!.entries[p][2]; fi; end); ## ## Position dictionaries ## InstallGlobalFunction(DictionaryByPosition, function(domain,look) local d,rep; d:=rec(domain:=domain,blist:=BlistList([1..Length(domain)],[])); if look then rep:=IsPositionLookupDictionary; d.vals:=[]; else rep:=IsPositionDictionary; fi; Objectify(NewType(DictionariesFamily,rep and IsMutable and IsCopyable),d); return d; end); InstallMethod(ShallowCopy, [IsPositionDictionary and IsCopyable], function(d) local r; r := rec( domain := d!.domain, blist := ShallowCopy(d!.blist)); Objectify(NewType(DictionariesFamily,IsPositionDictionary and IsMutable and IsCopyable),r); return r; end); InstallMethod(ShallowCopy, [IsPositionLookupDictionary and IsCopyable], function(d) local r; r := rec( domain := d!.domain, blist := ShallowCopy(d!.blist), vals := ShallowCopy(d!.vals)); Objectify(NewType(DictionariesFamily,IsPositionLookupDictionary and IsMutable and IsCopyable),r); return r; end); ############################################################################# ## #M AddDictionary(,,) ## InstallOtherMethod(AddDictionary,"for lookup position dictionaries",true, [IsPositionLookupDictionary and IsMutable,IsObject,IsObject],0, function(d, x, val) x:=PositionCanonical(d!.domain,x); d!.blist[x]:=true; d!.vals[x]:=val; end); InstallMethod(AddDictionary,"for position dictionaries",true, [IsPositionDictionary and IsMutable,IsObject],0, function(d, x) x:=PositionCanonical(d!.domain,x); d!.blist[x]:=true; end); ############################################################################# ## #M KnowsDictionary(,) ## InstallMethod(KnowsDictionary,"for position dictionaries",true, [IsPositionDictionary,IsObject],0, function(d,x) x:=PositionCanonical(d!.domain,x); return d!.blist[x]; end); ############################################################################# ## #M LookupDictionary(,) ## InstallMethod(LookupDictionary,"for position dictionaries",true, [IsPositionLookupDictionary,IsObject],0, function(d,x) local p; x:=PositionCanonical(d!.domain,x); if d!.blist[x] then return d!.vals[x]; else return fail; fi; end); ############################################################################# ## #F NewDictionary(,) ## InstallGlobalFunction(NewDictionary,function(arg) local hashfun,obj,dom,lookup; obj:=arg[1]; lookup:=arg[2]; if Length(arg)>2 then dom:=arg[3]; else dom:=fail; fi; # if the domain is an enumerator, get rid of it if HasUnderlyingCollection(dom) then dom:=UnderlyingCollection(dom); fi; # are we given a domain, which can index very quickly? if dom<>fail and IsList(dom) and (IsQuickPositionList(dom) or (not IsMutable(dom) and IsSSortedList(dom) and CanEasilySortElements(dom[1]) ) ) #2^22 plist (for position lookup) is 16MB size and Length(dom)<2^22 then Info(InfoHash,1,obj," Position dictionary"); return DictionaryByPosition(dom,lookup); elif dom<>fail and IsFreeLeftModule(dom) and IsFFECollection(LeftActingDomain(dom)) and Size(LeftActingDomain(dom))<=256 #2^22 plist (for position lookup) is 16MB size and Size(dom)<2^22 then # FF vector space: use enumerator for position Info(InfoHash,1,obj," Position dictionary for vector space"); return DictionaryByPosition(Enumerator(dom),lookup); fi; # can we try hashing? Only if domain is given and not for small perms. if dom<>fail and (not IsPerm(obj) or NrMovedPoints(obj)>100000) then if IsRecord(dom) and IsBound(dom.hashfun) then hashfun:=dom.hashfun; else hashfun:=SparseIntKey(dom,obj); fi; else hashfun:=fail; fi; if hashfun<>fail then Info(InfoHash,1," Hash dictionary"); # uncomment the next line to get back the old version. #return NaiveHashDictionary(dom,lookup,hashfun); return SparseHashTable(hashfun); fi; # can we sort the elements cheaply? if CanEasilySortElements(obj) then Info(InfoHash,1,obj," Sort dictionary"); return DictionaryBySort(lookup); fi; # Alas, we can't do anything. Go the hard way Info(InfoHash,1,obj," ",dom," List dictionary"); return DictionaryByList(lookup); end); # here starts the hash table bit by Gene and Scott ## PERFORMANCE: ## For perms, IsBound() inside GetHashKey() might cost too much. ## Try initializing hash!.valueArray to all 'fail' entries. ## Then just return hash!.valueArray[ LastHashIndex ], and if ## it's fail, let it be so. ## How much does this speed up the perm code? ## ############################################################################# ## #V MaxHashViewSize ## ## The maximum size of a hash table for which ViewObj will print the whole ## table (default 10). ## MaxHashViewSize := 10; ############################################################################# ## #V LastHashIndex is used for fast access to the last hash index. ## LastHashIndex := -1; ############################################################################# ############################################################################# ## ## Dense hash tables ## ############################################################################# ############################################################################# ############################################################################# ## #F DenseHashTable( ) ## InstallGlobalFunction( DenseHashTable, function( ) local Type, Rec; Type := NewType( DictionariesFamily, IsDenseHashRep and IsMutable ); Rec := rec( KeyArray := [], ValueArray := [] ); return Objectify( Type, Rec ); end ); ############################################################################# ## #M ViewObj( ) for dense hash tables ## InstallMethod( ViewObj, "for dense hash tables", true, [ IsDenseHashRep ], 0, function( hash ) if Size( hash ) > MaxHashViewSize then Print("< dense hash table of size ", Size( hash ), " >"); else PrintHashWithNames( hash, "Keys", "Values" ); fi; end ); ############################################################################# ## #M PrintHashWithNames( , , ) #M for dense hash tables ## InstallMethod( PrintHashWithNames, "for dense hash tables", true, [ IsDenseHashRep, IsString, IsString ], 0, function( hash, keyName, valueName ) local key; Print(keyName, ": ", hash!.KeyArray, "\n"); Print(valueName, ": ", List( hash!.KeyArray, key -> hash!.ValueArray[key] )); end ); ############################################################################# ## #M PrintObj( ) for dense hash tables ## InstallMethod( PrintObj, "for dense hash tables", true, [ IsDenseHashRep ], 0, function( hash ) PrintHashWithNames( hash, "Keys", "Values" ); Print("\n"); end ); ############################################################################# ## #M Size( ) for dense hash tables ## InstallMethod( Size, "for dense hash tables", true, [ IsDenseHashRep ], 0, function( hash ) return Length( hash!.KeyArray ); end ); ############################################################################# ## #M Enumerator( ) for dense hash tables ## InstallMethod( Enumerator, "for dense hash tables", true, [ IsDenseHashRep ], 0, function( hash ) return List( hash!.KeyArray, key -> GetHashEntry( hash, key ) ); end ); ############################################################################# ## #M HashKeyEnumerator( ) for dense hash tables ## InstallMethod( HashKeyEnumerator, "for dense hash tables", true, [ IsDenseHashRep ], 0, function( hash ) return hash!.KeyArray; end ); ############################################################################# ## #M Random( ) for dense hash tables ## ## Returns a random value. ## InstallMethod( Random, "for dense hash tables", true, [ IsHash and IsDenseHashRep ], 100, function( hash ) return GetHashEntry( hash, RandomHashKey( hash ) ); end ); ############################################################################# ## #M RandomHashKey( ) for dense hash tables ## ## Returns a random key. ## InstallMethod( RandomHashKey, "for dense hash tables", true, [ IsHash and IsDenseHashRep ], 100, function( hash ) return Random(hash!.KeyArray); end ); ############################################################################# ############################################################################# ## ## Sparse hash tables ## ############################################################################# ############################################################################# ############################################################################# ## #V DefaultHashLength ## ## Default starting hash table size ## DefaultHashLength := 2^7; BindGlobal("HASH_RANGE",[0..DefaultHashLength-2]); ############################################################################# ## #F SparseHashTable( ) ## InstallGlobalFunction( SparseHashTable, function(arg) local Rec,T; Rec := rec( KeyArray := ListWithIdenticalEntries( DefaultHashLength, fail ), ValueArray := [], LengthArray := DefaultHashLength, NumberKeys := 0 ); if Length(arg)>0 then T:=Objectify( DefaultSparseHashWithIKRepType, Rec ); T!.intKeyFun:=arg[1]; else T:=Objectify( DefaultSparseHashRepType, Rec ); fi; T!.LengthArrayHalf := QuoInt(T!.LengthArray,2); return T; end ); ############################################################################# ## #M ShallowCopy( ) for sparse hash table ## InstallMethod(ShallowCopy, [IsSparseHashRep and IsCopyable], function(t) local r; r := rec( KeyArray := ShallowCopy(t!.KeyArray), ValueArray := ShallowCopy(t!.ValueArray), LengthArray := t!.LengthArray, NumberKeys := t!.NumberKeys, LengthArrayHalf := t!.LengthArrayHalf); return Objectify( DefaultSparseHashRepType and IsMutable, r); end); InstallMethod(ShallowCopy, [IsSparseHashRep and TableHasIntKeyFun and IsCopyable], function(t) local r; r := rec( KeyArray := ShallowCopy(t!.KeyArray), ValueArray := ShallowCopy(t!.ValueArray), LengthArray := t!.LengthArray, NumberKeys := t!.NumberKeys, intKeyFun := t!.intKeyFun, LengthArrayHalf := t!.LengthArrayHalf); return Objectify( DefaultSparseHashWithIKRepType and IsMutable, r); end); ############################################################################# ## #M ViewObj( ) for sparse hash table ## InstallMethod( ViewObj, "for sparse hash tables", true, [ IsSparseHashRep ], 0, function( hash ) if Size( hash ) > MaxHashViewSize then Print("< sparse hash table of size ", Size( hash ), " >"); else PrintHashWithNames( hash, "Keys", "Values" ); fi; end ); ############################################################################# ## #M PrintHashWithNames( , , ) ## for sparse hash table ## InstallMethod( PrintHashWithNames, "for sparse hash tables", true, [ IsSparseHashRep, IsString, IsString ], 0, function( hash, keyName, valueName ) local key; Print(keyName, ": ", HashKeyEnumerator( hash ), "\n"); Print(valueName, ": ", Enumerator( hash )); end ); ############################################################################# ## #M PrintObj( ) for sparse hash table ## InstallMethod( PrintObj, "for sparse hash tables", true, [ IsSparseHashRep ], 0, function( hash ) PrintHashWithNames(hash, "Keys", "Values" ); Print("\n"); end ); ############################################################################# ## #M Size( ) for sparse hash table ## InstallMethod( Size, "for sparse hash tables", true, [ IsHash and IsSparseHashRep ], 0, hash -> hash!.NumberKeys ); ############################################################################# ## #M Enumerator( ) for sparse hash table ## InstallMethod( Enumerator, "for sparse hash tables", true, [ IsHash and IsSparseHashRep ], 0, hash -> List( Filtered( hash!.KeyArray, x -> x <> fail ), key -> GetHashEntry( hash, key ) ) ); ############################################################################# ## #M HashKeyEnumerator( ) for sparse hash table ## InstallMethod( HashKeyEnumerator, "for sparse hash tables", true, [ IsHash and IsSparseHashRep ], 0, hash -> Filtered( hash!.KeyArray, x -> x <> fail ) ); ############################################################################# ## #M Random( ) for sparse hash tables ## ## Returns a random key. ## InstallMethod( Random, "for sparse hash tables", true, [ IsHash and IsSparseHashRep ], 100, function( hash ) return GetHashEntry( hash, RandomHashKey( hash ) ); end ); ############################################################################# ## #M RandomHashKey( ) for sparse hash tables ## ## Returns a random key. ## InstallMethod( RandomHashKey, "for sparse hash tables", true, [ IsHash and IsSparseHashRep ], 100, function( hash ) local i; if Size( hash ) = 0 then return fail; fi; repeat i := Random( [1..hash!.LengthArray] ); until hash!.KeyArray[i] <> fail; return hash!.KeyArray[i]; end ); ############################################################################# ############################################################################# ## ## Hash functions ## ############################################################################# ############################################################################# ############################################################################# ## #F IntegerHashFunction( , , ) ## InstallGlobalFunction( IntegerHashFunction, function( key, i, size ) # return ( (1+key) + i*(1+2*(key mod size/2)) ) mod size; return 1+( (1+key) + i*(1+2*(key mod QuoInt(size,2))) ) mod size; #return 1 + ( key + i * (1 + (key mod 2) + (key mod size)) ) mod size; #return 1 + ( key + (i-1) * (QuoInt(size,17))) mod size; end ); BindGlobal("HashClashFct",function(intkey,i,len) return 1+((intkey+i) mod len); #return 1+(intkey mod (len-i)); end); # old obsolete code # ############################################################################# # ## # #M GetHashEntryAtLastIndex( ) # ## # InstallMethod( GetHashEntryAtLastIndex, "for hash table", true, # [ IsHash ], 0, # function( hash ) # if IsBound( hash!.ValueArray[ LastHashIndex ] ) then # return( hash!.ValueArray[ LastHashIndex ] ); # else # return fail; # fi; # end ); # # ############################################################################# # ## # #M SetHashEntry( , , ) # ## # InstallMethod( SetHashEntry, "for hash table", true, # [ IsHash and IsMutable, IsObject, IsObject ], 0, # function( hash, intkey, value ) # local index, i; # for i in HASH_RANGE do # index := IntegerHashFunction( intkey, i, hash!.LengthArray ); # if hash!.KeyArray[index] = fail then # hash!.ValueArray[ LastHashIndex ] := value; # return value; # fi; # od; # Error("hash table in infinite loop"); # end ); # # ############################################################################# # ## # #M SetHashEntryAtLastIndex( , ) # ## # InstallMethod( SetHashEntryAtLastIndex, "for hash table", true, # [ IsHash and IsMutable, IsObject ], 0, # function( hash, newvalue ) # hash!.ValueArray[ LastHashIndex ] := newvalue; # return newvalue; # end ); # dictionary type interface for hash tables. As we want these to be really # fast, the code has been stripped down. #MAXCLASH:=0; ############################################################################# ## #M AddDictionary(,,) ## BindGlobal("HashDictAddDictionary",function(hash,key,value) local index,intkey,i,cnt; intkey := hash!.intKeyFun(key); # cnt:=0; repeat for i in HASH_RANGE do index:=HashClashFct(intkey,i,hash!.LengthArray); if hash!.KeyArray[index] = fail then #if cnt>MAXCLASH then MAXCLASH:=cnt; #Print("found after ",cnt," clashes, ", Length(Set( # List([0..i-1],x->hash!.intKeyFun(hash!.KeyArray[HashClashFct(intkey,x,hash!.LengthArray)])) )), " different keys\n"); #fi; hash!.KeyArray[ index ] := key; hash!.ValueArray[ index ] := value; hash!.NumberKeys := hash!.NumberKeys + 1; # was: if 2 * hash!.NumberKeys > Length( hash!.KeyArray ) then # The length of the key array is just hash!.lengthArray. Thus # this looks like an unnecessary multiplication. if hash!.NumberKeys > hash!.LengthArrayHalf then DoubleHashDictSize( hash ); fi; return; fi; # cnt:=cnt+1; od; # failed: Double size #Error("Failed/double ",intkey," ",key," ",Maximum(HASH_RANGE),"\n"); MakeReadWriteGlobal("HASH_RANGE"); HASH_RANGE:=[1..2*Maximum(HASH_RANGE)]; MakeReadOnlyGlobal("HASH_RANGE"); DoubleHashDictSize( hash ); until false; end ); InstallOtherMethod(AddDictionary,"for hash tables",true, [IsHash and IsSparseHashRep and TableHasIntKeyFun and IsMutable, IsObject,IsObject],0,HashDictAddDictionary); InstallOtherMethod(AddDictionary,"for hash tables",true, [IsHash and IsSparseHashRep and IsMutable, IsObject,IsObject],0, function(hash,key,value) local index,intkey,i; intkey := SparseIntKey( false,key )(key); for i in HASH_RANGE do index:=HashClashFct(intkey,i,hash!.LengthArray); if hash!.KeyArray[index] = fail then hash!.KeyArray[ index ] := key; hash!.ValueArray[ index ] := value; hash!.NumberKeys := hash!.NumberKeys + 1; # was: if 2 * hash!.NumberKeys > Length( hash!.KeyArray ) then # The length of the key array is just hash!.lengthArray. Thus # this looks like an unnecessary multiplication. if hash!.NumberKeys > hash!.LengthArrayHalf then DoubleHashDictSize( hash ); fi; return; fi; od; Error("hash table in infinite loop"); end ); InstallGlobalFunction(DoubleHashDictSize, function( hash ) local oldKeyArray, oldValueArray, i,j,l; #Print("Double from ",hash!.LengthArray,"\n"); oldKeyArray := hash!.KeyArray; oldValueArray := hash!.ValueArray; # compact l:=Length(oldKeyArray); i:=1; # read j:=1; # write while i<=l do if oldKeyArray[i]<>fail then if i>j then oldKeyArray[j]:=oldKeyArray[i]; oldValueArray[j]:=oldValueArray[i]; fi; j:=j+1; fi; i:=i+1; od; for i in [l,l-1..j] do Unbind(oldKeyArray[i]); Unbind(oldValueArray[i]); od; hash!.LengthArray := NextPrimeInt(hash!.LengthArray * 2); hash!.LengthArrayHalf := QuoInt(hash!.LengthArray,2); hash!.KeyArray:=0; # old one away hash!.KeyArray := ListWithIdenticalEntries( hash!.LengthArray, fail ); hash!.ValueArray := []; hash!.NumberKeys := 0; l:=Length(oldKeyArray); if IsBound(hash!.intKeyFun) then for i in [l,l-1..1] do if oldKeyArray[i] <> fail then HashDictAddDictionary( hash, oldKeyArray[i], oldValueArray[i] ); fi; Unbind(oldKeyArray[i]); Unbind(oldValueArray[i]); od; else for i in [l,l-1..1] do if oldKeyArray[i] <> fail then AddDictionary( hash, oldKeyArray[i], oldValueArray[i] ); fi; Unbind(oldKeyArray[i]); Unbind(oldValueArray[i]); od; fi; end ); ############################################################################# ## #M AddDictionary(,) ## InstallOtherMethod(AddDictionary,"for hash tables, no value given",true, [IsHash and IsMutable,IsObject],0, function(ht, x) AddDictionary(ht,x,true); end); ############################################################################# ## #M KnowsDictionary(,) ## InstallMethod(KnowsDictionary,"for hash tables",true, [IsHash,IsObject],0, function(ht,x) return LookupDictionary(ht,x)<>fail; end); ############################################################################ ## #M LookupDictionary(,) ## InstallMethod(LookupDictionary,"for hash tables that know their int key",true, [IsHash and IsSparseHashRep and TableHasIntKeyFun,IsObject],0, function( hash, key ) local index,intkey,i,cnt; intkey := hash!.intKeyFun(key); for i in HASH_RANGE do index:=HashClashFct(intkey,i,hash!.LengthArray); if hash!.KeyArray[index] = key then #LastHashIndex := index; return hash!.ValueArray[ index ]; elif hash!.KeyArray[index] = fail then return fail; fi; od; # the entry could not have been added, as we would have found it by now return fail; end ); ############################################################################ ## #M LookupDictionary(,) ## InstallMethod(LookupDictionary,"for hash tables",true, [IsHash and IsSparseHashRep,IsObject],0, function( hash, key ) local index,intkey,i; intkey := SparseIntKey( false,key )(key); for i in HASH_RANGE do index:=HashClashFct(intkey,i,hash!.LengthArray); if hash!.KeyArray[index] = key then #LastHashIndex := index; return hash!.ValueArray[ index ]; elif hash!.KeyArray[index] = fail then return fail; fi; od; Error("hash table in infinite loop"); end ); # # some hash functions # ############################################################################# ## #M DenseIntKey() ## InstallMethod(DenseIntKey,"default fail",true,[IsObject,IsObject], 0,ReturnFail); InstallMethod(SparseIntKey,"defaults to DenseIntKey",true,[IsObject,IsObject], 0,DenseIntKey); InstallMethod(SparseIntKey,"for finite Gaussian row spaces",true, [ IsFFECollColl and IsGaussianRowSpace,IsObject ], 0, function(m,v) local f,n,bytelen,data,qq,i; f:=LeftActingDomain(m); n:=Size(f); if n=2 then bytelen:=QuoInt(Length(v),8); if bytelen<=8 then # short GF2 return x->NumberFFVector(x,2); else # long GF2 data:=[2*GAPInfo.BytesPerVariable,bytelen]; return function(x) if not IsGF2VectorRep(x) then Info(InfoWarning,1,"uncompressed vector"); x:=ShallowCopy(x); ConvertToGF2VectorRep(x); fi; return HASHKEY_BAG(x,101,data[1],data[2]); end; fi; elif n < 256 then qq:=n; # log i:=0; while qq<=256 do qq:=qq*n; i:=i+1; od; # i is now the number of field elements per byte bytelen := QuoInt(Length(v),i); if bytelen<=8 then # short 8-bit return x->NumberFFVector(x,n); else # long 8 bit data:=[3*GAPInfo.BytesPerVariable,bytelen]; # must check type #return x->HASHKEY_BAG(x,101,data[1],data[2]); return function(x) if not Is8BitVectorRep(x) or Q_VEC8BIT(x)<>n then Info(InfoWarning,1,"un- or miscompressed vector"); x:=ShallowCopy(x); ConvertToVectorRep(x,n); fi; return HASHKEY_BAG(x,101,data[1],data[2]); end; fi; else # large field -- vector represented as plist. f:=AsSSortedList(f); return function(v) local x,sy,p; sy := 0; for x in v do p := Position(f, x); # want to be quick: Assume no failures # if p = fail then # Error("NumberFFVector: Vector not over specified field"); # fi; sy := n*sy + (p-1); od; return sy; end; fi; end); SparseIntKeyVecListAndMatrix:=function(d,m) local f,n,pow,fct; if IsList(d) and Length(d)>0 and IsMatrix(d[1]) then f:=DefaultScalarDomainOfMatrixList(d); else f:=DefaultScalarDomainOfMatrixList([m]); fi; fct:=SparseIntKey(f^Length(m[1]),m[1]); n:=Minimum(Size(f),11)^Minimum(12,QuoInt(Length(m[1]),2)); #pow:=n^Length(m[1]); pow:=NextPrimeInt(n); # otherwise we produce huge numbers which take time return function(x) local i,gsy; gsy:=0; for i in x do gsy:=pow*gsy+fct(i); od; return gsy; end; end; InstallMethod(SparseIntKey,"for lists of vectors",true, [ IsFFECollColl,IsObject ], 0, function(m,v) local f,n; if not (IsList(m) and IS_PLIST_REP(m) and ForAll(m,i->IsRowVector(i))) then TryNextMethod(); fi; f:=DefaultFieldOfMatrix(m); return SparseIntKey(f^Length(v),v); end); InstallMethod(SparseIntKey, "for matrices over finite field vector spaces",true, [IsObject,IsFFECollColl and IsMatrix],0, SparseIntKeyVecListAndMatrix); InstallMethod(SparseIntKey, "for vector listsover finite field vector spaces",true, [IsObject,IsFFECollColl and IsList],0, SparseIntKeyVecListAndMatrix); ############################################################################# ## #M SparseIntKey( , ) for row spaces over finite fields ## InstallMethod( SparseIntKey, "for row spaces over finite fields", true, [ IsObject,IsVectorSpace and IsRowSpace], 0, function( key, dom ) return function(key) local sz, n, ret, k,d; d:=LeftActingDomain( key ); sz := Size(d); key := BasisVectors( CanonicalBasis( key ) ); n := sz ^ Length( key[1] ); ret := 1; for k in key do ret := ret * n + NumberFFVector( k, sz ); od; return ret; end; end ); InstallMethod(DenseIntKey,"integers",true, [IsObject,IsPosInt],0, function(d,i) #T this function might cause problems if there are nonpositive integers #T used densly. return IdFunc; end); InstallMethod(SparseIntKey,"permutations, arbitrary domain",true, [IsObject,IsInternalRep and IsPerm],0, function(d,pe) return function(p) local l; l:=LARGEST_MOVED_POINT_PERM(p); if IsPerm4Rep(p) then # is it a proper 4byte perm? if l>65536 then return HashKeyBag(p,255,0,4*l); else # the permutation does not require 4 bytes. Trim in two # byte representation (we need to do this to get consistent # hash keys, regardless of representation.) TRIM_PERM(p,l); fi; fi; # now we have a Perm2Rep: return HashKeyBag(p,255,0,2*l); end; end); #T Still to do: Permutation values based on base images: Method if the #T domain given is a permgroup. InstallMethod(SparseIntKey,"kernel pc group elements",true, [IsObject, IsElementFinitePolycyclicGroup and IsDataObjectRep and IsNBitsPcWordRep],0, function(d,e) local l,p; # we want to use an small shift to avoid cancellation due to similar bit # patterns in many bytes (the exponent values in most cases are very # small). The pcgs length is a reasonable small value-- otherwise we get # already overlap for the generators alone. p:=FamilyObj(e)!.DefiningPcgs; l:=NextPrimeInt(Length(p)+1); p:=Product(RelativeOrders(p)); while Gcd(l,p)>1 do l:=NextPrimeInt(l); od; return e->HashKeyBag(e,l,DOUBLE_OBJLEN,-1); end); InstallMethod(SparseIntKey,"pcgs element lists: i.e. pcgs",true, [IsObject,IsElementFinitePolycyclicGroupCollection and IsList],0, function(d,p) local o,e; if IsPcgs(p) then o:=OneOfPcgs(p); else o:=One(p[1]); fi; e:=SparseIntKey(false,o); # element hash fun o:=DefiningPcgs(FamilyObj(o)); o:=Product(RelativeOrders(o)); # order of group return function(x) local i,h; h:=0; for i in x do h:=h*o+e(i); od; return h; end; end); InstallMethod(SparseIntKey,"transformations, arbitrary domain",true, [IsObject,IsTransformationRep],0, function(d,t) local n,l; n:=DegreeOfTransformation(t); l:=List([1..n],i->n^(i-1)); return x->x![1]*l; end); gap-4r6p5/lib/rwsdt.gi0000644000175000017500000005324212172557254013403 0ustar billbill############################################################################# ## #W rwsdt.gi GAP Library Wolfgang Merkwitz ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file implements a deep thought collector as representation of a ## polycyclic collector with power/conjugate presentation. ############################################################################# ## #R IsDeepThoughtCollectorRep( ) ## DeclareRepresentation( "IsDeepThoughtCollectorRep", IsPositionalObjectRep, [1..PC_DEFAULT_TYPE], IsPowerConjugateCollector); ############################################################################# ## #M DeepThoughtCollector( , ) ## InstallMethod( DeepThoughtCollector, true, [ IsFreeGroup and IsWholeFamily, IsList ], 0, function( fgrp, orders ) local gens; gens := GeneratorsOfGroup(fgrp); if Length(orders) > Length(gens) then Error( "need ", Length(gens), " orders, not ", Length(orders) ); fi; # create a new deep thought collector return DeepThoughtCollectorByGenerators( ElementsFamily(FamilyObj(fgrp)), gens, orders ); end ); ############################################################################# InstallMethod( DeepThoughtCollector, true, [ IsFreeGroup and IsWholeFamily, IsInt ], 0, function( fgrp, i ) local gens, orders; gens := GeneratorsOfGroup(fgrp); if i < 0 or i = 1 then Error("need zero or integer greater than ",1); fi; orders := i + 0*[1..Length(gens)]; # create a new deep thought collector return DeepThoughtCollectorByGenerators( ElementsFamily(FamilyObj(fgrp)), gens, orders ); end ); ############################################################################# ## #M DeepThoughtCollectorByGenerators( , , ) ## InstallMethod( DeepThoughtCollectorByGenerators, true, [ IsFamily, IsList, IsList ], 0, function( efam, gens, orders ) local i, dt, m, bits, type, fam; # create the correct family fam := NewFamily( "PowerConjugateCollectorFamily", IsPowerConjugateCollector ); fam!.underlyingFamily := efam; # check the generators for i in [ 1 .. Length(gens) ] do if 1 <> NumberSyllables(gens[i]) then Error( gens[i], " must be a word of length 1" ); elif 1 <> ExponentSyllable( gens[i], 1 ) then Error( gens[i], " must be a word of length 1" ); elif i <> GeneratorSyllable( gens[i], 1 ) then Error( gens[i], " must be generator number ", i ); fi; od; # construct a deep thought collector as positional object dt := []; # and a default type dt[PC_DEFAULT_TYPE] := efam!.types[4]; # the generators must have IsInfBitsAssocWord gens := ShallowCopy(gens); for i in [ 1 .. Length(gens) ] do if not IsInfBitsAssocWord(gens[i]) then gens[i] := AssocWord( dt[PC_DEFAULT_TYPE], ExtRepOfObj(gens[i]) ); fi; od; # the rhs of the powers dt[PC_POWERS] := []; # and the rhs of the conjugates dt[ PC_CONJUGATES ] := List( gens, g -> [] ); # convert into a positional object type := NewType( fam, IsDeepThoughtCollectorRep and IsMutable ); Objectify( type, dt ); # underlying family vermutlich nicht n"otig # and the generators SetGeneratorsOfRws( dt, gens ); SetNumberGeneratorsOfRws( dt, Length(gens) ); # and the relative orders SetRelativeOrders( dt, ShallowCopy(orders) ); # we haven't computed the deep thought polynomials and the generator orders OutdatePolycyclicCollector(dt); # test whether dtrws is finite and set the corresponding feature # and return return dt; end ); ############################################################################# ## #M Rules( ) ## InstallMethod( Rules, "Deep Thought", true, [ IsPowerConjugateCollector and IsDeepThoughtCollectorRep ], 0, function( dtrws ) local rels, gens, ords, i, j; # first the power relators rels := []; gens := dtrws![PC_GENERATORS]; ords := dtrws![PC_EXPONENTS]; for i in [ 1 .. dtrws![PC_NUMBER_OF_GENERATORS] ] do if IsBound( ords[i] ) then if IsBound( dtrws![PC_POWERS][i] ) then Add( rels, gens[i]^ords[i] / InfBits_AssocWord( dtrws![PC_DEFAULT_TYPE], dtrws![PC_POWERS][i] ) ); else Add( rels, gens[i]^ords[i] ); fi; fi; od; # and now the conjugates for i in [ 2 .. dtrws![PC_NUMBER_OF_GENERATORS] ] do for j in [ 1 .. i-1 ] do if IsBound( dtrws![PC_CONJUGATES][i][j] ) then Add( rels, gens[i]^gens[j] / InfBits_AssocWord( dtrws![PC_DEFAULT_TYPE], dtrws![PC_CONJUGATES][i][j] ) ); else Add( rels, gens[i]^gens[j] / gens[i] ); fi; od; od; # and return return rels; end ); ############################################################################# ## #M SetRelativeOrders( , ) ## InstallMethod( SetRelativeOrders, true, [ IsDeepThoughtCollectorRep and IsPowerConjugateCollector, IsList ], 0, function( dtrws, orders ) local i; # check the orders for i in orders do if (not IsInt(i) and i <> infinity) or i < 0 or i=1 then Error( "relative orders must be zero or infinity or integers greater than 1" ); fi; od; orders := ShallowCopy(orders); for i in [1..Length(orders)] do if IsBound(orders[i]) then if orders[i] = 0 or orders[i] = infinity then Unbind(orders[i]); fi; fi; od; dtrws![PC_EXPONENTS] := orders; if Length(orders) < dtrws![PC_NUMBER_OF_GENERATORS] or not IsHomogeneousList( orders ) then SetFeatureObj( dtrws, IsFinite, false ); else SetFeatureObj( dtrws, IsFinite, true ); fi; end ); ############################################################################# ## #M SetRelativeOrder( , , ) ## InstallMethod( SetRelativeOrder, true, [ IsDeepThoughtCollectorRep and IsPowerConjugateCollector and IsMutable, IsInt, IsObject ], 0, function( dtrws, i, ord ) if i <= 0 then Error(" must be positive"); fi; if i > dtrws![PC_NUMBER_OF_GENERATORS] then Error( " must be at most ", dtrws![PC_NUMBER_OF_GENERATORS] ); fi; if (not IsInt(ord) and ord <> infinity) or ord < 0 or ord=1 then Error( "relative order must be zero or infinity or an integer greater than 1" ); fi; if ord = infinity or ord = 0 then if IsBound( dtrws![PC_EXPONENTS][i] ) then Unbind( dtrws![PC_EXPONENTS][i] ); SetFeatureObj( dtrws, IsFinite, false ); fi; else dtrws![PC_EXPONENTS][i] := ord; if 0 in RelativeOrders( dtrws ) then SetFeatureObj( dtrws, IsFinite, false ); else SetFeatureObj( dtrws, IsFinite, true ); fi; fi; end ); ############################################################################# ## #M RelativeOrders( ) ## InstallMethod( RelativeOrders,"Method for Deep Thought", true, [ IsDeepThoughtCollectorRep and IsPowerConjugateCollector ], 0, function( dtrws ) local orders, i; orders := ShallowCopy( dtrws![PC_EXPONENTS] ); for i in [1..Length(orders)] do if not IsBound(orders[i]) then orders[i] := 0; fi; od; for i in [ Length(orders)+1..dtrws![PC_NUMBER_OF_GENERATORS] ] do orders[i] := 0; od; return orders; end ); ############################################################################# ## #M SetNumberGeneratorsOfRws( , ) ## InstallMethod( SetNumberGeneratorsOfRws, true, [ IsDeepThoughtCollectorRep and IsPowerConjugateCollector, IsInt ], 0, function( dtrws, num ) dtrws![PC_NUMBER_OF_GENERATORS] := num; end ); ############################################################################# ## #M NumberGeneratorsOfRws( ) ## InstallMethod( NumberGeneratorsOfRws, true, [ IsDeepThoughtCollectorRep and IsPowerConjugateCollector ], 0, function( dtrws ) return dtrws![PC_NUMBER_OF_GENERATORS]; end ); ############################################################################# ## #M SetGeneratorsOfRws( , ) ## InstallMethod( SetGeneratorsOfRws, true, [ IsDeepThoughtCollectorRep and IsPowerConjugateCollector, IsList ], 0, function( dtrws, gens ) dtrws![PC_GENERATORS] := ShallowCopy(gens); end ); ############################################################################# ## #M GeneratorsOfRws( ) ## InstallMethod( GeneratorsOfRws, true, [ IsDeepThoughtCollectorRep and IsPowerConjugateCollector ], 0, function( dtrws ) return ShallowCopy( dtrws![PC_GENERATORS] ); end ); ############################################################################# ## #M ViewObj( ) ## InstallMethod( ViewObj, true, [ IsDeepThoughtCollectorRep and IsPowerConjugateCollector ], 0, function( dtrws ) Print( "<< deep thought collector >>" ); end ); ############################################################################# ## #M PrintObj( ) ## InstallMethod( PrintObj, true, [ IsDeepThoughtCollectorRep and IsPowerConjugateCollector ], 0, function( dtrws ) Print( "<< deep thought collector >>" ); end ); #T install a better `PrintObj' method! ############################################################################# ## #M SetPower( , , ) ## InstallMethod( SetPower, IsIdenticalObjFamiliesColXXXObj, [ IsPowerConjugateCollector and IsDeepThoughtCollectorRep and IsMutable, IsInt, IsMultiplicativeElementWithInverse ], 0, function( dtrws, i, rhs ) local fam, m, n, l; # check the family (this cannot be done in install) fam := UnderlyingFamily(dtrws); if not IsIdenticalObj( FamilyObj(rhs), fam ) then Error( " must lie in the group of " ); fi; # check if i <= 0 then Error( " must be positive" ); fi; if NumberGeneratorsOfRws(dtrws) < i then Error( " must be at most ", dtrws![PC_NUMBER_OF_GENERATORS] ); fi; if not IsBound( dtrws![PC_EXPONENTS][i] ) then Error( "no relative order is set for generator ", i ); fi; # check that the rhs is a reduced word with respect to the relative orders for m in [1..NumberSyllables(rhs)] do if IsBound( dtrws![PC_EXPONENTS][ GeneratorSyllable(rhs, m) ] ) and ExponentSyllable(rhs, m) >= dtrws![PC_EXPONENTS][ GeneratorSyllable(rhs, m) ] then Error(" is not reduced"); fi; if m < NumberSyllables(rhs) then if GeneratorSyllable(rhs, m) >= GeneratorSyllable(rhs, m+1) then Error(" is not reduced"); fi; fi; od; # check that the rhs lies underneath i if NumberSyllables(rhs) > 0 and GeneratorSyllable(rhs, 1) <= i then Error("illegal "); fi; # enter the rhs dtrws![PC_POWERS][i] := ExtRepOfObj(rhs); end ); ############################################################################# ## #M SetConjugate( , , , ) ## ## required: > ## DeepThoughtCollector_SetConjugateNC := function(dtrws, i, j, rhs) if IsBound(dtrws![PC_CONJUGATES][i]) then dtrws![PC_CONJUGATES][i][j] := ExtRepOfObj(rhs); else dtrws![PC_CONJUGATES][i] := []; dtrws![PC_CONJUGATES][i][j] := ExtRepOfObj(rhs); fi; end; InstallMethod( SetConjugate, IsIdenticalObjFamiliesColXXXXXXObj, [ IsPowerConjugateCollector and IsDeepThoughtCollectorRep and IsMutable, IsInt, IsInt, IsMultiplicativeElementWithInverse ], 0, function( dtrws, i, j, rhs ) local fam, m, n, l; # check and if i <= 1 then Error( " must be at least 2" ); fi; if dtrws![PC_NUMBER_OF_GENERATORS] < i then Error( " must be at most ", dtrws![PC_NUMBER_OF_GENERATORS] ); fi; if j <= 0 then Error( " must be positive" ); fi; if i <= j then Error( " must be at most ", i-1 ); fi; # check that the rhs is non-trivial if 0 = NumberSyllables(rhs) then Error( "right hand side is trivial" ); fi; # check that the rhs is a reduced word with respect to the relative orders for m in [1..NumberSyllables(rhs)] do if IsBound( dtrws![PC_EXPONENTS][ GeneratorSyllable(rhs, m) ] ) and ExponentSyllable(rhs, m) >= dtrws![PC_EXPONENTS][ GeneratorSyllable(rhs, m) ] then Error(" is not reduced"); fi; if m < NumberSyllables(rhs) then if GeneratorSyllable(rhs, m) >= GeneratorSyllable(rhs, m+1) then Error(" is not reduced"); fi; fi; od; # check that the rhs defines a nilpotent relation if GeneratorSyllable(rhs, 1) <> i or ExponentSyllable(rhs, 1) <> 1 then Error("rhs does not define a nilpotent relation"); fi; # install the conjugate relator DeepThoughtCollector_SetConjugateNC( dtrws, i, j, rhs ); OutdatePolycyclicCollector( dtrws ); end ); ############################################################################# ## #M UpdatePolycyclicCollector( ) ## InstallMethod( UpdatePolycyclicCollector, true, [ IsPowerConjugateCollector and IsDeepThoughtCollectorRep ], 0, function( dtrws ) local i,j; if IsUpToDatePolycyclicCollector(dtrws) then return; fi; # complete dtrws for i in [2..dtrws![PC_NUMBER_OF_GENERATORS]] do if not IsBound( dtrws![PC_CONJUGATES][i] ) then dtrws![PC_CONJUGATES][i] := []; fi; od; # remove trivial rhs's for i in [2..Length(dtrws![PC_CONJUGATES])] do for j in [1..i-1] do if IsBound(dtrws![PC_CONJUGATES][i][j]) then if Length(dtrws![PC_CONJUGATES][i][j]) = 2 then Unbind( dtrws![PC_CONJUGATES][i][j] ); fi; fi; od; od; for i in [1..dtrws![PC_NUMBER_OF_GENERATORS]] do if IsBound( dtrws![PC_POWERS][i]) then if Length(dtrws![PC_POWERS][i]) = 0 then Unbind( dtrws![PC_POWERS][i] ); fi; fi; od; # Compute the deep thought polynomials Print("computing deep thought polynomials ...\n"); dtrws![PC_DEEP_THOUGHT_POLS] := Calcreps2(dtrws![PC_CONJUGATES], 8, 1); Print("done\n"); # Compute the orders of the genrators of dtrws Print("computing generator orders ...\n"); CompleteOrdersOfRws(dtrws); Print("done\n"); # reduce the coefficients of the deep thought polynomials ReduceCoefficientsOfRws(dtrws); SetFeatureObj( dtrws, IsUpToDatePolycyclicCollector, true ); end ); ############################################################################# ## #M ReducedProduct( , , ) ## InstallMethod(ReducedProduct, "DeepThoughtReducedProduct", IsIdenticalObjFamiliesRwsObjObj, [IsPowerConjugateCollector and IsDeepThoughtCollectorRep and IsUpToDatePolycyclicCollector, IsAssocWord, IsAssocWord], 0, function(dtrws, lword, rword) return InfBits_AssocWord( dtrws![PC_DEFAULT_TYPE], DTMultiply( ExtRepOfObj(lword), ExtRepOfObj(rword), dtrws ) ); end ); ############################################################################# ## #M ReducedComm( , , ) ## InstallMethod(ReducedComm, "DeepThoughtReducedComm", IsIdenticalObjFamiliesRwsObjObj, [IsPowerConjugateCollector and IsDeepThoughtCollectorRep and IsUpToDatePolycyclicCollector, IsAssocWord, IsAssocWord], 0, function(dtrws, lword, rword) return InfBits_AssocWord( dtrws![PC_DEFAULT_TYPE], DTCommutator( ExtRepOfObj(lword), ExtRepOfObj(rword), dtrws ) ); end ); ############################################################################# ## #M ReducedLeftQuotient( , , ) ## InstallMethod(ReducedLeftQuotient, "DeepThoughtReducedLeftQuotient", IsIdenticalObjFamiliesRwsObjObj, [IsPowerConjugateCollector and IsDeepThoughtCollectorRep and IsUpToDatePolycyclicCollector, IsAssocWord, IsAssocWord], 0, function(dtrws, lword, rword) return InfBits_AssocWord( dtrws![PC_DEFAULT_TYPE], DTSolution( ExtRepOfObj(lword), ExtRepOfObj(rword), dtrws ) ); end ); ############################################################################# ## #M ReducedPower( , , ) ## InstallMethod(ReducedPower, "DeepThoughtReducedPower", IsIdenticalObjFamiliesRwsObjXXX, [IsPowerConjugateCollector and IsDeepThoughtCollectorRep and IsUpToDatePolycyclicCollector, IsAssocWord, IsInt], 0, function(dtrws, word, int) return InfBits_AssocWord( dtrws![PC_DEFAULT_TYPE], DTPower( ExtRepOfObj(word), int, dtrws ) ); end ); ############################################################################# ## #M ReducedQuotient( , , ) ## InstallMethod(ReducedQuotient, "DeepThoughtReducedQuotient", IsIdenticalObjFamiliesRwsObjObj, [IsPowerConjugateCollector and IsDeepThoughtCollectorRep and IsUpToDatePolycyclicCollector, IsAssocWord, IsAssocWord], 0, function(dtrws, lword, rword) return InfBits_AssocWord( dtrws![PC_DEFAULT_TYPE], DTQuotient( ExtRepOfObj(lword), ExtRepOfObj(rword), dtrws ) ); end ); ############################################################################# ## #M ReducedConjugate( , , ) ## InstallMethod(ReducedConjugate, "DeepThoughtReducedConjugate", IsIdenticalObjFamiliesRwsObjObj, [IsPowerConjugateCollector and IsDeepThoughtCollectorRep and IsUpToDatePolycyclicCollector, IsAssocWord, IsAssocWord], 0, function(dtrws, lword, rword) return InfBits_AssocWord( dtrws![PC_DEFAULT_TYPE], DTConjugate( ExtRepOfObj(lword), ExtRepOfObj(rword), dtrws ) ); end ); ############################################################################# ## #M ReducedInverse( , ) ## InstallMethod(ReducedInverse, "DeepThoughtReducedInverse", IsIdenticalObjFamiliesRwsObj, [IsPowerConjugateCollector and IsDeepThoughtCollectorRep and IsUpToDatePolycyclicCollector, IsAssocWord], 0, function(dtrws, word) return InfBits_AssocWord( dtrws![PC_DEFAULT_TYPE], DTSolution( ExtRepOfObj(word), [], dtrws ) ); end ); ############################################################################# ## #M CollectWordOrFail( , , ) ## ## This is only implemented to please the generic method for GroupByRws. For ## computations use ReducedProduct, ReducedComm etc. ## InstallMethod(CollectWordOrFail, "DeepThought", IsIdenticalObjFamiliesColXXXObj, [IsPowerConjugateCollector and IsDeepThoughtCollectorRep, IsList, IsMultiplicativeElementWithInverse], 0, function(dtrws, l, word) local i,j, help, help1,ext; if not IsUpToDatePolycyclicCollector(dtrws) then UpdatePolycyclicCollector(dtrws); fi; if NumberSyllables(word) = 0 then return true; fi; ext := ExtRepOfObj(word); i := 1; help := []; # reduce ext and store the result in help while i < Length(ext) do Append(help, [ ext[i], ext[i+1] ] ); if i+1 = Length(ext) or ext[i] >= ext[i+2] then break; fi; i := i+2; od; i := i+2; help1 := []; while i < Length(ext) do Append( help1, [ ext[i], ext[i+1] ] ); if i+1 = Length(ext) or ext[i] >= ext[i+2] then help := DTMultiply(help, help1, dtrws); help1 := []; fi; i := i+2; od; # convert l into ExtRep of a word and store the result in help1 help1 := []; for i in [1..Length(l)] do if l[i] <> 0 then Append( help1, [ i, l[i] ] ); fi; od; # compute the product of help1 and help help := DTMultiply(help1, help, dtrws); # convert the result into an exponent vector and store the result in l for i in [1..Length(l)] do l[i] := 0; od; for i in [1,3..Length(help)-1] do l[ help[i] ] := help[i+1]; od; return true; end ); ############################################################################# ## #M ObjByExponents( , ) ## InstallMethod(ObjByExponents, "DeepThought", true, [IsPowerConjugateCollector and IsDeepThoughtCollectorRep, IsList], 0, function(dtrws, l) local res, i; res := []; for i in [1..Length(l)] do if l[i] <> 0 then Append( res, [ i, l[i] ] ); fi; od; return InfBits_AssocWord( dtrws![PC_DEFAULT_TYPE], res ); end ); ############################################################################# ## #E rwsdt.gi . . . . . . . . . . . . . . . . . . . . . . . . . . . ends here ## gap-4r6p5/lib/kbsemi.gd0000644000175000017500000000731012172557252013476 0ustar billbill############################################################################# ## #W kbsemi.gd GAP library Andrew Solomon and Isabel Araújo ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the declarations for Knuth-Bendix Rewriting Systems ## ############################################################################ ## #I InfoKnuthBendix ## ## DeclareInfoClass("InfoKnuthBendix"); ############################################################################ ## #C IsKnuthBendixRewritingSystem() ## ## ## ## ## ## This is the category of Knuth-Bendix rewriting systems. ## ## ## DeclareCategory("IsKnuthBendixRewritingSystem", IsRewritingSystem); ############################################################################# ## #A KnuthBendixRewritingSystem(,) ## ## ## ## ## ## returns the Knuth-Bendix rewriting system of the family fam ## with respect to the reduction ordering on words given by wordord. ## ## ## DeclareOperation("KnuthBendixRewritingSystem",[IsFamily,IsOrdering]); ############################################################################ ## #F CreateKnuthBendixRewritingSystem(,) ## ## ## ## ## ## ## ## DeclareGlobalFunction("CreateKnuthBendixRewritingSystem"); ############################################################################ ## #F MakeKnuthBendixRewritingSystemConfluent() ## ## ## ## ## ## makes a RWS confluent by running a KB. It will call ## KB_REW.MakeKnuthBendixRewritingSystemConfluent. ## ## ## DeclareGlobalFunction("MakeKnuthBendixRewritingSystemConfluent"); ############################################################################# ## #V KB_REW #V GAPKB_REW ## ## <#GAPDoc Label="KB_REW"> ## ## ## ## ## ## KB_REW is a global record variable whose components contain functions ## used for Knuth-Bendix. By default KB_REW is assigned to ## GAPKB_REW, which contains the KB functions provided by ## the GAP library. ## ## ## <#/GAPDoc> ## BindGlobal("GAPKB_REW",rec(name:="GAP library Knuth-Bendix")); KB_REW:=GAPKB_REW; ############################################################################ ## #F ReduceWordUsingRewritingSystem(,) ## ## ## ## ## ## ## ## DeclareGlobalFunction("ReduceWordUsingRewritingSystem"); ############################################################################# ## #A TzRules( ) ## ## ## ## ## ## For a Knuth-Bendix rewriting system for a monoid, this attribute ## contains rewriting rules in compact form as Tietze words. The ## numbers used correspond to the generators of the monoid. ## ## ## DeclareAttribute( "TzRules", IsKnuthBendixRewritingSystem ); ############################################################################# ## #E gap-4r6p5/lib/grptbl.gd0000644000175000017500000001717612172557252013531 0ustar billbill############################################################################# ## #W grptbl.gd GAP library Thomas Breuer ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the implementation of magmas, monoids, and groups from ## a multiplication table. ## ############################################################################# ## #F MagmaByMultiplicationTableCreator( , ) ## ## ## ## ## ## This is a utility for the uniform construction of a magma, ## a magma-with-one, or a magma-with-inverses from a multiplication table. ## ## ## DeclareGlobalFunction( "MagmaByMultiplicationTableCreator" ); ############################################################################# ## #F MagmaByMultiplicationTable( ) ## ## <#GAPDoc Label="MagmaByMultiplicationTable"> ## ## ## ## ## For a square matrix A with n rows such that all entries of ## A are in the range [ 1 .. n ], ## returns a magma ## M with multiplication * defined by A. ## That is, M consists of the elements m_1, m_2, \ldots, m_n, ## and m_i * m_j = m_k, with k = A[i][j]. ##

## The ordering of elements is defined by ## m_1 < m_2 < \cdots < m_n, ## so m_i can be accessed as ## MagmaElement( M, i ), ## see . ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "MagmaByMultiplicationTable" ); ############################################################################# ## #F MagmaWithOneByMultiplicationTable( ) ## ## <#GAPDoc Label="MagmaWithOneByMultiplicationTable"> ## ## ## ## ## The only differences between and ## are that the latter ## returns a magma-with-one (see ) ## if the magma described by the matrix A has an identity, ## and returns fail if not. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "MagmaWithOneByMultiplicationTable" ); ############################################################################# ## #F MagmaWithInversesByMultiplicationTable( ) ## ## <#GAPDoc Label="MagmaWithInversesByMultiplicationTable"> ## ## ## ## ## and ## ## differ only in that the latter returns ## magma-with-inverses (see ) ## if each element in the magma described by the matrix A ## has an inverse, ## and returns fail if not. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "MagmaWithInversesByMultiplicationTable" ); ############################################################################# ## #F MagmaElement( , ) . . . . . . . . . . -th element of magma ## ## <#GAPDoc Label="MagmaElement"> ## ## ## ## ## For a magma M and a positive integer i, ## returns the i-th element of M, ## w.r.t. the ordering <. ## If M has less than i elements then fail is returned. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "MagmaElement" ); ############################################################################# ## #F SemigroupByMultiplicationTable( ) ## ## <#GAPDoc Label="SemigroupByMultiplicationTable"> ## ## ## ## ## returns the semigroup whose multiplication is defined by the square ## matrix A (see ) ## if such a semigroup exists. ## Otherwise fail is returned. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "SemigroupByMultiplicationTable" ); ############################################################################# ## #F MonoidByMultiplicationTable( ) ## ## <#GAPDoc Label="MonoidByMultiplicationTable"> ## ## ## ## ## returns the monoid whose multiplication is defined by the square ## matrix A (see ) ## if such a monoid exists. ## Otherwise fail is returned. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "MonoidByMultiplicationTable" ); ############################################################################# ## #F GroupByMultiplicationTable( ) ## ## ## ## ## ## returns the group whose multiplication is defined by the square ## matrix A (see ) ## if such a group exists. ## Otherwise fail is returned. ## ## ## DeclareGlobalFunction( "GroupByMultiplicationTable" ); ############################################################################# ## #A MultiplicationTable( ) #A MultiplicationTable( ) ## ## <#GAPDoc Label="MultiplicationTable"> ## ## MultiplicationTable ## ## ## ## ## For a list elms of elements that form a magma M, ## returns ## a square matrix A of positive integers such that ## A[i][j] = k holds if and only if ## elms[i] * elms[j] = elms[k]. ## This matrix can be used to construct a magma isomorphic to M, ## using . ##

## For a magma M, ## returns ## the multiplication table w.r.t. the sorted list of elements of ## M. ##

## l:= [ (), (1,2)(3,4), (1,3)(2,4), (1,4)(2,3) ];; ## gap> a:= MultiplicationTable( l ); ## [ [ 1, 2, 3, 4 ], [ 2, 1, 4, 3 ], [ 3, 4, 1, 2 ], [ 4, 3, 2, 1 ] ] ## gap> m:= MagmaByMultiplicationTable( a ); ## ## gap> One( m ); ## m1 ## gap> elm:= MagmaElement( m, 2 ); One( elm ); elm^2; ## m2 ## m1 ## m1 ## gap> Inverse( elm ); ## m2 ## gap> AsGroup( m ); ## ## gap> a:= [ [ 1, 2 ], [ 2, 2 ] ]; ## [ [ 1, 2 ], [ 2, 2 ] ] ## gap> m:= MagmaByMultiplicationTable( a ); ## ## gap> One( m ); Inverse( MagmaElement( m, 2 ) ); ## m1 ## fail ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "MultiplicationTable", IsHomogeneousList ); DeclareAttribute( "MultiplicationTable", IsMagma ); ############################################################################# ## #E gap-4r6p5/lib/polyconw.gi0000644000175000017500000004550512172557254014115 0ustar billbill############################################################################# ## #W polyconw.gi GAP library Thomas Breuer #W Frank Lübeck ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the implementation part of functions and data around ## Conway polynomials. ## ############################################################################### ## #F PowerModEvalPol( , , ) ## InstallGlobalFunction( PowerModEvalPol, function( f, g, xpownmodf ) local l, res, reslen, powlen, i; l:= Length( g ); res:= [ g[l] ]; reslen:= 1; powlen:= Length( xpownmodf ); ConvertToVectorRep( res ); for i in [ 1 .. l-1 ] do res:= ProductCoeffs( res, reslen, xpownmodf, powlen ); # `res:= res * x^n;' reslen:= ReduceCoeffs( res, f ); # `res:= res mod f;' if reslen = 0 then res[1]:= g[l-i]; # `res:= res + g_{l-i+1};' reslen:= 1; else res[1]:= res[1] + g[l-i]; # `res:= res + g_{l-i+1};' fi; od; ShrinkRowVector( res ); return res; end ); ############################################################################ ## #V CONWAYPOLYNOMIALS ## ## This variable was used in GAP 4, version <= 4.4.4 for storing ## coefficients of (pre)computed Conway polynomials. It is no longer used. ## ############################################################################ ## #V CONWAYPOLYNOMIALSINFO ## ## strings describing the origin of precomputed Conway polynomials, can be ## accessed by 'InfoText' ## ## also used to remember which data files were read ## BindGlobal("CONWAYPOLYNOMIALSINFO", rec( RP := "original list by Richard Parker (from 1980's)\n", GAP := "computed with the GAP function by Thomas Breuer, just checks\n\ conditions starting from 'smallest' polynomial\n", FL := "computed by a parallelized program by Frank Lübeck, computes\n\ minimal polynomial of all compatible elements (~2001)\n", KM := "computed by Kate Minola, a parallelized program for p=2, considering\n\ minimal polynomials of all compatible elements (~2004-2005)\n", RPn := "computed by Richard Parker (2004)\n", 3\,21 := "for p=3, n=21 there appeared a polynomial in some lists/systems\n\ which was not the Conway polynomial; the current one in GAP is correct\n", JB := "computed by John Bray using minimal polynomials of consistent \ elements, respectively a similar algorithm as in GAP (~2005)\n", conwdat1 := false, conwdat2 := false, conwdat3 := false, # cache for p > 110000 cache := rec() ) ); ############################################################################ ## #V CONWAYPOLDATA ## ## List of lists caching (pre-)computed Conway polynomials. ## ## Format: The ConwayPolynomial(p, n) is cached in CONWAYPOLDATA[p][n]. ## The entry has the format [num, fld]. Here fld is one of the ## component names of CONWAYPOLYNOMIALSINFO and describes the ## origin of the polynomial. num is an integer, encoding the ## polynomial as follows: ## Let (a0 + a1 X + a2 X^2 + ... + X^n)*One(GF(p)) be the polynomial ## where a0, a1, ... are integers in the range 0..p-1. Then ## num = a0 + a1 p + a2 p^2 + ... + a p^(n-1). ## BindGlobal("CONWAYPOLDATA", []); ## a utility function, checks consistency of a polynomial with Conway ## polynomials of proper subfield. (But doesn't check that it is the ## "smallest" such polynomial in the ordering used to define Conway ## polynomials. BindGlobal( "IsConsistentPolynomial", function( pol ) local n, p, ps, x, null, f; n := DegreeOfLaurentPolynomial(pol); p := Characteristic(pol); ps := Set(FactorsInt(n)); x := IndeterminateOfLaurentPolynomial(pol); null := 0*pol; f := function(k) local kpol; kpol := ConwayPolynomial(p, k); return Value(kpol, PowerMod(x, (p^n-1)/(p^k-1), pol)) mod pol = null; end; if IsPrimitivePolynomial(GF(p), pol) then return ForAll(ps, p-> f(n/p)); else return false; fi; end); ## This is now incorporated more intelligently in the 'FactInt' package. ## Commented out, since it wasn't documented anyway. ## BRENT_FACTORS_LIST := "not loaded, call `AddBrentFactorList();'"; ## AddBrentFactorList := function( ) ## local str, get, comm, res, n, p, z, pos; ## Print( ## "Copying many prime factors of numbers a^n+1 / a^n-1 from Richard Brent's\n", ## "list `factors.gz' (in \n", ## "ftp://ftp.comlab.ox.ac.uk/pub/Documents/techpapers/Richard.Brent/factors/factors.gz\n"); ## str := ""; ## get := OutputTextString(str, false); ## comm := "wget -q ftp://ftp.comlab.ox.ac.uk/pub/Documents/techpapers/Richard.Brent/factors/factors.gz -O - | gzip -dc "; ## Process(DirectoryCurrent(), Filename(DirectoriesSystemPrograms(),"sh"), ## InputTextUser(), get, ["-c", comm]); ## res := [[],[]]; ## n := 0; ## p := Position(str, '\n', 0); ## while p <> fail do ## z := str{[n+1..p-1]}; ## pos := Position(z, '-'); ## if pos = fail then ## pos := Position(z, '+'); ## fi; ## if pos <> fail then ## Add(res[1], NormalizedWhitespace(z{[1..pos]})); ## Add(res[2], Int(NormalizedWhitespace(z{[pos+2..Length(z)]}))); ## fi; ## n := p; ## p := Position(str, '\n', n); ## od; ## for p in res[2] do ## AddSet(Primes2,p); ## od; ## SortParallel(res[1], res[2]); ## BRENT_FACTORS_LIST := res; ## end; ## A consistency check for the data, loading AddBrentFactorList() is useful ## for the primitivity tests. ## ## # for 41^41-1 ## AddSet(Primes2, 5926187589691497537793497756719); ## # for 89^89-1 ## AddSet(Primes2, 4330075309599657322634371042967428373533799534566765522517); ## # for 97^97-1 ## AddSet(Primes2, 549180361199324724418373466271912931710271534073773); ## AddSet(Primes2, 85411410016592864938535742262164288660754818699519364051241927961077872028620787589587608357877); ## for p in [2,113,1009] do IsCheapConwayPolynomial(p,1); od; ## cp:=CONWAYPOLDATA;; ## test := []; ## for i in [1..Length(cp)] do ## if IsBound(cp[i]) then ## for j in [1..Length(cp[i])] do ## if IsBound(cp[i][j]) then ## a := IsConsistentPolynomial(ConwayPolynomial(i,j)); ## Print(i," ",j," ", a,"\n"); ## Add(test, [i, j, a]); ## fi; ## od; ## fi; ## od; ## number of polynomials for GF(p^n) compatible with Conway polynomials for ## all proper subfields. BindGlobal("NrCompatiblePolynomials", function(p, n) local ps, lcm; ps := Set(Factors(n)); lcm := Lcm(List(ps, r-> p^(n/r)-1)); return (p^n-1)/lcm; end); ## list of all cases wich less than 100*10^9 compatible polynomials, sorted ## w.r.t. this number ConwayCandidates := function() local cand, p, i; # read data for p in [2,113,1009] do ConwayPolynomial(p,1); od; cand := [];; for p in Primes{[1..31]} do for i in [1..200] do if NrCompatiblePolynomials(p,i) < 100000000000 then Add(cand, [NrCompatiblePolynomials(p,i), p, i]); fi; od; od; Sort(cand); cand := Filtered(cand, a-> not IsBound(CONWAYPOLDATA[a[2]][a[3]])); return cand; end; ## ## #################### end of list of new polynomials #################### ############################################################################ ## #F ConwayPol(

, ) . . . . . -th Conway polynomial in charact.

## InstallGlobalFunction( ConwayPol, function( p, n ) local F, # `GF(p)' one, # `One( F )' zero, # `Zero( F )' eps, # $(-1)^n$ in `F' x, # indeterminate over `F', as coefficients list cpol, # actual candidate for the Conway polynomial nfacs, # all `n/d' for prime divisors `d' of `n' cpols, # Conway polynomials for `d' in `nfacs' pp, # $p^n-1$ quots, # list of $(p^n-1)/(p^d-1)$, for $d$ in `nfacs' lencpols, # `Length( cpols )' ppmin, # list of $(p^n-1)/d$, for prime factors $d$ of $p^n-1$ found, # is the actual candidate compatible? onelist, # `[ one ]' pow, # powers of several polynomials i, # loop over `ppmin' xpownmodf, # power of `x', modulo `cpol' c, # loop over `cpol' e, # 1 or -1, used to compute the next candidate linfac, # for a quick precheck cachelist, # list of known Conway pols for given p StoreConwayPol; # maybe move out? # Check the arguments. if not ( IsPrimeInt( p ) and IsInt( n ) and n > 0 ) then Error( "

must be a prime, a positive integer" ); fi; # read data files if necessary if 1 < p and p <= 109 and CONWAYPOLYNOMIALSINFO.conwdat1 = false then ReadLib("conwdat1.g"); elif 109 < p and p < 1000 and CONWAYPOLYNOMIALSINFO.conwdat2 = false then ReadLib("conwdat2.g"); elif 1000 < p and p < 110000 and CONWAYPOLYNOMIALSINFO.conwdat3 = false then ReadLib("conwdat3.g"); fi; if p < 110000 then if not IsBound( CONWAYPOLDATA[p] ) then CONWAYPOLDATA[p] := []; fi; cachelist := CONWAYPOLDATA[p]; else if not IsBound( CONWAYPOLYNOMIALSINFO.cache.(String(p)) ) then CONWAYPOLYNOMIALSINFO.cache.(String(p)) := []; fi; cachelist := CONWAYPOLYNOMIALSINFO.cache.(String(p)); fi; if not IsBound( cachelist[n] ) then Info( InfoWarning, 1, "computing Conway polynomial for p = ", p, " and n = ", n ); F:= GF(p); one:= One( F ); zero:= Zero( F ); if n mod 2 = 1 then eps:= AdditiveInverse( one ); else eps:= one; fi; # polynomial `x' (as coefficients list) x:= [ zero, one ]; ConvertToVectorRep(x, p); # Initialize the smallest polynomial of degree `n' that is a candidate # for being the Conway polynomial. # This is `x^n + (-1)^n \*\ z' for the smallest primitive root `z'. # If the field can be realized in {\GAP} then `z' is just `Z(p)'. # Note that we enumerate monic polynomials with constant term # $(-1)^n \alpha$ where $\alpha$ is the smallest primitive element in # $GF(p)$ by the compatibility condition (and by existence of such a # polynomial). cpol:= ListWithIdenticalEntries( n, zero ); cpol[ n+1 ]:= one; cpol[1]:= eps * PrimitiveRootMod( p ); ConvertToVectorRep(cpol, p); if n > 1 then # Compute the list of all `n / l' for `l' a prime divisor of `n' nfacs:= List( Set( Factors( n ) ), d -> n / d ); if nfacs = [ 1 ] then # `n' is a prime, we have to check compatibility only with # the degree 1 Conway polynomial. # But this condition is satisfied by choice of the constant term # of the candidates. cpols:= []; else # Compute the Conway polynomials for all values $ / d$ # where $d$ is a prime divisor of . # They are used for checking compatibility. cpols:= List( nfacs, d -> ConwayPol( p, d ) * one ); List(cpols, f-> ConvertToVectorRep(f, p)); fi; pp:= p^n-1; quots:= List( nfacs, x -> pp / ( p^x -1 ) ); lencpols:= Length( cpols ); ppmin:= List( Set( Factors( pp ) ), d -> pp/d ); found:= false; onelist:= [ one ]; # many random polynomials have linear factors, for small p we check # this before trying to check primitivity if p < 256 then linfac := List([0..p-2], i-> List([0..n], k-> Z(p)^(i*k))); List(linfac, a-> ConvertToVectorRep(a,p)); else linfac := []; fi; while not found do # Test whether `cpol' is primitive. # $f$ is primitive if and only if # 0. (check first for small p) there is no zero in GF(p), # 1. $f$ divides $X^{p^n-1} -1$, and # 2. $f$ does not divide $X^{(p^n-1)/l} - 1$ for every # prime divisor $l$ of $p^n - 1$. found := ForAll(linfac, a-> a * cpol <> zero); if found then pow:= PowerModCoeffs( x, 2, pp, cpol, n+1 ); ShrinkRowVector( pow ); found:= ( pow = onelist ); fi; i:= 1; while found and ( i <= Length( ppmin ) ) do pow:= PowerModCoeffs( x, 2, ppmin[i], cpol, n+1 ); ShrinkRowVector( pow ); found:= pow <> onelist; i:= i+1; od; # Test compatibility with polynomials in `cpols'. i:= 1; while found and i <= lencpols do # Compute $`cpols[i]'( x^{\frac{p^n-1}{p^m-1}} ) mod `cpol'$. xpownmodf:= PowerModCoeffs( x, quots[i], cpol ); pow:= PowerModEvalPol( cpol, cpols[i], xpownmodf ); # Note that we need *not* call `ShrinkRowVector' # since the list `cpols[i]' has always length at least 2, # and a final `ShrinkRowVector' call is done by `PowerModEvalPol'. # ShrinkRowVector( pow ); found:= IsEmpty( pow ); i:= i+1; od; if not found then # Compute the next candidate according to the chosen ordering. # We have $f$ smaller than $g$ for two polynomials $f$, $g$ of # degree $n$ with # $f = \sum_{i=0}^n (-1)^{n-i} f_i x^i$ and # $g = \sum_{i=0}^n (-1)^{n-i} g_i x^i$ if and only if exists # $m\leq n$ such that $f_m \< g_m$, # and $f_i = g_i$ for all $i > m$. # (Note that the thesis of W. Nickel gives a wrong definition.) c:= 0; e:= eps; repeat c:= c+1; e:= -1*e; cpol[c+1]:= cpol[c+1] + e; until cpol[c+1] <> zero; fi; od; fi; StoreConwayPol := function(cpol, cachelist) local found, p, n; if IsUnivariatePolynomial(cpol) then cpol := CoefficientsOfUnivariatePolynomial(cpol); fi; p := Characteristic(cpol[1]); n := Length(cpol)-1; cpol:= List( cpol, IntFFE ); # Subtract `x^n', strip leading zeroes, # and store this polynomial in the global list. found:= ShallowCopy( cpol ); Unbind( found[ n+1 ] ); ShrinkRowVector( found ); cachelist[n]:= [List([0..Length(found)-1], k-> p^k) * found, "GAP"]; end; StoreConwayPol(cpol, cachelist); else # Decode the polynomial stored in the list (see description of # CONWAYPOLDATA above). c := cachelist[n][1]; cpol:= []; while c <> 0 do Add(cpol, c mod p); c := (c - cpol[Length(cpol)]) / p; od; while Length( cpol ) < n do Add( cpol, 0 ); od; Add( cpol, 1 ); fi; # Return the coefficients list. return cpol; end ); ############################################################################ ## #F ConwayPolynomial(

, ) . -th Conway polynomial in charact.

## InstallGlobalFunction( ConwayPolynomial, function( p, n ) local F, res; if IsPrimeInt( p ) and IsPosInt( n ) then F:= GF(p); res := UnivariatePolynomial( F, One( F ) * ConwayPol( p, n ) ); if p < 110000 then Setter(InfoText)(res, CONWAYPOLYNOMIALSINFO.( CONWAYPOLDATA[p][n][2])); else Setter(InfoText)(res, CONWAYPOLYNOMIALSINFO.cache.( String(p))[n][2]); fi; return res; else Error( "

must be a prime, a positive integer" ); fi; end ); InstallGlobalFunction( IsCheapConwayPolynomial, function( p, n ) if IsPrimeInt( p ) and IsPosInt( n ) then # read data files if necessary if 1 < p and p <= 109 and CONWAYPOLYNOMIALSINFO.conwdat1 = false then ReadLib("conwdat1.g"); elif 109 < p and p < 1000 and CONWAYPOLYNOMIALSINFO.conwdat2 = false then ReadLib("conwdat2.g"); elif 1000 < p and p < 110000 and CONWAYPOLYNOMIALSINFO.conwdat3 = false then ReadLib("conwdat3.g"); fi; if p < 110000 and IsBound(CONWAYPOLDATA[p]) and IsBound(CONWAYPOLDATA[p][n]) then return true; fi; if p >= 110000 and IsBound(CONWAYPOLYNOMIALSINFO.cache.(String(p))) and IsBound(CONWAYPOLYNOMIALSINFO.cache.(String(p))[n]) then return true; fi; # this is not very precise, hopefully good enough for the moment if p < 41 then if n < 100 and IsPrimeInt(n) then return true; fi; elif p < 100 then if n < 40 and IsPrimeInt(n) then return true; fi; elif p < 1000 then if n < 14 and IsPrimeInt(n) then return true; fi; elif p < 2^48 then if n in [1,2,3,5,7] then return true; fi; elif p < 2^60 then if n in [1,2,3,5] then return true; fi; elif p < 2^120 then if n in [1,2,3] then return true; fi; elif p < 2^200 then if n in [1,2] then return true; fi; elif n = 1 then return false; fi; fi; return false; end ); # arg: F, n[, i] InstallGlobalFunction( RandomPrimitivePolynomial, function(arg) local F, n, i, pol, FF, one, fac, a; F := arg[1]; n := arg[2]; if Length(arg) > 2 then i := arg[3]; else i := 1; fi; if IsUnivariatePolynomial(i) then i := IndeterminateNumberOfUnivariateRationalFunction(i); fi; if IsInt(F) then F := GF(F); fi; repeat pol := RandomPol(F, n, i); until IsIrreducibleRingElement(PolynomialRing(F), pol); FF := AlgebraicExtension(F, pol); one := One(FF); fac:=List(Set(Factors(Size(FF)-1)), p-> (Size(FF)-1)/p); repeat a := Random(FF); until ForAll(fac, d-> a^d <> one); return MinimalPolynomial(F, a); end ); ## # utility to write new data files in case of extensions ## printConwayData := function(f) ## local i, j, v; ## for i in [1..Length(CONWAYPOLDATA)] do ## if IsBound(CONWAYPOLDATA[i]) then ## PrintTo(f, "CONWAYPOLDATA[",i,"]:=[\n"); ## for j in [1..Length(CONWAYPOLDATA[i])] do ## if IsBound(CONWAYPOLDATA[i][j]) then ## PrintTo(f,"[",CONWAYPOLDATA[i][j][1],",\"",CONWAYPOLDATA[i][j][2], ## "\"]"); ## fi; ## PrintTo(f,","); ## od; ## PrintTo(f,"];\n"); ## fi; ## od; ## end; ## f := OutputTextFile("guck.g", false); ## SetPrintFormattingStatus(f, false); ## printConwayData(f); ## CloseStream(f); ## # and then distribute into conwdat?.g ############################################################################# ## #E gap-4r6p5/lib/grplatt.gi0000644000175000017500000021751712172557252013722 0ustar billbill############################################################################# ## #W grplatt.gi GAP library Martin Schönert, #W Alexander Hulpke ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains declarations for subgroup latices ## ############################################################################# ## #F Zuppos() . set of generators for cyclic subgroups of prime power size ## InstallMethod(Zuppos,"group",true,[IsGroup],0, function (G) local zuppos, # set of zuppos,result c, # a representative of a class of elements o, # its order N, # normalizer of < c > t; # loop variable # compute the zuppos zuppos:=[One(G)]; for c in List(ConjugacyClasses(G),Representative) do o:=Order(c); if IsPrimePowerInt(o) then if ForAll([2..o],i -> Gcd(o,i) <> 1 or not c^i in zuppos) then N:=Normalizer(G,Subgroup(G,[c])); for t in RightTransversal(G,N) do Add(zuppos,c^t); od; fi; fi; od; # return the set of zuppos Sort(zuppos); return zuppos; end); ############################################################################# ## #F Zuppos() . set of generators for cyclic subgroups of prime power size ## InstallOtherMethod(Zuppos,"group with condition",true,[IsGroup,IsFunction],0, function (G,func) local zuppos, # set of zuppos,result c, # a representative of a class of elements o, # its order N, # normalizer of < c > t; # loop variable # compute the zuppos zuppos:=[One(G)]; for c in List(ConjugacyClasses(G),Representative) do o:=Order(c); if func(Group(c)) and IsPrimePowerInt(o) then if ForAll([2..o],i -> Gcd(o,i) <> 1 or not c^i in zuppos) then N:=Normalizer(G,Subgroup(G,[c])); for t in RightTransversal(G,N) do Add(zuppos,c^t); od; fi; fi; od; # return the set of zuppos Sort(zuppos); return zuppos; end); ############################################################################# ## #M ConjugacyClassSubgroups(,) . . . . . . . . . . . . constructor ## InstallMethod(ConjugacyClassSubgroups,IsIdenticalObj,[IsGroup,IsGroup],0, function(G,U) local filter,cl; if CanComputeSizeAnySubgroup(G) then filter:=IsConjugacyClassSubgroupsByStabilizerRep; else filter:=IsConjugacyClassSubgroupsRep; fi; cl:=Objectify(NewType(CollectionsFamily(FamilyObj(G)), filter),rec()); SetActingDomain(cl,G); SetRepresentative(cl,U); SetFunctionAction(cl,OnPoints); return cl; end); ############################################################################# ## #M \^( , ) . . . . . . . . . conjugacy class of a subgroup of a group ## InstallOtherMethod( \^, "conjugacy class of a subgroup of a group", IsIdenticalObj, [ IsGroup, IsGroup ], 0, function ( H, G ) if IsSubgroup(G,H) then return ConjugacyClassSubgroups(G,H); else TryNextMethod(); fi; end ); ############################################################################# ## #M = . . . . . . . . . . . . . . . . . . by conjugacy test ## InstallMethod( \=, IsIdenticalObj, [ IsConjugacyClassSubgroupsRep, IsConjugacyClassSubgroupsRep ], 0, function( clasa, clasb ) if not IsIdenticalObj(ActingDomain(clasa),ActingDomain(clasb)) then TryNextMethod(); fi; return RepresentativeAction(ActingDomain(clasa),Representative(clasa), Representative(clasb))<>fail; end); ############################################################################# ## #M in . . . . . . . . . . . . . . . . . . by conjugacy test ## InstallMethod( \in, IsElmsColls, [ IsGroup,IsConjugacyClassSubgroupsRep], 0, function( G, clas ) return RepresentativeAction(ActingDomain(clas),Representative(clas),G) <>fail; end); ############################################################################# ## #M AsList() ## InstallOtherMethod(AsList, "for classes of subgroups", true, [ IsConjugacyClassSubgroupsRep],0, function(c) local rep; rep:=Representative(c); if not IsBound(c!.normalizerTransversal) then c!.normalizerTransversal:= RightTransversal(ActingDomain(c),StabilizerOfExternalSet(c)); fi; if HasParent(rep) and IsSubset(Parent(rep),ActingDomain(c)) then return List(c!.normalizerTransversal,i->ConjugateSubgroup(rep,i)); else return List(c!.normalizerTransversal,i->ConjugateGroup(rep,i)); fi; end); ############################################################################# ## #M ClassElementLattice ## InstallMethod(ClassElementLattice, "for classes of subgroups", true, [ IsConjugacyClassSubgroupsRep, IsPosInt],0, function(c,nr) local rep; rep:=Representative(c); if not IsBound(c!.normalizerTransversal) then c!.normalizerTransversal:= RightTransversal(ActingDomain(c),StabilizerOfExternalSet(c)); fi; return ConjugateSubgroup(rep,c!.normalizerTransversal[nr]); end); InstallOtherMethod( \[\], "for classes of subgroups", true, [ IsConjugacyClassSubgroupsRep, IsPosInt],0,ClassElementLattice ); InstallMethod( StabilizerOfExternalSet, true, [ IsConjugacyClassSubgroupsRep ], # override potential pc method 10, function(xset) return Normalizer(ActingDomain(xset),Representative(xset)); end); InstallOtherMethod( NormalizerOp, true, [ IsConjugacyClassSubgroupsRep ], 0, StabilizerOfExternalSet ); ############################################################################# ## #M PrintObj() . . . . . . . . . . . . . . . . . . . . print function ## InstallMethod(PrintObj,true,[IsConjugacyClassSubgroupsRep],0, function(cl) Print("ConjugacyClassSubgroups(",ActingDomain(cl),",", Representative(cl),")"); end); ############################################################################# ## #M ConjugacyClassesSubgroups() . classes of subgroups of a group ## InstallMethod(ConjugacyClassesSubgroups,"group",true,[IsGroup],0, function(G) return ConjugacyClassesSubgroups(LatticeSubgroups(G)); end); InstallOtherMethod(ConjugacyClassesSubgroups,"lattice",true, [IsLatticeSubgroupsRep],0, function(L) return L!.conjugacyClassesSubgroups; end); BindGlobal("LatticeFromClasses",function(G,classes) local lattice; # sort the classes Sort(classes, function (c,d) return Size(Representative(c)) < Size(Representative(d)) or (Size(Representative(c)) = Size(Representative(d)) and Size(c) < Size(d)); end); # create the lattice lattice:=Objectify(NewType(FamilyObj(classes),IsLatticeSubgroupsRep), rec(conjugacyClassesSubgroups:=classes, group:=G)); # return the lattice return lattice; end ); ############################################################################# ## #F LatticeByCyclicExtension([,[,]]) Lattice of subgroups ## ## computes the lattice of using the cyclic extension algorithm. If the ## function is given, the algorithm will discard all subgroups not ## fulfilling (and will also not extend them), returning a partial ## lattice. If is a list of length 2, the first entry is such a ## function, the second a function for selecting zuppos. ## This can be useful to compute only subgroups with certain ## properties. Note however that this will *not* necessarily yield all ## subgroups that fulfill , but the subgroups whose subgroups used ## for the construction also fulfill as well. ## # the following functions are declared only later SOLVABILITY_IMPLYING_FUNCTIONS:= [IsSolvableGroup,IsNilpotentGroup,IsPGroup,IsCyclic]; InstallGlobalFunction( LatticeByCyclicExtension, function(arg) local G, # group func, # test function zuppofunc, # test fct for zuppos noperf, # discard perfect groups lattice, # lattice (result) factors, # factorization of 's size zuppos, # generators of prime power order zupposPrime, # corresponding prime zupposPower, # index of power of generator ZupposSubgroup, # function to compute zuppos for subgroup zuperms, # permutation of zuppos by group Gimg, # grp image under zuperms nrClasses, # number of classes classes, # list of all classes classesZups, # zuppos blist of classes classesExts, # extend-by blist of classes perfect, # classes of perfect subgroups of perfectNew, # this class of perfect subgroups is new perfectZups, # zuppos blist of perfect subgroups layerb, # begin of previous layer layere, # end of previous layer H, # representative of a class Hzups, # zuppos blist of Hexts, # extend blist of C, # class of I, # new subgroup found Ielms, # elements of Izups, # zuppos blist of N, # normalizer of Nzups, # zuppos blist of Jzups, # zuppos of a conjugate of Kzups, # zuppos of a representative in reps, # transversal of in ac, transv, factored, mapped, expandmem, h,i,k,l,ri,rl,r; # loop variables G:=arg[1]; noperf:=false; zuppofunc:=false; if Length(arg)>1 and IsFunction(arg[2]) then func:=arg[2]; Info(InfoLattice,1,"lattice discarding function active!"); if IsList(func) then zuppofunc:=func[2]; func:=func[1]; fi; if Length(arg)>2 and IsBool(arg[3]) then noperf:=arg[3]; fi; else func:=false; fi; expandmem:=ValueOption("Expand")=true; # if store is true, an element list will be kept in `Ielms' if possible ZupposSubgroup:=function(U,store) local elms,zups; if Size(U)=Size(G) then if store then Ielms:=fail;fi; zups:=BlistList([1..Length(zuppos)],[1..Length(zuppos)]); elif Size(U)>10^4 then # the group is very big - test the zuppos with `in' Info(InfoLattice,3,"testing zuppos with `in'"); if store then Ielms:=fail;fi; zups:=List(zuppos,i->i in U); IsBlist(zups); else elms:=AsSSortedListNonstored(U); if store then Ielms:=elms;fi; zups:=BlistList(zuppos,elms); fi; return zups; end; # compute the factorized size of factors:=Factors(Size(G)); # compute a system of generators for the cyclic sgr. of prime power size if zuppofunc<>false then zuppos:=Zuppos(G,zuppofunc); else zuppos:=Zuppos(G); fi; Info(InfoLattice,1," has ",Length(zuppos)," zuppos"); # compute zuppo permutation if IsPermGroup(G) then zuppos:=List(zuppos,SmallestGeneratorPerm); zuppos:=AsSSortedList(zuppos); zuperms:=List(GeneratorsOfGroup(G), i->Permutation(i,zuppos,function(x,a) return SmallestGeneratorPerm(x^a); end)); if NrMovedPoints(zuperms)<200*NrMovedPoints(G) then zuperms:=GroupHomomorphismByImagesNC(G,Group(zuperms), GeneratorsOfGroup(G),zuperms); # force kernel, also enforces injective setting Gimg:=Image(zuperms); if Size(KernelOfMultiplicativeGeneralMapping(zuperms))=1 then SetSize(Gimg,Size(G)); fi; else zuperms:=fail; fi; else zuppos:=AsSSortedList(zuppos); zuperms:=fail; fi; # compute the prime corresponding to each zuppo and the index of power zupposPrime:=[]; zupposPower:=[]; for r in zuppos do i:=SmallestRootInt(Order(r)); Add(zupposPrime,i); k:=0; while k <> false do k:=k + 1; if GcdInt(i,k) = 1 then l:=Position(zuppos,r^(i*k)); if l <> fail then Add(zupposPower,l); k:=false; fi; fi; od; od; Info(InfoLattice,1,"powers computed"); if func<>false and (noperf or func in SOLVABILITY_IMPLYING_FUNCTIONS) then Info(InfoLattice,1,"Ignoring perfect subgroups"); perfect:=[]; else if IsPermGroup(G) then # trigger potentially better methods IsNaturalSymmetricGroup(G); IsNaturalAlternatingGroup(G); fi; perfect:=RepresentativesPerfectSubgroups(G); perfect:=Filtered(perfect,i->Size(i)>1 and Size(i)false then perfect:=Filtered(perfect,func); fi; perfect:=List(perfect,i->AsSubgroup(Parent(G),i)); fi; perfectZups:=[]; perfectNew :=[]; for i in [1..Length(perfect)] do I:=perfect[i]; #perfectZups[i]:=BlistList(zuppos,AsSSortedListNonstored(I)); perfectZups[i]:=ZupposSubgroup(I,false); perfectNew[i]:=true; od; Info(InfoLattice,1," has ",Length(perfect), " representatives of perfect subgroups"); # initialize the classes list nrClasses:=1; classes:=ConjugacyClassSubgroups(G,TrivialSubgroup(G)); SetSize(classes,1); classes:=[classes]; classesZups:=[BlistList(zuppos,[One(G)])]; classesExts:=[DifferenceBlist(BlistList(zuppos,zuppos),classesZups[1])]; layerb:=1; layere:=1; # loop over the layers of group (except the group itself) for l in [1..Length(factors)-1] do Info(InfoLattice,1,"doing layer ",l,",", "previous layer has ",layere-layerb+1," classes"); # extend representatives of the classes of the previous layer for h in [layerb..layere] do # get the representative,its zuppos blist and extend-by blist H:=Representative(classes[h]); Hzups:=classesZups[h]; Hexts:=classesExts[h]; Info(InfoLattice,2,"extending subgroup ",h,", size = ",Size(H)); # loop over the zuppos whose

-th power lies in for i in [1..Length(zuppos)] do if Hexts[i] and Hzups[zupposPower[i]] then # make the new subgroup # NC is safe -- all groups are subgroups of Parent(H) I:=ClosureSubgroupNC(H,zuppos[i]); #Subgroup(Parent(G),Concatenation(GeneratorsOfGroup(H), # [zuppos[i]])); if func=false or func(I) then SetSize(I,Size(H) * zupposPrime[i]); # compute the zuppos blist of #Ielms:=AsSSortedListNonstored(I); #Izups:=BlistList(zuppos,Ielms); if zuperms=fail then Izups:=ZupposSubgroup(I,true); else Izups:=ZupposSubgroup(I,false); fi; # compute the normalizer of N:=Normalizer(G,I); #AH 'NormalizerInParent' attribute ? Info(InfoLattice,2,"found new class ",nrClasses+1, ", size = ",Size(I)," length = ",Size(G)/Size(N)); # make the new conjugacy class C:=ConjugacyClassSubgroups(G,I); SetSize(C,Size(G) / Size(N)); SetStabilizerOfExternalSet(C,N); nrClasses:=nrClasses + 1; classes[nrClasses]:=C; # store the extend by list if l < Length(factors)-1 then classesZups[nrClasses]:=Izups; #Nzups:=BlistList(zuppos,AsSSortedListNonstored(N)); Nzups:=ZupposSubgroup(N,false); SubtractBlist(Nzups,Izups); classesExts[nrClasses]:=Nzups; fi; # compute the right transversal # (but don't store it in the parent) if expandmem and zuperms<>fail then if Index(G,N)>400 then ac:=AscendingChainOp(G,N); # do not store while Length(ac)>2 and Index(ac[3],ac[1])<100 do ac:=Concatenation([ac[1]],ac{[3..Length(ac)]}); od; if Length(ac)>2 and Maximum(List([3..Length(ac)],x->Index(ac[x],ac[x-1])))<500 then # mapped factorized transversal Info(InfoLattice,3,"factorized transversal ", List([2..Length(ac)],x->Index(ac[x],ac[x-1]))); transv:=[]; ac[Length(ac)]:=Gimg; for ri in [Length(ac)-1,Length(ac)-2..1] do ac[ri]:=Image(zuperms,ac[ri]); if ri=1 then transv[ri]:=List(RightTransversalOp(ac[ri+1],ac[ri]), i->Permuted(Izups,i)); else transv[ri]:=AsList(RightTransversalOp(ac[ri+1],ac[ri])); fi; od; mapped:=true; factored:=true; reps:=Cartesian(transv); Unbind(ac); Unbind(transv); else reps:=RightTransversalOp(Gimg,Image(zuperms,N)); mapped:=true; factored:=false; fi; else reps:=RightTransversalOp(G,N); mapped:=false; factored:=false; fi; else reps:=RightTransversalOp(G,N); mapped:=false; factored:=false; fi; # loop over the conjugates of for ri in [1..Length(reps)] do CompletionBar(InfoLattice,3,"Coset loop: ",ri/Length(reps)); r:=reps[ri]; # compute the zuppos blist of the conjugate if zuperms<>fail then # we know the permutation of zuppos by the group if mapped then if factored then Jzups:=r[1]; for rl in [2..Length(r)] do Jzups:=Permuted(Jzups,r[rl]); od; else Jzups:=Permuted(Izups,r); fi; else if factored then Error("factored"); else Jzups:=Image(zuperms,r); Jzups:=Permuted(Izups,Jzups); fi; fi; elif r = One(G) then Jzups:=Izups; elif Ielms<>fail then Jzups:=BlistList(zuppos,OnTuples(Ielms,r)); else Jzups:=ZupposSubgroup(I^r,false); fi; # loop over the already found classes for k in [h..layere] do Kzups:=classesZups[k]; # test if the is a subgroup of if IsSubsetBlist(Jzups,Kzups) then # don't extend by the elements of SubtractBlist(classesExts[k],Jzups); fi; od; od; CompletionBar(InfoLattice,3,"Coset loop: ",false); # now we are done with the new class Unbind(Ielms); Unbind(reps); Info(InfoLattice,2,"tested inclusions"); else Info(InfoLattice,1,"discarded!"); fi; # if condition fulfilled fi; # if Hexts[i] and Hzups[zupposPower[i]] then ... od; # for i in [1..Length(zuppos)] do ... # remove the stuff we don't need any more Unbind(classesZups[h]); Unbind(classesExts[h]); od; # for h in [layerb..layere] do ... # add the classes of perfect subgroups for i in [1..Length(perfect)] do if perfectNew[i] and IsPerfectGroup(perfect[i]) and Length(Factors(Size(perfect[i]))) = l then # make the new subgroup I:=perfect[i]; # compute the zuppos blist of #Ielms:=AsSSortedListNonstored(I); #Izups:=BlistList(zuppos,Ielms); if zuperms=fail then Izups:=ZupposSubgroup(I,true); else Izups:=ZupposSubgroup(I,false); fi; # compute the normalizer of N:=Normalizer(G,I); # AH: NormalizerInParent ? Info(InfoLattice,2,"found perfect class ",nrClasses+1, " size = ",Size(I),", length = ",Size(G)/Size(N)); # make the new conjugacy class C:=ConjugacyClassSubgroups(G,I); SetSize(C,Size(G)/Size(N)); SetStabilizerOfExternalSet(C,N); nrClasses:=nrClasses + 1; classes[nrClasses]:=C; # store the extend by list if l < Length(factors)-1 then classesZups[nrClasses]:=Izups; #Nzups:=BlistList(zuppos,AsSSortedListNonstored(N)); Nzups:=ZupposSubgroup(N,false); SubtractBlist(Nzups,Izups); classesExts[nrClasses]:=Nzups; fi; # compute the right transversal # (but don't store it in the parent) reps:=RightTransversalOp(G,N); # loop over the conjugates of for r in reps do # compute the zuppos blist of the conjugate if zuperms<>fail then # we know the permutation of zuppos by the group Jzups:=Image(zuperms,r); Jzups:=Permuted(Izups,Jzups); elif r = One(G) then Jzups:=Izups; elif Ielms<>fail then Jzups:=BlistList(zuppos,OnTuples(Ielms,r)); else Jzups:=ZupposSubgroup(I^r,false); fi; # loop over the perfect classes for k in [i+1..Length(perfect)] do Kzups:=perfectZups[k]; # throw away classes that appear twice in perfect if Jzups = Kzups then perfectNew[k]:=false; perfectZups[k]:=[]; fi; od; od; # now we are done with the new class Unbind(Ielms); Unbind(reps); Info(InfoLattice,2,"tested equalities"); # unbind the stuff we dont need any more perfectZups[i]:=[]; fi; # if IsPerfectGroup(I) and Length(Factors(Size(I))) = layer the... od; # for i in [1..Length(perfect)] do # on to the next layer layerb:=layere+1; layere:=nrClasses; od; # for l in [1..Length(factors)-1] do ... # add the whole group to the list of classes Info(InfoLattice,1,"doing layer ",Length(factors),",", " previous layer has ",layere-layerb+1," classes"); if Size(G)>1 and (func=false or func(G)) then Info(InfoLattice,2,"found whole group, size = ",Size(G),",","length = 1"); C:=ConjugacyClassSubgroups(G,G); SetSize(C,1); nrClasses:=nrClasses + 1; classes[nrClasses]:=C; fi; # return the list of classes Info(InfoLattice,1," has ",nrClasses," classes,", " and ",Sum(classes,Size)," subgroups"); lattice:=LatticeFromClasses(G,classes); if func<>false then lattice!.func:=func; fi; return lattice; end); BindGlobal("VectorspaceComplementOrbitsLattice",function(n,a,c,ker) local s, m, dim, p, field, one, bas, I, l, avoid, li, gens, act, actfun, rep, max, baselist, ve, new, lb, newbase, e, orb, stb, tr, di, cont, j, img, idx, stabilizer, i, base, d, gn; m:=ModuloPcgs(a,ker); dim:=Length(m); p:=RelativeOrders(m)[1]; field:=GF(p); one:=One(field); bas:=List(GeneratorsOfGroup(c),i->ExponentsOfPcElement(m,i)*one); TriangulizeMat(bas); bas:=Filtered(bas,i->not IsZero(i)); I := IdentityMat(dim, field); l:=BaseSteinitzVectors(I,bas); avoid:=Length(l.subspace); l:=Concatenation(l.factorspace,l.subspace); l:=ImmutableMatrix(field,l); li:=l^-1; gens:=GeneratorsOfGroup(n); act:=LinearActionLayer(n,m); act:=List(act,i->l*i*li); if p=2 then actfun:=OnSubspacesByCanonicalBasisGF2; else actfun:=OnSubspacesByCanonicalBasis; fi; rep:=[]; max:=dim-avoid; baselist := [[]]; ve:=AsList(field); for i in [1..dim] do Info(InfoLattice,5,"starting dim :",i," bases found :",Length(baselist)); new := []; for base in baselist do #subspaces of equal dimension lb:=Length(base); for d in [0..p^lb-1] do if d=0 then # special case for subspace of higher dimension if Length(base) < max and i<=max then newbase:=Concatenation(List(base,ShallowCopy), [I[i]]); else newbase:=[]; fi; else # possible extension number d newbase := List(base,ShallowCopy); e:=d; for j in [1..lb] do newbase[j][i]:=ve[(e mod p)+1]; e:=QuoInt(e,p); od; #for j in [1..Length(vec)] do # newbase[j][i] := vec[j]; #od; fi; if i0 then # we will need the space for the next level Add(new, newbase); fi; if Length(newbase)=max then # compute orbit orb:=[newbase]; stb:=a; tr:=[One(a)]; di:=NewDictionary(newbase,true, # fake entry to simulate a ``grassmannian'' object 1); AddDictionary(di,newbase,1); cont:=true; j:=1; while cont and j<=Length(orb) do for gn in [1..Length(gens)] do img:=actfun(orb[j],act[gn]); idx:=LookupDictionary(di,img); if idx=fail then if imgfail then return LatticeByCyclicExtension(G,[u->IsSubset(H,u),u->IsSubset(H,u)]); elif select<>fail then return LatticeByCyclicExtension(G,select); else return LatticeByCyclicExtension(G); fi; else hom:=NaturalHomomorphismByNormalSubgroupNC(G,ser[1]); f:=Image(hom,G); fselect:=fail; if H<>fail then HN:=Image(hom,H); c:=LatticeByCyclicExtension(f, [u->IsSubset(HN,u),u->IsSubset(HN,u)])!.conjugacyClassesSubgroups; elif select<>fail and (select=IsPerfectGroup or select=IsSimpleGroup) then c:=ConjugacyClassesPerfectSubgroups(f); c:=Filtered(c,x->Size(Representative(x))>1); fselect:=U->not IsSolvableGroup(U); elif select<>fail then c:=LatticeByCyclicExtension(f,select)!.conjugacyClassesSubgroups; else c:=LatticeByCyclicExtension(f)!.conjugacyClassesSubgroups; fi; if select<>fail then nu:=Filtered(c,i->select(Representative(i))); Info(InfoLattice,1,"Selection reduced ",Length(c)," to ",Length(nu)); c:=nu; fi; nu:=[]; nn:=[]; nf:=[]; for i in c do a:=Representative(i); k:=PreImage(hom,a); Add(nu,k); Add(nn,PreImage(hom,Stabilizer(i))); Add(nf,RestrictedMapping(hom,k)*IsomorphismFpGroup(a)); od; u:=[nu,nn,nf]; fi; for i in [2..Length(ser)] do Info(InfoLattice,1,"Step ",i," : ",Index(ser[i-1],ser[i])); #ohom:=hom; #hom:=NaturalHomomorphismByNormalSubgroupNC(G,ser[i]); if H<>fail then HN:=ClosureGroup(H,ser[i]); HNI:=Intersection(ClosureGroup(H,ser[i]),ser[i-1]); # if pcgs=false then mpcgs:=ModuloPcgs(HNI,ser[i]); # else # mpcgs:=pcgs[i-1] mod pcgs[i]; # fi; presmpcgs:=ModuloPcgs(ser[i-1],ser[i]); else if pcgs=false then mpcgs:=ModuloPcgs(ser[i-1],ser[i]); else mpcgs:=pcgs[i-1] mod pcgs[i]; fi; presmpcgs:=mpcgs; fi; if Length(mpcgs)>0 then gf:=GF(RelativeOrders(mpcgs)[1]); if select=IsPerfectGroup then # the only normal subgroups are those that are normal under any # subgroup so far. # minimal of the subgroups so far nu:=Filtered(u[1],x->not ForAny(u[1],y->Size(y)IsSubset(ser[i-1],y) and IsSubset(y,ser[i])) do if not k in nts then Add(nts,k);fi; od; od; # by setting up `act' as fail, we force a different selection later act:=[nts,fail]; elif select=IsSimpleGroup then # simple -> no extensions, only the trivial subgroup is valid. act:=[[ser[i]],GroupHomomorphismByImagesNC(G,Group(()), GeneratorsOfGroup(G), List(GeneratorsOfGroup(G),i->()))]; else act:=ActionSubspacesElementaryAbelianGroup(G,mpcgs); fi; else gf:=GF(Factors(Index(ser[i-1],ser[i]))[1]); act:=[[ser[i]],GroupHomomorphismByImagesNC(G,Group(()), GeneratorsOfGroup(G), List(GeneratorsOfGroup(G),i->()))]; fi; nts:=act[1]; act:=act[2]; nu:=[]; nn:=[]; nf:=[]; # Determine which ones we need and keep old ones orbs:=[]; for j in [1..Length(u[1])] do a:=u[1][j]; #if ForAny(GeneratorsOfGroup(a),i->SIZE_OBJ(i)>maxsz) then Error("1");fi; n:=u[2][j]; #if ForAny(GeneratorsOfGroup(n),i->SIZE_OBJ(i)>maxsz) then Error("2");fi; # find indices of subgroups normal under a and form orbits under the # normalizer if act<>fail then ns:=Difference([1..Length(nts)],MovedPoints(Image(act,a))); nim:=Image(act,n); ns:=Orbits(nim,ns); else nim:=Filtered([1..Length(nts)],x->IsNormal(a,nts[x])); ns:=[]; for k in [1..Length(nim)] do if not ForAny(ns,x->nim[k] in x) then p:=Orbit(n,nts[k]); p:=List(p,x->Position(nts,x)); p:=Filtered(p,x->x<>fail and x in nim); Add(ns,p); fi; od; fi; if Size(a)>Size(ser[i-1]) then # keep old groups if H=fail or IsSubset(HN,a) then Add(nu,a);Add(nn,n); if Size(ser[i])>1 then fphom:=LiftFactorFpHom(u[3][j],a,ser[i-1],ser[i],presmpcgs); Add(nf,fphom); fi; fi; orbs[j]:=ns; else # here a is the trivial subgroup in the factor. (This will never # happen if we look for perfect or simple groups!) orbs[j]:=[]; # previous kernel -- there the orbits are classes of subgroups in G for k in ns do Add(nu,nts[k[1]]); Add(nn,PreImage(act,Stabilizer(nim,k[1]))); if Size(ser[i])>1 then fphom:=IsomorphismFpGroupByChiefSeriesFactor(nts[k[1]],"x",ser[i]); Add(nf,fphom); fi; od; fi; od; # run through nontrivial subspaces (greedy test whether they are needed) for j in [1..Length(nts)] do if Size(nts[j])j in z); if p<>fail then # remove orbit orbs[k]:=orbs[k]{Difference([1..Length(orbs[k])],[p])}; Add(as,k); fi; od; if Length(as)>0 then Info(InfoLattice,2,"Normal subgroup ",j,", ",Length(as), " subgroups to consider"); # there are subgroups that will complement with this kernel. # Construct the modulo pcgs and the action of the largest subgroup # (which must be the normalizer) isn:=fail; isns:=1; for k in as do if Size(u[1][k])>isns then isns:=Size(u[1][k]); isn:=k; fi; od; if pcgs=false then lmpc:=ModuloPcgs(ser[i-1],nts[j]); npcgs:=ModuloPcgs(nts[j],ser[i]); else if IsTrivial(nts[j]) then lmpc:=pcgs[i-1]; npcgs:="not used"; else c:=InducedPcgs(pcgs[i-1],nts[j]); lmpc:=pcgs[i-1] mod c; npcgs:=c mod pcgs[i]; fi; fi; for k in as do a:=u[1][k]; if IsNormal(u[2][k],nts[j]) then n:=u[2][k]; else n:=Normalizer(u[2][k],nts[j]); #if ForAny(GeneratorsOfGroup(n),i->SIZE_OBJ(i)>maxsz) then Error("2a");fi; fi; if Length(GeneratorsOfGroup(n))>3 then w:=Size(n); n:=Group(SmallGeneratingSet(n)); SetSize(n,w); fi; ocr:=rec(group:=a, modulePcgs:=lmpc); #fphom:=RestrictedMapping(ohom,a)*IsomorphismFpGroup(Image(ohom,a)); #ocr.factorfphom:=fphom; ocr.factorfphom:=u[3][k]; OCOneCocycles(ocr,true); if IsBound(ocr.complement) then #if ForAny(ocr.complementGens,i->SIZE_OBJ(i)>maxsz) then Error("3");fi; v:=BaseSteinitzVectors( BasisVectors(Basis(ocr.oneCocycles)), BasisVectors(Basis(ocr.oneCoboundaries))); v:=VectorSpace(gf,v.factorspace,Zero(ocr.oneCocycles)); com:=[]; cgs:=[]; first:=false; if Size(v)>100 and Size(ser[i])=1 and HasElementaryAbelianFactorGroup(a,nts[j]) then com:=VectorspaceComplementOrbitsLattice(n,a,ser[i-1],nts[j]); Info(InfoLattice,4,"Subgroup ",Position(as,k),"/",Length(as), ", ",Size(v)," local complements, ",Length(com)," orbits"); for c in com do if H=fail or IsSubset(HN,c.representative) then Add(nu,c.representative); Add(nn,c.normalizer); fi; od; else for w in Enumerator(v) do cg:=ocr.cocycleToList(w); #if ForAny(cg,i->SIZE_OBJ(i)>maxsz) then Error("3");fi; for ii in [1..Length(cg)] do cg[ii]:=ocr.complementGens[ii]*cg[ii]; od; if first then # this is clearly kept -- so calculate a stabchain c:=ClosureSubgroup(nts[j],cg); first:=false; else c:=SubgroupNC(G,Concatenation(SmallGeneratingSet(nts[j]),cg)); fi; Assert(1,Size(c)=Index(a,ser[i-1])*Size(nts[j])); if H=fail or IsSubset(HN,c) then SetSize(c,Index(a,ser[i-1])*Size(nts[j])); Add(cgs,cg); #c!.comgens:=cg; Add(com,c); fi; od; w:=Length(com); com:=SubgroupsOrbitsAndNormalizers(n,com,false:savemem:=true); Info(InfoLattice,3,"Subgroup ",Position(as,k),"/",Length(as), ", ",w," local complements, ",Length(com)," orbits"); for w in com do c:=w.representative; if fselect=fail or fselect(c) then Add(nu,c); Add(nn,w.normalizer); if Size(ser[i])>1 then # need to lift presentation fphom:=ComplementFactorFpHom(ocr.factorfphom, a,ser[i-1],nts[j],c, ocr.generators,cgs[w.pos]); Assert(1,KernelOfMultiplicativeGeneralMapping(fphom)=nts[j]); if Size(nts[j])>Size(ser[i]) then fphom:=LiftFactorFpHom(fphom,c,nts[j],ser[i],npcgs); Assert(1, KernelOfMultiplicativeGeneralMapping(fphom)=ser[i]); fi; Add(nf,fphom); fi; fi; od; fi; ocr:=false; cgs:=false; com:=false; fi; od; fi; fi; od; u:=[nu,nn,nf]; od; nn:=[]; for i in [1..Length(u[1])] do a:=ConjugacyClassSubgroups(G,u[1][i]); n:=u[2][i]; SetSize(a,Size(G)/Size(n)); SetStabilizerOfExternalSet(a,n); Add(nn,a); od; # some `select'ions remove the trivial subgroup if select<>fail and not ForAny(u[1],x->Size(x)=1) and select(TrivialSubgroup(G)) then Add(nn,ConjugacyClassSubgroups(G,TrivialSubgroup(G))); fi; return LatticeFromClasses(G,nn); end); ############################################################################# ## #M LatticeSubgroups() . . . . . . . . . . lattice of subgroups ## InstallMethod(LatticeSubgroups,"via radical",true,[IsGroup],0, LatticeViaRadical); ############################################################################# ## #M Print for lattice ## InstallMethod(ViewObj,"lattice",true,[IsLatticeSubgroupsRep],0, function(l) Print(""); end); InstallMethod(PrintObj,"lattice",true,[IsLatticeSubgroupsRep],0, function(l) Print("LatticeSubgroups(",l!.group); if IsBound(l!.func) then Print("),# under further condition l!.func\n"); else Print(")"); fi; end); ############################################################################# ## #M ConjugacyClassesPerfectSubgroups ## InstallMethod(ConjugacyClassesPerfectSubgroups,"generic",true,[IsGroup],0, function(G) return List(RepresentativesPerfectSubgroups(G),i->ConjugacyClassSubgroups(G,i)); end); ############################################################################# ## #M PerfectResiduum ## InstallMethod(PerfectResiduum,"for groups",true, [IsGroup],0, function(G) G := DerivedSeriesOfGroup(G); G := G[Length(G)]; SetIsPerfectGroup(G, true); return G; end); InstallMethod(PerfectResiduum,"for perfect groups",true, [IsPerfectGroup],0, function(G) return G; end); InstallMethod(PerfectResiduum,"for solvable groups",true, [IsSolvableGroup],0, function(G) return TrivialSubgroup(G); end); ############################################################################# ## #M RepresentativesPerfectSubgroups solvable ## InstallMethod(RepresentativesPerfectSubgroups,"solvable",true, [IsSolvableGroup],0, function(G) return [TrivialSubgroup(G)]; end); ############################################################################# ## #M RepresentativesPerfectSubgroups ## BindGlobal("RepsPerfSimpSub",function(G,simple) local badsizes,n,un,cl,r,i,l,u,bw,cnt,gens,go,imgs,bg,bi,emb,nu,k,j, D,params,might,bo; if IsSolvableGroup(G) then return [TrivialSubgroup(G)]; elif Size(RadicalGroup(G))>1 then D:=LatticeViaRadical(G,IsPerfectGroup); D:=List(D!.conjugacyClassesSubgroups,Representative); if simple then D:=Filtered(D,IsSimpleGroup); else D:=Filtered(D,IsPerfectGroup); fi; return D; else PerfGrpLoad(0); badsizes := Union(PERFRec.notAvailable,PERFRec.notKnown); D:=G; D:=PerfectResiduum(D); n:=Size(D); Info(InfoLattice,1,"The perfect residuum has size ",n); # sizes of possible perfect subgroups un:=Filtered(DivisorsInt(n),i->i>1 # index <=4 would lead to solvable factor and ii<=k); fi; Info(InfoLattice,1,"Searching perfect groups up to size ",Maximum(un)); if ForAny(un,i->i>10^6) then Error("the perfect residuum is too large"); fi; un:=Filtered(un,i->i in PERFRec.sizes); if Length(Intersection(badsizes,un))>0 then Error( "failed due to incomplete information in the Holt/Plesken library"); fi; cl:=Filtered(ConjugacyClasses(G),i->Representative(i) in D); Info(InfoLattice,2,Length(cl)," classes of ", Length(ConjugacyClasses(G))," to consider"); r:=[]; for i in un do l:=NumberPerfectGroups(i); if l>0 then for j in [1..l] do u:=PerfectGroup(IsPermGroup,i,j); Info(InfoLattice,1,"trying group ",i,",",j,": ",u); # test whether there is a chance to embed might:=simple=false or IsSimpleGroup(u); cnt:=0; while might and cnt<20 do bg:=Order(Random(u)); might:=ForAny(cl,i->Order(Representative(i))=bg); cnt:=cnt+1; od; if might then # find a suitable generating system bw:=infinity; bo:=[0,0]; cnt:=0; repeat if cnt=0 then # first the small gen syst. gens:=SmallGeneratingSet(u); else # then something random repeat if Length(gens)>2 and Random([1,2])=1 then # try to get down to 2 gens gens:=List([1,2],i->Random(u)); else gens:=List([1..Random([2..Length(SmallGeneratingSet(u))])], i->Random(u)); fi; # try to get small orders for k in [1..Length(gens)] do go:=Order(gens[k]); # try a p-element if Random([1..2*Length(gens)])=1 then gens[k]:=gens[k]^(go/(Random(Factors(go)))); fi; od; until Index(u,SubgroupNC(u,gens))=1; fi; go:=List(gens,Order); imgs:=List(go,i->Filtered(cl,j->Order(Representative(j))=i)); Info(InfoLattice,3,go,":",Product(imgs,i->Sum(i,Size))); if Product(imgs,i->Sum(i,Size))Sum(i,Size)); elif Set(go)=Set(bo) then # we hit the orders again -> sign that we can't be # completely off track cnt:=cnt+Int(bw/Size(G)*3); fi; cnt:=cnt+1; until bw/Size(G)*60 then Info(InfoLattice,2,"find ",bw," from ",cnt); # find all embeddings params:=rec(gens:=bg,from:=u); emb:=MorClassLoop(G,bi,params, # all injective homs = 1+2+8 11); #emb:=MorClassLoop(G,bi,rec(type:=2,what:=3,gens:=bg,from:=u, # elms:=false,size:=Size(u))); Info(InfoLattice,2,Length(emb)," embeddings"); nu:=[]; for k in emb do k:=Image(k,u); if not ForAny(nu,i->RepresentativeAction(G,i,k)<>fail) then Add(nu,k); k!.perfectType:=[i,j]; fi; od; Info(InfoLattice,1,Length(nu)," classes"); r:=Concatenation(r,nu); fi; else Info(InfoLattice,2,"cannot embed"); fi; od; fi; od; # add the two obvious ones Add(r,D); Add(r,TrivialSubgroup(G)); return r; fi; end); InstallMethod(RepresentativesPerfectSubgroups,"using Holt/Plesken library", true,[IsGroup],0,G->RepsPerfSimpSub(G,false)); InstallMethod(RepresentativesSimpleSubgroups,"using Holt/Plesken library", true,[IsGroup],0,G->RepsPerfSimpSub(G,true)); InstallMethod(RepresentativesSimpleSubgroups,"if perfect subs are known", true,[IsGroup and HasRepresentativesPerfectSubgroups],0, G->Filtered(RepresentativesPerfectSubgroups(G),IsSimpleGroup)); ############################################################################# ## #M MaximalSubgroupsLattice ## InstallMethod(MaximalSubgroupsLattice,"cyclic extension",true, [IsLatticeSubgroupsRep],0, function (L) local maximals, # maximals as pair , (result) maximalsConjs, # corresponding conjugator element inverses cnt, # count for information messages classes, # list of all classes I, # representative of a class Ielms, # elements of Izups, # zuppos blist of N, # normalizer of Jgens, # zuppos of a conjugate of Kgroup, # zuppos of a representative in reps, # transversal of in grp, # the group lcl, # length(lcasses); clsz, notinmax, maxsz, mkk, ppow, primes, notperm, dom, orbs, Iorbs,Jorbs, i,k,kk,r; # loop variables if IsBound(L!.func) then Error("cannot compute maximality inclusions for partial lattice"); fi; grp:=L!.group; # relevant prime powers primes:=Set(Factors(Size(grp))); ppow:=Collected(Factors(Size(grp))); ppow:=Union(List(ppow,i->List([1..i[2]],j->i[1]^j))); # compute the lattice,fetch the classes,and representatives classes:=L!.conjugacyClassesSubgroups; lcl:=Length(classes); clsz:=List(classes,i->Size(Representative(i))); if IsPermGroup(grp) then notperm:=false; dom:=[1..LargestMovedPoint(grp)]; orbs:=List(classes,i->Set(List(Orbits(Representative(i),dom),Set))); orbs:=List(orbs,i->List([1..Maximum(dom)],p->Length(First(i,j->p in j)))); else notperm:=true; fi; # compute a system of generators for the cyclic sgr. of prime power size # initialize the maximals list Info(InfoLattice,1,"computing maximal relationship"); maximals:=List(classes,c -> []); maximalsConjs:=List(classes,c -> []); maxsz:=[]; if IsSolvableGroup(grp) then # maxes of grp maxsz[lcl]:=Set(List(MaximalSubgroupClassReps(grp),Size)); else maxsz[lcl]:=fail; # don't know about group fi; # find the minimal supergroups of the whole group Info(InfoLattice,2,"testing class ",lcl,", size = ", Size(grp),", length = 1, included in 0 minimal subs"); # loop over all classes for i in [lcl-1,lcl-2..1] do # take the subgroup I:=Representative(classes[i]); if not notperm then Iorbs:=orbs[i]; fi; Info(InfoLattice,2," testing class ",i); if IsSolvableGroup(I) then maxsz[i]:=Set(List(MaximalSubgroupClassReps(I),Size)); else maxsz[i]:=fail; fi; # compute the normalizer of N:=StabilizerOfExternalSet(classes[i]); # compute the right transversal (but don't store it in the parent) reps:=RightTransversalOp(grp,N); # initialize the counter cnt:=0; # loop over the conjugates of for r in [1..Length(reps)] do # compute the generators of the conjugate if reps[r] = One(grp) then Jgens:=SmallGeneratingSet(I); if not notperm then Jorbs:=Iorbs; fi; else Jgens:=OnTuples(SmallGeneratingSet(I),reps[r]); if not notperm then Jorbs:=Permuted(Iorbs,reps[r]); fi; fi; # loop over all other (larger) classes for k in [i+1..lcl] do Kgroup:=Representative(classes[k]); kk:=clsz[k]/clsz[i]; if IsInt(kk) and kk>1 and # maximal sizes known? (maxsz[k]=fail or clsz[i] in maxsz[k]) and (notperm or ForAll(dom,x->Jorbs[x]<=orbs[k][x])) then # test if the is a minimal supergroup of if ForAll(Jgens,i->i in Kgroup) then # at this point we know all maximals of k of larger order notinmax:=true; kk:=1; while notinmax and kk<=Length(maximals[k]) do mkk:=maximals[k][kk]; if IsInt(clsz[mkk[1]]/clsz[i]) # could be in by order and ForAll(Jgens,i->i^maximalsConjs[k][kk] in Representative(classes[mkk[1]])) then notinmax:=false; fi; kk:=kk+1; od; if notinmax then Add(maximals[k],[i,r]); # rep of x-th class ^r is contained in k-th class rep, # so to remove nonmax inclusions we need to test whether # conjugate of putative max by r^-1 is rep of x-th # class. Add(maximalsConjs[k],reps[r]^-1); cnt:=cnt + 1; fi; fi; fi; od; od; Unbind(reps); # inform about the count Info(InfoLattice,2,"size = ",Size(I),", length = ", Size(grp) / Size(N),", included in ",cnt," minimal sups"); od; return maximals; end); ############################################################################# ## #M MinimalSupergroupsLattice ## InstallMethod(MinimalSupergroupsLattice,"cyclic extension",true, [IsLatticeSubgroupsRep],0, function (L) local minimals, # minimals as pair , (result) minimalsZups, # their zuppos blist cnt, # count for information messages zuppos, # generators of prime power order classes, # list of all classes classesZups, # zuppos blist of classes I, # representative of a class Ielms, # elements of Izups, # zuppos blist of N, # normalizer of Jzups, # zuppos of a conjugate of Kzups, # zuppos of a representative in reps, # transversal of in grp, # the group i,k,r; # loop variables if IsBound(L!.func) then Error("cannot compute maximality inclusions for partial lattice"); fi; grp:=L!.group; # compute the lattice,fetch the classes,zuppos,and representatives classes:=L!.conjugacyClassesSubgroups; classesZups:=[]; # compute a system of generators for the cyclic sgr. of prime power size zuppos:=Zuppos(grp); # initialize the minimals list Info(InfoLattice,1,"computing minimal relationship"); minimals:=List(classes,c -> []); minimalsZups:=List(classes,c -> []); # loop over all classes for i in [1..Length(classes)-1] do # take the subgroup I:=Representative(classes[i]); # compute the zuppos blist of Ielms:=AsSSortedListNonstored(I); Izups:=BlistList(zuppos,Ielms); classesZups[i]:=Izups; # compute the normalizer of N:=StabilizerOfExternalSet(classes[i]); # compute the right transversal (but don't store it in the parent) reps:=RightTransversalOp(grp,N); # initialize the counter cnt:=0; # loop over the conjugates of for r in [1..Length(reps)] do # compute the zuppos blist of the conjugate if reps[r] = One(grp) then Jzups:=Izups; else Jzups:=BlistList(zuppos,OnTuples(Ielms,reps[r])); fi; # loop over all other (smaller classes) for k in [1..i-1] do Kzups:=classesZups[k]; # test if the is a maximal subgroup of if IsSubsetBlist(Jzups,Kzups) and ForAll(minimalsZups[k], zups -> not IsSubsetBlist(Jzups,zups)) then Add(minimals[k],[ i,r ]); Add(minimalsZups[k],Jzups); cnt:=cnt + 1; fi; od; od; # inform about the count Unbind(Ielms); Unbind(reps); Info(InfoLattice,2,"testing class ",i,", size = ",Size(I), ", length = ",Size(grp) / Size(N),", includes ",cnt, " maximal subs"); od; # find the maximal subgroups of the whole group cnt:=0; for k in [1..Length(classes)-1] do if minimals[k] = [] then Add(minimals[k],[ Length(classes),1 ]); cnt:=cnt + 1; fi; od; Info(InfoLattice,2,"testing class ",Length(classes),", size = ", Size(grp),", length = 1, includes ",cnt," maximal subs"); return minimals; end); ############################################################################# ## #F MaximalSubgroupClassReps() . . . . reps of conjugacy classes of #F maximal subgroups ## InstallMethod(MaximalSubgroupClassReps,"using lattice",true,[IsGroup],0, function (G) local maxs,lat; #AH special AG treatment if not HasIsSolvableGroup(G) and IsSolvableGroup(G) then return MaximalSubgroupClassReps(G); fi; # simply compute all conjugacy classes and take the maximals lat:=LatticeSubgroups(G); maxs:=MaximalSubgroupsLattice(lat)[Length(lat!.conjugacyClassesSubgroups)]; maxs:=List(lat!.conjugacyClassesSubgroups{ Set(maxs{[1..Length(maxs)]}[1])},Representative); return maxs; end); ############################################################################# ## #F ConjugacyClassesMaximalSubgroups() ## InstallMethod(ConjugacyClassesMaximalSubgroups, "use MaximalSubgroupClassReps",true,[IsGroup],0, function(G) return List(MaximalSubgroupClassReps(G),i->ConjugacyClassSubgroups(G,i)); end); ############################################################################# ## #F MaximalSubgroups() ## InstallMethod(MaximalSubgroups, "expand list",true,[IsGroup],0, function(G) return Concatenation(List(ConjugacyClassesMaximalSubgroups(G),AsList)); end); ############################################################################# ## #F NormalSubgroupsCalc([,]) normal subs for pc or perm groups ## NormalSubgroupsCalc := function (arg) local G, # group onlysimple, # determine only subgroups with simple composition factors nt,nnt, # normal subgroups cs, # comp. series M,N, # nt . in series mpcgs, # modulo pcgs p, # prime ocr, # 1-cohomology record l, # list vs, # vector space hom, # homomorphism jg, # generator images auts, # factor automorphisms comp, firsts, still, ab, T,S,C,A,ji,orb,orbi,cllen,r,o,c,inv,cnt, ii,i,j,k; # loop G:=arg[1]; onlysimple:=false; if Length(arg)>1 and arg[2]=true then onlysimple:=true; fi; if IsElementaryAbelian(G) then # we need to do this separately as the inductive process misses its # start if the chies series has only one step return InvariantSubgroupsElementaryAbelianGroup(G,[]); fi; cs:=ChiefSeries(G); G!.lattfpres:=IsomorphismFpGroupByChiefSeriesFactor(G,"x",G); nt:=[G]; for i in [2..Length(cs)] do still:=iSize(i)>Size(M)) do # test centrality if ForAll(GeneratorsOfGroup(j), i->ForAll(mpcgs,j->Comm(i,j) in N)) then Info(InfoLattice,2,"factorsize=",Index(j,N),"/",Index(M,N)); # reasons not to go complements if (HasAbelianFactorGroup(j,N) and p^(Length(mpcgs)*LogInt(Index(j,M),p))>100) then Info(InfoLattice,3,"Set l to fail"); l:=fail; # we will compute the subgroups later else ocr:=rec( group:=j, modulePcgs:=mpcgs ); if not IsBound(j!.lattfpres) then Info(InfoLattice,2,"Compute new factorfp"); j!.lattfpres:=IsomorphismFpGroupByChiefSeriesFactor(j,"x",M); fi; ocr.factorfphom:=j!.lattfpres; Assert(2,KernelOfMultiplicativeGeneralMapping(ocr.factorfphom)=M); # we want only normal complements. Therefore the 1-Coboundaries must # be trivial. We compute these first. if Dimension(OCOneCoboundaries(ocr))=0 then l:=[]; OCOneCocycles(ocr,true); if IsBound(ocr.complement) then l:=BaseSteinitzVectors(BasisVectors(Basis(ocr.oneCocycles)), BasisVectors(Basis(ocr.oneCoboundaries))); vs:=VectorSpace(LeftActingDomain(ocr.oneCocycles), l.factorspace,Zero(ocr.oneCocycles)); Info(InfoLattice,2,p^Length(l.factorspace)," cocycles"); # try to catch some solvable cases that look awful if Size(vs)>1000 and Length(Set(Factors(Index(j,N))))<=2 then l:=fail; else l:=[]; for k in vs do comp:=ocr.cocycleToList(k); for ii in [1..Length(comp)] do comp[ii]:=ocr.complementGens[ii]*comp[ii]; od; k:=ClosureGroup(N,comp); if IsNormal(G,k) then if still then # transfer a known presentation if not IsPcGroup(k) then k!.lattfpres:=ComplementFactorFpHom( ocr.factorfphom,l,M,N,k,ocr.generators,comp); Assert(1,KernelOfMultiplicativeGeneralMapping(k!.lattfpres)=N); fi; k!.obtain:="compl"; fi; Add(l,k); fi; od; Info(InfoLattice,2," -> ",Length(l)," normal complements"); nnt:=Concatenation(nnt,l); fi; fi; fi; fi; Info(InfoLattice,3,"Set l to ",l); if l=fail then if onlysimple then # all groups obtained will have a solvable factor l:=[]; else Info(InfoLattice,1,"using invariant subgroups"); # the factor is abelian, we therefore find this homomorphism # quick. hom:=NaturalHomomorphismByNormalSubgroup(j,N); r:=Image(hom,j); jg:=List(GeneratorsOfGroup(j),i->Image(hom,i)); # construct the automorphisms auts:=List(GeneratorsOfGroup(G), i->GroupHomomorphismByImagesNC(r,r,jg, List(GeneratorsOfGroup(j),k->Image(hom,k^i)))); l:=SubgroupsSolvableGroup(r,rec( actions:=auts, funcnorm:=r, consider:=ExactSizeConsiderFunction(Index(j,M)), normal:=true)); Info(InfoLattice,2,"found ",Length(l)," invariant subgroups"); C:=Image(hom,M); l:=Filtered(l,i->Size(i)=Index(j,M) and Size(Intersection(i,C))=1); l:=List(l,i->PreImage(hom,i)); l:=Filtered(l,i->IsNormal(G,i)); Info(InfoLattice,1,Length(l)," of these normal"); nnt:=Concatenation(nnt,l); fi; fi; fi; od; else # nonabelian factor. if still then # fp isom for decomposition mpcgs:=IsomorphismFpGroupByChiefSeriesFactor(M,"x",N); fi; # 1) compute the action for the factor # first, we obtain the simple factors T_i/N. # we get these as intersections of the conjugates of the subnormal # subgroup if HasCompositionSeries(M) then T:=CompositionSeries(M)[2]; # stored attribute else T:=false; fi; if not (T<>false and IsSubgroup(T,N)) then # we did not get the right T: must compute hom:=NaturalHomomorphismByNormalSubgroup(M,N); T:=CompositionSeries(Image(hom))[2]; T:=PreImage(hom,T); fi; hom:=NaturalHomomorphismByNormalSubgroup(M,T); A:=Image(hom,M); Info(InfoLattice,2,"Search involution"); # find involution in M/T repeat repeat inv:=Random(M); until (Order(inv) mod 2 =0) and not inv in T; o:=First([2..Order(inv)],i->inv^i in T); until (o mod 2 =0); Info(InfoLattice,2,"Element of order ",o); inv:=inv^(o/2); # this is an involution in the factor Assert(1,inv^2 in T and not inv in T); S:=Normalizer(G,T); # stabilize first component orb:=[inv]; # class representatives in A by preimages in G orbi:=[Image(hom,inv)]; cllen:=Index(A,Centralizer(A,orbi[1])); C:=T; #starting centralizer cnt:=1; # we have to find at least 1 centralizing element repeat # find element that centralizes inv modulo T repeat r:=Random(S); c:=Comm(inv,r); o:=First([1..Order(c)],i->c^i in T); c:=c^QuoInt(o-1,2); if o mod 2=1 then c:=r*c; else c:=inv^r*c; fi; # take care of potential class fusion if not c in T and c in C then cnt:=cnt+1; if cnt=10 then # if we have 10 true centralizing elements that did not # yield anything new, we assume that classes get fused. # So we have to test, how much fusion takes place. # We do this with an orbit algorithm on classes of A for j in orb do for k in SmallGeneratingSet(S) do j:=j^k; ji:=Image(hom,j); if ForAll(orbi,l->RepresentativeAction(A,l,ji)=fail) then Add(orb,j); Add(orbi,ji); fi; od; od; # now we have the length cllen:=cllen*Length(orb); Info(InfoLattice,1,Length(orb)," classes fuse"); fi; fi; until not c in C or Index(S,C)=cllen; C:=ClosureGroup(C,c); Info(InfoLattice,2,"New centralizing element of order ",o, ", Index=",Index(S,C)); until Index(S,C)<=cllen; C:=Core(G,C); #the true centralizer is the core of the involution # centralizer if Size(C)>Size(N) then for j in Filtered(nt,i->Size(i)>Size(M)) do j:=Intersection(C,j); if Size(j)>Size(N) and not j in nnt then j!.obtain:="nonab"; Add(nnt,j); fi; od; fi; fi; # else nonabelian # the kernel itself N!.lattfpres:=IsomorphismFpGroupByChiefSeriesFactor(N,"x",N); N!.obtain:="kernel"; Add(nnt,N); if onlysimple then c:=Length(nnt); nnt:=Filtered(nnt,j->Size(ClosureGroup(N,DerivedSubgroup(j)))=Size(j) ); Info(InfoLattice,2,"removed ",c-Length(nnt)," nonperfect groups"); fi; Info(InfoLattice,1,Length(nnt)-Length(nt), " new normal subgroups (",Length(nnt)," total)"); nt:=nnt; # modify hohomorphisms if still then for i in [1..firsts] do l:=nt[i]; if IsBound(l!.lattfpres) then Assert(1,KernelOfMultiplicativeGeneralMapping(l!.lattfpres)=M); # lift presentation # note: if notabelian mpcgs is an fp hom l!.lattfpres:=LiftFactorFpHom(l!.lattfpres,l,M,N,mpcgs); l!.obtain:="lift"; fi; od; fi; od; # remove partial presentation info for i in nt do Unbind(i!.lattfpres); od; return Reversed(nt); # to stay ascending end; ############################################################################# ## #M NormalSubgroups() ## InstallMethod(NormalSubgroups,"homomorphism principle pc groups",true, [IsPcGroup],0,NormalSubgroupsCalc); InstallMethod(NormalSubgroups,"homomorphism principle perm groups",true, [IsPermGroup],0,NormalSubgroupsCalc); ############################################################################# ## #M Socle() ## InstallMethod(Socle,"from normal subgroups",true,[IsGroup],0, function(G) local n,i,s; if Size(G)=1 then return G;fi; # this could be a bit shorter, but the groups in question have few normal # subgroups n:=NormalSubgroups(G); n:=Filtered(n,i->2=Number(n,j->IsSubset(i,j))); s:=n[1]; for i in [2..Length(n)] do s:=ClosureGroup(s,n[i]); od; return s; end); ############################################################################# ## #M IntermediateSubgroups(,) ## InstallMethod(IntermediateSubgroups,"blocks for coset operation", IsIdenticalObj, [IsGroup,IsGroup],0, function(G,U) local rt,op,a,l,i,j,u,max,subs; if Length(GeneratorsOfGroup(G))>2 then a:=SmallGeneratingSet(G); if Length(a)Filtered([1..i-1],j->IsSubset(a[i],a[j]))); # List the sets we know to be contained in each set max:=Set(List(Difference([1..l],Union(subs)), # sets which are # contained in no other i->[i,l+1])); for i in [1..l] do #take all subsets if Length(subs[i])=0 then # is minimal AddSet(max,[0,i]); else u:=ShallowCopy(subs[i]); #and remove those which come via other ones for j in u do u:=Difference(u,subs[j]); od; for j in u do #remainder is maximal AddSet(max,[j,i]); od; fi; od; return rec(subgroups:=List(a,i->ClosureGroup(U,rt{i})),inclusions:=max); end); InstallMethod(IntermediateSubgroups,"normal case", IsIdenticalObj, [IsGroup,IsGroup], 1,# better than the previous method function(G,N) local hom,F,cl,cls,lcl,sub,sel,unsel,i,j,rmNonMax; if not IsNormal(G,N) then TryNextMethod(); fi; hom:=NaturalHomomorphismByNormalSubgroup(G,N); F:=Image(hom,G); unsel:=[1,Size(F)]; cl:=Filtered(ConjugacyClassesSubgroups(F), i->not Size(Representative(i)) in unsel); Sort(cl,function(a,b) return Size(Representative(a))[]); sub[lcl+1]:=[0..Length(cl)]; rmNonMax := function(j) if j > 0 then UniteSet( unsel, sub[j] ); Perform( sub[j], rmNonMax ); fi; end; # now build a list of contained maximal subgroups for i in [1..lcl] do sel:=Filtered([1..i-1],j->IsInt(cls[i]/cls[j]) and cls[j]PreImage(hom,i)),inclusions:=sel); end); ############################################################################# ## #F DotFileLatticeSubgroups(,) ## InstallGlobalFunction(DotFileLatticeSubgroups,function(L,file) local cls, len, sz, max, rep, z, t, i, j, k; cls:=ConjugacyClassesSubgroups(L); len:=[]; sz:=[]; for i in cls do Add(len,Size(i)); AddSet(sz,Size(Representative(i))); od; PrintTo(file,"digraph lattice {\nsize = \"6,6\";\n"); # sizes and arrangement for i in sz do AppendTo(file,"\"s",i,"\" [label=\"",i,"\", color=white];\n"); od; sz:=Reversed(sz); for i in [2..Length(sz)] do AppendTo(file,"\"s",sz[i-1],"\"->\"s",sz[i], "\" [color=white,arrowhead=none];\n"); od; # subgroup nodes, also acccording to size for i in [1..Length(cls)] do for j in [1..len[i]] do if len[i]=1 then AppendTo(file,"\"",i,"x",j,"\" [label=\"",i,"\", shape=box];\n"); else AppendTo(file,"\"",i,"x",j,"\" [label=\"",i,"-",j,"\", shape=circle];\n"); fi; od; AppendTo(file,"{ rank=same; \"s",Size(Representative(cls[i])),"\""); for j in [1..len[i]] do AppendTo(file," \"",i,"x",j,"\""); od; AppendTo(file,";}\n"); od; max:=MaximalSubgroupsLattice(L); for i in [1..Length(cls)] do for j in max[i] do rep:=ClassElementLattice(cls[i],1); for k in [1..len[i]] do if k=1 then z:=j[2]; else t:=cls[i]!.normalizerTransversal[k]; z:=ClassElementLattice(cls[j[1]],1); # force computation of transv. z:=cls[j[1]]!.normalizerTransversal[j[2]]*t; z:=PositionCanonical(cls[j[1]]!.normalizerTransversal,z); fi; AppendTo(file,"\"",i,"x",k,"\" -> \"",j[1],"x",z, "\" [arrowhead=none];\n"); od; od; od; AppendTo(file,"}\n"); end); InstallGlobalFunction("ExtendSubgroupsOfNormal",function(G,N,Bs) local l,mark,i,b,M,no,cnt,j,q,As,a,hom,c,p,ap,prea,prestab,new,sz,k,h; l:=[]; # list of subgroups mark:=BlistList([1..Length(Bs)],[]); # mark off conjugates for i in [1..Length(Bs)] do if not mark[i] then Info(InfoLattice,1,"extending ",i); mark[i]:=true; b:=Bs[i]; Add(l,b); M:=Normalizer(G,b); no:=Intersection(M,N); # normalizer in N if Index(G,M)>Index(N,no) then # there are further conjugates cnt:=Index(G,M)/Index(N,no)-1; for j in RightTransversal(G,ClosureGroup(N,M)) do if cnt>0 and not IsOne(j) then a:=b^j; p:=First([i..Length(Bs)],x-> RepresentativeAction(N,a,Bs[x])<>fail); #if Size(b)=2 then Error("WWW");fi; if p<>fail and not mark[p] then # mark conjugate subgroup off as used mark[p]:=true; cnt:=cnt-1; fi; fi; od; if cnt<>0 then Info(InfoLattice,3,"cnt=",cnt);fi; fi; q:=NaturalHomomorphismByNormalSubgroup(M,no); As:=ConjugacyClassesSubgroups(Image(q)); for ap in [1..Length(As)] do Info(InfoLattice,2,"extending ",ap," of ",Length(As)); a:=As[ap]; if Size(Representative(a))>1 then # no complement of trivial # complement to no/b in a/b prea:=PreImage(q,Representative(a)); prestab:=PreImage(q,Stabilizer(a)); hom:=NaturalHomomorphismByNormalSubgroup(prea,b); #AAA:=[Image(hom),Image(hom,no)]; c:=ComplementClassesRepresentatives(Image(hom),Image(hom,no)); c:=List(c,x->PreImage(hom,x)); #oc:=c; c:=PermPreConjtestGroups(prestab,c); #c:=[[prestab,c]]; for j in c do new:=List(SubgroupsOrbitsAndNormalizers(j[1],j[2],false), x->x.representative); for k in new do sz:=Size(k); h:=Group(SmallGeneratingSet(k)); SetSize(h,sz); Add(l,h); od; Info(InfoLattice,1,"now found ",Length(l)," subgroups"); od; #if # Length(new)<>Length(SubgroupsOrbitsAndNormalizers(prestab,oc,false)) # then # Error("hier"); #fi; #fi; fi; od; fi; od; # finally subgroups of G/N #q:=NaturalHomomorphismByNormalSubgroup(G,N); #for a in ConjugacyClassesSubgroups(Image(q)) do # if Size(Representative(a))>1 then # no complement of trivial # Add(l,PreImage(q,Representative(a))); # fi; #od; return l; end); InstallGlobalFunction("SubdirectSubgroups",function(D) local fgi,inducedfactorautos,projs,psubs,info,n,l,nl,proj,emb,u,pos, subs,s,t,i,j,k,myid,myfgi,iso,dc,f,no,ind,g,hom; fgi:=function(gp,nor) local idx,hom,l,f; idx:=Index(gp,nor); hom:=NaturalHomomorphismByNormalSubgroup(gp,nor); if idx>1000 or idx=512 then l:=[idx,fail]; else l:=ShallowCopy(IdGroup(gp/nor)); fi; f:=Image(hom,gp); Add(l,hom); Add(l,f); Add(l,AutomorphismGroup(f)); return l; end; inducedfactorautos:=function(n,f,hom) local gens,auts,aut,i; gens:=GeneratorsOfGroup(f); auts:=[]; for i in GeneratorsOfGroup(n) do aut:=GroupHomomorphismByImages(f,f,gens,List(gens,x-> Image(hom,PreImagesRepresentative(hom,x)^i))); SetIsBijective(aut,true); Add(auts,aut); od; return auts; end; projs:=[]; psubs:=[]; info:=DirectProductInfo(D); n:=Length(info.groups); # previous embedding is all trivial l:=[[TrivialSubgroup(D),D]]; for i in [1..n] do proj:=Projection(D,i); emb:=Embedding(D,i); u:=info.groups[i]; pos:=Position(projs,u); if pos=fail then subs:=[]; for j in ConjugacyClassesSubgroups(u) do s:=[Representative(j),Stabilizer(j)]; no:=SubgroupsOrbitsAndNormalizers(s[2],NormalSubgroups(s[1]),false); nl:=[]; for k in no do myfgi:=fgi(s[1],k.representative); Add(myfgi,Subgroup(myfgi[5], inducedfactorautos(k.normalizer,myfgi[4],myfgi[3]))); Add(nl,Concatenation([k.representative,k.normalizer],myfgi)); od; Add(s,nl); Add(subs,s); od; Add(projs,u); Add(psubs,subs); pos:=Length(projs); else subs:=psubs[pos]; fi; if i=1 then l:=[]; for j in subs do g:=Image(emb,j[1]); Add(l,[g,Normalizer(D,g)]); od; else # i>1. Proper subdirect products nl:=[]; for j in l do no:=NormalSubgroups(j[1]); no:=SubgroupsOrbitsAndNormalizers(j[2],no,false); #Print("Try",j," ",Length(no),"\n"); for k in no do hom:=NaturalHomomorphismByNormalSubgroup(j[1],k.representative); f:=Image(hom); if Size(f)<1000 and Size(f)<>512 then myid:=ShallowCopy(IdGroup(f)); else myid:=[Size(f),fail]; fi; for s in subs do for t in s[3] do # look over normals of subgroup #Print(t,"\n"); if t{[3,4]}=myid then if false and myid=[1,1] then #Print("direct\n"); g:=Subgroup(D,Concatenation(GeneratorsOfGroup(j[1]),List(GeneratorsOfGroup(s[1]),x->Image(emb,x)))); Add(nl,[g,Normalizer(D,g)]); else iso:=IsomorphismGroups(f,t[6]); if iso<>fail then #Found isomorphic factor groups iso:=hom*iso; ind:=Subgroup(t[7],inducedfactorautos(k.normalizer,t[6],iso)); for dc in DoubleCosetRepsAndSizes(t[7],ind,t[8]) do # form the subdirect product g:=List(GeneratorsOfGroup(j[1]), x->x*Image(emb,PreImagesRepresentative(t[5], Image(dc[1],Image(iso,x))) )); Append(g,List(GeneratorsOfGroup(t[1]),x->Image(emb,x))); g:=Subgroup(D,g); if Size(g)<>Size(j[1])*Size(s[1])/Size(f) then Error("sudi\n");fi; Add(nl,[g,Normalizer(D,g)]); od; fi; fi; fi; od; od; od; od; l:=nl; fi; Info(InfoLattice,1,"subdirect level ",i," got ",Length(l)); od; return l; end); InstallGlobalFunction("SubgroupsTrivialFitting",function(G) local s,a,n,fac,iso,types,t,p,i,map,go,gold,nf; # find socle by derived s:=G; repeat a:=s; s:=DerivedSubgroup(s); until Size(s)=Size(a); # now try s as socle -- find minimal normals n:=Filtered(NormalSubgroups(s),x->Size(x)>1); n:=Filtered(n,x->not ForAny(n,y->Size(y)s then TryNextMethod(); fi; Info(InfoLattice,1,"socle index ",Index(G,s)," has ", Length(fac)," factors from ",Length(types)," types"); if Length(fac)=1 then map:=iso[1]; a:=ConjugacyClassesSubgroups(gold[1]); a:=List(a,x->PreImage(map,Representative(x))); else n:=DirectProduct(fac); # map to direct product a:=[]; map:=[]; for i in [1..Length(fac)] do Append(a,GeneratorsOfGroup(nf[i])); Append(map,List(GeneratorsOfGroup(nf[i]), x->Image(Embedding(n,i),Image(iso[i],x)))); od; map:=GroupHomomorphismByImages(s,n,a,map); a:=SubdirectSubgroups(n); a:=List(a,x->PreImage(map,x[1])); fi; Info(InfoLattice,1,"socle has ",Length(a)," classes of subgroups"); s:=ExtendSubgroupsOfNormal(G,s,a); Info(InfoLattice,1,"Overall ",Length(s)," subgroups"); return s; end); gap-4r6p5/lib/tuples.gi0000644000175000017500000003633412172557254013557 0ustar billbill############################################################################# ## #W tuples.gi GAP library Steve Linton ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file declares the operations for direct product elements. ## ############################################################################# ## #V DIRECT_PRODUCT_ELEMENT_FAMILIES . . . list of all direct product elements #V families ## EmptyDirectProductElementsFamily!.defaultTupleType:= NewType( EmptyDirectProductElementsFamily, IsDefaultDirectProductElementRep ); SetComponentsOfDirectProductElementsFamily( EmptyDirectProductElementsFamily, [] ); InstallValue( DIRECT_PRODUCT_ELEMENT_FAMILIES, [ [ EmptyDirectProductElementsFamily ] ] ); ############################################################################# ## #M DirectProductElementsFamily( ) . . . family of direct product #M elements ## InstallMethod( DirectProductElementsFamily, "for a collection (of families)", fam -> fam = CollectionsFamily(FamilyOfFamilies), [ IsCollection ], function( famlist ) local n, tupfams, freepos, len, i, fam, tuplespos, tuplesfam,filter,filter2; n := Length(famlist); if not IsBound(DIRECT_PRODUCT_ELEMENT_FAMILIES[n+1]) then tupfams:= WeakPointerObj( [] ); DIRECT_PRODUCT_ELEMENT_FAMILIES[n+1]:= tupfams; freepos:= 1; else tupfams:= DIRECT_PRODUCT_ELEMENT_FAMILIES[n+1]; len:= LengthWPObj( tupfams ); for i in [ 1 .. len+1 ] do fam:= ElmWPObj( tupfams, i ); if fam = fail then if not IsBound( freepos ) then freepos:= i; fi; elif ComponentsOfDirectProductElementsFamily( fam ) = famlist then tuplespos:= i; break; fi; od; fi; if IsBound( tuplespos ) then Info( InfoDirectProductElements, 2, "Reused direct product elements family, length ", n ); tuplesfam:= tupfams[ tuplespos ]; else Info( InfoDirectProductElements, 1, "Created new direct product elements family, length ", n ); filter:=IsDirectProductElement; filter2:=IsDirectProductElementFamily; # inherit positive element comparison from the families but do not # trigger the computation. if ForAll(famlist,i->HasCanEasilyCompareElements(i) and CanEasilySortElements(i)) then filter:=filter and CanEasilySortElements; filter2:=filter2 and CanEasilySortElements; elif ForAll(famlist,i->HasCanEasilyCompareElements(i) and CanEasilyCompareElements(i)) then filter:=filter and CanEasilyCompareElements; filter2:=filter2 and CanEasilyCompareElements; fi; tuplesfam:= NewFamily( "DirectProductElementsFamily( <> )", IsDirectProductElement, filter, filter2 ); SetComponentsOfDirectProductElementsFamily( tuplesfam, Immutable( famlist ) ); SetElmWPObj( tupfams, freepos, tuplesfam ); tuplesfam!.defaultTupleType:= NewType( tuplesfam, IsDefaultDirectProductElementRep ); fi; return tuplesfam; end ); ############################################################################# ## #M DirectProductElementsFamily( [] ) . . . . family of empty direct product #M element(s) ## InstallOtherMethod( DirectProductElementsFamily, "for an empty list", [ IsList and IsEmpty ], function( empty ) Info( InfoDirectProductElements, 2, "Reused direct product elements family, length 0 "); return DIRECT_PRODUCT_ELEMENT_FAMILIES[1][1]; end ); ############################################################################# ## #M DirectProductElement( ) . . . . . make a direct product element ## InstallMethod( DirectProductElement, "for a list", [ IsList ], function( objlist ) local fam; fam := DirectProductElementsFamily( List(objlist, FamilyObj) ); return DirectProductElementNC( fam, objlist ); end ); ############################################################################# ## #M DirectProductElement( , ) . make a direct product element ## InstallOtherMethod( DirectProductElement, "for a direct product elements family, and a list", [ IsDirectProductElementFamily, IsList ], function( fam, objlist ) while ComponentsOfDirectProductElementsFamily( fam ) <> List( objlist, FamilyObj ) do objlist:= Error( "objects not of proper families for direct product ", "elements family supplied, you may supply replacements" ); od; return DirectProductElementNC( fam, objlist ); end ); ############################################################################# ## #M PrintObj( ) . . . . . . . . . . . print a direct product element #M ViewObj( ) . . . . . . . . . . . . view a direct product element ## ## We install a special `ViewObj' method because as soon as a direct product ## element stores that it is finite (this happens for example in a call to ## `ShallowCopy'), the `ViewObj' method for finite lists would strike. ## InstallMethod( PrintObj, "for a direct product element", [ IsDirectProductElement ], function( dpelm ) local i; Print( "DirectProductElement( [ " ); for i in [ 1 .. Length( dpelm )-1 ] do Print( dpelm[i], ", " ); od; if Length( dpelm ) <> 0 then Print( dpelm[ Length( dpelm ) ] ); fi; Print(" ] )"); end ); InstallMethod( ViewObj, "for a direct product element (call `PrintObj')", [ IsDirectProductElement ], PrintObj ); ############################################################################# ## #M < . . . . . . . . . . . . . . . . . . . . . comparison ## InstallMethod( \<, "for two direct product elements", IsIdenticalObj, [ IsDirectProductElement, IsDirectProductElement ], function( dpelm1, dpelm2 ) local i; for i in [1..Length(dpelm1)] do if dpelm1[i] < dpelm2[i] then return true; elif dpelm1[i] > dpelm2[i] then return false; fi; od; return false; end ); ############################################################################# ## #M = . . . . . . . . . . . . . . . . . . . . . comparison ## InstallMethod( \=, "for two direct product elements", IsIdenticalObj, [ IsDirectProductElement, IsDirectProductElement ], function( dpelm1, dpelm2 ) local i; for i in [1..Length(dpelm1)] do if dpelm1[i] <> dpelm2[i] then return false; fi; od; return true; end ); ############################################################################# ## #M CanEasilyCompareElements( ) ## InstallMethod( CanEasilyCompareElements, "for direct product element", [ IsDirectProductElement ], function( dpelm ) local i; for i in dpelm do if not CanEasilyCompareElements( i ) then return false; fi; od; return true; end ); ############################################################################# ## #M DirectProductElementNC( , ) . make a direct product #M element ## ## Note that we really have to copy the list passed, even if it is immutable ## as we are going to call `Objectify'. ## InstallMethod( DirectProductElementNC, "for a direct product elements family, and a list", [ IsDirectProductElementFamily, IsList ], function( fam, objlist ) local t; Assert( 2, ComponentsOfDirectProductElementsFamily( fam ) = List( objlist, FamilyObj ) ); t:= Objectify( fam!.defaultTupleType, PlainListCopy( List( objlist, Immutable ) ) ); Info( InfoDirectProductElements, 3, "Created a new DirectProductElement ", t ); return t; end ); ############################################################################# ## #M [ ] . . . . . . . . . . . . . . . . . . . component access ## InstallMethod( \[\], "for a direct product element in default repres., and a pos. integer", [ IsDefaultDirectProductElementRep, IsPosInt ], function( dpelm, index ) while index > Length( dpelm ) do index:= Error( " too large for , ", "you may return another index" ); od; return dpelm![index]; end ); ############################################################################# ## #M Length( ) . . . . . . . . . . . . . . . . . number of components ## InstallMethod( Length, "for a direct product element in default representation", [ IsDefaultDirectProductElementRep ], function( dpelm ) return Length( ComponentsOfDirectProductElementsFamily( FamilyObj( dpelm ) ) ); end ); ############################################################################# ## #M InverseOp( ) ## InstallMethod( InverseOp, "for a direct product element", [ IsDirectProductElement ], function( dpelm ) return DirectProductElement( List( dpelm, Inverse ) ); end ); ############################################################################# ## #M OneOp( ) ## InstallMethod( OneOp, "for a direct product element", [ IsDirectProductElement ], function( dpelm ) return DirectProductElement( List( dpelm, One ) ); end ); ############################################################################# ## #M \*( , ) ## InstallMethod( \*, "for two direct product elements", [ IsDirectProductElement, IsDirectProductElement ], function( elm1, elm2 ) local n; n := Length( elm1 ); return DirectProductElement( List( [1..n], x -> elm1[x]*elm2[x] ) ); end ); ############################################################################# ## #M IsGeneratorsOfMagmaWithInverses( ) ## InstallMethod( IsGeneratorsOfMagmaWithInverses, "for list of direct product elements", [ IsDirectProductElementCollection ], function( l ) local n; if IsEmpty (l) then return true; fi; n := Length (l[1]); if ForAny (l, x -> Length (x) <> n) then return false; fi; return ForAll( [ 1 .. n ], i -> IsGeneratorsOfMagmaWithInverses (l{[1..Length(l)]}[i])); end ); ############################################################################# ## #M \^( , ) ## InstallMethod( \^, "for direct product element, and integer", [ IsDirectProductElement, IsInt ], function( dpelm, x ) return DirectProductElement( List( dpelm, y -> y^x ) ); end ); ############################################################################# ## #M AdditiveInverseOp( ) ## InstallMethod( AdditiveInverseOp, "for a direct product element", [ IsDirectProductElement ], function( dpelm ) return DirectProductElement( List( dpelm, AdditiveInverse ) ); end ); ############################################################################# ## #M ZeroOp( ) ## InstallMethod( ZeroOp, "for a direct product element", [ IsDirectProductElement ], function( dpelm ) return DirectProductElement( List( dpelm, Zero ) ); end ); ############################################################################# ## #M \+( , ) ## InstallMethod( \+, "for two direct product elements", [ IsDirectProductElement, IsDirectProductElement ], function( dpelm1, dpelm2 ) local n; n := Length( dpelm1 ); return DirectProductElement( List( [1..n], x -> dpelm1[x]+dpelm2[x] ) ); end ); ############################################################################# ## #M \+( , ) #M \+( , ) #M \*( , ) #M \*( , ) #M \+( , ) #M \+( , ) #M \*( , ) #M \*( , ) ## ## Direct product elements do *not* lie in `IsGeneralizedRowVector', ## since they shall behave as scalars; ## for example we want the sum of a direct product element and a list of ## diect product elements to be the list of sums. ## (It would also be possible to make them generalized row vectors with ## additive and multiplicative nesting depth zero, but then the nesting ## depths would have to be calculated whenever they are needed. ## In fact I think this approach would be equivalent.) ## ## Because direct product elements are lists, there are no default methods ## for adding or multiplying a direct product element and a default list. ## So we install such methods where direct product elements act as scalars. ## Analogously, ## we define the sum and the product of a direct product element ## with a non-list as the direct product element of componentwise sums and ## products, respectively. ## #T As soon as IsListDefault implies IsAdditiveElement and #T IsMultiplicativeElement, the InstallOtherMethod in the first four #T of the following methods can be replaced by InstallMethod! InstallOtherMethod( \+, "for a direct product element, and a default list", [ IsDirectProductElement, IsListDefault ], SUM_SCL_LIST_DEFAULT ); InstallOtherMethod( \+, "for a default list, and a direct product element", [ IsListDefault, IsDirectProductElement ], SUM_LIST_SCL_DEFAULT ); InstallOtherMethod( \*, "for a direct product element, and a default list", [ IsDirectProductElement, IsListDefault ], PROD_SCL_LIST_DEFAULT ); InstallOtherMethod( \*, "for a default list, and a direct product element", [ IsListDefault, IsDirectProductElement ], PROD_LIST_SCL_DEFAULT ); InstallOtherMethod( \+, "for a direct product element, and a non-list", [ IsDirectProductElement, IsObject ], function( dpelm, nonlist ) if IsList( nonlist ) then TryNextMethod(); fi; return DirectProductElement( List( dpelm, entry -> entry + nonlist ) ); end ); InstallOtherMethod( \+, "for a non-list, and a direct product element", [ IsObject, IsDirectProductElement ], function( nonlist, dpelm ) if IsList( nonlist ) then TryNextMethod(); fi; return DirectProductElement( List( dpelm, entry -> nonlist + entry ) ); end ); InstallOtherMethod( \*, "for a direct product element, and a non-list", [ IsDirectProductElement, IsObject ], function( dpelm, nonlist ) if IsList( nonlist ) then TryNextMethod(); fi; return DirectProductElement( List( dpelm, entry -> entry * nonlist ) ); end ); InstallOtherMethod( \*, "for a non-list, and a direct product element", [ IsObject, IsDirectProductElement ], function( nonlist, dpelm ) if IsList( nonlist ) then TryNextMethod(); fi; return DirectProductElement( List( dpelm, entry -> nonlist * entry ) ); end ); ############################################################################# ## #E gap-4r6p5/lib/sparselist.gd0000644000175000017500000000735512172557254014430 0ustar billbill############################################################################# ## #W sparselist.gd GAP library Steve Linton ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file declares the operations for sparse lists ## ############################################################################# ## #O SparseStructureOfList( ) ## ## This operation returns a sparse structure of ## The return value is a length three list, of which the first ## position may or may not be bound. If bound, it is the default ## value, if not bound, the default is to be unbound. The default value ## must by immutable ## ## The second entry is a dense duplicate-free list of integers ## between 1 and Length() inclusive, representing the ## positions where non-default entries may appear. ## ## The third entry is a list not longer than the second entry, giving ## the values that appear in the positions given in the second ## entry. Holes in this list represent holes in the original list. ## ## The second and third entries may be mutable (to avoid copying in ## time-critical code) but should not be changed. ## DeclareOperation( "SparseStructureOfList", [IsList]); ############################################################################# ## #F IsSparseList( ) ## ## A sparse list is a list for which the sparse structure and corresponding ## sparse methods should be used. ## ## The filter is ranked up so that sparse list methods will beat ## competing methods for finite, homogenous, etc. lists, which is ## usually right ## DeclareFilter( "IsSparseList", IsList ); RANK_FILTERS[FLAG1_FILTER(IsSparseList)] := 20; ############################################################################# ## #F SparseListBySortedList ( , , , ) #F SparseListBySortedListNC( , , , ) ## ## These two functions can be used to create homogeneous sparse ## lists, in a representation where the positions are stored as a ## sorted list and the values as a corresponding list. These lists ## must be dense. ## ## The NC version refrains from both checking and copying its arguments ## The non-NC version makes a shallow copy of and ## DeclareGlobalFunction( "SparseListBySortedList"); DeclareGlobalFunction( "SparseListBySortedListNC"); ############################################################################# ## #P IsSparseRowVector( ) ## ## A sparse list is a sparse row vector if it is dense and its default value ## is a common Zero of all its non-default values ## DeclareProperty( "IsSparseRowVector", IsSparseList); InstallTrueMethod( IsRowVector, IsSparseRowVector ); InstallTrueMethod( IsHomogeneousList, IsSparseRowVector ); InstallTrueMethod( IsCollection, IsSparseRowVector ); ############################################################################# ## #F SparseVectorBySortedList ( , , [, ] ) #F SparseVectorBySortedListNC( , , [, ]) ## ## These two functions can be used to create sparse row vectors using ## the SparseListBySortedList representation, but knowing a priori ## that they are sparse row vectors. The optional argument is ## needed only when and are empty. ## ## The NC version refrains from both checking and copying its arguments ## The non-NC version makes a shallow copy of and ## DeclareGlobalFunction( "SparseVectorBySortedList"); DeclareGlobalFunction( "SparseVectorBySortedListNC"); ############################################################################# ## #E gap-4r6p5/lib/grppcaut.gd0000644000175000017500000000164212172557252014053 0ustar billbill############################################################################# ## #W grppcaut.gd GAP library Bettina Eick ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ############################################################################# ## #P IsFrattiniFree ## DeclareProperty( "IsFrattiniFree", IsGroup ); DeclareGlobalFunction("AutomorphismGroupNilpotentGroup"); DeclareGlobalFunction("AutomorphismGroupSolvableGroup"); DeclareGlobalFunction("AutomorphismGroupFrattFreeGroup"); ############################################################################# ## #I InfoAutGrp ## DeclareInfoClass( "InfoAutGrp" ); DeclareInfoClass( "InfoMatOrb" ); DeclareInfoClass( "InfoOverGr" ); if not IsBound( CHOP ) then CHOP := false; fi; gap-4r6p5/lib/twocohom.gd0000644000175000017500000001213312172557254014064 0ustar billbill############################################################################# ## #W twocohom.gd GAP library Bettina Eick ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ############################################################################# ## #F CollectedWordSQ( , , ) ## ## ## ## ## ## ## ## DeclareGlobalFunction( "CollectedWordSQ" ); ############################################################################# ## #F CollectorSQ( , , ) ## ## ## ## ## ## ## ## DeclareGlobalFunction( "CollectorSQ" ); ############################################################################# ## #F AddEquationsSQ( , , ) ## ## ## ## ## ## ## ## DeclareGlobalFunction( "AddEquationsSQ" ); ############################################################################# ## #F SolutionSQ( , ) ## ## ## ## ## ## ## ## DeclareGlobalFunction( "SolutionSQ" ); ############################################################################# ## #F TwoCocyclesSQ( , , ) ## ## ## ## ## ## ## ## DeclareGlobalFunction( "TwoCocyclesSQ" ); ############################################################################# ## #F TwoCoboundariesSQ( , , ) ## ## ## ## ## ## ## ## DeclareGlobalFunction( "TwoCoboundariesSQ" ); ############################################################################# ## #F TwoCohomologySQ( , , ) ## ## ## ## ## ## ## ## DeclareGlobalFunction( "TwoCohomologySQ" ); ############################################################################# ## #O TwoCocycles( , ) ## ## <#GAPDoc Label="TwoCocycles"> ## ## ## ## ## returns the 2-cocycles of a pc group G by the ## G-module M. ## The generators of M must correspond to the ## value of G. The operation ## returns a list of vectors over the field underlying M and the ## additive group generated by these vectors is the group of ## 2-cocyles. ## ## ## <#/GAPDoc> ## DeclareOperation( "TwoCocycles", [ IsPcGroup, IsObject ] ); ############################################################################# ## #O TwoCoboundaries( , ) ## ## <#GAPDoc Label="TwoCoboundaries"> ## ## ## ## ## returns the group of 2-coboundaries of a pc group G by the ## G-module M. ## The generators of M must correspond to the ## value of G. ## The group of coboundaries is given as vector space over the field ## underlying M. ## ## ## <#/GAPDoc> ## DeclareOperation( "TwoCoboundaries", [ IsPcGroup, IsObject ] ); ############################################################################# ## #O TwoCohomology( , ) ## ## <#GAPDoc Label="TwoCohomology"> ## ## ## ## ## returns a record defining the second cohomology group as factor space of ## the space of cocycles by the space of coboundaries. ## G must be a pc group and the generators of M must ## correspond to the pcgs of G. ## G := SmallGroup( 4, 2 ); ## ## gap> mats := List( Pcgs( G ), x -> IdentityMat( 1, GF(2) ) ); ## [ , ] ## gap> M := GModuleByMats( mats, GF(2) ); ## rec( dimension := 1, field := GF(2), ## generators := [ , ## ], isMTXModule := true ) ## gap> TwoCoboundaries( G, M ); ## [ ] ## gap> TwoCocycles( G, M ); ## [ [ Z(2)^0, 0*Z(2), 0*Z(2) ], [ 0*Z(2), Z(2)^0, 0*Z(2) ], ## [ 0*Z(2), 0*Z(2), Z(2)^0 ] ] ## gap> cc := TwoCohomology( G, M );; ## gap> cc.cohom; ## -> ( GF(2)^3 )> ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "TwoCohomology", [ IsPcGroup, IsObject ] ); ############################################################################# ## #E gap-4r6p5/lib/algfld.gi0000644000175000017500000016774112172557252013501 0ustar billbill########################################################################### ## #W algfld.gi GAP Library Alexander Hulpke ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1999 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the methods for algebraic elements and their families ## ############################################################################# ## #R IsAlgebraicExtensionDefaultRep Representation of algebraic extensions ## DeclareRepresentation( "IsAlgebraicExtensionDefaultRep", IsAlgebraicExtension and IsComponentObjectRep and IsAttributeStoringRep, ["extFam"]); ############################################################################# ## #R IsAlgBFRep Representation for embedded base field ## DeclareRepresentation("IsAlgBFRep", IsPositionalObjectRep and IsAlgebraicElement,[]); ############################################################################# ## #R IsAlgExtRep Representation for true extension elements ## DeclareRepresentation("IsAlgExtRep", IsPositionalObjectRep and IsAlgebraicElement,[]); ############################################################################# ## #M AlgebraicElementsFamilies Initializing method ## InstallMethod(AlgebraicElementsFamilies,true,[IsUnivariatePolynomial],0, f -> []); ############################################################################# ## #F StoreAlgExtFam(,,) store fam as Alg.Ext.Fam. for p ## over field ## StoreAlgExtFam := function(p,f,fam) local aef; aef:=AlgebraicElementsFamilies(p); if not ForAny(aef,i->i[1]=f) then Add(aef,[f,fam]); fi; end; ############################################################################# ## #M AlgebraicElementsFamily generic method ## InstallMethod(AlgebraicElementsFamily,"generic",true, [IsField,IsUnivariatePolynomial],0, function(f,p) local fam,i,cof,red,rchar,impattr,deg; if not IsIrreducibleRingElement(PolynomialRing(f, [IndeterminateNumberOfLaurentPolynomial(p)]),p) then Error("

must be irreducible over f"); fi; fam:=AlgebraicElementsFamilies(p); i:=PositionProperty(fam,i->i[1]=f); if i<>fail then return fam[i][2]; fi; impattr:=IsAlgebraicElement and CanEasilySortElements and IsZDFRE; #if IsFinite(f) then # impattr:=impattr and IsFFE; #fi; fam:=NewFamily("AlgebraicElementsFamily(...)",IsAlgebraicElement, impattr, IsAlgebraicElementFamily and CanEasilySortElements); # The two types fam!.baseType := NewType(fam,IsAlgBFRep); fam!.extType := NewType(fam,IsAlgExtRep); # Important trivia fam!.baseField:=f; fam!.zeroCoefficient:=Zero(f); fam!.oneCoefficient:=One(f); if Size(f)<=256 then rchar:=Size(f); else rchar:=0; fi; fam!.rchar:=rchar; fam!.poly:=p; fam!.polCoeffs:=CoefficientsOfUnivariatePolynomial(p); deg:=DegreeOfLaurentPolynomial(p); fam!.deg:=deg; i:=List([1..DegreeOfLaurentPolynomial(p)],i->fam!.zeroCoefficient); i[2]:=fam!.oneCoefficient; if rchar>0 then ConvertToVectorRep(i,rchar); fi; fam!.primitiveElm:=ObjByExtRep(fam,i); fam!.indeterminateName:="a"; # reductions #red:=IdentityMat(deg,fam!.oneCoefficient); red:=[]; for i in [deg..2*deg-2] do cof:=ListWithIdenticalEntries(i,fam!.zeroCoefficient); Add(cof,fam!.oneCoefficient); if rchar>0 then ConvertToVectorRep(cof,rchar); fi; ReduceCoeffs(cof,fam!.polCoeffs); while Length(cof)2 then nam:=arg[3]; else nam:="a"; fi; if DegreeOfLaurentPolynomial(p)<=1 then return f; fi; fam:=AlgebraicElementsFamily(f,p); SetCharacteristic(fam,Characteristic(f)); fam!.indeterminateName:=nam; colf:=CollectionsFamily(fam); e:=Objectify(NewType(colf,IsAlgebraicExtensionDefaultRep), rec()); fam!.wholeField:=e; e!.extFam:=fam; SetCharacteristic(e,Characteristic(f)); SetDegreeOverPrimeField(e,DegreeOfLaurentPolynomial(p)*DegreeOverPrimeField(f)); SetIsFiniteDimensional(e,true); SetLeftActingDomain(e,f); SetGeneratorsOfField(e,[fam!.primitiveElm]); SetIsPrimeField(e,false); SetPrimitiveElement(e,fam!.primitiveElm); SetDefiningPolynomial(e,p); SetRootOfDefiningPolynomial(e,fam!.primitiveElm); if HasIsFinite(f) then if IsFinite(f) then SetIsFinite(e,true); if HasSize(f) then SetSize(e,Size(f)^fam!.deg); fi; else SetIsNumberField(e,true); SetIsFinite(e,false); SetSize(e,infinity); fi; fi; # AH: Noch VR-Eigenschaften! SetDimension( e, DegreeOverPrimeField( e ) ); SetOne(e,One(fam)); SetZero(e,Zero(fam)); fam!.wholeExtension:=e; return e; end; InstallMethod(AlgebraicExtension,"generic",true, [IsField,IsUnivariatePolynomial],0,DoAlgebraicExt); RedispatchOnCondition(AlgebraicExtension,true,[IsField,IsRationalFunction], [IsField,IsUnivariatePolynomial],0); InstallOtherMethod(AlgebraicExtension,"with name",true, [IsField,IsUnivariatePolynomial,IsString],0,DoAlgebraicExt); RedispatchOnCondition(AlgebraicExtension,true, [IsField,IsRationalFunction,IsString], [IsField,IsUnivariatePolynomial,IsString],0); ############################################################################# ## #M FieldExtension generically default on `AlgebraicExtension'. ## InstallMethod(FieldExtension,"generic",true, [IsField,IsUnivariatePolynomial],0,AlgebraicExtension); ############################################################################# ## #M PrintObj #M ViewObj ## InstallMethod( PrintObj, "for algebraic extension", true, [IsNumberField and IsAlgebraicExtension], 0, function( F ) Print( "" ); end ); InstallMethod( ViewObj, "for algebraic extension", true, [IsNumberField and IsAlgebraicExtension], 0, function( F ) Print("" ); end ); ############################################################################# ## #M ExtRepOfObj ## ## The external representation of an algebraic element is a coefficient ## list (in the primitive element) ## InstallMethod(ExtRepOfObj,"baseFieldElm",true, [IsAlgebraicElement and IsAlgBFRep],0, function(e) local f,l; f:=FamilyObj(e); l:=[e![1]]; while Length(l)i=fam!.zeroCoefficient) then e:=e[1]; elif Length(e)>fam!.deg then e:=e{[1..fam!.deg]}; fi; fi; return ObjByExtRep(fam,e); end); ############################################################################# ## #M PrintObj ## InstallMethod(PrintObj,"BFElm",true,[IsAlgBFRep],0, function(a) Print("!",String(a![1])); end); InstallMethod(PrintObj,"AlgElm",true,[IsAlgExtRep],0, function(a) local fam; fam:=FamilyObj(a); Print(StringUnivariateLaurent(fam,a![1],0,fam!.indeterminateName)); end); ############################################################################# ## #M String ## InstallMethod(String,"BFElm",true,[IsAlgBFRep],0, function(a) return Concatenation("!",String(a![1])); end); InstallMethod(String,"AlgElm",true,[IsAlgExtRep],0, function(a) local fam; fam:=FamilyObj(a); return StringUnivariateLaurent(fam,a![1],0,fam!.indeterminateName); end); ############################################################################# ## #M \+ for all combinations of A.E.Elms and base field elms. ## InstallMethod(\+,"AlgElm+AlgElm",IsIdenticalObj,[IsAlgExtRep,IsAlgExtRep],0, function(a,b) local e,i,fam; fam:=FamilyObj(a); e:=a![1]+b![1]; i:=2; while i<=fam!.deg do if e[i]<>fam!.zeroCoefficient then # still extension return Objectify(fam!.extType,[e]); fi; i:=i+1; od; return Objectify(fam!.baseType,[e[1]]); #return AlgExtElm(FamilyObj(a),a![1]+b![1]); end); InstallMethod(\+,"AlgElm+BFElm",IsIdenticalObj,[IsAlgExtRep,IsAlgBFRep],0, function(a,b) local fam; fam:=FamilyObj(a); a:=ShallowCopy(a![1]); a[1]:=a[1]+b![1]; return Objectify(fam!.extType,[a]); end); InstallMethod(\+,"BFElm+AlgElm",IsIdenticalObj,[IsAlgBFRep,IsAlgExtRep],0, function(a,b) local fam; fam:=FamilyObj(a); b:=ShallowCopy(b![1]); b[1]:=b[1]+a![1]; return Objectify(fam!.extType,[b]); #return ObjByExtRep(FamilyObj(a),b); end); InstallMethod(\+,"BFElm+BFElm",IsIdenticalObj,[IsAlgBFRep,IsAlgBFRep],0, function(a,b) local e,fam; fam:=FamilyObj(a); e:=a![1]+b![1]; return Objectify(fam!.baseType,[e]); #return ObjByExtRep(FamilyObj(a),a![1]+b![1]); end); InstallMethod(\+,"AlgElm+FElm",IsElmsCoeffs,[IsAlgExtRep,IsRingElement],0, function(a,b) local fam; fam:=FamilyObj(a); a:=ShallowCopy(a![1]); a[1]:=a[1]+(b*fam!.oneCoefficient); return Objectify(fam!.extType,[a]); #return ObjByExtRep(fam,a); end); InstallMethod(\+,"FElm+AlgElm",IsCoeffsElms,[IsRingElement,IsAlgExtRep],0, function(a,b) local fam; fam:=FamilyObj(b); b:=ShallowCopy(b![1]); b[1]:=b[1]+(a*fam!.oneCoefficient); return Objectify(fam!.extType,[b]); #return ObjByExtRep(fam,b); end); InstallMethod(\+,"BFElm+FElm",IsElmsCoeffs,[IsAlgBFRep,IsRingElement],0, function(a,b) local fam; fam:=FamilyObj(a); b:=a![1]+b; return Objectify(fam!.baseType,[b]); #return AlgExtElm(FamilyObj(a),b); end); InstallMethod(\+,"FElm+BFElm",IsCoeffsElms,[IsRingElement,IsAlgBFRep],0, function(a,b) local fam; fam:=FamilyObj(b); a:=b![1]+a; return Objectify(fam!.baseType,[a]); #return AlgExtElm(FamilyObj(b),a); end); ############################################################################# ## #M AdditiveInverseOp ## InstallMethod( AdditiveInverseOp, "AlgElm",true,[IsAlgExtRep],0, function(a) return Objectify(FamilyObj(a)!.extType,[-a![1]]); end); InstallMethod( AdditiveInverseOp, "BFElm",true,[IsAlgBFRep],0, function(a) return Objectify(FamilyObj(a)!.baseType,[-a![1]]); end); ############################################################################# ## #M \* for all combinations of A.E.Elms and base field elms. ## InstallMethod(\*,"AlgElm*AlgElm",IsIdenticalObj,[IsAlgExtRep,IsAlgExtRep],0, function(x,y) local fam,b,d,i; fam:=FamilyObj(x); b:=ProductCoeffs(x![1],y![1]); while Length(b)fam!.zeroCoefficient then # and whether the vector is too short. i:=Length(b)+1; while i<=fam!.deg do if not IsBound(b[i]) then b[i]:=fam!.zeroCoefficient; fi; i:=i+1; od; return Objectify(fam!.extType,[b]); fi; i:=i+1; od; return Objectify(fam!.baseType,[b[1]]); end); InstallMethod(\*,"AlgElm*BFElm",IsIdenticalObj,[IsAlgExtRep,IsAlgBFRep],0, function(a,b) if IsZero(b![1]) then return b; else a:=a![1]*b![1]; return Objectify(FamilyObj(b)!.extType,[a]); fi; end); InstallMethod(\*,"BFElm*AlgElm",IsIdenticalObj,[IsAlgBFRep,IsAlgExtRep],0, function(a,b) if IsZero(a![1]) then return a; else b:=b![1]*a![1]; return Objectify(FamilyObj(a)!.extType,[b]); fi; end); InstallMethod(\*,"BFElm*BFElm",IsIdenticalObj,[IsAlgBFRep,IsAlgBFRep],0, function(a,b) return Objectify(FamilyObj(a)!.baseType,[a![1]*b![1]]); end); InstallMethod(\*,"Alg*FElm",IsElmsCoeffs,[IsAlgebraicElement,IsRingElement],0, function(a,b) local fam; fam:=FamilyObj(a); b:=a![1]*(b*fam!.oneCoefficient); return AlgExtElm(fam,b); end); InstallMethod(\*,"FElm*Alg",IsCoeffsElms,[IsRingElement,IsAlgebraicElement],0, function(a,b) local fam; fam:=FamilyObj(b); a:=b![1]*(a*fam!.oneCoefficient); return AlgExtElm(fam,a); end); InstallOtherMethod(\*,"Alg*List",true,[IsAlgebraicElement,IsList],0, function(a,b) return List(b,i->a*i); end); InstallOtherMethod(\*,"List*Alg",true,[IsList,IsAlgebraicElement],0, function(a,b) return List(a,i->i*b); end); ############################################################################# ## #M InverseOp ## InstallMethod( InverseOp, "AlgElm",true,[IsAlgExtRep],0, function(a) local i,fam,f,g,t,h,rf,rg,rh,z; fam:=FamilyObj(a); f:=a![1]; g:=ShallowCopy(fam!.polCoeffs); rf:=[fam!.oneCoefficient]; z:=fam!.zeroCoefficient; rg:=[]; while g<>[] do t:=QuotRemPolList(f,g); h:=g; rh:=rg; g:=t[2]; if Length(t[1])=0 then rg:=[]; else rg:=ShallowCopy(-ProductCoeffs(t[1],rg)); fi; for i in [1..Length(rf)] do if IsBound(rg[i]) then rg[i]:=rg[i]+rf[i]; else rg[i]:=rf[i]; fi; od; f:=h; rf:=rh; ShrinkRowVector(g); #t:=Length(g); #while t>0 and g[t]=z do # Unbind(g[t]); # t:=t-1; #od; od; rf:=1/f[Length(f)]*rf; if fam!.rchar>0 then ConvertToVectorRep(rf,fam!.rchar); fi; return AlgExtElm(fam,rf); end); InstallMethod( InverseOp, "BFElm",true,[IsAlgBFRep],0, function(a) return ObjByExtRep(FamilyObj(a),Inverse(a![1])); end); ############################################################################# ## #M \< for all combinations of A.E.Elms and base field elms. ## Comparison is by the coefficient lists of the External ## representation. The base field is naturally embedded ## InstallMethod(\<,"AlgElma![1][i]=fam!.zeroCoefficient); else return false; fi; end); InstallMethod(\=,"BFElmb![1][i]=fam!.zeroCoefficient); else return false; fi; end); InstallMethod(\=,"BFElm=BFElm",IsIdenticalObj,[IsAlgBFRep,IsAlgBFRep],0, function(a,b) return a![1]=b![1]; end); InstallMethod(\=,"AlgElm=FElm",true,[IsAlgExtRep,IsRingElement],0, function(a,b) local fam; fam:=FamilyObj(a); # simulate comparison of lists if a![1][1]=b then return ForAll([2..fam!.deg],i->a![1][i]=fam!.zeroCoefficient); else return false; fi; end); InstallMethod(\=,"FElm=AlgElm",true,[IsRingElement,IsAlgExtRep],0, function(a,b) local fam; fam:=FamilyObj(b); # simulate comparison of lists if b![1][1]=a then return ForAll([2..fam!.deg],i->b![1][i]=fam!.zeroCoefficient); else return false; fi; end); InstallMethod(\=,"BFElm=FElm",true,[IsAlgBFRep,IsRingElement],0, function(a,b) return a![1]=b; end); InstallMethod(\=,"FElm=BFElm",true,[IsRingElement,IsAlgBFRep],0, function(a,b) return a=b![1]; end); InstallMethod(\mod,"AlgElm",IsElmsCoeffs,[IsAlgebraicElement,IsPosInt],0, function(a,m) return AlgExtElm(FamilyObj(a),List(ExtRepOfObj(a),i->i mod m)); end); ############################################################################# ## #M \in base field elements are considered to lie in the algebraic ## extension ## InstallMethod(\in,"Alg in Ext",true,[IsAlgebraicElement,IsAlgebraicExtension], 0, function(a,b) return FamilyObj(a)=b!.extFam; end); InstallMethod(\in,"FElm in Ext",true,[IsRingElement,IsAlgebraicExtension], 0, function(a,b) return a in b!.extFam!.baseField; end); ############################################################################# ## #M MinimalPolynomial ## InstallMethod(MinimalPolynomial,"AlgElm",true, [IsField,IsAlgebraicElement,IsPosInt],0, function(f,e,inum) local fam,c,m; fam:=FamilyObj(e); if ElementsFamily(FamilyObj(f))<>CoefficientsFamily(FamilyObj(e)) or fam!.baseField<>f then TryNextMethod(); fi; c:=One(e); m:=[]; repeat Add(m,ShallowCopy(ExtRepOfObj(c))); c:=c*e; until RankMat(m), )' is a polynomial with #T coefficients in , *not* the min. pol. of an element in #T with coefficients in `LeftActingDomain( )'. #T So the first argument will in general be `Rationals'! ############################################################################# ## #M CharacteristicPolynomial ## #InstallMethod(CharacteristicPolynomial,"Alg",true, # [IsAlgebraicExtension,IsScalar],0, #function(f,e) #local fam,p; # fam:=FamilyObj(One(f)); # p:=MinimalPolynomial(f,e); # return p^(fam!.deg/DegreeOfLaurentPolynomial(p)); #end); #T See the comment about `MinimalPolynomial' above! # ############################################################################# # ## # #M Trace # ## # InstallMethod(Trace,"Alg",true, # [IsAlgebraicExtension,IsScalar],0, # function(f,e) # local p; # p:=CharacteristicPolynomial(f,f,e); # p:=CoefficientsOfUnivariatePolynomial(p); # return -p[Length(p)-1]; # end); # # ############################################################################# # ## # #M Norm # ## # InstallMethod(Norm,"Alg",true, # [IsAlgebraicExtension,IsScalar],0, # function(f,e) # local p; # p:=CharacteristicPolynomial(f,f,e); # p:=CoefficientsOfUnivariatePolynomial(p); # return p[1]*(-1)^(Length(p)-1); # end); #T The above two installations are obsolete since now the default methods #T for `Trace' and `Norm' use `TracePolynomial'; #T the ``old'' default to use `Conjugates' is now restricted to the special #T case that the field has `IsFieldControlledByGaloisGroup'. ############################################################################# ## #M Random ## InstallMethod(Random,"Alg",true, [IsAlgebraicExtension],0, function(e) local fam,l; fam:=e!.extFam; l:=List([1..fam!.deg],i->Random(fam!.baseField)); if fam!.rchar>0 then ConvertToVectorRep(l,fam!.rchar); fi; return AlgExtElm(fam,l); end); ############################################################################# ## #F MaxNumeratorCoeffAlgElm() ## InstallMethod(MaxNumeratorCoeffAlgElm,"rational",true,[IsRat],0, function(e) return AbsInt(NumeratorRat(e)); end); InstallMethod(MaxNumeratorCoeffAlgElm,"algebraic element",true, [IsAlgebraicElement and IsAlgBFRep],0, function(e) return MaxNumeratorCoeffAlgElm(e![1]); end); InstallMethod(MaxNumeratorCoeffAlgElm,"algebraic element",true, [IsAlgebraicElement and IsAlgExtRep],0, function(e) return Maximum(List(e![1],MaxNumeratorCoeffAlgElm)); end); ############################################################################# ## ## Supply a canonical basis for algebraic extensions. ## (Subspaces of algebraic extensions could be easily handled via ## the nice/ugly vectors mechanism.) ## ############################################################################# ## #M Basis( ) ## InstallMethod( Basis, "for an algebraic extension (delegate to `CanonicalBasis')", [ IsAlgebraicExtension ], CANONICAL_BASIS_FLAGS, CanonicalBasis ); ############################################################################# ## #R IsCanonicalBasisAlgebraicExtension( ) ## DeclareRepresentation( "IsCanonicalBasisAlgebraicExtension", IsBasis and IsCanonicalBasis and IsAttributeStoringRep, [] ); ############################################################################# ## #M CanonicalBasis( ) . . . . . . . . . . . for algebraic extension ## ## The basis vectors are the first powers of the primitive element. ## InstallMethod( CanonicalBasis, "for an algebraic extension", true, [ IsAlgebraicExtension ], 0, function( F ) local B; B:= Objectify( NewType( FamilyObj( F ), IsCanonicalBasisAlgebraicExtension ), rec() ); SetUnderlyingLeftModule( B, F ); return B; end ); ############################################################################# ## #M BasisVectors( ) . . . . . . . . . . . . for canon. basis of alg. ext. ## InstallMethod( BasisVectors, "for canon. basis of an algebraic extension", [ IsCanonicalBasisAlgebraicExtension ], function( B ) local F; F:= UnderlyingLeftModule( B ); return List( [ 0 .. Dimension( F ) - 1 ], i -> PrimitiveElement( F )^i ); end ); ############################################################################# ## #M Coefficients( , ) . . . . . . . . . for canon. basis of alg. ext. ## InstallMethod( Coefficients, "for canon. basis of an algebraic extension, and alg. element", IsCollsElms, [ IsCanonicalBasisAlgebraicExtension, IsAlgebraicElement ], 0, function( B, v ) return ExtRepOfObj( v ); end ); InstallMethod( Coefficients, "for canon. basis of an algebraic extension, and scalar", true, [ IsCanonicalBasisAlgebraicExtension, IsScalar ], 0, function( B, v ) B:= UnderlyingLeftModule( B ); if v in LeftActingDomain( B ) then return Concatenation( [ v ], Zero( v ) * [ 1 .. Dimension( B )-1 ] ); else TryNextMethod(); fi; end ); ############################################################################# ## #M Characteristic( ) ## InstallMethod(Characteristic,"alg elm",true,[IsAlgebraicElement],0, function(e); return Characteristic(FamilyObj(e)!.baseField); end); ############################################################################# ## #M DefaultFieldByGenerators( ) ## InstallMethod(DefaultFieldByGenerators,"alg elms", [IsList and IsAlgebraicElementCollection],0, function(elms) local fam; if Length(elms)>0 then fam:=FamilyObj(elms[1]); if ForAll(elms,i->FamilyObj(i)=fam) then if IsBound(fam!.wholeExtension) then return fam!.wholeExtension; fi; fi; fi; TryNextMethod(); end); ############################################################################# ## #M DefaultFieldOfMatrixGroup( ) ## InstallMethod(DefaultFieldOfMatrixGroup,"alg elms", [IsGroup and IsAlgebraicElementCollCollColl and HasGeneratorsOfGroup],0, function(g) local l,f,i,j,k,gens; l:=GeneratorsOfGroup(g); if Length(l)=0 then l:=[One(g)]; fi; gens:=l[1][1]; f:=DefaultFieldByGenerators(gens); # ist row # are all elts in this? for i in l do for j in i do for k in j do if not k in f then gens:=Concatenation(gens,[k]); f:=DefaultFieldByGenerators(gens); fi; od; od; od; return f; end); InstallGlobalFunction(AlgExtEmbeddedPol,function(ext,pol) local f, cof; cof:=CoefficientsOfUnivariatePolynomial(pol); return UnivariatePolynomial(ext,cof*One(ext), IndeterminateNumberOfUnivariateRationalFunction(pol)); end); ############################################################################# ## #M FactorsSquarefree( , , ) ## ## The function uses Algorithm~3.6.4 in~\cite{Coh93}. ## (The record is ignored.) ## BindGlobal("AlgExtFactSQFree", function( R, U, opt ) local coeffring, basring, theta, xind, yind, x, y, coeffs, G, c, val, k, T, N, factors, i, j,xe,Re,one,kone; # Let $K = \Q(\theta)$ be a number field, # $T \in \Q[X]$ the minimal monic polynomial of $\theta$. # Let $U(X) be a monic squarefree polynomial in $K[x]$. coeffring:= CoefficientsRing( R ); one:=One(coeffring); basring:=LeftActingDomain(coeffring); theta:= PrimitiveElement( coeffring ); xind:= IndeterminateNumberOfUnivariateRationalFunction( U ); if xind = 1 then yind:= 2; else yind:= 1; fi; x:= Indeterminate( basring, xind ); xe:= Indeterminate( coeffring, xind ); y:= Indeterminate( basring, yind ); Re:=PolynomialRing(coeffring,[xind]); # Let $U(X) = \sum_{i=0}^m u_i X^i$ and write $u_i = g_i(\theta)$ # for some polynomial $g_i \in \Q[X]$. # Set $G(X,Y) = \sum_{i=0}^m g_i(Y) X^i \in \Q[X,Y]$. coeffs:= CoefficientsOfUnivariatePolynomial( U ); G:= Zero( basring ); for i in [ 1 .. Length( coeffs ) ] do if IsAlgBFRep( coeffs[i] ) then G:= G + coeffs[i]![1] * x^i; else c:= coeffs[i]![1]; val:= c[1]; for j in [ 2 .. Length( c ) ] do val:= val + c[j] * y^(j-1); od; G:= G + val * x^i; fi; od; # Set $k = 0$. k:= 0; # Compute $N(X) = R_Y( T(Y), G(X - kY,Y) )$ # where $R_Y$ denotes the resultant with respect to the variable $Y$. # If $N(X)$ is not squarefree, increase $k$. #T:= MinimalPolynomial( Rationals, theta, yind ); T:= CoefficientsOfUnivariatePolynomial(DefiningPolynomial(coeffring)); T:=UnivariatePolynomial(basring,T,yind); repeat k:= k+1; N:= Resultant( T, Value( G, [ x, y ], [ x-k*y, y ] ), y ); until DegreeOfUnivariateLaurentPolynomial( Gcd( N, Derivative(N) ) ) = 0; # Let $N = \prod_{i=1}^g N_i$ be a factorization of $N$. # For $1 \leq i \leq g$, set $A_i(X) = \gcd( U(X), N_i(X + k \theta) )$. # The desired factorization of $U(X)$ is $\prod_{i=1}^g A_i$. factors:= Factors( PolynomialRing( basring, [ xind ] ), N ); factors:= List( factors,f -> AlgExtEmbeddedPol(coeffring,f)); # over finite field alg ext we cannot multiply with Integers kone:=Zero(one); for j in [1..k] do kone:=kone+one; od; factors:= List( factors,f -> Value( f, xe + kone*theta ),one ); factors:= List( factors,f -> Gcd( Re, U, f ) ); factors:=Filtered( factors, x -> DegreeOfUnivariateLaurentPolynomial( x ) <> 0 ); if IsBound(opt.testirred) and opt.testirred=true then return Length(factors)=1; fi; return factors; end ); ############################################################################# ## #M DefectApproximation() ## InstallMethod(DefectApproximation,"Algebraic Extension",true, [IsAlgebraicExtension],0, function(e) local f, d, def, w, i, dr, g, g1, cf, f0, f1, h, p; if LeftActingDomain(e)<>Rationals then Error("DefectApproximation is only for extensions of the rationals"); fi; f:=DefiningPolynomial(e); f:=f*Lcm(List(CoefficientsOfUnivariatePolynomial(f),DenominatorRat)); d:=Discriminant(f); # largest square, that divides discriminant if d>=0 and RootInt(d)^2=d then def:=RootInt(d); else def:=Factors(AbsInt(d)); w:=[]; for i in def do if not IsPrimeInt(i) then i:=RootInt(i); Add(w,i); fi; Add(w,i); od; def:=Product(Collected(w),i->i[1]^QuoInt(i[2],2)); fi; # reduced discriminant (c.f. Bradford's thesis) dr:=Lcm(Union(List(GcdRepresentation(f,Derivative(f)), i->List(CoefficientsOfUnivariatePolynomial(i),DenominatorRat)))); def:=Gcd(def,dr); for p in Filtered(Factors(def),i->i<65536 and IsPrime(i)) do # test, whether we can drop i: ## Apply the Dedekind-Kriterion by Zassenhaus(1975), cf. Bradford's thesis. g:=Collected(Factors(PolynomialModP(f,p))); g1:=[]; for i in g do cf:=CoefficientsOfUnivariateLaurentPolynomial(i[1]); Add(g1,LaurentPolynomialByCoefficients(FamilyObj(1), List(cf[1],Int),cf[2], IndeterminateNumberOfLaurentPolynomial(i[1]))); od; f0:=Product(g1); f1:=Product(List([1..Length(g)],i->g1[i]^(g[i][2]-1))); h:=(f-f0*f1)/p; g:=Gcd(PolynomialModP(f1,p),PolynomialModP(h,p)); if DegreeOfLaurentPolynomial(g)=0 then while IsInt(def/p) do def:=def/p; od; fi; od; return def; end); ############################################################################# ## #F ChaNuPol(,,,, . reverse modulo ## transfer pol from modfield with alg. root alphamod to field with ## alg. root alpha by taking the standard preimages of the coefficients ## mod p ## BindGlobal("ChaNuPol",function(f,alm,alz,coeffun,fam,inum) local b,p,r,nu,w,i,z,fnew; p:=Characteristic(alm); z:=Z(p); r:=PrimitiveRootMod(p); nu:=0*alm; b:=IsPolynomial(f); if b then f:=CoefficientsOfUnivariateLaurentPolynomial(f); f:=ShiftedCoeffs(f[1],f[2]); else f:=[f]; fi; fnew:=[]; # f could be compressed vector, so we cannot assign to it. for i in [1..Length(f)] do w:=f[i]; if w=nu then w:=Zero(alz); else if IsFFE(w) and DegreeFFE(w)=1 then w:=PowerModInt(r,LogFFE(w,z),p)*One(alz); else w:=ValuePol(List(coeffun(w),IntFFE),alz); fi; fi; #f[i]:=w; fnew[i]:=w; od; return UnivariatePolynomialByCoefficients(fam,fnew,inum); end); ############################################################################# ## #F AlgebraicPolynomialModP(,,,) . . internal ## reduces mod to a polynomial over , mapping ## 'alpha' of f to ## BindGlobal("AlgebraicPolynomialModP",function(fam,f,a,p) local fk, w, cf, i, j; fk:=[]; for i in CoefficientsOfUnivariatePolynomial(f) do if IsRat(i) then Add(fk,One(fam)*(i mod p)); else w:=Zero(fam); cf:=ExtRepOfObj(i); for j in [1..Length(cf)] do w:=w+(cf[j] mod p)*a^(j-1); od; Add(fk,w); fi; od; return UnivariatePolynomialByCoefficients(fam,fk, IndeterminateNumberOfUnivariateLaurentPolynomial(f)); end); ############################################################################# ## #F AlgFacUPrep( ) . . . . Hensel preparation: f=\prod ff, \sum h_i u_i=1 ## BindGlobal("AlgFacUPrep",function(R,f) local ff,h,u,i,j,ggt,ggr; h:=[]; ff:=Factors(R,f); for i in [1..Length(ff)] do h[i]:=f/ff[i]; od; u:=[One(CoefficientsFamily(FamilyObj(f)))]; ggt:=h[1]; for i in [2..Length(ff)] do ggr:=GcdRepresentation(ggt,h[i]); ggt:=Gcd(ggt,h[i]); for j in [1..i-1] do u[j]:=u[j]*ggr[1]; od; u[i]:=ggr[2]; od; return u; end); ############################################################################# ## #F TransferedExtensionPol(,[,]) ## interpret polynomial over different algebraic extension. If minpol ## is given, the algebraic elements are reduced according to minpol. ## BindGlobal("TransferedExtensionPol",function(arg) local atc, kl, inum, alfam, red, c, operations, i; atc:=CoefficientsOfUnivariateLaurentPolynomial(arg[2]); kl:=ShallowCopy(atc[1]); inum:=arg[Length(arg)]; alfam:=ElementsFamily(FamilyObj(arg[1])); if Length(arg)>3 then red:=CoefficientsOfUnivariatePolynomial(arg[3]); # Rational case, reduce according to Minpol for i in [1..Length(kl)] do if IsAlgebraicElement(kl[i]) then #c:=RemainderCoeffs(kl[i].coefficients,red); c:=QuotRemPolList(ExtRepOfObj(kl[i]),red)[2]; if Length(red)=2 then kl[i]:=c[1]; else while Length(c),) ## BindGlobal("OrthogonalityDefectEuclideanLattice",function(bas) return AbsInt(Product(List(bas,i->RootInt(i*i,2)+1))/ DeterminantMat(bas)); end); ############################################################################# ## ## AlgExtSquareHensel( , ) hensel factorization over alg. ## extension. Suppose f is squarefree, has valuation 0 ## Lenstra's or Weinberger's method ## InstallGlobalFunction(AlgExtSquareHensel,function(R,f,opt) local K, inum, fact, degf, m, degm, dis, def, cf, d, avoid, bw, zaehl, p, mm, pr, mmf, nm, dm, al, kp, ff, i, gut, w, bp, bpr, bff, bkp, bal, bmm, kpcoeffun, fff, degs, bounds, numbound, yet, ordef, lenstra, weinberger, method, pex, actli, lbound, U, u, rfunfam, ext, fam, q, max, M, newq, a, ef, bound, Mi, ind, perm, alfam, dl, sel, act, len, degsm, comb, v, dd, cbn, l, ps, z, wc, j, k,methname; K:=CoefficientsRing(R); inum:=IndeterminateNumberOfUnivariateLaurentPolynomial(f); fact:=[]; degf:=DegreeOfLaurentPolynomial(f); m:=DefiningPolynomial(K); if IndeterminateNumberOfUnivariateLaurentPolynomial(m)<>inum then m:=Value(m,Indeterminate(LeftActingDomain(K),inum)); fi; degm:=DegreeOfLaurentPolynomial(m); dis:=Discriminant(m); def:=DefectApproximation(K); # find lcm of Denominators cf:=CoefficientsOfUnivariateLaurentPolynomial(f)[1]; d:=Lcm(Concatenation(Flat(List(cf,i->List(ExtRepOfObj(i),DenominatorRat))), List(CoefficientsOfUnivariateLaurentPolynomial(m)[1],DenominatorRat))); # find prime which does not divide the denominator and minpol is sqarefree # mod p. This is obviously satisfied, if we take d to be the Lcm of # the denominators and the discriminant avoid:=Lcm(d,dis*DenominatorRat(dis)^2,def); bw:="infinity"; zaehl:=1; p:=1; repeat p:=NextPrimeInt(p); while DenominatorRat(avoid/p)=1 do p:=NextPrimeInt(p); od; mm:=PolynomialModP(m,p); pr:=PolynomialRing(GF(p),[inum]); mmf:=Factors(pr,mm); nm:=Length(mmf); Sort(mmf,function(a,b) return DegreeOfLaurentPolynomial(a)>DegreeOfLaurentPolynomial(b); end); dm:=List(mmf,DegreeOfLaurentPolynomial); if dm[1]>1 # don't even risk problems with the @#$%&! valuation! and ForAll(mmf,i->CoefficientsOfUnivariateLaurentPolynomial(i)[2]=0) then al:=[]; kp:=[]; ff:=[]; i:=1; gut:=true; while gut and i<=nm do # cope with the too small range of finite fields in GAP if p^DegreeOfLaurentPolynomial(mmf[i])<=65536 then kp[i]:=GF(GF(p),CoefficientsOfUnivariatePolynomial(mmf[i])); if DegreeOfLaurentPolynomial(mmf[i])>1 then al[i]:=RootOfDefiningPolynomial(kp[i]); else al[i]:=CoefficientsOfUnivariateLaurentPolynomial(-mmf[i])[1][1]; fi; kp[i]!.myBasis:=Basis(kp[i],List([0..DegreeOfLaurentPolynomial(mmf[i])-1],j->al[i]^j)); kp[i]!.myCoeffun:=x->Coefficients(kp[i]!.myBasis,x); elif (IsRat(bw) and Length(Factors(bpr,bmm))=1 and zaehl>2) then # avoid our extensions if not necc. gut:=false; zaehl:=zaehl+1; else kp[i]:=AlgebraicExtension(GF(p),mmf[i]); al[i]:=RootOfDefiningPolynomial(kp[i]); kp[i]!.myCoeffun:=ExtRepOfObj; fi; if gut<>false then ff[i]:=AlgebraicPolynomialModP(ElementsFamily(FamilyObj(kp[i])),f,al[i],p); gut:=DegreeOfLaurentPolynomial(Gcd(ff[i],Derivative(ff[i])))<1; i:=i+1; fi; od; if gut then Info(InfoPoly,2,"trying prime ",p,": ",nm," factors of minpol, ", Length(Factors(PolynomialRing(kp[1]),ff[1]))," factors"); # Wert ist Produkt der Cofaktorgrade des Polynoms (wir wollen # m"oglichst wenig gro"se Faktoren haben) sowie des # Kofaktorgrades des Minimalpolynoms (wir wollen bereits # akzeptabel approximieren) im Kubik (da es dominieren soll). w:=(degm/dm[1])^3* Product(List(Factors(PolynomialRing(kp[1]),ff[1]),i->DegreeOfLaurentPolynomial(f)-DegreeOfLaurentPolynomial(i))); if wi!.myCoeffun); al:=bal; mm:=bmm; mmf:=Factors(bpr,mm); #is stored in pol nm:=Length(mmf); dm:=List(mmf,DegreeOfLaurentPolynomial); # multiply denominator by defect to be sure, that \Z[\alpha] includes the # algebraic integers to obtain 'result' denominator d:=d*def; fff:=List([1..Length(ff)],i->Factors(PolynomialRing(bkp[i]),ff[i])); Info(InfoPoly,1,"using prime ",p,": ",nm," factors of minpol, ", List(fff,Length)," factors"); # check possible Degrees degs:=Intersection(List(fff,i->List(Combinations(List(i,DegreeOfLaurentPolynomial)),Sum))); degs:=Difference(degs,[0]); degs:=Filtered(degs,i->2*i<=degf); IsRange(degs); Info(InfoPoly,1,"possible degrees: ",degs); # are we lucky? if Length(degs)>0 then bounds:=HenselBound(f,m,d); numbound:=bounds[Maximum(degs)]; Info(InfoPoly,1,"Bound for factor coefficients coefficients is:",numbound); # first suppose we get the lattice reduced to orthogonality defect 2 yet:=0; ordef:=3; if IsBound(opt.ordef) then ordef:=opt.ordef;fi; #NOCH: verwende bessere beim zweiten mal bereits bekanntes # geliftes # compute bounds and select method lenstra:=1; weinberger:=2; methname:=["Lenstra","Weinberger"]; method:=weinberger; pex:=LogInt(2*numbound-1,p)+1; actli:=[1..nm]; if nm>1 then w:=CoefficientsOfUnivariatePolynomial(m); lbound:= # obere Absch"atzung f"ur ||F||^(m-1) (w*w)^(Maximum(degs)-1) *(2*numbound)^degf; w:=Int(lbound*ordef^degf)+1; if LogInt(w,10)<800 then method:=lenstra; pex:=LogInt(w-1,p)+1-dm[1]; actli:=[1]; fi; fi; Info(InfoPoly,1,"using method ",methname[method]); # prep U for mm Hensel U:=AlgFacUPrep(bpr,mm); #Assert(1,ForAll(U,i->IndeterminateNumberOfUnivariateLaurentPolynomial(i)=inum)); # prepare u for ff Hensel u:=List([1..Length(ff)],i->AlgFacUPrep(PolynomialRing(bkp[i]),ff[i])); # alles in Charakteristik 0 transportieren Info(InfoPoly,1,"transporting in characteristic zero"); rfunfam:=RationalFunctionsFamily(FamilyObj(1)); for i in [1..nm] do if IsPolynomial(mmf[i]) then cf:=CoefficientsOfUnivariateLaurentPolynomial(mmf[i]); mmf[i]:=LaurentPolynomialByExtRepNC(rfunfam,List(cf[1],Int),cf[2],inum); else mmf[i]:=Int(mmf[i]); fi; if IsPolynomial(U[i]) then cf:=CoefficientsOfUnivariateLaurentPolynomial(U[i]); U[i]:=LaurentPolynomialByExtRepNC(rfunfam, List(cf[1],Int),cf[2],inum); else U[i]:=Int(U[i]); fi; #Assert(1,ForAll(U,i->IndeterminateNumberOfUnivariateLaurentPolynomial(i)=inum)); od; # dabei repr"asentieren wir die Wurzel \alpha als alg. Erweiterung mit # dem entsprechenden Polynom als Minpol. ext:=[]; for i in actli do if EuclideanDegree(mmf[i])>1 then ext[i]:=AlgebraicExtension(Rationals,mmf[i]); else ext[i]:=Rationals; fi; if DegreeOverPrimeField(ext[i])>1 then w:=RootOfDefiningPolynomial(ext[i]); else w:=One(ext[i]); fi; fam:=ElementsFamily(FamilyObj(ext[i])); fff[i]:=List(fff[i],j->ChaNuPol(j,al[i],w,kpcoeffun[i],fam,inum)); u[i]:=List(u[i],j->ChaNuPol(j,al[i],w,kpcoeffun[i],fam,inum)); od; repeat # jetzt hochHenseln q:=p^(2^yet); # how many square iterations needed for bound (the p-exponent)? max:=p^pex; M:=LogInt(pex-1,2)+1; pex:=2^M; # the new pex Info(InfoPoly,1,M," quadratic steps necessary"); for i in [1..M-yet] do # now lift q->q^2 (or appropriate smaller number) # avoid modulus too large, since the computation afterwards becomes # harder if method=lenstra then newq:=q^2; # we might need the better lift. else newq:=Minimum(q^2,max); fi; Info(InfoPoly,1,"quadratic Hensel Lifting, step ",i,", ",q,"->",newq); if Length(mmf)>1 then # more than 1 factor: actual lift necessary if i>1 then # now lift the U's Info(InfoPoly,2,"correcting U-inverses"); for j in [1..nm] do a:=ProductMod(mmf{Difference([1..nm],[j])},q) mod mmf[j] mod q; U[j]:=BPolyProd(U[j], (2-APolyProd(U[j],a,q)), mmf[j], q); #Assert(1,ForAll(U,i->IndeterminateNumberOfUnivariateLaurentPolynomial(i)=inum)); #a:=a*U[j] mod mmf[j] mod q; #if a<>a^0 then #Error("U-rez"); #fi; od; fi; for j in [1..nm] do a:=(m mod mmf[j] mod newq); if IsPolynomial(a) and IsPolynomial(U[j]) then mmf[j]:=mmf[j]+BPolyProd(U[j],a,mmf[j],newq); else mmf[j]:=mmf[j]+(U[j]*a mod mmf[j] mod newq); fi; od; #a:=(m-ProductMod(mmf,newq)) mod newq; #InfoAlg2("#I new F-discrepancy mod ",p,"^",2^i," is ",a, #"(should be 0)\n"); #if a<>0*a then #Error("uh-oh"); #fi; else mmf:=[m mod newq]; fi; # transport fff etc. into the new (lifted) extension fields ef:=[]; for k in actli do ext[k]:=AlgebraicExtension(Rationals,mmf[k]); # also to provoke the binding of the Ring w:=Indeterminate(ext[k],"X"); for j in [1..Length(fff[k])] do fff[k][j]:=TransferedExtensionPol(ext[k],fff[k][j],inum); u[k][j]:=TransferedExtensionPol(ext[k],u[k][j],inum); od; ef[k]:=TransferedExtensionPol(ext[k],f,mmf[k],inum); od; # lift u's if i>1 then Info(InfoPoly,2,"correcting u-inverses"); for k in actli do for j in [1..Length(u[k])] do a:=ProductMod(fff[k]{Difference([1..Length(u[k])],[j])},q) mod fff[k][j] mod q; u[k][j]:=BPolyProd(u[k][j],(2-APolyProd(a,u[k][j],q)), fff[k][j],q); #a:=a*u[k][j] mod fff[k][j] mod q; #if a<>a^0 then # Error("u-rez"); #fi; od; od; fi; for k in actli do for j in [1..Length(fff[k])] do a:=(ef[k] mod fff[k][j] mod newq); fff[k][j]:=fff[k][j]+BPolyProd(u[k][j],a,fff[k][j],newq) mod newq; od; #a:=(ef[k]-ProductMod(fff[k],newq)) mod newq; #InfoAlg2("#I new discrepancy mod ",p,"^",2^i," is ",a, #"(should be 0)\n"); #if a<>0*a then #Error("uh-oh"); #fi; od; # now all is fine mod newq; q:=newq; od; yet:=M; bound:=q/2; if method=lenstra then # prepare Lattice for mmf[1] M:=[]; for i in [0..dm[1]-1] do M[i+1]:=0*[1..degm]; M[i+1][i+1]:=p^pex; od; for i in [dm[1]..degm-1] do cf:=CoefficientsOfUnivariateLaurentPolynomial(mmf[1]); M[i+1]:=ShiftedCoeffs(cf[1], cf[2]+i-dm[1]); while Length(M[i+1])ordef and a>pex then Info(InfoWarning,1,"'ordef' was set too small, iterating"); ordef:=Maximum(w,ordef+1); # call again opt:=ShallowCopy(opt); opt.ordef:=ordef; return AlgExtSquareHensel(R,f,opt); else ordef:=Int(w)+1; fi; elif method=weinberger then w:=ordef-1; # to skip the loop fi; until w<=ordef; if method=lenstra then M:=TransposedMat(M); Mi:=M^(-1); elif method=weinberger then # Prepare for Chinese remainder if Length(mmf)>1 then U:=[]; for i in [1..nm] do a:=ProductMod(mmf{Difference([1..nm],[i])},q); U[i]:=a*(GcdRepresentation(mmf[i],a)[2] mod q) mod q; #Assert(1,ForAll(U,i->IndeterminateNumberOfUnivariateLaurentPolynomial(i)=inum)); od; else U:=[Indeterminate(Rationals,inum)^0]; fi; # sort according to the number of factors: # Our 'starting' factorisation is the one with the fewest factors, # because this one allows the fewest number of combinations. ind:=[1..nm]; Sort(ind,function(a,b) return Length(fff[a])DegreeOfLaurentPolynomial(b); end); od; fi; al:=RootOfDefiningPolynomial(K); alfam:=ElementsFamily(FamilyObj(K)); # now the hard part starts: We try all possible combinations, whether # they factor. dl:=[]; sel:=[]; for k in actli do # 'available' factors (not yet used up) sel[k]:=[1..Length(fff[k])]; dl[k]:=List(fff[k],DegreeOfLaurentPolynomial); Info(InfoPoly,1,"Degrees[",k,"] :",dl[k]); od; act:=1; len:=0; dm:=[]; for i in actli do dm[i]:=List(fff[i],DegreeOfLaurentPolynomial); od; repeat # factors of larger than half remaining degree we will find as # final cofactor degf:=DegreeOfLaurentPolynomial(f); degs:=Filtered(degs,i->2*i<=degf); if Length(degs)>0 and act in sel[1] then # all combinations of sel[1] of length len+1, that contain act: degsm:=degs-dm[1][act]; comb:=Filtered(Combinations(Filtered(sel[1],i->i>act),len), i->Sum(dm[1]{i}) in degsm); # sort according to degree Sort(comb,function(a,b) return Sum(dm[1]{a})Union([act],i)); gut:=true; i:=1; while gut and i<=Length(comb) do Info(InfoPoly,2,"trying ",comb[i]); if method=lenstra then a:=d*ProductMod(fff[1]{comb[i]},q) mod q; a:=CoefficientsOfUnivariatePolynomial(a); v:=[]; for j in a do if IsAlgebraicElement(j) then w:=ShallowCopy(ExtRepOfObj(j)); else w:=[j]; fi; while Length(w)Mi*i); w:=List(w,i->List(i,j->SignInt(j)*Int(AbsInt(j)+1/2))); w:=List(w,i->M*i); v:=(v-w)/d; a:=UnivariatePolynomialByCoefficients(alfam, List(v,i->AlgExtElm(alfam,i)),inum); #Print(a,"\n"); w:=TrialQuotientRPF(f,a,bounds); if w<>fail then Info(InfoPoly,1,"factor found"); f:=w; Add(fact,a); sel[1]:=Difference(sel[1],comb[i]); #fff[1]:=fff[1]{Difference([1..Length(fff[1])],comb[i])}; gut:=false; fi; elif method=weinberger then # now select all other combinations of same degree dd:=Sum(dl[1]{comb[i]}); #NOCH: Combinations nach Grad ordnen. Nur neue listen #bestimmen, wenn der Grad sich ge"andert hat. cbn:=[comb{[i]}]; for j in [2..nm] do # all combs in component nm of desired degree cbn[j]:=Concatenation(List([1..QuoInt(dd,Minimum(dl[j]))], i->Filtered(Combinations(sel[j],i), i->Sum(dl[j]{i})=dd))); od; if ForAny(cbn,i->Length(i)=0) then gut:=false; else l:=List([1..nm],i->1); # the great variable for-Loop #ff:=List([1..nm],i->ProductMod(fff[i]{cbn[i][1]},q).coefficients); ff:=List([1..nm],i->CoefficientsOfUnivariatePolynomial(ProductMod(fff[i]{cbn[i][1]},q))); fi; ps:=nm; while gut and ps>=1 do a:=[]; for j in [1..dd+1] do w:=0; for k in [1..nm] do z:=ff[k][j]; if IsAlgebraicElement(z) then z:=UnivariatePolynomial(Rationals, ExtRepOfObj(z),inum); fi; w:=w+U[k]*z mod m mod q; od; w:=d*w mod m mod q; wc:=ShallowCopy(CoefficientsOfUnivariatePolynomial(w)); for k in [1..Length(wc)] do if wc[k]>q/2 then wc[k]:=wc[k]-q; fi; od; w:=UnivariateLaurentPolynomialByCoefficients( CoefficientsFamily(FamilyObj(w)), wc,0,IndeterminateNumberOfUnivariateLaurentPolynomial(w)); a[j]:=1/d*Value(w,al); od; # now try the Factor a:=UnivariateLaurentPolynomialByCoefficients(alfam,a,0,inum); Info(InfoPoly,3,"trying subcombination ", List([2..nm],i->cbn[i][l[i]])); w:=TrialQuotientRPF(f,a,bounds); if w<>fail then Info(InfoPoly,1,"factor found"); Add(fact,a); for j in [1..nm] do sel[j]:=Difference(sel[j],cbn[j][l[j]]); od; f:=w; gut:=false; fi; # increase and update factors while ps>1 and l[ps]=Length(cbn[ps]) do l[ps]:=1; a:=ProductMod(fff[ps]{cbn[ps][1]},q); ff[ps]:=CoefficientsOfUnivariateLaurentPolynomial(a)[1]; ps:=ps-1; od; if ps>1 then l[ps]:=l[ps]+1; a:=ProductMod(fff[ps]{cbn[ps][l[ps]]},q); ff[ps]:=CoefficientsOfUnivariateLaurentPolynomial(a)[1]; fi; if ps>1 then ps:=nm; else ps:=0; fi; od; fi; i:=i+1; od; if comb=[] then i:=0; else # the len minimal lengths i:=ShallowCopy(dm[1]); Sort(i); i:=Sum(i{[1..Minimum(Length(i),len)]}); fi; if gut and dm[1][act]+i>=Maximum(degs) then # the actual factor will always yield factors too large, thus we # can avoid it furthermore Info(InfoPoly,2,"factor ",act," can be further neglected"); sel[1]:=Difference(sel[1],[act]); gut:=false; fi; fi; act:=act+1; if sel[1]<>[] and act>Maximum(sel[1]) then len:=len+1; act:=sel[1][1]; fi; until ForAny(sel,i->Length(i)=0) or Length(sel[1])f^0 then Add(fact,f); fi; return fact; end); InstallMethod( FactorsSquarefree, "polynomial/alg. ext.",IsCollsElmsX, [ IsAlgebraicExtensionPolynomialRing, IsUnivariatePolynomial, IsRecord ], function(r,pol,opt) if (Characteristic(r)=0 and DegreeOverPrimeField(CoefficientsRing(r))<=4 and DegreeOfLaurentPolynomial(pol) *DegreeOverPrimeField(CoefficientsRing(r))<=20) or Characteristic(r)>0 then return AlgExtFactSQFree(r,pol,opt); else return AlgExtSquareHensel(r,pol,opt); fi; end); ############################################################################# ## #M Factors( , ) . for a polynomial over a field of cyclotomics ## InstallMethod( Factors,"alg ext polynomial",IsCollsElms, [IsAlgebraicExtensionPolynomialRing,IsUnivariatePolynomial],0, function(R,pol) local opt,irrfacs, coeffring, i, factors, ind, coeffs, val, lc, der, g, factor, q; opt:=ValueOption("factoroptions"); PushOptions(rec(factoroptions:=rec())); # options do not hold for # subsequent factorizations if opt=fail then opt:=rec(); fi; # Check whether the desired factorization is already stored. irrfacs:= IrrFacsPol( pol ); coeffring:= CoefficientsRing( R ); i:= PositionProperty( irrfacs, pair -> pair[1] = coeffring ); if i <> fail then PopOptions(); return ShallowCopy(irrfacs[i][2]); fi; # Handle (at most) linear polynomials. if DegreeOfLaurentPolynomial( pol ) < 2 then factors:= [ pol ]; StoreFactorsPol( coeffring, pol, factors ); PopOptions(); return factors; fi; # Compute the valuation, split off the indeterminate as a zero. ind:= IndeterminateNumberOfLaurentPolynomial( pol ); coeffs:= CoefficientsOfLaurentPolynomial( pol ); val:= coeffs[2]; coeffs:= coeffs[1]; factors:= ListWithIdenticalEntries( val, IndeterminateOfUnivariateRationalFunction( pol ) ); if Length( coeffs ) = 1 then # The polynomial is a power of the indeterminate. factors[1]:= coeffs[1] * factors[1]; StoreFactorsPol( coeffring, pol, factors ); PopOptions(); return factors; elif Length( coeffs ) = 2 then # The polynomial is a linear polynomial times a power of the indet. factors[1]:= coeffs[2] * factors[1]; factors[ val+1 ]:= LaurentPolynomialByExtRepNC( FamilyObj( pol ), [coeffs[1] / coeffs[2], One(coeffring)],0,ind ); StoreFactorsPol( coeffring, pol, factors ); PopOptions(); return factors; fi; # We really have to compute the factorization. # First split the polynomial into leading coefficient and monic part. lc:= coeffs[ Length( coeffs ) ]; if not IsOne( lc ) then coeffs:= coeffs / lc; fi; if val = 0 then pol:= pol / lc; else pol:= LaurentPolynomialByExtRepNC( FamilyObj( pol ), coeffs, 0, ind ); fi; # Now compute the quotient of `pol' by the g.c.d. with its derivative, # and factorize the squarefree part. der:= Derivative( pol ); g:= Gcd( R, pol, der ); if DegreeOfLaurentPolynomial( g ) = 0 then Append( factors, FactorsSquarefree( R, pol, rec() ) ); else for factor in FactorsSquarefree( R, Quotient( R, pol, g ), opt ) do Add( factors, factor ); q:= Quotient( R, g, factor ); while q <> fail do Add( factors, factor ); g:= q; q:= Quotient( R, g, factor ); od; od; fi; # Adjust the first factor by the constant term. Assert( 2, DegreeOfLaurentPolynomial(g) = 0 ); if not IsOne( g ) then lc:= g * lc; fi; if not IsOne( lc ) then factors[1]:= lc * factors[1]; fi; # Store the factorization. if not IsBound(opt.stopdegs) then Assert( 2, Product( factors ) = pol ); StoreFactorsPol( coeffring, pol, factors ); fi; # Return the factorization. PopOptions(); return factors; end ); ############################################################################# ## #M IsIrreducibleRingElement() ## InstallMethod(IsIrreducibleRingElement,"AlgPol",true, [IsAlgebraicExtensionPolynomialRing,IsUnivariatePolynomial],0, function(R,pol) local irrfacs, coeffring, i, ind, coeffs, der, g; # Check whether the desired factorization is already stored. irrfacs:= IrrFacsPol( pol ); coeffring:= CoefficientsRing( R ); i:= PositionProperty( irrfacs, pair -> pair[1] = coeffring ); if i <> fail then return Length(irrfacs[i][2])=1; fi; # Handle (at most) linear polynomials. if DegreeOfLaurentPolynomial( pol ) < 2 then return true; fi; ind:= IndeterminateNumberOfLaurentPolynomial( pol ); coeffs:= CoefficientsOfLaurentPolynomial( pol ); if coeffs[2]>0 then return false; fi; # Now compute the quotient of `pol' by the g.c.d. with its derivative, # and factorize the squarefree part. der:= Derivative( pol ); g:= Gcd( R, pol, der ); if DegreeOfLaurentPolynomial( g ) = 0 then return AlgExtFactSQFree( R, pol, rec(testirred:=true)); else return false; fi; end); ############################################################################# ## #E gap-4r6p5/lib/utils.gd0000644000175000017500000003131112172557254013364 0ustar billbill############################################################################# ## #W utils.gd GAP Library Gene Cooperman #W and Scott Murray ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1999 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This is a temporary file containing utilities for group chains. ## ############################################################################# ############################################################################# ## ## General ## ############################################################################# ############################################################################# ############################################################################# ## #F UseSubsetRelationNC( , ) ## ## This would be a useful GAP fnc. For UseSubsetRelation, ## GAP currently requires: FAMILY PREDICATE: IS_IDENTICAL_OBJ ## DeclareGlobalFunction( "UseSubsetRelationNC", [ IsCollection, IsCollection ] ); ############################################################################# ## #O ImageUnderWord( , , , ) ## DeclareOperation( "ImageUnderWord", [ IsList, IsWordWithInverse, IsList, IsGroupHomomorphism ] ); ############################################################################# ## #O ImageUnderWord( , , , ) ## ## The image of under evaluated in the orbit generators. ## DeclareOperation( "ImageUnderWord", [ IsInt, IsWordWithInverse, IsList, IsGroupHomomorphism ] ); ############################################################################# ############################################################################# ## ## Matrices and vectors ## ############################################################################# ############################################################################# ############################################################################# ## #A UnderlyingVectorSpace( ) ## ## Underlying vector space of an algebra. ## DeclareAttribute( "UnderlyingVectorSpace", IsAlgebra ); ############################################################################# ## #A UnderlyingVectorSpace( ) ## ## Underlying vector space of a matrix group. ## DeclareAttribute( "UnderlyingVectorSpace", IsFFEMatrixGroup ); ############################################################################# ## #A UnderlyingVectorSpace( ) ## ## Underlying vector space of a matrix??? ## DeclareAttribute( "UnderlyingVectorSpace", IsMatrix ); ############################################################################# ## #O FixedPointSpace( ) ## ## The fixed point space of a matrix. ## DeclareOperation( "FixedPointSpace", [ IsMatrix ] ); ############################################################################# ## #O PermMatrixGroup( ) ## ## Convert a permutation group to a group of permutation matrices over GF(2). ## DeclareOperation( "PermMatrixGroup", [ IsPermGroup ] ); ############################################################################# ## #O EnvelopingAlgebra( ) ## ## The enveloping algebra of a matrix group. ## DeclareOperation( "EnvelopingAlgebra", [ IsFFEMatrixGroup ] ); ############################################################################# ## #O SpanOfMatrixGroup( ) ## ## The vector space span of a matrix group. ## DeclareOperation( "SpanOfMatrixGroup", [ IsFFEMatrixGroup ] ); ############################################################################# ## #P IsUniformMatrixGroup( ) ## ## Matrix group is uniform if fixed point space of every element ## is either the trivial space or the entire space. ## DeclareProperty( "IsUniformMatrixGroup", IsFFEMatrixGroup ); ############################################################################# ## #A PreBasis( ) ## ## Basis for the source of , such that the images of the elements ## are in the basis for the range. ## DeclareAttribute( "PreBasis", IsVectorSpaceHomomorphism ); ############################################################################# ## #F Pullback( , ) ## ## Image(H, PullBack( H, v )) = v; # => true; ## DeclareGlobalFunction( "PullBack", [ IsVectorSpaceHomomorphism, IsVector ] ); ############################################################################# ## #F ImageMat( , ) ## ## v := Random(Source(H)); A := Random(G); ## Image(H, v)^ImageMat( H, A ) = Image(H, v^A); # => true ## DeclareGlobalFunction( "ImageMat", [ IsVectorSpaceHomomorphism, IsMatrix ] ); ############################################################################# ## #F ExtendToBasis( , ) ## ## Extend to a basis. ## DeclareGlobalFunction( "ExtendToBasis", [ IsVectorSpace, IsList ] ); ############################################################################# ## #F ProjectionOntoVectorSubspace( , ) ## ## Returns the projection of onto ## DeclareGlobalFunction( "ProjectionOntoVectorSubspace", [ IsVectorSpace, IsVectorSpace ] ); ############################################################################# ## #F IsomorphismToFullRowSpace( ) ## ## Returns the isomorphism from to the appropriate row space. ## DeclareGlobalFunction( "IsomorphismToFullRowSpace", [ IsVectorSpace ] ); ############################################################################# ## #F ProjectionOntoFullRowSpace( , ) ## ## Returns the projection from onto a full row space isomorphic to . ## DeclareGlobalFunction( "ProjectionOntoFullRowSpace", [ IsVectorSpace, IsVectorSpace ] ); ############################################################################# ############################################################################# ## ## Groups ## ############################################################################# ############################################################################# ############################################################################# ## #F RandomSubprod( ) ## ## Returns a random subproduct of the generators of . ## DeclareGlobalFunction( "RandomSubprod", [ IsGroup, IsVectorSpace ] ); ############################################################################# ## #F RandomNormalSubproduct( , ) ## ## Returns a random normal subproduct. ## DeclareGlobalFunction( "RandomNormalSubproduct", [ IsGroup, IsGroup ] ); ############################################################################# ## #F RandomCommutatorSubproduct( , ) ## ## Returns a random commutator subproduct. ## DeclareGlobalFunction( "RandomCommutatorSubproduct", [ IsGroup, IsGroup ] ); ############################################################################# ## #P IsCharacteristicMatrixPGroup( ) #P IsNoncharacteristicMatrixPGroup( ) ## ## A matrix group is a characteristic $p$-group if it is a $p$-group ## and $p$ is also the characteristic of the underlying field. ## ## HasIsCharacteristicMatrixPGroup to true. Hence, we have three cases: ## (1) HasIsCharacteristicMatrixPGroup false ## (2) HasIsCharacteristicMatrixPGroup true, and IsCharacteristicMatrixPGroup true ## (3) HasIsCharacteristicMatrixPGroup true, and IsCharacteristicMatrixPGroup false ## The last case should be synonymous with IsNoncharacteristicMatrixPGroup ## Hence, when an IsCharacteristicMatrixPGroup method is applicable, the ## IsNoncharacteristicMatrixPGroup method will also be applicable, but ## the IsCharacteristicMatrixPGroup will be considered more specific, and ## so will always be preferred over the IsNoncharacteristicMatrixPGroup method. ## DeclareSynonym( "IsNoncharacteristicMatrixPGroup", HasIsCharacteristicMatrixPGroup ); ## gdc - This is bogus. We should just have two separate attributes ## with an immediate method connecting them. ## InstallImmediateMethod( IsNoncharacteristicMatrixPGroup, HasIsCharacteristicMatrixPGroup, ## 0, grp -> not IsCharacteristicMatrixPGroup ); DeclareProperty( "IsCharacteristicMatrixPGroup", IsFFEMatrixGroup ); DeclareProperty( "IsNoncharacteristicMatrixPGroup", IsFFEMatrixGroup ); ############################################################################# ## #O SizeUpperBound( ) ## ## Return an upper bound on the order of the group . ## DeclareOperation( "SizeUpperBound", [ IsGroup ] ); ############################################################################# ## #F DecomposeEltIntoPElts( ) #F DecomposeEltIntoPElts( , ) ## ## Produces list of elements: [p, elti], where p prime, ## elti has order a power of p, and cyclic group generated by elt ## is same as group generated by union of elements, elti. ## NO CHECKING: If you lie about the order, you get a false result. ## This seems to be similar to GAP's IndependentGeneratorsOfAbelianGroup(), ## but we need the extra information ## DeclareGlobalFunction( "DecomposeEltIntoPElts" ); ############################################################################# ## #O PGroupGeneratorsOfAbelianGroup( ) ## ## Produces list of p-groups, each elt of form [p, pgroupGenerators, exponent] ## DeclareOperation( "PGroupGeneratorsOfAbelianGroup", [ IsGroup and IsAbelian ] ); ############################################################################# ## #A GeneratorOfCyclicGroup( ) ## ## Cyclic groups must have a single generator. Store it. ## This is useful for groups given with multiple generators which are ## later shown to be cyclic. ## Note this gives an implicit presentation for the group. ## DeclareAttribute( "GeneratorOfCyclicGroup", IsGroup and IsCyclic ); ############################################################################# ## #A IndependentGeneratorsOfAbelianMatrixGroup( ) ## ## Note this gives an implicit presentation for the group. ## This should replace the current matrix group method for ## IndependentGeneratorsOfAbelianGroup. ## DeclareAttribute( "IndependentGeneratorsOfAbelianMatrixGroup", IsGroup and IsFFEMatrixGroup and IsAbelian ); DeclareAttribute( "IndependentGeneratorsOfAbelianMatrixGroup", IsAdditiveGroup ); ############################################################################# ## #F IsInCenter( , ) #F IsInCentre( , ) ## ## Is in the centre of ? ## DeclareGlobalFunction( "IsInCenter", [ IsGroup, IsAssociativeElement ] ); ############################################################################# ## #F UnipotentSubgroup( ,

) ## ## Returns the unipotent subgroup of GL( ,

). ## Currently

must be prime. ## DeclareGlobalFunction( "UnipotentSubgroup", [ IsInt, IsInt ] ); ############################################################################# ############################################################################# ## ## Matrix group recognition ## ############################################################################# ############################################################################# ############################################################################# ## #O NaturalHomomorphismByInvariantSubspace( , ) ## ## The natural homomorphism of a matrix algebra given by an invariant ## subspace of the underlying vector space. ## DeclareOperation( "NaturalHomomorphismByInvariantSubspace", [ IsAlgebra, IsVectorSpace ] ); ############################################################################# ## #O NaturalHomomorphismByInvariantSubspace( , ) ## ## The natural homomorphism of a matrix group given by an invariant ## subspace of the underlying vector space. ## DeclareOperation( "NaturalHomomorphismByInvariantSubspace", [ IsFFEMatrixGroup, IsVectorSpace ] ); ############################################################################# ## #O NaturalHomomorphismByFixedPointSubspace( , ) ## ## The natural homomorphism given by a fixed point subspace. ## DeclareOperation( "NaturalHomomorphismByFixedPointSubspace", [ IsFFEMatrixGroup, IsVectorSpace ] ); ############################################################################# ## #O NaturalHomomorphismByHomVW( , ) ## ## We are in the case of Hom(V,W) ## Get hom from g to Hom(V,W) by g-> (v -> v*g-v) for v in V, ## and interpret result as f in Hom(V,W), by images on Basis(V) ## where Hom(V,W) is viewed as additive group. ## NOTE: v*(hg)-v=(v*h-v)*g+(v*g-v),\phi(h*g)=\phi(h)\circ\phi(g) ## This is Hom from mult. grp. to additive grp. ## Action of G on this is v*g^(-1)*f*g when W ) . . . . . . . . . . . . . . . . pretty print matrix ## InstallGlobalFunction(PrintArray,function( array ) local arr, max, l, k; if not IsDenseList( array ) then Error( " must be a dense list" ); elif Length( array ) = 0 then Print( "[ ]\n" ); elif array = [[]] then Print( "[ [ ] ]\n" ); elif not ForAll( array, IsList ) then arr := List( array, String ); max := Maximum( List( arr, Length ) ); Print( "[ ", String( arr[ 1 ], max + 1 ) ); for l in [ 2 .. Length( arr ) ] do Print( ", ", String( arr[ l ], max + 1 ) ); od; Print( " ]\n" ); else arr := List( array, x -> List( x, String ) ); max := Maximum( List( arr, function(x) if Length(x) = 0 then return 1; else return Maximum( List(x,Length) ); fi; end) ); Print( "[ " ); for l in [ 1 .. Length( arr ) ] do if l > 1 then Print( " " ); fi; Print( "[ " ); if Length(arr[ l ]) = 0 then Print(" ]" ); else for k in [ 1 .. Length( arr[ l ] ) ] do Print( String( arr[ l ][ k ], max + 1 ) ); if k = Length( arr[ l ] ) then Print( " ]" ); else Print( ", " ); fi; od; fi; if l = Length( arr ) then Print( " ]\n" ); else Print( ",\n" ); fi; od; fi; end); ########################################################################## ## #M Display( ) ## InstallMethod( Display, "for a matrix", [IsMatrix ], PrintArray ); ############################################################################# ## #M IsGeneralizedCartanMatrix( ) ## InstallMethod( IsGeneralizedCartanMatrix, "for a matrix", [ IsMatrix ], function( A ) local n, i, j; if Length( A ) <> Length( A[1] ) then Error( " must be a square matrix" ); fi; n:= Length( A ); for i in [ 1 .. n ] do if A[i][i] <> 2 then return false; fi; od; for i in [ 1 .. n ] do for j in [ i+1 .. n ] do if not IsInt( A[i][j] ) or not IsInt( A[j][i] ) or 0 < A[i][j] or 0 < A[j][i] then return false; elif ( A[i][j] = 0 and A[j][i] <> 0 ) or ( A[j][i] = 0 and A[i][j] <> 0 ) then return false; fi; od; od; return true; end ); ############################################################################# ## #M IsDiagonalMat() ## InstallMethod( IsDiagonalMat, "for a matrix", [ IsMatrix ], function( mat ) local i, j,z; if IsEmpty(mat) then return true;fi; z:=Zero(mat[1][1]); for i in [ 1 .. Length( mat ) ] do for j in [ 1 .. Length( mat[i] ) ] do if mat[i][j] <> z and i <> j then return false; fi; od; od; return true; end); InstallOtherMethod( IsDiagonalMat, [ IsEmpty ], ReturnTrue ); ############################################################################# ## #M IsUpperTriangularMat() ## InstallMethod( IsUpperTriangularMat, "for a matrix", [ IsMatrix ], function( mat ) local i, j,z; if IsEmpty(mat) then return true;fi; z:=Zero(mat[1][1]); for i in [ 1 .. Length( mat ) ] do for j in [ 1 .. i-1] do if mat[i][j] <> z then return false; fi; od; od; return true; end); ############################################################################# ## #M IsLowerTriangularMat() ## InstallMethod( IsLowerTriangularMat, "for a matrix", [ IsMatrix ], function( mat ) local i, j,z; if IsEmpty(mat) then return true;fi; z:=Zero(mat[1][1]); for i in [ 1 .. Length( mat ) ] do for j in [ i+1 .. Length( mat[i] ) ] do if mat[i][j] <> z then return false; fi; od; od; return true; end); ############################################################################# ## #M DiagonalOfMat() . . . . . . . . . . . . . . . . diagonal of matrix ## InstallGlobalFunction( DiagonalOfMat, function ( mat ) local diag, i; diag := []; i := 1; while i <= Length(mat) and i <= Length(mat[1]) do diag[i] := mat[i][i]; i := i + 1; od; while 1 <= Length(mat) and i <= Length(mat[1]) do diag[i] := mat[1][1] - mat[1][1]; i := i + 1; od; return diag; end ); ############################################################################# ## #R IsNullMapMatrix . . . . . . . . . . . . . . . . . . . null map as matrix ## DeclareRepresentation( "IsNullMapMatrix", IsMatrix, [ ] ); BindGlobal( "NullMapMatrix", Objectify( NewType( ListsFamily, IsNullMapMatrix ), [ ] ) ); InstallMethod( Length, "for null map matrix", [ IsNullMapMatrix ], null -> 0 ); InstallMethod( ZERO, "for null map matrix", [ IsNullMapMatrix ], null -> null ); InstallMethod( \+, "for two null map matrices", [ IsNullMapMatrix, IsNullMapMatrix ], function(null,null2) return null; end ); InstallMethod( AINV, "for a null map matrix", [ IsNullMapMatrix ], null -> null ); InstallMethod( AdditiveInverseOp, "for a null map matrix", [ IsNullMapMatrix ], null -> null ); InstallMethod( \*, "for two null map matrices", [ IsNullMapMatrix, IsNullMapMatrix ], function(null,null2) return null; end ); InstallMethod( \*, "for a scalar and a null map matrix", [ IsScalar, IsNullMapMatrix ], function(s,null) return null; end ); InstallMethod( \*, "for a null map matrix and a scalar", [ IsNullMapMatrix, IsScalar ], function(null,s) return null; end ); InstallMethod( \*, "for vector and null map matrix", [ IsVector, IsNullMapMatrix ], function( v, null ) return [ ]; end ); InstallOtherMethod( \*, "for empty list and null map matrix", [ IsList and IsEmpty, IsNullMapMatrix ], function( v, null ) return [ ]; end ); InstallMethod( \*, "for matrix and null map matrix", [ IsMatrix, IsNullMapMatrix ], function( A, null ) return List( A, row -> [ ] ); end ); InstallOtherMethod( \*, "for list and null map matrix", [ IsList, IsNullMapMatrix ], function( A, null ) return List( A, row -> [ ] ); end ); InstallMethod( ViewObj, "for null map matrix", [ IsNullMapMatrix ], function( null ) Print( "" ); end ); InstallMethod( PrintObj, "for null map matrix", [ IsNullMapMatrix ], function( null ) Print( "NullMapMatrix" ); end ); ############################################################################# ## #F Matrix_OrderPolynomialInner( , , , ) ## ## Returns the coefficients of the order polynomial of at ## modulo . No conversions are attempted on or ## , which should usually be immutable and compressed for best ## results. should be a semi-echelonized basis, stored ## as a list with holes with the vector with pivot in position ## Vectors are added to so that it also spans all the images ## of under the algebra generated by ## ## The result, and any vectors added to are compressed ## and immutable ## #N In characteristic zero, or for structured sparse matrices, the naive #N Gaussian elimination here may not be optimal ## #N Shift to using ClearRow once we have kernel methods that give a #N performance benefit ## BindGlobal( "Matrix_OrderPolynomialInner", function( fld, mat, vec, vecs) local d, w, p, one, zero, zeroes, piv, pols, x, t; Info(InfoMatrix,2,"Order Polynomial Inner on ",Length(mat[1]), " x ",Length(mat)," matrix over ",fld," with ", Number(vecs)," basis vectors already given"); d := Length(vec); pols := []; one := One(fld); zero := Zero(fld); zeroes := []; # this loop runs images of under powers of # trying to reduce them with smaller powers (and tracking the polynomial) # or with vectors from as passed in # when we succeed, we know the order polynomial repeat w := ShallowCopy(vec); p := ShallowCopy(zeroes); Add(p,one); ConvertToVectorRepNC(p,fld); piv := PositionNot(w,zero,0); # # Strip as far as we can # while piv <= d and IsBound(vecs[piv]) do x := -w[piv]; if IsBound(pols[piv]) then AddCoeffs(p, pols[piv], x); fi; AddRowVector(w, vecs[piv], x, piv, d); piv := PositionNot(w,zero,piv); od; # # if something is left then we don't have the order poly yet # update tables etc. # if piv <=d then x := Inverse(w[piv]); MultRowVector(p, x); MakeImmutable(p); pols[piv] := p; MultRowVector(w, x ); MakeImmutable(w); vecs[piv] := w; vec := vec*mat; Add(zeroes,zero); fi; until piv > d; MakeImmutable(p); Info(InfoMatrix,2,"Order Polynomial returns ",p); return p; end ); ############################################################################# ## #F Matrix_OrderPolynomialSameField( , , , ) ## ## Compute the order polynomial, all the work is done in the ## routine above ## BindGlobal( "Matrix_OrderPolynomialSameField", function( fld, mat, vec, ind ) local imat, ivec, coeffs; imat:=ImmutableMatrix(fld,mat); ivec := Immutable(vec); ConvertToVectorRepNC(ivec, fld); coeffs := Matrix_OrderPolynomialInner( fld, imat, ivec, []); return UnivariatePolynomialByCoefficients(ElementsFamily(FamilyObj(fld)), coeffs, ind ); end ); ############################################################################# ## #F Matrix_CharacteristicPolynomialSameField( , , ) ## BindGlobal( "Matrix_CharacteristicPolynomialSameField", function( fld, mat, ind) local i, n, ords, base, imat, vec, one,cp,op,zero,fam; Info(InfoMatrix,1,"Characteristic Polynomial called on ", Length(mat[1])," x ",Length(mat)," matrix over ",fld); imat := ImmutableMatrix(fld,mat); n := Length(mat); base := []; vec := ZeroOp(mat[1]); one := One(fld); zero := Zero(fld); fam := ElementsFamily(FamilyObj(fld)); cp:=[one]; if Is8BitMatrixRep(mat) and Length(mat)>0 then # stay in the same field as matrix ConvertToVectorRepNC(cp,Q_VEC8BIT(mat[1])); fi; cp := UnivariatePolynomialByCoefficients(fam,cp,ind); for i in [1..n] do if not IsBound(base[i]) then vec[i] := one; op := Matrix_OrderPolynomialInner( fld, imat, vec, base); cp := cp * UnivariatePolynomialByCoefficients( fam,op,ind); vec[i] := zero; fi; od; Assert(3, IsZero(Value(cp,imat))); Assert(2, Length(CoefficientsOfUnivariatePolynomial(cp)) = n+1); Info(InfoMatrix,1,"Characteristic Polynomial returns ", cp); return cp; end ); ########################################################################## ## #F Matrix_MinimalPolynomialSameField( , , ) ## BindGlobal( "Matrix_MinimalPolynomialSameField", function( fld, mat, ind ) local i, n, ords, base, imat, vec, one,cp,zero, fam, processVec, mp, dim, span,op,w, piv,j,ring; Info(InfoMatrix,1,"Minimal Polynomial called on ", Length(mat[1])," x ",Length(mat)," matrix over ",fld); imat := ImmutableMatrix(fld,mat); n := Length(imat); base := []; dim := 0; # should be number of bound positions in base one := One(fld); zero := Zero(fld); fam := ElementsFamily(FamilyObj(fld)); mp:=[one]; if Is8BitMatrixRep(mat) and Length(mat)>0 then # stay in the same field as matrix ConvertToVectorRepNC(mp,Q_VEC8BIT(mat[1])); fi; #keep coeffs #mp := UnivariatePolynomialByCoefficients( fam, mp,ind); while dim < n do vec := ShallowCopy(mat[1]); for i in [1..n] do #Add(vec,Random([one,zero])); vec[i]:=Random([one,zero]); od; vec[Random([1..n])] := one; # make sure it's not zero #ConvertToVectorRepNC(vec,fld); MakeImmutable(vec); span := []; op := Matrix_OrderPolynomialInner( fld, imat, vec, span); #op := UnivariatePolynomialByCoefficients(fam, op, ind); #mp := Lcm(mp, op); # this command takes much time since a polynomial ring is created. # Instead use the quick gcd-based method (avoiding the dispatcher): #mp := (mp*op)/GcdOp(mp, op); #mp:=mp/LeadingCoefficient(mp); mp:=QUOTREM_LAURPOLS_LISTS(ProductCoeffs(mp,op),GcdCoeffs(mp,op))[1]; mp:=mp/mp[Length(mp)]; for j in [1..Length(span)] do if IsBound(span[j]) then if dim < n then if not IsBound(base[j]) then base[j] := span[j]; dim := dim+1; else w := ShallowCopy(span[j]); piv := j; repeat AddRowVector(w,base[piv],-w[piv], piv, n); piv := PositionNot(w, zero, piv); until piv > n or not IsBound(base[piv]); if piv <= n then MultRowVector(w,Inverse(w[piv])); MakeImmutable(w); base[piv] := w; dim := dim+1; fi; fi; fi; fi; od; od; mp := UnivariatePolynomialByCoefficients( fam, mp,ind); Assert(3, IsZero(Value(mp,imat))); Info(InfoMatrix,1,"Minimal Polynomial returns ", mp); return mp; end ); ########################################################################## ## #M Display( ) ## InstallMethod( Display, "for matrix of FFEs", [ IsFFECollColl and IsMatrix ], function( m ) local deg, chr, zero, w, t, x, v, f, z, y; if Length(m[1]) = 0 then TryNextMethod(); fi; if IsZmodnZObj(m[1][1]) then Print("ZmodnZ matrix:\n"); t:=List(m,i->List(i,i->i![1])); Display(t); Print("modulo ",DataType(TypeObj(m[1][1])),"\n"); #T what is this good for? #T (The code for finite prime fields should handle this case, #T and the output should look the same.) else # get the degree and characteristic deg := Lcm( List( m, DegreeFFE ) ); chr := Characteristic(m[1][1]); zero := Zero(m[1][1]); # if it is a finite prime field, use integers for display if deg = 1 then # compute maximal width w := LogInt( chr, 10 ) + 2; # create strings t := []; for x in [ 2 .. chr ] do t[x] := String( x-1, w ); od; #T useful only for (very) small characteristic, or? t[1] := String( ".", w ); # print matrix for v in m do for x in List( v, IntFFE ) do #T ! Print( t[x+1] ); od; Print( "\n" ); od; # if it a finite, use mixed integers/z notation #T ... else Print( "z = Z(", chr^deg, ")\n" ); # compute maximal width w := LogInt( chr^deg-1, 10 ) + 4; # create strings t := []; f := GF(chr^deg); z := Z(chr^deg); for x in [ 0 .. Size(f)-2 ] do y := z^x; if DegreeFFE(y) = 1 then t[x+2] := String( IntFFE(y), w ); #T ! else t[x+2] := String(Concatenation("z^",String(x)),w); fi; od; t[1] := String( ".", w ); # print matrix for v in m do for x in v do if x = zero then Print( t[1] ); else Print( t[LogFFE(x,z)+2] ); fi; od; Print( "\n" ); od; fi; fi; end ); ########################################################################## ## #M Display( ) ## InstallMethod( Display, "for matrix over Integers mod n", [ IsZmodnZObjNonprimeCollColl and IsMatrix ], function( m ) Print( "matrix over Integers mod ", DataType( TypeObj( m[1][1] ) ), ":\n" ); Display( List( m, i -> List( i, i -> i![1] ) ) ); end ); ############################################################################# ## #M CharacteristicPolynomial( ) ## InstallMethod( CharacteristicPolynomial, "supply field and indeterminate 1", [ IsMatrix ], mat -> CharacteristicPolynomialMatrixNC( DefaultFieldOfMatrix( mat ), mat, 1 ) ); ############################################################################# ## #M CharacteristicPolynomial( , , ) ## InstallMethod( CharacteristicPolynomial, "supply indeterminate 1", function (famF, famE, fammat) local fam; if HasElementsFamily (fammat) then fam := ElementsFamily (fammat); return IsIdenticalObj (famF, fam) and IsIdenticalObj (famE, fam); fi; return false; end, [ IsField, IsField, IsMatrix ], function( F, E, mat ) return CharacteristicPolynomial( F, E, mat, 1); end ); ############################################################################# ## #M CharacteristicPolynomial( , ) ## InstallMethod( CharacteristicPolynomial, "supply field", [ IsMatrix, IsPosInt ], function( mat, indnum ) local F; F := DefaultFieldOfMatrix( mat ); return CharacteristicPolynomial( F, F, mat, indnum ); end ); ############################################################################# ## #M CharacteristicPolynomial( , , , ) ## InstallMethod( CharacteristicPolynomial, "spinning over field", function (famF, famE, fammat, famid) local fam; if HasElementsFamily (fammat) then fam := ElementsFamily (fammat); return IsIdenticalObj (famF, fam) and IsIdenticalObj (famE, fam); fi; return false; end, [ IsField, IsField, IsOrdinaryMatrix, IsPosInt ], function( F, E, mat, inum ) local fld, B; if not IsSubset (E, F) then Error (" must be a subfield of ."); elif F <> E then # Replace the matrix by a matrix with the same char. polynomial # but with entries in `F'. B:= Basis( AsVectorSpace( F, E ) ); mat:= BlownUpMat( B, mat ); fi; return CharacteristicPolynomialMatrixNC( F, mat, inum); end ); InstallMethod( CharacteristicPolynomialMatrixNC, "spinning over field", IsElmsCollsX, [ IsField, IsOrdinaryMatrix, IsPosInt ], Matrix_CharacteristicPolynomialSameField); ############################################################################# ## #M MinimalPolynomial( , , ) ## InstallMethod( MinimalPolynomial, "spinning over field", IsElmsCollsX, [ IsField, IsOrdinaryMatrix, IsPosInt ], function( F, mat,inum ) local fld, B; fld:= DefaultFieldOfMatrix( mat ); if fld <> fail and not IsSubset( F, fld ) then # Replace the matrix by a matrix with the same minimal polynomial # but with entries in `F'. if not IsSubset( fld, F ) then fld:= ClosureField( fld, F ); fi; B:= Basis( AsField( F, fld ) ); mat:= BlownUpMat( B, mat ); fi; return MinimalPolynomialMatrixNC( F, mat,inum); end ); InstallOtherMethod( MinimalPolynomial, "supply field", [ IsMatrix,IsPosInt ], function(m,n) return MinimalPolynomial( DefaultFieldOfMatrix( m ), m, n ); end); InstallOtherMethod( MinimalPolynomial, "supply field and indeterminate 1", [ IsMatrix ], function(m) return MinimalPolynomial( DefaultFieldOfMatrix( m ), m, 1 ); end); InstallMethod( MinimalPolynomialMatrixNC, "spinning over field", IsElmsCollsX, [ IsField, IsOrdinaryMatrix, IsPosInt ], Matrix_MinimalPolynomialSameField); ############################################################################# ## #M Order( ) . . . . . . . . . . . . . . . . . . . . order of a matrix ## OrderMatLimit := 1000; InstallOtherMethod( Order, "generic method for ordinary matrices", [ IsOrdinaryMatrix ], function ( mat ) local m, rank; # check that the argument is an invertible square matrix m := Length(mat); if m <> Length(mat[1]) then Error( "Order: must be a square matrix" ); fi; rank:= RankMat( mat ); if rank = fail then if not IsUnit( DeterminantMat( mat ) ) then Error( "Order: must be invertible" ); fi; elif rank <> m then Error( "Order: must be invertible" ); #T also test here that the determinant is in fact a unit in the ring #T that is generated by the matrix entries? #T (Do we need `IsPossiblyInvertibleMat' and `IsSurelyInvertibleMat', #T the first meaning that the inverse in some ring exists, #T the second meaning that the inverse exists in the ring generated by the #T matrix entries? #T For `Order', it is `IsSurelyInvertibleMat' that one wants to check; #T then one can return `infinity' if the determinant is not a unit in the #T ring generated by the matrix entries.) fi; # loop over the standard basis vectors return OrderMatTrial(mat,infinity); end ); ############################################################################# ## #F OrderMatTrial( , ) ## InstallGlobalFunction(OrderMatTrial,function(mat,lim) local ord,i,vec,v,o; # loop over the standard basis vectors ord := 1; for i in [1..Length(mat)] do # compute the length of the orbit of the th standard basis vector # (equivalently, of the orbit of `mat[]', # the image of the standard basis vector under `mat') vec := mat[i]; v := vec * mat; o := 1; while v <> vec do v := v * mat; o := o + 1; if o>lim then return fail; elif OrderMatLimit = o and Characteristic(v[1])=0 then Info( InfoWarning, 1, "Order: warning, order of might be infinite" ); fi; od; # raise the matrix to this length (new mat will fix basis vector) mat := mat ^ o; ord := ord * o; od; if IsOne(mat) then return ord; else return fail; fi; end); # ############################################################################# # ## # #M Order( ) . . . . . . . . . . . order of a matrix of cyclotomics # ## # ## The idea is to compute the minimal polynomial of the matrix, # ## and to decompose this polynomial into cyclotomic polynomials. # ## This is due to R. Beals, who used it in his `grim' package for {\GAP}~3. # ## # InstallMethod( Order, # "ordinary matrix of cyclotomics", # [ IsOrdinaryMatrix and IsCyclotomicCollColl ], # function( cycmat ) # local m, # dimension of the matrix # trace, # trace of the matrix # minpol, # minimal polynomial of the matrix # n, # degree of `minpol' # p, # loop over small primes # t, # product of the primes `p' # l, # product of the values `p-1' # ord, # currently known factor of the order # d, # loop over the indices of cyclotomic polynomials # phi, # `Phi( d )' # c, # `d'-th cyclotomic polynomial # q; # quotient and remainder # # # Before we start with expensive calculations, # # we check whether the matrix has a *small* order. # ord:= OrderMatTrial( cycmat, OrderMatLimit - 1 ); # if ord <> fail then # return ord; # fi; # # # Check that the argument is an invertible square matrix. # m:= Length( cycmat ); # if m <> Length( cycmat[1] ) then # Error( "Order: must be a square matrix" ); # elif RankMat( cycmat ) <> m then # Error( "Order: must be invertible" ); # fi; # #T Here I could compute the inverse; # #T its trace could be checked, too. # #T Additionally, if `mat' consists of (algebraic) integers # #T and the inverse does not then the order of `mat' is infinite. # # # If the order is finite then the trace must be an algebraic integer. # trace:= TraceMat( cycmat ); # if not IsIntegralCyclotomic( trace ) then # return infinity; # fi; # # # If the order is finite then the absolute value of the trace # # is bounded by the dimension of the matrix. # #T compute this (approximatively) for arbitrary cyclotomics # #T (by the way: why isn't this function called `AbsRat'?) # if IsInt( trace ) and Length( cycmat ) < AbsInt( trace ) then # return infinity; # fi; # # # Compute the minimal polynomial of the matrix. # minpol:= MinimalPolynomial( Rationals, cycmat ); # n:= DegreeOfLaurentPolynomial( minpol ); # # # The order is finite if and only if the minimal polynomial # # is a product of cyclotomic polynomials. # # (Note that cyclotomic polynomials over the rationals are irreducible.) # # # A necessary condition is that the constant term of the polynomial # # is $\pm 1$, since this holds for every cyclotomic polynomial. # if AbsInt( Value( minpol, 0 ) ) <> 1 then # return infinity; # fi; # # # Another necessary condition is that no irreducible factor # # may occur more than once. # # (Note that the minimal polynomial divides $X^{ord} - 1$.) # if not IsOne( Gcd( minpol, Derivative( minpol ) ) ) then # return infinity; # fi; # # # Compute an upper bound `t' for the numbers $i$ with the property # # that $\varphi(i) \leq n$ holds. # # (Let $p_k$ denote the $k$-th prime divisor of $i$, # # and $q_k$ the $k$-th prime; then clearly $q_k \leq p_k$ holds. # # Now let $h$ be the smallest *positive* integer --be careful that the # # products considered below are not empty-- such that # # $\prod_{k=1}^h ( q_k - 1 ) \geq n$, and set $t = \prod_{k=1}^h q_k$. # # If $i$ has the property $\varphi(i) \leq n$ then # # $i \leq n \frac{i}{\varphi(i)} = n \prod_{k} \frac{p_k}{p_k-1}$. # # Replacing $p_k$ by $q_k$ means to replace the factor # # $\frac{p_k}{p_k-1}$ by a larger factor, # # and if $i$ has less than $h$ prime divisors then # # running over the first $h$ primes increases the value of the product # # again, so we get $i \leq n \prod_{k=1}^h \frac{q_k}{q_k-1} \leq t$.) # p:= 2; # t:= 2; # l:= 1; # while l < n do # p:= NextPrimeInt( p ); # t:= t * p; # l:= l * ( p - 1 ); # od; # # # Divide by each possible cyclotomic polynomial. # ord:= 1; # for d in [ 1 .. t ] do # # phi:= Phi( d ); # if phi <= n then # c:= CyclotomicPolynomial( Rationals, d ); # q:= QuotientRemainder( minpol, c ); # if IsZero( q[2] ) then # minpol:= q[1]; # n:= n - phi; # ord:= Lcm( ord, d ); # if n = 0 then # # # The minimal polynomial is a product of cyclotomic polynomials. # return ord; # # fi; # fi; # fi; # # od; # # # The matrix has infinite order. # return infinity; # end ); ############################################################################# ## #M Order( ) . . . . . . . . . . . . order of a matrix of cyclotomics ## InstallMethod( Order, "for a matrix of cyclotomics, with Minkowski kernel", [ IsOrdinaryMatrix and IsCyclotomicCollColl ], function ( mat ) local dim, F, tracemat, lat, red, det, trace, order, orddet, powdet, ordpowdet, I; # Check that the argument is an invertible square matrix. dim:= Length( mat ); if dim <> Length( mat[1] ) then Error( "Order: must be a square matrix" ); fi; # Before we start with expensive calculations, # we check whether the matrix has a *very small* order. order:= OrderMatTrial( mat, 6 ); if order <> fail then return order; fi; # We compute the determinant , issue an error message in case # is not invertible, compute the order of and check # whether ^ has small order. det := DeterminantMat( mat ); if det = 0 then Error( "Order: must be invertible" ); fi; orddet := Order(det); if orddet = infinity then return infinity; fi; powdet := mat^orddet; ordpowdet := OrderMatTrial( powdet, 12 ); if ordpowdet <> fail then return orddet * ordpowdet; fi; # If the order is finite then the trace must be an algebraic integer. trace := TraceMat( mat ); if not IsIntegralCyclotomic( trace ) then return infinity; fi; # If the order is finite then the absolute value of the trace # is bounded by the dimension of the matrix. if IsInt( trace ) and Length( mat ) < AbsInt( trace ) then return infinity; fi; F:= DefaultFieldOfMatrix( mat ); # Convert to a rational matrix if necessary. if 1 < Conductor( F ) then # Check whether the trace is larger than the dimension. tracemat := BlownUpMat( Basis(F), [[ trace ]] ); if AbsInt(Trace(tracemat)) > Length(mat) * Length(tracemat) then return infinity; fi; mat:= BlownUpMat( Basis( F ), mat ); dim:= Length( mat ); fi; # Convert to an integer matrix if necessary. if not ForAll( mat, row -> ForAll( row, IsInt ) ) then # The following checks trace and determinant. lat:= InvariantLattice( GroupWithGenerators( [ mat ] ) ); if lat = fail then return infinity; fi; mat:= lat * mat * Inverse( lat ); fi; # Compute the order of the reduction modulo $2$. red:= mat * Z(2); ConvertToMatrixRep(red,2); order:= Order( red ); #T if OrderMatTrial was used above then call `ProjectiveOrder' directly? # Now use the theorem (see Morris Newman, Integral Matrices) # that `mat' has infinite order if the `2 * order'-th # power is not equal to the identity matrix. I:= IdentityMat( dim ); #T supply better `IsOne' method for matrices, without constructing an object! mat:= mat ^ order; if mat = I then return order; elif mat ^ 2 = I then return 2 * order; else return infinity; fi; end ); ############################################################################# ## #M Order( ) . . . . . order of a matrix of finite field elements ## InstallMethod( Order, "ordinary matrix of finite field elements", true, [ IsOrdinaryMatrix and IsFFECollColl ], 0, function( mat ) local o; # catch the (unlikely in GL but likely in group theory...) case that mat # has a small order # the following limit is very crude but seems to work OK. It picks small # orders but still does not cost too much if the order gets larger. if Length(mat) <> Length(mat[1]) then Error("Order of non-square matrix is not defined"); fi; o:=Characteristic(mat[1][1])^DegreeFFE(mat[1][1]); # size of field of # first entry o:=QuoInt(Length(mat),o)*5; o:=OrderMatTrial(mat,o); if o<>fail then return o; fi; o := ProjectiveOrder(mat); return o[1] * Order( o[2] ); end ); ############################################################################# ## #M IsZero( ) ## InstallMethod( IsZero, "method for a matrix", [ IsMatrix ], function( mat ) local ncols, # number of columns zero, # zero coefficient row; # loop over rows in 'obj' ncols:= DimensionsMat( mat )[2]; zero:= Zero( mat[1][1] ); for row in mat do if PositionNot( row, zero ) <= ncols then return false; fi; od; return true; end ); ############################################################################# ## #M BaseMat( ) . . . . . . . . . . base for the row space of a matrix ## InstallMethod( BaseMatDestructive, "generic method for matrices", [ IsMatrix ], mat -> SemiEchelonMatDestructive( mat ).vectors ); InstallMethod( BaseMat, "generic method for matrices", [ IsMatrix ], function ( mat ) return BaseMatDestructive( MutableCopyMat( mat ) ); end ); ############################################################################# ## #M DefaultFieldOfMatrix( ) ## InstallMethod( DefaultFieldOfMatrix, "default method for a matrix (return `fail')", [ IsMatrix ], ReturnFail ); ############################################################################# ## #M DefaultFieldOfMatrix( ) ## InstallMethod( DefaultFieldOfMatrix, "method for a matrix over a finite field", [ IsMatrix and IsFFECollColl ], function( mat ) local deg, j; deg := 1; for j in mat do deg := LcmInt( deg, DegreeFFE(j) ); od; return GF( Characteristic(mat[1]), deg ); end ); ############################################################################# ## #M DefaultFieldOfMatrix( ) ## InstallMethod( DefaultFieldOfMatrix, "method for a matrix over the cyclotomics", [ IsMatrix and IsCyclotomicCollColl ], function( mat ) local deg, j; deg := 1; for j in mat do deg := LcmInt( deg, Conductor(j) ); od; return CF( deg ); end ); ############################################################################# ## #M DepthOfUpperTriangularMatrix( ) ## InstallMethod( DepthOfUpperTriangularMatrix, [ IsMatrix ], function( mat ) local dim, zero, i, j; # find the correct layer of dim := Length(mat); zero := Zero(mat[1][1]); for i in [ 1 .. dim-1 ] do for j in [ 1 .. dim-i ] do if mat[j][i+j] <> zero then return i; fi; od; od; return dim; end); InstallOtherMethod( SumIntersectionMat, [ IsEmpty, IsMatrix ], function(a,b) b:=MutableCopyMat(b); TriangulizeMat(b); b:=Filtered(b,i->not IsZero(i)); return [b,a]; end); InstallOtherMethod( SumIntersectionMat, [ IsMatrix, IsEmpty ], function(a,b) a:=MutableCopyMat(a); TriangulizeMat(a); a:=Filtered(a,i->not IsZero(i)); return [a,b]; end); InstallOtherMethod( SumIntersectionMat, IsIdenticalObj, [ IsEmpty, IsEmpty ], function(a,b) return [a,b]; end); ############################################################################# ## #M DeterminantMat( ) ## ## Fractions free method, will never introduce denominators ## ## This method is better for cyclotomics, but pivotting is really needed ## InstallMethod( DeterminantMatDestructive, "fraction-free method", [ IsOrdinaryMatrix and IsMutable], function ( mat ) local det, sgn, row, zero, m, i, j, k, mult, row2, piv; # check that the argument is a square matrix and get the size m := Length(mat); zero := Zero(mat[1][1]); if m <> Length(mat[1]) then Error("DeterminantMat: must be a square matrix"); fi; # run through all columns of the matrix i := 0; det := 1; sgn := 1; for k in [1..m] do # find a nonzero entry in this column #N 26-Oct-91 martin if is an rational matrix look for a pivot j := i + 1; while j <= m and mat[j][k] = zero do j := j+1; od; # if there is a nonzero entry if j <= m then # increment the rank i := i + 1; # make its row the current row if i <> j then row := mat[j]; mat[j] := mat[i]; mat[i] := row; sgn := -sgn; else row := mat[j]; fi; piv := row[k]; # clear all entries in this column # Then divide through by det, this, amazingly, works, due # to a theorem about 3x3 determinants for j in [i+1..m] do row2 := mat[j]; mult := -row2[k]; if mult <> zero then MultRowVector( row2, piv ); AddRowVector( row2, row, mult, k, m ); MultRowVector( row2, Inverse(det) ); else MultRowVector( row2, piv/det); fi; od; det := piv; else return zero; fi; od; # return the determinant return sgn * det; end); ############################################################################# ## #M DeterminantMat( ) ## ## direct Gaussian elimination, not avoiding denominators #T This method at the moment is better for finite fields ## another method is installed for cyclotomics. Anything else falls ## through here also. ## InstallMethod( DeterminantMatDestructive,"non fraction free", [ IsOrdinaryMatrix and IsFFECollColl and IsMutable], function( mat ) local m, zero, det, sgn, k, j, row, l, norm, row2, x; Info( InfoMatrix, 1, "DeterminantMat called" ); # check that the argument is a square matrix, and get the size m := Length(mat); if m = 0 or m <> Length(mat[1]) then Error( " must be a square matrix at least 1x1" ); fi; zero := Zero(mat[1][1]); # normalize rows using the inverse if IsFFECollColl(mat) then norm := true; else norm := false; fi; det := One(zero); sgn := det; # run through all columns of the matrix for k in [ 1 .. m ] do # look for a nonzero entry in this column j := k; while j <= m and mat[j][k] = zero do j := j+1; od; # if there is a nonzero entry if j <= m then # increment the rank, ... Info( InfoMatrix, 2, " nonzero columns: ", k ); # ... make its row the current row, ... if k <> j then row := mat[j]; mat[j] := mat[k]; mat[k] := row; sgn := -sgn; else row := mat[j]; fi; # ... and normalize the row. x := row[k]; det := det * x; MultRowVector( mat[k], Inverse(x) ); # clear all entries in this column, adjust only columns > k # (Note that we need not clear the rows from 'k+1' to 'j'.) for l in [ j+1 .. m ] do row2 := mat[l]; x := row2[k]; if x <> zero then AddRowVector( row2, row, -x, k+1, m ); fi; od; # the determinant is zero else Info( InfoMatrix, 1, "DeterminantMat returns ", zero ); return zero; fi; od; det := sgn * det; Info( InfoMatrix, 1, "DeterminantMat returns ", det ); # return the determinant return det; end ); InstallMethod( DeterminantMat, "for matrices", [ IsMatrix ], function( mat ) return DeterminantMatDestructive( MutableCopyMat( mat ) ); end ); InstallMethod( DeterminantMatDestructive,"nonprime residue rings", [ IsOrdinaryMatrix and CategoryCollections(CategoryCollections(IsZmodnZObjNonprime)) and IsMutable], DeterminantMatDivFree); ############################################################################# ## #M DeterminantMatDivFree( ) ## ## Division free method. This is an alternative to the fraction free method ## when division of matrix entries is expensive or not possible. ## ## This method implements a division free algorithm found in ## Mahajan and Vinay \cite{MV97}. ## ## The run time is $O(n^4)$ ## Auxillary storage size $n^2+n + C$ ## ## Our implementation has two runtime optimizations (both noted ## by Mahajan and Vinay) ## 1. Partial monomial sums, subtractions, and products are done at ## each level. ## 2. Prefix property is maintained allowing for a pruning of many ## vertices at each level ## ## and two auxillary storage size optimizations ## 1. only the upper triangular and diagonal portion of the ## auxillary storage is used. ## 2. Level information storage is reused (2 levels). ## ## This code was implemented by: ## Timothy DeBaillie ## Robert Morse ## Marcus Wassmer ## InstallMethod( DeterminantMatDivFree, "Division-free method", [ IsMatrix ], function ( M ) local u,v,w,i, ## indices a,b,c,x,y, ## temp indices temp, ## temp variable nlevel, ## next level clevel, ## current level pmone, ## plus or minus one zero, ## zero of the ring n, ## size of the matrix Vs, ## final sum V; ## graph # check that the argument is a square matrix and set the size n := Length(M); if not n = Length(M[1]) or not IsRectangularTable(M) then Error("DeterminantMatDivFree: must be a square matrix"); fi; ## initialze the final sum, the vertex set, initial parity ## and level indexes ## zero := Zero(M[1][1]); Vs := zero; V := []; pmone := (-One(M[1][1]))^((n mod 2)+1); clevel := 1; nlevel := 2; ## Vertices are indexed [u,v,i] holding the (partial) monomials ## whose sums will form the determinant ## where i = depth in the tree (current and next reusing ## level storage) ## u,v indices in the matrix ## ## Only the upper triangular portion of the storage space is ## needed. It is easier to create lower triangular data type ## which we do here and index via index arithmetic. ## for u in [1..n] do Add(V,[]); for v in [1..u] do Add(V[u],[zero,zero]); od; ## Initialize the level 0 nodes with +/- one, depending on ## the initial parity determined by the size of the matrix ## V[u][u][clevel] := pmone; od; ## Here are the $O(n^4)$ edges labeled by the elements of ## the matrix $M$. We build up products of the labels which form ## the monomials which make up the determinant. ## ## 1. Parity of monomials are maintained implicitly. ## 2. Partial sums for some vertices are not part of the final ## answer and can be pruned. ## for i in [0..n-2] do for u in [1..i+2] do ## <---- pruning of vertices for v in [u..n] do ## (maintains the prefix property) for w in [u+1..n] do ## translate indices to lower triangluar coordinates ## a := n-u+1; b := n-w+1; c := n-v+1; V[a][b][nlevel]:= V[a][b][nlevel]+ V[a][c][clevel]*M[v][w]; V[b][b][nlevel]:= V[b][b][nlevel]- V[a][c][clevel]*M[v][u]; od; od; od; ## set the new current and next level. The new next level ## is intialized to zero ## temp := nlevel; nlevel := clevel; clevel := temp; for x in [1..n] do for y in [1..x] do V[x][y][nlevel] := zero; od; od; od; ## with the final level, we form the last monomial product and then ## sum these monomials (parity has been accounted for) ## to find the determinant. ## for u in [1..n] do for v in [u..n] do Vs := Vs + V[n-u+1][n-v+1][clevel]*M[v][u]; od; od; ## Return the final sum ## return Vs; end); ############################################################################# ## #M DimensionsMat( ) ## InstallMethod( DimensionsMat, [ IsMatrix ], function( A ) if IsRectangularTable(A) then return [ Length(A), Length(A[1]) ]; else return fail; fi; end ); BindGlobal("DoDiagonalizeMat",function(R,M,transform,divide) local swaprow, swapcol, addcol, addrow, multcol, multrow, l, n, start, d, typ, ed, posi,posj, a, b, qr, c, i,j,left,right,cleanout, alldivide; swaprow:=function(a,b) local r; r:=M[a]; M[a]:=M[b]; M[b]:=r; if transform then r:=left[a]; left[a]:=left[b]; left[b]:=r; fi; end; swapcol:=function(a,b) local c; c:=M{[1..l]}[a]; M{[1..l]}[a]:=M{[1..l]}[b]; M{[1..l]}[b]:=c; if transform then c:=right{[1..n]}[a]; right{[1..n]}[a]:=right{[1..n]}[b]; right{[1..n]}[b]:=c; fi; end; addcol:=function(a,b,m) local i; for i in [1..l] do M[i][a]:=M[i][a]+m*M[i][b]; od; if transform then for i in [1..n] do right[i][a]:=right[i][a]+m*right[i][b]; od; fi; end; addrow:=function(a,b,m) AddCoeffs(M[a],M[b],m); if transform then AddCoeffs(left[a],left[b],m); fi; end; multcol:=function(a,m) local i; for i in [1..l] do M[i][a]:=M[i][a]*m; od; if transform then for i in [1..n] do right[i][a]:=right[i][a]*m; od; fi; end; multrow:=function(a,m) MultRowVector(M[a],m); if transform then MultRowVector(left[a],m); fi; end; # clean out row and column cleanout:=function() local a,i,b,c,qr; repeat # now do the GCD calculations only in row/column for i in [start+1..n] do a:=i; b:=start; if not IsZero(M[start][b]) then repeat qr:=QuotientRemainder(R,M[start][a],M[start][b]); addcol(a,b,-qr[1]); c:=a;a:=b;b:=c; until IsZero(qr[2]); if b=start then swapcol(start,i); fi; fi; # normalize qr:=StandardAssociateUnit(R,M[start][start]); multcol(start,qr); od; for i in [start+1..l] do a:=i; b:=start; if not IsZero(M[b][start]) then repeat qr:=QuotientRemainder(R,M[a][start],M[b][start]); addrow(a,b,-qr[1]); c:=a;a:=b;b:=c; until IsZero(qr[2]); if b=start then swaprow(start,i); fi; fi; qr:=StandardAssociateUnit(R,M[start][start]); multrow(start,qr); od; until ForAll([start+1..n],i->IsZero(M[start][i])); end; l:=Length(M); n:=Length(M[1]); if transform then left:=IdentityMat(l,R); right:=IdentityMat(n,R); fi; start:=1; while start<=Length(M) and start<=n do # find element of lowest degree and move it into pivot # hope is this will reduce the total number of iterations by making # it small in the first place d:=infinity; for i in [start..l] do for j in [start..n] do if not IsZero(M[i][j]) then ed:=EuclideanDegree(R,M[i][j]); if edinfinity then # there is at least one nonzero entry if posi<>start then swaprow(start,posi); fi; if posj<>start then swapcol(start,posj); fi; cleanout(); if divide then repeat alldivide:=true; #make sure the pivot also divides the rest for i in [start+1..l] do for j in [start+1..n] do if Quotient(M[i][j],M[start][start])=fail then alldivide:=false; # do gcd addrow(start,i,1); cleanout(); fi; od; od; until alldivide; fi; # normalize qr:=StandardAssociateUnit(R,M[start][start]); multcol(start,qr); fi; start:=start+1; od; if transform then return rec(rowtrans:=left,coltrans:=right,normal:=M); else return M; fi; end); ############################################################################# ## #M DiagonalizeMat(,) ## # this is a very naive implementation but it should work for any euclidean # ring. InstallMethod( DiagonalizeMat, "method for general Euclidean Ring", true, [ IsEuclideanRing,IsMatrix and IsMutable], 0,function(R,M) return DoDiagonalizeMat(R,M,false,false); end); ############################################################################# ## #M ElementaryDivisorsMat() . . . . . . elementary divisors of a matrix ## ## 'ElementaryDivisors' returns a list of the elementary divisors, i.e., the ## unique with '[]' divides '[+1]' and is equivalent ## to a diagonal matrix with the elements '[]' on the diagonal. ## InstallGlobalFunction(ElementaryDivisorsMatDestructive,function(ring,mat) # diagonalize the matrix DoDiagonalizeMat(ring, mat,false,true ); # get the diagonal elements return DiagonalOfMat(mat); end ); InstallMethod( ElementaryDivisorsMat, "generic method for euclidean rings", [ IsEuclideanRing,IsMatrix ], function ( ring,mat ) # make a copy to avoid changing the original argument mat := MutableCopyMat( mat ); if IsIdenticalObj(ring,Integers) then DiagonalizeMat(Integers,mat); return DiagonalOfMat(mat); fi; return ElementaryDivisorsMatDestructive(ring,mat); end); InstallOtherMethod( ElementaryDivisorsMat, "compatibility method -- supply ring", [ IsMatrix ], function(mat) local ring; if ForAll(mat,row->ForAll(row,IsInt)) then return ElementaryDivisorsMat(Integers,mat); fi; ring:=DefaultRing(Flat(mat)); return ElementaryDivisorsMat(ring,mat); end); ############################################################################# ## #M ElementaryDivisorsTransformationsMat() elem. divisors of a matrix ## ## 'ElementaryDivisorsTransformationsMat' does not only compute the ## elementary divisors, but also transforming matrices. InstallGlobalFunction(ElementaryDivisorsTransformationsMatDestructive, function(ring,mat) # diagonalize the matrix return DoDiagonalizeMat(ring, mat,true,true ); end ); InstallMethod( ElementaryDivisorsTransformationsMat, "generic method for euclidean rings", [ IsEuclideanRing,IsMatrix ], function ( ring,mat ) # make a copy to avoid changing the original argument mat := MutableCopyMat( mat ); return ElementaryDivisorsTransformationsMatDestructive(ring,mat); end); InstallOtherMethod( ElementaryDivisorsTransformationsMat, "compatibility method -- supply ring", [ IsMatrix ], function(mat) local ring; if ForAll(mat,row->ForAll(row,IsInt)) then return ElementaryDivisorsTransformationsMat(Integers,mat); fi; ring:=DefaultRing(Flat(mat)); return ElementaryDivisorsTransformationsMat(ring,mat); end); ############################################################################# ## #M MutableCopyMat( ) ## InstallMethod( MutableCopyMat, "generic method", [IsList], mat -> List( mat, ShallowCopy ) ); ############################################################################# ## #M MutableTransposedMat( ) . . . . . . . . . . transposed of a matrix ## InstallMethod( MutableTransposedMat, "generic method", [ IsRectangularTable and IsMatrix ], function( mat ) local trn, n, m, j; m:= Length( mat ); if m = 0 then return []; fi; # initialize the transposed m:= [ 1 .. m ]; n:= [ 1 .. Length( mat[1] ) ]; trn:= []; # copy the entries for j in n do trn[j]:= mat{ m }[j]; # ConvertToVectorRepNC( trn[j] ); od; # return the transposed return trn; end ); ############################################################################# ## #M MutableTransposedMat( ) . . . . . . . . . . transposed of a matrix ## InstallOtherMethod( MutableTransposedMat, "for arbitrary lists of lists", [ IsList ], function( t ) local res, m, i, j; res := []; if Length(t)>0 and IsDenseList(t) and ForAll(t, IsDenseList) then # special case with dense list of dense lists m := Maximum(List(t, Length)); for i in [m,m-1..1] do res[i] := []; od; for i in [1..Length(t)] do res{[1..Length(t[i])]}[i] := t[i]; od; else # general case, non dense lists allowed for i in [1..Length(t)] do if IsBound(t[i]) then if IsList(t[i]) then for j in [1..Length(t[i])] do if IsBound(t[i][j]) then if not IsBound(res[j]) then res[j] := []; fi; res[j][i] := t[i][j]; fi; od; else Error("bound entries must be lists"); fi; fi; od; fi; return res; end); ############################################################################# ## #M MutableTransposedMatDestructive( ) . . . . . transposed of a matrix ## may destroy `mat'. ## InstallMethod( MutableTransposedMatDestructive, "generic method", [IsMatrix and IsMutable], function( mat ) local m, n, min, i, j, store; m:= Length( mat ); if m = 0 then return []; fi; n:= Length( mat[1] ); min:= Minimum( m, n ); # swap the entries in the "square part" of the matrix. for i in [1..min] do for j in [i+1..min] do store:= mat[i][j]; mat[i][j]:= mat[j][i]; mat[j][i]:= store; od; od; # if the matrix is not square, then we have to adjust some rows or # columns. if m < n then for i in [1..n-m] do store:= [ ]; for j in [1..m] do store[j]:= mat[j][m+i]; Unbind( mat[j][m+i] ); od; Add( mat, store ); od; for i in [1..m] do mat[i]:= Filtered( mat[i], x -> IsBound(x) ); od; fi; if m > n then for i in [n+1..m] do for j in [1..n] do mat[j][i]:= mat[i][j]; od; Unbind( mat[i] ); od; mat:= Filtered( mat, x -> IsBound( x ) ); fi; # return the transposed return mat; end ); ############################################################################# ## #M NullspaceMat( ) . . . . . . basis of solutions of * = 0 ## InstallMethod( NullspaceMat, "generic method for ordinary matrices", [ IsOrdinaryMatrix ], mat -> SemiEchelonMatTransformation(mat).relations ); InstallMethod( NullspaceMatDestructive, "generic method for ordinary matrices", [ IsOrdinaryMatrix and IsMutable], mat -> SemiEchelonMatTransformationDestructive(mat).relations ); InstallMethod( TriangulizedNullspaceMat, "generic method for ordinary matrices", [ IsOrdinaryMatrix ], mat -> TriangulizedNullspaceMatDestructive( MutableCopyMat( mat ) ) ); InstallMethod( TriangulizedNullspaceMatDestructive, "generic method for ordinary matrices", [ IsOrdinaryMatrix and IsMutable], function( mat ) local ns; ns := SemiEchelonMatTransformationDestructive(mat).relations; TriangulizeMat(ns); return ns; end ); InstallMethod( TriangulizedNullspaceMatNT, "generic method", [ IsOrdinaryMatrix ], function( mat ) local nullspace, m, n, min, empty, i, k, row, zero, one;# TriangulizeMat( mat ); m := Length(mat); n := Length(mat[1]); zero := Zero( mat[1][1] ); one := One( mat[1][1] ); min := Minimum( m, n ); # insert empty rows to bring the leading term of each row on the diagonal empty := 0*mat[1]; i := 1; while i <= Length(mat) do if i < n and mat[i][i] = zero then for k in Reversed([i..Minimum(Length(mat),n-1)]) do mat[k+1] := mat[k]; od; mat[i] := empty; fi; i := i+1; od; for i in [ Length(mat)+1 .. n ] do mat[i] := empty; od; # 'mat' now looks like [ [1,2,0,2], [0,0,0,0], [0,0,1,3], [0,0,0,0] ], # and the solutions can be read in those columns with a 0 on the diagonal # by replacing this 0 by a -1, in this example [2,-1,0,0], [2,0,3,-1]. nullspace := []; for k in Reversed([1..n]) do if mat[k][k] = zero then row := []; for i in [1..k-1] do row[n-i+1] := -mat[i][k]; od; row[n-k+1] := one; for i in [k+1..n] do row[n-i+1] := zero; od; ConvertToVectorRepNC( row ); Add( nullspace, row ); fi; od; return nullspace; end ); #InstallMethod(TriangulizedNullspaceMat,"generic method", # [IsOrdinaryMatrix], # function ( mat ) # # triangulize the transposed of the matrix # return TriangulizedNullspaceMatNT( # MutableTransposedMat( Reversed( mat ) ) ); #end ); #InstallMethod(TriangulizedNullspaceMatDestructive,"generic method", # [IsOrdinaryMatrix], # function ( mat ) # # triangulize the transposed of the matrix # return TriangulizedNullspaceMatNT( # MutableTransposedMatDestructive( Reversed( mat ) ) ); #end ); ############################################################################# ## #M GeneralisedEigenvalues( , ) ## InstallMethod( GeneralisedEigenvalues, "for a matrix", [ IsField, IsMatrix ], function( F, A ) return Set( Factors( UnivariatePolynomialRing(F), MinimalPolynomial(F, A,1) ) ); end ); ############################################################################# ## #M GeneralisedEigenspaces( , ) ## InstallMethod( GeneralisedEigenspaces, "for a matrix", [ IsField, IsMatrix ], function( F, A ) return List( GeneralisedEigenvalues( F, A ), eval -> VectorSpace( F, TriangulizedNullspaceMat( Value( eval, A ) ) ) ); end ); ############################################################################# ## #M Eigenvalues( , ) ## InstallMethod( Eigenvalues, "for a matrix", [ IsField, IsMatrix ], function( F, A ) return List( Filtered( GeneralisedEigenvalues(F,A), eval -> DegreeOfLaurentPolynomial(eval) = 1 ), eval -> -1 * Value(eval,0) ); end ); ############################################################################# ## #M Eigenspaces( , ) ## InstallMethod( Eigenspaces, "for a matrix", [ IsField, IsMatrix ], function( F, A ) return List( Eigenvalues(F,A), eval -> VectorSpace( F, TriangulizedNullspaceMat(A - eval*One(A)) ) ); end ); ############################################################################# ## #M Eigenvectors( , ) ## InstallMethod( Eigenvectors, "for a matrix", [ IsField, IsMatrix ], function( F, A ) return Concatenation( List( Eigenspaces(F,A), esp -> AsList(Basis(esp)) ) ); end ); ############################################################################# ## #M ProjectiveOrder( ) . . . . . . . . . . . . . . . order mod scalars ## InstallMethod( ProjectiveOrder, "ordinary matrix of finite field elements", [ IsOrdinaryMatrix and IsFFECollColl ], function( mat ) local p, c; # construct the minimal polynomial of p := MinimalPolynomialMatrixNC( DefaultFieldOfMatrix(mat), mat,1 ); # check if is invertible c := CoefficientsOfUnivariatePolynomial(p); if c[1] = Zero(c[1]) then Error( "matrix must be invertible" ); fi; # compute the order of

return ProjectiveOrder(p); end ); ############################################################################# ## #M RankMat( ) . . . . . . . . . . . . . . . . . . . rank of a matrix ## InstallMethod( RankMatDestructive, "generic method for mutable matrices", [ IsMatrix and IsMutable ], function( mat ) mat:= SemiEchelonMatDestructive( mat ); if mat <> fail then mat:= Length( mat.vectors ); fi; return mat; end ); InstallMethod( RankMat, "generic method for matrices", [ IsMatrix ], mat -> RankMatDestructive( MutableCopyMat( mat ) ) ); ############################################################################# ## #M SemiEchelonMat( ) ## InstallMethod( SemiEchelonMatDestructive, "generic method for matrices", [ IsMatrix and IsMutable ], function( mat ) local zero, # zero of the field of nrows, # number of rows in ncols, # number of columns in vectors, # list of basis vectors heads, # list of pivot positions in `vectors' i, # loop over rows j, # loop over columns x, # a current element nzheads, # list of non-zero heads row, # the row of current interest inv; # inverse of a matrix entry nrows:= Length( mat ); ncols:= Length( mat[1] ); zero:= Zero( mat[1][1] ); heads:= ListWithIdenticalEntries( ncols, 0 ); nzheads := []; vectors := []; for i in [ 1 .. nrows ] do row := mat[i]; # Reduce the row with the known basis vectors. for j in [ 1 .. Length(nzheads) ] do x := row[nzheads[j]]; if x <> zero then AddRowVector( row, vectors[ j ], - x ); fi; od; j := PositionNot( row, zero ); if j <= ncols then # We found a new basis vector. inv:= Inverse( row[j] ); if inv = fail then return fail; fi; MultRowVector( row, inv ); Add( vectors, row ); Add( nzheads, j ); heads[j]:= Length( vectors ); fi; od; return rec( heads := heads, vectors := vectors ); end ); InstallMethod( SemiEchelonMat, "generic method for matrices", [ IsMatrix ], function( mat ) local copymat, v, vc, f; copymat := []; f := DefaultFieldOfMatrix(mat); for v in mat do vc := ShallowCopy(v); ConvertToVectorRepNC(vc,f); Add(copymat, vc); od; return SemiEchelonMatDestructive( copymat ); end ); ############################################################################# ## #M SemiEchelonMatTransformation( ) ## InstallMethod( SemiEchelonMatTransformation, "generic method for matrices", [ IsMatrix ], function( mat ) local copymat, v, vc, f; copymat := []; f := DefaultFieldOfMatrix(mat); for v in mat do vc := ShallowCopy(v); ConvertToVectorRepNC(vc,f); Add(copymat, vc); od; return SemiEchelonMatTransformationDestructive( copymat ); end); InstallMethod( SemiEchelonMatTransformationDestructive, "generic method for matrices", [ IsMatrix and IsMutable], function( mat ) local zero, # zero of the field of nrows, # number of rows in ncols, # number of columns in vectors, # list of basis vectors heads, # list of pivot positions in 'vectors' i, # loop over rows j, # loop over columns T, # transformation matrix coeffs, # list of coefficient vectors for 'vectors' relations, # basis vectors of the null space of 'mat' row, head, x, row2,f; nrows := Length( mat ); ncols := Length( mat[1] ); f := DefaultFieldOfMatrix(mat); if f = fail then f := mat[1][1]; fi; zero := Zero(f); heads := ListWithIdenticalEntries( ncols, 0 ); vectors := []; T := IdentityMat( nrows, f ); coeffs := []; relations := []; for i in [ 1 .. nrows ] do row := mat[i]; row2 := T[i]; # Reduce the row with the known basis vectors. for j in [ 1 .. ncols ] do head := heads[j]; if head <> 0 then x := - row[j]; if x <> zero then AddRowVector( row2, coeffs[ head ], x ); AddRowVector( row, vectors[ head ], x ); fi; fi; od; j:= PositionNot( row, zero ); if j <= ncols then # We found a new basis vector. x:= Inverse( row[j] ); if x = fail then TryNextMethod(); fi; Add( coeffs, row2 * x ); Add( vectors, row * x ); heads[j]:= Length( vectors ); else Add( relations, row2 ); fi; od; return rec( heads := heads, vectors := vectors, coeffs := coeffs, relations := relations ); end ); ############################################################################# ## #M SemiEchelonMats( ) ## InstallGlobalFunction( SemiEchelonMatsNoCo, function( mats ) local zero, # zero coefficient m, # number of rows n, # number of columns v, vectors, # list of matrices in the echelonized basis heads, # list with info about leading entries mat, # loop over generators of 'V' i, j, # loop over rows and columns of the matrix k, l, mij, scalar, x; zero:= Zero( mats[1][1][1] ); m:= Length( mats[1] ); n:= Length( mats[1][1] ); # Compute an echelonized basis. vectors := []; heads := ListWithIdenticalEntries( n, 0 ); heads := List( [ 1 .. m ], x -> ShallowCopy( heads ) ); for mat in mats do # Reduce the matrix modulo 'ech'. for i in [ 1 .. m ] do for j in [ 1 .. n ] do if heads[i][j] <> 0 and mat[i][j] <> zero then # Compute 'mat:= mat - mat[i][j] * vectors[ heads[i][j] ];' scalar:= - mat[i][j]; v:= vectors[ heads[i][j] ]; for k in [ 1 .. m ] do AddRowVector( mat[k], v[k], scalar ); od; fi; od; od; # Get the first nonzero column. i:= 1; j:= PositionNot( mat[1], zero ); while n < j and i < m do i:= i + 1; j:= PositionNot( mat[i], zero ); od; if j <= n then # We found a new basis vector. mij:= mat[i][j]; for k in [ 1 .. m ] do for l in [ 1 .. n ] do x:= Inverse( mij ); if x = fail then TryNextMethod(); fi; mat[k][l]:= mat[k][l] * x; od; od; Add( vectors, mat ); heads[i][j]:= Length( vectors ); fi; od; # Return the result. return rec( vectors := vectors, heads := heads ); end ); InstallMethod( SemiEchelonMats, "for list of matrices", [ IsList ], function( mats ) return SemiEchelonMatsNoCo( List( mats, x -> MutableCopyMat(x) ) ); end ); InstallMethod( SemiEchelonMatsDestructive, "for list of matrices", [ IsList ], function( mats ) return SemiEchelonMatsNoCo( mats ); end ); ############################################################################# ## #M TransposedMat( ) . . . . . . . . . . . . . transposed of a matrix ## InstallOtherMethod( TransposedMat, "generic method for matrices and lists", [ IsList ], MutableTransposedMat ); ############################################################################# ## #M TransposedMatDestructive( ) . . . . . . . . transposed of a matrix ## InstallMethod( TransposedMatDestructive, "generic method for matrices", [ IsMatrix ], MutableTransposedMatDestructive ); InstallOtherMethod(TransposedMatDestructive, "method for empty matrices",[IsList], function(mat) if mat<>[] and mat<>[[]] then TryNextMethod(); fi; return mat; end); ############################################################################ ## #M IsMonomialMatrix( ) ## InstallMethod( IsMonomialMatrix, "generic method for matrices", [ IsMatrix ], function( M ) local zero, # zero of the base ring len, # length of rows found, # store positions of nonzero elements row, # loop over rows j; # position of first non-zero element zero:= Zero(M[1][1]); len:= Length( M[1] ); if Length( M ) <> len then return false; fi; found:= BlistList( M, [] ); for row in M do j := PositionNot( row, zero ); if len < j or found[j] then return false; fi; if PositionNot( row, zero, j ) <= len then return false; fi; found[j] := true; od; return true; end ); ########################################################################## ## #M InverseMatMod( , ) ## InstallMethod( InverseMatMod, "generic method for matrix and integer", IsCollCollsElms, [ IsMatrix, IsInt ], function( mat, m ) local n, MM, inv, perm, i, pj, elem, liste, l; if Length(mat) <> Length(mat[1]) then Error( " must be a square matrix" ); fi; MM := List( mat, x -> List( x, y -> y mod m ) ); n := Length(MM); # construct the identity matrix inv := IdentityMat( n, Cyclotomics ); perm := []; # loop over the rows for i in [ 1 .. n ] do pj := 1; while MM[i][pj] = 0 do pj := pj + 1; if pj > n then # is not invertible mod return fail; fi; od; perm[pj] := i; elem := MM[i][pj]; MM[i] := List( MM[i], x -> (x/elem) mod m ); inv[i] := List( inv[i], x -> (x/elem) mod m ); liste := [ 1 .. i-1 ]; Append( liste, [i+1..n] ); for l in liste do elem := MM[l][pj]; MM[l] := MM[l] - MM[i] * elem; MM[l] := List( MM[l], x -> x mod m ); inv[l] := inv[l] - inv[i] * elem; inv[l] := List( inv[l], x -> x mod m ); od; od; return List( perm, i->inv[i] ); end ); ############################################################################# ## #M KroneckerProduct( , ) ## InstallMethod( KroneckerProduct, "generic method for matrices", IsIdenticalObj, [ IsMatrix, IsMatrix ], function ( mat1, mat2 ) local i, row1, row2, row, kroneckerproduct; kroneckerproduct := []; for row1 in mat1 do for row2 in mat2 do row := []; for i in row1 do Append( row, i * row2 ); od; #T application of the new 'AddRowVector' function? ConvertToVectorRepNC( row ); Add( kroneckerproduct, row ); od; od; return kroneckerproduct; end ); ############################################################################# ## #M SolutionMat( , ) . . . . . . . . . . one solution of equation ## ## One solution of * = or `fail'. ## InstallMethod( SolutionMatDestructive, "generic method", IsCollsElms, [ IsOrdinaryMatrix and IsMutable, IsRowVector and IsMutable], function( mat, vec ) local i,ncols,sem, vno, z,x, row, sol; ncols := Length(vec); z := Zero(mat[1][1]); sol := ListWithIdenticalEntries(Length(mat),z); ConvertToVectorRepNC(sol); if ncols <> Length(mat[1]) then Error("SolutionMat: matrix and vector incompatible"); fi; sem := SemiEchelonMatTransformationDestructive(mat); for i in [1..ncols] do vno := sem.heads[i]; if vno <> 0 then x := vec[i]; if x <> z then AddRowVector(vec, sem.vectors[vno], -x); AddRowVector(sol, sem.coeffs[vno], x); fi; fi; od; if IsZero(vec) then return sol; else return fail; fi; end); #InstallMethod( SolutionMatNoCo, # "generic method for ordinary matrix and vector", # IsCollsElms, # [ IsOrdinaryMatrix, # IsRowVector ], #function ( mat, vec ) # local h, v, tmp, i, l, r, s, c, zero; # # # solve * x = . # vec := ShallowCopy( vec ); # l := Length( mat ); # r := 0; # zero := Zero( mat[1][1] ); # Info( InfoMatrix, 1, "SolutionMat called" ); # # # Run through all columns of the matrix. # c := 1; # while c <= Length( mat[ 1 ] ) and r < l do # # # Find a nonzero entry in this column. # s := r + 1; # while s <= l and mat[ s ][ c ] = zero do s := s + 1; od; # # # If there is a nonzero entry, # if s <= l then # # # increment the rank. # Info( InfoMatrix, 2, " nonzero columns ", c ); # r := r + 1; # # # Make its row the current row and normalize it. # tmp := mat[ s ][ c ] ^ -1; # v := mat[ s ]; mat[ s ] := mat[ r ]; mat[ r ] := tmp * v; # v := vec[ s ]; vec[ s ] := vec[ r ]; vec[ r ] := tmp * v; # # # Clear all entries in this column. # for s in [ 1 .. Length( mat ) ] do # if s <> r and mat[ s ][ c ] <> zero then # tmp := mat[ s ][ c ]; # mat[ s ] := mat[ s ] - tmp * mat[ r ]; # vec[ s ] := vec[ s ] - tmp * vec[ r ]; # fi; # od; # fi; # c := c + 1; # od; # # # Find a solution. # for i in [ r + 1 .. l ] do # if vec[ i ] <> zero then return fail; fi; # od; # h := []; # s := Length( mat[ 1 ] ); # v := Zero( mat[ 1 ][ 1 ] ); # r := 1; # c := 1; # while c <= s and r <= l do # while c <= s and mat[ r ][ c ] = zero do # c := c + 1; # Add( h, v ); # od; # if c <= s then # Add( h, vec[ r ] ); # r := r + 1; # c := c + 1; # fi; # od; # while c <= s do Add( h, v ); c := c + 1; od; # # Info( InfoMatrix, 1, "SolutionMat returns" ); # return h; #end ); # InstallMethod( SolutionMat, "generic method for ordinary matrix and vector", IsCollsElms, [ IsOrdinaryMatrix, IsRowVector ], function ( mat, vec ) return SolutionMatDestructive( MutableCopyMat( mat ), ShallowCopy(vec) ); end ); #InstallMethod( SolutionMatDestructive, # "generic method for ordinary matrix and vector", # IsCollsElms, # [ IsOrdinaryMatrix, # IsRowVector ], # function ( mat, vec ) # return SolutionMatNoCo( MutableTransposedMatDestructive( mat ), # vec ); #end ); ############################################################################ ## #M SumIntersectionMat( , ) . . sum and intersection of two spaces ## ## performs Zassenhaus' algorithm to compute bases for the sum and the ## intersection of spaces generated by the rows of the matrices , . ## ## returns a list of length 2, at first position a base of the sum, at ## second position a base of the intersection. Both bases are in ## semi-echelon form. ## InstallMethod( SumIntersectionMat, IsIdenticalObj, [ IsMatrix, IsMatrix ], function( M1, M2 ) local n, # number of columns mat, # matrix for Zassenhaus algorithm zero, # zero vector v, # loop over 'M1' and 'M2' heads, # list of leading positions sum, # base of the sum i, # loop over rows of 'mat' int; # base of the intersection if Length( M1 ) = 0 then return [ M2, M1 ]; elif Length( M2 ) = 0 then return [ M1, M2 ]; elif Length( M1[1] ) <> Length( M2[1] ) then Error( "dimensions of matrices are not compatible" ); elif Zero( M1[1][1] ) <> Zero( M2[1][1] ) then Error( "fields of matrices are not compatible" ); fi; n:= Length( M1[1] ); mat:= []; zero:= Zero( M1[1] ); # Set up the matrix for Zassenhaus' algorithm. mat:= []; for v in M1 do v:= ShallowCopy( v ); Append( v, v ); ConvertToVectorRepNC( v ); Add( mat, v ); od; for v in M2 do v:= ShallowCopy( v ); Append( v, zero ); ConvertToVectorRepNC( v ); Add( mat, v ); od; # Transform `mat' into semi-echelon form. mat := SemiEchelonMatDestructive( mat ); heads := mat.heads; mat := mat.vectors; # Extract the bases for the sum \ldots sum:= []; for i in [ 1 .. n ] do if heads[i] <> 0 then Add( sum, mat[ heads[i] ]{ [ 1 .. n ] } ); fi; od; # \ldots and the intersection. int:= []; for i in [ n+1 .. Length( heads ) ] do if heads[i] <> 0 then Add( int, mat[ heads[i] ]{ [ n+1 .. 2*n ] } ); fi; od; # return the result return [ sum, int ]; end ); ############################################################################# ## #M TriangulizeMat( ) . . . . . bring a matrix in upper triangular form ## InstallMethod( TriangulizeMat, "generic method for mutable matrices", [ IsMatrix and IsMutable ], function ( mat ) local m, n, i, j, k, row, zero, x, row2; Info( InfoMatrix, 1, "TriangulizeMat called" ); if not IsEmpty( mat ) then # get the size of the matrix m := Length(mat); n := Length(mat[1]); zero := Zero( mat[1][1] ); # make sure that the rows are mutable for i in [ 1 .. m ] do if not IsMutable( mat[i] ) then mat[i]:= ShallowCopy( mat[i] ); fi; od; # run through all columns of the matrix i := 0; for k in [1..n] do # find a nonzero entry in this column j := i + 1; while j <= m and mat[j][k] = zero do j := j + 1; od; # if there is a nonzero entry if j <= m then # increment the rank Info( InfoMatrix, 2, " nonzero columns: ", k ); i := i + 1; # make its row the current row and normalize it row := mat[j]; mat[j] := mat[i]; x:= Inverse( row[k] ); if x = fail then TryNextMethod(); fi; MultRowVector( row, x ); mat[i] := row; # clear all entries in this column for j in [1..i-1] do row2 := mat[j]; x := row2[k]; if x <> zero then AddRowVector( row2, row, - x ); fi; od; for j in [i+1..m] do row2 := mat[j]; x := row2[k]; if x <> zero then AddRowVector( row2, row, - x ); fi; od; fi; od; fi; Info( InfoMatrix, 1, "TriangulizeMat returns" ); end ); InstallOtherMethod( TriangulizeMat, "for an empty list", [ IsList and IsEmpty], function( m ) return; end ); InstallMethod( TriangulizedMat, "generic method for matrices", [ IsMatrix ], function ( mat ) local m; m:=List(mat,ShallowCopy); TriangulizeMat(m); return m; end); ############################################################################# ## #M UpperSubdiagonal( , ) ## InstallMethod( UpperSubdiagonal, [ IsMatrix, IsPosInt ], function( mat, l ) local dim, exp, i; # collect exponents in dim := Length(mat); exp := []; # run through the diagonal for i in [ 1 .. dim-l ] do Add( exp, mat[i][l+i] ); od; # and return return exp; end ); ############################################################################# ## #F BaseFixedSpace( ) . . . . . . . . . . . . calculate fixed points ## ## 'BaseFixedSpace' returns a base of the vector space $V$ such that ## $M v = v$ for all $v$ in $V$ and all matrices $M$ in the list . ## InstallGlobalFunction( BaseFixedSpace, function( matrices ) local I, # identity matrix size, # dimension of vector space E, # linear system M, # one matrix of 'matrices' N, # M - I j; I := matrices[1]^0; size := Length(I); E := List( [ 1 .. size ], x -> [] ); for M in matrices do N := M - I; for j in [ 1..size ] do Append( E[ j ], N[ j ] ); od; od; return NullspaceMatDestructive( E ); end ); ########################################################################## ## #F BaseSteinitzVectors( , ) ## ## find vectors extending mat to a basis spanning the span of . ## 'BaseSteinitz' returns a ## record describing a base for the factorspace and ways to decompose ## vectors: ## ## zero: zero of and ## factorzero: zero of complement ## subspace: triangulized basis of ## factorspace: base of a complement of in ## heads: a list of integers i_j, such that if i_j>0 then a vector ## with head j is at position i_j in factorspace. If i_j<0 ## then the vector is in subspace. ## InstallGlobalFunction( BaseSteinitzVectors, function(bas,mat) local z,l,b,i,j,k,stop,v,dim,h,zv; # catch trivial case if Length(bas)=0 then return rec(subspace:=[],factorspace:=[]); fi; z:=Zero(bas[1][1]); zv:=Zero(bas[1]); if Length(mat)>0 then mat:=MutableCopyMat(mat); TriangulizeMat(mat); fi; bas:=MutableCopyMat(bas); dim:=Length(bas[1]); l:=Length(bas)-Length(mat); # missing dimension b:=[]; h:=[]; i:=1; j:=1; while Length(b)k[j]<>z); if v<>fail then # add the vector v:=bas[v]; v:=1/v[j]*v; # normed Add(b,v); h[j]:=Length(b); # if fail, then this dimension is only dependent (and not needed) fi; else stop:=true; # check whether we are running to fake zero columns if i<=Length(mat) then # has a step, clean with basis vector v:=mat[i]; v:=1/v[j]*v; # normed h[j]:=-i; else v:=fail; fi; fi; if v<>fail then # clean j-th component from bas with v for k in [1..Length(bas)] do if not IsZero(bas[k][j]) then bas[k]:=bas[k]-bas[k][j]/v[j]*v; fi; od; v:=Zero(v); bas:=Filtered(bas,k->k<>v); fi; j:=j+1; until stop; i:=i+1; od; # add subspace indices while i<=Length(mat) do if mat[i][j]<>z then h[j]:=-i; i:=i+1; fi; j:=j+1; od; return rec(factorspace:=b, factorzero:=zv, subspace:=mat, heads:=h); end ); ############################################################################# ## #F BlownUpMat( , ) ## InstallGlobalFunction( BlownUpMat, function ( B, mat ) local result, # blown up matrix, result vectors, # basis vectors of 'B' row, # loop over rows of 'mat' b, # loop over 'vectors' resrow, # one row of 'result' entry; # loop over 'row' vectors:= BasisVectors( B ); result:= []; for row in mat do for b in vectors do resrow:= []; for entry in row do Append( resrow, Coefficients( B, entry * b ) ); od; ConvertToVectorRepNC( resrow ); Add( result, resrow ); od; od; # Return the result. return result; end ); ############################################################################# ## #F BlownUpVector( , ) ## InstallGlobalFunction( BlownUpVector, function ( B, vector ) local result, # blown up vector, result entry; # loop over 'vector' result:= []; for entry in vector do Append( result, Coefficients( B, entry ) ); od; ConvertToVectorRepNC( result ); # Return the result. return result; end ); ############################################################################# ## #F IdentityMat( [, ] ) . . . . . . . . identity matrix of a given size ## InstallGlobalFunction( IdentityMat, function ( arg ) local id, m, zero, one, row, i, f; # check the arguments and get dimension, zero and one if Length(arg) = 1 then m := arg[1]; zero := 0; one := 1; f := Rationals; elif Length(arg) = 2 and IsRing(arg[2]) then m := arg[1]; zero := Zero( arg[2] ); one := One( arg[2] ); f := arg[2]; if one = fail then Error( "ring must be a ring-with-one" ); fi; elif Length(arg) = 2 then m := arg[1]; zero := Zero( arg[2] ); one := One( arg[2] ); f := Ring( one, arg[2] ); else Error("usage: IdentityMat( [, ] )"); fi; # special treatment for 0-dimensional spaces if m=0 then return NullMapMatrix; fi; # make an empty row row := ListWithIdenticalEntries(m,zero); ConvertToVectorRepNC(row,f); # make the identity matrix id := []; for i in [1..m] do id[i] := ShallowCopy( row ); id[i][i] := one; od; ConvertToMatrixRep(id,f); # return the identity matrix return id; end ); ############################################################################# ## #F NullMat( , [, ] ) . . . . . . . . . null matrix of a given size ## InstallGlobalFunction( NullMat, function ( arg ) local null, m, n, zero, row, i, k, f; if Length(arg) = 2 then m := arg[1]; n := arg[2]; f := Rationals; elif Length(arg) = 3 and IsRing(arg[3]) then m := arg[1]; n := arg[2]; f := arg[3]; elif Length(arg) = 3 then m := arg[1]; n := arg[2]; f := Ring(One(arg[3]), arg[3]); else Error("usage: NullMat( , [, ] )"); fi; zero := Zero(f); # make an empty row row := ListWithIdenticalEntries(n,zero); ConvertToVectorRepNC( row, f ); # make the null matrix null := []; for i in [1..m] do null[i] := ShallowCopy( row ); od; ConvertToMatrixRep(null,f); # return the null matrix return null; end ); ############################################################################# ## #F NullspaceModQ( , ) . . . . . . . . . . . nullspace of mod ## ## must be a matrix of integers modulo and a prime power. Then ## 'NullspaceModQ' returns the set of all vectors of integers modulo , ## which solve the homogeneous equation system given by modulo . ## InstallGlobalFunction( NullspaceModQ, function( E, q ) local facs, # factors of p, # prime of facs pex, # p-power n, # = p^n field, # field with p elements B, # E over GF(p) null, # basis of nullspace of B elem, # all elements solving E mod p^i-1 e, # one elem r, # inhomogenous part mod p^i-1 newelem, # all elements solving E mod p^i sol, # solution of E * x = r mod p^i ran, new, o, j, i,k; # factorize q facs := FactorsInt( q ); p := facs[1]; n := Length( facs ); field := GF(p); # solve homogeneous system mod p B := One( field ) * E; null := NullspaceMat( B ); if null = [] then return [ListWithIdenticalEntries (Length(E),0)]; fi; # set up elem := List( AsList( FreeLeftModule(field,null,"basis") ), x -> List( x, IntFFE ) ); #T ! newelem := [ ]; o := One( field ); ran:=[1..Length(null[1])]; # run trough powers for i in [ 2..n ] do pex:=p^(i-1); for e in elem do #r := o * ( - (e * E) / (p ^ ( i - 1 ) ) ); r := o * ( - (e * E) / pex ); sol := SolutionMat( B, r ); if sol <> fail then # accessing the elements of the compact vector `sol' # frequently would be very expensive sol:=List(sol,IntFFE); for j in [ 1..Length( elem ) ] do #new := e + ( p^(i-1) * List( o * elem[j] + sol, IntFFE ) ); new:=ShallowCopy(e); for k in ran do #new[k]:=new[k]+pex * IntFFE(o*elem[j][k]+ sol[k]); new[k]:=new[k]+pex * ((elem[j][k]+ sol[k]) mod p); od; #T ! MakeImmutable(new); # otherwise newelem does not remember # it is sorted! AddSet( newelem, new ); od; fi; od; if Length( newelem ) = 0 then return []; fi; elem := newelem; newelem := [ ]; od; return elem; end ); ############################################################################# ## #F BasisNullspaceModN( , ) . . . . . . . . nullspace of mod ## ## must be a matrix of integers modulo and a positive integer. ## Then 'NullspaceModQ' returns a set of vectors such that every ## such that = 0 modulo can be expressed by a Z-linear combination ## of elements of . ## InstallGlobalFunction (BasisNullspaceModN, function (M, n) local snf, null, nullM, i, gcdex; # if n is a prime, Gaussian elimination is fastest if IsPrimeInt (n) then return List (NullspaceMat (M*One(GF(n))), v -> List (v, IntFFE)); fi; # compute the Smith normal form S for M, i.e., S = R M C snf := NormalFormIntMat (M, 1+4); # compute the nullspace of S mod n null := IdentityMat (Length (M)); for i in [1..snf.rank] do null[i][i] := n/GcdInt (n, snf.normal[i][i]); od; # nullM = null*R is the nullspace of M C mod n # since solutions do not change under elementary matrices # nullM is also the nullspace for M nullM := null*snf.rowtrans mod n; Assert (1, ForAll (nullM, v -> v*M mod n =0*M[1])); return nullM; end); ############################################################################# ## #F PermutationMat( , [, ] ) . . . . . . permutation matrix ## InstallGlobalFunction( PermutationMat, function( arg ) local i, # loop variable perm, # permutation dim, # desired dimension of the permutation matrix F, # field of the matrix entries (defauled to 'Rationals') mat; # matrix corresponding to 'perm', result if not ( ( Length( arg ) = 2 or Length( arg ) = 3 ) and IsPerm( arg[1] ) and IsInt( arg[2] ) ) then Error( "usage: PermutationMat( , [, ] )" ); fi; perm:= arg[1]; dim:= arg[2]; if Length( arg ) = 2 then F:= Rationals; else F:= arg[3]; fi; mat:= NullMat( dim, dim, F ); for i in [ 1 .. dim ] do mat[i][ i^perm ]:= One( F ); od; return mat; end ); ############################################################################# ## #F DiagonalMat( ) ## InstallGlobalFunction( DiagonalMat, function( vector ) local zerovec, M, i; M:= []; zerovec:= Zero( vector[1] ); zerovec:= List( vector, x -> zerovec ); for i in [ 1 .. Length( vector ) ] do M[i]:= ShallowCopy( zerovec ); M[i][i]:= vector[i]; ConvertToVectorRepNC(M[i]); od; ConvertToMatrixRep( M ); return M; end ); ############################################################################# ## #F ReflectionMat( ) #F ReflectionMat( , ) #F ReflectionMat( , ) #F ReflectionMat( , , ) ## InstallGlobalFunction( ReflectionMat, function( arg ) local coeffs, # coefficients vector, first argument w, # root of unity, second argument (optional) conj, # conjugation function, third argument (optional) M, # matrix of the reflection, result n, # length of 'coeffs' one, # identity of the ring over that 'coeffs' is written c, # coefficient of 'M' i, # loop over rows of 'M' j, # loop over columns of 'M' row; # one row of 'M' # Get and check the arguments. if Length( arg ) < 1 or 3 < Length( arg ) or not IsList( arg[1] ) then Error( "usage: ReflectionMat( [, ] [, ] )" ); fi; coeffs:= arg[1]; if Length( arg ) = 1 then w:= -1; conj:= List( coeffs, ComplexConjugate ); elif Length( arg ) = 2 then if not IsFunction( arg[2] ) then w:= arg[2]; conj:= List( coeffs, ComplexConjugate ); else w:= -1; conj:= arg[2]; if not IsFunction( conj ) then Error( " must be a function" ); fi; conj:= List( coeffs, conj ); fi; elif Length( arg ) = 3 then conj:= arg[2]; if not IsFunction( conj ) then Error( " must be a function" ); fi; conj:= List( coeffs, conj ); w:= arg[3]; fi; # Construct the matrix. M:= []; one:= coeffs[1] ^ 0; w:= w * one; n:= Length( coeffs ); c:= ( w - one ) / ( coeffs * conj ); for i in [ 1 .. n ] do row:= []; for j in [ 1 .. n ] do row[j]:= conj[i] * c * coeffs[j]; od; row[i]:= row[i] + one; ConvertToVectorRepNC( row ); M[i]:= row; od; ConvertToMatrixRep( M ); # Return the result. return M; end ); ######################################################################### ## #F RandomInvertibleMat( [, ] ) . . . make a random invertible matrix ## ## 'RandomInvertibleMat' returns a invertible random matrix with rows ## and columns with elements taken from the ring , which defaults to ## 'Integers'. ## InstallGlobalFunction( RandomInvertibleMat, function ( arg ) local mat, m, R, i, row, k; # check the arguments and get the list of elements if Length(arg) = 1 then m := arg[1]; R := Integers; elif Length(arg) = 2 then m := arg[1]; R := arg[2]; else Error("usage: RandomInvertibleMat( [, ] )"); fi; # now construct the random matrix mat := []; for i in [1..m] do repeat row := []; for k in [1..m] do row[k] := Random( R ); od; ConvertToVectorRepNC( row, R ); mat[i] := row; until NullspaceMat( mat ) = []; od; ConvertToMatrixRep( mat, R ); return mat; end ); ############################################################################# ## #F RandomMat( , [, ] ) . . . . . . . . . . . make a random matrix ## ## 'RandomMat' returns a random matrix with rows and columns with ## elements taken from the ring , which defaults to 'Integers'. ## InstallGlobalFunction( RandomMat, function ( arg ) local mat, m, n, R, i, row, k; # check the arguments and get the list of elements if Length(arg) = 2 then m := arg[1]; n := arg[2]; R := Integers; elif Length(arg) = 3 then m := arg[1]; n := arg[2]; R := arg[3]; else Error("usage: RandomMat( , [, ] )"); fi; # now construct the random matrix mat := []; for i in [1..m] do row := []; for k in [1..n] do row[k] := Random( R ); od; ConvertToVectorRepNC( row, R ); mat[i] := row; od; # put into optimal form ConvertToMatrixRep(mat); return mat; end ); ############################################################################# ## #F RandomUnimodularMat( ) . . . . . . . . . . random unimodular matrix ## InstallGlobalFunction( RandomUnimodularMat, function ( m ) local mat, c, i, j, k, l, a, b, v, w, gcd; # start with the identity matrix mat := IdentityMat( m ); for c in [1..m] do # multiply two random rows with a random? unimodular 2x2 matrix i := Random([1..m]); repeat j := Random([1..m]); until j <> i; repeat a := Random( Integers ); b := Random( Integers ); gcd := Gcdex( a, b ); until gcd.gcd = 1; v := mat[i]; w := mat[j]; mat[i] := ShallowCopy(gcd.coeff1 * v + gcd.coeff2 * w); mat[j] := ShallowCopy(gcd.coeff3 * v + gcd.coeff4 * w); # multiply two random cols with a random? unimodular 2x2 matrix k := Random([1..m]); repeat l := Random([1..m]); until l <> k; repeat a := Random( Integers ); b := Random( Integers ); gcd := Gcdex( a, b ); until gcd.gcd = 1; for i in [1..m] do v := mat[i][k]; w := mat[i][l]; mat[i][k] := gcd.coeff1 * v + gcd.coeff2 * w; mat[i][l] := gcd.coeff3 * v + gcd.coeff4 * w; ConvertToVectorRepNC( mat[i] ); od; od; return mat; end ); ############################################################################# ## #F SimultaneousEigenvalues( , ) . . . . . . . . .eigenvalues ## ## The matgroup generated by must be an abelian p-group of ## exponent . The matrices in matlist must be matrices over GF() ## for some prime . Then the eigenvalues of in the splitting field ## GF(^r) for some r are powers of an element ksi in the splitting field, ## which is of order . ## ## 'SimultaneousEigenspaces' returns a matrix of intergers mod , say ## (a_{i,j}), such that the power ksi^a_{i,j} is an eigenvalue of the i-th ## matrix in and the eigenspaces of the different matrices to the ## eigenvalues ksi^a_{i,j} for fixed j are equal. ## InstallGlobalFunction( SimultaneousEigenvalues, function( arg ) local matlist, expo, q, # characteristic of field of matrices r, # such that ^r is splitting field field, # GF(^r) ksi, # -root of field eival, # exponents of eigenvalues of the matrices eispa, # eigenspaces of the matrices eigen, # exponents of simultaneous eigenvalues I, # identity matrix w, # ksi^w is candidate for a eigenvalue null, # basis of nullspace i, Split; Split := function( space, i ) local int, # intersection of two row spaces j; for j in [1..Length(eival[i])] do if 0 < Length( eispa[i][j] ) then int := SumIntersectionMat( space, eispa[i][j] )[2]; if 0 < Length( int ) then Append( eigen[i], List( int, x -> eival[i][j] ) ); if i < Length( matlist ) then Split( int, i+1 ); fi; fi; fi; od; end; matlist := arg[1]; expo := arg[2]; # compute ksi if Length( arg ) = 2 then q := Characteristic( matlist[1][1][1] ); # get splitting field r := 1; while EuclideanRemainder( q^r - 1, expo ) <> 0 do r := r+1; od; field := GF(q^r); ksi := GeneratorsOfField(field)[1]^((q^r - 1) / expo); else ksi := arg[3]; fi; # set up eigenvalues and spaces and Idmat eival := List( matlist, x -> [] ); eispa := List( matlist, x -> [] ); I := matlist[1]^0; # calculate eigenvalues and spaces for each matrix for i in [1..Length(matlist)] do for w in [0..expo-1] do null := NullspaceMat( matlist[i] - (ksi^w * I) ); if 0 < Length(null) then Add( eival[i], w ); Add( eispa[i], null ); fi; od; od; # now make the eigenvalues simultaneous eigen := List( matlist, x -> [] ); for i in [1..Length(eival[1])] do Append( eigen[1], List( eispa[1][i], x -> eival[1][i] ) ); if Length( matlist ) > 1 then Split( eispa[1][i], 2 ); fi; od; # return return eigen; end ); ############################################################################# ## #F FlatBlockMat( ) . . . . . . . . . . . convert block mat to mat ## InstallGlobalFunction( FlatBlockMat, function( block ) local d, l, mat, i, j, h, k, a, b; d := Length( block ); l := Length( block[1][1] ); mat := List( [1..d*l], x -> List( [1..d*l], y -> false ) ); for i in [1..d] do for j in [1..d] do for h in [1..l] do for k in [1..l] do a := (i-1)*l + h; b := (j-1)*l + k; mat[a][b] := block[i][j][h][k]; od; od; od; od; return mat; end ); ############################################################################# ## #F DirectSumMat( ) . . . . . . . . . . . create block diagonal mat #F DirectSumMat( mat1,..,matn ) . . . . . . . . . create block diagonal mat ## InstallGlobalFunction( DirectSumMat, function (arg) local c, r, res, m, f, F; if Length(arg)=1 and not IsMatrix(arg[1]) then arg:=arg[1]; fi; f:=function(m) if Length(m)=0 then return 0; else return Length(m[1]); fi; end; r:=1; m:=[ ]; while m = [ ] and r <= Length( arg ) do m:= arg[r]; r:=r+1; od; if m <> [ ] then F:= DefaultField( m[1][1] ); else F:= Rationals; fi; res:=List(NullMat(Sum(arg,Length),Sum(arg,f),F),ShallowCopy); r:=0; c:=0; for m in arg do res{r+[1..Length(m)]}{c+[1..f(m)]}:=m; r:=r+Length(m); c:=c+f(m); od; return res; end ); ############################################################################# ## #F TraceMat( ) . . . . . . . . . . . . . . . . . . . trace of a matrix ## InstallMethod( TraceMat, "method for lists", [ IsList ], function ( mat ) local trc, m, i; # check that the element is a square matrix m := Length(mat); if m <> Length(mat[1]) then Error("TraceMat: must be a square matrix"); fi; # sum all the diagonal entries trc := mat[1][1]; for i in [2..m] do trc := trc + mat[i][i]; od; # return the trace return trc; end ); ############################################################################# ## #M Trace( ) . . . . . . . . . . . . . . . . . . . . . . for a matrix ## InstallOtherMethod( Trace, "generic method for matrices", [ IsMatrix ], TraceMat ); ############################################################################# ## #M JordanDecomposition( ) ## InstallMethod( JordanDecomposition, "method for matrices", [IsMatrix], function( mat ) local F,p,B,f,g,fac,ff,h,w; # The algorithm is due to R. Beals F:= DefaultFieldOfMatrix( mat ); if F = fail then TryNextMethod(); fi; p:= Characteristic( F ); # First we determine a squarefree polynomial 'g' such that 'g^d(mat)=0'. f:= CharacteristicPolynomial( F, F, mat ); if p = 0 or p > Length( mat ) then g:= f/Gcd( f, Derivative( f ) ); else fac:= Factors(f); g:= One( F ); ff:= [ ]; for h in fac do if not h in ff then g:= g*h; Add( ff, h ); fi; od; fi; if f=g then return [ mat, 0*mat ]; fi; # Now 'B' will be the semisimple part of the matrix 'mat'. w:= GcdRepresentation( g, Derivative( g ) )[2]; w:= w*g; B:= ShallowCopy( mat ); while Value( g, B ) <> 0*B do B:= B - Value( w, B ); od; return [ B, mat-B ]; end ); ############################################################################# ## #F OnSubspacesByCanonicalBasis(,) ## InstallGlobalFunction(OnSubspacesByCanonicalBasis,function( mat, obj ) local row; mat:=mat*obj; if not IsMutable(mat) then mat := MutableCopyMat(mat); else for row in [1..Length(mat)] do if not IsMutable(mat[row]) then mat[row] := ShallowCopy(mat[row]); fi; od; fi; TriangulizeMat(mat); return mat; end); ############################################################################# ## #F OnSubspacesByCanonicalBasisConcatenations(,) ## InstallGlobalFunction(OnSubspacesByCanonicalBasisConcatenations, function( bvec, obj ) local n,a,mat,r; n:=Length(obj); # acting dimension mat:=[]; a:=1; while anot IsMatrix(i)) then Error(" must be a list of matrices"); fi; fg:=[l[1][1][1]]; f:=Field(fg); for i in l do for j in i do for k in j do if not k in f then Add(fg,k); f:=Field(fg); fi; od; od; od; return f; end); ############################################################################# ## #M DefaultScalarDomainOfMatrixList ## InstallMethod(DefaultScalarDomainOfMatrixList, "generic: form ring", [IsListOrCollection], function(l) local i,j,k,fg,f; # try to find out the field if Length(l)=0 or ForAny(l,i->not IsMatrix(i)) then Error(" must be a list of matrices"); fi; fg:=[l[1][1][1]]; if Characteristic(fg)=0 then f:=DefaultField(fg); else f:=DefaultRing(fg); fi; for i in l do for j in i do for k in j do if not k in f then Add(fg,k); f:=DefaultRing(fg); fi; od; od; od; return f; end); ############################################################################# ## #F NOT READY: BaseNullspace( ) ## #T BaseNullspace := function( struct ) #T if IsMat( struct ) then #T return NullspaceMat( struct ); #T elif IsRecord( struct ) then #T if not IsBound( struct.baseNullspace ) then #T if not IsBound( struct.operations ) then #T Error( " must have 'operations' entry" ); #T fi; #T struct.baseNullspace:= #T struct.operations.BaseNullspace( struct ); #T fi; #T return struct.baseNullspace; #T else #T Error( " must be a matrix or a record" ); #T fi; #T end; ########################################################################## ## #F NOT READY: MatricesOps.InvariantForm( ) ## #T MatricesOps.InvariantForm := function( D ) #T local F, # field #T q, # size of 'F' #T A, # 'F'-algebra generated by 'D' #T nr, # word number #T word, # loop over algebra elements #T i, # loop variable #T ns, # file for a nullspace #T sb1, # standard basis of 'D' #T T, # contragredient representation #T sb2, # standard basis of 'T' #T M; # invariant form, result #T #T if not ( IsList( D ) and ForAll( D, IsMatrix ) ) then #T Error( " must be a list of matrices" ); #T elif Length( D ) = 0 then #T Error( "need at least one matrix" ); #T fi; #T #T F:= Field( Flat( D ) ); #T if not IsFinite( F ) then #T Error( "sorry, for finite fields only" ); #T fi; #T q:= Size( F ); #T #T # Search for an algebra element of nullity 1. #T # Use normed words only, that is, words of the form $I + w$. #T # Write the 'D' nullspace of the nullity 1 word to 'ns'. #T A:= Algebra( F, D ); #T nr:= 1; #T repeat #T nr:= nr + q; #T word:= ElementAlgebra( A, nr ); #T ns:= NullspaceMat( word ); #T until Length( ns ) = 1; #T #T # Compute the standard basis for the natural module of 'D', #T # starting with the word of nullity 1, write output to 'sb1' #T sb1:= BasisVectors( StandardBasis( Module( A, ns ) ) ); #T #T # Check whether the whole space is spanned. #T if Length( sb1 ) < Length( ns[1] ) then #T Error( "representation is reducible" ); #T fi; #T #T # Make the contragredient representation 'T'. #T T:= Algebra( A.field, List( D, x -> TransposedMat( x^-1 ) ) ); #T #T # Write the 'T' nullspace of the nullity 1 word to 'ns'. #T ns:= NullspaceMat( ElementAlgebra( T, nr ) ); #T #T # Compute the standard basis for the natural module of 'T', #T # starting with the word of nullity 1, write output to 'sb2' #T sb2:= BasisVectors( StandardBasis( Module( T, ns ) ) ); #T #T # If 'D' and 'T' are equivalent then #T # the invariant matrix is 'M = sb1^(-1) * sb2', #T # since 'sb1 * D[i] * sb1^(-1) = sb2 * T[i] * sb2^(-1)' implies #T # that 'D[i] * M * D[i]^{tr} = M'. #T M:= sb1^-1 * sb2; #T #T # Check for equality. #T for i in [ 1 .. Length( D ) ] do #T if D[i] * M * TransposedMat( D[i] ) <> M then #T return false; #T fi; #T od; #T #T # Return the result. #T return M; #T end; ############################################################################# ## #F BaseOrthogonalSpaceMat( ) ## InstallMethod( BaseOrthogonalSpaceMat, "for a matrix", [ IsMatrix ], mat -> NullspaceMat( TransposedMat( mat ) ) ); # simplex method, code by Ken Monks, AH #in matrix M, row reduce to get 1s #in exactly the columns given by #L a list of indices BindGlobal("TriangulizeMatPivotColumns",function(M,L) local idx,i; if L=[1..Length(L)] then TriangulizeMat(M); else idx:=Concatenation(L,Filtered([1..Length(M[1])],x->not x in L)); for i in [1..Length(M)] do M[i]:=M[i]{idx}; od; TriangulizeMat(M); idx:=ListPerm(PermList(idx)^-1,Length(M[1])); for i in [1..Length(M)] do M[i]:=M[i]{idx}; od; fi; end); #inputs a linear form c and maximizes it subject to #the constraints Ax <= b where all entries of b are nonnegative. InstallGlobalFunction(SimplexMethod,function(A,b,c) local M, n, p, vars, slackVars, i, id, bestMove, newNonzero, len, ratios, newZero, positiveRatios, point, value,Val; Val:=function(M,vars,slackVars,len,x) if x in vars then return 0; else return M[Position(slackVars,x)+1][len]; fi; end; #check the size of the data is legit n:=Size(c); p:=Size(b); if not (IsMatrix(A) and Size(A)=p and ForAny(A,R->Size(R)=n)) then Error( "usage: SimplexMethod( , , )"); fi; id:=IdentityMat(p,Rationals); #build the augmented matrix #first row M:=[Concatenation([1],-c,List([1..p+1],x->0))]; #the rest of the rows for i in [1..p] do Add(M,Concatenation([0],A[i],id[i],[b[i]])); od; len:=Size(M[1]); #initialize the feasible starting vertex if ForAll(b,x->not x<0) then vars:=[2..2+n-1]; slackVars:=[2+n..n+p+1]; else return "Invalid data: not all constraints nonnegative!"; fi; #Print("slackVars are ",slackVars ,"\n"); #Print("vars are ",vars,"\n"); #Display(M); TriangulizeMatPivotColumns(M,Concatenation([1],slackVars)); #Display(M); #bestMove is the coeff var that will become nonzero bestMove:=Minimum(List(vars,i->M[1][i])); newNonzero:=vars[Position(List(vars,i->M[1][i]),bestMove)]; #Print(newNonzero, " is the new nonzero guy \n"); while bestMove<0 do #see if figure is unbounded #Print("about to do some ratios \n"); #Print(List([1..p],x-> M[x+1][newNonzero]), " is what we're going to divide by \n"); ratios:=List([1..p], function(x) if M[x+1][newNonzero]=0 then return infinity; else return M[x+1][len]/M[x+1][newNonzero]; fi; end); #Print("done doing some ratios"); positiveRatios:=Filtered(ratios,x -> x>0); if Size(positiveRatios)=0 then return "Feasible region unbounded!"; fi; #Print("Feasible region still looks bounded. \n"); #figure out who will become zero newZero:=slackVars[Position(ratios,Minimum(positiveRatios))]; #Print(newZero, " is the new zero guy \n"); Remove(slackVars,Position(slackVars,newZero)); Remove(vars,Position(vars,newNonzero)); Add(vars,newZero); Add(slackVars,newNonzero); slackVars:=Set(slackVars); vars:=Set(vars); #Print("slackVars are ",slackVars,"\n"); #Print("vars are ",vars,"\n"); TriangulizeMatPivotColumns(M,Concatenation([1],slackVars)); #Display(M); bestMove:=Minimum(List(vars,i->M[1][i])); newNonzero:=vars[Position(List(vars,i->M[1][i]),bestMove)]; #Print(newNonzero," is the new nonzero guy"); od; #calculate the original point and the max value there point:=List([2..2+n-1],x -> Val(M,vars,slackVars,len,x)); value:=point*c; return [point,value]; end); # can do better for matrices and large exponents, preliminary improvement, # will be further improved (FL) ## InstallMethod( \^, ## "for matrices, use char. poly. for large exponents", ## [ IsMatrix, IsPosInt ], ## function(mat, n) ## local pol, indet; ## # generic method for small n, break even point probably a bit lower, ## # needs rethinking and some experiments. ## if n < 2^Length(mat) then ## return POW_OBJ_INT(mat, n); ## fi; ## pol := CharacteristicPolynomial(mat); ## indet := IndeterminateOfUnivariateRationalFunction(pol); ## # cost of this needs to be investigated ## pol := PowerMod(indet, n, pol); ## # now we are sure that we need at most Length(mat) matrix multiplications ## return Value(pol, mat); ## end); ## # next iteration, conjugate matrix such that it is often very sparse # (a companion matrix), could still be improved, maybe with kernel functions # for compact matrices (FL) BindGlobal("POW_MAT_INT", function(mat, n) local d, addb, trafo, value, t, ti, mm, pol, ind; d := Length(mat); # finding a better break even point probably also depends on q if n < 2^QuoInt(3*d,4) then return POW_OBJ_INT(mat, n); fi; # helper function to build up a semi-echelon basis addb := function(seb, v) local rows, pivots, len, vv, c, pos, i; rows := seb.vectors; pivots := seb.pivots; len := Length(rows); vv := ShallowCopy(v); for i in [1..len] do c := vv[pivots[i]]; if not IsZero(c) then AddRowVector(vv, rows[i], -c); fi; od; pos := PositionNonZero(vv); if pos <= Length(vv) then if not IsOne(vv[pos]) then vv := vv/vv[pos]; fi; Add(rows, vv); Add(pivots, pos); seb.heads[pos] := len + 1; return true; else return false; fi; end; # this returns a base change matrix such that t*m*t^-1 is block triangular # with companion matrices along the diagonal # (could/should? be improved to return t^-1, t*m*t^-1 and the # characteristic polynomial of m at the same time) trafo := function(m) local id, b, t, r, a; id := m^0; b := rec(vectors := [], pivots := [], heads := []); t := []; # maybe better start with a random vector? for a in id do r := addb(b,a); if r = true then repeat Add(t, a); a := a*m; r := addb(b,a); until r <> true; fi; od; t := Matrix(t, m); return t; end; # compared to standard method, we avoid some zero or identity matrices # and we multiply with mat from left to take advantage of sparseness of mat value := function(pol, mat) local f, c, i, val, j; f := CoefficientsOfLaurentPolynomial(pol); c := f[1]; i := Length(c); if i = 0 then return 0*mat; fi; if i = 1 then val := POW_OBJ_INT(mat, f[2]); return c[1] * val; fi; val := c[i] * mat; if not IsMutable(val[1]) then val := MutableCopyMat(val); fi; i := i-1; for j in [1..Length(mat)] do val[j][j] := val[j][j]+c[i]; od; while 1 < i do val := mat * val; i := i - 1; for j in [1..Length(mat)] do val[j][j] := val[j][j]+c[i]; od; od; if 0 <> f[2] then val := val * POW_OBJ_INT(mat, f[2]); fi; return val; end; t := trafo(mat); ti := t^-1; mm := t * mat * ti; pol := CharacteristicPolynomial(mm); ind := IndeterminateOfUnivariateRationalFunction(pol); pol := PowerMod(ind, n, pol); mm := value(pol, mm); return ti * mm * t; end); InstallMethod( \^, "for matrices, use char. poly. for large exponents", [ IsMatrix, IsPosInt ], POW_MAT_INT ); ############################################################################# ## #E gap-4r6p5/lib/upolyirr.gi0000644000175000017500000001013212172557254014114 0ustar billbill############################################################################# ## #W upolyirr.gi GAP Library Frank Lübeck ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains methods to compute irreducible univariate polynomials ## ############################################################################# ## #F AllMonicPolynomialCoeffsOfDegree( , ) . . . . . all coefficient #F lists of monic polynomials over GF() of degree ## AllMonicPolynomialCoeffsOfDegree := function(n, q) local fq, one, res, a; fq := AsSortedList(GF(q)); one := One(GF(q)); res := Tuples(fq, n); for a in res do Add(a, one); od; return res; end; ############################################################################# ## #F AllIrreducibleMonicPolynomialCoeffsOfDegree( , ) . all coefficient #F lists of irreducible monic polynomials over GF() of degree ## #V IRR_POLS_OVER_GF_CACHE: a cache for the following function ## IRR_POLS_OVER_GF_CACHE := []; ## RedCoeffDirectFun := ApplicableMethod(ReduceCoeffs,[[Z(3)],1,[Z(3)],1]); AllIrreducibleMonicPolynomialCoeffsOfDegree := function(n, q) local l, zero, i, r, p, new, neverdiv; if not IsBound(IRR_POLS_OVER_GF_CACHE[q]) then IRR_POLS_OVER_GF_CACHE[q] := []; fi; if IsBound(IRR_POLS_OVER_GF_CACHE[q][n]) then return IRR_POLS_OVER_GF_CACHE[q][n]; fi; # this is for going around converting coefficients to polynomials # and using the \mod operator for divisibility tests # (I found a speedup factor of about 6 in the example n=9, q=3) neverdiv := function(r, p) local lr, lp, rr, pp; lr := Length(r[1]); lp := Length(p); for rr in r do pp := ShallowCopy(p); # here we go around method selection which gives a 10% speedup ReduceCoeffs(pp, lp, rr, lr); ## RedCoeffDirectFun(pp, lp, rr, lr); ShrinkRowVector(pp); if Length(pp)=0 then return false; fi; od; return true; end; l := AllMonicPolynomialCoeffsOfDegree(n, q); zero := 0*Indeterminate(GF(q)); for i in [1..Int(n/2)] do r := AllIrreducibleMonicPolynomialCoeffsOfDegree(i, q); new:= []; for p in l do if neverdiv(r, p) then Add(new, p); fi; od; l := new; od; IRR_POLS_OVER_GF_CACHE[q][n] := Immutable(l); return IRR_POLS_OVER_GF_CACHE[q][n]; end; ############################################################################# ## #F CompanionMat( ## InstallGlobalFunction( CompanionMat, function ( arg ) local c, l, res, i, F, c1; # for the moment allow coefficients as well if not IsList( arg[1] ) then c := CoefficientsOfLaurentPolynomial( arg[1] ); if c[2] < 0 then Error( "This polynomial does not have a companion matrix" ); fi; F:= DefaultField( c[1] ); c1:= ListWithIdenticalEntries( c[2], Zero(F) ); Append( c1, c[1] ); c:= c1; else c := arg[1]; F:= DefaultField( c ); fi; l := Length( c ) - 1; if l = 0 then Error( "This polynomial does not have a companion matrix" ); fi; res := NullMat( l, l, F ); res[1][l] := -c[1]; for i in [2..l] do res[i][i-1] := One( F ); res[i][l] := -c[i]; od; return res; end ); ############################################################################# ## #F AllIrreducibleMonicPolynomials( , ) ## InstallGlobalFunction( AllIrreducibleMonicPolynomials, function( degree, field ) local q, coeffs, fam, nr; if not IsFinite( field ) then Error("field must be finite"); fi; q := Size(field); nr := IndeterminateNumberOfLaurentPolynomial( Indeterminate(field,"x")); coeffs := AllIrreducibleMonicPolynomialCoeffsOfDegree(degree,q); fam := FamilyObj( Zero(field) ); return List( coeffs, x -> LaurentPolynomialByCoefficients( fam, x, 0, nr ) ); end ); gap-4r6p5/lib/mapping.gd0000644000175000017500000015246312172557252013671 0ustar billbill############################################################################# ## #W mapping.gd GAP library Thomas Breuer #W & Martin Schönert #W & Frank Celler ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file declares the operations for general mappings. ## ############################################################################# ## ## <#GAPDoc Label="[1]{mapping}"> ## A general mapping F in &GAP; is described by ## its source S, its range R, and a subset Rel of the ## direct product S \times R, ## which is called the underlying relation of F. ## S, R, and Rel are generalized domains ## (see ). ## The corresponding attributes for general mappings are ## , , ## and . ## ## ##

## Note that general mappings themselves are not domains. ## One reason for this is that two general mappings with same underlying ## relation are regarded as equal only if also the sources are equal and ## the ranges are equal. ## Other, more technical, reasons are that general mappings and domains ## have different basic operations, and that general mappings are ## arithmetic objects ## (see ); ## both should not apply to domains. ##

## Each element of an underlying relation of a general mapping lies in the ## category of direct product elements ## (see ). ##

## For each s \in S, the set \{ r \in R | (s,r) \in Rel \} ## is called the set of images of s. ## Analogously, for r \in R, ## the set \{ s \in S | (s,r) \in Rel \} ## is called the set of preimages of r. ##

## The ordering of general mappings via < is defined ## by the ordering of source, range, and underlying relation. ## Specifically, if the source and range domains of map1 and ## map2 are the same, then one considers the union of the preimages ## of map1 and map2 as a strictly ordered set. ## The smaller of map1 and map2 is the one whose image is ## smaller on the first point of this sequence where they differ. ## <#/GAPDoc> ## ## <#GAPDoc Label="[2]{mapping}"> ## and ## are basic operations for general mappings. ## is secondary, its default method sets up ## a domain that delegates tasks to the general mapping. ## (Note that this allows one to handle also infinite relations by generic ## methods if source or range of the general mapping is finite.) ##

## The distinction between basic operations and secondary operations for ## general mappings may be a little bit complicated. ## Namely, each general mapping must be in one of the two categories ## , . ## (The category is defined as the disjoint ## union of these two.) ##

## For general mappings of the first category, and ## are basic operations. ## (Note that in principle it is possible to delegate ## from to .) ## Methods for the secondary operations , ## , , ## , , ## and may use ## and , respectively, ## and methods for , ## must not call the secondary operations. ## In particular, there are no generic methods for ## and . ##

## Methods for and must ## not use and ## , e.g., ## compute the intersection of the set in question with the preimage of the ## range resp. the image of the source. ##

## For general mappings of the second category (which means structure ## preserving general mappings), the situation is different. ## The set of preimages under a group homomorphism, for example, is either ## empty or can be described as a coset of the (multiplicative) kernel. ## So it is reasonable to have , ## , ## , and ## as basic operations ## here, and to make and ## secondary operations that may delegate to these. ##

## In order to avoid infinite recursions, ## we must distinguish between the two different types of mappings. ##

## (Note that the basic domain operations such as ## for the underlying relation of a general mapping may use either ## or and the ## appropriate cokernel. ## Conversely, if for the underlying relation is known ## then resp. ## may delegate to it, ## the general mapping gets the property ## for this; ## note that this is not allowed if only an enumerator of the underlying ## relation is known.) ##

## Secondary operations are ## , , ## , ; ## they may use the basic operations, and must not be used by them. ## <#/GAPDoc> ## ## <#GAPDoc Label="[3]{mapping}"> ## General mappings are arithmetic objects. ## One can form groups and vector spaces of general mappings provided ## that they are invertible or can be added and admit scalar multiplication, ## respectively. ##

## For two general mappings with same source, range, preimage, and image, ## the sum is defined pointwise, i.e., ## the images of a point under the sum is the set of all sums with ## first summand in the images of the first general mapping and ## second summand in the images of the second general mapping. ##

## Scalar multiplication of general mappings is defined likewise. ##

## The product of two general mappings is defined as the composition. ## This multiplication is always associative. ## In addition to the composition via *, ## general mappings can be composed –in reversed order– ## via . ##

## General mappings are in the category of multiplicative elements with ## inverses. ## Similar to matrices, not every general mapping has an inverse or an ## identity, and we define the behaviour of and ## for general mappings as follows. ## returns fail when called for a general mapping ## whose source and range differ, ## otherwise returns the identity mapping of the source. ## (Note that the source may differ from the preimage). ## returns fail when called for a non-bijective ## general mapping or for a general mapping whose source and range differ; ## otherwise returns the inverse mapping. ##

## Besides the usual inverse of multiplicative elements, which means that ## Inverse( g ) * g = g * Inverse( g ) ## = One( g ), ## for general mappings we have the attribute ## . ## If F is a general mapping with source S, range R, ## and underlying relation Rel then ## InverseGeneralMapping( F ) has source R, ## range S, ## and underlying relation \{ (r,s) \mid (s,r) \in Rel \}. ## For a general mapping that has an inverse in the usual sense, ## i.e., for a bijection of the source, of course both concepts coincide. ##

## may delegate to ## . ## must not delegate to ## , ## but a known value of may be fetched. ## So methods to compute the inverse of a general mapping should be ## installed for . ##

## (Note that in many respects, general mappings behave similar to matrices, ## for example one can define left and right identities and inverses, which ## do not fit into the current concepts of &GAP;.) ## <#/GAPDoc> ## ## <#GAPDoc Label="[4]{mapping}"> ## Methods for the operations , ## , ## , , ## , ## , , ## and take two arguments, a general mapping ## map and an element or collection of elements elm. ## These methods must not check whether elm lies in the source ## or the range of map. ## In the case that elm does not, fail may be returned as well ## as any other &GAP; object, and even an error message is allowed. ## Checks of the arguments are done only by the functions ## , ## , ## , ## and , ## which then delegate to the operations listed above. ## <#/GAPDoc> ## ############################################################################# ## #C IsGeneralMapping( ) ## ## <#GAPDoc Label="IsGeneralMapping"> ## ## ## ## ## Each general mapping lies in the category . ## It implies the categories ## ## and ; ## for a discussion of these implications, ## see . ## ## ## <#/GAPDoc> ## DeclareCategory( "IsGeneralMapping", IsMultiplicativeElementWithInverse and IsAssociativeElement ); ############################################################################# ## #C IsSPGeneralMapping( ) #C IsNonSPGeneralMapping( ) ## ## <#GAPDoc Label="IsSPGeneralMapping"> ## ## ## ## ## ## ## ## ## ## <#/GAPDoc> ## DeclareCategory( "IsSPGeneralMapping", IsGeneralMapping ); DeclareCategory( "IsNonSPGeneralMapping", IsGeneralMapping ); ############################################################################# ## #C IsGeneralMappingCollection( ) ## ## ## ## ## ## ## ## DeclareCategoryCollections( "IsGeneralMapping" ); ############################################################################# ## #C IsGeneralMappingFamily( ) ## ## <#GAPDoc Label="IsGeneralMappingFamily"> ## ## ## ## ## The family category of the category of general mappings. ## ## ## <#/GAPDoc> ## DeclareCategoryFamily( "IsGeneralMapping" ); ############################################################################# ## #A FamilyRange( ) ## ## <#GAPDoc Label="FamilyRange"> ## ## ## ## ## is the elements family of the family of the range of each general ## mapping in the family Fam. ## ## ## <#/GAPDoc> ## DeclareAttribute( "FamilyRange", IsGeneralMappingFamily ); ############################################################################# ## #A FamilySource( ) ## ## <#GAPDoc Label="FamilySource"> ## ## ## ## ## is the elements family of the family of the source of each general ## mapping in the family Fam. ## ## ## <#/GAPDoc> ## DeclareAttribute( "FamilySource", IsGeneralMappingFamily ); ############################################################################# ## #A FamiliesOfGeneralMappingsAndRanges( ) ## ## <#GAPDoc Label="FamiliesOfGeneralMappingsAndRanges"> ## ## ## ## ## is a list that stores at the odd positions the families of general ## mappings with source in the family Fam, at the even positions the ## families of ranges of the general mappings. ## ## ## <#/GAPDoc> ## DeclareAttribute( "FamiliesOfGeneralMappingsAndRanges", IsFamily, "mutable" ); ############################################################################# ## #P IsConstantTimeAccessGeneralMapping( ) ## ## <#GAPDoc Label="IsConstantTimeAccessGeneralMapping"> ## ## ## ## ## is true if the underlying relation of the general mapping ## map knows its value, ## and false otherwise. ##

## In the former case, map is allowed to use this list for calls to ## etc. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsConstantTimeAccessGeneralMapping", IsGeneralMapping ); ############################################################################# ## #P IsEndoGeneralMapping( ) ## ## <#GAPDoc Label="IsEndoGeneralMapping"> ## ## ## ## ## If a general mapping has this property then its source and range are ## equal. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsEndoGeneralMapping", IsGeneralMapping ); ############################################################################# ## #P IsTotal( ) . . . . . . . . test whether a general mapping is total ## ## <#GAPDoc Label="IsTotal"> ## ## ## ## ## is true if each element in the source S ## of the general mapping map has images, i.e., ## s^{map} \neq \emptyset for all s \in S, ## and false otherwise. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsTotal", IsGeneralMapping ); ############################################################################# ## #P IsSingleValued( ) . test whether a general mapping is single-valued ## ## <#GAPDoc Label="IsSingleValued"> ## ## ## ## ## is true if each element in the source S ## of the general mapping map has at most one image, i.e., ## |s^{map}| \leq 1 for all s \in S, ## and false otherwise. ##

## Equivalently, IsSingleValued( map ) is true ## if and only if the preimages of different elements in R are ## disjoint. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsSingleValued", IsGeneralMapping ); ############################################################################# ## #P IsMapping( ) ## ## <#GAPDoc Label="IsMapping"> ## ## ## ## ## A mapping map is a general mapping that assigns to each ## element elm of its source a unique element ## Image( map, elm ) of its range. ##

## Equivalently, the general mapping map is a mapping if and only if ## it is total and single-valued ## (see , ). ## ## ## <#/GAPDoc> ## DeclareSynonymAttr( "IsMapping", IsGeneralMapping and IsTotal and IsSingleValued ); ############################################################################# ## #P IsEndoMapping( ) ## ## ## ## ## ## If a mapping has this property then its source and range are ## equal and it is single valued. ## ## ## DeclareSynonymAttr( "IsEndoMapping", IsMapping and IsEndoGeneralMapping ); ############################################################################# ## #P IsInjective( ) . . . . . . test if a general mapping is injective ## ## <#GAPDoc Label="IsInjective"> ## ## ## ## ## is true if the images of different elements in the source S ## of the general mapping map are disjoint, i.e., ## x^{map} \cap y^{map} = \emptyset ## for x \neq y \in S, ## and false otherwise. ##

## Equivalently, IsInjective( map ) is true ## if and only if each element in the range of map has at most one ## preimage in S. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsInjective", IsGeneralMapping ); DeclareSynonym("IsOneToOne",IsInjective); ############################################################################# ## #P IsSurjective( ) . . . . . . test if a general mapping is surjective ## ## <#GAPDoc Label="IsSurjective"> ## ## ## ## ## is true if each element in the range R ## of the general mapping map has preimages in the source S ## of map, i.e., ## \{ s \in S \mid x \in s^{map} \} \neq \emptyset ## for all x \in R, and false otherwise. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsSurjective", IsGeneralMapping ); DeclareSynonym("IsOnto",IsSurjective); ############################################################################# ## #P IsBijective( ) . . . . . . test if a general mapping is bijective ## ## <#GAPDoc Label="IsBijective"> ## ## ## ## ## A general mapping map is bijective if and only if it is ## an injective and surjective mapping (see , ## , ). ## ## ## <#/GAPDoc> ## DeclareSynonymAttr( "IsBijective", IsSingleValued and IsTotal and IsInjective and IsSurjective ); ############################################################################# ## #A Range( ) . . . . . . . . . . . . . . . range of a general mapping ## ## <#GAPDoc Label="Range"> ## ## ## ## ## The range of a general mapping. ## ## ## <#/GAPDoc> ## DeclareAttribute( "Range", IsGeneralMapping ); ############################################################################# ## #A Source( ) . . . . . . . . . . . . . . . source of a general mapping ## ## <#GAPDoc Label="Source"> ## ## ## ## ## The source of a general mapping. ## ## ## <#/GAPDoc> ## DeclareAttribute( "Source", IsGeneralMapping ); ############################################################################# ## #A UnderlyingRelation( ) . . underlying relation of a general mapping ## ## <#GAPDoc Label="UnderlyingRelation"> ## ## ## ## ## The underlying relation of a general mapping map is the ## domain of pairs (s,r), with s in the source and r in ## the range of map (see , ## ), ## and r \in ImagesElm( map, s ). ##

## Each element of the underlying relation is represented by ## a direct product element (see ). ## ## ## <#/GAPDoc> ## DeclareAttribute( "UnderlyingRelation", IsGeneralMapping ); ############################################################################# ## #A UnderlyingGeneralMapping( ) ## ## <#GAPDoc Label="UnderlyingGeneralMapping"> ## ## ## ## ## attribute for underlying relations of general mappings ## ## ## <#/GAPDoc> ## DeclareAttribute( "UnderlyingGeneralMapping", IsCollection ); ############################################################################# ## #F GeneralMappingsFamily( , ) ## ## <#GAPDoc Label="GeneralMappingsFamily"> ## ## ## ## ## All general mappings with same source family FS and same range ## family FR lie in the family ## GeneralMappingsFamily( FS, FR ). ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "GeneralMappingsFamily" ); ############################################################################# ## #F TypeOfDefaultGeneralMapping( , , ) ## ## <#GAPDoc Label="TypeOfDefaultGeneralMapping"> ## ## ## ## ## is the type of mappings with IsDefaultGeneralMappingRep with ## source source and range range and additional categories ## filter. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "TypeOfDefaultGeneralMapping" ); ############################################################################# ## #A IdentityMapping( ) . . . . . . . . identity mapping of a collection ## ## <#GAPDoc Label="IdentityMapping"> ## ## ## ## ## is the bijective mapping with source and range equal to the collection ## D, which maps each element of D to itself. ## ## ## <#/GAPDoc> ## DeclareAttribute( "IdentityMapping", IsCollection ); ############################################################################# ## #A InverseGeneralMapping( ) ## ## <#GAPDoc Label="InverseGeneralMapping"> ## ## ## ## ## The inverse general mapping of a general mapping map is ## the general mapping whose underlying relation ## (see ) contains a pair (r,s) ## if and only if the underlying relation of map contains the pair ## (s,r). ##

## See the introduction to Chapter  ## for the subtleties concerning the difference between ## and . ##

## Note that the inverse general mapping of a mapping map is ## in general only a general mapping. ## If map knows to be bijective its inverse general mapping will know ## to be a mapping. ## In this case also Inverse( map ) works. ## ## ## <#/GAPDoc> ## DeclareAttribute( "InverseGeneralMapping", IsGeneralMapping ); ############################################################################# ## #A ImagesSource( ) ## ## <#GAPDoc Label="ImagesSource"> ## ## ## ## ## is the set of images of the source of the general mapping map. ##

## delegates to , ## it is introduced only to store the image of map as attribute ## value. ## ## ## <#/GAPDoc> ## DeclareAttribute( "ImagesSource", IsGeneralMapping ); ############################################################################# ## #A PreImagesRange( ) ## ## <#GAPDoc Label="PreImagesRange"> ## ## ## ## ## is the set of preimages of the range of the general mapping map. ##

## delegates to , ## it is introduced only to store the preimage of map as attribute ## value. ## ## ## <#/GAPDoc> ## DeclareAttribute( "PreImagesRange", IsGeneralMapping ); ############################################################################# ## #O ImagesElm( , ) . . . all images of an elm under a gen. mapping ## ## <#GAPDoc Label="ImagesElm"> ## ## ## ## ## If elm is an element of the source of the general mapping ## map then returns the set of all images ## of elm under map. ##

## Anything may happen if elm is not an element of the source of ## map. ## ## ## <#/GAPDoc> ## DeclareOperation( "ImagesElm", [ IsGeneralMapping, IsObject ] ); ############################################################################# ## #O ImagesRepresentative(,) . one image of elm under a gen. mapping ## ## <#GAPDoc Label="ImagesRepresentative"> ## ## ## ## ## If elm is an element of the source of the general mapping ## map then returns either ## a representative of the set of images of elm under map ## or fail, the latter if and only if elm has no images under ## map. ##

## Anything may happen if elm is not an element of the source of ## map. ## ## ## <#/GAPDoc> ## DeclareOperation( "ImagesRepresentative", [ IsGeneralMapping, IsObject ] ); ############################################################################# ## #O ImagesSet( , ) ## ## <#GAPDoc Label="ImagesSet"> ## ## ## ## ## If elms is a subset of the source of the general mapping ## map then returns the set of all images of ## elms under map. ##

## The result will be either a proper set or a domain. ## Anything may happen if elms is not a subset of the source of ## map. ## ## ## <#/GAPDoc> ## DeclareOperation( "ImagesSet", [ IsGeneralMapping, IsCollection ] ); ############################################################################# ## #O ImageElm( , ) . . . . unique image of an elm under a mapping ## ## <#GAPDoc Label="ImageElm"> ## ## ## ## ## If elm is an element of the source of the total and single-valued ## mapping map then ## returns the unique image of elm under ## map. ##

## Anything may happen if elm is not an element of the source of ## map. ## ## ## <#/GAPDoc> ## DeclareOperation( "ImageElm", [ IsMapping, IsObject ] ); ############################################################################# ## #F Image( ) . . . . set of images of the source of a general mapping #F Image( , ) . . . . unique image of an element under a mapping #F Image( , ) . . set of images of a collection under a mapping ## ## <#GAPDoc Label="Image"> ## ## Image ## ## ## ## ## ## Image( map ) is the image of the general mapping ## map, i.e., ## the subset of elements of the range of map ## that are actually values of map. ## Note that in this case the argument may also be multi-valued. ##

## Image( map, elm ) is the image of the element ## elm of the source of the mapping map under map, ## i.e., the unique element of the range to which map maps ## elm. ## This can also be expressed as elm^map. ## Note that map must be total and single valued, ## a multi valued general mapping is not allowed ## (see ). ##

## Image( map, coll ) is the image of the subset ## coll of the source of the mapping map under map, ## i.e., the subset of the range to which map maps elements of ## coll. ## coll may be a proper set or a domain. ## The result will be either a proper set or a domain. ## Note that in this case map may also be multi-valued. ## (If coll and the result are lists then the positions of ## entries do in general not correspond.) ##

## ## delegates to when called ## with one argument, and to resp. ## when called with two arguments. ##

## If the second argument is not an element or a subset of the source of ## the first argument, an error is signalled. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "Image" ); ############################################################################# ## #F Images( ) . . . . set of images of the source of a general mapping #F Images( , ) . . . set of images of an element under a mapping #F Images( , ) . . set of images of a collection under a mapping ## ## <#GAPDoc Label="Images"> ## ## Images ## ## ## ## ## ## Images( map ) is the image of the general mapping ## map, i.e., the subset of elements of the range of map ## that are actually values of map. ##

## Images( map, elm ) is the set of images of the ## element elm of the source of the general mapping map under ## map, i.e., the set of elements of the range to which map ## maps elm. ##

## Images( map, coll ) is the set of images of the ## subset coll of the source of the general mapping map under ## map, i.e., the subset of the range to which map maps ## elements of coll. ## coll may be a proper set or a domain. ## The result will be either a proper set or a domain. ## (If coll and the result are lists then the positions of ## entries do in general not correspond.) ##

## ## delegates to when called ## with one argument, and to resp. ## when called with two arguments. ##

## If the second argument is not an element or a subset of the source of ## the first argument, an error is signalled. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "Images" ); ############################################################################# ## #O PreImagesElm( , ) . all preimages of elm under a gen. mapping ## ## <#GAPDoc Label="PreImagesElm"> ## ## ## ## ## If elm is an element of the range of the general mapping ## map then returns the set of all ## preimages of elm under map. ##

## Anything may happen if elm is not an element of the range of ## map. ## ## ## <#/GAPDoc> ## DeclareOperation( "PreImagesElm", [ IsGeneralMapping, IsObject ] ); ############################################################################# ## #O PreImageElm( , ) ## ## <#GAPDoc Label="PreImageElm"> ## ## ## ## ## If elm is an element of the range of the injective and surjective ## general mapping map then ## returns the unique preimage of elm under ## map. ##

## Anything may happen if elm is not an element of the range of ## map. ## ## ## <#/GAPDoc> ## DeclareOperation( "PreImageElm", [ IsGeneralMapping and IsInjective and IsSurjective, IsObject ] ); ############################################################################# ## #O PreImagesRepresentative( , ) . . . one preimage of an element ## under a gen. mapping ## ## <#GAPDoc Label="PreImagesRepresentative"> ## ## ## ## ## If elm is an element of the range of the general mapping ## map then returns either a ## representative of the set of preimages of elm under map or ## fail, the latter if and only if elm ## has no preimages under map. ##

## Anything may happen if elm is not an element of the range of ## map. ## ## ## <#/GAPDoc> ## DeclareOperation( "PreImagesRepresentative", [ IsGeneralMapping, IsObject ] ); ############################################################################# ## #O PreImagesSet( , ) ## ## <#GAPDoc Label="PreImagesSet"> ## ## ## ## ## If elms is a subset of the range of the general mapping map ## then returns the set of all preimages of ## elms under map. ##

## Anything may happen if elms is not a subset of the range of ## map. ## ## ## <#/GAPDoc> ## DeclareOperation( "PreImagesSet", [ IsGeneralMapping, IsCollection ] ); ############################################################################# ## #F PreImage( ) . . set of preimages of the range of a general mapping #F PreImage( , ) . unique preimage of an elm under a gen.mapping #F PreImage(, ) set of preimages of a coll. under a gen. mapping ## ## <#GAPDoc Label="PreImage"> ## ## PreImage ## ## ## ## ## ## PreImage( map ) is the preimage of the general mapping ## map, i.e., the subset of elements of the source of map ## that actually have values under map. ## Note that in this case the argument may also be non-injective or ## non-surjective. ##

## PreImage( map, elm ) is the preimage of the element ## elm of the range of the injective and surjective mapping ## map under map, i.e., the unique element of the source ## which is mapped under map to elm. ## Note that map must be injective and surjective ## (see ). ##

## PreImage( map, coll ) is the preimage of the subset ## coll of the range of the general mapping map under ## map, i.e., the subset of the source which is mapped under ## map to elements of coll. coll may be a proper set ## or a domain. ## The result will be either a proper set or a domain. ## Note that in this case map may also be non-injective or ## non-surjective. ## (If coll and the result are lists then the positions of ## entries do in general not correspond.) ##

## ## delegates to when ## called with one argument, ## and to resp. when ## called with two arguments. ##

## If the second argument is not an element or a subset of the range of ## the first argument, an error is signalled. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "PreImage" ); ############################################################################# ## #F PreImages( ) . . . set of preimages of the range of a gen. mapping #F PreImages(,) . set of preimages of an elm under a gen. mapping #F PreImages(,) set of preimages of a coll. under a gen. mapping ## ## <#GAPDoc Label="PreImages"> ## ## PreImages ## ## ## ## ## ## PreImages( map ) is the preimage of the general mapping ## map, i.e., the subset of elements of the source of map ## that have actually values under map. ##

## PreImages( map, elm ) is the set of preimages of the ## element elm of the range of the general mapping map under ## map, i.e., the set of elements of the source which map maps ## to elm. ##

## PreImages( map, coll ) is the set of images of the ## subset coll of the range of the general mapping map under ## map, i.e., the subset of the source which map maps to ## elements of coll. ## coll may be a proper set or a domain. ## The result will be either a proper set or a domain. ## (If coll and the result are lists then the positions of ## entries do in general not correspond.) ##

## ## delegates to when ## called with one argument, ## and to resp. when ## called with two arguments. ##

## If the second argument is not an element or a subset of the range of ## the first argument, an error is signalled. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "PreImages" ); ############################################################################# ## #O CompositionMapping2(,) . . . composition of general mappings #F CompositionMapping2General(,) ## ## <#GAPDoc Label="CompositionMapping2"> ## ## ## ## ## ## returns the composition of map2 ## and map1, ## this is the general mapping that maps an element first under map1, ## and then maps the images under map2. ##

## (Note the reverse ordering of arguments in the composition via ## the multiplication . ##

## is the method that forms a ## composite mapping with two constituent mappings. ## (This is used in some algorithms.) ## ## ## <#/GAPDoc> ## DeclareOperation( "CompositionMapping2", [ IsGeneralMapping, IsGeneralMapping ] ); DeclareGlobalFunction("CompositionMapping2General"); ############################################################################# ## #F CompositionMapping( , , ... ) . . . . composition of mappings ## ## <#GAPDoc Label="CompositionMapping"> ## ## ## ## ## allows one to compose arbitrarily many ## general mappings, ## and delegates each step to . ##

## Additionally, the properties and ## are maintained; ## if the source of the i+1-th general mapping is identical to ## the range of the i-th general mapping, ## also and are maintained. ## (So one should not call directly ## if one wants to maintain these properties.) ##

## Depending on the types of map1 and map2, ## the returned mapping might be constructed completely new (for example by ## giving domain generators and their images, this is for example the case ## if both mappings preserve the same algebraic structures and &GAP; can ## decompose elements of the source of map2 into generators) or as an ## (iterated) composition ## (see ). ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "CompositionMapping" ); ############################################################################# ## #R IsCompositionMappingRep( ) ## ## <#GAPDoc Label="IsCompositionMappingRep"> ## ## ## ## ## Mappings in this representation are stored as composition of two ## mappings, (pre)images of elements are computed in a two-step process. ## The constituent mappings of the composition can be obtained via ## . ## ## ## <#/GAPDoc> ## DeclareRepresentation( "IsCompositionMappingRep", IsGeneralMapping and IsAttributeStoringRep, [ "map1", "map2" ] ); ############################################################################# ## #F ConstituentsCompositionMapping( ) ## ## <#GAPDoc Label="ConstituentsCompositionMapping"> ## ## ## ## ## If map is stored in the representation ## as composition of two mappings ## map1 and map2, this function returns the ## two constituent mappings in a list [ map1, map2 ]. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "ConstituentsCompositionMapping" ); ############################################################################# ## #O ZeroMapping( , ) . . . . . . . . . . zero mapping from to ## ## <#GAPDoc Label="ZeroMapping"> ## ## ## ## ## A zero mapping is a total general mapping that maps each element of its ## source to the zero element of its range. ##

## (Each mapping with empty source is a zero mapping.) ## ## ## <#/GAPDoc> ## DeclareOperation( "ZeroMapping", [ IsCollection, IsCollection ] ); ############################################################################# ## #O RestrictedMapping( , ) ## ## <#GAPDoc Label="RestrictedMapping"> ## ## ## ## ## If subdom is a subdomain of the source of the general mapping ## map, ## this operation returns the restriction of map to subdom. ## ## ## ## <#/GAPDoc> ## DeclareOperation( "RestrictedMapping", [ IsGeneralMapping, IsDomain ] ); ############################################################################# ## #R IsGeneralRestrictedMappingRep( ) ## ## Mappings in this representation are stored as wrapper object, containing ## the original map but new source and range. ## DeclareRepresentation( "IsGeneralRestrictedMappingRep", IsGeneralMapping and IsAttributeStoringRep, [ "map" ] ); ############################################################################# ## #F GeneralRestrictedMapping( , , ) ## ## GeneralRestrictedMapping allows one to restrict and ## for an existing mapping, for example enforcing injectivity or ## surjectivity this way. ## DeclareGlobalFunction( "GeneralRestrictedMapping" ); ############################################################################# ## #O Embedding( , ) . . . . . . . embedding of one domain into another #O Embedding( , ) ## ## <#GAPDoc Label="Embedding"> ## ## Embedding ## ## ## ## ## returns the embedding of the domain S in the domain T, ## or in the second form, some domain indexed by the positive integer ## i. ## The precise natures of the various methods are described elsewhere: ## for Lie algebras, see ; for group products, ## see  ## for a general description, or for examples ## see  for direct products, ## for semidirect products, ## or  for wreath products; or for ## magma rings ## see . ## ## ## <#/GAPDoc> ## DeclareOperation( "Embedding", [ IsDomain, IsObject ] ); ############################################################################# ## #O Projection( , ) . . . . . . projection of one domain onto another #O Projection( , ) #O Projection( ) ## ## <#GAPDoc Label="Projection"> ## ## Projection ## ## ## ## ## ## returns the projection of the domain S onto the domain T, ## or in the second form, some domain indexed by the positive integer ## i, ## or in the third form some natural quotient domain of S. ## Various methods are defined for group products; ## see  for ## a general description, ## or for examples see  for direct ## products, for semidirect products, ## for subdirect products, ## or  for wreath products. ## ## ## <#/GAPDoc> ## DeclareOperation( "Projection", [ IsDomain, IsObject ] ); ############################################################################# ## #F GeneralMappingByElements( , , ) ## ## <#GAPDoc Label="GeneralMappingByElements"> ## ## ## ## ## is the general mapping with source S and range R, ## and with underlying relation consisting of the collection elms ## of direct product elements. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "GeneralMappingByElements" ); ############################################################################# ## #F MappingByFunction( , , [, ] ) #F MappingByFunction( , , , `false', ) ## ## <#GAPDoc Label="MappingByFunction"> ## ## MappingByFunction ## ## ## ## ## ## returns a mapping map with source ## S and range R, ## such that each element s of S is mapped to the element ## fun( s ), where fun is a &GAP; function. ##

## If the argument invfun is bound then map is a bijection ## between S and R, and the preimage of each element r ## of R is given by invfun( r ), ## where invfun is a &GAP; function. ##

## If five arguments are given and the fourth argument is false then ## the &GAP; function prefun can be used to compute a single preimage ## also if map is not bijective. ## ## ## ##

## The mapping returned by ## lies in the ## filter , ## see . ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "MappingByFunction" ); ############################################################################# ## #m IsBijective . . . . . . . . . . . . . . . . . . . . for identity mapping ## InstallTrueMethod( IsBijective, IsGeneralMapping and IsOne ); ############################################################################# ## #m IsSingleValued . . . . . . . . . . . . . . . . . . . . for zero mapping #m IsTotal . . . . . . . . . . . . . . . . . . . . . . . . for zero mapping ## InstallTrueMethod( IsSingleValued, IsGeneralMapping and IsZero ); InstallTrueMethod( IsTotal, IsGeneralMapping and IsZero ); ############################################################################# ## #F CopyMappingAttributes( , ) ## ## ## ## ## ## Let from and to be two general mappings which are known to be equal. ## CopyMappingAttributes copies known mapping attributes from from to ## to. This is used in operations, such as ## AsGroupGeneralMappingByImages, that produce equal mappings in another ## representation. ## ## ## DeclareGlobalFunction( "CopyMappingAttributes" ); ############################################################################# ## #A MappingGeneratorsImages() ## ## <#GAPDoc Label="MappingGeneratorsImages"> ## ## ## ## ## This attribute contains a list of length 2, the first entry being a list ## of generators of the source of map and the second entry a list of ## their images. This attribute is used, for example, by ## to store generators and images. ## ## ## ## ## <#/GAPDoc> ## DeclareAttribute( "MappingGeneratorsImages", IsGeneralMapping ); ############################################################################# ## #E gap-4r6p5/lib/ctblperm.gi0000644000175000017500000001503312172557252014042 0ustar billbill############################################################################# ## #W ctblperm.gi GAP library Alexander Hulpke ## ## #Y Copyright (C) 1993, 1997 #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the implementation of the Dixon-Schneider algorithm ## ############################################################################# ## #F FingerprintPerm( , , , , , ) #F Entry i,j of the matrix of el in the permutation representation of G ## FingerprintPerm := function(D,el,i,j,orbitJ,representatives) local x,a,cycle,cycles; a:=0; #cycles:=Cycles(el,D.group.orbit); cycles:=Cycles(el,MovedPoints(D.group)); for cycle in cycles do x:=cycle[1]; if x^(el*representatives[x]) in orbitJ then a:=a+Length(cycle); fi; od; return a; end; ############################################################################# ## #F IdentificationPermGroup(,) . . . . . class invariants for el in G ## ## The class invariant consists of the cycle structure and - if computation ## might improve results - of the Fingerprint of the permutation ## IdentificationPermGroup := function(D,el) local s,t,i,l; # guter Programmier s t i l ! s:=CycleStructurePerm(el); s:=ShallowCopy(s); if not IsPerfectGroup(D.group) then Add(s,CanonicalRightCosetElement(DerivedSubgroup(D.group),el)); fi; t:=ShallowCopy(s); if t in D.centmulCandidates then Add(s,"c"); l:=First(D.centmulMults,i->i[1]=t); for i in l{[2..Length(l)]} do s:=Concatenation(s,CycleStructurePerm( el*D.classreps[i])); od; fi; if t in D.fingerprintCandidates then Add(s,-FingerprintPerm(D,el,D.p1,D.p2,D.fingerprintOrbitStabilizer, D.fingerprintRepresentatives)); fi; return s; end; ############################################################################# ## #F RationalIdentificationPermGroup( , ) galois-fix class invariant ## ## When trying to use cheap identifications, we cannot use all ## identification routines: For exaple galois conjugated elements must be ## multiplied by the *galois conjugate* of the central element! ## RationalIdentificationPermGroup := function(D,el) return CycleStructurePerm(el); end; ############################################################################# ## #M DxPreparation() ## Set up some functions. Also test, whether calculating fingerprints and ## multiplication by central elements might improve the quick ## identification ## InstallMethod(DxPreparation,"perm",true,[IsPermGroup,IsRecord],0, function(G,D) local k,structures,ambiguousStructures,i,j,p,cem,ces,z,t,cen,a, c,s,f,fc,fs,fos,fr,enum; D.identification:=IdentificationPermGroup; D.rationalidentification:=RationalIdentificationPermGroup; D.ClassMatrixColumn:=StandardClassMatrixColumn; if IsDxLargeGroup(G) then D.ClassElement:=ClassElementLargeGroup; else enum:=Enumerator(G); D.enum:=enum; D.ClassElement:=ClassElementSmallGroup; D.classMap:=ListWithIdenticalEntries(Size(G),D.klanz); for j in [1..D.klanz-1] do for i in Orbit(G,D.classreps[j]) do D.classMap[Position(enum,i)]:=j; od; od; fi; D.fingerprintCandidates:=[]; D.centmulCandidates:=[]; D.permdegree:=LargestMovedPoint(G); k:=D.klanz; if IsDxLargeGroup(G) then # test, if cyclestructure yields no perfect result structures:=[]; ambiguousStructures:=[]; for i in [1..k] do s:=IdentificationPermGroup(D,D.classreps[i]); if not s in structures then Add(structures,s); elif not s in ambiguousStructures then Add(ambiguousStructures,s); fi; od; if ambiguousStructures<>[] then # Centre multiplikation test cem:=[]; cen:=[]; for i in [2..Length(D.classes)] do if D.classiz[i]=1 then Add(cen,i); fi; od; if cen<>[] then for s in ambiguousStructures do ces:=[s]; c:=Filtered(D.classrange,i-> IdentificationPermGroup(D,D.classreps[i])=s); a:=[[1..Length(c)]]; for z in cen do t:=List(c,i-> CycleStructurePerm( D.classreps[i]* D.classreps[z])); if Length(Set(t))>1 then # improved result ? fc:=[]; fs:=[]; for i in [1..Length(t)] do p:=Position(fc,t[i]); if p=fail then Add(fc,t[i]); p:=Length(fc); fs[p]:=[]; fi; Add(fs[p],i); od; fc:=[]; for i in a do fc:=Concatenation(fc,Filtered(List(fs,j->Intersection(j,i)), j->j<>[])); od; fc:=Set(fc); if fc<>a then Add(ces,z); a:=fc; fi; fi; od; if Length(ces)>1 then Add(cem,ces); fi; od; D.centmulMults:=cem; fi; # fingerprint test if IsTransitive(G,MovedPoints(G)) and # otherwise lotsa representatives will mess up memory Length(MovedPoints(G))<1500 then # select moved points 1 and 2 fos:=MovedPoints(G); D.p1:=fos[1]; D.p2:=fos[2]; fs := Stabilizer(G,D.p1); fos := First(OrbitsDomain(fs,[1..D.permdegree]),o->D.p2 in o); fr := List([1..D.permdegree],x->RepresentativeAction(G,x,D.p1)); fc:=[]; for s in ambiguousStructures do c:=Filtered([1..D.klanz],i->IdentificationPermGroup(D, D.classreps[i])=s); f:=List(c,i->FingerprintPerm(D, D.classreps[i],D.p1,D.p2,fos,fr)); if Length(Set(f))>1 then Add(fc,s); fi; od; if Length(fc)>0 then D.fingerprintCandidates:=fc; D.fingerprintOrbitStabilizer:=fos; D.fingerprintRepresentatives:=fr; fi; fi; D.centmulCandidates:=Set(List(cem,i->i[1])); fi; fi; D.ids:=[]; D.rids:=[]; for i in [1..D.klanz] do D.ids[i]:=D.identification(D,D.classreps[i]); D.rids[i]:= D.rationalidentification(D,D.classreps[i]); od; return D; end); ############################################################################# ## #E ctblperm.gi ## gap-4r6p5/lib/extaset.gd0000644000175000017500000000411612172557252013702 0ustar billbill############################################################################# ## #W extaset.gd GAP library Thomas Breuer ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file declares the operations for external additive sets. ## ############################################################################# ## #C IsExtASet( ) ## ## An external additive set is a domain with an action of a domain via `\+'. ## Since the operator `\+' in {\GAP} is commutative we do not distinguish ## actions from left and right. ## DeclareCategory( "IsExtASet", IsDomain and IsAdditiveElement ); ############################################################################# ## #C IsAssociativeAOpDSum( ) ## ## is `true' iff $a \+ ( x \+ y ) = ( a \+ x ) \+ y$ ## for $a \in E$ and $x, y \in D$. ## DeclareCategory( "IsAssociativeAOpDSum", IsExtASet ); ############################################################################# ## #C IsAssociativeAOpESum( ) ## ## is `true' iff $a \+ ( b \+ x ) = ( a \+ b ) \+ x$ ## for $a, b \in E$ and $x \in D$. ## DeclareCategory( "IsAssociativeAOpESum", IsExtASet ); ############################################################################# ## #C IsTrivialAOpEZero( ) ## ## is `true' iff the zero element $z \in E$ acts trivially on $D$, ## that is, $z \+ x = x$ for $x \in D$. #T necessary? ## DeclareCategory( "IsTrivialAOpEZero", IsExtASet ); ############################################################################# ## #A GeneratorsOfExtASet( ) ## DeclareAttribute( "GeneratorsOfExtASet", IsExtASet ); ############################################################################# ## #A AdditivelyActingDomain( ) ## DeclareAttribute( "AdditivelyActingDomain", IsExtASet ); ############################################################################# ## #E extaset.gd . . . . . . . . . . . . . . . . . . . . . . . . . . ends here gap-4r6p5/lib/streams.gd0000644000175000017500000013515212172557254013712 0ustar billbill############################################################################ ## #W streams.gd GAP Library Frank Celler ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the operations for streams. ## ## <#GAPDoc Label="[1]{streams}"> ## Streams provide flexible access to &GAP;'s input and output ## processing. An input stream takes characters from some source and ## delivers them to &GAP; which reads them from the stream. When an ## input stream has delivered all characters it is at end-of-stream. An ## output stream receives characters from &GAP; which writes them to ## the stream, and delivers them to some destination. ##

## A major use of streams is to provide efficient and flexible access to ## files. Files can be read and written using ## and , ## however the former only allows a complete file to be read as &GAP; ## input and the latter imposes a high time penalty if many small pieces of ## output are written to a large file. Streams allow input files in other ## formats to be read and processed, and files to be built up efficiently ## from small pieces of output. Streams may also be used for other purposes, ## for example to read from and print to &GAP; strings, or to read input ## directly from the user. ##

## Any stream is either a text stream, which translates the end-of-line ## character (\n) to or from the system's representation of ## end-of-line (e.g., new-line under UNIX and ## carriage-return-new-line under DOS), or a binary stream, ## which does not translate the end-of-line character. The processing of ## other unprintable characters by text streams is undefined. Binary streams ## pass them unchanged. ##

## Whereas it is cheap to append to a stream, streams do consume system ## resources, and only a limited number can be open at any time, therefore ## it is necessary to close a stream as soon as possible using ## . If creating a stream ## failed then can be used to get ## information about the failure. ## <#/GAPDoc> ## ############################################################################# ## #R IsInputTextStringRep (used in kernel) ## ## ## ## ## ## ## ## DeclareRepresentation( "IsInputTextStringRep", IsPositionalObjectRep, [] ); ############################################################################# ## #C IsClosedStream( ) . . . . . . . . . . . category of closed streams ## ## <#GAPDoc Label="IsClosedStream"> ## ## ## ## ## When a stream is closed, its type changes to lie in ## . This category is used to install methods that trap ## accesses to closed streams. ## ## ## <#/GAPDoc> ## DeclareCategory( "IsClosedStream", IsObject ); ############################################################################# ## #C IsStream( ) . . . . . . . . . . . . . . . . . . category of streams ## ## <#GAPDoc Label="IsStream"> ## ## ## ## ## Streams are &GAP; objects and all open streams, input, output, text ## and binary, lie in this category. ## ## ## <#/GAPDoc> ## DeclareCategory( "IsStream", IsObject ); ############################################################################# ## #C IsInputStream( ) . . . . . . . . . . . . category of input streams ## ## <#GAPDoc Label="IsInputStream"> ## ## ## ## ## All input streams lie in this category, and support input ## operations such as (see ) ## ## ## <#/GAPDoc> ## DeclareCategory( "IsInputStream", IsStream ); ############################################################################# ## #C IsInputTextStream( ) . . . . . . . category of input text streams ## ## <#GAPDoc Label="IsInputTextStream"> ## ## ## ## ## All text input streams lie in this category. They translate new-line ## characters read. ## ## ## <#/GAPDoc> ## DeclareCategory( "IsInputTextStream", IsInputStream ); ############################################################################# ## #C IsInputTextNone( ) . . . . . . category of input text none streams ## ## <#GAPDoc Label="IsInputTextNone"> ## ## ## ## ## It is convenient to use a category to distinguish dummy streams ## (see ) from others. Other distinctions are usually ## made using representations ## ## ## <#/GAPDoc> ## DeclareCategory( "IsInputTextNone", IsInputTextStream ); ############################################################################# ## #C IsOutputStream( ) . . . . . . . . . . . category of output streams ## ## <#GAPDoc Label="IsOutputStream"> ## ## ## ## ## All output streams lie in this category and support basic ## operations such as ## (see Section ). ## ## ## <#/GAPDoc> ## DeclareCategory( "IsOutputStream", IsStream ); ############################################################################# ## #C IsOutputTextStream( ) . . . . . . . category of output text streams ## ## <#GAPDoc Label="IsOutputTextStream"> ## ## ## ## ## All text output streams lie in this category and translate ## new-line characters on output. ## ## ## <#/GAPDoc> ## DeclareCategory( "IsOutputTextStream", IsOutputStream ); ############################################################################# ## #C IsOutputTextNone( ) . . . . . category of output text none streams ## ## <#GAPDoc Label="IsOutputTextNone"> ## ## ## ## ## It is convenient to use a category to distinguish dummy streams ## (see ) from others. Other distinctions are usually ## made using representations ## ## ## <#/GAPDoc> ## DeclareCategory( "IsOutputTextNone", IsOutputTextStream ); ############################################################################# ## #V StreamsFamily . . . . . . . . . . . . . . . . . . . family of all streams ## ## <#GAPDoc Label="StreamsFamily"> ## ## ## ## ## All streams lie in the . ## ## ## <#/GAPDoc> ## StreamsFamily := NewFamily( "StreamsFamily" ); ############################################################################# ## #O IsEndOfStream( ) . . . . . . . . . check for end-of-stream ## ## <#GAPDoc Label="IsEndOfStream"> ## ## ## ## ## returns true if the input stream is at end-of-stream, ## and false otherwise. Note that might return false ## even if the next fails. ## ## ## <#/GAPDoc> ## DeclareOperation( "IsEndOfStream", [ IsInputStream ] ); ############################################################################# ## #O PositionStream( ) . . . . . . . . . . . current position ## ## <#GAPDoc Label="PositionStream"> ## ## ## ## ## Some input streams, such as string streams and file streams attached to ## disk files, support a form of random access by way of the operations ## , and ## . ## returns a non-negative integer denoting ## the current position in the stream (usually the number of characters ## before the next one to be read. ##

## If this is not possible, for example for an input stream attached to ## standard input (normally the keyboard), then fail is returned ## ## ## <#/GAPDoc> ## DeclareOperation( "PositionStream", [ IsInputStream ] ); ############################################################################# ## #O ReadAll( ) . . . . . . . read whole input as string #O ReadAll( , ) . . read whole input as string ## ## <#GAPDoc Label="ReadAll"> ## ## ## ## ## returns all characters as string from the input stream ## stream-in. It waits (blocks) until at least one ## character is available from the stream, or until there is evidence ## that no characters will ever be available again. This last indicates ## that the stream is at end-of-stream. ## Otherwise, it reads as much input as it can from the stream without ## blocking further and returns it to the user. If the stream is ## already at end of file, so that no bytes are available, fail is ## returned. In the case of a file ## stream connected to a normal file (not a pseudo-tty or named pipe ## or similar), all the bytes should be immediately available and ## this function will read the remainder of the file. ##

## With a second argument, at most limit bytes will be ## returned. Depending on the stream a bounded number of additional bytes ## may have been read into an internal buffer. ##

## A default method is supplied for which simply calls ## repeatedly. ## This is only really safe for streams which cannot block. ## Other streams should install a method for ##

## i := InputTextString( "1Hallo\nYou\n1" );; ## gap> ReadByte(i); ## 49 ## gap> CHAR_INT(last); ## '1' ## gap> ReadLine(i); ## "Hallo\n" ## gap> ReadLine(i); ## "You\n" ## gap> ReadLine(i); ## "1" ## gap> ReadLine(i); ## fail ## gap> ReadAll(i); ## "" ## gap> RewindStream(i);; ## gap> ReadAll(i); ## "1Hallo\nYou\n1" ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "ReadAll", [ IsInputStream ] ); DeclareOperation( "ReadAll", [ IsInputStream, IsInt ] ); ############################################################################# ## #O ReadByte( ) . . . . . . . . . . . . . . read single byte ## ## <#GAPDoc Label="ReadByte"> ## ## ## ## ## returns one character (returned as integer) from the input ## stream input-stream. returns fail if there is no character ## available, in particular if it is at the end of a file. ##

## If input-stream is the input stream of a input/output process, ## may also return fail if no byte is currently available. ##

## is the basic operation for input streams. If a ## method is installed for a user-defined type of stream which does ## not block, then all the other ## input stream operations will work (although possibly not at peak ## efficiency). ##

## will wait (block) until a byte is available. For ## instance if the stream is a connection to another process, it will ## wait for the process to output a byte. ## ## ## <#/GAPDoc> ## DeclareOperation( "ReadByte", [ IsInputStream ] ); ############################################################################# ## #O ReadLine( ) . read whole line (or what's there) as string ## ## <#GAPDoc Label="ReadLine"> ## ## ## ## ## returns one line (returned as string with the newline) from ## the input stream input-stream. reads in the input until a ## newline is read or the end-of-stream is encountered. ##

## If input-stream is the input stream of a input/output process, ## may also return fail or return an incomplete line if the other ## process has not yet written any more. It will always wait (block) for at ## least one byte to be available, but will then return as much input ## as is available, up to a limit of one line ##

## A default method is supplied for which simply calls ## repeatedly. This is only safe for streams that cannot block. The kernel ## uses calls to to supply input to the ## parser when reading from a stream. ## ## ## <#/GAPDoc> ## DeclareOperation( "ReadLine", [ IsInputStream ] ); ############################################################################# ## #O ReadAllLine( [, ][, ] ) . . read whole line ## ## <#GAPDoc Label="ReadAllLine"> ## ## ## ## ## For an input/output stream iostream reads until a newline ## character if any input is found or returns fail if no input is found, ## i.e. if any input is found is non-blocking. ##

## If the argument nofail (which must be false or true) is provided ## and it is set to true then will wait, if necessary, for ## input and never return fail. ##

## If the argument IsAllLine (which must be a function that takes a string ## argument and returns either true or false) then it is used to ## determine what constitutes a whole line. The default behaviour is ## equivalent to passing the function ##

## 0 < Length(line) and line[Length(line)] = '\n' ## ]]> ##

## for the IsAllLine argument. The purpose of the IsAllLine argument is ## to cater for the case where the input being read is from an external ## process that writes a prompt for data that does not terminate with a ## newline. ##

## If the first argument is an input stream but not an input/output stream ## then behaves as if was called with just the ## first argument and any additional arguments are ignored. ## ## ## <#/GAPDoc> ## DeclareOperation( "ReadAllLine", [ IsInputStream, IsBool, IsFunction ] ); ############################################################################# ## #O RewindStream( ) . . . . . . . . . return to the beginning ## ## <#GAPDoc Label="RewindStream"> ## ## ## ## ## attempts to return an input stream to its starting ## condition, so that all the same characters can be read again. It returns ## true if the rewind succeeds and fail otherwise ##

## A default method implements RewindStream using . ## ## ## <#/GAPDoc> ## DeclareOperation( "RewindStream", [ IsInputStream ] ); ############################################################################# ## #O SeekPositionStream( , ) . . . . return to a position ## ## <#GAPDoc Label="SeekPositionStream"> ## ## ## ## ## attempts to rewind or wind forward an input stream ## to the specified position. This is not possible for all streams. It ## returns true if the seek is successful and fail otherwise. ## ## ## <#/GAPDoc> ## DeclareOperation( "SeekPositionStream", [ IsInputStream, IsInt ] ); ############################################################################# ## #O WriteAll( , ) . write whole string to file ## ## <#GAPDoc Label="WriteAll"> ## ## ## ## ## appends string to output-stream. ## No final newline is written. ## The function returns true if the write succeeds ## and fail otherwise. ## It will block as long as necessary for the write operation to ## complete (for example for a child process to clear its input buffer ) ##

## A default method is installed which implements ## by repeated calls to . ##

## When printing or appending to a stream (using , ## or or when logging to a stream), ## the kernel generates a call to for each line ## output. ##

## str := "";; a := OutputTextString(str,true);; ## gap> WriteByte(a,INT_CHAR('H')); ## true ## gap> WriteLine(a,"allo"); ## true ## gap> WriteAll(a,"You\n"); ## true ## gap> CloseStream(a); ## gap> Print(str); ## Hallo ## You ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "WriteAll", [ IsOutputStream, IsString ] ); ############################################################################# ## #O WriteByte( , ) . . . . . . . . . write single byte ## ## <#GAPDoc Label="WriteByte"> ## ## ## ## ## writes the next character (given as integer) to the output stream ## output-stream. The function returns true if the write succeeds and ## fail otherwise. ##

## is the basic operation for output streams. If a ## method is installed for a user-defined type of stream, then all the other ## output stream operations will work (although possibly not at peak ## efficiency). ## ## ## <#/GAPDoc> ## DeclareOperation( "WriteByte", [ IsOutputStream, IsInt ] ); ############################################################################# ## #O WriteLine( , ) . write string plus newline ## ## <#GAPDoc Label="WriteLine"> ## ## ## ## ## appends string to output-stream. A final newline is written. ## The function returns true if the write succeeds and fail otherwise. ##

## A default method is installed which implements by repeated ## calls to . ## ## ## <#/GAPDoc> ## DeclareOperation( "WriteLine", [ IsOutputStream, IsString ] ); ############################################################################# ## #O CloseStream( ) . . . . . . . . . . . . . . . . . close a stream ## ## <#GAPDoc Label="CloseStream"> ## ## ## ## ## In order to preserve system resources and to flush output streams every ## stream should be closed as soon as it is no longer used using ## . ##

## It is an error to try to read characters from or write characters to a ## closed stream. Closing a stream tells the &GAP; kernel and/or the ## operating system kernel that the file is no longer needed. This may be ## necessary because the &GAP; kernel and/or the operating system may ## impose a limit on how many streams may be open simultaneously. ## ## ## <#/GAPDoc> ## DeclareOperation( "CloseStream", [ IsStream ] ); ############################################################################# ## #O InputTextString( ) . . . . create input text stream from string ## ## <#GAPDoc Label="InputTextString"> ## ## ## ## ## InputTextString( string ) returns an input stream ## that delivers the characters from the string string. The ## string is not changed when reading characters from it and ## changing the string after the call to ## has no influence on the input stream. ## ## ## <#/GAPDoc> ## DeclareOperation( "InputTextString", [ IsString ] ); ############################################################################# ## #O InputTextFile( ) . . . . create input text stream from file ## ## <#GAPDoc Label="InputTextFile"> ## ## ## ## ## InputTextFile( name-file ) returns an input stream in the category ## that delivers the characters from the file ## name-file. ## ## ## <#/GAPDoc> ## DeclareOperation( "InputTextFile", [ IsString ] ); ############################################################################# ## #F InputTextNone() . . . . . . . . . . . . . . . . . dummy input text stream ## ## <#GAPDoc Label="InputTextNone"> ## ## ## ## ## returns a dummy input text stream, which delivers no characters, i.e., it ## is always at end of stream. Its main use is for calls to ## when the started program does not read anything. ## ## ## <#/GAPDoc> ## UNBIND_GLOBAL( "InputTextNone" ); DeclareGlobalFunction( "InputTextNone" ); ############################################################################# ## #F InputTextUser() . . . . . . . . . . . . . input text stream from the user ## ## <#GAPDoc Label="InputTextUser"> ## ## ## ## ## returns an input text stream which delivers characters typed by the user ## (or from the standard input device if it has been redirected). In normal ## circumstances, characters are delivered one by one as they are typed, ## without waiting until the end of a line. No prompts are printed. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "InputTextUser" ); ############################################################################# ## #O OutputTextString( , ) . . . . create output text stream ## ## <#GAPDoc Label="OutputTextString"> ## ## ## ## ## returns an output stream that puts all received characters into the list ## list. ## If append is false, then the list is emptied first, ## otherwise received characters are added at the end of the list. ##

## # read input from a string ## gap> input := InputTextString( "Hallo\nYou\n" );; ## gap> ReadLine(input); ## "Hallo\n" ## gap> ReadLine(input); ## "You\n" ## gap> # print to a string ## gap> str := "";; ## gap> out := OutputTextString( str, true );; ## gap> PrintTo( out, 1, "\n", (1,2,3,4)(5,6), "\n" ); ## gap> CloseStream(out); ## gap> Print( str ); ## 1 ## (1,2,3,4)(5,6) ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "OutputTextString", [ IsList, IsBool ] ); ############################################################################# ## #O OutputTextFile( , ) . . . create output text stream ## ## <#GAPDoc Label="OutputTextFile"> ## ## ## ## ## OutputTextFile( name-file, append ) returns an output stream in the ## category IsOutputTextFile that writes received characters to the file ## name-file. If append is false, then the file is emptied first, ## otherwise received characters are added at the end of the file. ##

## # use a temporary directory ## gap> name := Filename( DirectoryTemporary(), "test" );; ## gap> # create an output stream, append output, and close again ## gap> output := OutputTextFile( name, true );; ## gap> AppendTo( output, "Hallo\n", "You\n" ); ## gap> CloseStream(output); ## gap> # create an input, print complete contents of file, and close ## gap> input := InputTextFile(name);; ## gap> Print( ReadAll(input) ); ## Hallo ## You ## gap> CloseStream(input); ## gap> # append a single line ## gap> output := OutputTextFile( name, true );; ## gap> AppendTo( output, "AppendLine\n" ); ## gap> # close output stream to flush the output ## gap> CloseStream(output); ## gap> # create an input, print complete contents of file, and close ## gap> input := InputTextFile(name);; ## gap> Print( ReadAll(input) ); ## Hallo ## You ## AppendLine ## gap> CloseStream(input); ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "OutputTextFile", [ IsString, IsBool ] ); ############################################################################# ## #F OutputTextNone() . . . . . . . . . . . . . . . dummy output text stream ## ## <#GAPDoc Label="OutputTextNone"> ## ## ## ## ## returns a dummy output stream, which discards all received characters. ## Its main use is for calls to when the started ## program does not write anything. ## ## ## <#/GAPDoc> ## UNBIND_GLOBAL( "OutputTextNone" ); DeclareGlobalFunction( "OutputTextNone" ); ############################################################################# ## #F OutputTextUser() . . . . . . . . . . . . output text stream to the user ## ## <#GAPDoc Label="OutputTextUser"> ## ## ## ## ## returns an output stream which delivers characters to the user's display ## (or the standard output device if it has been redirected). Each character ## is delivered immediately it is written, without waiting for a full line ## of output. Text written in this way is not written to the session log ## (see ). ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "OutputTextUser" ); ## <#GAPDoc Label="[2]{streams}"> ## Input-output streams capture bidirectional ## communications between &GAP; and another process, either locally ## or (@as yet unimplemented@) remotely. ##

## Such streams support the basic operations of both input and output ## streams. They should provide some buffering, allowing output data to be ## written to the stream, even when input data is waiting to be read, ## but the amount of this buffering is operating system dependent, ## and the user should take care not to get too far ahead in writing, or ## behind in reading, or deadlock may occur. ##

## At present the only type of Input-Output streams that are ## implemented provide communication with a local child process, ## using a pseudo-tty. ##

## Like other streams, write operations are blocking, read operations ## will block to get the first character, but not thereafter. ##

## As far as possible, no translation is done on characters written ## to, or read from the stream, and no control characters have special ## effects, but the details of particular pseudo-tty implementations ## may effect this. ## <#/GAPDoc> ## ############################################################################# ## #C IsInputOutputStream( ) . . . . . . . . category of two-way streams ## ## <#GAPDoc Label="IsInputOutputStream"> ## ## ## ## ## is the Category of Input-Output Streams; it returns ## true if the obj is an input-output stream and false otherwise. ## ## ## <#/GAPDoc> ## DeclareCategory( "IsInputOutputStream", IsInputStream and IsOutputStream ); ############################################################################# ## #F InputOutputLocalProcess(

, , ) % ## . . .input/output stream to a process run as a "slave" on the local host ## ## <#GAPDoc Label="InputOutputLocalProcess"> ## ## ## ## ## starts up a slave process, whose executable file is executable, with ## command line arguments args in the directory dir. (Suitable ## choices for dir are DirectoryCurrent() or DirectoryTemporary() ## (see Section ); DirectoryTemporary() may be a good choice ## when executable generates output files that it doesn't itself remove ## afterwards.) ## returns an InputOutputStream object. Bytes ## written to this stream are received by the slave process as if typed ## at a terminal on standard input. Bytes written to standard output ## by the slave process can be read from the stream. ##

## When the stream is closed, the signal SIGTERM is delivered to the child ## process, which is expected to exit. ## d := DirectoryCurrent(); ## dir("./") ## gap> f := Filename(DirectoriesSystemPrograms(), "rev"); ## "/usr/bin/rev" ## gap> s := InputOutputLocalProcess(d,f,[]); ## < input/output stream to rev > ## gap> WriteLine(s,"The cat sat on the mat"); ## true ## gap> Print(ReadLine(s)); ## tam eht no tas tac ehT ## gap> x := ListWithIdenticalEntries(10000,'x');; ## gap> ConvertToStringRep(x); ## gap> WriteLine(s,x); ## true ## gap> WriteByte(s,INT_CHAR('\n')); ## true ## gap> y := ReadAll(s);; ## gap> Length(y); ## 4095 ## gap> CloseStream(s); ## gap> s; ## < closed input/output stream to rev > ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "InputOutputLocalProcess" ); ############################################################################# ## #O SetPrintFormattingStatus( , ) #O PrintFormattingStatus( ) . . . . . . . . is stream line-breaking ## ## <#GAPDoc Label="SetPrintFormattingStatus"> ## ## ## ## ## ## When text is being sent to an output text stream via ## , , ## , etc., it is ## by default formatted just as it would be were it being printed to the ## screen. ## Thus, it is broken into lines of reasonable length at (where possible) ## sensible places, lines containing elements of lists or records are ## indented, and so forth. ## This is appropriate if the output is eventually to be viewed by a human, ## and harmless if it to passed as input to &GAP;, ## but may be unhelpful if the output is to be passed as input to another ## program. ## It is possible to turn off this behaviour for a stream using the ## operation, and to test whether it ## is on or off using . ##

## sets whether output sent to the ## output stream stream via , ## , etc. ## will be formatted with line breaks and ## indentation. If the second argument newstatus is true ## then output will be so formatted, and if false then it will not. ## If the stream is not a text stream, only false is allowed. ##

## returns true if output sent to ## the output text stream stream via , ## , etc. ## will be formatted with line breaks and ## indentation, and false otherwise. ## For non-text streams, it returns false. ## If as argument stream the string "*stdout*" is given, these ## functions refer to the formatting status of the standard output (so usually ## the users terminal screen).

## These functions do not influence the behaviour of the low level functions ## , ## or which always write ## without formatting. ##

## s := "";; str := OutputTextString(s,false);; ## gap> PrintTo(str,Primes{[1..30]}); ## gap> s; ## "[ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61,\ ## \n 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113 ]" ## gap> Print(s,"\n"); ## [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, ## 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113 ] ## gap> SetPrintFormattingStatus(str, false); ## gap> PrintTo(str,Primes{[1..30]}); ## gap> s; ## "[ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61,\ ## \n 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113 ][ 2, 3, 5, 7\ ## , 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, \ ## 79, 83, 89, 97, 101, 103, 107, 109, 113 ]" ## gap> Print(s,"\n"); ## [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, ## 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113 ][ 2, 3, 5, 7, 1\ ## 1, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79,\ ## 83, 89, 97, 101, 103, 107, 109, 113 ] ## ]]> ##

## ## ## <#/GAPDoc> ## DeclareOperation( "SetPrintFormattingStatus", [IsOutputStream, IsBool] ); DeclareOperation( "PrintFormattingStatus", [IsOutputStream] ); ############################################################################# ## #F AppendTo( , , ... ) . . . . . . . . . . append to a stream ## ## ## ## ## ## This is the same as PrintTo for streams. If stream is just a ## filename than there is a difference: PrintTo will clear the file, ## AppendTo will not. ##

## If stream is really a stream, then the kernel will generate a call to ## for each line of output. ## ## ## BIND_GLOBAL( "AppendTo", function( arg ) if IsString(arg[1]) then arg := ShallowCopy(arg); arg[1] := USER_HOME_EXPAND(arg[1]); CallFuncList( APPEND_TO, arg ); elif IsOutputStream(arg[1]) then # direct call to `WriteAll' if arg is one string and formatting # is switched off if Length(arg) = 2 and ( not IsOutputTextStream( arg[1] ) or PrintFormattingStatus(arg[1]) = false ) and IsStringRep(arg[2]) then WriteAll(arg[1], arg[2]); else CallFuncList( APPEND_TO_STREAM, arg ); fi; else Error( "first argument must be a filename or output stream" ); fi; end ); ############################################################################# ## #F PrintTo( , , ... ) . . . . . . . . . . append to a stream ## ## ## ## ## ## PrintTo appends arg1, ... to the output stream. ##

## If stream is really a stream, then the kernel will generate a call to ## for each line of output. ## ## ## BIND_GLOBAL( "PrintTo", function( arg ) if IsString(arg[1]) then arg := ShallowCopy(arg); arg[1] := USER_HOME_EXPAND(arg[1]); CallFuncList( PRINT_TO, arg ); elif IsOutputStream(arg[1]) then # direct call to `WriteAll' if arg is one string and formatting # is switched off if Length(arg) = 2 and ( not IsOutputTextStream( arg[1] ) or PrintFormattingStatus(arg[1]) = false ) and IsStringRep(arg[2]) then WriteAll(arg[1], arg[2]); else CallFuncList( PRINT_TO_STREAM, arg ); fi; else Error( "first argument must be a filename or output stream" ); fi; end ); ############################################################################# ## #O LogTo( ) . . . . . . . . . . . . . . . . . . . . log to a stream ## ## <#GAPDoc Label="LogTo"> ## ## ## ## ## causes the subsequent interaction to be logged to the output stream ## stream. It works in precisely the same way as it does for files ## (see ). ## ## ## <#/GAPDoc> ## DeclareOperation( "LogTo", [ IsOutputStream ] ); ############################################################################# ## #O InputLogTo( ) . . . . . . . . . . . . . . log input to a stream ## ## <#GAPDoc Label="InputLogTo"> ## ## ## ## ## causes the subsequent input to be logged to the output stream ## stream. ## It works just like it does for files ## (see ). ## ## ## <#/GAPDoc> ## DeclareOperation( "InputLogTo", [ IsOutputStream ] ); DeclareSynonym( "LogInputTo",InputLogTo); ############################################################################# ## #O OutputLogTo( ) . . . . . . . . . . . . . log output to a stream ## ## <#GAPDoc Label="OutputLogTo"> ## ## ## ## ## causes the subsequent output to be logged to the output stream ## stream. ## It works just like it does for files ## (see ). ##

## ## ## <#/GAPDoc> ## DeclareOperation( "OutputLogTo", [ IsOutputStream ] ); DeclareSynonym( "LogOutputTo",OutputLogTo); ############################################################################# ## #O FileDescriptorOfStream( ) ## ## <#GAPDoc Label="FileDescriptorOfStream"> ## ## ## ## ## returns the UNIX file descriptor of the underlying file. This is mainly ## useful for the function call. This is ## as of now only available on UNIX-like operating systems and only for ## streams to local processes and local files. ## ## ## <#/GAPDoc> ## DeclareOperation("FileDescriptorOfStream", [IsStream] ); ############################################################################# ## #V OnCharReadHookInFuncs . . . . . . . installed handler functions for input ## ## ## ## ## ## contains a list of functions that are installed as reading handlers for ## streams. ## ## ## DeclareGlobalVariable( "OnCharReadHookInFuncs", "installed input handlers for streams" ); ############################################################################# ## #V OnCharReadHookInFds . . . . . . . . file descriptors for reading handlers ## ## ## ## ## ## contains a list of file descriptors of streams for which reading handlers ## are installed. ## ## ## DeclareGlobalVariable( "OnCharReadHookInFds", "UNIX file descriptors of input streams" ); ############################################################################# ## #V OnCharReadHookInStreams . . . . . . . . . . streams with reading handlers ## ## ## ## ## ## contains a list of streams for which reading handlers are installed. ## ## ## DeclareGlobalVariable( "OnCharReadHookInStreams", "input streams for which handlers are installed" ); ############################################################################# ## #V OnCharReadHookOutFuncs . . . . . . installed handler functions for output ## ## ## ## ## ## contains a list of functions that are installed as reading handlers for ## streams. ## ## ## DeclareGlobalVariable( "OnCharReadHookOutFuncs", "installed output handlers for streams" ); ############################################################################# ## #V OnCharReadHookOutFds . . . . . . . file descriptors for writing handlers ## ## ## ## ## ## contains a list of file descriptors of streams for which writing handlers ## are installed. ## ## ## DeclareGlobalVariable( "OnCharReadHookOutFds", "UNIX file descriptors of output streams" ); ############################################################################# ## #V OnCharReadHookOutStreams . . . . . . . . . . streams with writing handlers ## ## ## ## ## ## contains a list of streams for which writing handlers are installed. ## ## ## DeclareGlobalVariable( "OnCharReadHookOutStreams", "output streams for which handlers are installed" ); ############################################################################# ## #V OnCharReadHookExcFuncs . . . . installed handler functions for exceptions ## ## ## ## ## ## contains a list of functions that are installed as exception handlers ## for streams. ## ## ## DeclareGlobalVariable( "OnCharReadHookExcFuncs", "installed exception handlers for streams" ); ############################################################################# ## #V OnCharReadHookExcFds . . . . . . file descriptors for exception handlers ## ## ## ## ## ## contains a list of file descriptors of streams for which exception ## handlers are installed. ## ## ## DeclareGlobalVariable( "OnCharReadHookExcFds", "UNIX file descriptors of streams" ); ############################################################################# ## #V OnCharReadHookExcStreams . . . . . . . . streams with exception handlers ## ## ## ## ## ## contains a list of streams for which exception handlers are installed. ## ## ## DeclareGlobalVariable( "OnCharReadHookExcStreams", "streams for which handlers are installed" ); ############################################################################# ## #F InstallCharReadHookFunc( , , ) ## ## <#GAPDoc Label="InstallCharReadHookFunc"> ## ## ## ## ## installs the function func as a handler function for the stream ## stream. The argument mode decides, for what operations on the ## stream this function is installed. mode must be a string, in which ## a letter r means read, w means write and x means ## exception, according to the select function call in the UNIX ## C-library (see man select and ). More than one letter ## is allowed in mode. As described above the function is called ## in a situation when &GAP; is reading a character from the keyboard. ## Handler functions should not use much time to complete. ##

## This functionality does not work on the Macintosh architecture and ## only works if the operating system has a select function. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "InstallCharReadHookFunc" ); ############################################################################# ## #F UnInstallCharReadHookFunc( , ) ## ## <#GAPDoc Label="UnInstallCharReadHookFunc"> ## ## ## ## ## uninstalls the function func as a handler function for the stream ## stream. All instances are deinstalled, regardless of the mode ## of operation (read, write, exception). ##

## This functionality does not work on the Macintosh architecture and ## only works if the operating system has a select function. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "UnInstallCharReadHookFunc" ); ############################################################################# ## #F InputFromUser( ) ## ## <#GAPDoc Label="InputFromUser"> ## ## ## ## ## prints the arg as a prompt, then waits until a text is typed by the ## user (or from the standard input device if it has been redirected). ## This text must be a single expression, followed by one enter. ## This is evaluated (see ) and the result is returned. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "InputFromUser" ); ############################################################################# ## #E gap-4r6p5/lib/matobjplist.gd0000644000175000017500000000326312172557252014557 0ustar billbill############################################################################ # # matobjplist.gd # by Max Neunhöffer # # Copyright (C) 2006 by Lehrstuhl D für Mathematik, RWTH Aachen # # This file is a sample implementation for new style vectors and matrices. # It stores matrices as dense lists of lists with wrapping. # This part declares the representations and other type related things, # and declares some global functions. # ############################################################################ DeclareRepresentation( "IsPlistVectorRep", IsRowVectorObj and IsPositionalObjectRep, [] ); # 2 positions used: # ![1] : BaseDomain # ![2] : the elements as plain list DeclareRepresentation( "IsPlistMatrixRep", IsRowListMatrix and IsPositionalObjectRep, [] ); # 4 positions used: # ![1] : BaseDomain # ![2] : empty vector of corresponding vector representation # ![3] : row length # ![4] : the rows as plain list of vectors in the filter IsPlistVectorRep # Some constants for matrix access: BindGlobal( "BDPOS", 1 ); BindGlobal( "EMPOS", 2 ); BindGlobal( "RLPOS", 3 ); BindGlobal( "ROWSPOS", 4 ); # For vector access: #BindGlobal( "BDPOS", 1 ); # see above BindGlobal( "ELSPOS", 2 ); # Two filters to speed up some methods: DeclareFilter( "IsIntVector" ); DeclareFilter( "IsFFEVector" ); # Another pair of filters that slow down things: DeclareFilter( "IsCheckingVector" ); DeclareFilter( "IsCheckingMatrix" ); ############################################################################ # Constructors: ############################################################################ DeclareGlobalFunction( "MakePlistVectorType" ); gap-4r6p5/lib/monoid.gd0000644000175000017500000002006012172557252013506 0ustar billbill############################################################################# ## #W monoid.gd GAP library Thomas Breuer ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the declaration of operations for monoids. ## ############################################################################# ## #P IsMonoid( ) ## ## <#GAPDoc Label="IsMonoid"> ## ## ## ## ## A monoid is a magma-with-one (see ) ## with associative multiplication. ## ## ## <#/GAPDoc> ## DeclareSynonymAttr( "IsMonoid", IsMagmaWithOne and IsAssociative ); ############################################################################# ## #F Monoid( , ... ) #F Monoid( ) #F Monoid( , ) ## ## <#GAPDoc Label="Monoid"> ## ## Monoid ## ## ## ## ## In the first form, ## returns the monoid generated by the arguments gen1, gen2, ## \ldots, ## that is, the closure of these elements under multiplication and taking ## the 0-th power. ## In the second form, returns ## the monoid generated by the elements in the homogeneous list gens; ## a square matrix as only argument is treated as one generator, ## not as a list of generators. ## In the second form, the identity element id may be given as the ## second argument. ##

## It is not checked whether the underlying multiplication is ## associative, use and ## ## if you want to check whether a magma-with-one is in fact a monoid. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "Monoid" ); ############################################################################# ## #F Submonoid( , ) . . . . . . submonoid of generated by #F SubmonoidNC( , ) ## ## <#GAPDoc Label="Submonoid"> ## ## ## ## ## ## are just synonyms of ## and , respectively. ## ## ## <#/GAPDoc> ## DeclareSynonym( "Submonoid", SubmagmaWithOne ); DeclareSynonym( "SubmonoidNC", SubmagmaWithOneNC ); ############################################################################# ## #O MonoidByGenerators( [, ] ) . . . . monoid generated by ## ## <#GAPDoc Label="MonoidByGenerators"> ## ## ## ## ## is the underlying operation of . ## ## ## <#/GAPDoc> ## DeclareOperation( "MonoidByGenerators", [ IsCollection ] ); ############################################################################# ## #A AsMonoid( ) . . . . . . . . . . . . collection regarded as monoid ## ## <#GAPDoc Label="AsMonoid"> ## ## ## ## ## If C is a collection whose elements form a monoid ## (see ) ## then returns this monoid. ## Otherwise fail is returned. ## ## ## <#/GAPDoc> ## DeclareAttribute( "AsMonoid", IsCollection ); ############################################################################# ## #O AsSubmonoid( , ) ## ## <#GAPDoc Label="AsSubmonoid"> ## ## ## ## ## Let D be a domain and C a collection. ## If C is a subset of D that forms a monoid then ## ## returns this monoid, with parent D. ## Otherwise fail is returned. ## ## ## <#/GAPDoc> ## DeclareOperation( "AsSubmonoid", [ IsDomain, IsCollection ] ); ############################################################################# ## #A GeneratorsOfMonoid( ) . . . . . . . monoid generators of monoid ## ## <#GAPDoc Label="GeneratorsOfMonoid"> ## ## ## ## ## Monoid generators of a monoid M are the same as ## magma-with-one generators ## (see ). ## ## ## <#/GAPDoc> ## DeclareSynonymAttr( "GeneratorsOfMonoid", GeneratorsOfMagmaWithOne ); ############################################################################# ## #A TrivialSubmonoid( ) . . . . . . . . . trivial submonoid of monoid ## ## <#GAPDoc Label="TrivialSubmonoid"> ## ## ## ## ## is just a synonym for . ## ## ## <#/GAPDoc> ## DeclareSynonymAttr( "TrivialSubmonoid", TrivialSubmagmaWithOne ); ############################################################################# ## #F FreeMonoid( [,] ) #F FreeMonoid( [,], ) #F FreeMonoid( [,], , ... ) #F FreeMonoid( [,] ) #F FreeMonoid( [,]infinity, , ) ## ## <#GAPDoc Label="FreeMonoid"> ## ## FreeMonoid ## ## ## ## ## ## ## Called with a positive integer rank, ## returns ## a free monoid on rank generators. ## If the optional argument name is given then the generators are ## printed as name1, name2 etc., ## that is, each name is the concatenation of the string name and an ## integer from 1 to range. ## The default for name is the string "m". ##

## Called in the second form, ## returns ## a free monoid on as many generators as arguments, printed as ## name1, name2 etc. ##

## Called in the third form, ## returns ## a free monoid on as many generators as the length of the list ## names, the i-th generator being printed as ## names[i]. ##

## Called in the fourth form, ## ## returns a free monoid on infinitely many generators, where the first ## generators are printed by the names in the list init, ## and the other generators by name and an appended number. ##

## If the extra argument wfilt is given, it must be either ## or ## or or ## . ## This filter then specifies the representation used for the elements of ## the free monoid ## (see ). ## If no such filter is given, a letter representation is used. ##

## Also see Chapter . ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "FreeMonoid" ); ############################################################################# ## #E gap-4r6p5/lib/rwssmg.gd0000644000175000017500000001522112172557254013550 0ustar billbill############################################################################# ## #W rwssmg.gd GAP library Isabel Araújo ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the declarations for semigroups defined by rws. ## ############################################################################ ## #A ReducedConfluentRewritingSystem( [, ] ) ## ## <#GAPDoc Label="ReducedConfluentRewritingSystem"> ## ## ## ## ## returns a reduced confluent rewriting system of ## the finitely presented semigroup or monoid S with respect to the ## reduction ordering ordering (see ). ##

## The default for ordering is the length plus lexicographic ordering ## on words, also called the shortlex ordering; for the definition see for ## example . ##

## Notice that this might not terminate. In particular, if the semigroup or ## monoid S does not have a solvable word problem then it this will ## certainly never end. ## Also, in this case, the object returned is an immutable ## rewriting system, because once we have a confluent ## rewriting system for a finitely presented semigroup or monoid we do ## not want to allow it to change (as it was most probably very time ## consuming to get it in the first place). Furthermore, this is also ## an attribute storing object (see ). ## f := FreeSemigroup( "a" , "b" );; ## gap> a := GeneratorsOfSemigroup( f )[ 1 ];; ## gap> b := GeneratorsOfSemigroup( f )[ 2 ];; ## gap> g := f / [ [ a^2 , a*b ] , [ a^4 , b] ];; ## gap> rws := ReducedConfluentRewritingSystem(g); ## Rewriting System for Semigroup( [ a, b ] ) with rules ## [ [ a*b, a^2 ], [ a^4, b ], [ b*a, a^2 ], [ b^2, a^2 ] ] ## ]]> ##

## The creation of a reduced confluent rewriting system for a semigroup ## or for a monoid, in &GAP;, uses the Knuth-Bendix procedure for strings, ## which manipulates a rewriting system of the semigroup or monoid and attempts ## to make it confluent (See . ## See also Sims ). ## (Since the word problem for semigroups/monoids is not solvable in general, ## Knuth-Bendix procedure cannot always terminate). ##

## In order to apply this procedure we will build a rewriting system ## for the semigroup or monoid, which we will call a Knuth-Bendix Rewriting ## System (we need to define this because we need the rewriting system ## to store some information needed for the implementation of the ## Knuth-Bendix procedure). ##

## Actually, Knuth-Bendix Rewriting Systems do not only serve this purpose. ## Indeed these are objects which are mutable and which can be manipulated ## (see ). ##

## Note that the implemented version of the Knuth-Bendix procedure, in &GAP; ## returns, if it terminates, a confluent rewriting system which is reduced. ## Also, a reduction ordering has to be specified when building a rewriting ## system. If none is specified, the shortlex ordering is assumed ## (note that the procedure may terminate with a certain ordering and ## not with another one). ##

## On Unix systems it is possible to replace the built-in Knuth-Bendix by ## other routines, for example the package kbmag offers ## such a possibility. ## ## ## <#/GAPDoc> ## DeclareAttribute("ReducedConfluentRewritingSystem",IsSemigroup); ############################################################################# ## #A FreeMonoidOfRewritingSystem() ## ## <#GAPDoc Label="FreeMonoidOfRewritingSystem"> ## ## ## ## ## returns the free monoid over which rws is ## a rewriting system ## f1 := FreeSemigroupOfRewritingSystem(rws); ## ## gap> f1=f; ## true ## gap> g1 := SemigroupOfRewritingSystem(rws); ## ## gap> g1=g; ## true ## ]]> ##

## As mentioned before, having a confluent rewriting system, one can decide ## whether two words represent the same element of a finitely ## presented semigroup (or finitely presented monoid). ##

## a := GeneratorsOfSemigroup( g )[ 1 ]; ## a ## gap> b := GeneratorsOfSemigroup( g )[ 2 ]; ## b ## gap> a*b*a=a^3; ## true ## gap> ReducedForm(rws,UnderlyingElement(a*b*a)); ## a^3 ## gap> ReducedForm(rws,UnderlyingElement(a^3)); ## a^3 ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute("FreeMonoidOfRewritingSystem", IsRewritingSystem); ############################################################################# ## #A FamilyForRewritingSystem() ## ## ## ## ## ## returns the family of words over which rws is ## a rewriting system ## ## ## DeclareAttribute("FamilyForRewritingSystem", IsRewritingSystem); ############################################################################# ## #A FreeSemigroupOfRewritingSystem() ## ## <#GAPDoc Label="FreeSemigroupOfRewritingSystem"> ## ## ## ## ## returns the free semigroup over which rws is ## a rewriting system ## ## ## <#/GAPDoc> ## DeclareAttribute("FreeSemigroupOfRewritingSystem", IsRewritingSystem); ############################################################################# ## #F ReduceLetterRepWordsRewSys(,) ## ## ## ## ## ## Here w is a word of a free monoid or a free semigroup in tz ## represenattion, and tzrules are rules in tz representation. This ## function returns the reduced word in tz representation. ##

## All lists in tzrules as well as w must be plain lists, the entries ## must be small integers. (The behaviour otherwise is unpredictable.) ## ## ## DeclareGlobalFunction("ReduceLetterRepWordsRewSys"); ############################################################################# ## #E gap-4r6p5/lib/ctblsolv.gi0000644000175000017500000022575512172557252014100 0ustar billbill############################################################################# ## #W ctblsolv.gi GAP library Hans Ulrich Besche #W Thomas Breuer ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains character table methods for solvable groups. ## ############################################################################# ## #M CharacterDegrees( ,

) . . . . . . . . . . . for an abelian group ## InstallMethod( CharacterDegrees, "for an abelian group, and an integer p (just strip off the p-part)", [ IsGroup and IsAbelian, IsInt ], RankFilter(IsZeroCyc), # There is a method for groups for # the integer zero which is worse function( G, p ) G:= Size( G ); if p <> 0 then while G mod p = 0 do G:= G / p; od; fi; return [ [ 1, G ] ]; end ); ############################################################################# ## #F AppendCollectedList( , ) ## BindGlobal( "AppendCollectedList", function( list1, list2 ) local pair1, pair2, toadd; for pair2 in list2 do toadd:= true; for pair1 in list1 do if pair1[1] = pair2[1] then pair1[2]:= pair1[2] + pair2[2]; toadd:= false; break; fi; od; if toadd then AddSet( list1, pair2 ); fi; od; end ); ############################################################################# ## #F KernelUnderDualAction( , , ) . . . . . . . local function ## ## is a PCGS of an elementary abelian group . ## is a vector in the dual space of , w.r.t. . ## The kernel of is returned. ## BindGlobal( "KernelUnderDualAction", function( N, Npcgs, v ) local gens, # generators list i, j; gens:= []; for i in Reversed( [ 1 .. Length( v ) ] ) do if IsZero( v[i] ) then Add( gens, Npcgs[i] ); else # `i' is the position of the last nonzero entry of `v'. for j in Reversed( [ 1 .. i-1 ] ) do Add( gens, Npcgs[j]*Npcgs[i]^( Int(-v[j]/v[i]) ) ); od; return SubgroupNC( N, Reversed( gens ) ); fi; od; end ); ############################################################################# ## #F ProjectiveCharDeg( , , ) ## InstallGlobalFunction( ProjectiveCharDeg, function( G, z, q ) local oz, # the order of `z' N, # normal subgroup of `G' t, r, # collected list of character degrees, result h, # natural homomorphism img, k, c, ci, zn, i, p, # prime divisor of the size of `N' P, # Sylow `p' subgroup of `N' O, L, Gpcgs, # PCGS of `G' Ppcgs, # PCGS of `P' Opcgs, # PCGS of `O' mats, orbs, orb, # loop over `orbs' stab; # stabilizer of canonical representative of `orb' oz:= Order( z ); # For abelian groups, there are only linear characters. if IsAbelian( G ) then G:= Size( G ); if q <> 0 then while G mod q = 0 do G:= G / q; od; fi; return [ [ 1, G/oz ] ]; fi; # Now `G' is not abelian. h:= NaturalHomomorphismByNormalSubgroupNC( G, SubgroupNC( G, [ z ] ) ); img:= ImagesSource( h ); N:= ElementaryAbelianSeriesLargeSteps( img ); N:= N[ Length( N )-1 ]; if not IsPrime( Size( N ) ) then N:= ChiefSeriesUnderAction( img, N ); N:= N[ Length( N )-1 ]; fi; # `N' is a normal subgroup such that `N/' is a chief factor of `G' # of order `i' which is a power of `p'. N:= PreImagesSet( h, N ); i:= Size( N ) / oz; p:= Factors( i )[1]; if not IsAbelian( N ) then h:= NaturalHomomorphismByNormalSubgroupNC( G, SubgroupNC( G, [ z ] ) ); # `c' is a list of complement classes of `N' modulo `z' c:= List( ComplementClassesRepresentatives( ImagesSource( h ), ImagesSet( h, N ) ), x -> PreImagesSet( h, x ) ); r:= Centralizer( G, N ); for L in c do if IsSubset( L, r ) then # L is a complement to N in G modulo which centralizes N r:= RootInt( Size(N) / oz ); return List( ProjectiveCharDeg( L, z, q ), x -> [ x[1]*r, x[2] ] ); fi; od; Error( "this should not happen" ); fi; # `N' is abelian, `P' is its Sylow `p' subgroup. P:= SylowSubgroup( N, p ); if p = q then # Factor out `P' (lies in the kernel of the repr.) h:= NaturalHomomorphismByNormalSubgroupNC( G, P ); return ProjectiveCharDeg( ImagesSource( h ), ImageElm( h, z ), q ); elif i = Size( P ) then # `z' is a p'-element, `P' is elementary abelian. # Find the characters of the factor group needed. h:= NaturalHomomorphismByNormalSubgroupNC( G, P ); r:= ProjectiveCharDeg( ImagesSource( h ), ImageElm( h, z ), q ); if p = i then # `P' has order `p'. zn:= First( GeneratorsOfGroup( P ), g -> not IsOne( g ) ); t:= Stabilizer( G, zn ); i:= Size(G) / Size(t); AppendCollectedList( r, List( ProjectiveCharDeg( t, zn*z, q ), x -> [ x[1]*i, x[2]*(p-1)/i ] ) ); return r; else # `P' has order strictly larger than `p'. # `mats' describes the contragredient operation of `G' on `P'. Gpcgs:= Pcgs( G ); Ppcgs:= Pcgs( P ); mats:= List( List( Gpcgs, Inverse ), x -> TransposedMat( List( Ppcgs, y -> ExponentsConjugateLayer( Ppcgs, y,x ) )*Z(p)^0 ) ); orbs:= ExternalOrbitsStabilizers( G, NormedRowVectors( GF(p)^Length( Ppcgs ) ), Gpcgs, mats, OnLines ); orbs:= Filtered( orbs, o -> not IsZero( CanonicalRepresentativeOfExternalSet( o ) ) ); for orb in orbs do # `k' is the kernel of the character. stab:= StabilizerOfExternalSet( orb ); h:= NaturalHomomorphismByNormalSubgroupNC( stab, KernelUnderDualAction( P, Ppcgs, CanonicalRepresentativeOfExternalSet( orb ) ) ); img:= ImagesSource( h ); # `zn' is an element of `img'. # Note that the image of `P' under `h' has order `p'. zn:= First( GeneratorsOfGroup( ImagesSet( h, P) ), g -> not IsOne( g ) ) * ImageElm( h, z ); # `c' is stabilizer of the character, # `ci' is the number of orbits of characters with equal kernels if p = 2 then c := img; ci := 1; else c := Stabilizer( img, zn ); ci := Size( img ) / Size( c ); fi; k:= Size( G ) / Size( stab ) * ci; AppendCollectedList( r, List( ProjectiveCharDeg( c, zn, q ), x -> [ x[1]*k, x[2]*(p-1)/ci ] ) ); od; return r; fi; elif IsCyclic( P ) then # Choose a generator `zn' of `P'. zn := Pcgs( P )[1]; t := Stabilizer( G, zn, OnPoints ); if G = t then # `P' is a central subgroup of `G'. return List( ProjectiveCharDeg( G, zn*z, q ), x -> [ x[1], x[2]*p ] ); else # `P' is not central in `G'. return List( ProjectiveCharDeg( t, zn*z, q ), x -> [ x[1]*p, x[2] ] ); fi; fi; # `P' is the direct product of the Sylow `p' subgroup of `z' # and an elementary abelian `p' subgroup. O:= Omega( P, p ); Opcgs:= Pcgs( O ); Gpcgs:= Pcgs( G ); # `zn' is a generator of the intersection of and `O' zn := z^(oz/p); r := []; mats:= List( List( Gpcgs, Inverse ), x -> TransposedMat( List( Opcgs, y -> ExponentsConjugateLayer( Opcgs, y,x ) ) * Z(p)^0 ) ); orbs:= ExternalOrbitsStabilizers( G, NormedRowVectors( GF(p)^Length( Opcgs ) ), Gpcgs, mats, OnLines ); orbs:= Filtered( orbs, o -> not IsZero( CanonicalRepresentativeOfExternalSet( o ) ) ); # In this case the stabilzers of the kernels are already the # stabilizers of the characters. for orb in orbs do k:= KernelUnderDualAction( O, Opcgs, CanonicalRepresentativeOfExternalSet( orb ) ); if not zn in k then # The kernel avoids `zn'. t:= StabilizerOfExternalSet( orb ); h:= NaturalHomomorphismByNormalSubgroupNC( t, k ); img:= ImagesSource( h ); t:= Size(G) / Size(t); AppendCollectedList( r, List( ProjectiveCharDeg( img, ImageElm( h, z ), q ), x -> [ x[1]*t, x[2] ] ) ); fi; od; return r; end ); ############################################################################# ## #M CharacterDegrees( ,

) . . . . . . . . . . . for a solvable group ## ## The algorithm used is based on~\cite{Con90b}, ## its main tool is Clifford theory. ## ## Given a solvable group $G$ and a nonnegative integer $q$, ## we first choose an elementary abelian normal subgroup $N$. ## (Note that $N$ need not be a *minimal* normal subgroup, this requirement ## in~\cite{Con90b} applies only to the computation of projective degrees ## where nonabelian normal subgroups $N$ occur.) ## By recursion, the $q$-modular character degrees of the factor group $G/N$ ## are computed next. ## So it remains to compute the degrees of those $q$-modular irreducible ## characters whose kernels do not contain $N$. ## This last step follows~\cite{Con90b}, for the special case of a *trivial* ## central subgroup $Z$. ## Namely, we compute the $G$-orbits on the linear spaces of the nontrivial ## irreducible characters of $N$, under projective action. ## (The orbit consisting of the trivial character corresponds to those ## $q$-modular irreducible $G$-characters with $N$ in their kernels.) ## For each orbit, we use the function `ProjectiveCharDeg' to compute the ## degrees arising from a representative $\chi$, ## in the group $S/K$ with central cyclic subgroup $N/K$, ## where $S$ is the (subspace) stabilizer of $\chi$ and $K$ is the kernel of ## $\chi$. ## ## One recursive step of the algorithm is described in the following. ## ## Let $G$ be a solvable group, $z$ a central element in $G$, ## and let $q$ be the characteristic of the algebraic closed field $F$. ## Without loss of generality, we may assume that $G$ is nonabelian. ## Consider a faithful linear character $\lambda$ of $\langle z \rangle$. ## We calculate the character degrees $(G,z,q)$ of those absolutely ## irreducible characters of $G$ whose restrictions to $\langle z \rangle$ ## are a multiple of $\lambda$. ## ## We choose a normal subgroup $N$ of $G$ such that the factor ## $N / \langle z \rangle$ is a chief factor in $G$, and consider ## the following cases. ## ## If $N$ is nonabelian then we calculate a subgroup $L$ of $G$ such that ## $N \cap L = \langle z \rangle$, $L$ centralizes $N$, and $N L = G$. ## One can show that the order of $N / \langle z \rangle$ is a square $r^2$, ## and that the degrees $(G,z,q)$ are obtained from the degrees $(L,z,q)$ ## on multiplying each with $r$. ## ## If $N$ is abelian then the order of $N / \langle z \rangle$ is a prime ## power $p^i$. ## Let $P$ denote the Sylow $p$ subgroup of $N$. ## Following Clifford's theorem, we calculate orbit representatives and ## inertia subgroups with respect to the action of $G$ on those irreducible ## characters of $P$ that restrict to multiples of $\lambda_P$. ## For that, we distinguish three cases. ## \beginlist ## \item{(a)} ## $z$ is a $p^{\prime}$ element. ## Then we compute first the character degrees $(G/P,zP,q)$, ## corresponding to the (orbit of the) trivial character. ## The action on the nontrivial irreducible characters of $P$ ## is dual to the action on the nonzero vectors of the vector space ## $P$. ## For each representative, we compute the kernel $K$, and the degrees ## $(S/K,zK,q)$, where $S$ denotes the inertia subgroup. ## ## \item{(b)} ## $z$ is not a $p^{\prime}$ element, and $P$ cyclic (not prime order). ## Let $y$ be a generator of $P$. ## If $y$ is central in $G$ then we have to return $p$ copies of the ## degrees $(G,zy,q)$. ## Otherwise we compute the degrees $(C_G(y),zy,q)$, and multiply ## each with $p$. ## ## \item{(c)} ## $z$ is not a $p^{\prime}$ element, and $P$ is not cyclic. ## We compute $O = \Omega(P)$. ## As above, we consider the dual operation to that in $O$, ## and for each orbit representative we check whether its restriction ## to $O$ is a multiple of $\lambda_O$, and if yes compute the degrees ## $(S/K,zK,q)$. ## \endlist ## BindGlobal( "CharacterDegreesConlon", function( G, q ) local r, # list of degrees, result N, # elementary abelian normal subgroup of `G' p, # prime divisor of the order of `N' z, # one generator of `N' t, # stabilizer of `z' in `G' i, # index of `t' in `G' Gpcgs, # PCGS of `G' Npcgs, # PCGS of `N' mats, # matrices describing the action of `Gpcgs' w.r.t. `Npcgs' orbs, # orbits of the action orb, # loop over `orbs' rep, # canonical representative of `orb' stab, # stabilizer of `rep' h, # nat. hom. by the kernel of a character img, # image of `h' c, ci, k; Info( InfoCharacterTable, 1, "CharacterDegrees: called for group of order ", Size( G ) ); # If the group is abelian, we must give up because this method # needs a proper elementary abelian normal subgroup for its # reduction step. # (Note that we must not call `TryNextMethod' because the method # for abelian groups has higher rank.) if IsAbelian( G ) then r:= CharacterDegrees( G, q ); Info( InfoCharacterTable, 1, "CharacterDegrees: returns ", r ); return r; elif not ( q = 0 or IsPrimeInt( q ) ) then Error( " mut be zero or a prime" ); fi; # Choose a normal elementary abelian `p'-subgroup `N', # not necessarily minimal. N:= ElementaryAbelianSeriesLargeSteps( G ); N:= N[ Length( N ) - 1 ]; r:= CharacterDegrees( G / N, q ); p:= Factors( Size( N ) )[1]; if p = q then # If `N' is a `q'-group we are done. Info( InfoCharacterTable, 1, "CharacterDegrees: returns ", r ); return r; elif Size( N ) = p then # `N' is of prime order. z:= Pcgs( N )[1]; t:= Stabilizer( G, z, OnPoints ); i:= Size( G ) / Size( t ); AppendCollectedList( r, List( ProjectiveCharDeg( t, z, q ), x -> [ x[1]*i, x[2]*(p-1)/i ] ) ); else # `N' is an elementary abelian `p'-group of nonprime order. Gpcgs:= Pcgs( G ); Npcgs:= Pcgs( N ); mats:= List( Gpcgs, x -> TransposedMat( List( Npcgs, y -> ExponentsConjugateLayer( Npcgs, y,x ) ) * Z(p)^0 )^-1 ); orbs:= ExternalOrbitsStabilizers( G, NormedRowVectors( GF( p )^Length( Npcgs ) ), Gpcgs, mats, OnLines ); #T may fail because the list is too long! orbs:= Filtered( orbs, o -> not IsZero( CanonicalRepresentativeOfExternalSet( o ) ) ); for orb in orbs do stab:= StabilizerOfExternalSet( orb ); rep:= CanonicalRepresentativeOfExternalSet( orb ); h:= NaturalHomomorphismByNormalSubgroupNC( stab, KernelUnderDualAction( N, Npcgs, rep ) ); img:= ImagesSource( h ); # The kernel has index `p' in `stab'. z:= First( GeneratorsOfGroup( ImagesSet( h, N ) ), g -> not IsOne( g ) ); if p = 2 then c := img; ci := 1; else c := Stabilizer( img, z ); ci := Size( img ) / Size( c ); fi; k:= Size( G ) / Size( stab ) * ci; AppendCollectedList( r, List( ProjectiveCharDeg( c, z, q ), x -> [ x[1]*k, x[2]*(p-1)/ci ] ) ); od; fi; Info( InfoCharacterTable, 1, "CharacterDegrees: returns ", r ); return r; end ); InstallMethod( CharacterDegrees, "for a solvable group and an integer (Conlon's algorithm)", [ IsGroup and IsSolvableGroup, IsInt ], RankFilter(IsZeroCyc), # There is a method for groups for # the integer zero which is worse function( G, q ) if HasIrr( G ) then # Use the known irreducibles. TryNextMethod(); else return CharacterDegreesConlon( G, q ); fi; end ); ############################################################################# ## #F CoveringTriplesCharacters( , ) . . . . . . . . . . . . . . . local ## InstallGlobalFunction( CoveringTriplesCharacters, function( G, z ) local oz, h, img, N, t, r, k, c, zn, i, p, P, O, Gpcgs, Ppcgs, Opcgs, mats, orbs, orb; # The trivial character will be dealt with separately. if IsTrivial( G ) then return []; fi; oz:= Order( z ); if Size( G ) = oz then return [ [ G, TrivialSubgroup( G ), z ] ]; fi; h:= NaturalHomomorphismByNormalSubgroupNC( G, SubgroupNC( G, [ z ] ) ); img:= ImagesSource( h ); N:= ElementaryAbelianSeriesLargeSteps( img ); N:= N[ Length( N ) - 1 ]; if not IsPrime( Size( N ) ) then N:= ChiefSeriesUnderAction( img, N ); N:= N[ Length( N ) - 1 ]; fi; N:= PreImagesSet( h, N ); if not IsAbelian( N ) then Info( InfoCharacterTable, 2, "#I misuse of `CoveringTriplesCharacters'!\n" ); return []; fi; i:= Size( N ) / oz; p:= Factors( i )[1]; P:= SylowSubgroup( N, p ); if i = Size( P ) then # `z' is a p'-element, `P' is elementary abelian. # Find the characters of the factor group needed. h:= NaturalHomomorphismByNormalSubgroupNC( G, P ); r:= List( CoveringTriplesCharacters( ImagesSource( h ), ImageElm( h, z ) ), x -> [ PreImagesSet( h, x[1] ), PreImagesSet( h, x[2] ), PreImagesRepresentative( h, x[3] ) ] ); if p = i then # `P' has order `p'. zn:= First( GeneratorsOfGroup( P ), g -> not IsOne( g ) ); return Concatenation( r, CoveringTriplesCharacters( Stabilizer( G, zn ), zn*z ) ); else Gpcgs:= Pcgs( G ); Ppcgs:= Pcgs( P ); mats:= List( List( Gpcgs, Inverse ), x -> TransposedMat( List( Ppcgs, y -> ExponentsConjugateLayer( Ppcgs, y,x ) )*Z(p)^0 ) ); orbs:= ExternalOrbitsStabilizers( G, NormedRowVectors( GF(p)^Length( Ppcgs ) ), Gpcgs, mats, OnLines ); orbs:= Filtered( orbs, o -> not IsZero( CanonicalRepresentativeOfExternalSet( o ) ) ); for orb in orbs do h:= NaturalHomomorphismByNormalSubgroupNC( StabilizerOfExternalSet( orb ), KernelUnderDualAction( P, Ppcgs, CanonicalRepresentativeOfExternalSet( orb ) ) ); img:= ImagesSource( h ); zn:= First( GeneratorsOfGroup( ImagesSet( h, P ) ), g -> not IsOne( g ) ) * ImageElm( h, z ); if p = 2 then c:= img; else c:= Stabilizer( img, zn ); fi; Append( r, List( CoveringTriplesCharacters( c, zn ), x -> [ PreImagesSet( h, x[1] ), PreImagesSet( h, x[2] ), PreImagesRepresentative( h, x[3] ) ] ) ); od; return r; fi; elif IsCyclic( P ) then zn:= Pcgs( P )[1]; return CoveringTriplesCharacters( Stabilizer( G, zn ), zn*z ); fi; O:= Omega( P, p ); Opcgs:= Pcgs( O ); Gpcgs:= Pcgs( G ); zn := z^(oz/p); r := []; mats:= List( List( Gpcgs, Inverse ), x -> TransposedMat( List( Opcgs, y -> ExponentsConjugateLayer( Opcgs, y,x ) )*Z(p)^0 ) ); orbs:= ExternalOrbitsStabilizers( G, NormedRowVectors( GF(p)^Length( Opcgs ) ), Gpcgs, mats, OnLines ); orbs:= Filtered( orbs, o -> not IsZero( CanonicalRepresentativeOfExternalSet( o ) ) ); for orb in orbs do k:= KernelUnderDualAction( O, Opcgs, CanonicalRepresentativeOfExternalSet( orb ) ); if not zn in k then t:= SubgroupNC( G, StabilizerOfExternalSet( orb ) ); h:= NaturalHomomorphismByNormalSubgroupNC( t, k ); img:= ImagesSource( h ); Append( r, List( CoveringTriplesCharacters( img, ImageElm( h, z ) ), x -> [ PreImagesSet( h, x[1] ), PreImagesSet( h, x[2] ), PreImagesRepresentative( h, x[3] ) ] ) ); fi; od; return r; end ); ############################################################################# ## #M IrrConlon( ) ## ## This algorithm is a generalization of the algorithm to compute the ## absolutely irreducible degrees of a solvable group to the computation ## of the absolutely irreducible characters of a supersolvable group, ## using an idea like in ## ## S. B. Conlon, J. Symbolic Computation (1990) 9, 535-550. ## ## The function `CoveringTriplesCharacters' is used to compute a list of ## triples describing linear representations of subgroups of . ## These linear representations are induced to and then evaluated on ## representatives of the conjugacy classes. ## ## For every irreducible character the monomiality information is stored as ## value of the attribute `TestMonomial'. ## InstallMethod( IrrConlon, "for a group", [ IsGroup ], function( G ) local mulmoma, # local function: multiply monomial matrices ct, # character table of `G' ccl, # conjugacy classes of `G' Gpcgs, # PCGS of `G' irr, # matrix of character values irredinfo, # monomiality info evl, # encode class representatives as words in `Gpcgs' i, t, chi, j, mat, k, triple, hom, zi, oz, ee, zp, co, # cosets coreps, # representatives of `co' dim, rep, # matrix representation bco, p, i1, # loop variable in `mulmoma' re; # result of `mulmoma' # Compute the product of the monomial matrices `a' and `b'; # The diagonal elements are powers of a fixed `oz'-th root of unity. mulmoma:= function( a, b ) re:= rec( perm:= [], diag:= [] ); for i1 in [ 1 .. Length( a.perm ) ] do re.perm[i1]:= b.perm[ a.perm[i1] ]; re.diag[ b.perm[i1] ]:= ( b.diag[ b.perm[i1] ] + a.diag[i1] ) mod oz; od; return re; end; ct:= CharacterTable( G ); ccl:= ConjugacyClasses( ct ); Gpcgs:= Pcgs( G ); irr:= []; irredinfo:= [ rec( inducedFrom:= rec( subgroup:= G, kernel:= G ) ) ]; # `evl' is a list describing representatives of the nontrivial # conjugacy classes. # the entry for the element $g.1^2*g.2^0*g.3^1$ is $[ 1, 1, 3 ]$. evl:= []; for i in [ 2 .. Length( ccl ) ] do k:= ExponentsOfPcElement( Gpcgs, Representative( ccl[i] ) ); t:= []; for j in [ 1 .. Length( k ) ] do if 0 < k[j] then Append( t, [ 1 .. k[j] ]*0 + j ); fi; od; Add( evl, t ); od; for triple in CoveringTriplesCharacters( G, One( G ) ) do hom:= NaturalHomomorphismByNormalSubgroupNC( triple[1], triple[2] ); zi:= ImagesRepresentative( hom, triple[3] ); oz:= Order( zi ); ee:= E( oz ); zp:= List( [ 1 .. oz ], x -> zi^x ); co:= RightCosets( G, triple[1] ); coreps:= List( co, Representative ); dim:= Length( co ); # `rep' describes a matrix representation on a module with basis # a transversal of the stabilizer in `G'. # (The monomial matrices are the same as in `RepresentationsPGroup'.) rep:= []; for i in Gpcgs do mat:= rec( perm:= [], diag:= [] ); for j in [ 1 .. dim ] do bco:= co[j]*i; p:= Position( co, bco, 0 ); Add( mat.perm, p ); mat.diag[p]:= Position( zp, ImageElm( hom, coreps[j]*i*Inverse( coreps[p] ) ), 0 ); od; Add( rep, mat ); od; # Compute the representing matrices for class representatives, # and their traces. chi:= [ dim ]; for j in evl do mat:= Iterated( rep{ j }, mulmoma ); t:= 0; for k in [ 1 .. dim ] do if mat.perm[k] = k then t:= t + ee^mat.diag[k]; fi; od; Add( chi, t ); od; # Test if `chi' is known and add `chi' and its Galois-conjugates # to the list. # Also compute the monomiality information. if not chi in irr then chi:= GaloisMat( [ chi ] ).mat; Append( irr, chi ); for j in chi do Add( irredinfo, rec( subgroup:= triple[1], kernel:= triple[2] ) ); od; fi; od; # Construct the characters from their values lists, # and set the monomiality info. irr:= Concatenation( [ TrivialCharacter( G ) ], List( irr, chi -> Character( ct, chi ) ) ); for i in [ 1 .. Length( irr ) ] do SetTestMonomial( irr[i], irredinfo[i] ); od; # Return the characters. return irr; end ); ############################################################################# ## #M Irr( , 0 ) . . . . . . for a supersolvable group (Conlon's algorithm) ## InstallMethod( Irr, "for a supersolvable group (Conlon's algorithm)", [ IsGroup and IsSupersolvableGroup, IsZeroCyc ], function( G, zero ) local irr; irr:= IrrConlon( G ); SetIrr( OrdinaryCharacterTable( G ), irr ); return irr; end ); InstallMethod( Irr, "for a supersolvable group with known `IrrConlon'", [ IsGroup and IsSupersolvableGroup and HasIrrConlon, IsZeroCyc ], function( G, zero ) local irr; irr:= IrrConlon( G ); SetIrr( OrdinaryCharacterTable( G ), irr ); return irr; end ); ############################################################################# ## #M Irr( , 0 ) . . . . for a supersolvable group (Baum-Clausen algorithm) ## InstallMethod( Irr, "for a supersolvable group (Baum-Clausen algorithm)", [ IsGroup and IsSupersolvableGroup, IsZeroCyc ], function( G, zero ) local irr; irr:= IrrBaumClausen( G ); SetIrr( OrdinaryCharacterTable( G ), irr ); return irr; end ); InstallMethod( Irr, "for a supersolvable group with known `IrrBaumClausen'", [ IsGroup and IsSupersolvableGroup and HasIrrBaumClausen, IsZeroCyc ], function( G, zero ) local irr; irr:= IrrBaumClausen( G ); SetIrr( OrdinaryCharacterTable( G ), irr ); return irr; end ); ############################################################################# ## #V BaumClausenInfoDebug . . . . . . . . . . . . . . testing BaumClausenInfo ## InstallValue( BaumClausenInfoDebug, rec( makemat:= function( record, e ) local dim, mat, diag, gcd, i; dim:= Length( record.diag ); mat:= NullMat( dim, dim ); diag:= record.diag; gcd:= Gcd( diag ); if gcd = 0 then e:= 1; else gcd:= GcdInt( gcd, e ); e:= E( e / gcd ); diag:= diag / gcd; fi; for i in [ 1 .. dim ] do mat[i][ record.perm[i] ]:= e^diag[ record.perm[i] ]; od; return mat; end, testrep:= function( pcgs, rep, e ) local images, hom; images:= List( rep, record -> BaumClausenInfoDebug.makemat( record, e ) ); hom:= GroupGeneralMappingByImagesNC( Group( pcgs ), Group( images ), pcgs, images ); return IsGroupHomomorphism( hom ); end, checkconj:= function( pcgs, i, lg, j, rep1, rep2, X, e ) local ii, exps, mat, jj; X:= BaumClausenInfoDebug.makemat( X, e ); for ii in [ i .. lg ] do exps:= ExponentsOfPcElement( pcgs, pcgs[ii]^pcgs[j], [ i .. lg ] ); mat:= One( X ); for jj in [ 1 .. lg-i+1 ] do mat:= mat * BaumClausenInfoDebug.makemat( rep1[jj], e )^exps[jj]; od; if X * mat <> BaumClausenInfoDebug.makemat( rep2[ ii-i+1 ], e ) * X then return false; fi; od; return true; end ) ); ############################################################################# ## #M BaumClausenInfo( ) . . . . . info about irreducible representations ## #T generalize to characteristic p !! ## InstallMethod( BaumClausenInfo, "for a (solvable) group", [ IsGroup ], function( G ) local e, # occurring roots of unity are `e'-th roots pcgs, # Pcgs of `G' lg, # length of `pcgs' cs, # composition series of `G' corresp. to `pcgs' abel, # position of abelian normal comp. subgroup ExtLinRep, # local function indices, # sizes of composition factors in `cs' linear, # list of linear representations i, # current position in the iteration: $G_i$ p, # size of current composition factor pexp, # exponent vector of `pcgs[i]^p' root, # value of an xtension roots, # list of $p$-th roots (relative to `e') mulmoma, # product of two monomial matrices poweval, # representing matrix for power of generator pilinear, # action of $g_1, \ldots, g_i$ on `linear' d, j, k, l, # loop variables u, v, w, # loop variables M, # pos, # position in a list nonlin, # list of nonlinear representations pinonlin, # action of $g_1, \ldots, g_i$ on `nonlin' Xlist, # conjugating matrices: # for $X = `Xlist[j][k]'$, we have # $X \cdot {`nonlin[k]'}^{g_j} \cdot X^{-1} = # `nonlin[ pinonlin[j][k] ]'$ min, # minval, # ssr, # next, # X, # one matrix for `Xlist' nextlinear, # extensions of `linear' nextnonlin1, # nonlinear repr. arising from `linear' nextnonlin2, # nonlinear repr. arising from `nonlin' pinextlinear, # action of $g_1, \ldots, g_i$ on `nextlinear' pinextnonlin1, # action of $g_1, \ldots, g_i$ on `nextnonlin1' pinextnonlin2, # action of $g_1, \ldots, g_i$ on `nextnonlin2' nextXlist1, # conjugating matrices for `nextnonlin1' nextXlist2, # conjugating matrices for `nextnonlin2' cexp, # exponent vector of `pcgs[i]^pcgs[j]' poli, # list that encodes `pexp' rep, # one representation D, C, # value, # image, # used, # boolean list Dpos1, # positions of extension resp. induced repres. # that arise from linear representations Dpos2, # positions of extension resp. induced repres. # that arise from nonlinear representations dim, # dimension of the current representation invX, # inverse of `X' D_gi, # hom, # homomorphism to adjust the composition series orb, # Forb, # sigma, pi, # permutations needed in the fusion case constants, # vector $(c_0, c_1, \ldots, c_{p-1})$ kernel; # kernel of `hom' if not IsSolvableGroup( G ) then Error( " must be solvable" ); fi; # Step 0: # Treat the case of the trivial group, # and initialize some variables. pcgs:= SpecialPcgs( G ); #T because I need a ``prime orders pcgs'' lg:= Length( pcgs ); if lg = 0 then return rec( pcgs := pcgs, kernel := G, exponent := 1, nonlin := [], lin := [ [] ] ); fi; cs:= PcSeries( pcgs ); if HasExponent( G ) then e:= Exponent( G ); else e:= Size(G); #T better adjust on the fly fi; # Step 1: # If necessary then adjust the composition series of $G$ # and get the largest factor group of $G$ that has an abelian normal # subgroup such that the factor group modulo this subgroup is # supersolvable. abel:= 1; while IsNormal( G, cs[ abel ] ) and not IsAbelian( cs[ abel ] ) do abel:= abel + 1; od; # If `cs[ abel ]' is abelian then we compute its representations first, # and then loop over the initial part of the composition series; # note that the factor group is supersolvable. # If `cs[ abel ]' is not abelian then we try to switch to a better # composition series, namely one through the derived subgroup of the # supersolvable residuum. if not IsNormal( G, cs[ abel ] ) then # We have reached a non-normal nonabelian composition subgroup # so we have to adjust the composition series. Info( InfoGroup, 2, "BaumClausenInfo: switching to a suitable comp. ser." ); ssr:= SupersolvableResiduumDefault( G ); hom:= NaturalHomomorphismByNormalSubgroupNC( G, DerivedSubgroup( ssr.ssr ) ); # `SupersolvableResiduumDefault' contains a component `ds', # a list of subgroups such that any composition series through # `ds' from `G' down to the residuum is a chief series. pcgs:= []; for i in [ 2 .. Length( ssr.ds ) ] do j:= NaturalHomomorphismByNormalSubgroupNC( ssr.ds[ i-1 ], ssr.ds[i] ); Append( pcgs, List( SpecialPcgs( ImagesSource( j ) ), x -> PreImagesRepresentative( j, x ) ) ); od; Append( pcgs, SpecialPcgs( ssr.ds[ Length( ssr.ds ) ]) ); G:= ImagesSource( hom ); pcgs:= List( pcgs, x -> ImagesRepresentative( hom, x ) ); pcgs:= Filtered( pcgs, x -> Order( x ) <> 1 ); pcgs:= PcgsByPcSequence( ElementsFamily( FamilyObj( G ) ), pcgs ); cs:= PcSeries( pcgs ); lg:= Length( pcgs ); # The image of `ssr' under `hom' is abelian, # compute its position in the composition series. abel:= Position( cs, ImagesSet( hom, ssr.ssr ) ); # If `G' is supersolvable then `abel = lg+1', # but the last *nontrivial* member of the chain is normal and abelian, # so we choose this group. # (Otherwise we would have the technical problem in step 4 that the # matrix `M' would be empty.) if lg < abel then abel:= lg; fi; fi; # Step 2: # Compute the representations of `cs[ abel ]', # each a list of images of $g_{abel}, \ldots, g_{lg}$. # The local function `ExtLinRep' computes the extensions of the # linear $G_{i+1}$-representations $F$ in the list `linear' to $G_i$. # The only condition that must be satisfied is that # $F(g_i)^p = F(g_i^p)$. # (Roughly speaking, we just compute $p$-th roots.) ExtLinRep:= function( i, linear, pexp, roots ) local nextlinear, rep, j, shift; nextlinear:= []; if IsZero( pexp ) then # $g_i^p$ is the identity for rep in linear do for j in roots do Add( nextlinear, Concatenation( [ j ], rep ) ); od; od; else pexp:= pexp{ [ i+1 .. lg ] }; #T cut this outside the function! for rep in linear do # Compute the value of `rep' on $g_i^p$. shift:= pexp * rep; if shift mod p <> 0 then # We must enlarge the exponent. Error("wrong exponent"); #T if not integral then enlarge the exponent! #T (is this possible here at all?) fi; shift:= shift / p; for j in roots do Add( nextlinear, Concatenation( [ (j+shift) mod e ], rep ) ); od; od; fi; return nextlinear; end; indices:= RelativeOrders( pcgs ); #T here set the exponent `e' to `indices[ lg ]' ! Info( InfoGroup, 2, "BaumClausenInfo: There are ", lg, " steps" ); linear:= List( [ 0 .. indices[lg]-1 ] * ( e / indices[lg] ), x -> [ x ] ); for i in [ lg-1, lg-2 .. abel ] do Info( InfoGroup, 2, "BaumClausenInfo: Compute repres. of step ", i, " (central case)" ); p:= indices[i]; # `pexp' describes $g_i^p$. pexp:= ExponentsOfRelativePower( pcgs,i); # { ? } ?? root:= e/p; #T enlarge the exponent if necessary! roots:= [ 0, root .. (p-1)*root ]; linear:= ExtLinRep( i, linear, pexp, roots ); od; # We are done if $G$ is abelian. if abel = 1 then return rec( pcgs := pcgs, kernel := TrivialSubgroup( G ), exponent := e, nonlin := [], lin := linear ); fi; # Step 3: # Define some local functions. # (We did not need them for abelian groups.) # `mulmoma' returns the product of two monomial matrices. mulmoma:= function( a, b ) local prod, i; prod:= rec( perm := b.perm{ a.perm }, diag := [] ); for i in [ 1 .. Length( a.perm ) ] do prod.diag[ b.perm[i] ]:= ( b.diag[ b.perm[i] ] + a.diag[i] ) mod e; od; return prod; end; # `poweval' evaluates the representation `rep' on the $p$-th power of # the conjugating element. # This $p$-th power is described by `poli'. poweval:= function( rep, poli ) local pow, i; if IsEmpty( poli ) then return rec( perm:= [ 1 .. Length( rep[1].perm ) ], diag:= [ 1 .. Length( rep[1].perm ) ] * 0 ); fi; pow:= rep[ poli[1] ]; for i in [ 2 .. Length( poli ) ] do pow:= mulmoma( pow, rep[ poli[i] ] ); od; return pow; end; # Step 4: # Compute the actions of $g_j$, $j < abel$, on the representations # of $G_{abel}$. # Let $g_i^{g_j} = \prod_{k=1}^n g_k^{\alpha_{ik}^j}$, # and set $A_j = [ \alpha_{ik}^j} ]_{i,k}$. # Then the representation that maps $g_i$ to the root $\zeta_e^{c_i}$ # is mapped to the representation that has images exponents # $A_j * (c_1, \ldots, c_n)$ under $g_j$. Info( InfoGroup, 2, "BaumClausenInfo: Initialize actions on abelian normal subgroup" ); pilinear:= []; for j in [ 1 .. abel-1 ] do # Compute the matrix $A_j$. M:= List( [ abel .. lg ], i -> ExponentsOfPcElement( pcgs, pcgs[i]^pcgs[j], [ abel .. lg ] ) ); # Compute the permutation corresponding to the action of $g_j$. pilinear[j]:= List( linear, rep -> Position( linear, List( M * rep, x -> x mod e ) ) ); od; # Step 5: # Run up the composition series from `abel' to `1', # and compute extensions resp. induced representations. # For each index, we have to update `linear', `pilinear', # `nonlin', `pinonlin', and `Xlist'. nonlin := []; pinonlin := []; Xlist := []; for i in [ abel-1, abel-2 .. 1 ] do p:= indices[i]; # `poli' describes $g_i^p$. #was pexp:= ExponentsOfPcElement( pcgs, pcgs[i]^p ); pexp:= ExponentsOfRelativePower( pcgs, i ); poli:= Concatenation( List( [ i+1 .. lg ], x -> List( [ 1 .. pexp[x] ], y -> x-i ) ) ); # `p'-th roots of unity roots:= [ 0 .. p-1 ] * ( e/p ); Info( InfoGroup, 2, "BaumClausenInfo: Compute repres. of step ", i ); # Step A: # Compute representations of $G_i$ arising from *linear* # representations of $G_{i+1}$. used := BlistList( [ 1 .. Length( linear ) ], [] ); nextlinear := []; nextnonlin1 := []; d := 1; pexp:= pexp{ [ i+1 .. lg ] }; # At position `d', store the position of either the first extension # of `linear[d]' in `nextlinear' or the position of the induced # representation of `linear[d]' in `nextnonlin1'. Dpos1:= []; while d <> fail do rep:= linear[d]; used[d]:= true; # `root' is the value of `rep' on $g_i^p$. root:= ( pexp * rep ) mod e; if pilinear[i][d] = d then # `linear[d]' extends to $G_i$. Dpos1[d]:= Length( nextlinear ) + 1; # Take a `p'-th root. root:= root / p; #T enlarge the exponent if necessary! for j in roots do Add( nextlinear, Concatenation( [ root+j ], rep ) ); od; else # We must fuse the representations in the orbit of `d' # under `pilinear[i]'; # so we construct the induced representation `D'. Dpos1[d]:= Length( nextnonlin1 ) + 1; D:= List( rep, x -> rec( perm := [ 1 .. p ], diag := [ x ] ) ); pos:= d; for j in [ 2 .. p ] do pos:= pilinear[i][ pos ]; for k in [ 1 .. Length( rep ) ] do D[k].diag[j]:= linear[ pos ][k]; od; used[ pos ]:= true; Dpos1[ pos ]:= Length( nextnonlin1 ) + 1; od; Add( nextnonlin1, Concatenation( [ rec( perm := Concatenation( [p], [1..p-1]), diag := Concatenation( [ 1 .. p-1 ] * 0, [ root ] ) ) ], D ) ); Assert( 2, BaumClausenInfoDebug.testrep( pcgs{ [ i .. lg ] }, nextnonlin1[ Length( nextnonlin1 ) ], e ), Concatenation( "BaumClausenInfo: failed assertion in ", "inducing linear representations ", "(i = ", String( i ), ")\n" ) ); fi; d:= Position( used, false, d ); od; # Step B: # Now compute representations of $G_i$ arising from *nonlinear* # representations of $G_{i+1}$ (if there are some). used:= BlistList( [ 1 .. Length( nonlin ) ], [] ); nextnonlin2:= []; if Length( nonlin ) = 0 then d:= fail; else d:= 1; fi; # At position `d', store the position of the first extension resp. # of the induced representation of `nonlin[d]'in `nextnonlin2'. Dpos2:= []; while d <> fail do used[d]:= true; rep:= nonlin[d]; if pinonlin[i][d] = d then # The representation $F = `rep'$ has `p' different extensions. # For `X = Xlist[i][d]', we have $`rep ^ X' = `rep'^{g_i}$, # i.e., $X^{-1} F X = F^{g_i}$. # Representing matrix $F(g_i)$ is $c X$ with $c^p X^p = F(g_i^p)$, # so $c^p X^p.diag[k] = F(g_i^p).diag[k]$ for all $k$ ; # for determination of $c$ we look at `k = X^p.perm[1]'. X:= Xlist[i][d]; image:= X.perm[1]; value:= X.diag[ image ]; for j in [ 2 .. p ] do image:= X.perm[ image ]; value:= X.diag[ image ] + value; # now `image = X^j.perm[1]', `value = X^j.diag[ image ]' od; # Subtract this from $F(g_i^p).diag[k]$; # note that `image' is the image of 1 under `X^p', so also # under $F(g_i^p)$. value:= - value; image:= 1; for j in poli do image:= rep[j].perm[ image ]; value:= rep[j].diag[ image ] + value; od; value:= ( value / p ) mod e; #T enlarge the exponent if necessary! Dpos2[d]:= Length( nextnonlin2 ) + 1; # Compute the `p' extensions. for k in roots do Add( nextnonlin2, Concatenation( [ rec( perm := X.perm, diag := List( X.diag, x -> ( x + k + value ) mod e ) ) ], rep ) ); Assert( 2, BaumClausenInfoDebug.testrep( pcgs{ [ i .. lg ] }, nextnonlin2[ Length( nextnonlin2 ) ], e ), Concatenation( "BaumClausenInfo: failed assertion in ", "extending nonlinear representations ", "(i = ", String( i ), ")\n" ) ); od; else # `$F$ = nonlin[d]' fuses with `p-1' partners given by the orbit # of `d' under `pinonlin[i]'. # The new irreducible representation of $G_i$ will be # $X Ind( F ) X^{-1}$ with $X$ the block diagonal matrix # consisting of blocks $X_{i,F}^{(k)}$ defined by # $X_{i,F}^{(0)} = Id$, # and $X_{i,F}^{(k)} = X_{i,\pi_i^{k-1} F} X_{i,F}^{(k-1)}$ # for $k > 0$. # The matrix for $g_i$ in the induced representation $Ind( F )$ is # of the form # | 0 F(g_i^p) | # | I 0 | # Thus $X Ind(F) X^{-1} ( g_i )$ is the block diagonal matrix # consisting of the blocks # $X_{i,F}, X_{i,\pi_i F}, \ldots, X_{i,\pi_i^{p-2} F}$, and # $F(g_i^p) \cdot ( X_{i,F}^{(p-1)} )^{-1}$. dim:= Length( rep[1].diag ); Dpos2[d]:= Length( nextnonlin2 ) + 1; # We make a copy of `rep' because we want to change it. D:= List( rep, record -> rec( perm := ShallowCopy( record.perm ), diag := ShallowCopy( record.diag ) ) ); # matrices for $g_j, i\< j \leq n$ pos:= d; for j in [ 1 .. p-1 ] * dim do pos:= pinonlin[i][ pos ]; for k in [ 1 .. Length( rep ) ] do Append( D[k].diag, nonlin[ pos ][k].diag ); Append( D[k].perm, nonlin[ pos ][k].perm + j ); od; used[ pos ]:= true; Dpos2[ pos ]:= Length( nextnonlin2 ) + 1; od; # The matrix of $g_i$ is a block-cycle with blocks # $X_{i,\pi_i^k(F)}$ for $0 \leq k \leq p-2$, # and $F(g_i^p) \cdot (X_{i,F}^{(p-1)})^{-1}$. X:= Xlist[i][d]; # $X_{i,F}$ pos:= d; for j in [ 1 .. p-2 ] do pos:= pinonlin[i][ pos ]; X:= mulmoma( Xlist[i][ pos ], X ); od; # `invX' is the inverse of `X'. invX:= rec( perm := [], diag := [] ); for j in [ 1 .. Length( X.diag ) ] do invX.perm[ X.perm[j] ]:= j; invX.diag[j]:= e - X.diag[ X.perm[j] ]; od; #T improve this using the {} operator! X:= mulmoma( poweval( rep, poli ), invX ); D_gi:= rec( perm:= List( X.perm, x -> x + ( p-1 ) * dim ), diag:= [] ); pos:= d; for j in [ 0 .. p-2 ] * dim do # $X_{i,\pi_i^j F}$ Append( D_gi.diag, Xlist[i][ pos ].diag); Append( D_gi.perm, Xlist[i][ pos ].perm + j); pos:= pinonlin[i][ pos ]; od; Append( D_gi.diag, X.diag ); Add( nextnonlin2, Concatenation( [ D_gi ], D ) ); Assert( 2, BaumClausenInfoDebug.testrep( pcgs{ [ i .. lg ] }, nextnonlin2[ Length( nextnonlin2 ) ], e ), Concatenation( "BaumClausenInfo: failed assertion in ", "inducing nonlinear representations ", "(i = ", String( i ), ")\n" ) ); fi; d:= Position( used, false, d ); od; # Step C: # Compute `pilinear', `pinonlin', and `Xlist'. pinextlinear := []; pinextnonlin1 := []; nextXlist1 := []; pinextnonlin2 := []; nextXlist2 := []; for j in [ 1 .. i-1 ] do pinextlinear[j] := []; pinextnonlin1[j] := []; nextXlist1[j] := []; # `cexp' describes $g_i^{g_j}$. cexp:= ExponentsOfPcElement( pcgs, pcgs[i]^pcgs[j], [ i .. lg ] ); # Compute `pilinear', and the parts of `pinonlin', `Xlist' # arising from *linear* representations for the next step, # that is, compute the action of $g_j$ on `nextlinear' and # `nextnonlin1'. for k in [ 1 .. Length( linear ) ] do if pilinear[i][k] = k then # Let $F = `linear[k]'$ extend to # $D = D_0, D_1, \ldots, D_{p-1}$, # $C$ the first extension of $\pi_j(F)$. # We have $D( g_i^{g_j} ) = D^{g_j}(g_i) = ( C \chi^l )(g_i)$ # where $\chi^l(g_i)$ is the $l$-th power of the chosen # primitive $p$-th root of unity. D:= nextlinear[ Dpos1[k] ]; # `pos' is the position of $C$ in `nextlinear'. pos:= Dpos1[ pilinear[j][k] ]; l:= ( ( cexp * D # $D( g_i^{g_j} )$ - nextlinear[ pos ][1] ) # $C(g_i)$ * p / e ) mod p; for u in [ 0 .. p-1 ] do Add( pinextlinear[j], pos + ( ( l + u * cexp[1] ) mod p ) ); od; elif not IsBound( pinextnonlin1[j][ Dpos1[k] ] ) then # $F$ fuses with its conjugates under $g_i$, # the conjugating matrix describing the action of $g_j$ # is a permutation matrix. # Let $D = F^{g_j}$, then the permutation corresponds to # the mapping between the lists # $[ D, (F^{g_i})^{g_j}, \ldots, (F^{g_i^{p-1}})^{g_j} ]$ # and $[ D, D^{g_i}, \ldots, D^{g_i^{p-1}} ]$; # The constituents in the first list are the images of # the induced representation of $F$ under $g_j$, # and those in the second list are the constituents of the # induced representation of $D$. # While `u' runs from $1$ to $p$, # `pos' runs over the positions of $(F^{g_i^u})^{g_j}$ in # `linear'. # `orb' is the list of positions of the $(F^{g_j})^{g_i^u}$, # cyclically permuted such that the smallest entry is the # first. pinextnonlin1[j][ Dpos1[k] ]:= Dpos1[ pilinear[j][k] ]; pos:= pilinear[j][k]; orb:= [ pos ]; min:= 1; minval:= pos; for u in [ 2 .. p ] do pos:= pilinear[i][ pos ]; orb[u]:= pos; if pos < minval then minval:= pos; min:= u; fi; od; if 1 < min then orb:= Concatenation( orb{ [ min .. p ] }, orb{ [ 1 .. min-1 ] } ); fi; # Compute the conjugating matrix `X'. # Let $C$ be the stored representation $\tau_j D$ # equivalent to $D^{g_j}$. # Compute the position of $C$ in `pinextnonlin1'. C:= nextnonlin1[ pinextnonlin1[j][ Dpos1[k] ] ]; D:= nextnonlin1[ Dpos1[k] ]; # `sigma' is the bijection of constituents in the restrictions # of $D$ and $\tau_j D$ to $G_{i-1}$. # More precisely, $\pi_j(\pi_i^{u-1} F) = \Phi_{\sigma(u-1)}$. sigma:= []; pos:= k; for u in [ 1 .. p ] do sigma[u]:= Position( orb, pilinear[j][ pos ] ); pos:= pilinear[i][ pos ]; od; # Compute $\pi = \sigma^{-1} (1,2,\ldots,p) \sigma$. pi:= []; pi[ sigma[p] ]:= sigma[1]; for u in [ 1 .. p-1 ] do pi[ sigma[u] ]:= sigma[ u+1 ]; od; # Compute the values $c_{\pi^u(0)}$, for $0 \leq u \leq p-1$. # Note that $c_0 = 1$. # (Here we encode of course the exponents.) constants:= [ 0 ]; l:= 1; for u in [ 1 .. p-1 ] do # Compute $c_{\pi^u(0)}$. # (We have $`l' = 1 + \pi^{u-1}(0)$.) # Note that $B_u = [ [ 1 ] ]$ for $0\leq u\leq p-2$, # and $B_{p-1} = \Phi_0(g_i^p)$. # Next we compute the image under $A_{\pi^{u-1}(0)}$; # this matrix is in the $(\pi^{u-1}(0)+1)$-th column block # and in the $(\pi^u(0)+1)$-th row block of $D^{g_j}$. # Since we do not have this matrix explicitly, # we use the conjugate representation and the action # encoded by `cexp'. # Note the necessary initial shift because we use the # whole representation $D$ and not a single constituent; # so we shift by $\pi^u(0)+1$. #T `perm' is nontrivial only for v = 1, this should make life easier. value:= 0; image:= pi[l]; for v in [ 1 .. lg-i+1 ] do for w in [ 1 .. cexp[v] ] do image:= D[v].perm[ image ]; value:= value + D[v].diag[ image ]; od; od; # Next we divide by the corresponding value in # the image of the first standard basis vector under # $B_{\sigma\pi^{u-1}(0)}$. value:= value - C[1].diag[ sigma[l] ]; constants[ pi[l] ]:= ( constants[l] - value ) mod e; l:= pi[l]; od; # Put the conjugating matrix together. X:= rec( perm := [], diag := constants ); for u in [ 1 .. p ] do X.perm[ sigma[u] ]:= u; od; Assert( 2, BaumClausenInfoDebug.checkconj( pcgs, i, lg, j, nextnonlin1[ Dpos1[k] ], nextnonlin1[ pinextnonlin1[j][ Dpos1[k] ] ], X, e ), Concatenation( "BaumClausenInfo: failed assertion on ", "conjugating matrices for linear repres. ", "(i = ", String( i ), ")\n" ) ); nextXlist1[j][ Dpos1[k] ]:= X; fi; od; # Compute the remaining parts of `pinonlin' and `Xlist' for # the next step, namely for those *nonlinear* representations # arising from *nonlinear* ones. nextXlist2[j] := []; pinextnonlin2[j] := []; # `cexp' describes $g_i^{g_j}$. cexp:= ExponentsOfPcElement( pcgs, pcgs[i]^pcgs[j], [ i .. lg ] ); # Compute the action of $g_j$ on `nextnonlin2'. for k in [ 1 .. Length( nonlin ) ] do if pinonlin[i][k] = k then # Let $F = `nonlin[k]'$ extend to # $D = D_0, D_1, \ldots, D_{p-1}$, # $C$ the first extension of $\pi_j(F)$. # We have $X_{j,F} \cdot F^{g_j} = \pi_j(F) \cdot X_{j,F}$, # thus $X_{j,F} \cdot D( g_i^{g_j} ) # = X_{j,F} \cdot D^{g_j}(g_i) # = ( C \chi^l )(g_i) \cdot X_{j,F}$ # where $\chi^l(g_i)$ is the $l$-th power of the chosen # primitive $p$-th root of unity. D:= nextnonlin2[ Dpos2[k] ]; # `pos' is the position of $C$ in `nextnonlin2'. pos:= Dpos2[ pinonlin[j][k] ]; # Find a nonzero entry in $X_{j,F} \cdot D( g_i^{g_j} )$. image:= Xlist[j][k].perm[1]; value:= Xlist[j][k].diag[ image ]; for u in [ 1 .. lg-i+1 ] do for v in [ 1 .. cexp[u] ] do image:= D[u].perm[ image ]; value:= value + D[u].diag[ image ]; od; od; # Subtract the corresponding value in $C(g_i) \cdot X_{j,F}$. C:= nextnonlin2[ pos ]; Assert( 2, image = Xlist[j][k].perm[ C[1].perm[1] ], "BaumClausenInfo: failed assertion on conj. matrices" ); value:= value - ( C[1].diag[ C[1].perm[1] ] + Xlist[j][k].diag[ image ] ); l:= ( value * p / e ) mod p; for u in [ 0 .. p-1 ] do pinextnonlin2[j][ Dpos2[k] + u ]:= pos + ( ( l + u * cexp[1] ) mod p ); nextXlist2[j][ Dpos2[k] + u ]:= Xlist[j][k]; od; Assert( 2, BaumClausenInfoDebug.checkconj( pcgs, i, lg, j, nextnonlin2[ Dpos2[k] ], nextnonlin2[ pinextnonlin2[j][ Dpos2[k] ] ], Xlist[j][k], e ), Concatenation( "BaumClausenInfo: failed assertion on ", "conjugating matrices for nonlinear repres. ", "(i = ", String( i ), ")\n" ) ); elif not IsBound( pinextnonlin2[j][ Dpos2[k] ] ) then # $F$ fuses with its conjugates under $g_i$, yielding $D$. dim:= Length( nonlin[k][1].diag ); # Let $C$ be the stored representation $\tau_j D$ # equivalent to $D^{g_j}$. # Compute the position of $C$ in `pinextnonlin2'. pinextnonlin2[j][ Dpos2[k] ]:= Dpos2[ pinonlin[j][k] ]; C:= nextnonlin2[ pinextnonlin2[j][ Dpos2[k] ] ]; D:= nextnonlin2[ Dpos2[k] ]; # Compute the positions of the constituents; # `orb[k]' is the position of $\Phi_{k-1}$ in `nonlin'. pos:= pinonlin[j][k]; orb:= [ pos ]; min:= 1; minval:= pos; for u in [ 2 .. p ] do pos:= pinonlin[i][ pos ]; orb[u]:= pos; if pos < minval then minval:= pos; min:= u; fi; od; if 1 < min then orb:= Concatenation( orb{ [ min .. p ] }, orb{ [ 1 .. min-1 ] } ); fi; # `sigma' is the bijection of constituents in the restrictions # of $D$ and $\tau_j D$ to $G_{i-1}$. # More precisely, $\pi_j(\pi_i^{u-1} F) = \Phi_{\sigma(u-1)}$. sigma:= []; pos:= k; for u in [ 1 .. p ] do sigma[u]:= Position( orb, pinonlin[j][ pos ] ); pos:= pinonlin[i][ pos ]; od; # Compute $\pi = \sigma^{-1} (1,2,\ldots,p) \sigma$. pi:= []; pi[ sigma[p] ]:= sigma[1]; for u in [ 1 .. p-1 ] do pi[ sigma[u] ]:= sigma[ u+1 ]; od; # Compute the positions of the constituents # $F_0, F_{\pi(0)}, \ldots, F_{\pi^{p-1}(0)}$. Forb:= [ k ]; pos:= k; for u in [ 2 .. p ] do pos:= pinonlin[i][ pos ]; Forb[u]:= pos; od; # Compute the values $c_{\pi^u(0)}$, for $0 \leq u \leq p-1$. # Note that $c_0 = 1$. # (Here we encode of course the exponents.) constants:= [ 0 ]; l:= 1; for u in [ 1 .. p-1 ] do # Compute $c_{\pi^u(0)}$. # (We have $`l' = 1 + \pi^{u-1}(0)$.) # Note that $B_u = X_{j,\pi_j^u \Phi_0}$ for $0\leq u\leq p-2$, # and $B_{p-1} = # \Phi_0(g_i^p) \cdot ( X_{j,\Phi_0}^{(p-1)} )^{-1}$ # First we get the image and diagonal value of # the first standard basis vector under $X_{j,\pi^u(0)}$. image:= Xlist[j][ Forb[ pi[l] ] ].perm[1]; value:= Xlist[j][ Forb[ pi[l] ] ].diag[ image ]; # Next we compute the image under $A_{\pi^{u-1}(0)}$; # this matrix is in the $(\pi^{u-1}(0)+1)$-th column block # and in the $(\pi^u(0)+1)$-th row block of $D^{g_j}$. # Since we do not have this matrix explicitly, # we use the conjugate representation and the action # encoded by `cexp'. # Note the necessary initial shift because we use the # whole representation $D$ and not a single constituent; # so we shift by `dim' times $\pi^u(0)+1$. image:= dim * ( pi[l] - 1 ) + image; for v in [ 1 .. lg-i+1 ] do for w in [ 1 .. cexp[v] ] do image:= D[v].perm[ image ]; value:= value + D[v].diag[ image ]; od; od; # Next we divide by the corresponding value in # the image of the first standard basis vector under # $B_{\sigma\pi^{u-1}(0)} X_{j,\pi^{u-1}(0)}$. # Note that $B_v$ is in the $(v+2)$-th row block for # $0 \leq v \leq p-2$, in the first row block for $v = p-1$, # and in the $(v+1)$-th column block of $C$. v:= sigma[l]; if v = p then image:= C[1].perm[1]; else image:= C[1].perm[ v*dim + 1 ]; fi; value:= value - C[1].diag[ image ]; image:= Xlist[j][ Forb[l] ].perm[ image - ( v - 1 ) * dim ]; value:= value - Xlist[j][ Forb[l] ].diag[ image ]; constants[ pi[l] ]:= ( constants[l] - value ) mod e; l:= pi[l]; od; # Put the conjugating matrix together. X:= rec( perm:= [], diag:= [] ); pos:= k; for u in [ 1 .. p ] do Append( X.diag, List( Xlist[j][ pos ].diag, x -> ( x + constants[u] ) mod e ) ); X.perm{ [ ( sigma[u] - 1 )*dim+1 .. sigma[u]*dim ] }:= Xlist[j][ pos ].perm + (u-1) * dim; pos:= pinonlin[i][ pos ]; od; Assert( 2, BaumClausenInfoDebug.checkconj( pcgs, i, lg, j, nextnonlin2[ Dpos2[k] ], nextnonlin2[ pinextnonlin2[j][ Dpos2[k] ] ], X, e ), Concatenation( "BaumClausenInfo: failed assertion on ", "conjugating matrices for nonlinear repres. ", "(i = ", String( i ), ")\n" ) ); nextXlist2[j][ Dpos2[k] ]:= X; fi; od; od; # Finish the update for the next index. linear := nextlinear; pilinear := pinextlinear; nonlin := Concatenation( nextnonlin1, nextnonlin2 ); pinonlin := List( [ 1 .. i-1 ], j -> Concatenation( pinextnonlin1[j], pinextnonlin2[j] + Length( pinextnonlin1[j] ) ) ); Xlist := List( [ 1 .. i-1 ], j -> Concatenation( nextXlist1[j], nextXlist2[j] ) ); od; # Step 6: If necessary transfer the representations back to the # original group. if IsBound( hom ) and not IsTrivial( KernelOfMultiplicativeGeneralMapping( hom ) ) then Info( InfoGroup, 2, "BaumClausenInfo: taking preimages in the original group" ); kernel:= KernelOfMultiplicativeGeneralMapping( hom ); k:= Pcgs( kernel ); pcgs:= PcgsByPcSequence( ElementsFamily( FamilyObj( kernel ) ), Concatenation( List( pcgs, x -> PreImagesRepresentative( hom, x ) ), k ) ); k:= ListWithIdenticalEntries( Length( k ), 0 ); linear:= List( linear, rep -> Concatenation( rep, k ) ); for rep in nonlin do dim:= Length( rep[1].perm ); M:= rec( perm:= [ 1 .. dim ], diag:= [ 1 .. dim ] * 0 ); for i in k do Add( rep, M ); od; od; else kernel:= TrivialSubgroup( G ); fi; # Return the result (for nonabelian groups). return Immutable( rec( pcgs := pcgs, kernel := kernel, exponent := e, nonlin := nonlin, lin := linear ) ); end ); ############################################################################# ## #F IrreducibleRepresentationsByBaumClausen( ) . for a supersolv. group ## BindGlobal( "IrreducibleRepresentationsByBaumClausen", function( G ) local mrep, # list of images lists for the result info, # result of `BaumClausenInfo' lg, # composition length of `G' rep, # loop over the representations gcd, # g.c.d. of the exponents in `rep' Ee, # complex root of unity needed for `rep' images, # one list of images dim, # current dimension i, k, # loop variabes mat; # one representing matrix mrep:= []; info:= BaumClausenInfo( G ); lg:= Length( info.pcgs ); if info.lin=[[]] then # trivial group return [GroupHomomorphismByImagesNC(G,Group([[1]]),[],[])]; fi; # Compute the images of linear representations on the pcgs. for rep in info.lin do gcd := Gcd( rep ); if gcd = 0 then Add( mrep, List( rep, x -> [ [ 1 ] ] ) ); else gcd:= GcdInt( gcd, info.exponent ); Ee:= E( info.exponent / gcd ); Add( mrep, List( rep / gcd, x -> [ [ Ee^x ] ] ) ); fi; od; # Compute the images of nonlinear representations on the pcgs. for rep in info.nonlin do images:= []; dim:= Length( rep[1].perm ); gcd:= GcdInt( Gcd( List( rep, x -> Gcd( x.diag ) ) ), info.exponent ); Ee:= E( info.exponent / gcd ); for i in [ 1 .. lg ] do mat:= NullMat( dim, dim, Rationals ); for k in [ 1 .. dim ] do mat[k][ rep[i].perm[k] ]:= Ee^( rep[i].diag[ rep[i].perm[k] ] / gcd ); od; images[i]:= mat; od; Add( mrep, images ); od; return List( mrep, images -> GroupHomomorphismByImagesNC( G, GroupByGenerators( images ), info.pcgs, images ) ); end ); ############################################################################# ## #M IrreducibleRepresentations( ) . for an abelian by supersolvable group ## InstallMethod( IrreducibleRepresentations, "(abelian by supersolvable) finite group", [ IsGroup and IsFinite ], 1, # higher than Dixon's method function( G ) if IsAbelian( SupersolvableResiduum( G ) ) then return IrreducibleRepresentationsByBaumClausen( G ); else TryNextMethod(); fi; end ); ############################################################################# ## #M IrreducibleRepresentations( , ) . . for a group and `Cyclotomics' ## InstallMethod( IrreducibleRepresentations, "finite group, Cyclotomics", [ IsGroup and IsFinite, IsCyclotomicCollection and IsField ], function( G, F ) if F <> Cyclotomics then TryNextMethod(); else return IrreducibleRepresentations( G ); fi; end ); ############################################################################# ## #M IrreducibleRepresentations( , ) ## InstallMethod( IrreducibleRepresentations, "for a finite group over a finite field", [ IsGroup and IsFinite, IsField and IsFinite ], function( G, f ) local md, hs, gens, M, mats, H, hom; md := IrreducibleModules( G, f, 0 ); gens:=md[1]; md:=md[2]; hs := []; for M in md do mats := M.generators; H := Group( mats, IdentityMat( M.dimension, f ) ); hom := GroupHomomorphismByImagesNC( G, H, gens, mats ); Add( hs, hom ); od; return hs; end ); ############################################################################# ## #M IrrBaumClausen( ) . . . . irred. characters of a supersolvable group ## InstallMethod( IrrBaumClausen, "for a (solvable) group", [ IsGroup ], function( G ) local mulmoma, # local function to multiply monomial matrices ccl, # conjugacy classes of `G' tbl, # character table of `G' info, # result of `BaumClausenInfo' pcgs, # value of `info.pcgs' lg, # composition length evl, # list encoding exponents of class representatives i, j, k, # loop variables exps, # exponent vector of a group element t, # intermediate representation value irreducibles, # list of irreducible characters rep, # loop over the representations gcd, # g.c.d. of the exponents in `rep' q, # Ee, # complex root of unity needed for `rep' chi, # one character values list deg, # character degree idmat, # identity matrix trace; # trace of a matrix mulmoma:= function( a, b ) local prod, i; prod:= rec( perm := b.perm{ a.perm }, diag := [] ); for i in [ 1 .. deg ] do prod.diag[ b.perm[i] ]:= b.diag[ b.perm[i] ] + a.diag[i]; od; return prod; end; tbl:= CharacterTable( G ); ccl:= ConjugacyClasses( tbl ); SetExponent( G, Exponent( tbl ) ); info:= BaumClausenInfo( G ); # The trivial group does not admit matrix arithmetic for evaluations. if IsTrivial( G ) then return [ Character( G, [ 1 ] ) ]; fi; pcgs:= info.pcgs; lg:= Length( pcgs ); exps:= List( ccl, c -> ExponentsOfPcElement( pcgs, Representative( c ) ) ); # Compute the linear irreducibles. # Compute the roots of unity only once for all linear characters. # ($q$-th roots suffice, where $q$ divides the number of linear # characters and the known exponent; we do *not* compute the smallest # possible roots for each representation.) q:= Gcd( info.exponent, Length( info.lin ) ); gcd:= info.exponent / q; Ee:= E(q); Ee:= List( [ 0 .. q-1 ], i -> Ee^i ); irreducibles:= List( info.lin, rep -> Character( tbl, Ee{ ( ( exps * rep ) / gcd mod q ) + 1 } ) ); # Compute the nonlinear irreducibles. if not IsEmpty( info.nonlin ) then evl:= []; for i in [ 2 .. Length( ccl ) ] do t:= []; for j in [ 1 .. lg ] do for k in [ 1 .. exps[i][j] ] do Add( t, j ); od; od; evl[ i-1 ]:= t; od; for rep in info.nonlin do gcd:= GcdInt( Gcd( List( rep, x -> Gcd( x.diag ) ) ), info.exponent ); Ee:= E( info.exponent / gcd ); deg:= Length( rep[1].perm ); chi:= [ deg ]; idmat:= rec( perm := [ 1 .. deg ], diag := [ 1 .. deg ] * 0 ); for j in evl do # Compute the value of the representation at the representative. t:= idmat; for k in j do t:= mulmoma( t, rep[k] ); od; # Compute the character value. trace:= 0; for k in [ 1 .. deg ] do if t.perm[k] = k then trace:= trace + Ee^( t.diag[k] / gcd ); fi; od; Add( chi, trace ); od; Add( irreducibles, Character( tbl, chi ) ); od; fi; # Return the result. return irreducibles; end ); ############################################################################# ## #F InducedRepresentationImagesRepresentative( , , , ) ## ## Let $_H$ denote the restriction of the group homomorphism to ## the group , and $\phi$ the induced representation of $_H$ to $G$, ## where is a transversal of in $G$. ## `InducedRepresentationImagesRepresentative' returns the image of the ## element of $G$ under $\phi$. ## InstallGlobalFunction( InducedRepresentationImagesRepresentative, function( rep, H, R, g ) local len, blocks, i, k, kinv, j; len:= Length( R ); blocks:= []; for i in [ 1 .. len ] do k:= R[i] * g; kinv:= Inverse( k ); j:= PositionProperty( R, r -> r * kinv in H ); blocks[i]:= [ i, j, ImagesRepresentative( rep, k / R[j] ) ]; od; return BlockMatrix( blocks, len, len ); end ); ############################################################################# ## #F InducedRepresentation( , ) . . . . induced matrix representation #F InducedRepresentation( , , ) #F InducedRepresentation( , , , ) ## ## Let be a matrix representation of the group $H$, which is a ## subgroup of the group . ## `InducedRepresentation' returns the induced matrix representation of . ## ## The optional third argument is a right transversal of $H$ in . ## If the fourth optional argument is given then it must be a subgroup ## of the source of , and the induced representation of the restriction ## of to is computed. ## InstallGlobalFunction( InducedRepresentation, function( arg ) local rep, G, H, R, gens, images, map; # Get and check the arguments. if Length( arg ) = 2 and IsGroupHomomorphism( arg[1] ) and IsGroup( arg[2] ) then rep := arg[1]; G := arg[2]; H := Source( rep ); R := RightTransversal( G, H ); elif Length( arg ) = 3 and IsGroupHomomorphism( arg[1] ) and IsGroup( arg[2] ) and IsHomogeneousList( arg[3] ) then rep := arg[1]; G := arg[2]; R := arg[3]; H := Source( rep ); elif Length( arg ) = 4 and IsGroupHomomorphism( arg[1] ) and IsGroup( arg[2] ) and IsHomogeneousList( arg[3] ) and IsGroup( arg[4] ) then rep := arg[1]; G := arg[2]; R := arg[3]; H := arg[4]; else Error( "usage: InducedRepresentation(,[,[,]])" ); fi; # Handle a trivial case. if Length( R ) = 1 then return rep; fi; # Construct the images of the generators of . gens:= GeneratorsOfGroup( G ); images:= List( gens, g -> InducedRepresentationImagesRepresentative( rep, H, R, g ) ); # Construct and return the homomorphism. map:= GroupHomomorphismByImagesNC( G, GroupByGenerators( images ), gens, images ); SetIsSurjective( map, true ); return map; end ); ############################################################################# ## #M ^ ## InstallOtherMethod( \^, "for group homomorphism and group (induction)", [ IsGroupHomomorphism, IsGroup ], function( rep, G ) if IsMatrixGroup( Range( rep ) ) and IsSubset( Source( rep ), G ) then return InducedRepresentation( rep, G ); else TryNextMethod(); fi; end ); ############################################################################# ## #E gap-4r6p5/lib/smgideal.gd0000644000175000017500000000461112172557254014014 0ustar billbill############################################################################# ## #W smgideal.gd GAP library Robert Arthur ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains declarations relating to semigroup ideals. ## ############################################################################# ## #O SemigroupIdealByGenerators(, ) ## ## <#GAPDoc Label="SemigroupIdealByGenerators"> ## ## ## ## ## S is a semigroup, gens is a list of elements of S. ## Returns the two-sided ideal of S generated by gens. ## ## ## <#/GAPDoc> ## DeclareSynonym("SemigroupIdealByGenerators", MagmaIdealByGenerators ); ############################################################################# ## #P IsLeftSemigroupIdeal() #P IsRightSemigroupIdeal() #P IsSemigroupIdeal() ## ## <#GAPDoc Label="IsLeftSemigroupIdeal"> ## ## ## ## ## ## ## Categories of semigroup ideals. ## ## ## <#/GAPDoc> ## DeclareProperty("IsLeftSemigroupIdeal", IsLeftMagmaIdeal ); DeclareProperty("IsRightSemigroupIdeal", IsRightMagmaIdeal ); DeclareProperty("IsSemigroupIdeal", IsMagmaIdeal ); ############################################################################# ## #A ReesCongruenceOfSemigroupIdeal( ) ## ## <#GAPDoc Label="ReesCongruenceOfSemigroupIdeal"> ## ## ## ## ## A two sided ideal I of a semigroup S defines a congruence on ## S given by \Delta \cup I \times I. ## ## ## <#/GAPDoc> ## DeclareAttribute("ReesCongruenceOfSemigroupIdeal", IsMagmaIdeal); DeclareGlobalFunction( "EnumeratorOfSemigroupIdeal" ); DeclareGlobalFunction( "IsBound_LeftSemigroupIdealEnumerator" ); DeclareGlobalFunction( "IsBound_RightSemigroupIdealEnumerator" ); ############################################################################# ## #E gap-4r6p5/lib/compiler.g0000644000175000017500000002342112172557252013673 0ustar billbill############################################################################# ## #W compiler.g GAP library Frank Celler ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the frontend function for the compiler. ## ############################################################################# ## #F RatPairString( ) . . . . . . . . . . . . . string -> 2 rationals ## RatPairString := function( string ) local p, x, y; # find "," p := Position( string, ',' ); if p = false then x := Rat(string); y := x; elif p = 1 then x := 1; y := Rat(string{[2..Length(string)]}); elif p = Length(string) then x := Rat(string{[1..p-1]}); y := 1; else x := Rat(string{[1..p-1]}); y := Rat(string{[p+1..Length(string)]}); fi; if x = 0 then x := 1; fi; if y = 0 then y := 1; fi; return [ x, y ]; end; ############################################################################# ## #F ParseArguments( , , ) . . . . parse sequence of options ## ## is a argument list and the position to start at. ## describes the arguments, it is a record, whose record names correspond to ## paramters, the values describe the possible paramters: ## ## "switch" toggle the switch or set to the optional paramter ## "switch/true" default is `true' ## "switch/false" default is `false' ## ## "string" set to the mandatory paramter ## "string/default" default value ## ## "integer" set to the mandatory paramter ## "integer/default" default value ## ## "geometry" set to the two mandatory paramter width/height ## "geometry/wxh" default value ## ## "alias/name" define an alias ## ## Example: ## ## gap> a; ## rec( ## name := "string/test", ## nice := "switch/false", ## depth := "integer/10", ## ndepth := "integer" ) ## gap> ParseArguments( a, [], 1 ); ## rec( ## name := "test", ## nice := false, ## depth := 10 ) ## gap> ParseArguments( a, ["ndepth",20], 1 ); ## rec( ## name := "test", ## nice := false, ## depth := 10, ## ndepth := 20 ) ## ParseArguments := function( def, args, pos ) local IsMatch, SplitString, keys, type, val, key, tmp, defaultGeometry, next, match; # match a substring IsMatch := function( a, b ) local c; a := LowercaseString(a); b := LowercaseString(b); c := [ 1 .. Minimum( Length(a), Length(b) ) ]; return a{c} = b{c}; end; # substring after SplitString := function( str, sep ) local p; p := Position( str, sep ); if p = fail then return [ str, "" ]; else return [ str{[1..p-1]}, str{[p+1..Length(str)]} ]; fi; end; # parse the default description keys := RecNames(def); type := rec(); val := rec(); for key in keys do # a switch if IsMatch( "switch", def.(key) ) then type.(key) := "switch"; val.(key) := not IsMatch("false",SplitString(def.(key),'/')[2]); # a string elif IsMatch( "string", def.(key) ) then type.(key) := "string"; val.(key) := SplitString( def.(key), '/' )[2]; # a geometry elif IsMatch( "geometry", def.(key) ) then type.(key) := "geometry"; tmp := SplitString( SplitString( def.(key), '/' )[2], 'x' ); val.(key) := List( tmp, Int ); if not IsBound(defaultGeometry) then defaultGeometry := key; fi; # an integer elif IsMatch( "integer", def.(key) ) then type.(key) := "integer"; tmp := SplitString( def.(key), '/' )[2]; if 0 < Length(tmp) then tmp := Int(tmp); else tmp := fail; fi; if tmp <> fail then val.(key) := tmp; fi; # an alias elif IsMatch( "alias", def.(key) ) then type.(key) := "alias"; val.(key) := SplitString( def.(key), '/' )[2]; # unknown type else Error( "type '", def.(key), "' is unknown" ); fi; od; # parse the arguments starting at position while pos <= Length(args) do next := args[pos]; # an integer could be a geometry parameter if IsInt(next) and pos < Length(args) and IsInt(args[pos+1]) then if IsBound(defaultGeometry) then if next <= 0 then Error( "width must be non-negative, not ", next ); fi; if args[pos+1] <= 0 then Error("height must be non-negative, not ", args[pos+1]); fi; val.(defaultGeometry) := [ next, args[pos+1] ]; pos := pos+2; else Error( "'geometry' may not be specified" ); fi; # just one integer elif IsInt(next) then tmp := Concatenation( "unknown parameter '", String(next), "', known parameters are: " ); for key in [ 1 .. Length(keys) ] do if 1 < key then Append( tmp, ", " ); fi; Append( tmp, keys[key] ); od; Error( tmp ); # check the other keys else match := false; for key in keys do if not match and IsMatch( key, next ) then match := true; # check for an alias if type.(key) = "alias" then key := val.(key); fi; # a switch takes an optional boolean argument if type.(key) = "switch" then if pos < Length(args) and IsBool(args[pos+1]) then val.(key) := args[pos+1]; pos := pos+2; else val.(key) := not val.(key); pos := pos+1; fi; # a string elif type.(key) = "string" then if pos=Length(args) or not IsString(args[pos+1]) then Error( key, " requires a string argument" ); fi; val.(key) := args[pos+1]; pos := pos+2; # an integer elif type.(key) = "integer" then if pos=Length(args) or not IsInt(args[pos+1]) then Error( key, " requires an integer argument" ); fi; val.(key) := args[pos+1]; pos := pos+2; # a geometry elif type.(key) = "geometry" then if pos+1 = Length(args) then Error( key, " requires a width and height" ); fi; if not IsInt(args[pos+1]) or args[pos+1] <= 0 then Error( "width must be non-negative, not ", args[pos+1] ); fi; if not IsInt(args[pos+2]) or args[pos+2] <= 0 then Error( "height must be non-negative, not ", args[pos+2] ); fi; val.(key) := [ args[pos+1], args[pos+2] ]; pos := pos+3; fi; fi; od; # we didn't found a match if not match then tmp := Concatenation( "unknown parameter '", next, "', known parameters are: " ); for key in [ 1 .. Length(keys) ] do if 1 < key then Append( tmp, ", " ); fi; Append( tmp, keys[key] ); od; Error( tmp ); fi; fi; od; # that's it, remove alias entries for key in keys do if type.(key) = "alias" then Unbind(val.(key)); fi; od; return val; end; ############################################################################# ## #F CompileFunc( , , , ... ) ## ## must be a filename, ## the function to compile, ## the name used in the compiled module ## ## optional parameters are: ## "Magic1" ## "Magic2" ## "FastIntArith" ## "FastPlainLists" ## "CheckTypes" ## "CheckListElements" ## "CheckPosObjElements" ## CompileFunc := function( arg ) local output, func, name, arguments; output := arg[1]; func := arg[2]; name := arg[3]; arguments := rec( magic1 := "integer/0", magic2 := "string", fastintarith := "switch/true", fastplainlists := "switch/true", checktypes := "switch/true", checklistelements := "switch/true", checkposobjelements := "switch/true" ); arguments := ParseArguments( arguments, arg, 4 ); return COMPILE_FUNC( output, func, name, arguments.magic1, arguments.magic2, arguments.fastintarith, arguments.fastplainlists, arguments.checktypes, arguments.checklistelements, arguments.checkposobjelements ); end; ############################################################################# ## #E compiler.g . . . . . . . . . . . . . . . . . . . . . . . . . . ends here gap-4r6p5/lib/macfloat.g0000644000175000017500000000175612172557252013656 0ustar billbill############################################################################# ## #W macfloat.g GAP library Steve Linton ## Stefan Kohl ## Laurent Bartholdi ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file deals with settings for the low-level macfloats ## ############################################################################# DeclareRepresentation("IsIEEE754FloatRep", IsFloat and IsInternalRep and IS_MACFLOAT,[]); BIND_GLOBAL("IEEE754FloatsFamily", NewFamily("IEEE754FloatsFamily", IsIEEE754FloatRep)); BIND_GLOBAL( "TYPE_MACFLOAT", NewType(IEEE754FloatsFamily, IsIEEE754FloatRep)); ############################################################################# ## #E gap-4r6p5/lib/ctblfuns.gd0000644000175000017500000033746312172557252014063 0ustar billbill############################################################################# ## #W ctblfuns.gd GAP library Thomas Breuer ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the definition of categories of class functions, ## and the corresponding properties, attributes, and operations. ## ## 1. Why Class Functions? ## 2. Basic Operations for Class Functions ## 3. Comparison of Class Functions ## 4. Arithmetic Operations for Class Functions ## 5. Printing Class Functions ## 6. Creating Class Functions from Values Lists ## 7. Creating Class Functions using Groups ## 8. Operations for Class Functions ## 9. Restricted and Induced Class Functions ## 10. Reducing Virtual Characters ## 11. Symmetrizations of Class Functions ## 12. Operations for Brauer Characters ## 13. Domains Generated by Class Functions ## 14. Auxiliary operations ## ############################################################################# ## #C IsClassFunction( ) ## ## <#GAPDoc Label="IsClassFunction"> ## ## ## ## ## class functionclass function objects ## A class function (in characteristic p) of a finite group ## G is a map from the set of (p-regular) elements in G ## to the field of cyclotomics ## that is constant on conjugacy classes of G. ##

## Each class function in &GAP; is represented by an immutable list, ## where at the i-th position the value on the i-th conjugacy ## class of the character table of G is stored. ## The ordering of the conjugacy classes is the one used in the underlying ## character table. ## Note that if the character table has access to its underlying group then ## the ordering of conjugacy classes in the group and in the character table ## may differ ## (see ); ## class functions always refer to the ordering of classes in the character ## table. ##

## Class function objects in &GAP; are not just plain lists, ## they store the character table of the group G as value of the ## attribute . ## The group G itself is accessible only via the character table ## and thus only if the character table stores its group, as value of the ## attribute . ## The reason for this is that many computations with class functions are ## possible without using their groups, ## for example class functions of character tables in the &GAP; ## character table library do in general not have access to their ## underlying groups. ##

## There are (at least) two reasons why class functions in &GAP; are ## not implemented as mappings. ## First, we want to distinguish class functions in different ## characteristics, for example to be able to define the Frobenius character ## of a given Brauer character; ## viewed as mappings, the trivial characters in all characteristics coprime ## to the order of G are equal. ## Second, the product of two class functions shall be again a class ## function, whereas the product of general mappings is defined as ## composition. ##

## A further argument is that the typical operations for mappings such as ## ## and ## ## play no important role for class functions. ## ## ## <#/GAPDoc> ## DeclareCategory( "IsClassFunction", IsScalar and IsCommutativeElement and IsAssociativeElement and IsHomogeneousList and IsScalarCollection and IsFinite and IsGeneralizedRowVector ); ############################################################################# ## #F CharacterString( , ) ## ## ## ## ## ## ## ## DeclareGlobalFunction( "CharacterString" ); ############################################################################# ## ## 1. Why Class Functions? ## ## <#GAPDoc Label="[1]{ctblfuns}"> ## In principle it is possible to represent group characters or more general ## class functions by the plain lists of their values, ## and in fact many operations for class functions work with plain lists of ## class function values. ## But this has two disadvantages. ##

## First, it is then necessary to regard a values list explicitly as a class ## function of a particular character table, by supplying this character ## table as an argument. ## In practice this means that with this setup, ## the user has the task to put the objects into the right context. ## For example, forming the scalar product or the tensor product of two ## class functions or forming an induced class function or a conjugate ## class function then needs three arguments in this case; ## this is particularly inconvenient in cases where infix operations cannot ## be used because of the additional argument, as for tensor products and ## induced class functions. ##

## Second, when one says that ## \chi is a character of a group G ## then this object \chi carries a lot of information. ## \chi has certain properties such as being irreducible or not. ## Several subgroups of G are related to \chi, ## such as the kernel and the centre of \chi. ## Other attributes of characters are the determinant and the central ## character. ## This knowledge cannot be stored in a plain list. ##

## For dealing with a group together with its characters, and maybe also ## subgroups and their characters, it is desirable that &GAP; keeps track ## of the interpretation of characters. ## On the other hand, for using characters without accessing their groups, ## such as characters of tables from the &GAP; table library, ## dealing just with values lists is often sufficient. ## In particular, if one deals with incomplete character tables then it is ## often necessary to specify the arguments explicitly, ## for example one has to choose a fusion map or power map from a set of ## possibilities. ##

## The main idea behind class function objects is that a class function ## object is equal to its values list in the sense of , ## so class function objects can be used wherever their values lists ## can be used, ## but there are operations for class function objects that do not work ## just with values lists. ## ## ## ## ## &GAP; library functions prefer to return class function objects ## rather than returning just values lists, ## for example lists ## consist of class function objects, ## and ## returns a class function object. ##

## Here is an example that shows both approaches. ## First we define some groups. ##

## S4:= SymmetricGroup( 4 );; SetName( S4, "S4" ); ## gap> D8:= SylowSubgroup( S4, 2 );; SetName( D8, "D8" ); ## ]]> ##

## We do some computations using the functions described later in this ## Chapter, first with class function objects. ##

## irrS4:= Irr( S4 );; ## gap> irrD8:= Irr( D8 );; ## gap> chi:= irrD8[4]; ## Character( CharacterTable( D8 ), [ 1, -1, 1, -1, 1 ] ) ## gap> chi * chi; ## Character( CharacterTable( D8 ), [ 1, 1, 1, 1, 1 ] ) ## gap> ind:= chi ^ S4; ## Character( CharacterTable( S4 ), [ 3, -1, -1, 0, 1 ] ) ## gap> List( irrS4, x -> ScalarProduct( x, ind ) ); ## [ 0, 1, 0, 0, 0 ] ## gap> det:= Determinant( ind ); ## Character( CharacterTable( S4 ), [ 1, 1, 1, 1, 1 ] ) ## gap> cent:= CentralCharacter( ind ); ## ClassFunction( CharacterTable( S4 ), [ 1, -2, -1, 0, 2 ] ) ## gap> rest:= Restricted( cent, D8 ); ## ClassFunction( CharacterTable( D8 ), [ 1, -2, -1, -1, 2 ] ) ## ]]> ##

## Now we repeat these calculations with plain lists of character values. ## Here we need the character tables in some places. ##

## tS4:= CharacterTable( S4 );; ## gap> tD8:= CharacterTable( D8 );; ## gap> chi:= ValuesOfClassFunction( irrD8[4] ); ## [ 1, -1, 1, -1, 1 ] ## gap> Tensored( [ chi ], [ chi ] )[1]; ## [ 1, 1, 1, 1, 1 ] ## gap> ind:= InducedClassFunction( tD8, chi, tS4 ); ## ClassFunction( CharacterTable( S4 ), [ 3, -1, -1, 0, 1 ] ) ## gap> List( Irr( tS4 ), x -> ScalarProduct( tS4, x, ind ) ); ## [ 0, 1, 0, 0, 0 ] ## gap> det:= DeterminantOfCharacter( tS4, ind ); ## ClassFunction( CharacterTable( S4 ), [ 1, 1, 1, 1, 1 ] ) ## gap> cent:= CentralCharacter( tS4, ind ); ## ClassFunction( CharacterTable( S4 ), [ 1, -2, -1, 0, 2 ] ) ## gap> rest:= Restricted( tS4, cent, tD8 ); ## ClassFunction( CharacterTable( D8 ), [ 1, -2, -1, -1, 2 ] ) ## ]]> ##

## If one deals with character tables from the &GAP; table library then ## one has no access to their groups, ## but often the tables provide enough information for computing induced or ## restricted class functions, symmetrizations etc., ## because the relevant class fusions and power maps are often stored on ## library tables. ## In these cases it is possible to use the tables instead of the groups ## as arguments. ## (If necessary information is not uniquely determined by the tables then ## an error is signalled.) ##

## s5 := CharacterTable( "A5.2" );; irrs5 := Irr( s5 );; ## gap> m11:= CharacterTable( "M11" );; irrm11:= Irr( m11 );; ## gap> chi:= TrivialCharacter( s5 ); ## Character( CharacterTable( "A5.2" ), [ 1, 1, 1, 1, 1, 1, 1 ] ) ## gap> chi ^ m11; ## Character( CharacterTable( "M11" ), [ 66, 10, 3, 2, 1, 1, 0, 0, 0, 0 ## ] ) ## gap> Determinant( irrs5[4] ); ## Character( CharacterTable( "A5.2" ), [ 1, 1, 1, 1, -1, -1, -1 ] ) ## ]]> ##

## Functions that compute normal subgroups related to characters ## have counterparts that return the list of class positions corresponding ## to these groups. ##

## ClassPositionsOfKernel( irrs5[2] ); ## [ 1, 2, 3, 4 ] ## gap> ClassPositionsOfCentre( irrs5[2] ); ## [ 1, 2, 3, 4, 5, 6, 7 ] ## ]]> ##

## Non-normal subgroups cannot be described this way, ## so for example inertia subgroups (see ) ## can in general not be computed from character tables without access to ## their groups. ## <#/GAPDoc> ## ############################################################################# ## ## 2. Basic Operations for Class Functions ## ## <#GAPDoc Label="[2]{ctblfuns}"> ## Basic operations for class functions are ## , ## , ## and the basic operations for lists ## (see ). ## <#/GAPDoc> ## ############################################################################# ## #A UnderlyingCharacterTable( ) ## ## <#GAPDoc Label="UnderlyingCharacterTable"> ## ## ## ## ## For a class function psi of the group G, say, ## the character table of G is stored as value of ## . ## The ordering of entries in the list psi ## (see ) ## refers to the ordering of conjugacy classes in this character table. ##

## If psi is an ordinary class function then the underlying character ## table is the ordinary character table of G ## (see ), ## if psi is a class function in characteristic p \neq 0 then ## the underlying character table is the p-modular Brauer table of ## G ## (see ). ## So the underlying characteristic of psi can be read off from the ## underlying character table. ## ## ## <#/GAPDoc> ## DeclareAttribute( "UnderlyingCharacterTable", IsClassFunction ); ############################################################################# ## #A ValuesOfClassFunction( ) . . . . . . . . . . . . . . list of values ## ## <#GAPDoc Label="ValuesOfClassFunction"> ## ## ## ## ## is the list of values of the class function psi, ## the i-th entry being the value on the i-th conjugacy class ## of the underlying character table ## (see ). ##

## g:= SymmetricGroup( 4 ); ## Sym( [ 1 .. 4 ] ) ## gap> psi:= TrivialCharacter( g ); ## Character( CharacterTable( Sym( [ 1 .. 4 ] ) ), [ 1, 1, 1, 1, 1 ] ) ## gap> UnderlyingCharacterTable( psi ); ## CharacterTable( Sym( [ 1 .. 4 ] ) ) ## gap> ValuesOfClassFunction( psi ); ## [ 1, 1, 1, 1, 1 ] ## gap> IsList( psi ); ## true ## gap> psi[1]; ## 1 ## gap> Length( psi ); ## 5 ## gap> IsBound( psi[6] ); ## false ## gap> Concatenation( psi, [ 2, 3 ] ); ## [ 1, 1, 1, 1, 1, 2, 3 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "ValuesOfClassFunction", IsClassFunction ); ############################################################################# ## ## 3. Comparison of Class Functions ## ## <#GAPDoc Label="[3]{ctblfuns}"> ## With respect to and , ## class functions behave equally to their lists of values ## (see ). ## So two class functions are equal if and only if their lists of values are ## equal, no matter whether they are class functions of the same character ## table, of the same group but w.r.t. different class ordering, ## or of different groups. ##

## grps:= Filtered( AllSmallGroups( 8 ), g -> not IsAbelian( g ) ); ## [ , ## ] ## gap> t1:= CharacterTable( grps[1] ); SetName( t1, "t1" ); ## CharacterTable( ) ## gap> t2:= CharacterTable( grps[2] ); SetName( t2, "t2" ); ## CharacterTable( ) ## gap> irr1:= Irr( grps[1] ); ## [ Character( t1, [ 1, 1, 1, 1, 1 ] ), ## Character( t1, [ 1, -1, -1, 1, 1 ] ), ## Character( t1, [ 1, -1, 1, 1, -1 ] ), ## Character( t1, [ 1, 1, -1, 1, -1 ] ), ## Character( t1, [ 2, 0, 0, -2, 0 ] ) ] ## gap> irr2:= Irr( grps[2] ); ## [ Character( t2, [ 1, 1, 1, 1, 1 ] ), ## Character( t2, [ 1, -1, -1, 1, 1 ] ), ## Character( t2, [ 1, -1, 1, 1, -1 ] ), ## Character( t2, [ 1, 1, -1, 1, -1 ] ), ## Character( t2, [ 2, 0, 0, -2, 0 ] ) ] ## gap> irr1 = irr2; ## true ## gap> IsSSortedList( irr1 ); ## false ## gap> irr1[1] < irr1[2]; ## false ## gap> irr1[2] < irr1[3]; ## true ## ]]> ## <#/GAPDoc> ## ############################################################################# ## ## 4. Arithmetic Operations for Class Functions ## ## <#GAPDoc Label="[4]{ctblfuns}"> ## Class functions are row vectors of cyclotomics. ## The additive behaviour of class functions is defined such that ## they are equal to the plain lists of class function values except that ## the results are represented again as class functions whenever this makes ## sense. ## The multiplicative behaviour, however, is different. ## This is motivated by the fact that the tensor product of class functions ## is a more interesting operation than the vector product of plain lists. ## (Another candidate for a multiplication of compatible class functions ## would have been the inner product, which is implemented via the function ## . ## In terms of filters, the arithmetic of class functions is based on the ## decision that they lie in , ## with additive nesting depth 1, but they do not lie in ## . ##

## More specifically, the scalar multiple of a class function with a ## cyclotomic is a class function, ## and the sum and the difference of two class functions ## of the same underlying character table ## (see ) ## are again class functions of this table. ## The sum and the difference of a class function and a list that is ## not a class function are plain lists, ## as well as the sum and the difference of two class functions of different ## character tables. ##

## g:= SymmetricGroup( 4 );; tbl:= CharacterTable( g );; ## gap> SetName( tbl, "S4" ); irr:= Irr( g ); ## [ Character( S4, [ 1, -1, 1, 1, -1 ] ), ## Character( S4, [ 3, -1, -1, 0, 1 ] ), ## Character( S4, [ 2, 0, 2, -1, 0 ] ), ## Character( S4, [ 3, 1, -1, 0, -1 ] ), ## Character( S4, [ 1, 1, 1, 1, 1 ] ) ] ## gap> 2 * irr[5]; ## Character( S4, [ 2, 2, 2, 2, 2 ] ) ## gap> irr[1] / 7; ## ClassFunction( S4, [ 1/7, -1/7, 1/7, 1/7, -1/7 ] ) ## gap> lincomb:= irr[3] + irr[1] - irr[5]; ## VirtualCharacter( S4, [ 2, -2, 2, -1, -2 ] ) ## gap> lincomb:= lincomb + 2 * irr[5]; ## VirtualCharacter( S4, [ 4, 0, 4, 1, 0 ] ) ## gap> IsCharacter( lincomb ); ## true ## gap> lincomb; ## Character( S4, [ 4, 0, 4, 1, 0 ] ) ## gap> irr[5] + 2; ## [ 3, 3, 3, 3, 3 ] ## gap> irr[5] + [ 1, 2, 3, 4, 5 ]; ## [ 2, 3, 4, 5, 6 ] ## gap> zero:= 0 * irr[1]; ## VirtualCharacter( S4, [ 0, 0, 0, 0, 0 ] ) ## gap> zero + Z(3); ## [ Z(3), Z(3), Z(3), Z(3), Z(3) ] ## gap> irr[5] + TrivialCharacter( DihedralGroup( 8 ) ); ## [ 2, 2, 2, 2, 2 ] ## ]]> ##

## class functions ## The product of two class functions of the same character table is the ## tensor product (pointwise product) of these class functions. ## Thus the set of all class functions of a fixed group forms a ring, ## and for any field F of cyclotomics, the F-span of a given ## set of class functions forms an algebra. ##

## The product of two class functions of different tables and the ## product of a class function and a list that is not a class ## function are not defined, an error is signalled in these cases. ## Note that in this respect, class functions behave differently from their ## values lists, for which the product is defined as the standard scalar ## product. ##

## tens:= irr[3] * irr[4]; ## Character( S4, [ 6, 0, -2, 0, 0 ] ) ## gap> ValuesOfClassFunction( irr[3] ) * ValuesOfClassFunction( irr[4] ); ## 4 ## ]]> ##

## inverse ## Class functions without zero values are invertible, ## the inverse is defined pointwise. ## As a consequence, for example groups of linear characters can be formed. ##

## tens / irr[1]; ## Character( S4, [ 6, 0, -2, 0, 0 ] ) ## ]]> ##

## Other (somewhat strange) implications of the definition of arithmetic ## operations for class functions, together with the general rules of list ## arithmetic (see ), ## apply to the case of products involving lists of class functions. ## No inverse of the list of irreducible characters as a matrix is defined; ## if one is interested in the inverse matrix then one can compute it from ## the matrix of class function values. ##

## Inverse( List( irr, ValuesOfClassFunction ) ); ## [ [ 1/24, 1/8, 1/12, 1/8, 1/24 ], [ -1/4, -1/4, 0, 1/4, 1/4 ], ## [ 1/8, -1/8, 1/4, -1/8, 1/8 ], [ 1/3, 0, -1/3, 0, 1/3 ], ## [ -1/4, 1/4, 0, -1/4, 1/4 ] ] ## ]]> ##

## Also the product of a class function with a list of class functions is ## not a vector-matrix product but the list of pointwise products. ##

## irr[1] * irr{ [ 1 .. 3 ] }; ## [ Character( S4, [ 1, 1, 1, 1, 1 ] ), ## Character( S4, [ 3, 1, -1, 0, -1 ] ), ## Character( S4, [ 2, 0, 2, -1, 0 ] ) ] ## ]]> ##

## And the product of two lists of class functions is not the matrix ## product but the sum of the pointwise products. ##

## irr * irr; ## Character( S4, [ 24, 4, 8, 3, 4 ] ) ## ]]> ##

## character value ## power ## ^ ## The powering operator has several meanings ## for class functions. ## The power of a class function by a nonnegative integer is clearly the ## tensor power. ## The power of a class function by an element that normalizes the ## underlying group or by a Galois automorphism is the conjugate class ## function. ## (As a consequence, the application of the permutation induced by such an ## action cannot be denoted by ; instead one can use ## .) ## The power of a class function by a group or a character table is the ## induced class function (see ). ## The power of a group element by a class function is the class function ## value at (the conjugacy class containing) this element. ##

## irr[3] ^ 3; ## Character( S4, [ 8, 0, 8, -1, 0 ] ) ## gap> lin:= LinearCharacters( DerivedSubgroup( g ) ); ## [ Character( CharacterTable( Alt( [ 1 .. 4 ] ) ), [ 1, 1, 1, 1 ] ), ## Character( CharacterTable( Alt( [ 1 .. 4 ] ) ), ## [ 1, 1, E(3)^2, E(3) ] ), ## Character( CharacterTable( Alt( [ 1 .. 4 ] ) ), ## [ 1, 1, E(3), E(3)^2 ] ) ] ## gap> List( lin, chi -> chi ^ (1,2) ); ## [ Character( CharacterTable( Alt( [ 1 .. 4 ] ) ), [ 1, 1, 1, 1 ] ), ## Character( CharacterTable( Alt( [ 1 .. 4 ] ) ), ## [ 1, 1, E(3), E(3)^2 ] ), ## Character( CharacterTable( Alt( [ 1 .. 4 ] ) ), ## [ 1, 1, E(3)^2, E(3) ] ) ] ## gap> Orbit( GaloisGroup( CF(3) ), lin[2] ); ## [ Character( CharacterTable( Alt( [ 1 .. 4 ] ) ), ## [ 1, 1, E(3)^2, E(3) ] ), ## Character( CharacterTable( Alt( [ 1 .. 4 ] ) ), ## [ 1, 1, E(3), E(3)^2 ] ) ] ## gap> lin[1]^g; ## Character( S4, [ 2, 0, 2, 2, 0 ] ) ## gap> (1,2,3)^lin[2]; ## E(3)^2 ## ]]> ## ## ## ## ## ## The characteristic of class functions is zero, ## as for all list of cyclotomics. ## For class functions of a p-modular character table, such as Brauer ## characters, the prime p is given by the ## ## value of the character table. ##

## Characteristic( irr[1] ); ## 0 ## gap> irrmod2:= Irr( g, 2 ); ## [ Character( BrauerTable( Sym( [ 1 .. 4 ] ), 2 ), [ 1, 1 ] ), ## Character( BrauerTable( Sym( [ 1 .. 4 ] ), 2 ), [ 2, -1 ] ) ] ## gap> Characteristic( irrmod2[1] ); ## 0 ## gap> UnderlyingCharacteristic( UnderlyingCharacterTable( irrmod2[1] ) ); ## 2 ## ]]> ## ## ## ## ## ## ## ## ## ## The operations ## , ## , ## and return ## a class function when they are called with a class function; ## The complex conjugate of a class function that is known to be a (virtual) ## character is again known to be a (virtual) character, and applying an ## arbitrary Galois automorphism to an ordinary (virtual) character yields ## a (virtual) character. ##

## ComplexConjugate( lin[2] ); ## Character( CharacterTable( Alt( [ 1 .. 4 ] ) ), [ 1, 1, E(3), E(3)^2 ## ] ) ## gap> GaloisCyc( lin[2], 5 ); ## Character( CharacterTable( Alt( [ 1 .. 4 ] ) ), [ 1, 1, E(3), E(3)^2 ## ] ) ## gap> Permuted( lin[2], (2,3,4) ); ## ClassFunction( CharacterTable( Alt( [ 1 .. 4 ] ) ), ## [ 1, E(3), 1, E(3)^2 ] ) ## ]]> ## ## ##

## ## ## ## ## By definition of for arbitrary monoid elements, ## the return value of for a character must be its ## multiplicative order. ## The determinantal order ## (see ) of a character chi ## can be computed as Order( Determinant( chi ) ). ##

## det:= Determinant( irr[3] ); ## Character( S4, [ 1, -1, 1, 1, -1 ] ) ## gap> Order( det ); ## 2 ## ]]> ## ## ## <#/GAPDoc> ## ############################################################################# ## #A GlobalPartitionOfClasses( ) ## ## ## ## ## ## Let n be the number of conjugacy classes of the character table ## tbl. ## returns a list of subsets of the ## range [ 1 .. n ] that forms a partition of [ 1 .. n ]. ## This partition is respected by each table automorphism of tbl ## (see ); ## note that also fixed points occur. ##

## This is useful for the computation of table automorphisms ## and of conjugate class functions. ##

## Since group automorphisms induce table automorphisms, the partition is ## also respected by the permutation group that occurs in the computation ## of inertia groups and conjugate class functions. ##

## If the group of table automorphisms is already known then its orbits ## form the finest possible global partition. ##

## Otherwise the subsets in the partition are the sets of classes with ## same centralizer order and same element order, and ## –if more about the character table is known– ## also with the same number of p-th root classes, ## for all p for which the power maps are stored. ## ## ## DeclareAttribute( "GlobalPartitionOfClasses", IsNearlyCharacterTable ); ############################################################################# ## #O CorrespondingPermutations( [, ], ) ## ## ## ## ## ## Called with two arguments tbl and elms, ## returns the list of those ## permutations of conjugacy classes of the character table tbl ## that are induced by the action of the group elements in the list ## elms. ## If an element of elms does not act on the classes of ## tbl then either fail or a (meaningless) permutation ## is returned. ##

## In the call with three arguments, the second argument chi must be ## (the values list of) a class function of tbl, ## and the returned permutations will at least yield the same ## conjugate class functions as the permutations of classes that are induced ## by elms, ## that is, the images are not necessarily the same for orbits on which ## chi is constant. ##

## This function is used for computing conjugate class functions. ## ## ## DeclareOperation( "CorrespondingPermutations", [ IsOrdinaryTable, IsHomogeneousList ] ); DeclareOperation( "CorrespondingPermutations", [ IsOrdinaryTable, IsClassFunction, IsHomogeneousList ] ); ############################################################################# ## ## 5. Printing Class Functions ## ## <#GAPDoc Label="[5]{ctblfuns}"> ## ## ## ## ## The default methods for class functions ## print one of the strings "ClassFunction", ## "VirtualCharacter", "Character" (depending on whether the ## class function is known to be a character or virtual character, ## see , ), ## followed by the output for the underlying character ## table (see ), ## and the list of values. ## The table is chosen (and not the group) in order to distinguish class ## functions of different underlying characteristic ## (see ). ## ## ## ## ## ## ## ## The default method for class functions ## does the same as , ## except that the character table is is -ed instead of ## -ed. ##

## Note that if a class function is shown only with one of the ## strings "ClassFunction", "VirtualCharacter", ## it may still be that it is in fact a character; ## just this was not known at the time when the class function was printed. ##

## In order to reduce the space that is needed to print a class function, ## it may be useful to give a name (see ) to the ## underlying character table. ## ## ## ## ## ## ## ## The default method for a class function chi ## calls for its underlying character table ## (see ), ## with chi as the only entry in the chars list of the options ## record. ##

## chi:= TrivialCharacter( CharacterTable( "A5" ) ); ## Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ) ## gap> Display( chi ); ## A5 ## ## 2 2 2 . . . ## 3 1 . 1 . . ## 5 1 . . 1 1 ## ## 1a 2a 3a 5a 5b ## 2P 1a 1a 3a 5b 5a ## 3P 1a 2a 1a 5b 5a ## 5P 1a 2a 3a 1a 1a ## ## Y.1 1 1 1 1 1 ## ]]> ## ## ## <#/GAPDoc> ## ############################################################################# ## ## 6. Creating Class Functions from Values Lists ## ############################################################################# ## #O ClassFunction( , ) #O ClassFunction( , ) ## ## <#GAPDoc Label="ClassFunction"> ## ## ## ## ## ## In the first form, ## ## returns the class function of the character table tbl with values ## given by the list values of cyclotomics. ## In the second form, G must be a group, ## and the class function of its ordinary character table is returned. ##

## Note that tbl determines the underlying characteristic of the ## returned class function ## (see ). ## ## ## <#/GAPDoc> ## DeclareOperation( "ClassFunction", [ IsNearlyCharacterTable, IsDenseList ] ); DeclareOperation( "ClassFunction", [ IsGroup, IsDenseList ] ); ############################################################################# ## #O VirtualCharacter( , ) #O VirtualCharacter( , ) ## ## <#GAPDoc Label="VirtualCharacter"> ## ## ## ## ## ## ## returns the virtual character ## (see ) ## of the character table tbl or the group G, ## respectively, with values given by the list values. ##

## It is not checked whether the given values really describe a ## virtual character. ## ## ## <#/GAPDoc> ## DeclareOperation( "VirtualCharacter", [ IsNearlyCharacterTable, IsDenseList ] ); DeclareOperation( "VirtualCharacter", [ IsGroup, IsDenseList ] ); ############################################################################# ## #O Character( , ) ## ## <#GAPDoc Label="Character"> ## ## ## ## ## ## ## returns the character (see ) ## of the character table tbl or the group G, ## respectively, with values given by the list values. ##

## It is not checked whether the given values really describe a ## character. ## g:= DihedralGroup( 8 ); tbl:= CharacterTable( g ); ## ## CharacterTable( ) ## gap> SetName( tbl, "D8" ); ## gap> phi:= ClassFunction( g, [ 1, -1, 0, 2, -2 ] ); ## ClassFunction( D8, [ 1, -1, 0, 2, -2 ] ) ## gap> psi:= ClassFunction( tbl, ## > List( Irr( g ), chi -> ScalarProduct( chi, phi ) ) ); ## ClassFunction( D8, [ -3/8, 9/8, 5/8, 1/8, -1/4 ] ) ## gap> chi:= VirtualCharacter( g, [ 0, 0, 8, 0, 0 ] ); ## VirtualCharacter( D8, [ 0, 0, 8, 0, 0 ] ) ## gap> reg:= Character( tbl, [ 8, 0, 0, 0, 0 ] ); ## Character( D8, [ 8, 0, 0, 0, 0 ] ) ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "Character", [ IsNearlyCharacterTable, IsDenseList ] ); DeclareOperation( "Character", [ IsGroup, IsDenseList ] ); ############################################################################# ## #F ClassFunctionSameType( , , ) ## ## <#GAPDoc Label="ClassFunctionSameType"> ## ## ## ## ## Let tbl be a character table, chi a class function object ## (not necessarily a class function of tbl), ## and values a list of cyclotomics. ## returns the class function ## \psi of tbl with values list values, ## constructed with ## . ##

## If chi is known to be a (virtual) character then \psi ## is also known to be a (virtual) character. ##

## h:= Centre( g );; ## gap> centbl:= CharacterTable( h );; SetName( centbl, "C2" ); ## gap> ClassFunctionSameType( centbl, phi, [ 1, 1 ] ); ## ClassFunction( C2, [ 1, 1 ] ) ## gap> ClassFunctionSameType( centbl, chi, [ 1, 1 ] ); ## VirtualCharacter( C2, [ 1, 1 ] ) ## gap> ClassFunctionSameType( centbl, reg, [ 1, 1 ] ); ## Character( C2, [ 1, 1 ] ) ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "ClassFunctionSameType" ); ############################################################################# ## ## 7. Creating Class Functions using Groups ## ############################################################################# ## #A TrivialCharacter( ) #A TrivialCharacter( ) ## ## <#GAPDoc Label="TrivialCharacter"> ## ## TrivialCharacter ## ## ## ## ## is the trivial character of the group G ## or its character table tbl, respectively. ## This is the class function with value equal to 1 for each class. ##

## TrivialCharacter( CharacterTable( "A5" ) ); ## Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ) ## gap> TrivialCharacter( SymmetricGroup( 3 ) ); ## Character( CharacterTable( Sym( [ 1 .. 3 ] ) ), [ 1, 1, 1 ] ) ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "TrivialCharacter", IsNearlyCharacterTable ); DeclareAttribute( "TrivialCharacter", IsGroup ); ############################################################################# ## #A NaturalCharacter( ) #A NaturalCharacter( ) ## ## <#GAPDoc Label="NaturalCharacter"> ## ## ## ## ## ## If the argument is a permutation group G then ## ## returns the (ordinary) character of the natural permutation ## representation of G on the set of moved points (see ## ), ## that is, the value on each class is the number of points among the moved ## points of G that are fixed by any permutation in that class. ##

## If the argument is a matrix group G in characteristic zero then ## returns the ## (ordinary) character of the natural matrix representation of G, ## that is, the value on each class is the trace of any matrix in that class. ##

## If the argument is a group homomorphism hom whose image is a ## permutation group or a matrix group then ## returns the ## restriction of the natural character of the image of hom to the ## preimage of hom. ##

## NaturalCharacter( SymmetricGroup( 3 ) ); ## Character( CharacterTable( Sym( [ 1 .. 3 ] ) ), [ 3, 1, 0 ] ) ## gap> NaturalCharacter( Group( [ [ 0, -1 ], [ 1, -1 ] ] ) ); ## Character( CharacterTable( Group([ [ [ 0, -1 ], [ 1, -1 ] ] ]) ), ## [ 2, -1, -1 ] ) ## gap> d8:= DihedralGroup( 8 );; hom:= IsomorphismPermGroup( d8 );; ## gap> NaturalCharacter( hom ); ## Character( CharacterTable( ), ## [ 8, 0, 0, 0, 0 ] ) ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "NaturalCharacter", IsGroup ); DeclareAttribute( "NaturalCharacter", IsGeneralMapping ); ############################################################################# ## #O PermutationCharacter( , , ) #O PermutationCharacter( , ) ## ## <#GAPDoc Label="PermutationCharacter"> ## ## PermutationCharacter ## ## ## ## ## Called with a group G, an action domain or proper set D, ## and an action function opr ## (see Chapter ), ## ## returns the permutation character of the action ## of G on D via opr, ## that is, the value on each class is the number of points in D ## that are fixed by an element in this class under the action opr. ##

## If the arguments are a group G and a subgroup U of G ## then returns ## the permutation character of the action of G on the right cosets ## of U via right multiplication. ##

## To compute the permutation character of a ## transitive permutation group ## G on the cosets of a point stabilizer U, ## the attribute ## of G can be used instead of ## PermutationCharacter( G, U ). ##

## More facilities concerning permutation characters are the transitivity ## test (see Section ) ## and several tools for computing possible permutation characters ## (see , ## ). ##

## PermutationCharacter( GL(2,2), AsSSortedList( GF(2)^2 ), OnRight ); ## Character( CharacterTable( SL(2,2) ), [ 4, 2, 1 ] ) ## gap> s3:= SymmetricGroup( 3 );; a3:= DerivedSubgroup( s3 );; ## gap> PermutationCharacter( s3, a3 ); ## Character( CharacterTable( Sym( [ 1 .. 3 ] ) ), [ 2, 0, 2 ] ) ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "PermutationCharacter", [ IsGroup, IsCollection, IsFunction ] ); DeclareOperation( "PermutationCharacter", [ IsGroup, IsGroup ] ); ############################################################################# ## ## 8. Operations for Class Functions ## ## <#GAPDoc Label="[6]{ctblfuns}"> ## In the description of the following operations, ## the optional first argument tbl is needed only if the argument ## chi is a plain list and not a class function object. ## In this case, tbl must always be the character table of which ## chi shall be regarded as a class function. ## <#/GAPDoc> ## ############################################################################# ## #P IsCharacter( [, ] ) ## ## <#GAPDoc Label="IsCharacter"> ## ## ## ## ## ordinary character ## An ordinary character of a group G is a class function of ## G whose values are the traces of a complex matrix representation ## of G. ##

## Brauer character ## A Brauer character of G in characteristic p is ## a class function of G whose values are the complex lifts of a ## matrix representation of G with image a finite field of ## characteristic p. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsCharacter", IsClassFunction ); DeclareOperation( "IsCharacter", [ IsCharacterTable, IsHomogeneousList ] ); ############################################################################# ## #P IsVirtualCharacter( [, ] ) ## ## <#GAPDoc Label="IsVirtualCharacter"> ## ## ## ## ## virtual character ## A virtual character is a class function that can be written as the ## difference of two proper characters (see ). ## ## ## <#/GAPDoc> ## DeclareProperty( "IsVirtualCharacter", IsClassFunction ); DeclareOperation( "IsVirtualCharacter", [ IsCharacterTable, IsHomogeneousList ] ); ############################################################################# ## #M IsVirtualCharacter( ) . . . . . . . . . . . . . . . for a character ## ## Each character is of course a virtual character. ## InstallTrueMethod( IsVirtualCharacter, IsCharacter and IsClassFunction ); ############################################################################# ## #P IsIrreducibleCharacter( [, ] ) ## ## <#GAPDoc Label="IsIrreducibleCharacter"> ## ## ## ## ## irreducible character ## A character is irreducible if it cannot be written as the sum of ## two characters. ## For ordinary characters this can be checked using the scalar product ## of class functions ## (see ). ## For Brauer characters there is no generic method for checking ## irreducibility. ##

## S4:= SymmetricGroup( 4 );; SetName( S4, "S4" ); ## gap> psi:= ClassFunction( S4, [ 1, 1, 1, -2, 1 ] ); ## ClassFunction( CharacterTable( S4 ), [ 1, 1, 1, -2, 1 ] ) ## gap> IsVirtualCharacter( psi ); ## true ## gap> IsCharacter( psi ); ## false ## gap> chi:= ClassFunction( S4, SizesCentralizers( CharacterTable( S4 ) ) ); ## ClassFunction( CharacterTable( S4 ), [ 24, 4, 8, 3, 4 ] ) ## gap> IsCharacter( chi ); ## true ## gap> IsIrreducibleCharacter( chi ); ## false ## gap> IsIrreducibleCharacter( TrivialCharacter( S4 ) ); ## true ## ]]> ## ## ## <#/GAPDoc> ## DeclareProperty( "IsIrreducibleCharacter", IsClassFunction ); DeclareOperation( "IsIrreducibleCharacter", [ IsCharacterTable, IsHomogeneousList ] ); ############################################################################# ## #O ScalarProduct( [, ], ) ## ## <#GAPDoc Label="ScalarProduct:ctblfuns"> ## ## ## ## ## the scalar product of the class functions chi and psi, ## which belong to the same character table tbl. ## ## ## constituent ## decompose ## multiplicity ## inner product ## If chi and psi are class function objects, ## the argument tbl is not needed, ## but tbl is necessary if at least one of chi, psi ## is just a plain list. ##

## The scalar product of two ordinary class functions \chi, ## \psi of a group G is defined as ##

## ( \sum_{{g \in G}} \chi(g) \psi(g^{{-1}}) ) / |G|. ##

## For two p-modular class functions, ## the scalar product is defined as ## ( \sum_{{g \in S}} \chi(g) \psi(g^{{-1}}) ) / |G|, ## where S is the set of p-regular elements in G. ## ## ## <#/GAPDoc> ## DeclareOperation( "ScalarProduct", [ IsCharacterTable, IsRowVector, IsRowVector ] ); ############################################################################# ## #O MatScalarProducts( [, ][, ] ) ## ## <#GAPDoc Label="MatScalarProducts"> ## ## ## ## ## Called with two lists list, list2 of class functions of the ## same character table (which may be given as the argument tbl), ## returns the matrix of scalar products ## (see ) ## More precisely, this matrix contains in the i-th row the list of ## scalar products of list2[i] ## with the entries of list. ##

## If only one list list of class functions is given then ## a lower triangular matrix of scalar products is returned, ## containing (for j \leq i) in the i-th row in column ## j the value ## ScalarProduct( tbl, list[j], list[i] ). ## ## ## <#/GAPDoc> ## DeclareOperation( "MatScalarProducts", [ IsHomogeneousList, IsHomogeneousList ] ); DeclareOperation( "MatScalarProducts", [ IsOrdinaryTable, IsHomogeneousList, IsHomogeneousList ] ); DeclareOperation( "MatScalarProducts", [ IsHomogeneousList ] ); DeclareOperation( "MatScalarProducts", [ IsOrdinaryTable, IsHomogeneousList ] ); ############################################################################# ## #A Norm( [, ] ) ## ## <#GAPDoc Label="Norm:ctblfuns"> ## ## ## ## ## Norm ## For an ordinary class function chi of the group G, say, ## we have chi = \sum_{{\chi \in Irr(G)}} a_{\chi} \chi, ## with complex coefficients a_{\chi}. ## The norm of chi is defined as ## \sum_{{\chi \in Irr(G)}} a_{\chi} \overline{{a_{\chi}}}. ##

## tbl:= CharacterTable( "A5" );; ## gap> ScalarProduct( TrivialCharacter( tbl ), Sum( Irr( tbl ) ) ); ## 1 ## gap> ScalarProduct( tbl, [ 1, 1, 1, 1, 1 ], Sum( Irr( tbl ) ) ); ## 1 ## gap> tbl2:= tbl mod 2; ## BrauerTable( "A5", 2 ) ## gap> chi:= Irr( tbl2 )[1]; ## Character( BrauerTable( "A5", 2 ), [ 1, 1, 1, 1 ] ) ## gap> ScalarProduct( chi, chi ); ## 3/4 ## gap> ScalarProduct( tbl2, [ 1, 1, 1, 1 ], [ 1, 1, 1, 1 ] ); ## 3/4 ## gap> chars:= Irr( tbl ){ [ 2 .. 4 ] };; ## gap> chars:= Set( Tensored( chars, chars ) );; ## gap> MatScalarProducts( Irr( tbl ), chars ); ## [ [ 0, 0, 0, 1, 1 ], [ 1, 1, 0, 0, 1 ], [ 1, 0, 1, 0, 1 ], ## [ 0, 1, 0, 1, 1 ], [ 0, 0, 1, 1, 1 ], [ 1, 1, 1, 1, 1 ] ] ## gap> MatScalarProducts( tbl, chars ); ## [ [ 2 ], [ 1, 3 ], [ 1, 2, 3 ], [ 2, 2, 1, 3 ], [ 2, 1, 2, 2, 3 ], ## [ 2, 3, 3, 3, 3, 5 ] ] ## gap> List( chars, Norm ); ## [ 2, 3, 3, 3, 3, 5 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "Norm", IsClassFunction ); DeclareOperation( "Norm", [ IsOrdinaryTable, IsHomogeneousList ] ); ############################################################################# ## #A CentreOfCharacter( [, ] ) ## ## <#GAPDoc Label="CentreOfCharacter"> ## ## ## ## ## centre ## For a character chi of the group G, say, ## returns the centre of chi, ## that is, the normal subgroup of all those elements of G for which ## the quotient of the value of chi by the degree of chi is ## a root of unity. ##

## If the underlying character table of psi does not store the group ## G then an error is signalled. ## (See  ## for a way to handle the centre implicitly, ## by listing the positions of conjugacy classes in the centre.) ##

## List( Irr( S4 ), CentreOfCharacter ); ## [ Group([ (), (1,2), (1,2)(3,4), (1,2,3), (1,2,3,4) ]), Group(()), ## Group([ (1,2)(3,4), (1,3)(2,4) ]), Group(()), ## Group([ (), (1,2), (1,2)(3,4), (1,2,3), (1,2,3,4) ]) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "CentreOfCharacter", IsClassFunction ); DeclareOperation( "CentreOfCharacter", [ IsOrdinaryTable, IsHomogeneousList ] ); DeclareSynonym( "CenterOfCharacter", CentreOfCharacter ); ############################################################################# ## #A ClassPositionsOfCentre( ) ## ## <#GAPDoc Label="ClassPositionsOfCentre:ctblfuns"> ## ## ## ## ## is the list of positions of classes forming the centre of the character ## chi (see ). ##

## List( Irr( S4 ), ClassPositionsOfCentre ); ## [ [ 1, 2, 3, 4, 5 ], [ 1 ], [ 1, 3 ], [ 1 ], [ 1, 2, 3, 4, 5 ] ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "ClassPositionsOfCentre", IsHomogeneousList ); ############################################################################# ## #A ConstituentsOfCharacter( [, ] ) ## ## <#GAPDoc Label="ConstituentsOfCharacter"> ## ## ## ## ## is the set of irreducible characters that occur in the decomposition of ## the (virtual) character chi with nonzero coefficient. ##

## nat:= NaturalCharacter( S4 ); ## Character( CharacterTable( S4 ), [ 4, 2, 0, 1, 0 ] ) ## gap> ConstituentsOfCharacter( nat ); ## [ Character( CharacterTable( S4 ), [ 1, 1, 1, 1, 1 ] ), ## Character( CharacterTable( S4 ), [ 3, 1, -1, 0, -1 ] ) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "ConstituentsOfCharacter", IsClassFunction ); DeclareOperation( "ConstituentsOfCharacter", [ IsCharacterTable, IsHomogeneousList ] ); ############################################################################# ## #A DegreeOfCharacter( ) ## ## <#GAPDoc Label="DegreeOfCharacter"> ## ## ## ## ## is the value of the character chi on the identity element. ## This can also be obtained as chi[1]. ##

## List( Irr( S4 ), DegreeOfCharacter ); ## [ 1, 3, 2, 3, 1 ] ## gap> nat:= NaturalCharacter( S4 ); ## Character( CharacterTable( S4 ), [ 4, 2, 0, 1, 0 ] ) ## gap> nat[1]; ## 4 ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "DegreeOfCharacter", IsClassFunction ); ############################################################################# ## #O InertiaSubgroup( [, ], ) ## ## <#GAPDoc Label="InertiaSubgroup"> ## ## ## ## ## Let chi be a character of the group H, say, ## and tbl the character table of H; ## if the argument tbl is not given then the underlying character ## table of chi (see ) is ## used instead. ## Furthermore, let G be a group that contains H as a normal ## subgroup. ##

## returns the stabilizer in G of ## chi, w.r.t. the action of G on the classes of H ## via conjugation. ## In other words, returns the group of all ## those elements g \in G that satisfy ## chi^g = chi. ##

## der:= DerivedSubgroup( S4 ); ## Group([ (1,3,2), (2,4,3) ]) ## gap> List( Irr( der ), chi -> InertiaSubgroup( S4, chi ) ); ## [ S4, Alt( [ 1 .. 4 ] ), Alt( [ 1 .. 4 ] ), S4 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "InertiaSubgroup", [ IsGroup, IsClassFunction ] ); DeclareOperation( "InertiaSubgroup", [ IsOrdinaryTable, IsGroup, IsHomogeneousList ] ); ############################################################################# ## #A KernelOfCharacter( [, ] ) ## ## <#GAPDoc Label="KernelOfCharacter"> ## ## ## ## ## For a class function chi of the group G, say, ## returns the normal subgroup of G ## that is formed by those conjugacy classes for which the value of ## chi equals the degree of chi. ## If the underlying character table of chi does not store the group ## G then an error is signalled. ## (See  for a way to handle the ## kernel implicitly, ## by listing the positions of conjugacy classes in the kernel.) ##

## The returned group is the kernel of any representation of G that ## affords chi. ##

## List( Irr( S4 ), KernelOfCharacter ); ## [ Group([ (), (1,2)(3,4), (1,2,3) ]), Group(()), ## Group([ (1,2)(3,4), (1,3)(2,4) ]), Group(()), ## Group([ (), (1,2), (1,2)(3,4), (1,2,3), (1,2,3,4) ]) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "KernelOfCharacter", IsClassFunction ); DeclareOperation( "KernelOfCharacter", [ IsOrdinaryTable, IsHomogeneousList ] ); ############################################################################# ## #A ClassPositionsOfKernel( ) ## ## <#GAPDoc Label="ClassPositionsOfKernel"> ## ## ## ## ## is the list of positions of those conjugacy classes that form the kernel ## of the character chi, that is, those positions with character ## value equal to the character degree. ##

## List( Irr( S4 ), ClassPositionsOfKernel ); ## [ [ 1, 3, 4 ], [ 1 ], [ 1, 3 ], [ 1 ], [ 1, 2, 3, 4, 5 ] ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "ClassPositionsOfKernel", IsHomogeneousList ); ############################################################################# ## #O CycleStructureClass( [, ], ) ## ## <#GAPDoc Label="CycleStructureClass"> ## ## ## ## ## Let permchar be a permutation character, and class be the ## position of a conjugacy class of the character table of permchar. ## returns a list describing ## the cycle structure of each element in class class in the ## underlying permutation representation, in the same format as the result ## of . ##

## nat:= NaturalCharacter( S4 ); ## Character( CharacterTable( S4 ), [ 4, 2, 0, 1, 0 ] ) ## gap> List( [ 1 .. 5 ], i -> CycleStructureClass( nat, i ) ); ## [ [ ], [ 1 ], [ 2 ], [ , 1 ], [ ,, 1 ] ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "CycleStructureClass", [ IsOrdinaryTable, IsHomogeneousList, IsPosInt ] ); DeclareOperation( "CycleStructureClass", [ IsClassFunction, IsPosInt ] ); ############################################################################# ## #P IsTransitive( [, ] ) ## ## <#GAPDoc Label="IsTransitive:ctblfuns"> ## ## ## ## ## For a permutation character chi of the group G that ## corresponds to an action on the G-set \Omega ## (see ), ## ## returns true if the action of G on \Omega is ## transitive, and false otherwise. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsTransitive", IsClassFunction ); DeclareOperation( "IsTransitive", [ IsCharacterTable, IsHomogeneousList ] ); ############################################################################# ## #A Transitivity( [, ] ) ## ## <#GAPDoc Label="Transitivity:ctblfuns"> ## ## ## ## ## For a permutation character chi of the group G ## that corresponds to an action on the G-set \Omega ## (see ), ## returns the maximal ## nonnegative integer k such that the action of G on ## \Omega is k-transitive. ##

## IsTransitive( nat ); Transitivity( nat ); ## true ## 4 ## gap> Transitivity( 2 * TrivialCharacter( S4 ) ); ## 0 ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "Transitivity", IsClassFunction ); DeclareOperation( "Transitivity", [ IsOrdinaryTable, IsHomogeneousList ] ); ############################################################################# ## #A CentralCharacter( [, ] ) ## ## <#GAPDoc Label="CentralCharacter"> ## ## ## ## ## central character ## For a character chi of the group G, say, ## returns ## the central character of chi. ##

## The central character of \chi is the class function ## \omega_{\chi} defined by ## \omega_{\chi}(g) = |g^G| \cdot \chi(g)/\chi(1) for each ## g \in G. ## ## ## <#/GAPDoc> ## DeclareAttribute( "CentralCharacter", IsClassFunction ); DeclareOperation( "CentralCharacter", [ IsCharacterTable, IsHomogeneousList ] ); ############################################################################# ## #A DeterminantOfCharacter( [, ] ) ## ## <#GAPDoc Label="DeterminantOfCharacter"> ## ## ## ## ## determinant character ## returns the ## determinant character of the character chi. ## This is defined to be the character obtained by taking the determinant of ## representing matrices of any representation affording chi; ## the determinant can be computed using . ##

## It is also possible to call instead of ## . ##

## Note that the determinant character is well-defined for virtual ## characters. ##

## CentralCharacter( TrivialCharacter( S4 ) ); ## ClassFunction( CharacterTable( S4 ), [ 1, 6, 3, 8, 6 ] ) ## gap> DeterminantOfCharacter( Irr( S4 )[3] ); ## Character( CharacterTable( S4 ), [ 1, -1, 1, 1, -1 ] ) ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "DeterminantOfCharacter", IsClassFunction ); DeclareOperation( "DeterminantOfCharacter", [ IsCharacterTable, IsHomogeneousList ] ); ############################################################################# ## #O EigenvaluesChar( [, ], ) ## ## <#GAPDoc Label="EigenvaluesChar"> ## ## ## ## ## Let chi be a character of the group G, say. ## For an element g \in G in the class-th conjugacy class, ## of order n, let M be a matrix of a representation affording ## chi. ##

## returns the list of length n ## where at position k the multiplicity ## of E(n)^k = \exp(2 \pi i k / n) ## as an eigenvalue of M is stored. ##

## We have ## chi[ class ] = List( [ 1 .. n ], k -> E(n)^k ) ## * EigenvaluesChar( tbl, chi, class ). ##

## It is also possible to call instead of ## . ##

## chi:= Irr( CharacterTable( "A5" ) )[2]; ## Character( CharacterTable( "A5" ), ## [ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ] ) ## gap> List( [ 1 .. 5 ], i -> Eigenvalues( chi, i ) ); ## [ [ 3 ], [ 2, 1 ], [ 1, 1, 1 ], [ 0, 1, 1, 0, 1 ], [ 1, 0, 0, 1, 1 ] ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "EigenvaluesChar", [ IsClassFunction, IsPosInt ] ); DeclareOperation( "EigenvaluesChar", [ IsCharacterTable, IsHomogeneousList, IsPosInt ] ); ############################################################################# ## #O Tensored( , ) ## ## <#GAPDoc Label="Tensored"> ## ## ## ## ## Let chars1 and chars2 be lists of (values lists of) class ## functions of the same character table. ## returns the list of tensor products of all entries ## in chars1 with all entries in chars2. ##

## irra5:= Irr( CharacterTable( "A5" ) );; ## gap> chars1:= irra5{ [ 1 .. 3 ] };; chars2:= irra5{ [ 2, 3 ] };; ## gap> Tensored( chars1, chars2 ); ## [ Character( CharacterTable( "A5" ), ## [ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ] ), ## Character( CharacterTable( "A5" ), ## [ 3, -1, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ] ), ## Character( CharacterTable( "A5" ), ## [ 9, 1, 0, -2*E(5)-E(5)^2-E(5)^3-2*E(5)^4, ## -E(5)-2*E(5)^2-2*E(5)^3-E(5)^4 ] ), ## Character( CharacterTable( "A5" ), [ 9, 1, 0, -1, -1 ] ), ## Character( CharacterTable( "A5" ), [ 9, 1, 0, -1, -1 ] ), ## Character( CharacterTable( "A5" ), ## [ 9, 1, 0, -E(5)-2*E(5)^2-2*E(5)^3-E(5)^4, ## -2*E(5)-E(5)^2-E(5)^3-2*E(5)^4 ] ) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "Tensored", [ IsHomogeneousList, IsHomogeneousList ] ); ############################################################################# ## ## 9. Restricted and Induced Class Functions ## ## <#GAPDoc Label="[7]{ctblfuns}"> ## For restricting a class function of a group G to a subgroup ## H and for inducing a class function of H to G, ## the class fusion from H to G must be known ## (see ). ##

## inflated class functions ## If F is the factor group of G by the normal subgroup ## N then each class function of F can be naturally regarded ## as a class function of G, with N in its kernel. ## For a class function of F, the corresponding class function of ## G is called the inflated class function. ## Restriction and inflation are in principle the same, ## namely indirection of a class function by the appropriate fusion map, ## and thus no extra operation is needed for this process. ## But note that contrary to the case of a subgroup fusion, the factor ## fusion can in general not be computed from the groups G and ## F; ## either one needs the natural homomorphism, or the factor fusion to the ## character table of F must be stored on the table of G. ## This explains the different syntax for computing restricted and inflated ## class functions. ##

## In the following, ## the meaning of the optional first argument tbl is the same as in ## Section . ## <#/GAPDoc> ## ############################################################################# ## #O RestrictedClassFunction( [, ], ) #O RestrictedClassFunction( [, ], ) #O RestrictedClassFunction( [, ], ) ## ## <#GAPDoc Label="RestrictedClassFunction"> ## ## ## ## ## Let chi be a class function of the group G, say, ## and let target be either a subgroup H of G ## or an injective homomorphism from H to G ## or the character table of H. ## Then returns the class function of ## H obtained by restricting chi to H. ##

## If chi is a class function of a factor group Gof ## H, where target is either the group H ## or a homomorphism from H to G ## or the character table of H ## then the restriction can be computed in the case of the homomorphism; ## in the other cases, this is possible only if the factor fusion from ## H to G is stored on the character table of H. ## ## ## <#/GAPDoc> ## DeclareOperation( "RestrictedClassFunction", [ IsClassFunction, IsGroup ] ); DeclareOperation( "RestrictedClassFunction", [ IsNearlyCharacterTable, IsHomogeneousList, IsGroup ] ); DeclareOperation( "RestrictedClassFunction", [ IsClassFunction, IsGeneralMapping ] ); DeclareOperation( "RestrictedClassFunction", [ IsNearlyCharacterTable, IsHomogeneousList, IsGeneralMapping ] ); DeclareOperation( "RestrictedClassFunction", [ IsClassFunction, IsNearlyCharacterTable ] ); DeclareOperation( "RestrictedClassFunction", [ IsNearlyCharacterTable, IsHomogeneousList, IsNearlyCharacterTable ] ); ############################################################################# ## #O RestrictedClassFunctions( [, ], ) #O RestrictedClassFunctions( [, ], ) #O RestrictedClassFunctions( [, ], ) ## ## <#GAPDoc Label="RestrictedClassFunctions"> ## ## ## ## ## is similar to ## , ## the only difference is that it takes a list chars of class ## functions instead of one class function, ## and returns the list of restricted class functions. ##

## a5:= CharacterTable( "A5" );; s5:= CharacterTable( "S5" );; ## gap> RestrictedClassFunction( Irr( s5 )[2], a5 ); ## Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ) ## gap> RestrictedClassFunctions( Irr( s5 ), a5 ); ## [ Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ), ## Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ), ## Character( CharacterTable( "A5" ), [ 6, -2, 0, 1, 1 ] ), ## Character( CharacterTable( "A5" ), [ 4, 0, 1, -1, -1 ] ), ## Character( CharacterTable( "A5" ), [ 4, 0, 1, -1, -1 ] ), ## Character( CharacterTable( "A5" ), [ 5, 1, -1, 0, 0 ] ), ## Character( CharacterTable( "A5" ), [ 5, 1, -1, 0, 0 ] ) ] ## gap> hom:= NaturalHomomorphismByNormalSubgroup( S4, der );; ## gap> RestrictedClassFunctions( Irr( Image( hom ) ), hom ); ## [ Character( CharacterTable( S4 ), [ 1, 1, 1, 1, 1 ] ), ## Character( CharacterTable( S4 ), [ 1, -1, 1, 1, -1 ] ) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "RestrictedClassFunctions", [ IsList, IsGroup ] ); DeclareOperation( "RestrictedClassFunctions", [ IsNearlyCharacterTable, IsList, IsGroup ] ); DeclareOperation( "RestrictedClassFunctions", [ IsList, IsGeneralMapping ] ); DeclareOperation( "RestrictedClassFunctions", [ IsNearlyCharacterTable, IsList, IsGeneralMapping ] ); DeclareOperation( "RestrictedClassFunctions", [ IsList, IsNearlyCharacterTable ] ); DeclareOperation( "RestrictedClassFunctions", [ IsNearlyCharacterTable, IsList, IsNearlyCharacterTable ] ); ############################################################################# ## #O Restricted( , , ) #O Restricted( , , , ) #O Restricted( , ) #O Restricted( [, ], ) #O Restricted( [, ], ) #O Restricted( [, ], ) #O Restricted( [, ], ) #O Restricted( [, ], ) #O Restricted( [, ], ) ## ## ## ## ## ## ## ## ## ## ## ## ## ## This is mainly for convenience and compatibility with &GAP; 3. ## ## ## DeclareOperation( "Restricted", [ IsObject, IsObject ] ); DeclareOperation( "Restricted", [ IsObject, IsObject, IsObject ] ); DeclareOperation( "Restricted", [ IsObject, IsObject, IsObject, IsObject ] ); DeclareSynonym( "Inflated", Restricted ); ############################################################################# ## #O InducedClassFunction( [, ], ) #O InducedClassFunction( [, ], ) #O InducedClassFunction( [, ], ) ## ## <#GAPDoc Label="InducedClassFunction"> ## ## InducedClassFunction ## ## ## ## ## ## Let chi be a class function of the group G, say, ## and let target be either a supergroup H of G ## or an injective homomorphism from H to G ## or the character table of H. ## Then ## returns the class function of H obtained by inducing chi ## to H. ## ## ## <#/GAPDoc> ## DeclareOperation( "InducedClassFunction", [ IsClassFunction, IsGroup ] ); DeclareOperation( "InducedClassFunction", [ IsNearlyCharacterTable, IsHomogeneousList, IsGroup ] ); DeclareOperation( "InducedClassFunction", [ IsClassFunction, IsGeneralMapping ] ); DeclareOperation( "InducedClassFunction", [ IsNearlyCharacterTable, IsHomogeneousList, IsGeneralMapping ] ); DeclareOperation( "InducedClassFunction", [ IsClassFunction, IsNearlyCharacterTable ] ); DeclareOperation( "InducedClassFunction", [ IsNearlyCharacterTable, IsHomogeneousList, IsNearlyCharacterTable ] ); ############################################################################# ## #O InducedClassFunctions( [, ], ) #O InducedClassFunctions( [, ], ) #O InducedClassFunctions( [, ], ) ## ## <#GAPDoc Label="InducedClassFunctions"> ## ## ## ## ## is similar to ## , ## the only difference is that it takes a list chars of class ## functions instead of one class function, ## and returns the list of induced class functions. ##

## InducedClassFunctions( Irr( a5 ), s5 ); ## [ Character( CharacterTable( "A5.2" ), [ 2, 2, 2, 2, 0, 0, 0 ] ), ## Character( CharacterTable( "A5.2" ), [ 6, -2, 0, 1, 0, 0, 0 ] ), ## Character( CharacterTable( "A5.2" ), [ 6, -2, 0, 1, 0, 0, 0 ] ), ## Character( CharacterTable( "A5.2" ), [ 8, 0, 2, -2, 0, 0, 0 ] ), ## Character( CharacterTable( "A5.2" ), [ 10, 2, -2, 0, 0, 0, 0 ] ) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "InducedClassFunctions", [ IsList, IsGroup ] ); DeclareOperation( "InducedClassFunctions", [ IsNearlyCharacterTable, IsList, IsGroup ] ); DeclareOperation( "InducedClassFunctions", [ IsList, IsGeneralMapping ] ); DeclareOperation( "InducedClassFunctions", [ IsNearlyCharacterTable, IsList, IsGeneralMapping ] ); DeclareOperation( "InducedClassFunctions", [ IsList, IsNearlyCharacterTable ] ); DeclareOperation( "InducedClassFunctions", [ IsNearlyCharacterTable, IsList, IsNearlyCharacterTable ] ); ############################################################################# ## #F InducedClassFunctionsByFusionMap( , , , ) ## ## <#GAPDoc Label="InducedClassFunctionsByFusionMap"> ## ## ## ## ## Let subtbl and tbl be two character tables of groups ## H and G, such that H is a subgroup of G, ## let chars be a list of class functions of subtbl, and ## let fusionmap be a fusion map from subtbl to tbl. ## The function returns the list of induced class functions of tbl ## that correspond to chars, w.r.t. the given fusion map. ##

## is the function that does ## the work for and ## . ##

## fus:= PossibleClassFusions( a5, s5 ); ## [ [ 1, 2, 3, 4, 4 ] ] ## gap> InducedClassFunctionsByFusionMap( a5, s5, Irr( a5 ), fus[1] ); ## [ Character( CharacterTable( "A5.2" ), [ 2, 2, 2, 2, 0, 0, 0 ] ), ## Character( CharacterTable( "A5.2" ), [ 6, -2, 0, 1, 0, 0, 0 ] ), ## Character( CharacterTable( "A5.2" ), [ 6, -2, 0, 1, 0, 0, 0 ] ), ## Character( CharacterTable( "A5.2" ), [ 8, 0, 2, -2, 0, 0, 0 ] ), ## Character( CharacterTable( "A5.2" ), [ 10, 2, -2, 0, 0, 0, 0 ] ) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "InducedClassFunctionsByFusionMap" ); ############################################################################# ## #O Induced( , , ) #O Induced( , , , ) #O Induced( , , , ) #O Induced( [, ], ) #O Induced( [, ], ) #O Induced( [, ], ) #O Induced( [, ], ) #O Induced( [, ], ) #O Induced( [, ], ) ## ## ## ## ## ## ## ## ## ## ## ## ## ## This is mainly for convenience and compatibility with &GAP; 3. ## ## ## DeclareOperation( "Induced", [ IsObject, IsObject ] ); DeclareOperation( "Induced", [ IsObject, IsObject, IsObject ] ); DeclareOperation( "Induced", [ IsObject, IsObject, IsObject, IsObject ] ); ############################################################################# ## #O InducedCyclic( [, ][, "all"] ) ## ## <#GAPDoc Label="InducedCyclic"> ## ## ## ## ## calculates characters induced up from ## cyclic subgroups of the ordinary character table tbl ## to tbl, and returns the strictly sorted list of the induced ## characters. ##

## If the string "all" is specified then all irreducible characters ## of these subgroups are induced, ## otherwise only the permutation characters are calculated. ##

## If a list classes is specified then only those cyclic subgroups ## generated by these classes are considered, ## otherwise all classes of tbl are considered. ##

## InducedCyclic( a5, "all" ); ## [ Character( CharacterTable( "A5" ), [ 12, 0, 0, 2, 2 ] ), ## Character( CharacterTable( "A5" ), ## [ 12, 0, 0, E(5)^2+E(5)^3, E(5)+E(5)^4 ] ), ## Character( CharacterTable( "A5" ), ## [ 12, 0, 0, E(5)+E(5)^4, E(5)^2+E(5)^3 ] ), ## Character( CharacterTable( "A5" ), [ 20, 0, -1, 0, 0 ] ), ## Character( CharacterTable( "A5" ), [ 20, 0, 2, 0, 0 ] ), ## Character( CharacterTable( "A5" ), [ 30, -2, 0, 0, 0 ] ), ## Character( CharacterTable( "A5" ), [ 30, 2, 0, 0, 0 ] ), ## Character( CharacterTable( "A5" ), [ 60, 0, 0, 0, 0 ] ) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "InducedCyclic", [ IsOrdinaryTable ] ); DeclareOperation( "InducedCyclic", [ IsOrdinaryTable, IsList ] ); DeclareOperation( "InducedCyclic", [ IsOrdinaryTable, IsList, IsString ] ); ############################################################################# ## ## 10. Reducing Virtual Characters ## ## <#GAPDoc Label="[8]{ctblfuns}"> ## The following operations are intended for the situation that one is ## given a list of virtual characters of a character table and is interested ## in the irreducible characters of this table. ## The idea is to compute virtual characters of small norm from the given ## ones, hoping to get eventually virtual characters of norm 1. ## <#/GAPDoc> ## ############################################################################# ## #O ReducedClassFunctions( [, ][, ] ) ## ## <#GAPDoc Label="ReducedClassFunctions"> ## ## ## ## ## Let reducibles be a list of ordinary virtual characters ## of the group G, say. ## If constituents is given then it must also be a list of ordinary ## virtual characters of G, ## otherwise we have constituents equal to reducibles ## in the following. ##

## returns a record with the components ## remainders and irreducibles, ## both lists of virtual characters of G. ## These virtual characters are computed as follows. ##

## Let rems be the set of nonzero class functions obtained by ## subtraction of ## ## \sum_{\chi} ( [reducibles[i], \chi] / [\chi, \chi] ) \cdot \chi ## ## from reducibles[i], ## where the summation runs over constituents ## and [\chi, \psi] denotes the scalar product of G-class ## functions. ## Let irrs be the list of irreducible characters in rems. ##

## We project rems into the orthogonal space of irrs and ## all those irreducibles found this way until no new irreducibles arise. ## Then the irreducibles list is the set of all found irreducible ## characters, and the remainders list is the set of all nonzero ## remainders. ## ## ## <#/GAPDoc> ## DeclareOperation( "ReducedClassFunctions", [ IsHomogeneousList, IsHomogeneousList ] ); DeclareOperation( "ReducedClassFunctions", [ IsOrdinaryTable, IsHomogeneousList, IsHomogeneousList ] ); DeclareOperation( "ReducedClassFunctions", [ IsHomogeneousList ] ); DeclareOperation( "ReducedClassFunctions", [ IsOrdinaryTable, IsHomogeneousList ] ); DeclareSynonym( "Reduced", ReducedClassFunctions ); ############################################################################# ## #O ReducedCharacters( [, ], ) ## ## <#GAPDoc Label="ReducedCharacters"> ## ## ## ## ## is similar to ## , ## the only difference is that constituents and reducibles ## are assumed to be lists of characters. ## This means that only those scalar products must be formed where the ## degree of the character in constituents does not exceed the degree ## of the character in reducibles. ##

## tbl:= CharacterTable( "A5" );; ## gap> chars:= Irr( tbl ){ [ 2 .. 4 ] };; ## gap> chars:= Set( Tensored( chars, chars ) );; ## gap> red:= ReducedClassFunctions( chars ); ## rec( ## irreducibles := ## [ Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ), ## Character( CharacterTable( "A5" ), ## [ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ] ), ## Character( CharacterTable( "A5" ), ## [ 3, -1, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ] ), ## Character( CharacterTable( "A5" ), [ 4, 0, 1, -1, -1 ] ), ## Character( CharacterTable( "A5" ), [ 5, 1, -1, 0, 0 ] ) ], ## remainders := [ ] ) ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "ReducedCharacters", [ IsHomogeneousList, IsHomogeneousList ] ); DeclareOperation( "ReducedCharacters", [ IsOrdinaryTable, IsHomogeneousList, IsHomogeneousList ] ); DeclareSynonym( "ReducedOrdinary", ReducedCharacters ); ############################################################################# ## #F IrreducibleDifferences( , , [, ] ) #F IrreducibleDifferences( , , "triangle"[, ] ) ## ## <#GAPDoc Label="IrreducibleDifferences"> ## ## ## ## ## returns the list of irreducible ## characters which occur as difference of an element of reducibles ## and an element of reducibles2, ## where these two arguments are lists of class functions of the character ## table tbl. ##

## If reducibles2 is the string "triangle" then the ## differences of elements in reducibles are considered. ##

## If scprmat is not specified then it will be calculated, ## otherwise we must have ## scprmat = ## MatScalarProducts( tbl, reducibles, reducibles2 ) ## or scprmat = ## MatScalarProducts( tbl, reducibles ), ## respectively. ##

## IrreducibleDifferences( a5, chars, "triangle" ); ## [ Character( CharacterTable( "A5" ), ## [ 3, -1, 0, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ] ), ## Character( CharacterTable( "A5" ), ## [ 3, -1, 0, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ] ) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "IrreducibleDifferences" ); ############################################################################# ## ## 11. Symmetrizations of Class Functions ## ############################################################################# ## #O Symmetrizations( [, ], ) ## ## <#GAPDoc Label="Symmetrizations"> ## ## ## ## ## characters ## returns the list of symmetrizations ## of the characters characters of the ordinary character table ## tbl with the ordinary irreducible characters of the symmetric ## group of degree n; ## instead of the integer n, ## the character table of the symmetric group can be entered. ##

## The symmetrization \chi^{[\lambda]} of the character \chi ## of tbl with the character \lambda of the symmetric group ## S_n of degree n is defined by ## ## \chi^{[\lambda]}(g) = \left( \sum_{{\rho \in S_n}} ## \lambda(\rho) \prod_{{k=1}}^n \chi(g^k)^{{a_k(\rho)}} \right) / n! , ## ## where a_k(\rho) is the number of cycles of length k ## in \rho. ##

## For special kinds of symmetrizations, ## see , , ## and , ## . ##

## Note that the returned list may contain zero class functions, ## and duplicates are not deleted. ## ##

## tbl:= CharacterTable( "A5" );; ## gap> Symmetrizations( Irr( tbl ){ [ 1 .. 3 ] }, 3 ); ## [ VirtualCharacter( CharacterTable( "A5" ), [ 0, 0, 0, 0, 0 ] ), ## VirtualCharacter( CharacterTable( "A5" ), [ 0, 0, 0, 0, 0 ] ), ## Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ), ## Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ), ## Character( CharacterTable( "A5" ), ## [ 8, 0, -1, -E(5)-E(5)^4, -E(5)^2-E(5)^3 ] ), ## Character( CharacterTable( "A5" ), [ 10, -2, 1, 0, 0 ] ), ## Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ), ## Character( CharacterTable( "A5" ), ## [ 8, 0, -1, -E(5)^2-E(5)^3, -E(5)-E(5)^4 ] ), ## Character( CharacterTable( "A5" ), [ 10, -2, 1, 0, 0 ] ) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "Symmetrizations", [ IsNearlyCharacterTable, IsHomogeneousList, IsInt ] ); DeclareOperation( "Symmetrizations", [ IsNearlyCharacterTable, IsHomogeneousList, IsCharacterTable ] ); DeclareOperation( "Symmetrizations", [ IsHomogeneousList, IsInt ] ); DeclareOperation( "Symmetrizations", [ IsHomogeneousList, IsCharacterTable ] ); DeclareSynonym( "Symmetrisations", Symmetrizations ); ############################################################################# ## #F SymmetricParts( , , ) ## ## <#GAPDoc Label="SymmetricParts"> ## ## ## ## ## symmetric power ## is the list of symmetrizations of the characters characters ## of the character table tbl with the trivial character of ## the symmetric group of degree n ## (see ). ##

## SymmetricParts( tbl, Irr( tbl ), 3 ); ## [ Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ), ## Character( CharacterTable( "A5" ), [ 10, -2, 1, 0, 0 ] ), ## Character( CharacterTable( "A5" ), [ 10, -2, 1, 0, 0 ] ), ## Character( CharacterTable( "A5" ), [ 20, 0, 2, 0, 0 ] ), ## Character( CharacterTable( "A5" ), [ 35, 3, 2, 0, 0 ] ) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "SymmetricParts" ); ############################################################################# ## #F AntiSymmetricParts( , , ) ## ## <#GAPDoc Label="AntiSymmetricParts"> ## ## ## ## ## exterior power ## is the list of symmetrizations of the characters characters ## of the character table tbl with the alternating character of ## the symmetric group of degree n ## (see ). ##

## AntiSymmetricParts( tbl, Irr( tbl ), 3 ); ## [ VirtualCharacter( CharacterTable( "A5" ), [ 0, 0, 0, 0, 0 ] ), ## Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ), ## Character( CharacterTable( "A5" ), [ 1, 1, 1, 1, 1 ] ), ## Character( CharacterTable( "A5" ), [ 4, 0, 1, -1, -1 ] ), ## Character( CharacterTable( "A5" ), [ 10, -2, 1, 0, 0 ] ) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "AntiSymmetricParts" ); ############################################################################# ## #F RefinedSymmetrizations( , , , ) ## ## ## ## ## ## is the list of Murnaghan components for orthogonal ## ('func(x,y)=x', see ) ## or symplectic ## ('func(x,y)=x-y', see ) ## symmetrizations. ## ## ## DeclareGlobalFunction( "RefinedSymmetrizations" ); DeclareSynonym( "RefinedSymmetrisations", RefinedSymmetrizations ); ############################################################################# ## #F OrthogonalComponents( , , ) ## ## <#GAPDoc Label="OrthogonalComponents"> ## ## ## ## ## symmetrizations ## Frame ## Murnaghan components ## If \chi is a nonlinear character with indicator +1, ## a splitting of the tensor power \chi^m is given by the so-called ## Murnaghan functions (see ). ## These components in general have fewer irreducible constituents ## than the symmetrizations with the symmetric group of degree m ## (see ). ##

## returns the Murnaghan components ## of the nonlinear characters of the character table tbl ## in the list chars up to the power m, ## where m is an integer between 2 and 6. ##

## The Murnaghan functions are implemented as in . ##

## Note: ## If chars is a list of character objects ## (see ) then also ## the result consists of class function objects. ## It is not checked whether all characters in chars do really have ## indicator +1; ## if there are characters with indicator 0 or -1, ## the result might contain virtual characters ## (see also ), ## therefore the entries of the result do in general not know that they are ## characters. ##

## tbl:= CharacterTable( "A8" );; chi:= Irr( tbl )[2]; ## Character( CharacterTable( "A8" ), [ 7, -1, 3, 4, 1, -1, 1, 2, 0, -1, ## 0, 0, -1, -1 ] ) ## gap> OrthogonalComponents( tbl, [ chi ], 3 ); ## [ ClassFunction( CharacterTable( "A8" ), ## [ 21, -3, 1, 6, 0, 1, -1, 1, -2, 0, 0, 0, 1, 1 ] ), ## ClassFunction( CharacterTable( "A8" ), ## [ 27, 3, 7, 9, 0, -1, 1, 2, 1, 0, -1, -1, -1, -1 ] ), ## ClassFunction( CharacterTable( "A8" ), ## [ 105, 1, 5, 15, -3, 1, -1, 0, -1, 1, 0, 0, 0, 0 ] ), ## ClassFunction( CharacterTable( "A8" ), ## [ 35, 3, -5, 5, 2, -1, -1, 0, 1, 0, 0, 0, 0, 0 ] ), ## ClassFunction( CharacterTable( "A8" ), ## [ 77, -3, 13, 17, 2, 1, 1, 2, 1, 0, 0, 0, 2, 2 ] ) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "OrthogonalComponents" ); ############################################################################# ## #F SymplecticComponents( , , ) ## ## <#GAPDoc Label="SymplecticComponents"> ## ## ## ## ## symmetrizations ## Murnaghan components ## If \chi is a (nonlinear) character with indicator -1, ## a splitting of the tensor power \chi^m is given in terms of the ## so-called Murnaghan functions (see ). ## These components in general have fewer irreducible constituents ## than the symmetrizations with the symmetric group of degree m ## (see ). ##

## returns the symplectic symmetrizations ## of the nonlinear characters of the character table tbl ## in the list chars up to the power m, ## where m is an integer between 2 and 5. ##

## Note: ## If chars is a list of character objects ## (see ) then also ## the result consists of class function objects. ## It is not checked whether all characters in chars do really have ## indicator -1; ## if there are characters with indicator 0 or +1, ## the result might contain virtual characters ## (see also ), ## therefore the entries of the result do in general not know that they are ## characters. ##

## tbl:= CharacterTable( "U3(3)" );; chi:= Irr( tbl )[2]; ## Character( CharacterTable( "U3(3)" ), ## [ 6, -2, -3, 0, -2, -2, 2, 1, -1, -1, 0, 0, 1, 1 ] ) ## gap> SymplecticComponents( tbl, [ chi ], 3 ); ## [ ClassFunction( CharacterTable( "U3(3)" ), ## [ 14, -2, 5, -1, 2, 2, 2, 1, 0, 0, 0, 0, -1, -1 ] ), ## ClassFunction( CharacterTable( "U3(3)" ), ## [ 21, 5, 3, 0, 1, 1, 1, -1, 0, 0, -1, -1, 1, 1 ] ), ## ClassFunction( CharacterTable( "U3(3)" ), ## [ 64, 0, -8, -2, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0 ] ), ## ClassFunction( CharacterTable( "U3(3)" ), ## [ 14, 6, -4, 2, -2, -2, 2, 0, 0, 0, 0, 0, -2, -2 ] ), ## ClassFunction( CharacterTable( "U3(3)" ), ## [ 56, -8, 2, 2, 0, 0, 0, -2, 0, 0, 0, 0, 0, 0 ] ) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "SymplecticComponents" ); ############################################################################# ## ## 12. Operations for Brauer Characters ## ############################################################################# ## #F FrobeniusCharacterValue( ,

) ## ## <#GAPDoc Label="FrobeniusCharacterValue"> ## ## ## ## ## Let value be a cyclotomic whose coefficients over the rationals ## are in the ring &ZZ;_{p} of p-local numbers, ## where p is a prime integer. ## Assume that value lies in &ZZ;_{p}[\zeta] ## for \zeta = \exp(p^n-1), ## for some positive integer n. ##

## returns the image of value ## under the ring homomorphism from &ZZ;_{p}[\zeta] ## to the field with p^n elements ## that is defined with the help of Conway polynomials ## (see ), more information can be found ## in . ##

## If value is a Brauer character value in characteristic p ## then the result can be described as the corresponding value of the ## Frobenius character, that is, as the trace of a representing matrix ## with the given Brauer character value. ##

## If the result of cannot be ## expressed as an element of a finite field in &GAP; ## (see Chapter ) ## then returns fail. ##

## If the Conway polynomial of degree n is required for the ## computation then it is computed only if ## returns true when it is ## called with p and n, ## otherwise fail is returned. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "FrobeniusCharacterValue" ); ############################################################################## ## #F ReductionToFiniteField( ,

) ## ## If this function shall become documented, this can be done in the manual ## section for FrobeniusCharacterValue. ## ## ## ## ## Let value be a cyclotomic whose coefficients over the rationals ## are in the ring &ZZ;_{p} of p-local numbers, ## where p is a prime integer. ## returns a pair [ pol, m ] ## where pol is a polynomial over the field with p elements ## and m is an integer such that the field with p^m ## elements is the minimal field that contains the reduction under the ring ## homomorphism defined above. ## The reduction of value is represented by pol modulo ## the ideal spanned by the Conway polynomial ## (see ) of degree m. ##

## fail is returned if ... ## ## DeclareGlobalFunction( "ReductionToFiniteField" ); ############################################################################# ## #A BrauerCharacterValue( ) ## ## <#GAPDoc Label="BrauerCharacterValue"> ## ## ## ## ## For an invertible matrix mat over a finite field F, ## returns the Brauer character value ## of mat if the order of mat is coprime to the characteristic ## of F, and fail otherwise. ##

## The Brauer character value of a matrix is the sum of complex lifts ## of its eigenvalues. ##

## g:= SL(2,4);; # 2-dim. irreducible representation of A5 ## gap> ccl:= ConjugacyClasses( g );; ## gap> rep:= List( ccl, Representative );; ## gap> List( rep, Order ); ## [ 1, 2, 5, 5, 3 ] ## gap> phi:= List( rep, BrauerCharacterValue ); ## [ 2, fail, E(5)^2+E(5)^3, E(5)+E(5)^4, -1 ] ## gap> List( phi{ [ 1, 3, 4, 5 ] }, x -> FrobeniusCharacterValue( x, 2 ) ); ## [ 0*Z(2), Z(2^2), Z(2^2)^2, Z(2)^0 ] ## gap> List( rep{ [ 1, 3, 4, 5 ] }, TraceMat ); ## [ 0*Z(2), Z(2^2), Z(2^2)^2, Z(2)^0 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "BrauerCharacterValue", IsMatrix ); ############################################################################# ## #V ZEV_DATA #F ZevData( , [, ] ) #F ZevDataValue( , ) ## ## ## ## ## ## ## ## These variables are used for a database that speeds up the computation of ## Brauer character values. ##

## ZEV_DATA is a list of length 2, at position 1 storing a list of ## prime powers q, and at position 2 a corresponding list of lists l. ## For given q, the list l is again a list of length 2, ## at position 1 storing a list of positive integers n, at position 2 ## a corresponding list of lists, the entry for fixed (q and) n being ## a list of pairs [ c, y ] as needed by ZevData. ##

## For a prime power q and a positive integer n, ZevData returns ## a list of pairs [ c, y ] where c is the coefficient list of a ## polynomial f over the field F with q elements, ## and y a complex value. ## These pairs are used to compute Brauer character values of matrices M ## over F, of order n; ## a d-dimensional nullspace of the matrix obtained by evaluating f at ## M contributes the summand y with multiplicity d / Degree( f ). ##

## ZevData checks whether the required data are already stored in the ## global list ZEV_DATA; ## if not then ZevDataValue is called, which does the real work. ##

## Called with three arguments, ZevData stores the third argument in the ## global list ZEV_DATA, at the position where the call with the first two ## arguments will fetch it. ##

## (The names of these functions reflect that the corresponding command in ## the C-&MeatAxe; is zev.) ## ## ## DeclareGlobalVariable( "ZEV_DATA", "nested list of length 2" ); DeclareGlobalFunction( "ZevData" ); DeclareGlobalFunction( "ZevDataValue" ); ############################################################################# ## #F SizeOfFieldOfDefinition( ,

) ## ## <#GAPDoc Label="SizeOfFieldOfDefinition"> ## ## ## ## ## For a cyclotomic or a list of cyclotomics val, ## and a prime integer p, ## returns the size of the smallest finite field ## in characteristic p that contains the p-modular reduction ## of val. ##

## The reduction map is defined as in , ## that is, the complex (p^d-1)-th root of unity ## \exp(p^d-1) is mapped to the residue class of the ## indeterminate, modulo the ideal spanned by the Conway polynomial ## (see ) of degree d over the ## field with p elements. ##

## If val is a Brauer character then the value returned is the size ## of the smallest finite field in characteristic p over which the ## corresponding representation lives. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "SizeOfFieldOfDefinition" ); ############################################################################# ## #F RealizableBrauerCharacters( , ) ## ## <#GAPDoc Label="RealizableBrauerCharacters"> ## ## ## ## ## For a list matrix of absolutely irreducible Brauer characters ## in characteristic p, and a power q of p, ## returns a duplicate-free list of ## sums of Frobenius conjugates of the rows of matrix, ## each irreducible over the field with q elements. ##

## irr:= Irr( CharacterTable( "A5" ) mod 2 ); ## [ Character( BrauerTable( "A5", 2 ), [ 1, 1, 1, 1 ] ), ## Character( BrauerTable( "A5", 2 ), ## [ 2, -1, E(5)+E(5)^4, E(5)^2+E(5)^3 ] ), ## Character( BrauerTable( "A5", 2 ), ## [ 2, -1, E(5)^2+E(5)^3, E(5)+E(5)^4 ] ), ## Character( BrauerTable( "A5", 2 ), [ 4, 1, -1, -1 ] ) ] ## gap> List( irr, phi -> SizeOfFieldOfDefinition( phi, 2 ) ); ## [ 2, 4, 4, 2 ] ## gap> RealizableBrauerCharacters( irr, 2 ); ## [ Character( BrauerTable( "A5", 2 ), [ 1, 1, 1, 1 ] ), ## ClassFunction( BrauerTable( "A5", 2 ), [ 4, -2, -1, -1 ] ), ## Character( BrauerTable( "A5", 2 ), [ 4, 1, -1, -1 ] ) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "RealizableBrauerCharacters" ); ############################################################################# ## ## 13. Domains Generated by Class Functions ## ## <#GAPDoc Label="[9]{ctblfuns}"> ## &GAP; supports groups, vector spaces, and algebras generated by class ## functions. ## ## <#/GAPDoc> ## ############################################################################# ## #F IsClassFunctionsSpace( ) ## ## ## ## ## ## If an F-vector space V is in the filter ## then this expresses that V ## consists of class functions, and that V is ## handled via the mechanism of nice bases (see ), ## in the following way. ## Let T be the underlying character table of the elements of V. ## Then the NiceFreeLeftModuleInfo value of V is T, ## and the NiceVector value of v \in V is defined as ## ValueOfClassFunction( v ). ## ## ## DeclareHandlingByNiceBasis( "IsClassFunctionsSpace", "for free left modules of class functions" ); ############################################################################# ## ## 14. Auxiliary operations ## ############################################################################## ## #F OrbitChar( , ) ## ## ## ## ## ## is the orbit of the character values list chi under the action of ## Galois automorphisms and multiplication with the linear characters in ## the list linear. ##

## It is assumed that linear is closed under Galois automorphisms and ## tensoring. ## (This means that we can first form the orbit under Galois action, and ## then apply the linear characters to all Galois conjugates.) ## ## ## DeclareGlobalFunction( "OrbitChar" ); ############################################################################## ## #F OrbitsCharacters( ) ## ## ## ## ## ## is a list of orbits of the characters in the list chars ## under the action of Galois automorphisms ## and multiplication with the linear characters in chars. ##

## (Note that the image of an ordinary character under a Galois automorphism ## is always a character; this is in general not true for Brauer characters.) ## ## ## DeclareGlobalFunction( "OrbitsCharacters" ); ############################################################################## ## #F OrbitRepresentativesCharacters( ) ## ## ## ## ## ## is a list of representatives of the orbits of the characters irr ## under the action of Galois automorphisms and multiplication with linear ## characters. ## ## ## DeclareGlobalFunction( "OrbitRepresentativesCharacters" ); #T where to put the following two functions? ############################################################################# ## #F CollapsedMat( , ) ## ## <#GAPDoc Label="CollapsedMat"> ## ## ## ## ## is a record with the components ##

## ## fusion ## ## fusion that collapses those columns of mat that are equal in ## mat and also for all maps in the list maps, ## ## mat ## ## the image of mat under that fusion. ## ## ##

## mat:= [ [ 1, 1, 1, 1 ], [ 2, -1, 0, 0 ], [ 4, 4, 1, 1 ] ];; ## gap> coll:= CollapsedMat( mat, [] ); ## rec( fusion := [ 1, 2, 3, 3 ], ## mat := [ [ 1, 1, 1 ], [ 2, -1, 0 ], [ 4, 4, 1 ] ] ) ## gap> List( last.mat, x -> x{ last.fusion } ) = mat; ## true ## gap> coll:= CollapsedMat( mat, [ [ 1, 1, 1, 2 ] ] ); ## rec( fusion := [ 1, 2, 3, 4 ], ## mat := [ [ 1, 1, 1, 1 ], [ 2, -1, 0, 0 ], [ 4, 4, 1, 1 ] ] ) ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "CollapsedMat" ); ############################################################################# ## #F CharacterTableQuaternionic( <4n> ) ## ## ## ## ## ## is the ordinary character table of the generalized quaternion group ## of order 4n. ## ## ## DeclareGlobalFunction( "CharacterTableQuaternionic" ); ############################################################################# ## #E gap-4r6p5/lib/memory.gd0000644000175000017500000000213012172557252013527 0ustar billbill############################################################################# ## ## memory.gd recog package Max Neunhöffer ## Ákos Seress ## ## Copyright 2005 Lehrstuhl D für Mathematik, RWTH Aachen ## ## Group objects remembering how they were created from the generators. ## ############################################################################# DeclareFilter("IsObjWithMemoryRankFilter",100); DeclareRepresentation("IsObjWithMemory", IsComponentObjectRep and IsObjWithMemoryRankFilter and IsMultiplicativeElementWithInverse, ["slp","n","el"]); DeclareAttribute("TypeOfObjWithMemory",IsFamily); DeclareGlobalFunction( "GeneratorsWithMemory" ); DeclareOperation( "StripMemory", [IsObject] ); DeclareOperation( "ForgetMemory", [IsObject] ); DeclareGlobalFunction( "StripStabChain" ); DeclareGlobalFunction( "CopyMemory" ); DeclareGlobalFunction( "GroupWithMemory" ); DeclareGlobalFunction( "SLPOfElm" ); DeclareGlobalFunction( "SLPOfElms" ); DeclareGlobalFunction( "SortFunctionWithMemory" ); gap-4r6p5/lib/monoid.gi0000644000175000017500000001577712172557252013536 0ustar billbill############################################################################# ## #W monoid.gi GAP library Thomas Breuer ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains generic methods for monoids. ## ############################################################################# ## #M PrintObj( ) . . . . . . . . . . . . . . . . . . . . . print a monoid ## InstallMethod( PrintObj, "for monoid", true, [ IsMonoid ], 0, function( M ) Print( "Monoid( ... )" ); end ); InstallMethod( String, "for monoid", true, [ IsMonoid ], 0, function( M ) return "Monoid( ... )"; end ); InstallMethod( PrintObj, "for monoid with known generators", true, [ IsMonoid and HasGeneratorsOfMonoid ], 0, function( M ) Print( "Monoid( ", GeneratorsOfMagmaWithOne( M ), ", ... )" ); end ); InstallMethod( String, "for monoid with known generators", true, [ IsMonoid and HasGeneratorsOfMonoid ], 0, function( M ) return STRINGIFY( "Monoid( ", GeneratorsOfMagmaWithOne( M ), ", ... )" ); end ); InstallMethod( PrintString, "for monoid with known generators", true, [ IsMonoid and HasGeneratorsOfMonoid ], 0, function( M ) return PRINT_STRINGIFY( "Monoid( ", GeneratorsOfMagmaWithOne( M ), ", ... )" ); end ); ############################################################################# ## #M ViewObj( ) . . . . . . . . . . . . . . . . . . . . . . view a monoid ## InstallMethod( ViewObj, "for a monoid", true, [ IsMonoid ], 0, function( M ) Print( "" ); end ); InstallMethod( ViewObj, "for a monoid with generators", true, [ IsMonoid and HasGeneratorsOfMagmaWithOne ], 0, function( M ) if IsEmpty( GeneratorsOfMagmaWithOne( M ) ) then Print( "" ); elif Length(GeneratorsOfMagmaWithOne(M)) = 1 then Print( "" ); else Print( "" ); fi; end ); ############################################################################# ## #M MonoidByGenerators( ) . . . . . . . . monoid generated by ## InstallOtherMethod( MonoidByGenerators, "for a collection", true, [ IsCollection ] , 0, function( gens ) local M; M:= Objectify( NewType( FamilyObj( gens ), IsMonoid and IsAttributeStoringRep ), rec() ); SetGeneratorsOfMagmaWithOne( M, AsList( gens ) ); return M; end ); InstallOtherMethod( MonoidByGenerators, "for collection and identity", IsCollsElms, [ IsCollection, IsMultiplicativeElementWithOne ], 0, function( gens, id ) local M; M:= Objectify( NewType( FamilyObj( gens ), IsMonoid and IsAttributeStoringRep ), rec() ); SetGeneratorsOfMagmaWithOne( M, AsList( gens ) ); SetOne( M, Immutable( id ) ); return M; end ); InstallOtherMethod( MonoidByGenerators, "for empty collection and identity", true, [ IsEmpty, IsMultiplicativeElementWithOne ], 0, function( gens, id ) local M; M:= Objectify( NewType( CollectionsFamily( FamilyObj( id ) ), IsMonoid and IsTrivial and IsAttributeStoringRep ), rec() ); SetGeneratorsOfMagmaWithOne( M, AsList( gens ) ); SetOne( M, Immutable( id ) ); return M; end ); InstallImmediateMethod( GeneratorsOfSemigroup, IsMonoid and HasGeneratorsOfMonoid and IsAttributeStoringRep, 0, M->Concatenation([One(M)],GeneratorsOfMonoid(M))); ############################################################################# ## #M AsMonoid( ) . . . . . . . . . . . . . . domain , viewed as monoid ## InstallMethod( AsMonoid, "for a monoid", true, [ IsMonoid ], 100, IdFunc ); InstallMethod( AsMonoid, "generic method for a collection", true, [ IsCollection ], 0, function ( D ) local M, L; D := AsSSortedList( D ); L := ShallowCopy( D ); M := TrivialSubmagmaWithOne( MonoidByGenerators( D ) ); SubtractSet( L, AsSSortedList( M ) ); while not IsEmpty(L) do M := ClosureMagmaDefault( M, L[1] ); SubtractSet( L, AsSSortedList( M ) ); od; if Length( AsSSortedList( M ) ) <> Length( D ) then return fail; fi; M := MonoidByGenerators( GeneratorsOfMonoid( M ), One( D[1] ) ); SetAsSSortedList( M, D ); SetIsFinite( M, true ); SetSize( M, Length( D ) ); # return the monoid return M; end ); ############################################################################# ## #M AsSubmonoid( , ) ## InstallMethod( AsSubmonoid, "generic method for a domain and a collection", IsIdenticalObj, [ IsDomain, IsCollection ], 0, function( G, U ) local S; if not IsSubset( G, U ) then return fail; fi; if IsMagmaWithOne( U ) then if not IsAssociative( U ) then return fail; fi; S:= SubmonoidNC( G, GeneratorsOfMagmaWithOne( U ) ); else S:= SubmagmaWithOneNC( G, AsList( U ) ); if not IsAssociative( S ) then return fail; fi; fi; UseIsomorphismRelation( U, S ); UseSubsetRelation( U, S ); return S; end ); ############################################################################# ## #M IsCommutative( ) . . . . . . . . . . test if a monoid is commutative ## InstallMethod( IsCommutative, "for associative magma-with-one", true, [ IsMagmaWithOne and IsAssociative ], 0, IsCommutativeFromGenerators( GeneratorsOfMagmaWithOne ) ); ############################################################################# ## #F Monoid( , ... ) #F Monoid( ) #F Monoid( , ) ## InstallGlobalFunction( Monoid, function( arg ) # special case for matrices, because they may look like lists if Length( arg ) = 1 and IsMatrix( arg[1] ) then return MonoidByGenerators( [ arg[1] ] ); # special case for matrices, because they look like lists elif Length( arg ) = 2 and IsMatrix( arg[1] ) then return MonoidByGenerators( arg ); # list of generators elif Length( arg ) = 1 and IsList( arg[1] ) and 0 < Length( arg[1] ) then return MonoidByGenerators( arg[1] ); # list of generators plus identity elif Length( arg ) = 2 and IsList( arg[1] ) then return MonoidByGenerators( arg[1], arg[2] ); # generators elif 0 < Length( arg ) then return MonoidByGenerators( arg ); # no argument given, error else Error("usage: Monoid(,...), Monoid(), Monoid()"); fi; end ); ############################################################################# ## #E gap-4r6p5/lib/grp.gd0000644000175000017500000042033612172557252013023 0ustar billbill############################################################################# ## #W grp.gd GAP library Thomas Breuer #W & Frank Celler #W & Bettina Eick #W & Heiko Theißen ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the declarations of operations for groups. ## ############################################################################# ## ## <#GAPDoc Label="[1]{grp}"> ## Unless explicitly declared otherwise, all subgroup series are descending. ## That is they are stored in decreasing order. ## <#/GAPDoc> ## ## <#GAPDoc Label="[2]{grp}"> ## If a group U is created as a subgroup of another group G, ## G becomes the parent of U. ## There is no universal parent group, ## parent-child chains can be arbitrary long. ## &GAP; stores the result of some operations ## (such as ) ## with the parent as an attribute. ## <#/GAPDoc> ## ############################################################################# ## #V InfoGroup ## ## <#GAPDoc Label="InfoGroup"> ## ## ## ## ## is the info class for the generic group theoretic functions ## (see ). ## ## ## <#/GAPDoc> ## DeclareInfoClass( "InfoGroup" ); ############################################################################# ## #C IsGroup( ) ## ## <#GAPDoc Label="IsGroup"> ## ## ## ## ## A group is a magma-with-inverses (see ) ## and associative (see ) multiplication. ##

## IsGroup tests whether the object obj fulfills these conditions, ## it does not test whether obj is a set of elements that forms a group ## under multiplication; ## use if you want to perform such a test. ## (See  for details about categories.) ## IsGroup(g); ## true ## ]]> ## ## ## <#/GAPDoc> ## DeclareSynonym( "IsGroup", IsMagmaWithInverses and IsAssociative ); InstallTrueMethod( IsFiniteOrderElementCollection, IsGroup and IsFinite ); ############################################################################# ## #A GeneratorsOfGroup( ) ## ## <#GAPDoc Label="GeneratorsOfGroup"> ## ## ## ## ## returns a list of generators of the group G. ## If G has been created by the command ## with argument gens, ## then the list returned by ## will be equal to gens. For such a group, each generator ## can also be accessed using the . operator ## (see ): for a positive integer ## i, G.i returns the i-th element of ## the list returned by . Moreover, ## if G is a free group, and name is the name of a ## generator of G then G.name also returns ## this generator. ## g:=GroupWithGenerators([(1,2,3,4),(1,2)]); ## Group([ (1,2,3,4), (1,2) ]) ## gap> GeneratorsOfGroup(g); ## [ (1,2,3,4), (1,2) ] ## ]]> ##

## While in this example &GAP; displays the group via the generating set ## stored in the attribute , ## the methods installed for will in general display only ## some information about the group which may even be just the fact that it ## is a group. ## ## ## <#/GAPDoc> ## DeclareSynonymAttr( "GeneratorsOfGroup", GeneratorsOfMagmaWithInverses ); ############################################################################# ## #O GroupString( , ) ## ## ## ## ## ## returns a short string (usually less than one line) with information ## about the group G. name is a display name if the group G does ## not have one. ## ## ## DeclareOperation( "GroupString", [IsGroup,IsString] ); ############################################################################# ## #A NameIsomorphismClass( ) . . . . . . . . . . . . . . . . experimental ## ## ## ## ## ## ## ## DeclareAttribute( "NameIsomorphismClass", IsGroup ); ############################################################################# ## #P IsCyclic( ) ## ## <#GAPDoc Label="IsCyclic"> ## ## ## ## ## A group is cyclic if it can be generated by one element. ## For a cyclic group, one can compute a generating set consisting of only ## one element using . ## ## ## <#/GAPDoc> ## DeclareProperty( "IsCyclic", IsGroup ); InstallSubsetMaintenance( IsCyclic, IsGroup and IsCyclic, IsGroup ); InstallFactorMaintenance( IsCyclic, IsGroup and IsCyclic, IsObject, IsGroup ); InstallTrueMethod( IsCyclic, IsGroup and IsTrivial ); InstallTrueMethod( IsCommutative, IsGroup and IsCyclic ); ############################################################################# ## #P IsElementaryAbelian( ) ## ## <#GAPDoc Label="IsElementaryAbelian"> ## ## ## ## ## A group G is elementary abelian if it is commutative and if there is a ## prime p such that the order of each element in G divides p. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsElementaryAbelian", IsGroup ); InstallSubsetMaintenance( IsElementaryAbelian, IsGroup and IsElementaryAbelian, IsGroup ); InstallFactorMaintenance( IsElementaryAbelian, IsGroup and IsElementaryAbelian, IsObject, IsGroup ); InstallTrueMethod( IsElementaryAbelian, IsGroup and IsTrivial ); InstallTrueMethod( IsCommutative, IsGroup and IsElementaryAbelian ); ############################################################################# ## #P IsFinitelyGeneratedGroup( ) ## ## <#GAPDoc Label="IsFinitelyGeneratedGroup"> ## ## ## ## ## tests whether the group G can be generated by a finite number of ## generators. (This property is mainly used to obtain finiteness ## conditions.) ##

## Note that this is a pure existence statement. Even if a group is known ## to be generated by a finite number of elements, it can be very hard or ## even impossible to obtain such a generating set if it is not known. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsFinitelyGeneratedGroup", IsGroup ); InstallFactorMaintenance( IsFinitelyGeneratedGroup, IsGroup and IsFinitelyGeneratedGroup, IsObject, IsGroup ); InstallTrueMethod( IsFinitelyGeneratedGroup, IsGroup and IsFinite ); ############################################################################# ## #P IsSubsetLocallyFiniteGroup() . . . . test if a group is locally finite ## ## <#GAPDoc Label="IsSubsetLocallyFiniteGroup"> ## ## ## ## ## A group is called locally finite if every finitely generated subgroup is ## finite. This property checks whether the group U is a subset of a ## locally finite group. This is used to check whether finite generation ## will imply finiteness, as it does for example for permutation groups. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsSubsetLocallyFiniteGroup", IsGroup ); # this true method will enforce that many groups are finite, which is needed # implicitly InstallTrueMethod( IsFinite, IsFinitelyGeneratedGroup and IsGroup and IsSubsetLocallyFiniteGroup ); InstallTrueMethod( IsSubsetLocallyFiniteGroup, IsFinite and IsGroup ); InstallSubsetMaintenance( IsSubsetLocallyFiniteGroup, IsGroup and IsSubsetLocallyFiniteGroup, IsGroup ); ############################################################################# ## #M IsSubsetLocallyFiniteGroup( ) . . . . . . . . . . for magmas of FFEs ## InstallTrueMethod( IsSubsetLocallyFiniteGroup, IsFFECollection and IsMagma ); ############################################################################# ## ## <#GAPDoc Label="[3]{grp}"> ## The following filters and operations indicate capabilities of &GAP;. ## They can be used in the method selection or algorithms to check whether ## it is feasible to compute certain operations for a given group. ## In general, they return true if good algorithms for the given arguments ## are available in &GAP;. ## An answer false indicates that no method for this group may exist, ## or that the existing methods might run into problems. ##

## Typical examples when this might happen is with finitely presented ## groups, for which many of the methods cannot be guaranteed to succeed in ## all situations. ##

## The willingness of &GAP; to perform certain operations may change, ## depending on which further information is known about the arguments. ## Therefore the filters used are not implemented as properties but as ## other filters (see  and ). ## <#/GAPDoc> ## ############################################################################# ## #F CanEasilyTestMembership( ) ## ## <#GAPDoc Label="CanEasilyTestMembership"> ## ## ## ## ## This filter indicates whether &GAP; can test membership of elements in ## the group G ## (via the operation ) ## in reasonable time. ## It is used by the method selection to decide whether an algorithm ## that relies on membership tests may be used. ## ## ## <#/GAPDoc> ## DeclareFilter( "CanEasilyTestMembership" ); ############################################################################# ## #F CanEasilyComputeWithIndependentGensAbelianGroup( ) ## ## <#GAPDoc Label="CanEasilyComputeWithIndependentGensAbelianGroup"> ## ## ## ## ## This filter indicates whether &GAP; can in reasonable time compute ## independent abelian generators of the group G ## (via ) and ## then can decompose arbitrary group elements with respect to these ## generators using . ## ## It is used by the method selection to decide whether an algorithm ## that relies on these two operations may be used. ## ## ## <#/GAPDoc> ## DeclareFilter( "CanEasilyComputeWithIndependentGensAbelianGroup" ); ############################################################################# ## #F CanComputeSizeAnySubgroup( ) ## ## <#GAPDoc Label="CanComputeSizeAnySubgroup"> ## ## ## ## ## This filter indicates whether &GAP; can easily compute the size of any ## subgroup of the group G. ## (This is for example advantageous if one can test that a stabilizer index ## equals the length of the orbit computed so far to stop early.) ## ## ## <#/GAPDoc> ## DeclareFilter( "CanComputeSizeAnySubgroup" ); InstallTrueMethod(CanEasilyTestMembership, IsFinite and CanComputeSizeAnySubgroup); InstallTrueMethod(CanComputeSize,CanComputeSizeAnySubgroup); InstallTrueMethod( CanComputeSize, IsTrivial ); # these implications can create problems with some fp groups. Therefore we # are a bit less eager #InstallTrueMethod( CanComputeSizeAnySubgroup, IsTrivial ); #InstallTrueMethod( CanEasilyTestMembership, IsTrivial ); ############################################################################# ## #F CanComputeIndex( , ) ## ## <#GAPDoc Label="CanComputeIndex"> ## ## ## ## ## This function indicates whether the index [G:H] ## (which might be ) can be computed. ## It assumes that H \leq G ## (see ). ## ## ## <#/GAPDoc> ## DeclareOperation( "CanComputeIndex", [IsGroup,IsGroup] ); ############################################################################# ## #P KnowsHowToDecompose( [, ] ) ## ## <#GAPDoc Label="KnowsHowToDecompose"> ## ## ## ## ## Tests whether the group G can decompose elements in the generators ## gens. ## If gens is not given it tests, whether it can decompose in the ## generators given in the value of ## G. ##

## This property can be used for example to check whether a ## group homomorphism by images ## (see ) can be reasonably defined ## from this group. ## ## ## <#/GAPDoc> ## DeclareProperty( "KnowsHowToDecompose", IsGroup ); DeclareOperation( "KnowsHowToDecompose", [ IsGroup, IsList ] ); ############################################################################# ## #P IsPGroup( ) . . . . . . . . . . . . . . . . . is a group a p-group ? ## ## <#GAPDoc Label="IsPGroup"> ## ## ## ## ## p-group ## A p-group is a finite group whose order ## (see ) is of the form p^n for a prime ## integer p and a nonnegative integer n. ## returns true if G is a ## p-group, and false otherwise. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsPGroup", IsGroup ); InstallSubsetMaintenance( IsPGroup, IsGroup and IsPGroup, IsGroup ); InstallFactorMaintenance( IsPGroup, IsGroup and IsPGroup, IsObject, IsGroup ); InstallTrueMethod( IsPGroup, IsGroup and IsTrivial ); InstallTrueMethod( IsPGroup, IsGroup and IsElementaryAbelian ); ############################################################################# ## #A PrimePGroup( ) ## ## <#GAPDoc Label="PrimePGroup"> ## ## ## ## ## If G is a nontrivial p-group ## (see ), returns ## the prime integer p; ## if G is trivial then returns ## fail. ## Otherwise an error is issued. ##

## (One should avoid a common error of writing ## if IsPGroup(g) then ... PrimePGroup(g) ... where the code ## represented by dots assumes that PrimePGroup(g) is an integer.) ## ## ## <#/GAPDoc> ## DeclareAttribute( "PrimePGroup", IsPGroup ); ############################################################################# ## #A PClassPGroup( ) ## ## <#GAPDoc Label="PClassPGroup"> ## ## ## ## ## The p-class of a p-group G ## (see ) ## is the length of the lower p-central series ## (see ) of G. ## If G is not a p-group then an error is issued. ## ## ## <#/GAPDoc> ## DeclareAttribute( "PClassPGroup", IsPGroup ); ############################################################################# ## #A RankPGroup( ) ## ## <#GAPDoc Label="RankPGroup"> ## ## ## ## ## For a p-group G (see ), ## returns the rank of G, ## which is defined as the minimal size of a generating system of G. ## If G is not a p-group then an error is issued. ## h:=Group((1,2,3,4),(1,3));; ## gap> PClassPGroup(h); ## 2 ## gap> RankPGroup(h); ## 2 ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "RankPGroup", IsPGroup ); ############################################################################# ## #P IsNilpotentGroup( ) ## ## <#GAPDoc Label="IsNilpotentGroup"> ## ## ## ## ## A group is nilpotent if the lower central series ## (see  for a definition) ## reaches the trivial subgroup in a finite number of steps. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsNilpotentGroup", IsGroup ); InstallSubsetMaintenance( IsNilpotentGroup, IsGroup and IsNilpotentGroup, IsGroup ); InstallFactorMaintenance( IsNilpotentGroup, IsGroup and IsNilpotentGroup, IsObject, IsGroup ); InstallTrueMethod( IsNilpotentGroup, IsGroup and IsCommutative ); InstallTrueMethod( IsNilpotentGroup, IsGroup and IsPGroup ); ############################################################################# ## #P IsPerfectGroup( ) ## ## <#GAPDoc Label="IsPerfectGroup"> ## ## ## ## ## A group is perfect if it equals its derived subgroup ## (see ). ## ## ## <#/GAPDoc> ## DeclareProperty( "IsPerfectGroup", IsGroup ); InstallFactorMaintenance( IsPerfectGroup, IsGroup and IsPerfectGroup, IsObject, IsGroup ); ############################################################################# ## #P IsSporadicSimpleGroup( ) ## ## ## ## ## ## A group is sporadic simple if it is one of the ## 26 sporadic simple groups; ## these are (in &ATLAS; notation, see ) ## M_{11}, M_{12}, J_1, M_{22}, J_2, ## M_{23}, HS, J_3, M_{24}, M^cL, ## He, Ru, Suz, O'N, Co_3, Co_2, ## Fi_{22}, HN, Ly, Th, Fi_{23}, ## Co_1, J_4, Fi_{24}', B, and M. ##

## This property can be used for example for selecting the character tables ## of the sporadic simple groups, ## see the documentation of the &GAP; package CTblLib. ## ## ## DeclareProperty( "IsSporadicSimpleGroup", IsGroup ); InstallIsomorphismMaintenance( IsSporadicSimpleGroup, IsGroup and IsSporadicSimpleGroup, IsGroup ); ############################################################################# ## #P IsSimpleGroup( ) ## ## <#GAPDoc Label="IsSimpleGroup"> ## ## ## ## ## A group is simple if it is nontrivial and has no nontrivial normal ## subgroups. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsSimpleGroup", IsGroup ); InstallIsomorphismMaintenance( IsSimpleGroup, IsGroup and IsSimpleGroup, IsGroup ); InstallTrueMethod( IsSimpleGroup, IsGroup and IsSporadicSimpleGroup ); ############################################################################# ## #P IsAlmostSimpleGroup( ) ## ## <#GAPDoc Label="IsAlmostSimpleGroup"> ## ## ## ## ## A group G is almost simple if a nonabelian simple group ## S exists such that G is isomorphic to a subgroup of the ## automorphism group of S that contains all inner automorphisms of ## S. ##

## Equivalently, G is almost simple if and only if it has a unique ## minimal normal subgroup N and if N is a nonabelian simple ## group. ##

## ## Note that an almost simple group is not defined as an extension of ## a simple group by outer automorphisms, ## since we want to exclude extensions of groups of prime order. ## In particular, a simple group is almost simple if and only ## if it is nonabelian. ##

## IsAlmostSimpleGroup( AlternatingGroup( 5 ) ); ## true ## gap> IsAlmostSimpleGroup( SymmetricGroup( 5 ) ); ## true ## gap> IsAlmostSimpleGroup( SymmetricGroup( 3 ) ); ## false ## gap> IsAlmostSimpleGroup( SL( 2, 5 ) ); ## false ## ]]> ## ## ## <#/GAPDoc> ## DeclareProperty( "IsAlmostSimpleGroup", IsGroup ); ############################################################################# ## #P IsSupersolvableGroup( ) ## ## <#GAPDoc Label="IsSupersolvableGroup"> ## ## ## ## ## A finite group is supersolvable if it has a normal series ## with cyclic factors. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsSupersolvableGroup", IsGroup ); InstallSubsetMaintenance( IsSupersolvableGroup, IsGroup and IsSupersolvableGroup, IsGroup ); InstallFactorMaintenance( IsSupersolvableGroup, IsGroup and IsSupersolvableGroup, IsObject, IsGroup ); InstallTrueMethod( IsSupersolvableGroup, IsNilpotentGroup ); ############################################################################# ## #P IsMonomialGroup( ) ## ## <#GAPDoc Label="IsMonomialGroup"> ## ## ## ## ## A finite group is monomial if every irreducible complex character is ## induced from a linear character of a subgroup. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsMonomialGroup", IsGroup ); InstallFactorMaintenance( IsMonomialGroup, IsGroup and IsMonomialGroup, IsObject, IsGroup ); InstallTrueMethod( IsMonomialGroup, IsSupersolvableGroup and IsFinite ); ############################################################################# ## #P IsSolvableGroup( ) ## ## <#GAPDoc Label="IsSolvableGroup"> ## ## ## ## ## A group is solvable if the derived series ## (see  for a definition) ## reaches the trivial subgroup in a finite number of steps. ##

## For finite groups this is the same as being polycyclic ## (see ), ## and each polycyclic group is solvable, ## but there are infinite solvable groups that are not polycyclic. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsSolvableGroup", IsGroup ); InstallSubsetMaintenance( IsSolvableGroup, IsGroup and IsSolvableGroup, IsGroup ); InstallFactorMaintenance( IsSolvableGroup, IsGroup and IsSolvableGroup, IsObject, IsGroup ); ## For finite groups, supersolvability implies monomiality, and this implies ## solvability. ## But monomiality is defined only for finite groups, for the general case ## we need the direct implication from supersolvability to solvability. InstallTrueMethod( IsSolvableGroup, IsMonomialGroup ); InstallTrueMethod( IsSolvableGroup, IsSupersolvableGroup ); ############################################################################# ## #P IsPolycyclicGroup( ) ## ## <#GAPDoc Label="IsPolycyclicGroup"> ## ## ## ## ## A group is polycyclic if it has a subnormal series with cyclic factors. ## For finite groups this is the same as if the group is solvable ## (see ). ## ## ## <#/GAPDoc> ## DeclareProperty( "IsPolycyclicGroup", IsGroup ); InstallTrueMethod( IsSolvableGroup, IsPolycyclicGroup ); InstallTrueMethod( IsPolycyclicGroup, IsSolvableGroup and IsFinite ); InstallTrueMethod( IsPolycyclicGroup, IsNilpotentGroup and IsFinitelyGeneratedGroup ); ############################################################################# ## #A AbelianInvariants( ) ## ## <#GAPDoc Label="AbelianInvariants:grp"> ## ## ## ## ## ## AbelianInvariants ## returns the abelian invariants (also sometimes called primary ## decomposition) of the commutator factor group of the ## group G. These are given as a list of prime-powers or zeroes and ## describe the structure of G/G' as a direct product ## of cyclic groups of prime power (or infinite) order. ##

## (See to obtain actual ## generators). ## g:=Group((1,2,3,4),(1,2),(5,6));; ## gap> AbelianInvariants(g); ## [ 2, 2 ] ## gap> h:=FreeGroup(2);;h:=h/[h.1^3];; ## gap> AbelianInvariants(h); ## [ 0, 3 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "AbelianInvariants", IsGroup ); ############################################################################# ## #A IsInfiniteAbelianizationGroup( ) ## ## <#GAPDoc Label="IsInfiniteAbelianizationGroup:grp"> ## ## ## ## ## ## IsInfiniteAbelianizationGroup ## returns true if the commutator factor group G/G' is ## infinite. This might be done without computing the full structure of the ## commutator factor group. ## ## ## <#/GAPDoc> ## DeclareAttribute( "IsInfiniteAbelianizationGroup", IsGroup ); ############################################################################# ## #A AsGroup( ) . . . . . . . . . . . . . collection , viewed as group ## ## <#GAPDoc Label="AsGroup"> ## ## ## ## ## if the elements of the collection D form a group the command returns ## this group, otherwise it returns fail. ## AsGroup([(1,2)]); ## fail ## gap> AsGroup([(),(1,2)]); ## Group([ (1,2) ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "AsGroup", IsCollection ); ############################################################################# ## #A ChiefSeries( ) ## ## <#GAPDoc Label="ChiefSeries"> ## ## ## ## ## is a series of normal subgroups of G which cannot be refined ## further. ## That is there is no normal subgroup N of G with ## U_i > N > U_{{i+1}}. ## This attribute returns one chief series (of potentially many ## possibilities). ## g:=Group((1,2,3,4),(1,2));; ## gap> ChiefSeries(g); ## [ Group([ (1,2,3,4), (1,2) ]), ## Group([ (2,4,3), (1,4)(2,3), (1,3)(2,4) ]), ## Group([ (1,4)(2,3), (1,3)(2,4) ]), Group(()) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "ChiefSeries", IsGroup ); ############################################################################# ## #O ChiefSeriesUnderAction( , ) ## ## <#GAPDoc Label="ChiefSeriesUnderAction"> ## ## ## ## ## returns a series of normal subgroups of G which are invariant under ## H such that the series cannot be refined any further. ## G must be a subgroup of H. ## This attribute returns one such series (of potentially many ## possibilities). ## ## ## <#/GAPDoc> ## DeclareOperation( "ChiefSeriesUnderAction", [ IsGroup, IsGroup ] ); ############################################################################# ## #O ChiefSeriesThrough( , ) ## ## <#GAPDoc Label="ChiefSeriesThrough"> ## ## ## ## ## is a chief series of the group G going through ## the normal subgroups in the list l, which must be a list of normal ## subgroups of G contained in each other, sorted by descending size. ## This attribute returns one ## chief series (of potentially many possibilities). ## ## ## <#/GAPDoc> ## DeclareOperation( "ChiefSeriesThrough", [ IsGroup, IsList ] ); ############################################################################# ## #A CommutatorFactorGroup( ) ## ## <#GAPDoc Label="CommutatorFactorGroup"> ## ## ## ## ## computes the commutator factor group G/G' of the group G. ## CommutatorFactorGroup(g); ## Group([ f1 ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "CommutatorFactorGroup", IsGroup ); ############################################################################# ## #A CompositionSeries( ) ## ## <#GAPDoc Label="CompositionSeries"> ## ## ## ## ## A composition series is a subnormal series which cannot be refined. ## This attribute returns one composition series (of potentially many ## possibilities). ## ## ## <#/GAPDoc> ## DeclareAttribute( "CompositionSeries", IsGroup ); #T and for module? ############################################################################# ## #F DisplayCompositionSeries( ) ## ## <#GAPDoc Label="DisplayCompositionSeries"> ## ## ## ## ## Displays a composition series of G in a nice way, identifying the ## simple factors. ## CompositionSeries(g); ## [ Group([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ]), ## Group([ (2,4,3), (1,4)(2,3), (1,3)(2,4) ]), ## Group([ (1,4)(2,3), (1,3)(2,4) ]), Group([ (1,3)(2,4) ]), Group(()) ## ] ## gap> DisplayCompositionSeries(Group((1,2,3,4,5,6,7),(1,2))); ## G (2 gens, size 5040) ## | Z(2) ## S (5 gens, size 2520) ## | A(7) ## 1 (0 gens, size 1) ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "DisplayCompositionSeries" ); ############################################################################# ## #A ConjugacyClasses( ) ## ## <#GAPDoc Label="ConjugacyClasses:grp"> ## ## ## ## ## returns the conjugacy classes of elements of G as a list of ## class objects of G ## (see  for details). ## It is guaranteed that the class of the ## identity is in the first position, the further arrangement depends on ## the method chosen (and might be different for equal but not identical ## groups). ##

## For very small groups (of size up to 500) the classes will be computed ## by the conjugation action of G on itself ## (see ). ## This can be deliberately switched off using the noaction ## option shown below. ##

## For solvable groups, the default method to compute the classes is by ## homomorphic lift ## (see section ). ##

## For other groups the method of is employed. ##

## supports the following ## options that can be used to modify this strategy: ## ## random ## ## The classes are computed by random search. ## See below. ## ## action ## ## The classes are computed by action of G on itself. ## See below. ## ## noaction ## ## Even for small groups ## ## is not used as a default. This can be useful if the elements of the ## group use a lot of memory. ## ## ## g:=SymmetricGroup(4);; ## gap> cl:=ConjugacyClasses(g); ## [ ()^G, (1,2)^G, (1,2)(3,4)^G, (1,2,3)^G, (1,2,3,4)^G ] ## gap> Representative(cl[3]);Centralizer(cl[3]); ## (1,2)(3,4) ## Group([ (1,2), (1,3)(2,4), (3,4) ]) ## gap> Size(Centralizer(cl[5])); ## 4 ## gap> Size(cl[2]); ## 6 ## ]]> ##

## In general, you will not need to have to influence the method, but simply ## call ## –&GAP; will try to select a suitable method on its own. ## The method specifications are provided here mainly for expert use. ## ## ## <#/GAPDoc> ## DeclareAttribute( "ConjugacyClasses", IsGroup ); ############################################################################# ## #A ConjugacyClassesMaximalSubgroups( ) ## ## <#GAPDoc Label="ConjugacyClassesMaximalSubgroups"> ## ## ## ## ## returns the conjugacy classes of maximal subgroups of G. ## Representatives of the classes can be computed directly by ## . ## ConjugacyClassesMaximalSubgroups(g); ## [ AlternatingGroup( [ 1 .. 4 ] )^G, Group( [ (1,2,3), (1,2) ] )^G, ## Group( [ (1,2), (3,4), (1,3)(2,4) ] )^G ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "ConjugacyClassesMaximalSubgroups", IsGroup ); ############################################################################# ## #A MaximalSubgroups( ) ## ## <#GAPDoc Label="MaximalSubgroups"> ## ## ## ## ## returns a list of all maximal subgroups of G. This may take up much ## space, therefore the command should be avoided if possible. See ## . ## MaximalSubgroups(Group((1,2,3),(1,2))); ## [ Group([ (1,2,3) ]), Group([ (2,3) ]), Group([ (1,2) ]), ## Group([ (1,3) ]) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "MaximalSubgroups", IsGroup ); ############################################################################# ## #A MaximalSubgroupClassReps( ) ## ## <#GAPDoc Label="MaximalSubgroupClassReps"> ## ## ## ## ## returns a list of conjugacy representatives of the maximal subgroups ## of G. ## MaximalSubgroupClassReps(g); ## [ Alt( [ 1 .. 4 ] ), Group([ (1,2,3), (1,2) ]), ## Group([ (1,2), (3,4), (1,3)(2,4) ]) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute("MaximalSubgroupClassReps",IsGroup); ############################################################################# ## #A PerfectResiduum( ) ## ## <#GAPDoc Label="PerfectResiduum"> ## ## ## ## ## is the smallest normal subgroup of G that has a solvable factor group. ## PerfectResiduum(Group((1,2,3,4,5),(1,2))); ## Group([ (1,3,2), (2,4,3), (1,3)(4,5) ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "PerfectResiduum", IsGroup ); ############################################################################# ## #A RepresentativesPerfectSubgroups( ) #A RepresentativesSimpleSubgroups( ) ## ## <#GAPDoc Label="RepresentativesPerfectSubgroups"> ## ## ## ## ## ## returns a list of conjugacy representatives of perfect (respectively ## simple) subgroups of G. ## This uses the library of perfect groups ## (see ), ## thus it will issue an error if the library is insufficient to determine ## all perfect subgroups. ## m11:=TransitiveGroup(11,6); ## M(11) ## gap> r:=RepresentativesPerfectSubgroups(m11); ## [ Group([ (2,3,4)(5,6,8)(7,11,9), (3,11)(4,5)(6,10)(7,8) ]), ## Group([ (1,2,3)(5,9,6)(7,8,11), (3,11)(4,5)(6,10)(7,8) ]), ## Group([ (2,3,4,11,6)(5,7,10,8,9), (3,11)(4,5)(6,10)(7,8) ]), ## Group([ (1,2,3)(4,6,11)(7,9,10), (3,11)(4,5)(6,10)(7,8) ]), M(11), ## Group(()) ] ## gap> List(r,Size); ## [ 60, 60, 360, 660, 7920, 1 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "RepresentativesPerfectSubgroups", IsGroup ); DeclareAttribute( "RepresentativesSimpleSubgroups", IsGroup ); ############################################################################# ## #A ConjugacyClassesPerfectSubgroups( ) ## ## <#GAPDoc Label="ConjugacyClassesPerfectSubgroups"> ## ## ## ## ## returns a list of the conjugacy classes of perfect subgroups of G. ## (see .) ## ConjugacyClassesPerfectSubgroups(m11); ## [ Group( [ ( 2, 3, 4)( 5, 6, 8)( 7,11, 9), ## ( 3,11)( 4, 5)( 6,10)( 7, 8) ] )^G, ## Group( [ ( 1, 2, 3)( 5, 9, 6)( 7, 8,11), ## ( 3,11)( 4, 5)( 6,10)( 7, 8) ] )^G, ## Group( [ ( 2, 3, 4,11, 6)( 5, 7,10, 8, 9), ## ( 3,11)( 4, 5)( 6,10)( 7, 8) ] )^G, ## Group( [ ( 1, 2, 3)( 4, 6,11)( 7, 9,10), ## ( 3,11)( 4, 5)( 6,10)( 7, 8) ] )^G, M(11)^G, Group( () )^G ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "ConjugacyClassesPerfectSubgroups", IsGroup ); ############################################################################# ## #A ConjugacyClassesSubgroups( ) ## ## <#GAPDoc Label="ConjugacyClassesSubgroups"> ## ## ## ## ## This attribute returns a list of all conjugacy classes of subgroups of ## the group G. ## It also is applicable for lattices of subgroups (see ). ## The order in which the classes are listed depends on the method chosen by ## &GAP;. ## For each class of subgroups, a representative can be accessed using ## . ## ConjugacyClassesSubgroups(g); ## [ Group( () )^G, Group( [ (1,3)(2,4) ] )^G, Group( [ (3,4) ] )^G, ## Group( [ (2,4,3) ] )^G, Group( [ (1,4)(2,3), (1,3)(2,4) ] )^G, ## Group( [ (3,4), (1,2)(3,4) ] )^G, ## Group( [ (1,3,2,4), (1,2)(3,4) ] )^G, Group( [ (3,4), (2,4,3) ] )^G, ## Group( [ (1,4)(2,3), (1,3)(2,4), (3,4) ] )^G, ## Group( [ (1,4)(2,3), (1,3)(2,4), (2,4,3) ] )^G, ## Group( [ (1,4)(2,3), (1,3)(2,4), (2,4,3), (3,4) ] )^G ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "ConjugacyClassesSubgroups", IsGroup ); ############################################################################# ## #A LatticeSubgroups( ) ## ## <#GAPDoc Label="LatticeSubgroups"> ## ## ## ## ## computes the lattice of subgroups of the group G. This lattice has ## the conjugacy classes of subgroups as attribute ## and ## permits one to test maximality/minimality relations. ## g:=SymmetricGroup(4);; ## gap> l:=LatticeSubgroups(g); ## ## gap> ConjugacyClassesSubgroups(l); ## [ Group( () )^G, Group( [ (1,3)(2,4) ] )^G, Group( [ (3,4) ] )^G, ## Group( [ (2,4,3) ] )^G, Group( [ (1,4)(2,3), (1,3)(2,4) ] )^G, ## Group( [ (3,4), (1,2)(3,4) ] )^G, ## Group( [ (1,3,2,4), (1,2)(3,4) ] )^G, Group( [ (3,4), (2,4,3) ] )^G, ## Group( [ (1,4)(2,3), (1,3)(2,4), (3,4) ] )^G, ## Group( [ (1,4)(2,3), (1,3)(2,4), (2,4,3) ] )^G, ## Group( [ (1,4)(2,3), (1,3)(2,4), (2,4,3), (3,4) ] )^G ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "LatticeSubgroups", IsGroup ); ############################################################################# ## #A DerivedLength( ) ## ## <#GAPDoc Label="DerivedLength"> ## ## ## ## ## The derived length of a group is the number of steps in the derived ## series. (As there is always the group, it is the series length minus 1.) ## List(DerivedSeriesOfGroup(g),Size); ## [ 24, 12, 4, 1 ] ## gap> DerivedLength(g); ## 3 ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "DerivedLength", IsGroup ); ############################################################################# ## #A HirschLength( ) ## ## ## ## ## ## Suppose that G is polycyclic-by-finite; that is, there exists a ## polycyclic normal subgroup N in G with [G : N] finite. Then the Hirsch ## length of G is the number of infinite cyclic factors in a polycyclic ## series of N. This is an invariant of G. ## ## ## DeclareAttribute( "HirschLength", IsGroup ); InstallIsomorphismMaintenance( HirschLength, IsGroup and HasHirschLength, IsGroup ); ############################################################################# ## #A DerivedSeriesOfGroup( ) ## ## <#GAPDoc Label="DerivedSeriesOfGroup"> ## ## ## ## ## The derived series of a group is obtained by U_{{i+1}} = U_i'. ## It stops if U_i is perfect. ## ## ## <#/GAPDoc> ## DeclareAttribute( "DerivedSeriesOfGroup", IsGroup ); ############################################################################# ## #A DerivedSubgroup( ) ## ## <#GAPDoc Label="DerivedSubgroup"> ## ## ## ## ## The derived subgroup G' of G is the subgroup ## generated by all commutators of pairs of elements of G. ## It is normal in G and the factor group G/G' ## is the largest abelian factor group of G. ## g:=Group((1,2,3,4),(1,2));; ## gap> DerivedSubgroup(g); ## Group([ (1,3,2), (1,4,3) ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "DerivedSubgroup", IsGroup ); ############################################################################# ## #A MaximalAbelianQuotient( ) . . . . Max abelian quotient ## ## <#GAPDoc Label="MaximalAbelianQuotient"> ## ## ## ## ## returns an epimorphism from G onto the maximal abelian quotient of ## G. ## The kernel of this epimorphism is the derived subgroup of G, ## see . ## ## ## <#/GAPDoc> ## DeclareAttribute( "MaximalAbelianQuotient",IsGroup); ############################################################################# ## #A CommutatorLength( ) ## ## <#GAPDoc Label="CommutatorLength"> ## ## ## ## ## returns the minimal number n such that each element ## in the derived subgroup (see ) of the ## group G can be written as a product of (at most) n ## commutators of elements in G. ## CommutatorLength( g ); ## 1 ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "CommutatorLength", IsGroup ); ############################################################################# ## #A DimensionsLoewyFactors( ) ## ## <#GAPDoc Label="DimensionsLoewyFactors"> ## ## ## ## ## This operation computes the dimensions of the factors of the Loewy ## series of G. ## (See for the slightly complicated ## definition of the Loewy Series.) ##

## The dimensions are computed via the without computing ## the Loewy series itself. ## G:= SmallGroup( 3^6, 100 ); ## ## gap> JenningsSeries( G ); ## [ , Group([ f3, f4, f5, f6 ]), ## Group([ f4, f5, f6 ]), Group([ f5, f6 ]), Group([ f5, f6 ]), ## Group([ f5, f6 ]), Group([ f6 ]), Group([ f6 ]), Group([ f6 ]), ## Group([ of ... ]) ] ## gap> DimensionsLoewyFactors(G); ## [ 1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 20, 22, 23, 25, 26, ## 27, 27, 27, 27, 27, 27, 27, 27, 27, 26, 25, 23, 22, 20, 19, 17, 16, ## 14, 13, 11, 10, 8, 7, 5, 4, 2, 1 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "DimensionsLoewyFactors", IsGroup ); ############################################################################# ## #A ElementaryAbelianSeries( ) #A ElementaryAbelianSeriesLargeSteps( ) #A ElementaryAbelianSeries( [,,,...] ) ## ## <#GAPDoc Label="ElementaryAbelianSeries"> ## ## ElementaryAbelianSeries ## ## ## ## ## ## returns a series of normal subgroups of G such that all factors are ## elementary abelian. If the group is not solvable (and thus no such series ## exists) it returns fail. ##

## The variant tries to make ## the steps in this series large (by eliminating intermediate subgroups if ## possible) at a small additional cost. ##

## In the third variant, an elementary abelian series through the given ## series of normal subgroups in the list list is constructed. ## List(ElementaryAbelianSeries(g),Size); ## [ 24, 12, 4, 1 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "ElementaryAbelianSeries", IsGroup ); DeclareAttribute( "ElementaryAbelianSeriesLargeSteps", IsGroup ); ############################################################################# ## #A Exponent( ) ## ## <#GAPDoc Label="Exponent"> ## ## ## ## ## The exponent e of a group G is the lcm of the orders of its ## elements, that is, e is the smallest integer such that ## g^e = 1 for all g \in G. ## Exponent(g); ## 12 ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "Exponent", IsGroup ); InstallIsomorphismMaintenance( Exponent, IsGroup and HasExponent, IsGroup ); ############################################################################# ## #A FittingSubgroup( ) ## ## <#GAPDoc Label="FittingSubgroup"> ## ## ## ## ## The Fitting subgroup of a group G is its largest nilpotent normal ## subgroup. ## FittingSubgroup(g); ## Group([ (1,2)(3,4), (1,4)(2,3) ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "FittingSubgroup", IsGroup ); ############################################################################# ## #A PrefrattiniSubgroup( ) ## ## <#GAPDoc Label="PrefrattiniSubgroup"> ## ## ## ## ## returns a Prefrattini subgroup of the finite solvable group G. ##

## A factor M/N of G is called a Frattini factor if ## M/N is contained in the Frattini subgroup of G/N. ## A subgroup P is a Prefrattini subgroup of G if P ## covers each Frattini chief factor of G, and if for each maximal ## subgroup of G there exists a conjugate maximal subgroup, which ## contains P. ## In a finite solvable group G the Prefrattini subgroups ## form a characteristic conjugacy class of subgroups and the intersection ## of all these subgroups is the Frattini subgroup of G. ## G := SmallGroup( 60, 7 ); ## ## gap> P := PrefrattiniSubgroup(G); ## Group([ f2 ]) ## gap> Size(P); ## 2 ## gap> IsNilpotent(P); ## true ## gap> Core(G,P); ## Group([ ]) ## gap> FrattiniSubgroup(G); ## Group([ ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "PrefrattiniSubgroup", IsGroup ); ############################################################################# ## #A FrattiniSubgroup( ) ## ## <#GAPDoc Label="FrattiniSubgroup"> ## ## ## ## ## The Frattini subgroup of a group G is the intersection of all ## maximal subgroups of G. ## FrattiniSubgroup(g); ## Group(()) ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "FrattiniSubgroup", IsGroup ); ############################################################################# ## #A InvariantForm( ) ## ## ## ## ## ## ## ## DeclareAttribute( "InvariantForm", IsGroup ); ############################################################################# ## #A JenningsSeries( ) ## ## <#GAPDoc Label="JenningsSeries"> ## ## ## ## ## For a p-group G, this function returns its Jennings series. ## This series is defined by setting ## G_1 = G and for i \geq 0, ## G_{{i+1}} = [G_i,G] G_j^p, ## where j is the smallest integer \geq i/p. ## ## ## <#/GAPDoc> ## DeclareAttribute( "JenningsSeries", IsGroup ); ############################################################################# ## #A LowerCentralSeriesOfGroup( ) ## ## <#GAPDoc Label="LowerCentralSeriesOfGroup"> ## ## ## ## ## The lower central series of a group G is defined as ## U_{{i+1}}:= [G, U_i]. ## It is a central series of normal subgroups. ## The name derives from the fact that U_i is contained in the ## i-th step subgroup of any central series. ## ## ## <#/GAPDoc> ## DeclareAttribute( "LowerCentralSeriesOfGroup", IsGroup ); ############################################################################# ## #A NilpotencyClassOfGroup( ) ## ## <#GAPDoc Label="NilpotencyClassOfGroup"> ## ## ## ## ## The nilpotency class of a nilpotent group G is the number of steps in ## the lower central series of G (see ); ##

## If G is not nilpotent an error is issued. ## ## ## <#/GAPDoc> ## DeclareAttribute( "NilpotencyClassOfGroup", IsGroup ); ############################################################################# ## #A MaximalNormalSubgroups( ) ## ## <#GAPDoc Label="MaximalNormalSubgroups"> ## ## ## ## ## is a list containing those proper normal subgroups of the group G ## that are maximal among the proper normal subgroups. ## MaximalNormalSubgroups( g ); ## [ Group([ (2,4,3), (1,4)(2,3), (1,3)(2,4) ]) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "MaximalNormalSubgroups", IsGroup ); ############################################################################# ## #A NormalMaximalSubgroups( ) ## ## ## ## ## ## ## ## DeclareAttribute( "NormalMaximalSubgroups", IsGroup ); ############################################################################# ## #A MinimalNormalSubgroups( ) ## ## <#GAPDoc Label="MinimalNormalSubgroups"> ## ## ## ## ## is a list containing those nontrivial normal subgroups of the group G ## that are minimal among the nontrivial normal subgroups. ## MinimalNormalSubgroups( g ); ## [ Group([ (1,4)(2,3), (1,3)(2,4) ]) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "MinimalNormalSubgroups", IsGroup ); ############################################################################# ## #A NormalSubgroups( ) ## ## <#GAPDoc Label="NormalSubgroups"> ## ## ## ## ## returns a list of all normal subgroups of G. ## g:=SymmetricGroup(4);;NormalSubgroups(g); ## [ Sym( [ 1 .. 4 ] ), Group([ (2,4,3), (1,4)(2,3), (1,3)(2,4) ]), ## Group([ (1,4)(2,3), (1,3)(2,4) ]), Group(()) ] ## ]]> ##

## The algorithm for the computation of normal subgroups is described in ## . ## ## ## <#/GAPDoc> ## DeclareAttribute( "NormalSubgroups", IsGroup ); ############################################################################# ## #F NormalSubgroupsAbove( , , ) ## ## ## ## ## ## ## ## DeclareGlobalFunction("NormalSubgroupsAbove"); ############################################################################ ## #A NrConjugacyClasses( ) ## ## <#GAPDoc Label="NrConjugacyClasses"> ## ## ## ## ## returns the number of conjugacy classes of G. ## g:=Group((1,2,3,4),(1,2));; ## gap> NrConjugacyClasses(g); ## 5 ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "NrConjugacyClasses", IsGroup ); ############################################################################# ## #O Omega( ,

[, ] ) ## ## <#GAPDoc Label="Omega"> ## ## ## ## ## For a p-group G, one defines ## \Omega_{n}(G) = ## \{ g \in G \mid g^{{p^{n}}} = 1 \}. ## The default value for n is 1. ##

## @At the moment methods exist only for abelian G and n=1.@ ## h:=SmallGroup(16,10); ## ## gap> Omega(h,2); ## Group([ f2, f3, f4 ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "Omega", [ IsGroup, IsPosInt ] ); DeclareOperation( "Omega", [ IsGroup, IsPosInt, IsPosInt ] ); DeclareOperation( "OmegaOp", [ IsGroup, IsPosInt, IsPosInt ] ); DeclareAttribute( "ComputedOmegas", IsGroup, "mutable" ); ############################################################################# ## #F Agemo( ,

[, ] ) ## ## <#GAPDoc Label="Agemo"> ## ## ## ## ## For a p-group G, one defines ## \mho_{n}(G) = ## \langle g^{{p^{n}}} \mid g \in G \rangle. ## The default value for n is 1. ## Agemo(h,2);Agemo(h,2,2); ## Group([ f4 ]) ## Group([ ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "Agemo" ); DeclareOperation( "AgemoOp", [ IsGroup, IsPosInt, IsPosInt ] ); DeclareAttribute( "ComputedAgemos", IsGroup, "mutable" ); ############################################################################# ## #A RadicalGroup( ) ## ## <#GAPDoc Label="RadicalGroup"> ## ## ## ## ## is the radical of G, i.e., the largest solvable normal subgroup of G. ## RadicalGroup(SL(2,5)); ## ## gap> Size(last); ## 2 ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "RadicalGroup", IsGroup ); ############################################################################# ## #A RationalClasses( ) ## ## <#GAPDoc Label="RationalClasses"> ## ## ## ## ## returns a list of the rational classes of the group G. (See ## .) ## RationalClasses(DerivedSubgroup(g)); ## [ RationalClass( AlternatingGroup( [ 1 .. 4 ] ), () ), ## RationalClass( AlternatingGroup( [ 1 .. 4 ] ), (1,2)(3,4) ), ## RationalClass( AlternatingGroup( [ 1 .. 4 ] ), (1,2,3) ) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "RationalClasses", IsGroup ); ############################################################################# ## #A GeneratorsSmallest( ) ## ## <#GAPDoc Label="GeneratorsSmallest"> ## ## ## ## ## returns a smallest generating set for the group G. ## This is the lexicographically (using &GAP;s order of group elements) ## smallest list l of elements of G such that ## G = \langle l \rangle and ## l_i \not \in \langle l_1, \ldots, l_{{i-1}} \rangle ## (in particular l_1 is not the identity element of the group). ## The comparison of two groups via ## lexicographic comparison of their sorted element lists yields the same ## relation as lexicographic comparison of their smallest generating sets. ## g:=SymmetricGroup(4);; ## gap> GeneratorsSmallest(g); ## [ (3,4), (2,3), (1,2) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "GeneratorsSmallest", IsMagma ); ############################################################################# ## #A LargestElementGroup( ) ## ## <#GAPDoc Label="LargestElementGroup"> ## ## ## ## ## returns the largest element of G with respect to the ordering < of ## the elements family. ## ## ## <#/GAPDoc> ## DeclareAttribute( "LargestElementGroup", IsGroup ); ############################################################################# ## #A MinimalGeneratingSet( ) ## ## <#GAPDoc Label="MinimalGeneratingSet"> ## ## ## ## ## returns a generating set of G of minimal possible length. ##

## Note that –apart from special cases– currently there are only ## efficient methods known to compute minimal generating sets of finite ## solvable groups and of finitely generated nilpotent groups. ## Hence so far these are the only cases for which methods are available. ## The former case is covered by a method implemented in the &GAP; library, ## while the second case requires the package Polycyclic. ##

## If you do not really need a minimal generating set, but are satisfied ## with getting a reasonably small set of generators, you better use ## . ##

## Information about the minimal generating sets of the finite simple ## groups of order less than 10^6 can be found in . ## See also the package AtlasRep. ## MinimalGeneratingSet(g); ## [ (2,4,3), (1,4,2,3) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "MinimalGeneratingSet", IsGroup ); ############################################################################# ## #A SmallGeneratingSet() small generating set (hopefully even irredundant) ## ## <#GAPDoc Label="SmallGeneratingSet"> ## ## ## ## ## returns a generating set of G which has few elements. As neither ## irredundancy, nor minimal length is proven it runs much faster than ## . ## It can be used whenever a short generating set is desired which not ## necessarily needs to be optimal. ## SmallGeneratingSet(g); ## [ (1,2,3,4), (1,2) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "SmallGeneratingSet", IsGroup ); ############################################################################# ## #A SupersolvableResiduum( ) ## ## <#GAPDoc Label="SupersolvableResiduum"> ## ## ## ## ## is the supersolvable residuum of the group G, that is, ## its smallest normal subgroup N such that the factor group ## G / N is supersolvable. ## SupersolvableResiduum(g); ## Group([ (1,3)(2,4), (1,4)(2,3) ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "SupersolvableResiduum", IsGroup ); ############################################################################# ## #F SupersolvableResiduumDefault( ) . . . . supersolvable residuum of ## ## ## ## ## ## For a group G, SupersolvableResiduumDefault returns a record with the ## following components. ## ## ssr: ## ## the supersolvable residuum of G, that is, ## the largest normal subgroup N of G such that the factor group ## G / N is supersolvable, ## ## ds: ## ## a chain of normal subgroups of G, ## descending from G to the supersolvable residuum, ## such that any refinement of this chain is a normal series. ## ## ## ## ## DeclareGlobalFunction( "SupersolvableResiduumDefault" ); ############################################################################# ## #A ComplementSystem( ) ## ## <#GAPDoc Label="ComplementSystem"> ## ## ## ## ## A complement system of a group G is a set of Hall ## p'-subgroups of G, ## where p' runs through the subsets of prime factors of ## |G| that omit exactly one prime. ## Every pair of subgroups from this set commutes as subgroups. ## Complement systems exist only for solvable groups, therefore ## returns fail if the group G ## is not solvable. ## ComplementSystem(h); ## [ Group([ f3, f4 ]), Group([ f1, f2, f4 ]), Group([ f1, f2, f3 ]) ] ## gap> List(last,Size); ## [ 15, 20, 12 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "ComplementSystem", IsGroup ); ############################################################################# ## #A SylowSystem( ) ## ## <#GAPDoc Label="SylowSystem"> ## ## ## ## ## A Sylow system of a group G is a set of Sylow subgroups of ## G such that every pair of subgroups from this set commutes as ## subgroups. ## Sylow systems exist only for solvable groups. The operation returns ## fail if the group G is not solvable. ## h:=SmallGroup(60,10);; ## gap> SylowSystem(h); ## [ Group([ f1, f2 ]), Group([ f3 ]), Group([ f4 ]) ] ## gap> List(last,Size); ## [ 4, 3, 5 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "SylowSystem", IsGroup ); ############################################################################# ## #A HallSystem( ) ## ## <#GAPDoc Label="HallSystem"> ## ## ## ## ## returns a list containing one Hall P-subgroup for each set ## P of prime divisors of the order of G. ## Hall systems exist only for solvable groups. The operation returns ## fail if the group G is not solvable. ## HallSystem(h); ## [ Group([ ]), Group([ f1, f2 ]), Group([ f1, f2, f3 ]), ## Group([ f1, f2, f3, f4 ]), Group([ f1, f2, f4 ]), Group([ f3 ]), ## Group([ f3, f4 ]), Group([ f4 ]) ] ## gap> List(last,Size); ## [ 1, 4, 12, 60, 20, 3, 15, 5 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "HallSystem", IsGroup ); ############################################################################# ## #A TrivialSubgroup( ) . . . . . . . . . . trivial subgroup of group ## ## <#GAPDoc Label="TrivialSubgroup"> ## ## ## ## ## TrivialSubgroup(g); ## Group(()) ## ]]> ## ## ## <#/GAPDoc> ## DeclareSynonymAttr( "TrivialSubgroup", TrivialSubmagmaWithOne ); ############################################################################# ## #A Socle( ) . . . . . . . . . . . . . . . . . . . . . . . . socle of ## ## <#GAPDoc Label="Socle"> ## ## ## ## ## The socle of the group G is the subgroup generated by ## all minimal normal subgroups. ## Socle(g); ## Group([ (1,4)(2,3), (1,2)(3,4) ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "Socle", IsGroup ); ############################################################################# ## #A UpperCentralSeriesOfGroup( ) ## ## <#GAPDoc Label="UpperCentralSeriesOfGroup"> ## ## ## ## ## The upper central series of a group G is defined as an ending ## series U_i / U_{{i+1}}:= Z(G/U_{{i+1}}). ## It is a central series of normal subgroups. ## The name derives from the fact that U_i contains every i-th ## step subgroup of a central series. ## ## ## <#/GAPDoc> ## DeclareAttribute( "UpperCentralSeriesOfGroup", IsGroup ); ############################################################################# ## #O EulerianFunction( , ) ## ## <#GAPDoc Label="EulerianFunction"> ## ## ## ## ## returns the number of n-tuples (g_1, g_2, \ldots, g_n) ## of elements of the group G that generate the whole group G. ## The elements of such an n-tuple need not be different. ##

## In , the notation \phi_{n}(G) ## is used for the value returned by , ## and the quotient of \phi_{n}(G) by the order of the ## automorphism group of G is called d_{n}(G). ## If G is a nonabelian simple group then ## d_{n}(G) is the greatest number d for which ## the direct product of d groups isomorphic with G ## can be generated by n elements. ##

## If the Library of Tables of Marks ## (see Chapter ) covers the group G, ## you may also use . ##

## EulerianFunction( g, 2 ); ## 432 ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "EulerianFunction", [ IsGroup, IsPosInt ] ); ############################################################################# ## #F AgemoAbove( , ,

) ## ## ## ## ## ## ## ## DeclareGlobalFunction( "AgemoAbove" ); ############################################################################# ## #O AsSubgroup( , ) ## ## <#GAPDoc Label="AsSubgroup"> ## ## ## ## ## creates a subgroup of G which contains the same elements as U ## v:=AsSubgroup(g,Group((1,2,3),(1,4))); ## Group([ (1,2,3), (1,4) ]) ## gap> Parent(v); ## Group([ (1,2,3,4), (1,2) ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "AsSubgroup", [ IsGroup, IsGroup ] ); ############################################################################# ## #O ClassMultiplicationCoefficient( , , , ) #O ClassMultiplicationCoefficient( , , , ) ## ## ## ## ## ## ## ## ## DeclareOperation( "ClassMultiplicationCoefficient", [ IsGroup, IsPosInt, IsPosInt, IsPosInt ] ); DeclareOperation( "ClassMultiplicationCoefficient", [ IsGroup, IsCollection, IsCollection, IsCollection ] ); ############################################################################# ## #F ClosureGroupDefault( , ) . . . . . closure of group with element ## ## <#GAPDoc Label="ClosureGroupDefault"> ## ## ## ## ## This functions returns the closure of the group G with the element ## elm. ## If G has the attribute then also the ## result has this attribute. ## This is used to implement the default method for ## and . ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "ClosureGroupDefault" ); ############################################################################# ## #O ClosureGroup( , ) . . . closure of group with element or group ## ## <#GAPDoc Label="ClosureGroup"> ## ## ## ## ## creates the group generated by the elements of G and obj. ## obj can be either an element or a collection of elements, ## in particular another group. ## g:=SmallGroup(24,12);;u:=Subgroup(g,[g.3,g.4]); ## Group([ f3, f4 ]) ## gap> ClosureGroup(u,g.2); ## Group([ f2, f3, f4 ]) ## gap> ClosureGroup(u,[g.1,g.2]); ## Group([ f1, f2, f3, f4 ]) ## gap> ClosureGroup(u,Group(g.2*g.1)); ## Group([ f1*f2^2, f3, f4 ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "ClosureGroup", [ IsGroup, IsObject ] ); ############################################################################# ## #F ClosureGroupAddElm( , ) #F ClosureGroupCompare( , ) #F ClosureGroupIntest( , ) ## ## <#GAPDoc Label="ClosureGroupAddElm"> ## ## ## ## ## ## ## These three functions together with ## implement the main methods for . ## In the ordering given, they just add elm to the generators, remove ## duplicates and identity elements, and test whether elm is already ## contained in G. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "ClosureGroupAddElm" ); DeclareGlobalFunction( "ClosureGroupCompare" ); DeclareGlobalFunction( "ClosureGroupIntest" ); ############################################################################# ## #F ClosureSubgroup( , ) #F ClosureSubgroupNC( , ) ## ## <#GAPDoc Label="ClosureSubgroup"> ## ## ## ## ## ## For a group G that stores a parent group (see ), ## calls with the same ## arguments; ## if the result is a subgroup of the parent of G then the parent of G ## is set as parent of the result, otherwise an error is raised. ## The check whether the result is contained in the parent of G is omitted ## by the NC version. As a wrong parent might imply wrong properties this ## version should be used with care. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "ClosureSubgroup" ); DeclareGlobalFunction( "ClosureSubgroupNC" ); ############################################################################# ## #O CommutatorSubgroup( , ) ## ## <#GAPDoc Label="CommutatorSubgroup"> ## ## ## ## ## If G and H are two groups of elements in the same family, ## this operation returns the group generated by all commutators ## [ g, h ] = g^{{-1}} h^{{-1}} g h (see ) ## of elements g \in G and ## h \in H, that is the group ## \left \langle [ g, h ] \mid g \in G, h \in H \right \rangle. ## CommutatorSubgroup(Group((1,2,3),(1,2)),Group((2,3,4),(3,4))); ## Group([ (1,4)(2,3), (1,3,4) ]) ## gap> Size(last); ## 12 ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "CommutatorSubgroup", [ IsGroup, IsGroup ] ); ############################################################################# ## #O ConjugateGroup( , ) . . . . . . conjugate of group by ## ## <#GAPDoc Label="ConjugateGroup"> ## ## ## ## ## returns the conjugate group of G, obtained by applying the ## conjugating element obj. ##

## To form a conjugate (group) by any object acting via ^, ## one can also use the infix operator ^. ## ConjugateGroup(g,(1,5)); ## Group([ (2,3,4,5), (2,5) ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "ConjugateGroup", [ IsGroup, IsObject ] ); ############################################################################# ## #O ConjugateSubgroup( , ) ## ## <#GAPDoc Label="ConjugateSubgroup"> ## ## ## ## ## For a group G which has a parent group P ## (see ), returns the subgroup of P, ## obtained by conjugating G using the conjugating ## element g. ##

## If G has no parent group, it just delegates to the ## call to with the same arguments. ##

## To form a conjugate (subgroup) by any object acting via ^, ## one can also use the infix operator ^. ## ## ## <#/GAPDoc> ## DeclareOperation( "ConjugateSubgroup", [ IsGroup and HasParent, IsMultiplicativeElementWithInverse ] ); ############################################################################# ## #O ConjugateSubgroups( , ) ## ## <#GAPDoc Label="ConjugateSubgroups"> ## ## ## ## ## returns a list of all images of the group U under conjugation action ## by G. ## ## ## <#/GAPDoc> ## DeclareOperation( "ConjugateSubgroups", [ IsGroup, IsGroup ] ); ############################################################################# ## #O Core( , ) ## ## <#GAPDoc Label="Core"> ## ## ## ## ## If S and U are groups of elements in the same family, this ## operation ## returns the core of U in S, that is the intersection of all ## S-conjugates of U. ## g:=Group((1,2,3,4),(1,2));; ## gap> Core(g,Subgroup(g,[(1,2,3,4)])); ## Group(()) ## ]]> ## ## ## <#/GAPDoc> ## InParentFOA( "Core", IsGroup, IsGroup, DeclareAttribute ); ############################################################################# ## #O CosetTable( , ) ## ## <#GAPDoc Label="CosetTable"> ## ## ## ## ## returns the coset table of the finitely presented group G ## on the cosets of the subgroup H. ##

## Basically a coset table is the permutation representation of the finitely ## presented group on the cosets of a subgroup (which need not be faithful ## if the subgroup has a nontrivial core). Most of the set theoretic and ## group functions use the regular representation of G, ## i.e., the coset table of G over the trivial subgroup. ##

## The coset table is returned as a list of lists. For each generator of ## G and its inverse the table contains a generator list. A generator ## list is simply a list of integers. ## If l is the generator list for the generator g and if ## l[i] = j then generator g takes the coset ## i to the coset j by multiplication from the right. ## Thus the permutation representation of G on the cosets of H ## is obtained by applying to each generator list. ##

## The coset table is standard (see below). ##

## For finitely presented groups, a coset table is computed by a ## Todd-Coxeter coset enumeration. ## Note that you may influence the performance of that enumeration by ## changing the values of the global variables ## and ## described below and that the ## options described under are ## recognized. ##

## tab := CosetTable(g, Subgroup(g, [ g.1, g.2*g.1*g.2*g.1*g.2^-1 ])); ## [ [ 1, 4, 5, 2, 3 ], [ 1, 4, 5, 2, 3 ], [ 2, 3, 1, 4, 5 ], ## [ 3, 1, 2, 4, 5 ] ] ## gap> List( last, PermList ); ## [ (2,4)(3,5), (2,4)(3,5), (1,2,3), (1,3,2) ] ## gap> PrintArray( TransposedMat( tab ) ); ## [ [ 1, 1, 2, 3 ], ## [ 4, 4, 3, 1 ], ## [ 5, 5, 1, 2 ], ## [ 2, 2, 4, 4 ], ## [ 3, 3, 5, 5 ] ] ## ]]> ##

## The last printout in the preceding example provides the coset table in ## the form in which it is usually used in hand calculations: ## The rows correspond to the cosets, the columns correspond to the ## generators and their inverses in the ordering ## g_1, g_1^{{-1}}, g_2, g_2^{{-1}}. ## (See section  ## for a description on the way the numbers are assigned.) ## ## ## <#/GAPDoc> ## DeclareOperation( "CosetTable", [ IsGroup, IsGroup ] ); ############################################################################# ## #O CosetTableNormalClosure( , ) ## ## ## ## ## ## returns the coset table of the finitely presented group G on the cosets ## of the normal closure of the subgroup H. ## ## ## DeclareOperation( "CosetTableNormalClosure", [ IsGroup, IsGroup ] ); ############################################################################# ## #F FactorGroup( , ) #O FactorGroupNC( , ) ## ## <#GAPDoc Label="FactorGroup"> ## ## ## ## ## ## returns the image of the NaturalHomomorphismByNormalSubgroup(G,N). ## The homomorphism will be stored in the attribute ## NaturalHomomorphism of the result. ## The NC version does not test whether N is normal in G. ## g:=Group((1,2,3,4),(1,2));;n:=Subgroup(g,[(1,2)(3,4),(1,3)(2,4)]);; ## gap> hom:=NaturalHomomorphismByNormalSubgroup(g,n); ## [ (1,2,3,4), (1,2) ] -> [ f1*f2, f1 ] ## gap> Size(ImagesSource(hom)); ## 6 ## gap> FactorGroup(g,n); ## Group([ f1, f2 ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "FactorGroup" ); DeclareOperation( "FactorGroupNC", [ IsGroup, IsGroup ] ); ############################################################################# ## #A NaturalHomomorphism() ## ## <#GAPDoc Label="NaturalHomomorphism"> ## ## ## ## ## For a group F obtained via FactorGroup, this attribute ## holds the natural homomorphism onto F ## ## ## <#/GAPDoc> ## DeclareAttribute( "NaturalHomomorphism", IsGroup ); ############################################################################# ## #O Index( , ) #O IndexNC( , ) ## ## <#GAPDoc Label="Index"> ## ## Index (&GAP; operation) ## ## ## ## ## For a subgroup U of the group G, ## returns the index ## [G:U] = |G| / |U| ## of U in G. ## The NC version does not test whether U is contained in ## G. ## Index(g,u); ## 4 ## ]]> ## ## ## <#/GAPDoc> ## InParentFOA( "Index", IsGroup, IsGroup, DeclareAttribute ); DeclareOperation( "IndexNC", [ IsGroup, IsGroup ] ); ############################################################################# ## #A IndexInWholeGroup( ) ## ## <#GAPDoc Label="IndexInWholeGroup"> ## ## ## ## ## If the family of elements of G itself forms a group P, this ## attribute returns the index of G in P. It is used ## primarily for free groups or finitely presented groups. ## ## ## <#/GAPDoc> ## DeclareAttribute( "IndexInWholeGroup", IsGroup ); ############################################################################# ## #A IndependentGeneratorsOfAbelianGroup( ) ## ## <#GAPDoc Label="IndependentGeneratorsOfAbelianGroup"> ## ## ## ## ## returns a list of generators a_1, a_2, \ldots of prime power order ## or infinite order of the abelian group A such that A is the ## direct product of the cyclic groups generated by the a_i. ## The list of orders of the returned generators must match the result of ## (taking into account that zero ## and are identified). ## g:=AbelianGroup(IsPermGroup,[15,14,22,78]);; ## gap> List(IndependentGeneratorsOfAbelianGroup(g),Order); ## [ 2, 2, 2, 3, 3, 5, 7, 11, 13 ] ## gap> AbelianInvariants(g); ## [ 2, 2, 2, 3, 3, 5, 7, 11, 13 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "IndependentGeneratorsOfAbelianGroup", IsGroup and IsAbelian ); ############################################################################# ## #O IndependentGeneratorExponents( , ) ## ## <#GAPDoc Label="IndependentGeneratorExponents"> ## ## ## ## ## For an abelian group G, ## with value the ## list [ a_1, \ldots, a_n ], ## this operation returns the exponent vector ## [ e_1, \ldots, e_n ] to represent ## g = \prod_i a_i^{{e_i}}. ## g := AbelianGroup([16,9,625]);; ## gap> gens := IndependentGeneratorsOfAbelianGroup(g);; ## gap> List(gens, Order); ## [ 9, 16, 625 ] ## gap> AbelianInvariants(g); ## [ 9, 16, 625 ] ## gap> r:=gens[1]^4*gens[2]^12*gens[3]^128;; ## gap> IndependentGeneratorExponents(g,r); ## [ 4, 12, 128 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "IndependentGeneratorExponents", [IsGroup and IsAbelian,IsMultiplicativeElementWithInverse] ); ############################################################################# ## #O IsConjugate( , , ) #O IsConjugate( , , ) ## ## <#GAPDoc Label="IsConjugate"> ## ## IsConjugate ## ## ## ## ## tests whether the elements x and y ## or the subgroups U and V are ## conjugate under the action of G. ## (They do not need to be contained in G.) ## This command is only a shortcut to . ## IsConjugate(g,Group((1,2,3,4),(1,3)),Group((1,3,2,4),(1,2))); ## true ## ]]> ##

## can be used to ## obtain conjugating elements. ## RepresentativeAction(g,(1,2),(3,4)); ## (1,3)(2,4) ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "IsConjugate", [ IsGroup, IsObject, IsObject ] ); ############################################################################# ## #O IsNormal( , ) ## ## <#GAPDoc Label="IsNormal"> ## ## ## ## ## returns true if the group G normalizes the group U ## and false otherwise. ##

## A group G normalizes a group U if and only if for every g \in G ## and u \in U the element u^g is a member of U. ## Note that U need not be a subgroup of G. ## IsNormal(g,u); ## false ## ]]> ## ## ## <#/GAPDoc> ## InParentFOA( "IsNormal", IsGroup, IsGroup, DeclareProperty ); ############################################################################# ## #O IsCharacteristicSubgroup(,) ## ## <#GAPDoc Label="IsCharacteristicSubgroup"> ## ## ## ## ## tests whether N is invariant under all automorphisms of G. ## IsCharacteristicSubgroup(g,u); ## false ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "IsCharacteristicSubgroup", [IsGroup,IsGroup] ); ############################################################################# ## #F IsPNilpotent( ,

) ## ## <#GAPDoc Label="IsPNilpotent"> ## ## ## ## ## A group is p-nilpotent if it possesses a normal p-complement. ## ## ## <#/GAPDoc> ## KeyDependentOperation( "IsPNilpotent", IsGroup, IsPosInt, "prime" ); ############################################################################# ## #F IsPSolvable( ,

) ## ## <#GAPDoc Label="IsPSolvable"> ## ## ## ## ## A finite group is p-solvable if every chief factor either has ## order not divisible by p, or is solvable. ##

## ## ## <#/GAPDoc> ## KeyDependentOperation( "IsPSolvable", IsGroup, IsPosInt, "prime" ); ############################################################################# ## #F IsSubgroup( , ) ## ## <#GAPDoc Label="IsSubgroup"> ## ## ## ## ## IsSubgroup returns true if U is a group that is a subset of the ## domain G. ## This is actually checked by calling IsGroup( U ) and ## IsSubset( G, U ); ## note that special methods for are available ## that test only generators of U if G is closed under the group ## operations. ## So in most cases, ## for example whenever one knows already that U is a group, ## it is better to call only . ## IsSubgroup(g,u); ## true ## gap> v:=Group((1,2,3),(1,2)); ## Group([ (1,2,3), (1,2) ]) ## gap> u=v; ## true ## gap> IsSubgroup(g,v); ## true ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "IsSubgroup" ); ############################################################################# ## #O IsSubnormal( , ) ## ## <#GAPDoc Label="IsSubnormal"> ## ## ## ## ## A subgroup U of the group G is subnormal if it is contained in a ## subnormal series of G. ## IsSubnormal(g,Group((1,2,3))); ## false ## gap> IsSubnormal(g,Group((1,2)(3,4))); ## true ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "IsSubnormal", [ IsGroup, IsGroup ] ); ############################################################################# ## #O NormalClosure( , ) ## ## <#GAPDoc Label="NormalClosure"> ## ## ## ## ## The normal closure of U in G is the smallest normal subgroup ## of the closure of G and U which contains U. ## NormalClosure(g,Subgroup(g,[(1,2,3)])); ## Group([ (1,2,3), (1,3,4) ]) ## gap> NormalClosure(g,Group((3,4,5))); ## Group([ (3,4,5), (1,5,4), (1,2,5) ]) ## ]]> ## ## ## <#/GAPDoc> ## InParentFOA( "NormalClosure", IsGroup, IsGroup, DeclareAttribute ); ############################################################################# ## #O NormalIntersection( , ) ## ## <#GAPDoc Label="NormalIntersection"> ## ## ## ## ## computes the intersection of G and U, assuming that G is normalized ## by U. This works faster than Intersection, but will not produce the ## intersection if G is not normalized by U. ## NormalIntersection(Group((1,2)(3,4),(1,3)(2,4)),Group((1,2,3,4))); ## Group([ (1,3)(2,4) ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "NormalIntersection", [ IsGroup, IsGroup ] ); ############################################################################# ## #O Normalizer( , ) #O Normalizer( , ) ## ## <#GAPDoc Label="Normalizer"> ## ## Normalizer ## ## ## ## ## For two groups G, U, ## computes the ## normalizer N_{G}(U), ## that is, the stabilizer of U ## under the conjugation action of G. ##

## For a group G and a group element g, ## ## computes N_{G}(\langle g \rangle). ##

## Normalizer(g,Subgroup(g,[(1,2,3)])); ## Group([ (1,2,3), (2,3) ]) ## ]]> ## ## ## <#/GAPDoc> ## InParentFOA( "Normalizer", IsGroup, IsObject, DeclareAttribute ); ############################################################################# ## #O CentralizerModulo(,,) full preimage of C_(G/N)(elm.N) ## ## <#GAPDoc Label="CentralizerModulo"> ## ## ## ## ## Computes the full preimage of the centralizer ## C_{{G/N}}(elm \cdot N) in G ## (without necessarily constructing the factor group). ## CentralizerModulo(g,n,(1,2)); ## Group([ (3,4), (1,3)(2,4), (1,4)(2,3) ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation("CentralizerModulo", [IsGroup,IsGroup,IsObject]); ############################################################################# ## #F PCentralSeries( ,

) ## ## <#GAPDoc Label="PCentralSeries"> ## ## ## ## ## The p-central series of G is defined by ## U_1:= G, ## U_i:= [G, U_{{i-1}}] U_{{i-1}}^{p}. ## ## ## <#/GAPDoc> ## KeyDependentOperation( "PCentralSeries", IsGroup, IsPosInt, "prime" ); ############################################################################# ## #F PRump( ,

) ## ## <#GAPDoc Label="PRump"> ## ## ## ## ## For a prime p, the p-rump of a group G is ## the subgroup G' G^{p}. ##

## @example missing!@ ## ## ## <#/GAPDoc> ## KeyDependentOperation( "PRump", IsGroup, IsPosInt, "prime" ); ############################################################################# ## #F PCore( ,

) ## ## <#GAPDoc Label="PCore"> ## ## ## ## ## PCore ## The p-core of G is the largest normal ## p-subgroup of G. ## It is the core of a Sylow p subgroup of G, ## see . ## PCore(g,2); ## Group([ (1,4)(2,3), (1,2)(3,4) ]) ## ]]> ## ## ## <#/GAPDoc> ## KeyDependentOperation( "PCore", IsGroup, IsPosInt, "prime" ); ############################################################################# ## #O SubnormalSeries( , ) ## ## <#GAPDoc Label="SubnormalSeries"> ## ## ## ## ## If U is a subgroup of G this operation returns a subnormal ## series that descends from G to a subnormal subgroup ## V \geq U. If U is subnormal, V = U. ## s:=SubnormalSeries(g,Group((1,2)(3,4))); ## [ Group([ (1,2,3,4), (1,2) ]), Group([ (1,2)(3,4), (1,3)(2,4) ]), ## Group([ (1,2)(3,4) ]) ] ## ]]> ## ## ## <#/GAPDoc> ## InParentFOA( "SubnormalSeries", IsGroup, IsGroup, DeclareAttribute ); ############################################################################# ## #F SylowSubgroup( ,

) ## ## <#GAPDoc Label="SylowSubgroup"> ## ## ## ## ## returns a Sylow p subgroup of the finite group G. ## This is a p-subgroup of G whose index in G is ## coprime to p. ## computes Sylow subgroups via the operation ## SylowSubgroupOp. ## g:=SymmetricGroup(4);; ## gap> SylowSubgroup(g,2); ## Group([ (1,2), (3,4), (1,3)(2,4) ]) ## ]]> ## ## ## <#/GAPDoc> ## KeyDependentOperation( "SylowSubgroup", IsGroup, IsPosInt, "prime" ); ############################################################################# ## #F SylowComplement( ,

) ## ## <#GAPDoc Label="SylowComplement"> ## ## ## ## ## returns a Sylow p-complement of the finite group G. ## This is a subgroup U of order coprime to p such that the ## index [G:U] is a p-power. ##

## At the moment methods exist only if G is solvable and &GAP; will ## issue an error if G is not solvable. ##

## SylowComplement(g,3); ## Group([ (1,2), (3,4), (1,3)(2,4) ]) ## ]]> ## ## ## <#/GAPDoc> ## KeyDependentOperation( "SylowComplement", IsGroup, IsPosInt, "prime" ); ############################################################################# ## #F HallSubgroup( ,

) ## ## <#GAPDoc Label="HallSubgroup"> ## ## ## ## ## computes a P-Hall subgroup for a set P of primes. ## This is a subgroup the order of which is only divisible by primes in ## P and whose index is coprime to all primes in P. Such a ## subgroup is unique up to conjugacy if G is solvable. ## The function computes Hall subgroups via the operation ## HallSubgroupOp. ##

## If G is solvable this function always returns a subgroup. If ## G is not solvable this function might return a subgroup (if it is ## unique up to conjugacy), a list of subgroups (which are representatives of ## the conjugacy classes in case there are several such classes) or fail ## if no such subgroup exists. ## h:=SmallGroup(60,10);; ## gap> u:=HallSubgroup(h,[2,3]); ## Group([ f1, f2, f3 ]) ## gap> Size(u); ## 12 ## gap> h:=PSL(3,5);; ## gap> HallSubgroup(h,[2,3]); ## [ , ## ] ## gap> HallSubgroup(h,[3,31]); ## Group( ## [ (2,18,11)(3,20,7)(4,19,9)(5,21,8)(6,17,10)(12,29,22)(13,27,26)(14, ## 31,23)(15,30,24)(16,28,25), (1,6,18,3,16,10,9,28,8,21,2,30,26,20, ## 5,7,12,23,22,11,25,13,14,31,15,17,4,24,29,27,19) ]) ## gap> HallSubgroup(h,[5,31]); ## fail ## ]]> ## ## ## <#/GAPDoc> ## KeyDependentOperation( "HallSubgroup", IsGroup, IsList, ReturnTrue ); ############################################################################# ## #O NrConjugacyClassesInSupergroup( , ) ## ## ## ## ## ## ## ## DeclareOperation( "NrConjugacyClassesInSupergroup", [ IsGroup, IsGroup ] ); ############################################################################# ## #O Factorization( , ) ## ## <#GAPDoc Label="Factorization"> ## ## ## ## ## returns a factorization of elm as word in the generators of the ## group G given in the attribute . ## The attribute of G ## will contain a map from the group G to the free group ## in which the word is expressed. ## The attribute of this map gives a ## list of generators and corresponding letters. ##

## The algorithm used computes all elements of the group to ensure a short ## word is found. Therefore this function should not be used when the ## group G has more than a few thousand elements. ## Because of this, one should not call this function within algorithms, ## but use homomorphisms instead. ## G:=SymmetricGroup( 6 );; ## gap> r:=(3,4);; s:=(1,2,3,4,5,6);; ## gap> # create subgroup to force the system to use the generators r and s: ## gap> H:= Subgroup(G, [ r, s ] ); ## Group([ (3,4), (1,2,3,4,5,6) ]) ## gap> Factorization( H, (1,2,3) ); ## (x2*x1)^2*x2^-2 ## gap> s*r*s*r*s^-2; ## (1,2,3) ## gap> MappingGeneratorsImages(EpimorphismFromFreeGroup(H)); ## [ [ x1, x2 ], [ (3,4), (1,2,3,4,5,6) ] ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "Factorization", [ IsGroup, IsMultiplicativeElementWithInverse ] ); ############################################################################# ## #O GroupByGenerators( ) . . . . . . . . . . . . . group by generators #O GroupByGenerators( , ) . . . . . . . . . . group by generators ## ## <#GAPDoc Label="GroupByGenerators"> ## ## ## ## ## ## returns the group G generated by the list gens. ## If a second argument id is present then this is stored as the identity ## element of the group. ##

## The value of the attribute of G need not be equal ## to gens. ## is the underlying operation called by . ## ## ## <#/GAPDoc> ## DeclareOperation( "GroupByGenerators", [ IsCollection ] ); DeclareOperation( "GroupByGenerators", [ IsCollection, IsMultiplicativeElementWithInverse ] ); ############################################################################# ## #O GroupWithGenerators( [, ] ) . . . . group with given generators ## ## <#GAPDoc Label="GroupWithGenerators"> ## ## ## ## ## returns the group G generated by ## the list gens. ## If a second argument id is present then this is stored as the ## identity element of the group. ## The value of the attribute of G ## is equal to gens. ## ## ## <#/GAPDoc> ## DeclareOperation( "GroupWithGenerators", [ IsCollection ] ); DeclareOperation( "GroupWithGenerators", [ IsCollection, IsMultiplicativeElementWithInverse ] ); ############################################################################# ## #F Group( , ... ) #F Group( [, ] ) ## ## <#GAPDoc Label="Group"> ## ## ## ## ## ## Group( gen, ... ) is the group generated by the arguments ## gen, ... ##

## If the only argument gens is a list that is not a matrix then ## Group( gens ) is the group generated by the elements of ## that list. ##

## If there are two arguments, a list gens and an element id, ## then Group( gens, id ) is the group generated by the ## elements of gens, with identity id. ##

## Note that the value of the attribute ## need not be equal to the list gens of generators entered as ## argument. ## Use if you want to be ## sure that the argument gens is stored as value of ## . ## g:=Group((1,2,3,4),(1,2)); ## Group([ (1,2,3,4), (1,2) ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "Group" ); ############################################################################# ## #F Subgroup( , ) . . . . . . . subgroup of generated by #F SubgroupNC( , ) #F Subgroup( ) ## ## <#GAPDoc Label="Subgroup"> ## ## ## ## ## ## ## creates the subgroup U of G generated by gens. ## The value of U will be G. ## The NC version does not check, whether the elements in gens ## actually lie in G. ##

## The unary version of ## creates a (shell) subgroup that does not even ## know generators but can be used to collect information about a ## particular subgroup over time. ## u:=Subgroup(g,[(1,2,3),(1,2)]); ## Group([ (1,2,3), (1,2) ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareSynonym( "Subgroup", SubmagmaWithInverses ); DeclareSynonym( "SubgroupNC", SubmagmaWithInversesNC ); ############################################################################# ## #F SubgroupByProperty( , ) ## ## <#GAPDoc Label="SubgroupByProperty"> ## ## ## ## ## creates a subgroup of G consisting of those elements fulfilling ## prop (which is a tester function). ## No test is done whether the property actually defines a subgroup. ##

## Note that currently very little functionality beyond an element test ## exists for groups created this way. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "SubgroupByProperty" ); ############################################################################# ## #A ElementTestFunction( ) ## ## ## ## ## ## This attribute contains a function that provides an element test for the ## group G. ## ## ## DeclareAttribute( "ElementTestFunction", IsGroup ); ############################################################################# ## #F SubgroupShell( ) ## ## <#GAPDoc Label="SubgroupShell"> ## ## ## ## ## creates a subgroup of G which at this point is not yet specified ## further (but will be later, for example by assigning a generating set). ## u:=SubgroupByProperty(g,i->3^i=3); ## ## gap> (1,3) in u; (1,4) in u; (1,5) in u; ## false ## true ## false ## gap> GeneratorsOfGroup(u); ## [ (1,2), (1,4,2) ] ## gap> u:=SubgroupShell(g); ## ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "SubgroupShell" ); ############################################################################# ## #C IsRightTransversal( ) ## ## ## ## ## ## ## ## DeclareCategory("IsRightTransversal",IsCollection); DeclareCategoryCollections("IsRightTransversal"); ############################################################################# ## #O RightTransversal( , ) ## ## <#GAPDoc Label="RightTransversal"> ## ## ## ## ## A right transversal t is a list of representatives for the set ## U \setminus G of right ## cosets (consisting of cosets Ug) of U in G. ##

## The object returned by is not a ## plain list, but an object that behaves like an immutable list of length ## [G:U], ## except if U is the trivial subgroup of G ## in which case may return the ## sorted plain list of coset representatives. ##

## The operation , ## called for a transversal t ## and an element g of G, will return the position of the ## representative in t that lies in the same coset of U as the ## element g does. ## (In comparison, will return fail if the ## element is not equal to the representative.) ## Functions that implement group actions such as ## or ## ## (see Chapter ) ## use , therefore it is possible to ## act on a right transversal to implement the action on the cosets. ## This is often much more efficient than acting on cosets. ## g:=Group((1,2,3,4),(1,2));; ## gap> u:=Subgroup(g,[(1,2,3),(1,2)]);; ## gap> rt:=RightTransversal(g,u); ## RightTransversal(Group([ (1,2,3,4), (1,2) ]),Group([ (1,2,3), (1,2) ])) ## gap> Length(rt); ## 4 ## gap> Position(rt,(1,2,3)); ## fail ## ]]> ##

## Note that the elements of a right transversal are not necessarily ## canonical in the sense of ## , but we may compute a list of ## canonical coset representatives by calling that function. ## (See also .) ##

## List(RightTransversal(g,u),i->CanonicalRightCosetElement(u,i)); ## [ (), (2,3,4), (1,2,3,4), (3,4) ] ## gap> PositionCanonical(rt,(1,2,3)); ## 1 ## gap> rt[1]; ## () ## ]]> ## ## ## <#/GAPDoc> ## InParentFOA( "RightTransversal", IsGroup, IsGroup, DeclareAttribute ); ############################################################################# ## #O IntermediateSubgroups( , ) ## ## <#GAPDoc Label="IntermediateSubgroups"> ## ## ## ## ## returns a list of all subgroups of G that properly contain ## U; that is all subgroups between G and U. ## It returns a record with a component subgroups, which is a list of ## these subgroups, as well as a component inclusions, ## which lists all maximality inclusions among these subgroups. ## A maximality inclusion is given as a list [i, j] indicating that ## the subgroup number i is a maximal subgroup of the subgroup number ## j, ## the numbers 0 and 1 + Length(subgroups) are used to ## denote U and G, respectively. ## ## ## <#/GAPDoc> ## DeclareOperation( "IntermediateSubgroups", [IsGroup, IsGroup] ); ############################################################################# ## #A IsomorphismTypeInfoFiniteSimpleGroup( ) ## ## <#GAPDoc Label="IsomorphismTypeInfoFiniteSimpleGroup"> ## ## IsomorphismTypeInfoFiniteSimpleGroup ## ## ## ## ## For a finite simple group G, ## ## returns a record with the components series, name ## and possibly parameter, ## describing the isomorphism type of G. ## The component name is a string that gives name(s) for G, ## and series is a string that describes the following series. ##

## (If different characterizations of G are possible ## only one is given by series and parameter, ## while name may give several names.) ## ## "A" ## ## Alternating groups, parameter gives the natural degree. ## ## "L" ## ## Linear groups (Chevalley type A), ## parameter is a list [ n, q ] that indicates ## L(n,q). ## ## "2A" ## ## Twisted Chevalley type {}^2A, ## parameter is a list [ n, q ] that indicates ## {}^2A(n,q). ## ## "B" ## ## Chevalley type B, ## parameter is a list [n, q ] that indicates ## B(n,q). ## ## "2B" ## ## Twisted Chevalley type {}^2B, ## parameter is a value q that indicates {}^2B(2,q). ## ## "C" ## ## Chevalley type C, ## parameter is a list [ n, q ] that indicates ## C(n,q). ## ## "D" ## ## Chevalley type D, ## parameter is a list [ n, q ] that indicates ## D(n,q). ## ## "2D" ## ## Twisted Chevalley type {}^2D, ## parameter is a list [ n, q ] that indicates ## {}^2D(n,q). ## ## "3D" ## ## Twisted Chevalley type {}^3D, ## parameter is a value q that indicates {}^3D(4,q). ## ## "E" ## ## Exceptional Chevalley type E, ## parameter is a list [ n, q ] that indicates ## E_n(q). ## The value of n is 6, 7, or 8. ## ## "2E" ## ## Twisted exceptional Chevalley type E_6, ## parameter is a value q that indicates {}^2E_6(q). ## ## "F" ## ## Exceptional Chevalley type F, ## parameter is a value q that indicates F(4,q). ## ## "2F" ## ## Twisted exceptional Chevalley type {}^2F (Ree groups), ## parameter is a value q that indicates {}^2F(4,q). ## ## "G" ## ## Exceptional Chevalley type G, ## parameter is a value q that indicates G(2,q). ## ## "2G" ## ## Twisted exceptional Chevalley type {}^2G (Ree groups), ## parameter is a value q that indicates {}^2G(2,q). ## ## "Spor" ## ## Sporadic simple groups, name gives the name. ## ## "Z" ## ## Cyclic groups of prime size, parameter gives the size. ## ## ##

## An equal sign in the name denotes different naming schemes for the same ## group, a tilde sign abstract isomorphisms between groups constructed ## in a different way. ##

## IsomorphismTypeInfoFiniteSimpleGroup( ## > Group((4,5)(6,7),(1,2,4)(3,5,6))); ## rec( ## name := "A(1,7) = L(2,7) ~ B(1,7) = O(3,7) ~ C(1,7) = S(2,7) ~ 2A(1,\ ## 7) = U(2,7) ~ A(2,2) = L(3,2)", parameter := [ 2, 7 ], series := "L" ) ## ]]> ##

## For a positive integer n, ## ## returns fail if n is not the order of a finite simple ## group, and a record as described for the case of a group G ## otherwise. ## If more than one simple group of order n exists then the result ## record contains only the name component, a string that lists the ## two possible isomorphism types of simple groups of this order. ##

## IsomorphismTypeInfoFiniteSimpleGroup( 5 ); ## rec( name := "Z(5)", parameter := 5, series := "Z" ) ## gap> IsomorphismTypeInfoFiniteSimpleGroup( 6 ); ## fail ## gap> IsomorphismTypeInfoFiniteSimpleGroup(Size(SymplecticGroup(6,3))/2); ## rec( ## name := "cannot decide from size alone between B(3,3) = O(7,3) and C\ ## (3,3) = S(6,3)", parameter := [ 3, 3 ] ) ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "IsomorphismTypeInfoFiniteSimpleGroup", IsGroup ); DeclareAttribute( "IsomorphismTypeInfoFiniteSimpleGroup", IsPosInt ); ############################################################################# ## #F SmallSimpleGroup( [, ] ) ## ## <#GAPDoc Label="SmallSimpleGroup"> ## ## ## ## The ith simple group of order order in the stored list, ## given in a small-degree permutation representation, or ## if no such simple group exists. ## ## ## If i is not given, it defaults to 1. ## Currently, all simple groups of order less than 10^6 are ## available via this function. ## ## gap> SmallSimpleGroup(60); ## A5 ## gap> SmallSimpleGroup(20160,1); ## A8 ## gap> SmallSimpleGroup(20160,2); ## PSL(3,4) ## ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "SmallSimpleGroup" ); ############################################################################# ## #F AllSmallNonabelianSimpleGroups( ) ## ## <#GAPDoc Label="AllSmallNonabelianSimpleGroups"> ## ## ## ## A list of all nonabelian simple groups whose order lies in the range ## orders. ## ## ## The groups are given in small-degree permutation representations. ## The returned list is sorted by ascending group order. ## Currently, all simple groups of order less than 10^6 are ## available via this function. ## ## gap> List(AllSmallNonabelianSimpleGroups([1..1000000]), ## > StructureDescription); ## [ "A5", "PSL(3,2)", "A6", "PSL(2,8)", "PSL(2,11)", "PSL(2,13)", ## "PSL(2,17)", "A7", "PSL(2,19)", "PSL(2,16)", "PSL(3,3)", ## "PSU(3,3)", "PSL(2,23)", "PSL(2,25)", "M11", "PSL(2,27)", ## "PSL(2,29)", "PSL(2,31)", "A8", "PSL(3,4)", "PSL(2,37)", "O(5,3)", ## "Sz(8)", "PSL(2,32)", "PSL(2,41)", "PSL(2,43)", "PSL(2,47)", ## "PSL(2,49)", "PSU(3,4)", "PSL(2,53)", "M12", "PSL(2,59)", ## "PSL(2,61)", "PSU(3,5)", "PSL(2,67)", "J1", "PSL(2,71)", "A9", ## "PSL(2,73)", "PSL(2,79)", "PSL(2,64)", "PSL(2,81)", "PSL(2,83)", ## "PSL(2,89)", "PSL(3,5)", "M22", "PSL(2,97)", "PSL(2,101)", ## "PSL(2,103)", "HJ", "PSL(2,107)", "PSL(2,109)", "PSL(2,113)", ## "PSL(2,121)", "PSL(2,125)", "O(5,4)" ] ## ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "AllSmallNonabelianSimpleGroups" ); ############################################################################# ## #A IsomorphismPcGroup( ) ## ## <#GAPDoc Label="IsomorphismPcGroup"> ## ## ## ## ## isomorphic ## returns an isomorphism from G onto an isomorphic pc group. ## The series chosen for this pc representation depends on ## the method chosen. ## G must be a polycyclic group of any kind, for example a solvable ## permutation group. ## G := Group( (1,2,3), (3,4,1) );; ## gap> iso := IsomorphismPcGroup( G ); ## Pcgs([ (2,4,3), (1,2)(3,4), (1,3)(2,4) ]) -> [ f1, f2, f3 ] ## gap> H := Image( iso ); ## Group([ f1, f2, f3 ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "IsomorphismPcGroup", IsGroup ); ############################################################################# ## #A IsomorphismSpecialPcGroup( ) ## ## <#GAPDoc Label="IsomorphismSpecialPcGroup"> ## ## ## ## ## returns an isomorphism from G onto an isomorphic pc group ## whose family pcgs is a special pcgs. ## (This can be beneficial to the runtime of calculations.) ## G may be a polycyclic group of any kind, for example a solvable ## permutation group. ## ## ## <#/GAPDoc> ## DeclareAttribute( "IsomorphismSpecialPcGroup", IsGroup ); ############################################################################# ## #A IsomorphismPermGroup( ) ## ## <#GAPDoc Label="IsomorphismPermGroup"> ## ## ## ## ## returns an isomorphism from the group G onto a permutation group ## which is isomorphic to G. ## The method will select a suitable permutation representation. ## g:=SmallGroup(24,12); ## ## gap> iso:=IsomorphismPermGroup(g); ## ## gap> Image(iso,g.3*g.4); ## (1,12)(2,16)(3,19)(4,5)(6,22)(7,8)(9,23)(10,11)(13,24)(14,15)(17, ## 18)(20,21) ## ]]> ##

## In many cases the permutation representation constructed by ## is regular. ## ## ## <#/GAPDoc> ## DeclareAttribute("IsomorphismPermGroup",IsGroup); ############################################################################# ## #A IsomorphismFpGroup( ) ## ## <#GAPDoc Label="IsomorphismFpGroup"> ## ## ## ## ## returns an isomorphism from the given finite group G to a finitely ## presented group isomorphic to G. ## The function first chooses a set of generators of G ## and then computes a presentation in terms of these generators. ## g := Group( (2,3,4,5), (1,2,5) );; ## gap> iso := IsomorphismFpGroup( g ); ## [ (4,5), (1,2,3,4,5), (1,3,2,4,5) ] -> [ F1, F2, F3 ] ## gap> fp := Image( iso ); ## ## gap> RelatorsOfFpGroup( fp ); ## [ F1^2, F1^-1*F2*F1*F2^-1*F3*F2^-2, F1^-1*F3*F1*F2*F3^-1*F2*F3*F2^-1, ## F2^5*F3^-5, F2^5*(F3^-1*F2^-1)^2, (F2^-2*F3^2)^2 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "IsomorphismFpGroup", IsGroup ); ############################################################################# ## #A IsomorphismFpGroupByGenerators( ,[,] ) #A IsomorphismFpGroupByGeneratorsNC( ,, ) ## ## <#GAPDoc Label="IsomorphismFpGroupByGenerators"> ## ## ## ## ## ## returns an isomorphism from a finite group G ## to a finitely presented group F isomorphic to G. ## The generators of F correspond to the ## generators of G given in the list gens. # If string is given it is used to name the generators of the ## finitely presented group. ##

## The NC version will avoid testing whether the elements in ## gens generate G. ## SetInfoLevel( InfoFpGroup, 1 ); ## gap> iso := IsomorphismFpGroupByGenerators( g, [ (1,2), (1,2,3,4,5) ] ); ## #I the image group has 2 gens and 5 rels of total length 39 ## [ (1,2), (1,2,3,4,5) ] -> [ F1, F2 ] ## gap> fp := Image( iso ); ## ## gap> RelatorsOfFpGroup( fp ); ## [ F1^2, F2^5, (F2^-1*F1)^4, (F2^-1*F1*F2*F1)^3, (F2^2*F1*F2^-2*F1)^2 ] ## ]]> ##

## The main task of the function ## is to find a presentation of ## G in the provided generators gens. ## In the case of a permutation group G it does this by first ## constructing a stabilizer chain of G and then it works through ## that chain from the bottom to the top, recursively computing a ## presentation for each of the involved stabilizers. ## The method used is essentially an implementation of John Cannon's ## multi-stage relations-finding algorithm as described in ## (see also for a more graph ## theoretical description). ## Moreover, it makes heavy use of Tietze transformations in each stage to ## avoid an explosion of the total length of the relators. ##

## Note that because of the random methods involved in the construction of ## the stabilizer chain the resulting presentations of G will in ## general be different for repeated calls with the same arguments. ##

## M12 := MathieuGroup( 12 ); ## Group([ (1,2,3,4,5,6,7,8,9,10,11), (3,7,11,8)(4,10,5,6), ## (1,12)(2,11)(3,6)(4,8)(5,9)(7,10) ]) ## gap> gens := GeneratorsOfGroup( M12 );; ## gap> iso := IsomorphismFpGroupByGenerators( M12, gens );; ## #I the image group has 3 gens and 23 rels of total length 628 ## gap> iso := IsomorphismFpGroupByGenerators( M12, gens );; ## #I the image group has 3 gens and 23 rels of total length 569 ## ]]> ##

## Also in the case of a permutation group G, the function ## supports the option ## method that can be used to modify the strategy. ## The option method may take the following values. ##

## ## method := "regular" ## ## This may be specified for groups of small size, up to 10^5 say. ## It implies that the function first constructs a regular representation ## R of G and then a presentation of R. ## In general, this presentation will be much more concise than the ## default one, but the price is the time needed for the construction of ## R. ## ## method := [ "regular", bound ] ## ## This is a refinement of the previous possibility. ## In this case, bound should be an integer, and if so the method ## "regular" as described above is applied to the largest ## stabilizer in the stabilizer chain of G whose size does not ## exceed the given bound and then the multi-stage algorithm is used to ## work through the chain from that subgroup to the top. ## ## method := "fast" ## ## This chooses an alternative method which essentially is a kind of ## multi-stage algorithm for a stabilizer chain of G but does not ## make any attempt do reduce the number of relators as it is done in ## Cannon's algorithm or to reduce their total length. ## Hence it is often much faster than the default method, but the total ## length of the resulting presentation may be huge. ## ## method := "default" ## ## This simply means that the default method shall be used, which is the ## case if the option method is not given a value. ## ## ##

## iso := IsomorphismFpGroupByGenerators( M12, gens : ## > method := "regular" );; ## #I the image group has 3 gens and 11 rels of total length 92 ## gap> iso := IsomorphismFpGroupByGenerators( M12, gens : ## > method := "fast" );; ## #I the image group has 3 gens and 162 rels of total length 3737 ## ]]> ##

## Though the option method := "regular" is only checked in the case ## of a permutation group it also affects the performance and the results of ## the function for other ## groups, e. g. for matrix groups. ## This happens because, for these groups, the function first calls the ## function to get a bijective action ## homomorphism from G to a suitable permutation group, ## P say, and then, recursively, calls itself for the group P ## so that now the option becomes relevant. ##

## G := ImfMatrixGroup( 5, 1, 3 ); ## ImfMatrixGroup(5,1,3) ## gap> gens := GeneratorsOfGroup( G ); ## [ [ [ -1, 0, 0, 0, 0 ], [ 0, 1, 0, 0, 0 ], [ 0, 0, 0, 1, 0 ], ## [ -1, -1, -1, -1, 2 ], [ -1, 0, 0, 0, 1 ] ], ## [ [ 0, 1, 0, 0, 0 ], [ 0, 0, 1, 0, 0 ], [ 0, 0, 0, 1, 0 ], ## [ 1, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 1 ] ] ] ## gap> iso := IsomorphismFpGroupByGenerators( G, gens );; ## #I the image group has 2 gens and 9 rels of total length 94 ## gap> iso := IsomorphismFpGroupByGenerators( G, gens : ## > method := "regular");; ## #I the image group has 2 gens and 6 rels of total length 56 ## gap> SetInfoLevel( InfoFpGroup, 0 ); ## gap> iso; ## [ F1, F2 ]> ## gap> ConstituentsCompositionMapping(iso); ## [ , ## [ (2,3)(4,6,10,17,7,12)(5,8,13,19,26,24)(9,15,23,35,31,43)(14,21, ## 32)(16,25,38)(18,27,39,33,45,57)(20,30,36,48,28,40)(22,34,44, ## 55,66,74)(29,41,51,61,60,47)(37,49,54,52,46,58)(42,53,65)(50, ## 62,63,72,56,67)(59,69,77,78,64,73)(68,71,75)(76,79), ## (1,2,4,7)(3,5,9,16)(6,11,18,28)(8,14,22,30)(12,13,20,31)(15,24, ## 37,50)(17,26,38,45)(19,29,42,27)(21,33,46,35)(23,36,25,39)(32, ## 44,56,40)(34,47,59,70)(41,52,64,72)(43,54,65,66)(48,60)(49,61, ## 71,55)(51,63,53,57)(58,68,76,62)(67,75,74,77)(73,78,80,79) ## ] -> [ F1, F2 ] ] ## ]]> ##

## Since &GAP; cannot decompose elements of a matrix group into generators, ## the resulting isomorphism is stored as a composition of a (faithful) ## permutation action on vectors and a homomorphism from the permutation image ## to the finitely presented group. In such a situation the constituent ## mappings can be obtained via ## as separate &GAP; objects. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("IsomorphismFpGroupByGenerators"); DeclareOperation( "IsomorphismFpGroupByGeneratorsNC", [ IsGroup, IsList, IsString ] ); DeclareOperation( "IsomorphismFpGroupBySubnormalSeries", [IsGroup, IsList, IsString] ); DeclareOperation( "IsomorphismFpGroupByCompositionSeries", [IsGroup, IsString] ); DeclareOperation( "IsomorphismFpGroupByChiefSeries", [IsGroup, IsString] ); DeclareGlobalFunction( "IsomorphismFpGroupByPcgs" ); ############################################################################# ## #A PrimePowerComponents( ) ## ## ## ## ## ## ## ## DeclareAttribute( "PrimePowerComponents", IsMultiplicativeElement ); ############################################################################# ## #O PrimePowerComponent( ,

) ## ## ## ## ## ## ## ## DeclareOperation( "PrimePowerComponent", [ IsMultiplicativeElement, IsPosInt ] ); ############################################################################# ## #O PowerMapOfGroup( , , ) ## ## ## ## ## ## is a list of positions, ## at position i the position of the conjugacy class containing ## the n-th powers of the elements in the i-th class ## of the list ccl of conjugacy classes. ## ## ## DeclareOperation( "PowerMapOfGroup", [ IsGroup, IsInt, IsHomogeneousList ] ); ############################################################################# ## #F PowerMapOfGroupWithInvariants( , , , ) ## ## ## ## ## ## is a list of integers, at position i the position of the conjugacy ## class containimg the n-th powers of elements in class i ## of ccl. ## The list invariants contains all invariants besides element order ## that shall be used before membership tests. ##

## Element orders are tested first in any case since they may allow a ## decision without forming the n-th powers of elements. ## ## ## DeclareGlobalFunction( "PowerMapOfGroupWithInvariants" ); ############################################################################# ## #O HasAbelianFactorGroup( , ) ## ## <#GAPDoc Label="HasAbelianFactorGroup"> ## ## ## ## ## tests whether G / N is abelian ## (without explicitly constructing the factor group). ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("HasAbelianFactorGroup"); ############################################################################# ## #O HasSolvableFactorGroup( , ) ## ## <#GAPDoc Label="HasSolvableFactorGroup"> ## ## ## ## ## tests whether G / N is solvable ## (without explicitly constructing the factor group). ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("HasSolvableFactorGroup"); ############################################################################# ## #O HasElementaryAbelianFactorGroup( , ) ## ## <#GAPDoc Label="HasElementaryAbelianFactorGroup"> ## ## ## ## ## tests whether G / N is elementary abelian ## (without explicitly constructing the factor group). ## HasAbelianFactorGroup(g,n); ## false ## gap> HasAbelianFactorGroup(DerivedSubgroup(g),n); ## true ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("HasElementaryAbelianFactorGroup"); ############################################################################# ## #F IsGroupOfFamily() ## ## ## ## ## ## This filter indicates that the group G is the group ## which is stored in the family fam of its elements ## as fam!.wholeGroup. ## ## ## DeclareFilter("IsGroupOfFamily"); ############################################################################# ## #F Group_PseudoRandom() ## ## ## ## ## ## Computes a pseudo-random element of G by product replacement. ## (This is installed as a method for PseudoRandom ## under the condition that generators are known.) ## ## ## DeclareGlobalFunction("Group_PseudoRandom"); ############################################################################# ## #E gap-4r6p5/lib/extlset.gd0000644000175000017500000001436512172557252013724 0ustar billbill############################################################################# ## #W extlset.gd GAP library Thomas Breuer ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file declares the operations for external left sets. ## ############################################################################# ## #C IsExtLSet( ) ## ## ## ## ## ## An external left set is a domain with an action of a domain ## from the left. ## ## ## DeclareCategory( "IsExtLSet", IsDomain ); ############################################################################# ## #C IsAssociativeLOpDProd( ) ## ## ## ## ## ## is true iff a * ( x * y ) = ( a * x ) * y ## for a \in E and x, y \in D. ## ## ## DeclareCategory( "IsAssociativeLOpDProd", IsExtLSet ); ############################################################################# ## #C IsAssociativeLOpEProd( ) ## ## ## ## ## ## is true iff a * ( b * x ) = ( a * b ) * x ## for a, b \in E and x \in D. ## ## ## DeclareCategory( "IsAssociativeLOpEProd", IsExtLSet ); ############################################################################# ## #C IsDistributiveLOpDProd( ) ## ## ## ## ## ## is true iff a * ( x * y ) = ( a * x ) * ( a * y ) ## for a \in E and x, y \in D. ## ## ## DeclareCategory( "IsDistributiveLOpDProd", IsExtLSet ); ############################################################################# ## #C IsDistributiveLOpDSum( ) ## ## ## ## ## ## is true iff a * ( x + y ) = ( a * x ) + ( a * y ) ## for a \in E and x, y \in D. ## ## ## DeclareCategory( "IsDistributiveLOpDSum", IsExtLSet ); ############################################################################# ## #C IsDistributiveLOpEProd( ) ## ## ## ## ## ## is true iff ( a * b ) * x = ( a * x ) * ( b * x ) ## for a, b \in E and x \in D. ## ## ## DeclareCategory( "IsDistributiveLOpEProd", IsExtLSet ); ############################################################################# ## #C IsDistributiveLOpESum( ) ## ## ## ## ## ## is true iff ( a + b ) * x = ( a * x ) + ( b * x ) ## for a, b \in E and x \in D. ## ## ## DeclareCategory( "IsDistributiveLOpESum", IsExtLSet ); ############################################################################# ## #C IsTrivialLOpEOne( ) ## ## ## ## ## ## is true iff the identity element e \in E acts trivially on D, ## that is, e * x = x for x \in D. ## ## ## ## DeclareCategory( "IsTrivialLOpEOne", IsExtLSet ); ############################################################################# ## #C IsTrivialLOpEZero( ) ## ## ## ## ## ## is true iff the zero element z \in E acts trivially on D, ## that is, z * x = Z for x \in D and the zero element Z of D. ## ## ## ## DeclareCategory( "IsTrivialLOpEZero", IsExtLSet ); ############################################################################# ## #C IsLeftActedOnByRing( ) ## ## ## ## ## ## ## ## DeclareCategory( "IsLeftActedOnByRing", IsExtLSet ); ############################################################################# ## #P IsLeftActedOnByDivisionRing( ) ## ## ## ## ## ## This is a property because then we need not duplicate code that creates ## either left modules or left vector spaces. ## ## ## DeclareProperty( "IsLeftActedOnByDivisionRing", IsExtLSet and IsLeftActedOnByRing ); ############################################################################# ## #C IsLeftActedOnBySuperset( ) ## ## ## ## ## ## ## ## DeclareCategory( "IsLeftActedOnBySuperset", IsExtLSet ); ############################################################################# ## #A GeneratorsOfExtLSet( ) ## ## ## ## ## ## ## ## DeclareAttribute( "GeneratorsOfExtLSet", IsExtLSet ); ############################################################################# ## #A LeftActingDomain( ) ## ## <#GAPDoc Label="LeftActingDomain"> ## ## ## ## ## Let D be an external left set, that is, D is closed under the action ## of a domain L by multiplication from the left. ## Then L can be accessed as value of LeftActingDomain for D. ## ## ## <#/GAPDoc> ## DeclareAttribute( "LeftActingDomain", IsExtLSet ); ############################################################################# ## #E gap-4r6p5/lib/attr.gi0000644000175000017500000000262112172557252013203 0ustar billbill############################################################################# ## #W attr.gi GAP library Steve Linton ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file defines some functions that tweak the behaviour of attributes ## ############################################################################# ## #F EnableAttributeValueStoring( ) tell the attribute to resume ## storing values ## InstallGlobalFunction(EnableAttributeValueStoring, function( attr ) Assert(1,IsOperation(attr)); Assert(2,Setter(attr) <> false); Info(InfoAttributes + InfoWarning, 3, "Enabling value storing for ",NAME_FUNC(attr)); SET_ATTRIBUTE_STORING( attr, true); end); ############################################################################# ## #F DisableAttributeValueStoring( ) tell the attribute to stop ## storing values ## InstallGlobalFunction(DisableAttributeValueStoring, function( attr ) Assert(1,IsOperation(attr)); Assert(2,Setter(attr) <> false); Info(InfoAttributes + InfoWarning, 2, "Disabling value storing for ",NAME_FUNC(attr)); SET_ATTRIBUTE_STORING( attr, false); end); gap-4r6p5/lib/claspcgs.gi0000644000175000017500000017215112172557252014036 0ustar billbill############################################################################# ## #W claspcgs.gi GAP library Heiko Theißen ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains functions that deal with conjugacy topics in solvable ## groups using affine methods. These topics includes calculating the ## (rational) conjugacy classes and centralizers in solvable groups. The ## functions rely only on the existence of pcgs, not on the particular ## representation of the groups. ## ############################################################################# ## #F SubspaceVectorSpaceGroup( ,

, , ) ## ## This function creates a record containing information about a complement ## in to the span of . ## InstallGlobalFunction( SubspaceVectorSpaceGroup, function( N, p, gens,howmuch ) local zero, one, r, ran, n, nan, cg, pos, Q, i, j, v; one:=One( GF( p ) ); zero:=0 * one; r:=Length( N ); ran:=[ 1 .. r ]; n:=Length( gens ); nan:=[ 1 .. n ]; Q:=[ ]; if n <> 0 and IsMultiplicativeElementWithInverse( gens[ 1 ] ) then Q:=List( gens, gen -> ExponentsOfPcElement( N, gen ) ) * one; else Q:=ShallowCopy( gens ); fi; cg:=rec( matrix :=[ ], one :=one, baseComplement:=ShallowCopy( ran ), commutator :=0, centralizer :=0, dimensionN :=r, dimensionC :=n ); if n = 0 or r = 0 then cg.inverse:=NullMapMatrix; cg.projection :=IdentityMat( r, one ); cg.needed :=[]; return cg; fi; for i in nan do cg.matrix[ i ]:=Concatenation( Q[ i ], zero * nan ); cg.matrix[ i ][ r + i ]:=one; od; TriangulizeMat( cg.matrix ); pos:=1; for v in cg.matrix do while v[ pos ] = zero do pos:=pos + 1; od; RemoveSet( cg.baseComplement, pos ); if pos <= r then cg.commutator :=cg.commutator + 1; else cg.centralizer:=cg.centralizer + 1; fi; od; if howmuch=1 then return Immutable(cg); fi; cg.needed :=[ ]; cg.projection :=IdentityMat( r, one ); # Find a right pseudo inverse for . Append( Q, cg.projection ); Q:=MutableTransposedMat( Q ); TriangulizeMat( Q ); Q:=TransposedMat( Q ); i:=1; j:=1; while i <= Length( N ) do while j <= Length( gens ) and Q[ j ][ i ] = zero do j:=j + 1; od; if j <= Length( gens ) and Q[ j ][ i ] <> zero then cg.needed[ i ]:=j; else # If does not have full rank, terminate when the bottom row # is reached. i:=Length( N ); fi; i:=i + 1; od; if IsEmpty( cg.needed ) then cg.inverse:=NullMapMatrix; else cg.inverse:=Q{ Length( gens ) + ran } { [ 1 .. Length( cg.needed ) ] }; cg.inverse:=ImmutableMatrix(p,cg.inverse,true); fi; if IsEmpty( cg.baseComplement ) then cg.projection:=NullMapMatrix; else # Find a base change matrix for the projection onto the complement. for i in [ 1 .. cg.commutator ] do cg.projection[ i ][ i ]:=zero; od; Q:=[ ]; for i in [ 1 .. cg.commutator ] do Q[ i ]:=cg.matrix[ i ]{ ran }; od; for i in [ cg.commutator + 1 .. r ] do Q[ i ]:=ListWithIdenticalEntries( r, zero ); Q[ i ][ cg.baseComplement[ i-r+Length(cg.baseComplement) ] ] :=one; od; cg.projection:=cg.projection ^ Q; cg.projection:=cg.projection{ ran }{ cg.baseComplement }; cg.projection:=ImmutableMatrix(p,cg.projection,true); fi; return Immutable(cg); end ); ############################################################################# ## #F KernelHcommaC( , , , ) ## ## Given a homomorphism C -> N, c |-> [h,c], this function determines (a) a ## vector space decomposition N = [h,C] + K with projection onto K and (b) ## the ``kernel'' S < C which plays the role of C_G(h) in lemma 3.1 of ## [Mecky, Neub\"user, Bull. Aust. Math. Soc. 40]. ## InstallGlobalFunction( KernelHcommaC, function( N, h, C, howmuch ) local i, tmp, v,x; x:=List( C, c -> Comm( h, c ) ); N!.subspace:=SubspaceVectorSpaceGroup(N,RelativeOrders(N)[1],x,howmuch); tmp:=[ ]; for i in [ N!.subspace.commutator + 1 .. N!.subspace.commutator + N!.subspace.centralizer ] do v:=N!.subspace.matrix[ i ]; tmp[ i - N!.subspace.commutator ]:=PcElementByExponentsNC( C, v{ [ N!.subspace.dimensionN + 1 .. N!.subspace.dimensionN + N!.subspace.dimensionC ] } ); od; return tmp; end ); ############################################################################# ## #F CentralStepClEANS( ,, , , , ) ## # if is true the normal subgroup is not necessarily in the series and # we cannot call `ExtendedPcgs' but must form a new pcgs. InstallGlobalFunction( CentralStepClEANS, function( home,H, U, N, cl,off ) local classes, # classes to be constructed, the result field, # field over which is a vector space h, # preimage `cl.representative' under gens, # preimage `Centralizer( cl )' under cemodk, cengen, exp, w, # coefficient vectors for projection along $[h,N]$ kern,img, c,nc; # loop variable field:=GF( RelativeOrders( N )[ 1 ] ); h:=cl.representative; if IsBound(cl.centralizerpcgs) then if IsSubset(cl.centralizerpcgs,DenominatorOfModuloPcgs(N!.capH)) then cemodk:=Filtered(cl.centralizerpcgs,i->not i in DenominatorOfModuloPcgs(N!.capH)); else cemodk:=cl.centralizerpcgs mod DenominatorOfModuloPcgs( N!.capH ); fi; else cemodk:=InducedPcgs(home, cl.centralizer ) mod DenominatorOfModuloPcgs( N!.capH ); fi; kern:=DenominatorOfModuloPcgs( N!.capH ); if IsBound(cl.candidates) then img:=KernelHcommaC( N, h, cemodk,2 ); else img:=KernelHcommaC( N, h, cemodk,1 ); fi; if off then cengen:=InducedPcgsByPcSequenceAndGenerators(ParentPcgs( kern ), kern, img ); else #cengen:=ExtendedPcgs(kern,img); cengen:=Concatenation(img,kern); fi; #C:=SubgroupByPcgs( H, cengen ); classes:=[ ]; if IsBound( cl.candidates ) then gens:=cemodk{ N!.subspace.needed }; if IsIdenticalObj( FamilyObj( U ), FamilyObj( cl.candidates ) ) then for c in cl.candidates do exp:=ExponentsOfPcElement( N, LeftQuotient( h, c ) ); MultRowVector( exp, One( field ) ); w:=exp * N!.subspace.projection; exp{ N!.subspace.baseComplement }:= exp{ N!.subspace.baseComplement }-w; nc:=rec( representative:=h * PcElementByExponentsNC ( N, N!.subspace.baseComplement, w ), #centralizer:=C, #centralizerpcgs:=cengen, cengen:=cengen, operator:=LinearCombinationPcgs( gens, exp * N!.subspace.inverse, One( cl.candidates[1] ))^(-1)); # check that action is really OK Assert(1,c^nc.operator/nc.representative in Group(DenominatorOfModuloPcgs(N),One(U))); Add( classes, nc ); od; else c:=rec( representative:=cl.candidates, #centralizer:=C, #centralizerpcgs:=cengen, cengen:=cengen, operator:=One( H ) ); Add( classes, c ); fi; else gens:=N!.subspace.baseComplement; for w in field ^ Length( gens ) do c:=rec( representative:=h * PcElementByExponentsNC( N,gens,w ), #centralizer:=C ) #centralizerpcgs:=cengen ) cengen:=cengen ); Add( classes, c ); od; fi; return classes; end ); ############################################################################# ## #F CorrectConjugacyClass(,,,,,,, ) ## cf. MN89 ## InstallGlobalFunction( CorrectConjugacyClass, function( home, h, n, stab, N,depthlev, cNh,off ) local cl, comm, s, ostab; ostab:=stab; #AH: take only those elements module N - the part in N is cNh stab:=Filtered(stab,i->DepthOfPcElement(home,i)0 and Length(stab)>0 then comm:=[]; for s in [ 1 .. Length( stab ) ] do comm[ s ]:=ExponentsOfPcElement( N, Comm( n, stab[ s ] )*Comm( h, stab[ s ] )); od; comm:=comm * N!.subspace.inverse; for s in [ 1 .. Length( comm ) ] do stab[ s ]:=stab[ s ] / PcElementByExponentsNC ( N!.capH, N!.subspace.needed, comm[ s ] ); od; fi; if off then stab:=InducedPcgsByPcSequenceAndGenerators(ParentPcgs( cNh ), cNh, stab ); elif IsList(cNh) and IsList(cNh[1]) then #stab:=ExtendedPcgs(cNh[1],Concatenation(stab,cNh[2])); stab:=Concatenation(stab,cNh[2],cNh[1]); else #stab:=ExtendedPcgs(cNh,stab); stab:=Concatenation(stab,cNh); fi; cl:=rec( representative:=h * n, cengen:=stab ); return cl; end ); ############################################################################# ## #F GeneralStepClEANS( , , , ,, , ) ## # if is true the normal subgroup is not necessarily in the series and # we cannot call `ExtendedPcgs' but must form a new pcgs. InstallGlobalFunction(GeneralStepClEANS,function(home, H, U, N,nexpo, cl, off) local classes, # classes to be constructed, the result field, # field over which is a vector space h, # preimage `cl.representative' under cNh, # centralizer of in gens, # preimage `Centralizer( cl )' under r, # dimension of ran, # constant range `[ 1 .. r ]' aff, # as affine space xset, # affine operation of on imgs, M, # generating matrices for affine operation orb, # orbit of affine operation Rep, # representative function to use for n, k, # cf. Mecky--Neub\"user paper cls,rep,pos,# set of classes with canonical representatives j, c, ca, i, # loop variables S, # orbit-stabilizer ceve,#xponent vector p, # positions Cgens, # generators of C in N next,blist, # orbit stabilizer algo depthlev, # depth at which N starts one,zero, vec, kern,img; depthlev:=DepthOfPcElement(home,N[1]); Cgens:=cl.centralizerpcgs; field:=GF( RelativeOrders( N )[ 1 ] ); h:=cl.representative; # Determine the subspace $[h,N]$ and calculate the centralizer of . kern:=DenominatorOfModuloPcgs( N!.capH ); img:=KernelHcommaC( N, h, N!.capH,2 ); r:=Length( N!.subspace.baseComplement ); #AH: Take only those which are not in N gens:=Cgens mod NumeratorOfModuloPcgs(N!.capH); if not (off or IsBound(cl.candidates)) and r=0 then # special treatment: The commutators span the whole space # this is noncentral_case4 in GAP3 c:=CorrectConjugacyClass( home, h, One(gens[1]), gens, N, depthlev,[kern,img],off ); return [c]; fi; ran:=[ 1 .. r ]; if off then cNh:=InducedPcgsByPcSequenceAndGenerators(ParentPcgs( kern ), kern, img ); else #cNh:=ExtendedPcgs(kern,img); cNh:=[kern,img]; # we only need cNh to extend it fi; # Construct matrices for the affine operation on $N/[h,N]$. aff:=ExtendedVectors( field ^ r ); one:=One(field); zero:=Zero(field); imgs:=[ ]; for c in gens do ceve:=ExponentsOfPcElement(home,c,[1..depthlev-1]); M:=[ ]; for i in [ 1 .. r ] do p:=N!.subspace.baseComplement[i]; # construct the vector image vec:=p; for j in [1..Length(ceve)] do for k in [1..ceve[j]] do if IsInt(vec) then vec:=nexpo[j][vec]; else vec:=vec*nexpo[j]; fi; od; od; M[ i ]:=Concatenation( vec * N!.subspace.projection, [ zero ] ); od; i:=Comm( h, c ); M[ r + 1 ]:=Concatenation( ExponentsOfPcElement ( N, i ) * N!.subspace.projection, [ one ] ); M:=ImmutableMatrix(field,M,true); Add( imgs, M ); od; classes:=[ ]; if IsBound( cl.candidates ) then # not yet improved: we use an external set and thus have to give a # full list of generators of C: imgs:=Concatenation(imgs,List([1..Length(Cgens)-Length(gens)],i->IdentityMat( r + 1, field ))); gens:=Cgens; xset:=ExternalSet(SubgroupByPcgs(H,Cgens),aff,gens,imgs,OnPoints); if IsIdenticalObj( FamilyObj( U ), FamilyObj( cl.candidates ) ) then Rep:=CanonicalRepresentativeOfExternalSet; else cl.candidates:=[ cl.candidates ]; Rep:=Representative; fi; cls:=[ ]; for ca in cl.candidates do n:=ExponentsOfPcElement( N, LeftQuotient( h, ca ) ) * One( field ); ConvertToVectorRep(n, field); k:=n * N!.subspace.projection; orb:=Concatenation( k, [ One( field ) ]); ConvertToVectorRep(orb, field); orb:=ExternalOrbit( xset, Immutable(orb) ); rep:=PcElementByExponentsNC( N, N!.subspace.baseComplement, Rep( orb ){ ran } ); pos:=Position( cls, rep ); if pos = fail then Add( cls, rep ); c:=StabilizerOfExternalSet( orb ); if IsIdenticalObj( Rep, CanonicalRepresentativeOfExternalSet ) then c:=ConjugateSubgroup( c, ActorOfExternalSet( orb ) ); fi; c:=CorrectConjugacyClass( home, h, rep, InducedPcgs(home,c), N, depthlev,cNh,off ); else c:=rec( representative:=h * rep, #centralizer:=classes[ pos ].centralizer ) #centralizerpcgs:=classes[ pos ].centralizerpcgs ) cengen:=classes[ pos ].cengen ); fi; n:=ShallowCopy( -n ); n{ N!.subspace.baseComplement }:= k + n{ N!.subspace.baseComplement }; c.operator:=PcElementByExponentsNC( N, N!.subspace.needed, n * N!.subspace.inverse ); # Now (h.n)^c.operator = h.k if IsIdenticalObj(Rep,CanonicalRepresentativeOfExternalSet) then c.operator:=c.operator * ActorOfExternalSet( orb ); # Now (h.n)^c.operator = h.rep mod [h,N] k:=PcElementByExponentsNC( N, N!.subspace.needed, ExponentsOfPcElement( N, LeftQuotient ( c.representative, ca ^ c.operator ) ) * N!.subspace.inverse ); c.operator:=c.operator / k; # Now (h.n)^c.operator = h.rep fi; Add( classes, c ); od; else #xset:=ExternalSet( C, aff, gens, imgs ); #k:=ExternalOrbitsStabilizers( xset ); # do the orbits stuff ourselves blist:=BlistList([1..Length(aff)],[]); next:=1; k:=[]; while next<>fail do S:=Pcs_OrbitStabilizer(gens,aff,aff[next],imgs,OnRight); # tick off if IsPositionDictionary(S.dictionary) then UniteBlist(blist,S.dictionary!.blist); else for i in S.orbit do blist[PositionCanonical(aff,i)]:=true; od; fi; Unbind(S.dictionary); Add(k,S); next:=Position(blist,false,next); od; for orb in k do rep:=PcElementByExponentsNC( N, N!.subspace.baseComplement, orb.orbit[1]{ ran } ); c:=CorrectConjugacyClass( home, h, rep, #orb.stabilizer, N, depthlev,cNh,off ) orb.stabpcs, N, depthlev,cNh,off ); Add( classes, c ); od; fi; return classes; end ); ############################################################################# ## #F ClassesSolvableGroup(, [,]) . . . . . ## ## In this function classes are described by records with components ## `representative', `centralizer', `galoisGroup' (for rational classes). If ## are given, their classes will have a canonical ## `representative' ## InstallGlobalFunction(ClassesSolvableGroup, function(arg) local G, home, # the group and the home pcgs H,Hp, # acting group mustlift, liftkerns, QH,QG, fhome,ofhome, first, mode, # LSB: ratCl | power | test :MSB candidates, # candidates to be replaced by their canonical reps. eas, # elementary abelian series in step, # counter looping over K, L, # members of indstep, # indice normal steps Ldep, # depth of L in pcgs Kp,mK,Lp,mL, # induced and modulo pcgs's LcapH,KcapH, # intersections N, cent, # elementary abelian factor, for affine action cls, newcls, # classes in range/source of homomorphism cli, # index news, # new classes obtained in step cl, # class looping over opr, exp, # (candidates[i]^opr[i])^exp[i]=cls[i].representative team, # team of candidates with same image modulo blist,pos,q, # these control grouping of into s p, # prime dividing $|G|$ i,c, # loop variables opt, # options consider, # consider function divi, inflev, # InfoLevel flag nexpo, # N-Exponents of the elements of N conjugated allcent; # DivisorsInt(Size(G)) (used for Info) inflev:=InfoLevel(InfoClasses)>1; mode:=arg[2]; # explained below whenever it appears if mode mod 2=1 then Error("this function does not cater for rational classes any longer"); fi; G:=arg[1]; if Length(arg)=3 then opt:=ShallowCopy(arg[3]); # convert series to pcgs if IsBound(opt.series) and not IsBound(opt.pcgs) then fi; else opt:=rec(); fi; # is a list of elements whose classes will be output (but # with canonical representatives), see comment above. Or is # just one element, from whose output class the centralizer will be read # off. H:=G; if IsBound(opt.candidates) then candidates:=opt.candidates; if not ForAll(candidates,i->i in G) then G:=ClosureGroup(H,candidates); fi; else candidates:=false; fi; if IsBound(opt.consider) then consider:=opt.consider; else consider:=true; fi; # Treat the case of a trivial group. if IsTrivial(H) then if mode=4 then # test conjugacy of two elements return One(G); else cl:=rec(representative:=One(G), centralizer:=H); fi; if candidates<>false then cls:=List(candidates, c -> cl); else cls:=[cl]; fi; return cls; fi; # Calculate a (central) elementary abelian series with all pcgs induced # w.r.t. . if IsBound(opt.pcgs) then # we prescribed a series home:=opt.pcgs; eas:=EANormalSeriesByPcgs(home); cent:=false; elif IsPrimePowerInt(Size(G)) then p:=FactorsInt(Size(G))[1]; home:=PcgsPCentralSeriesPGroup(G); eas:=PCentralNormalSeriesByPcgsPGroup(home); cent:=ReturnTrue; else home:=PcgsElementaryAbelianSeries(G); eas:=EANormalSeriesByPcgs(home); cent:=function(cl, N, L) return ForAll(N, k -> ForAll #(InducedPcgs(home,cl.centralizer), (cl.centralizerpcgs, #T was: Only those elements form the induced PCGS. The subset seemed to #T enforce taking only the elements up, but the ordering of the series used #T may be different then the ordering in the PCGS. So this will fail. AH #T one might pick the right ones, but this would be almost the same work. #T { [1 .. Length(InducedPcgsWrtHomePcgs(cl.centralizer)) #T - Length(InducedPcgsWrtHomePcgs(L))] }, c -> Comm(k, c) in L)); end; cent:=false; fi; if cent=false then # AH, 26-4-99: Test centrality not via `in' but via exponents cent:=function(pcgs,grpg,Npcgs,dep) local i,j; for i in grpg do for j in Npcgs do if DepthOfPcElement(pcgs,Comm(j,i))false); liftkerns:=[]; if candidates=false then # we only want to go in factor groups if no candidates are given # (otherwise we'd have to take care not to forget tails when mapping in # the factor groups) step:=2; # the first step we'd have for i in [2..Length(eas)-1] do if Index(G,eas[i])>1000 or Index(G,eas[i+1])>10000 then # only form a factor if the factor is large enough or the next step # would be large # form a factor by i and go to this factor at the first time (index # step) no factor representation was given mustlift[step]:=true; liftkerns[step]:=eas[i]; step:=i+1; fi; od; if step>2 then # we created a factor, so we have to lift at the end mustlift[step]:=true; liftkerns[step]:=eas[Length(eas)]; fi; fi; Info(InfoClasses,1,"Series of sizes ",List(eas,Size)); if mode<3 and inflev then divi:=DivisorsInt(Size(G)); Info(InfoClasses,2,"centsiz: ",divi); fi; # Initialize the algorithm for the trivial group. step:=1; L:=eas[step]; Lp:=InducedPcgs(home,L); if not IsIdenticalObj( G, H ) then Hp:=InducedPcgs(home, H ); LcapH:=NormalIntersectionPcgs( home, Hp, Lp ); fi; if candidates<>false then mL:=ModuloPcgsByPcSequenceNC(home, home, Lp); fi; cl:=rec(representative:=One(G), centralizer:=H, centralizerpcgs:=InducedPcgs(home,H), cengen:=InducedPcgs(home,H)); if candidates<>false then cls:=List(candidates, c -> cl); opr:=List(candidates, c -> One(G)); exp:=ListWithIdenticalEntries(Length(candidates), 1); else cls:=[cl]; fi; # Now go back through the factors by all groups in the elementary abelian # series. first:=true; fhome:=home; # just to avoid unboundness the first time QG:=G; QH:=H; for step in [step + 1 .. Length(eas)] do Info(InfoClasses,1,"Step ",step,", ",Length(cls)," classes to lift"); # We apply the homomorphism principle to the homomorphism G/L -> G/K. if mustlift[step] then ofhome:=fhome; # get the new quotient and Q's if Size(eas[step])=1 then QH:=H; fhome:=home; QG:=G; else # the new factor group in which we calculate QH:=home mod InducedPcgs(home,liftkerns[step]); QH:=GROUP_BY_PCGS_FINITE_ORDERS(QH); fhome:=FamilyPcgs(QH); QG:=SubgroupByPcgs(QG, ProjectedInducedPcgs(home,fhome,InducedPcgs(home,G))); fi; fi; # The actual computations are all done in , factors are # represented by modulo pcgs. Ldep:=indstep[step]; if IsIdenticalObj(fhome,home) then K:=eas[step-1]; Kp:=InducedPcgs(fhome,K); L:=eas[step]; Lp:=InducedPcgs(fhome,L); elif mustlift[step] then Kp:=ProjectedInducedPcgs(home,fhome,InducedPcgs(home,eas[step-1])); K:=SubgroupByPcgs(QG,Kp); Lp:=ProjectedInducedPcgs(home,fhome,InducedPcgs(home,eas[step])); L:=SubgroupByPcgs(QG,Lp); # not needed any longer else # we did not lift K:=L; Kp:=Lp; Lp:=ProjectedInducedPcgs(home,fhome,InducedPcgs(home,eas[step])); L:=SubgroupByPcgs(QG,Lp); # not needed any longer fi; N:=Kp mod Lp; # modulo pcgs representing the kernel if mustlift[step] then for i in cls do if not IsBound(i.yet) then if first then # if it is the first time, we must actually map in the factor i.representative:=ProjectedPcElement(home,fhome,i.representative); i.centralizerpcgs:=ProjectedInducedPcgs(home,fhome,i.cengen); i.cengen:=i.centralizerpcgs!.pcSequence; else i.representative:=LiftedPcElement(fhome,ofhome,i.representative); i.centralizerpcgs:=LiftedInducedPcgs(fhome,ofhome,i.cengen,N); i.cengen:=i.centralizerpcgs!.pcSequence; fi; i.yet:=true; # several cl records may be equal. We must map only # once fi; od; else for i in cls do if IsBound(i.cengen) and not IsBound(i.centralizerpcgs) then i.centralizerpcgs:=InducedPcgsByPcSequence(fhome,i.cengen); i.cengen:=i.centralizerpcgs!.pcSequence; fi; od; fi; first:=false; # allcent:=ForAll(N,i->ForAll(GeneratorsOfGroup(G),j->Comm(i,j) in L)) allcent:=cent(fhome,fhome,N,Ldep); if allcent=false then nexpo:=LinearOperationLayer(fhome{[1..indstep[step-1]-1]},N); fi; #T What is this? Obviously it is needed somewhere, but it is #T certainly not good programming style. AH #SetFilterObj(N, IsPcgs); if not IsIdenticalObj(G,H) then Error("This case disabled -- code not yet corrected"); KcapH:=LcapH; LcapH:=NormalIntersectionPcgs(fhome,Hp,Lp); N!.capH:=KcapH mod LcapH; SetFilterObj( N!.capH, IsPcgs ); else N!.capH:=N; fi; # Identification of classes. # Rational classes or identification of classes. if candidates<>false then mK:=mL; mL:=ModuloPcgsByPcSequenceNC(fhome, fhome, Lp); if mode=4 # test conjugacy of two elements and not cls[1].representative / cls[2].representative in K then return fail; fi; blist:=BlistList([1 .. Length(cls)], []); pos:=Position(blist, false); while pos<>fail do # Find a team of candidates with same image under . cl:=cls[pos]; cl.representative:=PcElementByExponentsNC(mK, ExponentsOfPcElement(mK, cl.representative)); cl.candidates:=[]; team:=[]; q:=pos; while q<>fail do if cls[q].representative / cl.representative in K then c:=candidates[q] ^ opr[q]; i:=PositionSorted(cl.candidates, c); if i > Length(cl.candidates) or cl.candidates[i]<>c then Add(cl.candidates, c,i); Add(team, [q], i); else Add(team[i], q); fi; blist[q]:=true; fi; q:=Position(blist, false, q); od; # Now is a class modulo (possibly with # `.candidates' a list of elements mapping into this # class modulo ). Let be a list of all classes # modulo that map to modulo (resp. a list of # classes to which the list `.candidates' maps modulo # , together with `operator's and `exponent's as in # (c^o^e=r)). if allcent then # generic central Info(InfoClasses,5,"central case 1"); newcls:=CentralStepClEANS(fhome,QH, QG, N, cl,false); elif cent(fhome,cl.centralizerpcgs, N, Ldep) then # central in this case Info(InfoClasses,5,"central case 2"); newcls:=CentralStepClEANS(fhome,QH, QG, N, cl,false); else Info(InfoClasses,5,"general case"); newcls:=GeneralStepClEANS(fhome, QH, QG, N, nexpo, cl,false); fi; # Update , and . for i in [1 .. Length(team)] do for q in team[i] do cls[q]:=newcls[i]; opr[q]:=opr[q] * newcls[i].operator; od; od; pos:=Position(blist, false, pos); od; else newcls:=[]; for cli in [1..Length(cls)] do cl:=cls[cli]; if consider=true or consider(fhome,cl.representative,cl.centralizerpcgs,K,L) then if allcent or cent(fhome,cl.centralizerpcgs, N, Ldep) then news:=CentralStepClEANS(fhome,QG, QG, N, cl,false); else news:=GeneralStepClEANS(fhome, QG, QG, N,nexpo, cl,false); fi; Assert(1,# only do the test if no factors were formed FamilyObj(news[1].cengen)<>FamilyObj(eas[step]) or ForAll(news, i->ForAll(i.cengen, j->Comm(i.representative,j) in eas[step]))); Append(newcls,news); fi; Unbind(cls[cli]); od; cls:=newcls; fi; if inflev then c:=Collected(List(cls,i->Size(SubgroupByPcgs(QH, InducedPcgsByPcSequence(fhome,i.cengen))))); if not IsBound( divi ) then divi:=DivisorsInt(Size(G)); fi; c:=Concatenation(c,List(divi,i->[i,0])); # to cope with `First' Info(InfoClasses,2,List(divi,i->First(c,j->j[1]=i)[2])); fi; od; if mode=4 then # test conjugacy of two elements if cls[1].representative<>cls[2].representative then return fail; else return opr[1] / opr[2]; fi; fi; for i in cls do if not IsBound(i.centralizer) then if not IsBound(i.centralizerpcgs) then i.centralizerpcgs:=InducedPcgsByPcSequence(home,i.cengen); i.cengen:=i.centralizerpcgs; fi; i.centralizer:=SubgroupByPcgs(G,i.centralizerpcgs); fi; od; if candidates<>false then # add operators (and exponents) for i in [1 .. Length(cls)] do cls[i].operator:=opr[i]; od; fi; return cls; end); InstallGlobalFunction(CentralizerSizeLimitConsiderFunction,function(sz) return function(fhome,rep,cenp,K,L) return Product(RelativeOrders(cenp))/Size(K)<=sz; end; end); ############################################################################# ## #M ActorOfExternalSet( ) . . . . . . . . . conj. cl. of solv. groups ## InstallMethod( ActorOfExternalSet, true, [ IsConjugacyClassGroupRep ], 0, function( cl ) local G, rep; G:=ActingDomain( cl ); if not CanEasilyComputePcgs( G ) then TryNextMethod(); fi; rep:=ClassesSolvableGroup( G, 0,rec(candidates:=[ Representative(cl)]) ) [ 1 ]; if not HasStabilizerOfExternalSet( cl ) then SetStabilizerOfExternalSet( cl, ConjugateSubgroup( rep.centralizer, rep.operator ^ -1 ) ); fi; SetCanonicalRepresentativeOfExternalSet( cl, rep.representative ); return rep.operator; end ); ############################################################################# ############################################################################# # everything which follows is only used for rational classes in p groups. # This is not of that much importance any longer as the permutation groups # class algorithm is different, but it is still worth having for rational # classes of p-elements. AH, 14-apr-99 ############################################################################# ## #F RationalClassesSolvableGroup(, [,]) . . . . . ## ## This is the old version. It is now only used for rational classes and ## does not incorporate any of the improvements to the ordinary code. ## (However therefore the ordinary code does not need to worry with the ## rational classes case) ## In this function classes are described by records with components ## `representative', `centralizer', `galoisGroup' (for rational classes). If ## are given, their classes will have a canonical ## `representative' ## and additional components `operator' and `exponent' (for ## rational classes) such that ## (candidate ^ operator) ^ exponent=representative. (c^o^e=r) ## InstallGlobalFunction(RationalClassesSolvableGroup, function(arg) local G, home, # the group and the home pcgs H,Hp, # acting group mode, # LSB: ratCl | power | test :MSB candidates, # candidates to be replaced by their canonical reps. eas, # elementary abelian series in step, # counter looping over K, L, # members of Kp,mK,Lp,mL, # induced and modulo pcgs's LcapH,KcapH, # intersections N, cent, # elementary abelian factor, for affine action cls, newcls, # classes in range/source of homomorphism news, # new classes obtained in step cl, # class looping over opr, exp, # (candidates[i]^opr[i])^exp[i]=cls[i].representative team, # team of candidates with same image modulo blist,pos,q, # these control grouping of into s p, # prime dividing $|G|$ ord, # order of a rational class modulo new, power, # auxiliary variables for determination of power tree c, i, # loop variables opt, # options divi; # DivisorsInt(Size(G)) (used for Info) G:=arg[1]; mode :=arg[2]; # explained below whenever it appears if Length(arg)=3 then opt:=ShallowCopy(arg[3]); # convert series to pcgs if IsBound(opt.series) and not IsBound(opt.pcgs) then Error("convert series to pcgs!"); fi; else opt:=rec(); fi; # is a list of elements whose classes will be output (but # with canonical representatives), see comment above. Or is # just one element, from whose output class the centralizer will be read # off. H:=G; if IsBound(opt.candidates) then candidates:=opt.candidates; if not ForAll(candidates,i->i in G) then G:=ClosureGroup(H,candidates); fi; else candidates:=false; fi; #if IsBound(opt.consider) then # consider:=opt.consider; #else # consider:=true; #fi; # Treat the case of a trivial group. if IsTrivial(H) then if mode=4 then # test conjugacy of two elements return One(G); elif mode mod 2=1 then # rational classes cl:=rec(representative:=One(G), centralizer:=G, galoisGroup:=GroupByPrimeResidues([], 1)); cl.galoisGroup!.type:=3; cl.galoisGroup!.operators:=[]; cl.isCentral:=true; if mode mod 4=3 then # construct the power tree cl.power :=rec(representative:=One(G)); cl.power.operator:=One(G); cl.power.exponent:=1; fi; else cl:=rec(representative:=One(G), centralizer:=H); fi; if candidates<>false then cls:=List(candidates, c -> cl); else cls:=[cl]; fi; return cls; fi; # Calculate a (central) elementary abelian series with all pcgs induced # w.r.t. . if IsBound(opt.pcgs) then # we prescribed a series home:=opt.pcgs; eas:=EANormalSeriesByPcgs(home); cent:=function(cl, N, L) return ForAll(N, k -> ForAll (InducedPcgs(home,cl.centralizer), c -> Comm(k, c) in L)); end; elif IsPrimePowerInt(Size(G)) then p:=FactorsInt(Size(G))[1]; home:=PcgsPCentralSeriesPGroup(G); eas:=PCentralNormalSeriesByPcgsPGroup(home); cent:=ReturnTrue; elif mode mod 2=1 then # rational classes Error(" must be a p-group"); else home:=PcgsElementaryAbelianSeries(G); eas:=EANormalSeriesByPcgs(home); cent:=function(cl, N, L) return ForAll(N, k -> ForAll (InducedPcgs(home,cl.centralizer), #T was: Only those elements form the induced PCGS. The subset seemed to #T enforce taking only the elements up, but the ordering of the series used #T may be different then the ordering in the PCGS. So this will fail. AH #T one might pick the right ones, but this would be almost the same work. #T { [1 .. Length(InducedPcgsWrtHomePcgs(cl.centralizer)) #T - Length(InducedPcgsWrtHomePcgs(L))] }, c -> Comm(k, c) in L)); end; fi; Info(InfoClasses,1,"Series of sizes ",List(eas,Size)); if mode<3 and InfoLevel(InfoClasses)>1 then divi:=DivisorsInt(Size(G)); Info(InfoClasses,2,"centsiz: ",divi); fi; # Initialize the algorithm for the trivial group. step:=1; L :=eas[step]; Lp:=InducedPcgs(home,L); if not IsIdenticalObj( G, H ) then Hp := InducedPcgs(home, H ); LcapH := NormalIntersectionPcgs( home, Hp, Lp ); fi; if mode mod 2=1 # rational classes or candidates<>false then mL:=ModuloPcgsByPcSequenceNC(home, home, Lp); fi; if mode mod 2=1 then # rational classes cl:=rec(representative:=One(G), centralizer:=H, galoisGroup:=GroupByPrimeResidues([], 1)); cl.galoisGroup!.type:=3; cl.galoisGroup!.operators:=[]; if mode mod 4=3 then # construct the power tree cl.power :=rec(representative:=One(G)); cl.power.operator:=One(G); cl.power.exponent:=1; cl.power.kernel :=false; fi; else cl:=rec(representative:=One(G), centralizer:=H); fi; if candidates<>false then cls:=List(candidates, c -> cl); opr:=List(candidates, c -> One(G)); exp:=ListWithIdenticalEntries(Length(candidates), 1); else cls:=[cl]; fi; # Now go back through the factors by all groups in the elementary abelian # series. for step in [step + 1 .. Length(eas)] do Info(InfoClasses,1,"Step ",step,", ",Length(cls)," classes to lift"); # We apply the homomorphism principle to the homomorphism G/L -> G/K. # The actual computations are all done in , factors are # represented by modulo pcgs. K :=L; Kp:=Lp; L :=eas[step]; Lp:=InducedPcgs(home,L); N :=Kp mod Lp; # modulo pcgs representing the kernel #T What is this? Obviously it is needed somewhere, but it is #T certainly not good programming style. AH SetFilterObj(N, IsPcgs); if not IsIdenticalObj(G,H) then KcapH := LcapH; LcapH := NormalIntersectionPcgs(home,Hp,Lp); N!.capH:=KcapH mod LcapH; SetFilterObj( N!.capH, IsPcgs ); else N!.capH:=N; fi; # Rational classes or identification of classes. if mode mod 2=1 or candidates<>false then mK:=mL; mL:=ModuloPcgsByPcSequenceNC(home, home, Lp); fi; # Identification of classes. if candidates<>false then if mode=4 # test conjugacy of two elements and not cls[1].representative / cls[2].representative in K then return fail; fi; blist:=BlistList([1 .. Length(cls)], []); pos:=Position(blist, false); while pos<>fail do # Find a team of candidates with same image under . cl:=cls[pos]; cl.representative:=PcElementByExponentsNC(mK, ExponentsOfPcElement(mK, cl.representative)); cl.candidates:=[]; team:=[]; q:=pos; while q<>fail do if cls[q].representative / cl.representative in K then c:=candidates[q] ^ opr[q]; if mode mod 2=1 then # rational classes c:=c ^ exp[q]; fi; i:=PositionSorted(cl.candidates, c); if i > Length(cl.candidates) or cl.candidates[i]<>c then Add( cl.candidates,c,i); Add(team, [q], i); else Add(team[i], q); fi; blist[q]:=true; fi; q:=Position(blist, false, q); od; # Now is a class modulo (possibly with # `.candidates' a list of elements mapping into this # class modulo ). Let be a list of all classes # modulo that map to modulo (resp. a list of # classes to which the list `.candidates' maps modulo # , together with `operator's and `exponent's as in # (c^o^e=r)). if mode mod 2=1 then # rational classes newcls:=CentralStepRatClPGroup(home, H, N, mK, mL, cl); elif cent(cl, N, L) then newcls:=CentralStepClEANS(home,H, G, N, cl); else newcls:=GeneralStepClEANS(home, H, G, N, cl); fi; # Update , and . for i in [1 .. Length(team)] do for q in team[i] do cls[q]:=newcls[i]; opr[q]:=opr[q] * newcls[i].operator; if mode mod 2=1 then # rational classes ord:=OrderModK(cls[q].representative, mL); if ord<>1 then # For historical reasons, the `exponent's # returns by `CentralStepRatClPGroup' are the # inverses of what we need. exp[q]:=exp[q] / newcls[i].exponent mod ord; fi; fi; od; od; pos:=Position(blist, false, pos); od; elif mode mod 2=1 then # rational classes newcls:=[]; for cl in cls do if IsBound(cl.power) then # construct the power tree cl.representative:=PcElementByExponentsNC(mK, ExponentsOfPcElement(mK, cl.representative)); cl.power.representative:=PcElementByExponentsNC(mK, ExponentsOfPcElement(mK, cl.power.representative)); fi; new:=CentralStepRatClPGroup(home, G, N, mK, mL, cl); ord:=OrderModK(new[1].representative, mL); # if ord <= limit.order # and ( limit.size=0 # or limit.size mod Size(new[1])=0) then if IsBound(cl.power) then # construct the power tree if ord=1 then power:=cl.power; else cl.power.candidates:=[(new[1].representative ^ cl.power.operator) ^ (p*cl.power.exponent)]; power:=CentralStepRatClPGroup(home, G, N, mK, mL, cl.power)[1]; power.operator:=cl.power.operator * power.operator; power.exponent:=cl.power.exponent / power.exponent mod ord; fi; for c in new do c.power:=power; od; fi; Append(newcls, new); # fi od; cls:=newcls; else newcls:=[]; for cl in cls do #if consider=true or consider(fhome,cl.representative,cl.centralizerpcgs,K,L) #then if cent(cl, N, L) then news:=CentralStepClEANS(home,G, G, N, cl); else news:=GeneralStepClEANS(home, G, G, N, cl); fi; Assert(1,ForAll(news, i->ForAll(GeneratorsOfGroup(i.centralizer), j->Comm(i.representative,j) in eas[step]))); Append(newcls,news); #fi; od; cls:=newcls; fi; if InfoLevel(InfoClasses)>1 then c:=Collected(List(cls,i->Size(i.centralizer))); if not IsBound( divi ) then divi:=DivisorsInt(Size(G)); fi; c:=Concatenation(c,List(divi,i->[i,0])); # to cope with `First' Info(InfoClasses,2,List(divi,i->First(c,j->j[1]=i)[2])); fi; od; if mode=4 then # test conjugacy of two elements if cls[1].representative<>cls[2].representative then return fail; else return opr[1] / opr[2]; fi; fi; if candidates<>false then # add operators (and exponents) for i in [1 .. Length(cls)] do cls[i].operator:=opr[i]; if mode mod 2=1 then # rational classes cls[i].exponent:=exp[i]; fi; od; fi; return cls; end); ############################################################################# ## #F OrderModK( , ) . . . . . . . . . . order modulo normal subgroup ## InstallGlobalFunction( OrderModK, function( h, mK ) local ord, d, o; ord:=1; d:=DepthOfPcElement( mK, h ); while d <= Length( mK ) do o:=RelativeOrders( mK )[ d ]; h:=h ^ o; ord:=ord * o; d:=DepthOfPcElement( mK, h, d + 1 ); od; return ord; end ); ############################################################################# ## #F OldSubspaceVectorSpaceGroup( ,

, , ) . complement and projection ## ## This function creates a record containing information about a complement ## in to the span of . ## BindGlobal("OldSubspaceVectorSpaceGroup", function( N, p, gens ) local zero, one, r, ran, n, nan, cg, pos, Q, i, j, v; one:=One( GF( p ) ); zero:=0 * one; r:=Length( N ); ran:=[ 1 .. r ]; n:=Length( gens ); nan:=[ 1 .. n ]; Q:=[ ]; if n <> 0 and IsMultiplicativeElementWithInverse( gens[ 1 ] ) then Q:=List( gens, gen -> ExponentsOfPcElement( N, gen ) ) * one; else Q:=ShallowCopy( gens ); fi; cg:=rec( matrix :=[ ], needed := [], one :=one, baseComplement:=ShallowCopy( ran ), projection := IdentityMat( r, one ), commutator :=0, centralizer :=0, dimensionN :=r, dimensionC :=n ); if n = 0 or r = 0 then cg.inverse:=NullMapMatrix; return cg; fi; for i in nan do cg.matrix[ i ]:=Concatenation( Q[ i ], zero * nan ); cg.matrix[ i ][ r + i ]:=one; od; TriangulizeMat( cg.matrix ); pos:=1; for v in cg.matrix do while v[ pos ] = zero do pos:=pos + 1; od; RemoveSet( cg.baseComplement, pos ); if pos <= r then cg.commutator :=cg.commutator + 1; else cg.centralizer:=cg.centralizer + 1; fi; od; cg.needed :=[ ]; cg.projection :=IdentityMat( r, one ); # Find a right pseudo inverse for . Append( Q, cg.projection ); Q:=MutableTransposedMat( Q ); TriangulizeMat( Q ); Q:=TransposedMat( Q ); i:=1; j:=1; while i <= Length( N ) do while j <= Length( gens ) and Q[ j ][ i ] = zero do j:=j + 1; od; if j <= Length( gens ) and Q[ j ][ i ] <> zero then cg.needed[ i ]:=j; else # If does not have full rank, terminate when the bottom row # is reached. i:=Length( N ); fi; i:=i + 1; od; if IsEmpty( cg.needed ) then cg.inverse:=NullMapMatrix; else cg.inverse:=Q{ Length( gens ) + ran } { [ 1 .. Length( cg.needed ) ] }; cg.inverse:=ImmutableMatrix(p,cg.inverse,true); fi; if IsEmpty( cg.baseComplement ) then cg.projection:=NullMapMatrix; else # Find a base change matrix for the projection onto the complement. for i in [ 1 .. cg.commutator ] do cg.projection[ i ][ i ]:=zero; od; Q:=[ ]; for i in [ 1 .. cg.commutator ] do Q[ i ]:=cg.matrix[ i ]{ ran }; od; for i in [ cg.commutator + 1 .. r ] do Q[ i ]:=ListWithIdenticalEntries( r, zero ); Q[ i ][ cg.baseComplement[ i-r+Length(cg.baseComplement) ] ] :=one; od; cg.projection:=cg.projection ^ Q; cg.projection:=cg.projection{ ran }{ cg.baseComplement }; cg.projection:=ImmutableMatrix(p,cg.projection,true); fi; return Immutable(cg); end ); ############################################################################# ## #F OldKernelHcommaC( , , ) ## ## Given a homomorphism C -> N, c |-> [h,c], this function determines (a) a ## vector space decomposition N = [h,C] + K with projection onto K and (b) ## the ``kernel'' S < C which plays the role of C_G(h) in lemma 3.1 of ## [Mecky, Neub\"user, Bull. Aust. Math. Soc. 40]. ## BindGlobal("OldKernelHcommaC", function( N, h, C ) local i, tmp, v; N!.subspace := OldSubspaceVectorSpaceGroup( N, RelativeOrders( N )[ 1 ], List( C, c -> Comm( h, c ) ) ); tmp := [ ]; for i in [ N!.subspace.commutator + 1 .. N!.subspace.commutator + N!.subspace.centralizer ] do v := N!.subspace.matrix[ i ]; tmp[ i - N!.subspace.commutator ] := PcElementByExponentsNC( C, v{ [ N!.subspace.dimensionN + 1 .. N!.subspace.dimensionN + N!.subspace.dimensionC ] } ); od; return tmp; end ); ############################################################################# ## #F CentralStepConjugatingElement( ... ) . . . . . . . . . . . . . . . local ## ## This function returns an element of conjugating to ^. ## InstallGlobalFunction( CentralStepConjugatingElement, function( N, h, k1, k2, l, cN ) local v, conj; v:=ExponentsOfPcElement( N, h ^ -l * h ^ cN * k1 * k2 ^ -l ); conj:=LinearCombinationPcgs( N!.CmodK{ N!.subspace.needed }, v * N!.subspace.inverse,OneOfPcgs( N ) ); conj:=LeftQuotient( conj, cN ); return conj; end ); ############################################################################# ## #F CentralStepRatClPGroup(, , , , , ) ## InstallGlobalFunction( CentralStepRatClPGroup, function( home, G, N, mK, mL, cl ) local h, # preimage of `cl.representative' under candexps, # list of exponent vectors for mod classes, # the resulting list of classes ohN, oh, # order of in `Range()' resp. `Source()' p, # exponent of K, # a complement to $[h,C]$ in Gal, gal, # Galois group for element in `Source()' preimage, # preimage of $Gal(hN)$ in $Z_oh^*$ operator, # generator of acting by conjugation reps, conj, #\ representatives, conjugating elements, exps, #/ exponents and orbit lengths in orbit algorithm Q, v, r, # subspace to be projected onto, projection vectors k, # orbit representative in gens, oprs, # generators and operators for new Galois group type, # the type of the Galois group as subgroup of Z_2^r^* i, j, l, c, # loop variables C, cyc, xset, opr, orb,kern,img; p :=RelativeOrders( N )[ 1 ]; h :=cl.representative; ohN:=OrderModK( h, mK ); oh :=OrderModK( h, mL ); classes:=[ ]; if oh = 1 then # Special case: is trivial. Gal:=Units( Integers mod 1 ); gal:=GroupByPrimeResidues( [ ], p ); gal!.type:=3; gal!.operators:=[ ]; if IsBound( cl.candidates ) then for c in cl.candidates do l:=LeadingExponentOfPcElement( N, c ); if l = fail then l:=1; c:=rec( representative:=c, galoisGroup:=TrivialSubgroup( Gal ) ); c.galoisGroup!.type:=3; c.galoisGroup!.operators:=[ ]; else c:=rec( representative:=c ^ ( 1 / l mod p ), galoisGroup:=gal ); fi; c.centralizer:=G; c.operator :=OneOfPcgs( N ); c.exponent :=l; Add( classes, c ); od; else c:=rec( representative:=One( G ), centralizer:=G, galoisGroup:=TrivialSubgroup( Gal ) ); c.galoisGroup!.type:=3; c.galoisGroup!.operators:=[ ]; Add( classes, c ); for v in EnumeratorOfNormedRowVectors( GF( p ) ^ Length( N ) ) do c:=rec( representative:=PcElementByExponentsNC( N, v ), centralizer:=G, galoisGroup:=gal ); Add( classes, c ); od; fi; else Gal:=Units( Integers mod oh ); if IsBound( cl.kernel ) then N:=cl.kernel; else N!.CmodK:=InducedPcgs(home, cl.centralizer ) mod DenominatorOfModuloPcgs( N ); kern:=DenominatorOfModuloPcgs( N ); img:=OldKernelHcommaC( N, h, N!.CmodK ) ; #N!.CmodL:=ExtendedPcgs(kern,img); N!.CmodL:=InducedPcgsByPcSequenceAndGenerators(ParentPcgs( kern ), kern, img ); fi; if IsBound( cl.candidates ) then cl.candidates:=List( cl.candidates, c -> LeftQuotient( h, c ) ); candexps:=List( cl.candidates, c -> ExponentsOfPcElement( N, c ) ) * N!.subspace.projection; fi; # If

= 2, use a projection operation. if p = 2 then # Construct the preimage of $Gal(hN)$ in $Z_oh^*$. if ohN <= 2 then preimage:=GroupByPrimeResidues( [ -1, 5 ], oh ); preimage!.type:=1; preimage!.operators:=List( GeneratorsOfGroup( preimage ), i -> One( G ) ); else if cl.galoisGroup!.type = 1 then preimage:=[ -1, 5^(ohN/(2*Size(cl.galoisGroup))) ]; elif cl.galoisGroup!.type = 2 then preimage:=[ -( 5^(ohN/(4*Size(cl.galoisGroup)))) ]; else preimage:=[ 5^(ohN/(4*Size(cl.galoisGroup))) ]; fi; preimage:=GroupByPrimeResidues( preimage, oh ); preimage!.type:=cl.galoisGroup!.type; if Length( GeneratorsOfGroup( preimage ) ) = Length( GeneratorsOfGroup( cl.galoisGroup ) ) then preimage!.operators:=cl.galoisGroup!.operators; else preimage!.operators:=Concatenation ( cl.galoisGroup!.operators, [ One( G ) ] ); fi; fi; # Construct the image of the homomorphism -> . Q:=[ ]; for i in [ 1 .. Length( GeneratorsOfGroup( preimage ) ) ] do #Assert(2,LeftQuotient(h^Int(GeneratorsOfGroup(preimage)[i]), # h^preimage!.operators[i]) in # Group(NumeratorOfModuloPcgs(N))); Add( Q, ExponentsOfPcElement( N, LeftQuotient( h ^ Int( GeneratorsOfGroup( preimage )[ i ] ), h ^ preimage!.operators[ i ] ) ) ); od; Q:=Q * N!.subspace.projection; K:=InducedPcgsByPcSequenceNC( N, N{ N!.subspace.baseComplement } ); K!.subspace:=OldSubspaceVectorSpaceGroup( K, p, Q ); # Project the factors in onto a complement to . if IsBound( cl.candidates ) then v:=List( candexps, ShallowCopy ); r:=v * K!.subspace.projection; reps:=[ ]; exps:=[ ]; conj:=[ ]; if not IsEmpty( K!.subspace.baseComplement ) then v{[1..Length(v)]}{K!.subspace.baseComplement}:= v{[1..Length(v)]}{K!.subspace.baseComplement} + r; fi; v:=v * K!.subspace.inverse; for i in [ 1 .. Length( r ) ] do reps[ i ]:=PcElementByExponentsNC ( K, K!.subspace.baseComplement, r[ i ] ); exps[ i ]:=LinearCombinationPcgs( GeneratorsOfGroup(preimage){K!.subspace.needed}, v[ i ],One(preimage)); conj[ i ]:=LinearCombinationPcgs( preimage!.operators { K!.subspace.needed }, v[ i ], One(G)); od; # In the construction case, the complement to is a set of # representatives. else reps:=EnumeratorByPcgs( K, K!.subspace.baseComplement ); fi; # The kernel of the homomorphism into is the Galois group of # . if IsTrivial( preimage ) then # pre = < 1 > gens:=GeneratorsOfGroup( preimage ); oprs:=preimage!.operators; type:=preimage!.type; else if Q[ 1 ] = Zero( Q[ 1 ] ) then i:=1; else i:=2; fi; if Length( GeneratorsOfGroup( preimage ) ) = 1 then gens:=[ GeneratorsOfGroup( preimage )[ 1 ] ^ i ]; oprs:=[ preimage!.operators [ 1 ] ^ i ]; if preimage!.type = 1 then type:=2 * i - 1; # <-1> elif preimage!.type = 2 then type:=i + 1; else type:=3; fi; else if Q[ 2 ] = Zero( Q[ 2 ] ) then j:=1; else j:=2; fi; if i = 1 then gens:=[ GeneratorsOfGroup( preimage )[ 1 ], GeneratorsOfGroup( preimage )[ 2 ] ^ j ]; oprs:=[ preimage!.operators [ 1 ], preimage!.operators [ 2 ] ^ j ]; type:=1; elif j = 2 and Q[ 1 ] = Q[ 2 ] then gens:=[ GeneratorsOfGroup( preimage )[ 1 ] * GeneratorsOfGroup( preimage )[ 2 ] ]; oprs:=[ preimage!.operators [ 1 ] * preimage!.operators [ 2 ] ]; type:=2; else gens:=[ GeneratorsOfGroup( preimage )[ 2 ] ^ j ]; oprs:=[ preimage!.operators [ 2 ] ^ j ]; type:=3; fi; fi; fi; # If

<> 2, use an affine operation of a cyclic group generated by # . else K:=EnumeratorByPcgs( N, N!.subspace.baseComplement ); cyc:=GroupByPrimeResidues( [ PowerModInt ( PrimitiveRootMod( oh ), IndexInParent( cl.galoisGroup ), oh ) ], oh ); SetSize( cyc, Phi( oh ) / IndexInParent( cl.galoisGroup ) ); if IsTrivial( cyc ) then preimage:=One( cyc ); else SetIndependentGeneratorsOfAbelianGroup( cyc, GeneratorsOfGroup( cyc ) ); preimage:=Pcgs( cyc )[ 1 ]; fi; if IsTrivial( cl.galoisGroup ) then operator:=One( G ); else operator:=cl.galoisGroup!.operators[ 1 ]; fi; v:=PcElementByExponentsNC( N, N!.subspace.baseComplement, ExponentsOfPcElement( N, LeftQuotient( h ^ Int( preimage ), h ^ operator ) ) * N!.subspace.projection ); opr:=function( k, l ) return #AH, jun3 2001: without the pcgs filtereing we might get # extra kernel elements. I have no idea how this was # originally avoided. This is rather a workaround than a fix # -- the whole code should be rewritten cleanly. PcElementByExponentsNC(N,ExponentsOfPcElement(N, ( v * k ) ^ ( 1 / Int( l ) mod p ) )); end; xset:=ExternalSet( cyc, K, opr ); reps:=[ ]; exps:=[ ]; if IsBound( cl.candidates ) then conj:=[ ]; for c in candexps do orb:=ExternalOrbit( xset, PcElementByExponentsNC( N, N!.subspace.baseComplement, c ) ); Add( reps, CanonicalRepresentativeOfExternalSet( orb ) ); i:=Size( cyc ) / Order( ActorOfExternalSet( orb ) ); Add( exps, preimage ^ i ); Add( conj, operator ^ i ); od; else for orb in ExternalOrbits( xset ) do Add( reps, CanonicalRepresentativeOfExternalSet( orb ) ); Add( exps, preimage ^ Size( orb ) ); od; fi; fi; # If is a set of representatives of the orbits then # is a set of representatives of the rational classes in . for l in [ 1 .. Length( reps ) ] do k:=reps[ l ]; # Construct the Galois group and find conjugating elements # corresponding to its generator(s). if p <> 2 then gens:=[ exps[ l ] ]; oprs:=[ operator ^ Int( exps[ l ] ) ]; fi; gal:=SubgroupNC( Gal, gens ); if p = 2 then gal!.type:=type; fi; gal!.operators:=[ ]; for i in [ 1 .. Length( GeneratorsOfGroup( gal ) ) ] do Add( gal!.operators, CentralStepConjugatingElement ( N, h, k, k, Int( GeneratorsOfGroup( gal )[ i ] ), oprs[ i ] ) ); od; C:=SubgroupNC( G, N!.CmodL ); c:=rec( representative:=h * k, centralizer:=C, galoisGroup:=gal ); if IsBound( cl.candidates ) then # cl.candidates[l] ^ c.operator = # c.representative ^ c.exponent (DIFFERS from (c^o^e=r)!) c.exponent:=Int( exps[ l ] ); c.operator:=CentralStepConjugatingElement ( N, h, cl.candidates[ l ], k, c.exponent, conj[ l ] ); if IsBound( cl.kernel ) then c.kernel:=N; fi; fi; Add( classes, c ); od; fi; return classes; end ); ############################################################################# ## #E claspcgs.gi . . . . . . . . . . . . . . . . . . . . . . . . . . ends here gap-4r6p5/lib/mgmcong.gi0000644000175000017500000011347612172557252013673 0ustar billbill############################################################################# ## #W mgmcong.gi GAP library Robert F. Morse ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains generic methods for magma congruences ## ## Maintenance and further development by: ## Robert F. Morse ## Andrew Solomon ## ## ############################################################################# ## #M PrintObj( ) ## print a [left, right, two-sided] Magma Congruence ## ## left magma congruence InstallMethod( PrintObj, "for a left magma congruence", true, [ IsLeftMagmaCongruence ], 0, function( S ) Print( "LeftMagmaCongruence( ... )" ); end ); InstallMethod( PrintObj, "for a left magma congruence with known generating pairs", true, [ IsLeftMagmaCongruence and HasGeneratingPairsOfMagmaCongruence ], 0, function( S ) Print( "LeftMagmaCongruence( ", GeneratingPairsOfMagmaCongruence( S ), " )" ); end ); ## right magma congruence InstallMethod( PrintObj, "for a right magma congruence", true, [ IsRightMagmaCongruence ], 0, function( S ) Print( "RightMagmaCongruence( ... )" ); end ); InstallMethod( PrintObj, "for a right magma congruence with known generating pairs", true, [ IsRightMagmaCongruence and HasGeneratingPairsOfMagmaCongruence ], 0, function( S ) Print( "RightMagmaCongruence( ", GeneratingPairsOfMagmaCongruence( S ), " )" ); end ); ## two sided magma congruence InstallMethod( PrintObj, "for a magma congruence", true, [ IsMagmaCongruence ], 0, function( S ) Print( "MagmaCongruence( ... )" ); end ); InstallMethod( PrintObj, "for a magma Congruence with known generating pairs", true, [ IsMagmaCongruence and HasGeneratingPairsOfMagmaCongruence ], 0, function( S ) Print( "MagmaCongruence( ", GeneratingPairsOfMagmaCongruence( S ), " )" ); end ); ############################################################################# ## #M ViewObj( ) ## view a [left,right,two-sided] magma congruence ## ## left magma congruence InstallMethod( ViewObj, "for a LeftMagmaCongruence", true, [ IsLeftMagmaCongruence ], 0, function( S ) Print( "" ); end ); InstallMethod( ViewObj, "for a LeftMagmaCongruence with known generating pairs", true, [ IsLeftMagmaCongruence and HasGeneratingPairsOfMagmaCongruence ], 0, function( S ) Print( "" ); end ); ## right magma congruence InstallMethod( ViewObj, "for a RightMagmaCongruence", true, [ IsRightMagmaCongruence ], 0, function( S ) Print( "" ); end ); InstallMethod( ViewObj, "for a RightMagmaCongruence with generators", true, [ IsRightMagmaCongruence and HasGeneratingPairsOfMagmaCongruence ], 0, function( S ) Print( "" ); end ); ## two sided magma congruence InstallMethod( ViewObj, "for a magma congruence", true, [ IsMagmaCongruence ], 0, function( S ) Print( "" ); end ); InstallMethod( ViewObj, "for a magma congruence with generating pairs", true, [ IsMagmaCongruence and HasGeneratingPairsOfMagmaCongruence ], 0, function( S ) Print( "" ); end ); ############################################################################# ## #M LR2MagmaCongruenceByGeneratingPairsCAT(,,) ## ## create the magma congruence with generating pairs as ## a where is IsLeftMagmaCongruence, ## IsRightMagmaCongruence or IsMagmaCongruence. ## InstallGlobalFunction( LR2MagmaCongruenceByGeneratingPairsCAT, function(F, gens, category ) local r, cong, fam; # Check that the relations are all lists of length 2 for r in gens do if Length(r) <> 2 then Error("A relation should be a list of length 2"); fi; od; # Create the equivalence relation fam := GeneralMappingsFamily( ElementsFamily(FamilyObj(F)), ElementsFamily(FamilyObj(F)) ); # Create the default type for the elements. cong := Objectify(NewType(fam, category and IsEquivalenceRelationDefaultRep), rec()); SetSource(cong, F); SetRange(cong, F); # Add the generators in the appropriate attribute # They are all set in a common place with special names # as needed if (category = IsMagmaCongruence) then SetGeneratingPairsOfMagmaCongruence(cong, Immutable(gens)); elif (category = IsLeftMagmaCongruence) then SetGeneratingPairsOfLeftMagmaCongruence(cong, Immutable(gens)); SetGeneratingPairsOfMagmaCongruence(cong, Immutable(gens)); elif (category = IsRightMagmaCongruence) then SetGeneratingPairsOfMagmaCongruence(cong, Immutable(gens)); SetGeneratingPairsOfRightMagmaCongruence(cong, Immutable(gens)); else Error("Invalid category ",category," of Magma congruence"); fi; return cong; end); ############################################################################# ## #M LR2MagmaCongruenceByPartitionNCCAT(,,) ## ## create the magma congruence with partition as ## a where is IsLeftMagmaCongruence, ## IsRightMagmaCongruence or IsMagmaCongruence. ## ## is a list of lists containing (at least) all of the non singleton ## blocks of the partition. It is not checked that is actually ## a congruence in the category specified. ## InstallGlobalFunction( LR2MagmaCongruenceByPartitionNCCAT, function(F, part, cat) local cong, fam; # The only cheap check we can do: if not IsElmsColls(FamilyObj(F), FamilyObj(part)) then Error(" should be a list of lists of elements of the magma"); fi; # Create the equivalence relation fam := GeneralMappingsFamily( ElementsFamily(FamilyObj(F)), ElementsFamily(FamilyObj(F)) ); # Create the default type for the elements. cong := Objectify(NewType(fam, cat and IsEquivalenceRelationDefaultRep), rec()); SetSource(cong, F); SetRange(cong, F); SetEquivalenceRelationPartition(cong, part); return cong; end); ############################################################################# ## #M LeftMagmaCongruenceByGeneratingPairs( , ) #M RightMagmaCongruenceByGeneratingPairs( , ) #M MagmaCongruenceByGeneratingPairs( , ) ## InstallMethod( LeftMagmaCongruenceByGeneratingPairs, "for a magma and a list of pairs of its elements", IsElmsColls, [ IsMagma, IsList ], 0, function( M, gens ) return LR2MagmaCongruenceByGeneratingPairsCAT(M, gens, IsLeftMagmaCongruence); end ); InstallMethod( LeftMagmaCongruenceByGeneratingPairs, "for a magma and an empty list", true, [ IsMagma, IsList and IsEmpty ], 0, function( M, gens ) return LR2MagmaCongruenceByGeneratingPairsCAT(M, gens, IsLeftMagmaCongruence); end ); InstallMethod( RightMagmaCongruenceByGeneratingPairs, "for a magma and a list of pairs of its elements", IsElmsColls, [ IsMagma, IsList ], 0, function( M, gens ) return LR2MagmaCongruenceByGeneratingPairsCAT(M, gens, IsRightMagmaCongruence); end ); InstallMethod( RightMagmaCongruenceByGeneratingPairs, "for a magma and an empty list", true, [ IsMagma, IsList and IsEmpty ], 0, function( M, gens ) return LR2MagmaCongruenceByGeneratingPairsCAT(M, gens, IsRightMagmaCongruence); end ); InstallMethod( MagmaCongruenceByGeneratingPairs, "for a magma and a list of pairs of its elements", IsElmsColls, [ IsMagma, IsList ], 0, function( M, gens ) local c; c := LR2MagmaCongruenceByGeneratingPairsCAT(M, gens, IsMagmaCongruence); if HasIsSemigroup(M) and IsSemigroup(M) then SetIsSemigroupCongruence(c,true); fi; return c; end ); InstallMethod( MagmaCongruenceByGeneratingPairs, "for a magma and an empty list", true, [ IsMagma, IsList and IsEmpty ], 0, function( M, gens ) local c; c := LR2MagmaCongruenceByGeneratingPairsCAT(M, gens, IsMagmaCongruence); if HasIsSemigroup(M) and IsSemigroup(M) then SetIsSemigroupCongruence(c,true); fi; return c; end ); ############################################################################# ## #M EquivalenceClasses( ) ## ## For a MagmaCongruence ## InstallMethod(EquivalenceClasses, "for magma congruences", true, [IsMagmaCongruence], 0, function(e) local part, # the partition of the equivalence relation distinctreps; # the reprentatives of distinct non-trivial # congruence classes part := EquivalenceRelationPartition(e); distinctreps := List(part,x->x[1]); return List(distinctreps, x->EquivalenceClassOfElementNC(e, x)); end); ############################################################################# ## #M \*( , ) ## ## Product of congruence classes. As in fp-semigroups we just ## multiply without worrying about getting the representative right. ## Then we check equality when doing < or =. ## InstallMethod( \*, "for two magma congruence classes", IsIdenticalObj, [ IsCongruenceClass, IsCongruenceClass ], 0, function( x1, x2 ) if EquivalenceClassRelation(x1) <> EquivalenceClassRelation(x2) then Error("Can only multiply classes of the same congruence"); fi; return EquivalenceClassOfElementNC(EquivalenceClassRelation(x1), Representative(x1)*Representative(x2)); end ); ############################################################################ ## #M One() ## ## It is installed as ## OtherMethod to appease GAP since the selection filters ## IsCongruenceClass and IsMultiplicativeElementWithOne ## match two declarations of One - the first filter for domains, ## the second filter for IsMultiplicativeElementWithOne. ## InstallOtherMethod(One, "One()", true, [IsCongruenceClass and IsMultiplicativeElementWithOne], 0, function(x) return EquivalenceClassOfElement(EquivalenceClassRelation(x), One(Representative(x))); end); ###################################################################### ## #F MagmaCongruencePartition(,) ## ## This function sets one of the two attributes ## ## EquivalenceRelationPartition ## PartialClosureOfCongruence ## ## depending on whether full closure is found or partial closure is ## found. Both of these attributes are partitions of the magma's ## elements. If a previously computed PartialClosureOfCongruence satisfies ## the no computations are performed. ## ## A left magma congruence, right magma congruence, and magma congruence ## is the smallest equivalence relation containing the generating pairs ## closed under the operations of left multiplication, right ## multiplication or both respectively. ## ## If the magma is infinite (or very large) it may not be possible to compute ## the entire partition. allows for a stop condition (possibly) ## short of full closure. The function takes two parameters ## (congruence, forest). Other variables that might be needed by ## should be assigned to globals variables before MagmaCongruencePartition is ## called. ## ## A PartialClosureOfCongruence reflects a partial computation that can be used ## in subsequent computations. Hence it is a mutable attribute. ## ## A partial closure is also provided if either one block or the number of ## blocks exceeds 64,000 in length. The partial closure attribute is stored for ## the user to inspect. ## ## This algorithm is based on Atkinson et. al. (Group Theory on a ## Microcomputer, in Computational Group Theory, 1984). ## ## Non-trivial blocks are considered trees and the block system a forest ## ## Data representation: ## o Forest is a list of non-empty lists with no holes. ## o Each list in the forest represents a non-empty tree of depth 1 ## with root the first element (hence it has at least 2 elements). ## ## If follows from the data representations that full path compression ## is used. ## ## The merging of blocks can only be done via list Append. ## This insures that the root of the left tree being merged does not change ## and hence is an invariant. ## ###################################################################### BindGlobal("MagmaCongruencePartition", function(cong,partialcond) local C, #Initial branches (given pairs) forest, #Forest in which each tree is a block i,p,g,j, #index variables r1,r2, #roots of possible blocks to merge p1,p2, #positions of the blocks gens, #Required generators (in generality all the elements maxlimit, #Maximum size for either a partition or number of # partition; checklimit,#Function for checking limit equivrel; #Initial forest (if there is not partial closure) ## Set up limits on the size and number of partitions we can ## create a check function ## maxlimit := 64000; checklimit := function() if Length(forest) >= maxlimit then return true; fi; if First(forest, x->Length(x)>=maxlimit) <> fail then return true; fi; return false; end; ## check that we know the generators .... ## if not HasGeneratingPairsOfMagmaCongruence(cong) then Error("MagmaCongruencePartition requires GeneratingPairsOfMagmaCongruence"); fi; if not ((HasGeneratorsOfMagma(Source(cong)) or HasGeneratorsOfMagmaWithInverses(Source(cong))) or (HasIsFinite(Source(cong)) and IsFinite(Source(cong)) )) then Error("MagmaCongruencePartition requires generators for underlying semigroup or list of all elements"); fi; ## does the partition already exist if so return done deal ## if HasEquivalenceRelationPartition(cong) then return; fi; ## check to see if we are to generate the trivial relation ## ## Filter all pairs of the form (a,a). ## if this filtered set is empty return the diagonal ## equivalence ## C := List(Filtered(GeneratingPairsOfMagmaCongruence(cong), x->not x[1]=x[2]), y->ShallowCopy(y)); if IsEmpty(C) then SetEquivalenceRelationPartition(cong,[]); return; fi; C := Set(C); ## Set the forest either to the partial closure from a previous ## call or find the smallest equivalence relation ## containing the filtered generators ## if HasPartialClosureOfCongruence(cong) then forest := ShallowCopy(PartialClosureOfCongruence(cong)); C := ShallowCopy(cong!.C); else equivrel := EquivalenceRelationPartition( EquivalenceRelationByPairsNC(Source(cong),C)); forest := List(equivrel, x->ShallowCopy(x)); fi; ## Check partial closure might be fulfilled by initial closure ## if partialcond(cong,forest) then SetPartialClosureOfCongruence(cong,forest); cong!.C := ShallowCopy(C); return; fi; ## Determine whether we can use generators or need ## all the elements ## ## If the Magma is associative then use generators ## #T If the magam has a generating set but is not associative #T then use an iterator. One need to be implemented ## ## else use elements of the magma ## if HasGeneratorsOfMagmaWithInverses(Source(cong)) and HasIsAssociative(Source(cong)) and IsAssociative(Source(cong)) then gens := GeneratorsOfMagmaWithInverses(Source(cong)); elif HasGeneratorsOfMagma(Source(cong)) and HasIsAssociative(Source(cong)) and IsAssociative(Source(cong)) then gens := GeneratorsOfMagma(Source(cong)); elif HasGeneratorsOfMagma(Source(cong)) and HasIsFinite(Source(cong)) and IsFinite(Source(cong)) then gens := AsSSortedList(Source(cong)); else gens := AsSSortedList(Source(cong)); fi; ## ## Work through the branches in the forest above ## determining the closure wrt left and right ## translations following Atkinson et. al. ## repeat p := C[1]; RemoveSet(C,C[1]); for g in gens do p1 := Length(forest)+1; p2 := Length(forest)+1; if IsRightMagmaCongruence(cong) then ## ## Search the forest to see if each right translation ## is in one of the blocks (trees) in the forest ## Get out a soon as both are found ## for i in [1..Length(forest)] do if p1>Length(forest) and p[1]*g in forest[i] then r1 := forest[i][1]; p1 := i; if p2<=Length(forest) then break; fi; fi; if p2>Length(forest) and p[2]*g in forest[i] then r2 := forest[i][1]; p2 := i; if p1<=Length(forest) then break; fi; fi; od; ## ## If the translation is not in any of the ## blocks already defined make the element ## a root to a potential block ## if p1=Length(forest)+1 then r1:=p[1]*g; fi; if p2=Length(forest)+1 then r2:=p[2]*g; fi; ## ## If the roots are different ## merge the blocks they represent ## if r1<>r2 then ## ## Merging of two existing blocks ## we must complete the Append and ## get rid of the one block without ## leaving a hole ## if p1<=Length(forest) and p2<=Length(forest) and not p1=p2 then Append(forest[p1],forest[p2]); Unbind(forest[p2]); ## No holes are left is at the end otherwise ## move the last one into the middle if not p2=Length(forest) then forest[p2]:=forest[Length(forest)]; Unbind(forest[Length(forest)]); fi; ## Simple cases of merging a new element with ## an existing block elif p1<=Length(forest) and not p2<=Length(forest) then Add(forest[p1],r2); elif p2<=Length(forest) and not p1<=Length(forest) then Add(forest[p2],r1); ## Add new non-trivial block made up of r1 and r2 else Add(forest,[r1,r2]); fi; ## Add the new branch to C AddSet(C,[r1,r2]); fi; fi; if IsLeftMagmaCongruence(cong) then ## ## Complete the left translations in an exact ## manner as above ## p1 := Length(forest)+1; p2 := Length(forest)+1; for i in [1..Length(forest)] do if p1>Length(forest) and g*p[1] in forest[i] then r1 := forest[i][1]; p1 := i; if p2<=Length(forest) then break; fi; fi; if p2>Length(forest) and g*p[2] in forest[i] then r2 := forest[i][1]; p2 := i; if p1<=Length(forest) then break; fi; fi; od; if p1=Length(forest)+1 then r1:=g*p[1]; fi; if p2=Length(forest)+1 then r2:=g*p[2]; fi; if r1<>r2 then if p1<=Length(forest) and p2<=Length(forest) and not p1=p2 then Append(forest[p1],forest[p2]); Unbind(forest[p2]); if not p2=Length(forest) then forest[p2]:=forest[Length(forest)]; Unbind(forest[Length(forest)]); fi; elif p1<=Length(forest) and not p2<=Length(forest) then Add(forest[p1],r2); elif p2<=Length(forest) and not p1<=Length(forest) then Add(forest[p2],r1); else Add(forest,[r1,r2]); fi; AddSet(C,[r1,r2]); fi; fi; od; ## Exit conditions are: ## full closure is complete ## we have created a partition larger than our limit ## partial closure condition is satisfied ## until IsEmpty(C) or checklimit() or partialcond(cong,forest); ## Set the equivalence partition if we have full closure ## if IsEmpty(C) then SetEquivalenceRelationPartition(cong,forest); ## Set partial closure if partialcond is met or ## size limit has been reached ## elif partialcond(cong,forest) then SetPartialClosureOfCongruence(cong,forest); cong!.C := ShallowCopy(C); elif checklimit() then Info(InfoWarning,1, "The congruence has either over 64,000 blocks or a \n", "#I block with over 64,000 elements. Hence only a\n", "#I a partial closure has been completed. You may view\n", "#I this partition using the 'PartialClosureOfCongruence'\n", "#I attribute"); SetPartialClosureOfCongruence(cong,forest); cong!.C := ShallowCopy(C); else Error("error, internal error in mgmcong.gi"); fi; end); ###################################################################### ## ## EquivalenceRelationPartition() ## Calculate the partition attribute of a left congruence ## ###################################################################### InstallMethod(EquivalenceRelationPartition, "for a left congruence on a magma", true, [IsLeftMagmaCongruence], 0, function(cong) # cong a congruence. # close the congruence with respect to left mult. MagmaCongruencePartition(cong,function(x,y) return false; end); return EquivalenceRelationPartition(cong); end); ###################################################################### ## ## EquivalenceRelationPartition() ## Calculate the partition attribute of a right congruence ## ###################################################################### InstallMethod(EquivalenceRelationPartition, "for a right congruence on a magma", true, [IsRightMagmaCongruence], 0, function(cong) # cong a congruence. # close the congruence with respect to right mult. MagmaCongruencePartition(cong,function(x,y) return false; end); return EquivalenceRelationPartition(cong); end); ###################################################################### ## ## EquivalenceRelationPartition() ## Calculate the partition attribute of a congruence ## ###################################################################### InstallMethod(EquivalenceRelationPartition, "for a congruence on a magma", true, [IsMagmaCongruence], 0, function(cong) # cong a congruence. # close the congruence with respect to left and right mult. MagmaCongruencePartition(cong,function(x,y) return false; end); return EquivalenceRelationPartition(cong); end); ############################################################################# ## #M JoinMagmaCongruences(,) ## ## Find the transitive closure of equivalence relations represented by ## cong1 and cong2 ## InstallMethod(JoinMagmaCongruences, "for magma congruences", true, [IsMagmaCongruence, IsMagmaCongruence],0, function(c1,c2) local er, # Join is equivalence relations cong; # Join congruence # Check to see that the both congruences have the same # parent magma # if Source(c1)<>Source(c2) then Error("usage: the source of and must be the same"); fi; # Find the join of the two congruences ar equivalence relations # er := JoinEquivalenceRelations(c1,c2); # Create the congruence and set the partition to that of # of er # cong := LR2MagmaCongruenceByGeneratingPairsCAT(Source(c1), Union(GeneratingPairsOfMagmaCongruence(c1), GeneratingPairsOfMagmaCongruence(c2)), IsMagmaCongruence); cong!.EquivalenceRelationPartition := EquivalenceRelationPartition(er); if HasIsAssociative(Source(c1)) and IsAssociative(Source(c1)) then SetIsSemigroupCongruence(cong,true); fi; return cong; end); ############################################################################# ## #M MeetMagmaCongruences(,) ## ## Find the meet of the equivalence relations represented by ## cong1 and cong2 ## InstallMethod(MeetMagmaCongruences, "for magma congruences", true, [IsMagmaCongruence, IsMagmaCongruence],0, function(c1,c2) local er, # Meet os equivalence relations cong; # Meet congruence # Check to see that the both congruences have the same # parent magma # if Source(c1)<>Source(c2) then Error("The source of and must be the same"); fi; # Find the meet of the two congruences as equivalence relations # er := MeetEquivalenceRelations(c1,c2); # Create the congruence and set the partition to that of # of er # cong := LR2MagmaCongruenceByGeneratingPairsCAT(Source(c1), Intersection(GeneratingPairsOfMagmaCongruence(c1), GeneratingPairsOfMagmaCongruence(c2)), IsMagmaCongruence); cong!.EquivalenceRelationPartition := EquivalenceRelationPartition(er); if HasIsAssociative(Source(c1)) and IsAssociative(Source(c1)) then SetIsSemigroupCongruence(cong,true); fi; return cong; end); ############################################################################# ## #M \in( , ) ## ## Checks whether is contained in the magma congruence class ## If is infinite, this will not necessarily terminate. ## InstallMethod( \in, "for a magma congruence class", true, [IsObject, IsCongruenceClass], 0, function(x, C) local partialclosure, #Partial closure part, #Partition rep, rel, class, GLOBAL_SEARCH_ELEMENT, GLOBAL_REP; # first ensure that is in the right family if FamilyObj(x) <> ElementsFamily(FamilyObj(Source(EquivalenceClassRelation(C)))) then Error("incompatible arguments for \in"); fi; # quick check to see if element is representative if x=Representative(C) then return true; fi; ## If the partition has been computed let the equivalence relation ## method deal with it if HasEquivalenceRelationPartition(EquivalenceClassRelation(C)) then TryNextMethod(); fi; ## We have partial closure see if this is enough ## if HasPartialClosureOfCongruence(EquivalenceClassRelation(C)) then part := PartialClosureOfCongruence(EquivalenceClassRelation(C)); rep := Representative(C); class := First(part,y->rep in y); # the partial closure has the elements in the same class # return true if class <> fail and x in class then return true; fi; fi; ## Need to see if a partial closure can give an answer ## NOT possible to give a negative solution if the number ## of blocks or the size of a block is infinite ## GLOBAL_REP := Representative(C); GLOBAL_SEARCH_ELEMENT := x; rel := EquivalenceClassRelation(C); ## These global variables are constant and used ## in the following partial closure test: ## stop when the search element is found in ## a block with the class's representative ## partialclosure := function(cong, forest) local block; block := First(forest,y-> GLOBAL_SEARCH_ELEMENT in y); if block=fail then return false; fi; return GLOBAL_REP in block; end; MagmaCongruencePartition(rel, partialclosure); ## We might have gotten a full closure from this call if so ## delegate the next method to determine if we have ## the element in the class ## Otherwise the partial condition must have been satisfied ## return true ## if HasEquivalenceRelationPartition(rel) then TryNextMethod(); else return true; fi; end); ############################################################################# ## #M Enumerator( ) ## ## Enumerator for a magma congruence class. ## InstallMethod( Enumerator, "for a magma congruence class", true, [IsCongruenceClass], 0, function(class) local cong; # the congruence of which class is a class cong := EquivalenceClassRelation(class); ## if the partition is already known, just go through the ## generic equivalence class method else compute the partition ## then get lazy and call generic equivalence ## if HasEquivalenceRelationPartition(EquivalenceClassRelation(class)) then TryNextMethod(); else MagmaCongruencePartition(cong,function(x,y) return false; end); TryNextMethod(); fi; end); ############################################################################# ## #M EquivalenceClassOfElement( , ) #M EquivalenceClassOfElementNC( , ) ## ## Returns the equivalence class of an element with respect to a ## magma congrucene . No calculation is performed at this stage. ## We do not always wish to check that is in the underlying set ## of , since we may wish to use equivalence relations to perform ## membership tests (for example when checking membership of a ## transformation in a monoid, we use Greens relations and classes). ## InstallMethod(EquivalenceClassOfElementNC, "for magma congruence with no check", true, [IsMagmaCongruence, IsObject], 0, function(rel, rep) local new; if IsMultiplicativeElementWithOne(rep) then new:= Objectify(NewType(CollectionsFamily(FamilyObj(rep)), IsCongruenceClass and IsEquivalenceClassDefaultRep and IsMultiplicativeElementWithOne), rec()); else new:= Objectify(NewType(CollectionsFamily(FamilyObj(rep)), IsCongruenceClass and IsEquivalenceClassDefaultRep and IsMultiplicativeElement), rec()); fi; SetEquivalenceClassRelation(new, rel); SetRepresentative(new, rep); SetParent(new, UnderlyingDomainOfBinaryRelation(rel)); return new; end); InstallMethod(EquivalenceClassOfElementNC, "for magma congruence with no check", true, [IsLeftMagmaCongruence, IsObject], 0, function(rel, rep) local new; if IsMultiplicativeElementWithOne(rep) then new:= Objectify(NewType(CollectionsFamily(FamilyObj(rep)), IsCongruenceClass and IsEquivalenceClassDefaultRep and IsMultiplicativeElementWithOne), rec()); else new:= Objectify(NewType(CollectionsFamily(FamilyObj(rep)), IsCongruenceClass and IsEquivalenceClassDefaultRep and IsMultiplicativeElement), rec()); fi; SetEquivalenceClassRelation(new, rel); SetRepresentative(new, rep); SetParent(new, UnderlyingDomainOfBinaryRelation(rel)); return new; end); InstallMethod(EquivalenceClassOfElementNC, "for magma congruence with no check", true, [IsRightMagmaCongruence, IsObject], 0, function(rel, rep) local new; if IsMultiplicativeElementWithOne(rep) then new:= Objectify(NewType(CollectionsFamily(FamilyObj(rep)), IsCongruenceClass and IsEquivalenceClassDefaultRep and IsMultiplicativeElementWithOne), rec()); else new:= Objectify(NewType(CollectionsFamily(FamilyObj(rep)), IsCongruenceClass and IsEquivalenceClassDefaultRep and IsMultiplicativeElement), rec()); fi; SetEquivalenceClassRelation(new, rel); SetRepresentative(new, rep); SetParent(new, UnderlyingDomainOfBinaryRelation(rel)); return new; end); InstallMethod(EquivalenceClassOfElement, "for magma congruence with checking", true, [IsMagmaCongruence, IsObject], 0, function(rel, rep) if not rep in UnderlyingDomainOfBinaryRelation(rel) then Error("Representative must lie in underlying set of the relation"); fi; return EquivalenceClassOfElementNC(rel, rep); end); InstallMethod(EquivalenceClassOfElement, "for left magma congruence with checking", true, [IsLeftMagmaCongruence, IsObject], 0, function(rel, rep) if not rep in UnderlyingDomainOfBinaryRelation(rel) then Error("Representative must lie in underlying set of the relation"); fi; return EquivalenceClassOfElementNC(rel, rep); end); InstallMethod(EquivalenceClassOfElement, "for right magma congruence with checking", true, [IsRightMagmaCongruence, IsObject], 0, function(rel, rep) if not rep in UnderlyingDomainOfBinaryRelation(rel) then Error("Representative must lie in underlying set of the relation"); fi; return EquivalenceClassOfElementNC(rel, rep); end); ############################################################################# ## #M ImagesElm( , ) . . . for a magma congruence ## assume we can compute the partition ## InstallMethod( ImagesElm, "for magma congruence and element", FamSourceEqFamElm, [ IsMagmaCongruence, IsObject ], 0, function( rel, elm ) return Set(Enumerator(EquivalenceClassOfElement(rel,elm))); end); ############################################################################# ## #M ImagesElm( , ) . . . for a left magma congruence ## assume we can compute the partition ## InstallMethod( ImagesElm, "for magma congruence and element", FamSourceEqFamElm, [ IsLeftMagmaCongruence, IsObject ], 0, function( rel, elm ) return Set(Enumerator(EquivalenceClassOfElement(rel,elm))); end); ############################################################################# ## #M ImagesElm( , ) . . . for a right magma congruence ## assume we can compute the partition ## InstallMethod( ImagesElm, "for magma congruence and element", FamSourceEqFamElm, [ IsRightMagmaCongruence, IsObject ], 0, function( rel, elm ) return Set(Enumerator(EquivalenceClassOfElement(rel,elm))); end); ############################################################################# ## #E gap-4r6p5/lib/methwhy.g0000644000175000017500000002640112172557252013547 0ustar billbill############################################################################# ## #W methwhy.g GAP tools Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file allows some fancy accesses to the method selection ## ############################################################################# ## #F Print_Value() ## ## ## ## ## ## print a number factorized by SUM_FLAGS ## ## ## BindGlobal("Print_Value_SFF",function(val) if val>SUM_FLAGS then Print(QuoInt(val,SUM_FLAGS),"*SUM_FLAGS"); val:=val mod SUM_FLAGS; if val>0 then Print("+",val); fi; else Print(val); fi; end); ############################################################################# ## #F ApplicableMethod( , [, [, ]] ) #F ApplicableMethodTypes( , [, [, ]] ) ## ## <#GAPDoc Label="ApplicableMethod"> ## ## ## ## ## ## Called with two arguments, returns the ## method of highest rank that is applicable for the operation opr ## with the arguments in the list args. ## The default printlevel is 0. ## If no method is applicable then fail is returned. ##

## If a positive integer is given as the fourth argument nr then ## returns the nr-th applicable method ## for the operation opr with the arguments in the list args, ## where the methods are ordered according to descending rank. ## If less than nr methods are applicable then fail is ## returned. ##

## If the fourth argument nr is the string "all" then ## ## returns a list of all applicable methods for opr with arguments ## args, ordered according to descending rank. ##

## Depending on the integer value printlevel, additional information is ## printed. Admissible values and their meaning are as follows. ##

## ## 0 ## ## no information, ## ## 1 ## ## information about the applicable method, ## ## 2 ## ## also information about the not applicable methods of higher rank, ## ## 3 ## ## also for each not applicable method the first reason why it is not ## applicable, ## ## 4 ## ## also for each not applicable method all reasons why it is not ## applicable. ## ## 6 ## ## also the function body of the selected method(s) ## ## ##

## When a method returned by is called then ## it returns either the desired result or the string ## "TRY_NEXT_METHOD", which corresponds to a call to ## in the method and means that ## the method selection would call the next applicable method. ##

## Note: ## The &GAP; kernel provides special treatment for the infix operations ## \+, \-, \*, \/, \^, \mod and ## \in. ## For some kernel objects (notably cyclotomic numbers, ## finite field elements and row vectors thereof) it calls kernel methods ## circumventing the method selection mechanism. ## Therefore for these operations may return ## a method which is not the kernel method actually used. ##

## The function takes the types ## or filters of the arguments as argument (if only filters are given ## of course family predicates cannot be tested). ## ## ## <#/GAPDoc> ## BIND_GLOBAL("ApplicableMethodTypes",function(arg) local oper,l,obj,skip,verbos,fams,flags,i,j,methods,flag,flag2, lent,nam,val,erg,has,need,isconstructor; if Length(arg)<2 or not IsList(arg[2]) or not IsFunction(arg[1]) then Error("usage: ApplicableMethodTypes(,[,[,]])"); fi; oper:=arg[1]; isconstructor:=oper in CONSTRUCTORS; obj:=arg[2]; if Length(arg)>2 then verbos:=arg[3]; else verbos:=0; fi; if Length(arg)>3 then if IsInt( arg[4] ) then skip:=arg[4] - 1; else skip:= -1; fi; erg:=[]; else skip:=0; fi; l:=Length(obj); # get families and filters flags:=[]; fams:=[]; for i in obj do if IsFilter(i) or IsIdenticalObj( i, IsObject ) then Add(flags,FLAGS_FILTER(i)); Add(fams,fail); elif IsType(i) then Add(flags,i![2]); Add(fams,i![1]); else Error("wrong kind of argument"); fi; od; if ForAny(fams,i->i=fail) then fams:=fail; Info(InfoWarning,1,"Family predicate cannot be tested"); fi; methods:=METHODS_OPERATION(oper,l); if verbos > 0 then Print("#I Searching Method for ",NameFunction(oper)," with ",l, " arguments:\n"); fi; lent:=4+l; #length of one entry if verbos > 0 then Print("#I Total: ", Length(methods)/lent," entries\n"); fi; for i in [1..Length(methods)/lent] do nam:=methods[lent*(i-1)+l+4]; val:=methods[lent*(i-1)+l+3]; if verbos>1 then Print("#I Method ",i,": ``",nam,"'', value: "); Print_Value_SFF(val); Print("\n"); fi; flag:=true; j:=1; while j<=l and (flag or verbos>3) do if j=1 and isconstructor then flag2:=IS_SUBSET_FLAGS(methods[lent*(i-1)+1+j],flags[j]); else flag2:=IS_SUBSET_FLAGS(flags[j],methods[lent*(i-1)+1+j]); fi; flag:=flag and flag2; if flag2=false and verbos>2 then need:=NamesFilter(methods[lent*(i-1)+1+j]); if j=1 and isconstructor then Print("#I - ",Ordinal(j)," argument must be ", need,"\n"); else has:=NamesFilter(flags[j]); Print("#I - ",Ordinal(j)," argument needs ", Filtered(need,i->not i in has),"\n"); fi; fi; j:=j+1; od; if flag then if fams=fail or CallFuncList(methods[lent*(i-1)+1],fams) then if verbos=1 then Print("#I Method ",i,": ``",nam,"'', value: "); Print_Value_SFF(val); Print("\n"); fi; oper:=methods[lent*(i-1)+j+1]; if verbos>5 then Print("#I Function Body:\n"); Print(oper); fi; if skip=0 then return oper; else Add(erg,oper); skip:=skip-1; if verbos>0 then Print("#I Skipped:\n"); fi; fi; elif verbos>2 then Print("#I - bad family relations\n"); fi; fi; od; if skip<0 then return erg; else return fail; fi; end); BIND_GLOBAL("ApplicableMethod",function(arg) local i,l; if Length(arg)<2 or not IsList(arg[2]) or not IsFunction(arg[1]) then Error("usage: ApplicableMethod(,[,[,]])"); fi; l:=ShallowCopy(arg[2]); for i in [1..Length(l)] do if i=1 and arg[1] in CONSTRUCTORS then l[i]:=l[i]; else l[i]:=TypeObj(l[i]); fi; od; arg[2]:=l; return CallFuncList(ApplicableMethodTypes,arg); end); ############################################################################# ## #F ShowImpliedFilters( ) ## ## <#GAPDoc Label="ShowImpliedFilters"> ## ## ## ## ## Displays information about the filters that may be implied by ## filter. They are given by their names. ShowImpliedFilters first ## displays the names of all filters that are unconditionally implied by ## filter. It then displays implications that require further filters to ## be present (indicating by + the required further filters). ## The function displays only first-level implications, implications that ## follow in turn are not displayed (though &GAP; will do these). ## ShowImpliedFilters(IsMatrix); ## Implies: ## IsGeneralizedRowVector ## IsNearAdditiveElementWithInverse ## IsAdditiveElement ## IsMultiplicativeElement ## ## ## May imply with: ## +IsGF2MatrixRep ## IsOrdinaryMatrix ## ## +CategoryCollections(CategoryCollections(IsAdditivelyCommutativeElement)) ## IsAdditivelyCommutativeElement ## ## +IsInternalRep ## IsOrdinaryMatrix ## ## ]]> ## ## ## <#/GAPDoc> ## BIND_GLOBAL("ShowImpliedFilters",function(fil) local flags,f,i,j,l,m,n; flags:=FLAGS_FILTER(fil); f:=Filtered(IMPLICATIONS,x->IS_SUBSET_FLAGS(x[2],flags)); l:=[]; m:=[]; for i in f do n:=SUB_FLAGS(i[2],flags); # the additional requirements if SIZE_FLAGS(n)=0 then Add(l,i[1]); else Add(m,[n,i[1]]); fi; od; if Length(l)>0 then Print("Implies:\n"); for i in l do for j in NamesFilter(i) do Print(" ",j,"\n"); od; od; fi; if Length(m)>0 then Print("\n\nMay imply with:\n"); for i in m do for j in NamesFilter(i[1]) do Print("+",j,"\n"); od; for j in NamesFilter(i[2]) do Print(" ",j,"\n"); od; Print("\n"); od; fi; end); ############################################################################# ## #F PageSource( func ) . . . . . . . . . . . . . . . show source code in pager ## ## <#GAPDoc Label="PageSource"> ## ## ## ## ## This shows the file containing the source code of the function or method ## func in a pager (see ). The display starts at ## a line shortly before the code of func.

## ## This function works if FilenameFunc(func) returns the name of ## a proper file. In that case this filename and the position of the ## function definition are also printed. ## Otherwise the function indicates that the source is not available ## (for example this happens for functions which are implemented in ## the &GAP; C-kernel).

## ## Usage examples:
## met := ApplicableMethod(\^, [(1,2),2743527]); PageSource(met);
## PageSource(Combinations);
## ct:=CharacterTable(Group((1,2,3)));
## met := ApplicableMethod(Size,[ct]); PageSource(met); ##

## ## ## <#/GAPDoc> BIND_GLOBAL("PageSource", function ( fun ) local f, l; f := FILENAME_FUNC( fun ); if f = fail then if IsKernelFunction(fun) then Print("Cannot locate source of kernel function ", NameFunction(fun),".\n"); else Print( "Source not available.\n" ); fi; elif not (IsExistingFile(f) and IsReadableFile(f)) then Print( "Cannot access code from file \"",f,"\".\n"); else l := Maximum(STARTLINE_FUNC( fun )-5, 1); Print( "Showing source in ", f, " (from line ", l, ")\n" ); # Exec( Concatenation( "view +", String( l ), " ", f ) ); Pager(rec(lines := StringFile(f), formatted := true, start := l)); fi; end); ############################################################################# ## #E gap-4r6p5/lib/conwdat3.g0000644000175000017500000203075612172557252013616 0ustar billbill############################################################################# ## #W conwdat3.g GAP library Thomas Breuer #W Frank Lübeck ## ## #Y Copyright (C) 2005 The GAP Group ## ## This file contains the data for precomputed Conway polynomials for ## primes ## 1000 < p < 110000 ## (File is only read by 'ConwayPolynomial' if needed.) CONWAYPOLDATA[1009]:=[ ,,,[15085570,"RPn"],,[873681994957,"JB"],,,[2700584453,"RPn"],]; CONWAYPOLDATA[1013]:=[ ,,,[2789805,"RPn"],,[2123953631491,"JB"],,,[9762403570,"RPn"],]; CONWAYPOLDATA[1019]:=[ ,,,[9289206,"RPn"],,[2132424228782,"JB"],,,[1008808979,"RPn"],]; CONWAYPOLDATA[1021]:=[ ,,,[4082989,"RPn"],,[728072947742,"JB"],,,[2541070916,"RPn"],]; CONWAYPOLDATA[1031]:=[ ,,,[4079681,"RPn"],,[5310099608804,"JB"],,,[6354544773,"RPn"],]; CONWAYPOLDATA[1033]:=[ ,,,[18091967,"RPn"],,[769030978346,"JB"],,,[12602664041,"RPn"],]; CONWAYPOLDATA[1039]:=[ ,,,[8387850,"RPn"],,[1150146153282,"JB"],,,[6612084824,"RPn"],]; CONWAYPOLDATA[1049]:=[ ,,,[5376128,"RPn"],,[4023561882637,"JB"],,,[6236319683,"RPn"],]; CONWAYPOLDATA[1051]:=[ ,,,[7672307,"RPn"],,[790129179599,"JB"],,,[15964468232,"RPn"],]; CONWAYPOLDATA[1061]:=[ ,,,[7442917,"RPn"],,[2312960502005,"JB"],,,[12154601676,"RPn"],]; CONWAYPOLDATA[1063]:=[ ,,,[2927505,"RPn"],,[581195438154,"JB"],,,[4710167879,"RPn"],]; CONWAYPOLDATA[1069]:=[ ,,,[7995057,"RPn"],,[838182584730,"JB"],,,[5910844143,"RPn"],]; CONWAYPOLDATA[1087]:=[ ,,,[12988566,"RPn"],,[5804247075817,"JB"],,,[7533748074,"RPn"],]; CONWAYPOLDATA[1091]:=[ ,,,[3413741,"RPn"],,[3838737265573,"JB"],,,[934330216,"RPn"],]; CONWAYPOLDATA[1093]:=[ ,,,[8247783,"RPn"],,[940283357783,"JB"],,,[51928503226,"RPn"],]; CONWAYPOLDATA[1097]:=[ ,,,[5896378,"RPn"],,[1569097397874,"JB"],,,[21144672,"RPn"],]; CONWAYPOLDATA[1103]:=[ ,,,[3336580,"RPn"],,[2549438994451,"JB"],,,[3229751651,"RPn"],]; CONWAYPOLDATA[1109]:=[ ,,,[11061168,"RPn"],,[2883269157964,"JB"],,,[5383948800,"RPn"],]; CONWAYPOLDATA[1117]:=[ ,,,[8442288,"RPn"],,[1389359108600,"JB"],,,[3804220514,"RPn"],]; CONWAYPOLDATA[1123]:=[ ,,,[11342302,"RPn"],,[1300351974959,"JB"],,,[2075640898,"RPn"],]; CONWAYPOLDATA[1129]:=[ ,,,[21428431,"RPn"],,[4864233137144,"JB"],,,[21000710758,"RPn"],]; CONWAYPOLDATA[1151]:=[ ,,,[6089958,"RPn"],,[2661295257633,"JB"],,,[2788290577,"RPn"],]; CONWAYPOLDATA[1153]:=[ ,,,[39555976,"RPn"],,[390534591258,"JB"],,,[5916416567,"RPn"],]; CONWAYPOLDATA[1163]:=[ ,,,[5405629,"RPn"],,[4015073741353,"JB"],,,[3526425335,"RPn"],]; CONWAYPOLDATA[1171]:=[ ,,,[12272082,"RPn"],,[1673979331397,"JB"],,,[796599681,"RPn"],]; CONWAYPOLDATA[1181]:=[ ,,,[5018076,"RPn"],,[5521385646710,"JB"],,,[9988626363,"RPn"],]; CONWAYPOLDATA[1187]:=[ ,,,[6535624,"RPn"],,[5446150254926,"JB"],,,[6990726107,"RPn"],]; CONWAYPOLDATA[1193]:=[ ,,,[16641160,"RPn"],,[5953640035684,"JB"],,,[6780373742,"RPn"],]; CONWAYPOLDATA[1201]:=[ ,,,[30056237,"RPn"],,[1589159272741,"JB"],,,[1572908855,"RPn"],]; CONWAYPOLDATA[1213]:=[ ,,,[14308550,"RPn"],,[1085324531439,"JB"],,,[10576148211,"RPn"],]; CONWAYPOLDATA[1217]:=[ ,,,[14410500,"RPn"],,[4936364312955,"JB"],,,[1777482045,"RPn"],]; CONWAYPOLDATA[1223]:=[ ,,,[6857366,"RPn"],,[6378763106287,"JB"],,,[7548275277,"RPn"],]; CONWAYPOLDATA[1229]:=[ ,,,[10487059,"RPn"],,[4540573432286,"JB"],,,[1485935967,"RPn"],]; CONWAYPOLDATA[1231]:=[ ,,,[5361008,"RPn"],,[2149557677896,"JB"],,,[46468650928,"RPn"],]; CONWAYPOLDATA[1237]:=[ ,,,[10368536,"RPn"],,[1607182833774,"JB"],,,[20707835214,"RPn"],]; CONWAYPOLDATA[1249]:=[ ,,,[27509232,"RPn"],,[924620941023,"JB"],,,[1792742151,"RPn"],]; CONWAYPOLDATA[1259]:=[ ,,,[10831179,"RPn"],,[4890860854633,"JB"],,,[5250877305,"RPn"],]; CONWAYPOLDATA[1277]:=[ ,,,[7484499,"RPn"],,[7393409563076,"JB"],,,[699575077,"RPn"],]; CONWAYPOLDATA[1279]:=[ ,,,[10986613,"RPn"],,[334133089149,"JB"],,,[1829301258,"RPn"],]; CONWAYPOLDATA[1283]:=[ ,,,[14030890,"RPn"],,[4488738696319,"JB"],,,[3998320670,"RPn"],]; CONWAYPOLDATA[1289]:=[ ,,,[6408914,"RPn"],,[5153443722234,"JB"],,,[7520276060,"RPn"],]; CONWAYPOLDATA[1291]:=[ ,,,[11160697,"RPn"],,[2248299571463,"JB"],,,[9684201536,"RPn"],]; CONWAYPOLDATA[1297]:=[ ,,,[14504361,"RPn"],,[1739635257350,"JB"],,,[14930525735,"RPn"],]; CONWAYPOLDATA[1301]:=[ ,,,[6576557,"RPn"],,[5217788081266,"JB"],,,[23897824410,"RPn"],]; CONWAYPOLDATA[1303]:=[ ,,,[4458872,"RPn"],,[2718808238740,"JB"],,,[1468996982,"RPn"],]; CONWAYPOLDATA[1307]:=[ ,,,[7936106,"RPn"],,[9045938710762,"JB"],,,[1270482418,"RPn"],]; CONWAYPOLDATA[1319]:=[ ,,,[10037603,"RPn"],,[5224588291046,"JB"],,,[2107390029,"RPn"],]; CONWAYPOLDATA[1321]:=[ ,,,[15575924,"RPn"],,[2433765958931,"JB"],,,[18165625807,"RPn"],]; CONWAYPOLDATA[1327]:=[ ,,,[4482609,"RPn"],,[2824402450641,"JB"],,,[29107926796,"RPn"],]; CONWAYPOLDATA[1361]:=[ ,,,[1835992,"RPn"],,[5510214291369,"JB"],,,[7626230119,"RPn"],]; CONWAYPOLDATA[1367]:=[ ,,,[16346591,"RPn"],,[8280089594770,"JB"],,,[9999912570,"RPn"],]; CONWAYPOLDATA[1373]:=[ ,,,[22478758,"RPn"],,[9370651747706,"JB"],,,[10030915572,"RPn"],]; CONWAYPOLDATA[1381]:=[ ,,,[20876579,"RPn"],,[4082359251490,"JB"],,,[41357786127,"RPn"],]; CONWAYPOLDATA[1399]:=[ ,,,[28749463,"RPn"],,[3188221465360,"JB"],,,[23267362163,"RPn"],]; CONWAYPOLDATA[1409]:=[ ,,,[5334477,"RPn"],,[5689144540829,"JB"],,,[4341888448,"RPn"],]; CONWAYPOLDATA[1423]:=[ ,,,[10118956,"RPn"],,[12112943274880,"JB"],,,[62192684587,"RPn"],]; CONWAYPOLDATA[1427]:=[ ,,,[28026282,"RPn"],,[21462189934655,"JB"],,,[4428487583,"RPn"],]; CONWAYPOLDATA[1429]:=[ ,,,[14288577,"RPn"],,[7748957304286,"JB"],,,[5397785987,"RPn"],]; CONWAYPOLDATA[1433]:=[ ,,,[7425809,"RPn"],,[8400246574636,"JB"],,,[936797953,"RPn"],]; CONWAYPOLDATA[1439]:=[ ,,,[10340661,"RPn"],,[8063317021276,"JB"],,,[2315716499,"RPn"],]; CONWAYPOLDATA[1447]:=[ ,,,[11784371,"RPn"],,[1302859796552,"JB"],,,[33020454624,"RPn"],]; CONWAYPOLDATA[1451]:=[ ,,,[7417514,"RPn"],,[28475505898975,"JB"],,,[6516239309,"RPn"],]; CONWAYPOLDATA[1453]:=[ ,,,[20988587,"RPn"],,[4447964773663,"JB"],,,[21321134561,"RPn"],]; CONWAYPOLDATA[1459]:=[ ,,,[16148215,"RPn"],,[1956301004977,"JB"],,,[8585078436,"RPn"],]; CONWAYPOLDATA[1471]:=[ ,,,[6220865,"RPn"],,[3085913880201,"JB"],,,[109520489500,"RPn"],]; CONWAYPOLDATA[1481]:=[ ,,,[10805379,"RPn"],,[9477365244556,"JB"],,,[14422783661,"RPn"],]; CONWAYPOLDATA[1483]:=[ ,,,[32525158,"RPn"],,[3811676539765,"JB"],,,[26052733002,"RPn"],]; CONWAYPOLDATA[1487]:=[ ,,,[8838733,"RPn"],,[8816938801643,"JB"],,,[32430293778,"RPn"],]; CONWAYPOLDATA[1489]:=[ ,,,[21888314,"RPn"],,[839127081654,"JB"],,,[25751952719,"RPn"],]; CONWAYPOLDATA[1493]:=[ ,,,[8359309,"RPn"],,[6517278015145,"JB"],,,[3070448557,"RPn"],]; CONWAYPOLDATA[1499]:=[ ,,,[17632739,"RPn"],,[7401377636049,"JB"],,,[26628756151,"RPn"],]; CONWAYPOLDATA[1511]:=[ ,,,[9014637,"RPn"],,[5581239246728,"JB"],,,[24473384432,"RPn"],]; CONWAYPOLDATA[1523]:=[ ,,,[1710331,"RPn"],,[5620424752752,"JB"],,,[4863692883,"RPn"],]; CONWAYPOLDATA[1531]:=[ ,,,[6139312,"RPn"],,[20534280982483,"JB"],,,[28402257700,"RPn"],]; CONWAYPOLDATA[1543]:=[ ,,,[9517229,"RPn"],,[5113293485157,"JB"],,,[28470397556,"RPn"],]; CONWAYPOLDATA[1549]:=[ ,,,[2069466,"RPn"],,[5287477849526,"JB"],,,[36622540749,"RPn"],]; CONWAYPOLDATA[1553]:=[ ,,,[11712729,"RPn"],,[15022609617163,"JB"],,,[1552967384,"RPn"],]; CONWAYPOLDATA[1559]:=[ ,,,[6586794,"RPn"],,[10595630375861,"JB"],,,[12618924818,"RPn"],]; CONWAYPOLDATA[1567]:=[ ,,,[12271180,"RPn"],,[3293192897994,"JB"],,,[22637590281,"RPn"],]; CONWAYPOLDATA[1571]:=[ ,,,[6252582,"RPn"],,[12068569765120,"JB"],,,[24747226199,"RPn"],]; CONWAYPOLDATA[1579]:=[ ,,,[17244262,"RPn"],,[4902243235822,"JB"],,,[3057766656,"RPn"],]; CONWAYPOLDATA[1583]:=[ ,,,[10017229,"RPn"],,[7356739546103,"JB"],,,[7571430424,"RPn"],]; CONWAYPOLDATA[1597]:=[ ,,,[4578610,"RPn"],,[3230402503499,"JB"],,,[39731248755,"RPn"],]; CONWAYPOLDATA[1601]:=[ ,,,[19482572,"RPn"],,[14357141182887,"JB"],,,[22065828926,"RPn"],]; CONWAYPOLDATA[1607]:=[ ,,,[30970109,"RPn"],,[7513877432736,"JB"],,,[7453765772,"RPn"],]; CONWAYPOLDATA[1609]:=[ ,,,[14999105,"RPn"],,[3635814909293,"JB"],,,[33244655985,"RPn"],]; CONWAYPOLDATA[1613]:=[ ,,,[2063030,"RPn"],,[19970501092050,"JB"],,,[22449248484,"RPn"],]; CONWAYPOLDATA[1619]:=[ ,,,[23252080,"RPn"],,[8274011889363,"JB"],,,[38929933252,"RPn"],]; CONWAYPOLDATA[1621]:=[ ,,,[17317145,"RPn"],,[5696612029966,"JB"],,,[25514400592,"RPn"],]; CONWAYPOLDATA[1627]:=[ ,,,[9854742,"RPn"],,[4613370818020,"JB"],,,[3584861836,"RPn"],]; CONWAYPOLDATA[1637]:=[ ,,,[4094139,"RPn"],,[13537123350921,"JB"],,,[24945359018,"RPn"],]; CONWAYPOLDATA[1657]:=[ ,,,[37209603,"RPn"],,[19574605984037,"JB"],,,[34473311667,"RPn"],]; CONWAYPOLDATA[1663]:=[ ,,,[8082183,"RPn"],,[6768458616145,"JB"],,,[91532968470,"RPn"],]; CONWAYPOLDATA[1667]:=[ ,,,[24343203,"RPn"],,[14712497547796,"JB"],,,[6307177848,"RPn"],]; CONWAYPOLDATA[1669]:=[ ,,,[18182088,"RPn"],,[6174282580940,"JB"],,,[29815283038,"RPn"],]; CONWAYPOLDATA[1693]:=[ ,,,[11204276,"RPn"],,[6305748514448,"JB"],,,[52991622909,"RPn"],]; CONWAYPOLDATA[1697]:=[ ,,,[51006732,"RPn"],,[14294700917840,"JB"],,,[15396828390,"RPn"],]; CONWAYPOLDATA[1699]:=[ ,,,[11218500,"RPn"],,[2894420970313,"JB"],,,[112220954817,"RPn"],]; CONWAYPOLDATA[1709]:=[ ,,,[2049094,"RPn"],,[15820841524060,"JB"],,,[16896462583,"RPn"],]; CONWAYPOLDATA[1721]:=[ ,,,[8783987,"RPn"],,[10937936028517,"JB"],,,[35314345183,"RPn"],]; CONWAYPOLDATA[1723]:=[ ,,,[7739719,"RPn"],,[24020906781110,"JB"],,,[9607379077,"RPn"],]; CONWAYPOLDATA[1733]:=[ ,,,[7864356,"RPn"],,[17545253287177,"JB"],,,[7393938080,"RPn"],]; CONWAYPOLDATA[1741]:=[ ,,,[29851188,"RPn"],,[8675511147440,"JB"],,,[23739722360,"RPn"],]; CONWAYPOLDATA[1747]:=[ ,,,[26907296,"RPn"],,[12221058113544,"JB"],,,[14722299181,"RPn"],]; CONWAYPOLDATA[1753]:=[ ,,,[44689236,"RPn"],,[8268857792063,"JB"],,,[138351060102,"RPn"],]; CONWAYPOLDATA[1759]:=[ ,,,[14388626,"RPn"],,[7254119150375,"JB"],,,[5322193981,"RPn"],]; CONWAYPOLDATA[1777]:=[ ,,,[59014175,"RPn"],,[9788581104023,"JB"],,,[66035729607,"RPn"],]; CONWAYPOLDATA[1783]:=[ ,,,[18355995,"RPn"],,[16921956015505,"JB"],,,[101614863840,"RPn"],]; CONWAYPOLDATA[1787]:=[ ,,,[24294267,"RPn"],,[14733446172137,"JB"],,,[10870079753,"RPn"],]; CONWAYPOLDATA[1789]:=[ ,,,[2860617,"RPn"],,[3941773216968,"JB"],,,[65332616224,"RPn"],]; CONWAYPOLDATA[1801]:=[ ,,,[81055817,"RPn"],,[10464595832142,"JB"],,,[57195835610,"RPn"],]; CONWAYPOLDATA[1811]:=[ ,,,[38605093,"RPn"],,[12922546247817,"JB"],,,[28906171456,"RPn"],]; CONWAYPOLDATA[1823]:=[ ,,,[9516065,"RPn"],,[19783266756104,"JB"],,,[9417262510,"RPn"],]; CONWAYPOLDATA[1831]:=[ ,,,[16755484,"RPn"],,[10307235208353,"JB"],,,[8882992130,"RPn"],]; CONWAYPOLDATA[1847]:=[ ,,,[19181100,"RPn"],,[19357908884422,"JB"],,,[2781862739,"RPn"],]; CONWAYPOLDATA[1861]:=[ ,,,[13443866,"RPn"],,[20711543685272,"JB"],,,[28468619583,"RPn"],]; CONWAYPOLDATA[1867]:=[ ,,,[26821324,"RPn"],,[6019182481846,"JB"],,,[25890708380,"RPn"],]; CONWAYPOLDATA[1871]:=[ ,,,[37786730,"RPn"],,[18170944296562,"JB"],,,[31896430044,"RPn"],]; CONWAYPOLDATA[1873]:=[ ,,,[48969595,"RPn"],,[3200109583636,"JB"],,,[69414964548,"RPn"],]; CONWAYPOLDATA[1877]:=[ ,,,[23633309,"RPn"],,[24264055303806,"JB"],,,[26324446363,"RPn"],]; CONWAYPOLDATA[1879]:=[ ,,,[13767439,"RPn"],,[11818360296677,"JB"],,,[171396566368,"RPn"],]; CONWAYPOLDATA[1889]:=[ ,,,[3545656,"RPn"],,[12909469698240,"JB"],,,[43983103864,"RPn"],]; CONWAYPOLDATA[1901]:=[ ,,,[31187808,"RPn"],,[19606255398552,"JB"],,,[13212356812,"RPn"],]; CONWAYPOLDATA[1907]:=[ ,,,[10705900,"RPn"],,[59969115338549,"JB"],,,[2082304787,"RPn"],]; CONWAYPOLDATA[1913]:=[ ,,,[10791236,"RPn"],,[22258902964521,"JB"],,,[31844779366,"RPn"],]; CONWAYPOLDATA[1931]:=[ ,,,[28493838,"RPn"],,[19154512539372,"JB"],,,[34261671206,"RPn"],]; CONWAYPOLDATA[1933]:=[ ,,,[24630291,"RPn"],,[48748668114582,"JB"],,,[5232663856,"RPn"],]; CONWAYPOLDATA[1949]:=[ ,,,[13391581,"RPn"],,[28096562104403,"JB"],,,[19426047461,"RPn"],]; CONWAYPOLDATA[1951]:=[ ,,,[13436540,"RPn"],,[11458760285893,"JB"],,,[32379432023,"RPn"],]; CONWAYPOLDATA[1973]:=[ ,,,[18540283,"RPn"],,[61272577158633,"JB"],,,[5599360187,"RPn"],]; CONWAYPOLDATA[1979]:=[ ,,,[54373027,"RPn"],,[30419726328413,"JB"],,,[26475966401,"RPn"],]; CONWAYPOLDATA[1987]:=[ ,,,[31068734,"RPn"],,[7696778747683,"JB"],,,[23126581726,"RPn"],]; CONWAYPOLDATA[1993]:=[ ,,,[73645341,"RPn"],,[13853815536319,"JB"],,,[323291238433,"RPn"],]; CONWAYPOLDATA[1997]:=[ ,,,[39558575,"RPn"],,[29635547256965,"JB"],,,[30721794079,"RPn"],]; CONWAYPOLDATA[1999]:=[ ,,,[14340829,"RPn"],,[8900331332141,"JB"],,,[63102155136,"RPn"],]; CONWAYPOLDATA[2003]:=[ ,,,[54826121,"RPn"],,[48119302449408,"JB"],,,[25527471852,"RPn"],]; CONWAYPOLDATA[2011]:=[ ,,,[24136025,"RPn"],,[10034328675606,"JB"],,,[232442426420,"RPn"],]; CONWAYPOLDATA[2017]:=[ ,,,[27219420,"RPn"],,[15123703527976,"JB"],,,[78461043836,"RPn"],]; CONWAYPOLDATA[2027]:=[ ,,,[3849275,"RPn"],,[33595082385949,"JB"],,,[50331867411,"RPn"],]; CONWAYPOLDATA[2029]:=[ ,,,[32192116,"RPn"],,[12470154925814,"JB"],,,[174186247365,"RPn"],]; CONWAYPOLDATA[2039]:=[ ,,,[61013004,"RPn"],,[50997047992467,"JB"],,,[6891100226,"RPn"],]; CONWAYPOLDATA[2053]:=[ ,,,[45391832,"RPn"],,[17738584221463,"JB"],,,[12183739957,"RPn"],]; CONWAYPOLDATA[2063]:=[ ,,,[37400132,"RPn"],,[23455592329754,"JB"],,,[64992700420,"RPn"],]; CONWAYPOLDATA[2069]:=[ ,,,[28608065,"RPn"],,[85394275425240,"JB"],,,[7550964466,"RPn"],]; CONWAYPOLDATA[2081]:=[ ,,,[34051406,"RPn"],,[34668567735876,"JB"],,,[51184246863,"RPn"],]; CONWAYPOLDATA[2083]:=[ ,,,[38720889,"RPn"],,[7148855039739,"JB"],,,[79950476708,"RPn"],]; CONWAYPOLDATA[2087]:=[ ,,,[28856954,"RPn"],,[23671048603012,"JB"],,,[17504789714,"RPn"],]; CONWAYPOLDATA[2089]:=[ ,,,[12874514,"RPn"],,[15839159860765,"JB"],,,[27197148484,"RPn"],]; CONWAYPOLDATA[2099]:=[ ,,,[34677581,"RPn"],,[49964103245059,"JB"],,,[53109095304,"RPn"],]; CONWAYPOLDATA[2111]:=[ ,,,[12957325,"RPn"],,[133005090321863,"JB"],,,[2745066286,"RPn"],]; CONWAYPOLDATA[2113]:=[ ,,,[83066261,"RPn"],,[17488670797755,"JB"],,,[16223964753,"RPn"],]; CONWAYPOLDATA[2129]:=[ ,,,[30755537,"RPn"],,[73654810366409,"JB"],,,[58423008851,"RPn"],]; CONWAYPOLDATA[2131]:=[ ,,,[13453005,"RPn"],,[9685014720921,"JB"],,,[57946134950,"RPn"],]; CONWAYPOLDATA[2137]:=[ ,,,[29864585,"RPn"],,[7163627730598,"JB"],,,[273017215459,"RPn"],]; CONWAYPOLDATA[2141]:=[ ,,,[16222359,"RPn"],,[38013913841994,"JB"],,,[1276095946,"RPn"],]; CONWAYPOLDATA[2143]:=[ ,,,[17287584,"RPn"],,[15910683645108,"JB"],,,[68646590417,"RPn"],]; CONWAYPOLDATA[2153]:=[ ,,,[13415346,"RPn"],,[39789728804784,"JB"],,,[19380027115,"RPn"],]; CONWAYPOLDATA[2161]:=[ ,,,[73422159,"RPn"],,[40966042897282,"JB"],,,[65066960110,"RPn"],]; CONWAYPOLDATA[2179]:=[ ,,,[32883296,"RPn"],,[21094714231702,"JB"],,,[35700304551,"RPn"],]; CONWAYPOLDATA[2203]:=[ ,,,[37497268,"RPn"],,[7941564717175,"JB"],,,[95376545409,"RPn"],]; CONWAYPOLDATA[2207]:=[ ,,,[41604162,"RPn"],,[29190369423953,"JB"],,,[7649733456,"RPn"],]; CONWAYPOLDATA[2213]:=[ ,,,[34073563,"RPn"],,[39705079533966,"JB"],,,[31553750678,"RPn"],]; CONWAYPOLDATA[2221]:=[ ,,,[32444370,"RPn"],,[24299968926751,"JB"],,,[64706578462,"RPn"],]; CONWAYPOLDATA[2237]:=[ ,,,[43136073,"RPn"],,[34434552030856,"JB"],,,[59962317465,"RPn"],]; CONWAYPOLDATA[2239]:=[ ,,,[59946989,"RPn"],,[12618661486739,"JB"],,,[355948752932,"RPn"],]; CONWAYPOLDATA[2243]:=[ ,,,[8514430,"RPn"],,[73000822624156,"JB"],,,[6738723403,"RPn"],]; CONWAYPOLDATA[2251]:=[ ,,,[34543853,"RPn"],,[23583826552733,"JB"],,,[28535560080,"RPn"],]; CONWAYPOLDATA[2267]:=[ ,,,[55675255,"RPn"],,[117883349232715,"JB"],,,[21240545415,"RPn"],]; CONWAYPOLDATA[2269]:=[ ,,,[55134433,"RPn"],,[26404954884018,"JB"],,,[116219493749,"RPn"],]; CONWAYPOLDATA[2273]:=[ ,,,[14681310,"RPn"],,[52769530879373,"JB"],,,[21284956158,"RPn"],]; CONWAYPOLDATA[2281]:=[ ,,,[3334829,"RPn"],,[14721189149687,"JB"],,,[127257348110,"RPn"],]; CONWAYPOLDATA[2287]:=[ ,,,[36322153,"RPn"],,[21678174937596,"JB"],,,[20697455183,"RPn"],]; CONWAYPOLDATA[2293]:=[ ,,,[55458500,"RPn"],,[23336280263587,"JB"],,,[94414809267,"RPn"],]; CONWAYPOLDATA[2297]:=[ ,,,[46279961,"RPn"],,[53864312559220,"JB"],,,[11262218559,"RPn"],]; CONWAYPOLDATA[2309]:=[ ,,,[10348940,"RPn"],,[51950718814312,"JB"],,,[81548541590,"RPn"],]; CONWAYPOLDATA[2311]:=[ ,,,[21048591,"RPn"],,[90809867896929,"JB"],,,[21935057554,"RPn"],]; CONWAYPOLDATA[2333]:=[ ,,,[41812028,"RPn"],,[53744427190374,"JB"],,,[1114765723,"RPn"],]; CONWAYPOLDATA[2339]:=[ ,,,[4135354,"RPn"],,[88568649664313,"JB"],,,[9433975241,"RPn"],]; CONWAYPOLDATA[2341]:=[ ,,,[53814915,"RPn"],,[15653669419960,"JB"],,,[434663777416,"RPn"],]; CONWAYPOLDATA[2347]:=[ ,,,[19468368,"RPn"],,[30214264426930,"JB"],,,[77185573073,"RPn"],]; CONWAYPOLDATA[2351]:=[ ,,,[37446741,"RPn"],,[46759757482070,"JB"],,,[48521186368,"RPn"],]; CONWAYPOLDATA[2357]:=[ ,,,[49487574,"RPn"],,[54209594233348,"JB"],,,[10733035543,"RPn"],]; CONWAYPOLDATA[2371]:=[ ,,,[44299766,"RPn"],,[80122164931153,"JB"],,,[314758797453,"RPn"],]; CONWAYPOLDATA[2377]:=[ ,,,[37903647,"RPn"],,[13095067388610,"JB"],,,[388360311837,"RPn"],]; CONWAYPOLDATA[2381]:=[ ,,,[73465758,"RPn"],,[37980644228648,"JB"],,,[54418062146,"RPn"],]; CONWAYPOLDATA[2383]:=[ ,,,[50574414,"RPn"],,[101788531647683,"JB"],,,[161238829572,"RPn"],]; CONWAYPOLDATA[2389]:=[ ,,,[61017451,"RPn"],,[26753771464702,"JB"],,,[64381624464,"RPn"],]; CONWAYPOLDATA[2393]:=[ ,,,[44983617,"RPn"],,[87967008104233,"JB"],,,[18039939194,"RPn"],]; CONWAYPOLDATA[2399]:=[ ,,,[21192777,"RPn"],,[91621957129720,"JB"],,,[69209221193,"RPn"],]; CONWAYPOLDATA[2411]:=[ ,,,[27304581,"RPn"],,[62051777536539,"JB"],,,[23724493149,"RPn"],]; CONWAYPOLDATA[2417]:=[ ,,,[87466399,"RPn"],,[46748525380786,"JB"],,,[7432678636,"RPn"],]; CONWAYPOLDATA[2423]:=[ ,,,[61977922,"RPn"],,[63639877550293,"JB"],,,[76503700229,"RPn"],]; CONWAYPOLDATA[2437]:=[ ,,,[39513520,"RPn"],,[35227831988887,"JB"],,,[85878576203,"RPn"],]; CONWAYPOLDATA[2441]:=[ ,,,[5072404,"RPn"],,[53986410061315,"JB"],,,[4692431934,"RPn"],]; CONWAYPOLDATA[2447]:=[ ,,,[15465045,"RPn"],,[66974838899708,"JB"],,,[64958859717,"RPn"],]; CONWAYPOLDATA[2459]:=[ ,,,[46598052,"RPn"],,[68363009633730,"JB"],,,[109215435005,"RPn"],]; CONWAYPOLDATA[2467]:=[ ,,,[45752984,"RPn"],,[22636036035345,"JB"],,,[144524423820,"RPn"],]; CONWAYPOLDATA[2473]:=[ ,,,[70685764,"RPn"],,[69724683961608,"JB"],,,[66627588252,"RPn"],]; CONWAYPOLDATA[2477]:=[ ,,,[23249124,"RPn"],,[89872271847638,"JB"],,,[143553526859,"RPn"],]; CONWAYPOLDATA[2503]:=[ ,,,[18054142,"RPn"],,[20109544152450,"JB"],,,[116991468994,"RPn"],]; CONWAYPOLDATA[2521]:=[ ,,,[151199513,"RPn"],,[71574761155340,"JB"],,,[207863128112,"RPn"],]; CONWAYPOLDATA[2531]:=[ ,,,[54727815,"RPn"],,[120110695208635,"JB"],,,[8852220587,"RPn"],]; CONWAYPOLDATA[2539]:=[ ,,,[18146235,"RPn"],,[21814122679819,"JB"],,,[129357979981,"RPn"],]; CONWAYPOLDATA[2543]:=[ ,,,[25857229,"RPn"],,[110520960734397,"JB"],,,[6626666373,"RPn"],]; CONWAYPOLDATA[2549]:=[ ,,,[83683672,"RPn"],,[65264910911109,"JB"],,,[17633980,"RPn"],]; CONWAYPOLDATA[2551]:=[ ,,,[24642666,"RPn"],,[31352837654890,"JB"],,,[82590903037,"RPn"],]; CONWAYPOLDATA[2557]:=[ ,,,[45478804,"RPn"],,[42698433897007,"JB"],,,[108011369749,"RPn"],]; CONWAYPOLDATA[2579]:=[ ,,,[11690609,"RPn"],,[73557557634012,"JB"],,,[125839395886,"RPn"],]; CONWAYPOLDATA[2591]:=[ ,,,[39160381,"RPn"],,[73998628473784,"JB"],,,[19481407709,"RPn"],]; CONWAYPOLDATA[2593]:=[ ,,,[99903111,"RPn"],,[24277243264861,"JB"],,,[201582685258,"RPn"],]; CONWAYPOLDATA[2609]:=[ ,,,[6775576,"RPn"],,[65973457717710,"JB"],,,[69936585270,"RPn"],]; CONWAYPOLDATA[2617]:=[ ,,,[74369911,"RPn"],,[27151581285030,"JB"],,,[302981808921,"RPn"],]; CONWAYPOLDATA[2621]:=[ ,,,[66856470,"RPn"],,[90226651010532,"JB"],,,[30772739017,"RPn"],]; CONWAYPOLDATA[2633]:=[ ,,,[66061973,"RPn"],,[72378405223619,"JB"],,,[774383728,"RPn"],]; CONWAYPOLDATA[2647]:=[ ,,,[39416480,"RPn"],,[20412550804153,"JB"],,,[49257948881,"RPn"],]; CONWAYPOLDATA[2657]:=[ ,,,[19194171,"RPn"],,[82165359363966,"JB"],,,[22556564299,"RPn"],]; CONWAYPOLDATA[2659]:=[ ,,,[18315194,"RPn"],,[35745622750784,"JB"],,,[200769374444,"RPn"],]; CONWAYPOLDATA[2663]:=[ ,,,[27301081,"RPn"],,[84269674035151,"JB"],,,[78015833855,"RPn"],]; CONWAYPOLDATA[2671]:=[ ,,,[20214135,"RPn"],,[47118199924578,"JB"],,,[321712369116,"RPn"],]; CONWAYPOLDATA[2677]:=[ ,,,[49310342,"RPn"],,[13878198805605,"JB"],,,[225156904515,"RPn"],]; CONWAYPOLDATA[2683]:=[ ,,,[61306552,"RPn"],,[36812518918459,"JB"],,,[161685959007,"RPn"],]; CONWAYPOLDATA[2687]:=[ ,,,[18653159,"RPn"],,[79104155649038,"JB"],,,[74706972687,"RPn"],]; CONWAYPOLDATA[2689]:=[ ,,,[178052154,"RPn"],,[46545732596235,"JB"],]; CONWAYPOLDATA[2693]:=[ ,,,[6142735,"RPn"],,[104350926311405,"JB"],,,[71957369334,"RPn"],]; CONWAYPOLDATA[2699]:=[ ,,,[33240886,"RPn"],,[99490995299669,"JB"],,,[106560333685,"RPn"],]; CONWAYPOLDATA[2707]:=[ ,,,[18878620,"RPn"],,[51470587279714,"JB"],,,[394034360595,"RPn"],]; CONWAYPOLDATA[2711]:=[ ,,,[18608311,"RPn"],,[89362369648193,"JB"],,,[18248085290,"RPn"],]; CONWAYPOLDATA[2713]:=[ ,,,[51074943,"RPn"],,[38347499879863,"JB"],,,[74998304932,"RPn"],]; CONWAYPOLDATA[2719]:=[ ,,,[28922006,"RPn"],,[68509044053987,"JB"],,,[56131389467,"RPn"],]; CONWAYPOLDATA[2729]:=[ ,,,[7414696,"RPn"],,[107231364986996,"JB"],,,[10044253695,"RPn"],]; CONWAYPOLDATA[2731]:=[ ,,,[21992746,"RPn"],,[10440157895239,"JB"],,,[32585420808,"RPn"],]; CONWAYPOLDATA[2741]:=[ ,,,[97028661,"RPn"],,[94682434855317,"JB"],,,[115489740781,"RPn"],]; CONWAYPOLDATA[2749]:=[ ,,,[4659561,"RPn"],,[15946172671410,"JB"],,,[227888441075,"RPn"],]; CONWAYPOLDATA[2753]:=[ ,,,[73571175,"RPn"],,[207242820237056,"JB"],,,[89435326238,"RPn"],]; CONWAYPOLDATA[2767]:=[ ,,,[44983122,"RPn"],,[27766287742805,"JB"],,,[126925449911,"RPn"],]; CONWAYPOLDATA[2777]:=[ ,,,[5001380,"RPn"],,[266674269680263,"JB"],,,[61492280114,"RPn"],]; CONWAYPOLDATA[2789]:=[ ,,,[30093312,"RPn"],,[102229600175668,"JB"],,,[76560696759,"RPn"],]; CONWAYPOLDATA[2791]:=[ ,,,[27982572,"RPn"],,[40796955690995,"JB"],,,[84038863218,"RPn"],]; CONWAYPOLDATA[2797]:=[ ,,,[76408448,"RPn"],,[61136821482847,"JB"],]; CONWAYPOLDATA[2801]:=[ ,,,[59440024,"RPn"],,[74757886676004,"JB"],,,[58803930703,"RPn"],]; CONWAYPOLDATA[2803]:=[ ,,,[132626750,"RPn"],,[30716818043764,"JB"],,,[15156289099,"RPn"],]; CONWAYPOLDATA[2819]:=[ ,,,[31313454,"RPn"],,[187088381102215,"JB"],,,[30951782755,"RPn"],]; CONWAYPOLDATA[2833]:=[ ,,,[182895652,"RPn"],,[15582743434868,"JB"],]; CONWAYPOLDATA[2837]:=[ ,,,[152622091,"RPn"],,[249846186017316,"JB"],,,[156406658346,"RPn"],]; CONWAYPOLDATA[2843]:=[ ,,,[71956332,"RPn"],,[102516633619656,"JB"],,,[13496662031,"RPn"],]; CONWAYPOLDATA[2851]:=[ ,,,[72649184,"RPn"],,[11796941660859,"JB"],,,[226177194131,"RPn"],]; CONWAYPOLDATA[2857]:=[ ,,,[179133911,"RPn"],,[66572039505883,"JB"],,,[41184794932,"RPn"],]; CONWAYPOLDATA[2861]:=[ ,,,[13787161,"RPn"],,[124635436669087,"JB"],,,[181212877,"RPn"],]; CONWAYPOLDATA[2879]:=[ ,,,[21123230,"RPn"],,[134453614285151,"JB"],,,[17854668382,"RPn"],]; CONWAYPOLDATA[2887]:=[ ,,,[79796685,"RPn"],,[28199523784015,"JB"],,,[225850890530,"RPn"],]; CONWAYPOLDATA[2897]:=[ ,,,[12911932,"RPn"],,[254728073433595,"JB"],,,[47966692196,"RPn"],]; CONWAYPOLDATA[2903]:=[ ,,,[40360414,"RPn"],,[220996639394209,"JB"],,,[29173727525,"RPn"],]; CONWAYPOLDATA[2909]:=[ ,,,[16566757,"RPn"],,[88445961527874,"JB"],,,[5769617510,"RPn"],]; CONWAYPOLDATA[2917]:=[ ,,,[30952292,"RPn"],,[126548076462131,"JB"],,,[23546764913,"RPn"],]; CONWAYPOLDATA[2927]:=[ ,,,[92832737,"RPn"],,[128351683750684,"JB"],,,[129054775556,"RPn"],]; CONWAYPOLDATA[2939]:=[ ,,,[117809817,"RPn"],,[145919381522460,"JB"],,,[42144954342,"RPn"],]; CONWAYPOLDATA[2953]:=[ ,,,[128310816,"RPn"],,[94119915904106,"JB"],,,[275128000880,"RPn"],]; CONWAYPOLDATA[2957]:=[ ,,,[59861510,"RPn"],,[137522459211305,"JB"],,,[126623447542,"RPn"],]; CONWAYPOLDATA[2963]:=[ ,,,[74975754,"RPn"],,[116296261925105,"JB"],,,[252748907468,"RPn"],]; CONWAYPOLDATA[2969]:=[ ,,,[43282085,"RPn"],,[121935170032103,"JB"],,,[15231890387,"RPn"],]; CONWAYPOLDATA[2971]:=[ ,,,[49871216,"RPn"],,[75877505137149,"JB"],,,[416411349140,"RPn"],]; CONWAYPOLDATA[2999]:=[ ,,,[116262250,"RPn"],,[596131955429237,"JB"],,,[206530765439,"RPn"],]; CONWAYPOLDATA[3001]:=[ ,,,[144018004,"RPn"],,[200287641020254,"JB"],,,[16473896455,"RPn"],]; CONWAYPOLDATA[3011]:=[ ,,,[70192434,"RPn"],,[153526347135686,"JB"],,,[46867834916,"RPn"],]; CONWAYPOLDATA[3019]:=[ ,,,[81742446,"RPn"],,[57766437106156,"JB"],]; CONWAYPOLDATA[3023]:=[ ,,,[36542029,"RPn"],,[122393810687045,"JB"],,,[8873829069,"RPn"],]; CONWAYPOLDATA[3037]:=[ ,,,[88722920,"RPn"],,[26008690429649,"JB"],,,[135962511528,"RPn"],]; CONWAYPOLDATA[3041]:=[ ,,,[80242870,"RPn"],,[424829766961621,"JB"],,,[11835711883,"RPn"],]; CONWAYPOLDATA[3049]:=[ ,,,[259558332,"RPn"],,[68211367596603,"JB"],,,[100071729025,"RPn"],]; CONWAYPOLDATA[3061]:=[ ,,,[101055860,"RPn"],,[128440816711922,"JB"],,,[14431528339,"RPn"],]; CONWAYPOLDATA[3067]:=[ ,,,[82968486,"RPn"],,[78175568697835,"JB"],,,[360260057644,"RPn"],]; CONWAYPOLDATA[3079]:=[ ,,,[36984954,"RPn"],,[55675842243326,"JB"],,,[73160602397,"RPn"],]; CONWAYPOLDATA[3083]:=[ ,,,[109452668,"RPn"],,[517976249604348,"JB"],,,[175840831873,"RPn"],]; CONWAYPOLDATA[3089]:=[ ,,,[18836725,"RPn"],,[541594514867925,"JB"],,,[54221226264,"RPn"],]; CONWAYPOLDATA[3109]:=[ ,,,[67648737,"RPn"],,[61357021957486,"JB"],,,[556916827091,"RPn"],]; CONWAYPOLDATA[3119]:=[ ,,,[35584678,"RPn"],,[138928818242821,"JB"],,,[34725576752,"RPn"],]; CONWAYPOLDATA[3121]:=[ ,,,[5552266,"RPn"],,[86676602777374,"JB"],,,[353623843853,"RPn"],]; CONWAYPOLDATA[3137]:=[ ,,,[18354590,"RPn"],,[192534822380433,"JB"],,,[253883916135,"RPn"],]; CONWAYPOLDATA[3163]:=[ ,,,[55320873,"RPn"],,[97995157273266,"JB"],]; CONWAYPOLDATA[3167]:=[ ,,,[45661811,"RPn"],,[190209998692429,"JB"],,,[53578441404,"RPn"],]; CONWAYPOLDATA[3169]:=[ ,,,[7272862,"RPn"],,[100160233978757,"JB"],,,[302198825191,"RPn"],]; CONWAYPOLDATA[3181]:=[ ,,,[46471236,"RPn"],,[25808307661544,"JB"],,,[155441645367,"RPn"],]; CONWAYPOLDATA[3187]:=[ ,,,[86976419,"RPn"],,[37134417410417,"JB"],,,[181636101403,"RPn"],]; CONWAYPOLDATA[3191]:=[ ,,,[57249742,"RPn"],,[296448255351237,"JB"],,,[253935922070,"RPn"],]; CONWAYPOLDATA[3203]:=[ ,,,[173381595,"RPn"],,[113418953247011,"JB"],,,[48154164644,"RPn"],]; CONWAYPOLDATA[3209]:=[ ,,,[27889422,"RPn"],,[196754601509292,"JB"],]; CONWAYPOLDATA[3217]:=[ ,,,[163561936,"RPn"],,[87585566781548,"JB"],,,[230851823485,"RPn"],]; CONWAYPOLDATA[3221]:=[ ,,,[88606499,"RPn"],,[198296625870899,"JB"],,,[179810546998,"RPn"],]; CONWAYPOLDATA[3229]:=[ ,,,[9690235,"RPn"],,[284316199173835,"JB"],,,[629696373171,"RPn"],]; CONWAYPOLDATA[3251]:=[ ,,,[84519504,"RPn"],,[314983851911753,"JB"],,,[403031040900,"RPn"],]; CONWAYPOLDATA[3253]:=[ ,,,[40952019,"RPn"],,[100627025766777,"JB"],,,[133518591266,"RPn"],]; CONWAYPOLDATA[3257]:=[ ,,,[7497617,"RPn"],,[300254001849391,"JB"],,,[52707568503,"RPn"],]; CONWAYPOLDATA[3259]:=[ ,,,[51896319,"RPn"],,[62003339120594,"JB"],,,[135882942563,"RPn"],]; CONWAYPOLDATA[3271]:=[ ,,,[41397779,"RPn"],,[106101790872585,"JB"],,,[417144882850,"RPn"],]; CONWAYPOLDATA[3299]:=[ ,,,[6119647,"RPn"],,[153115767022943,"JB"],,,[37000610793,"RPn"],]; CONWAYPOLDATA[3301]:=[ ,,,[27583162,"RPn"],,[103708566414314,"JB"],,,[359520901918,"RPn"],]; CONWAYPOLDATA[3307]:=[ ,,,[30321885,"RPn"],,[58794798942661,"JB"],,,[100314316429,"RPn"],]; CONWAYPOLDATA[3313]:=[ ,,,[76142689,"RPn"],,[113947348848562,"JB"],,,[312354768514,"RPn"],]; CONWAYPOLDATA[3319]:=[ ,,,[88092904,"RPn"],,[68854135161160,"JB"],,,[244327039939,"RPn"],]; CONWAYPOLDATA[3323]:=[ ,,,[87205491,"RPn"],,[189309117793641,"JB"],,,[19890517651,"RPn"],]; CONWAYPOLDATA[3329]:=[ ,,,[88384953,"RPn"],,[193478630582401,"JB"],,,[112942390435,"RPn"],]; CONWAYPOLDATA[3331]:=[ ,,,[84004492,"RPn"],,[96656994941773,"JB"],]; CONWAYPOLDATA[3343]:=[ ,,,[44428475,"RPn"],,[115111636459548,"JB"],,,[623951370044,"RPn"],]; CONWAYPOLDATA[3347]:=[ ,,,[87942427,"RPn"],,[189211369388765,"JB"],,,[156154766966,"RPn"],]; CONWAYPOLDATA[3359]:=[ ,,,[44177579,"RPn"],,[241935415936098,"JB"],,,[264977533190,"RPn"],]; CONWAYPOLDATA[3361]:=[ ,,,[141972023,"RPn"],,[17769679190941,"JB"],,,[209094185795,"RPn"],]; CONWAYPOLDATA[3371]:=[ ,,,[41813886,"RPn"],,[493061845650154,"JB"],]; CONWAYPOLDATA[3373]:=[ ,,,[238855627,"RPn"],,[85601467447833,"JB"],]; CONWAYPOLDATA[3389]:=[ ,,,[57413052,"RPn"],,[526917959613049,"JB"],]; CONWAYPOLDATA[3391]:=[ ,,,[76484008,"RPn"],,[123080848661705,"JB"],]; CONWAYPOLDATA[3407]:=[ ,,,[67550594,"RPn"],,[212246901631497,"JB"],]; CONWAYPOLDATA[3413]:=[ ,,,[66369200,"RPn"],,[363573265522434,"JB"],]; CONWAYPOLDATA[3433]:=[ ,,,[77338629,"RPn"],,[71915580901866,"JB"],]; CONWAYPOLDATA[3449]:=[ ,,,[93040227,"RPn"],,[163104944360694,"JB"],]; CONWAYPOLDATA[3457]:=[ ,,,[103820631,"RPn"],,[141364368853396,"JB"],]; CONWAYPOLDATA[3461]:=[ ,,,[46875786,"RPn"],,[283629268657733,"JB"],]; CONWAYPOLDATA[3463]:=[ ,,,[59947996,"RPn"],,[20415613814386,"JB"],]; CONWAYPOLDATA[3467]:=[ ,,,[188930700,"RPn"],,[288469376299359,"JB"],]; CONWAYPOLDATA[3469]:=[ ,,,[152674161,"RPn"],,[144690775298431,"JB"],]; CONWAYPOLDATA[3491]:=[ ,,,[31286344,"RPn"],,[420868998869641,"JB"],]; CONWAYPOLDATA[3499]:=[ ,,,[84476359,"RPn"],,[103024736478422,"JB"],]; CONWAYPOLDATA[3511]:=[ ,,,[70258628,"RPn"],,[114688211819758,"JB"],]; CONWAYPOLDATA[3517]:=[ ,,,[47289584,"RPn"],,[149062539027475,"JB"],]; CONWAYPOLDATA[3527]:=[ ,,,[33072684,"RPn"],,[416809667686257,"JB"],]; CONWAYPOLDATA[3529]:=[ ,,,[268436931,"RPn"],,[14895094700912,"JB"],]; CONWAYPOLDATA[3533]:=[ ,,,[49264154,"RPn"],,[363088106910501,"JB"],]; CONWAYPOLDATA[3539]:=[ ,,,[60998206,"RPn"],,[276314229909528,"JB"],]; CONWAYPOLDATA[3541]:=[ ,,,[62679248,"RPn"],,[128178013897794,"JB"],]; CONWAYPOLDATA[3547]:=[ ,,,[113206054,"RPn"],,[94926402701302,"JB"],]; CONWAYPOLDATA[3557]:=[ ,,,[162949729,"RPn"],,[285212053806179,"JB"],]; CONWAYPOLDATA[3559]:=[ ,,,[32294369,"RPn"],,[86017882221099,"JB"],]; CONWAYPOLDATA[3571]:=[ ,,,[111490193,"RPn"],,[159591874712352,"JB"],]; CONWAYPOLDATA[3581]:=[ ,,,[84550993,"RPn"],,[343420892659607,"JB"],]; CONWAYPOLDATA[3583]:=[ ,,,[166853147,"RPn"],,[113347251656861,"JB"],]; CONWAYPOLDATA[3593]:=[ ,,,[37298936,"RPn"],,[275959934220861,"JB"],]; CONWAYPOLDATA[3607]:=[ ,,,[231746148,"RPn"],,[381428816087744,"JB"],]; CONWAYPOLDATA[3613]:=[ ,,,[129388758,"RPn"],,[104597140080003,"JB"],]; CONWAYPOLDATA[3617]:=[ ,,,[9816541,"RPn"],,[173175387202071,"JB"],]; CONWAYPOLDATA[3623]:=[ ,,,[33009158,"RPn"],,[638607242297971,"JB"],]; CONWAYPOLDATA[3631]:=[ ,,,[77652581,"RPn"],,[170259276043972,"JB"],]; CONWAYPOLDATA[3637]:=[ ,,,[165796284,"RPn"],,[83962349727580,"JB"],]; CONWAYPOLDATA[3643]:=[ ,,,[34204129,"RPn"],,[102427553347643,"JB"],]; CONWAYPOLDATA[3659]:=[ ,,,[61870033,"RPn"],,[505385229152324,"JB"],]; CONWAYPOLDATA[3671]:=[ ,,,[91907169,"RPn"],,[755089975196051,"JB"],]; CONWAYPOLDATA[3673]:=[ ,,,[144550920,"RPn"],,[149662659861380,"JB"],]; CONWAYPOLDATA[3677]:=[ ,,,[88909862,"RPn"],,[522704962640608,"JB"],]; CONWAYPOLDATA[3691]:=[ ,,,[162614389,"RPn"],,[181614838026680,"JB"],]; CONWAYPOLDATA[3697]:=[ ,,,[212496171,"RPn"],,[179492840692617,"JB"],]; CONWAYPOLDATA[3701]:=[ ,,,[21365875,"RPn"],,[479755643391034,"JB"],]; CONWAYPOLDATA[3709]:=[ ,,,[51714589,"RPn"],,[9262932871878,"JB"],]; CONWAYPOLDATA[3719]:=[ ,,,[109468772,"RPn"],,[737586623574483,"JB"],]; CONWAYPOLDATA[3727]:=[ ,,,[51816484,"RPn"],,[61828004614344,"JB"],]; CONWAYPOLDATA[3733]:=[ ,,,[96318868,"RPn"],,[194035981267303,"JB"],]; CONWAYPOLDATA[3739]:=[ ,,,[24561498,"RPn"],,[153424013031283,"JB"],]; CONWAYPOLDATA[3761]:=[ ,,,[69078290,"RPn"],,[614756432250425,"JB"],]; CONWAYPOLDATA[3767]:=[ ,,,[78839548,"RPn"],,[357459534754800,"JB"],]; CONWAYPOLDATA[3769]:=[ ,,,[69963954,"RPn"],,[116999815077660,"JB"],]; CONWAYPOLDATA[3779]:=[ ,,,[53450178,"RPn"],,[214296229921139,"JB"],]; CONWAYPOLDATA[3793]:=[ ,,,[157413298,"RPn"],,[199769106177200,"JB"],]; CONWAYPOLDATA[3797]:=[ ,,,[55933609,"RPn"],,[302106860951541,"JB"],]; CONWAYPOLDATA[3803]:=[ ,,,[111986943,"RPn"],,[346329443603171,"JB"],]; CONWAYPOLDATA[3821]:=[ ,,,[214488017,"RPn"],,[567105028075426,"JB"],]; CONWAYPOLDATA[3823]:=[ ,,,[271929993,"RPn"],,[136343610545523,"JB"],]; CONWAYPOLDATA[3833]:=[ ,,,[25462622,"RPn"],,[415030181323521,"JB"],]; CONWAYPOLDATA[3847]:=[ ,,,[259310887,"RPn"],,[203637259731732,"JB"],]; CONWAYPOLDATA[3851]:=[ ,,,[111933168,"RPn"],,[311069830203069,"JB"],]; CONWAYPOLDATA[3853]:=[ ,,,[147920525,"RPn"],,[193289387899765,"JB"],]; CONWAYPOLDATA[3863]:=[ ,,,[117373397,"RPn"],,[393082504708238,"JB"],]; CONWAYPOLDATA[3877]:=[ ,,,[98200535,"RPn"],,[156777074677789,"JB"],]; CONWAYPOLDATA[3881]:=[ ,,,[148945031,"RPn"],,[587570943973204,"JB"],]; CONWAYPOLDATA[3889]:=[ ,,,[190004884,"RPn"],,[153122831990851,"JB"],]; CONWAYPOLDATA[3907]:=[ ,,,[130153893,"RPn"],,[1134621551706770,"JB"],]; CONWAYPOLDATA[3911]:=[ ,,,[59122600,"RPn"],,[747996037191019,"JB"],]; CONWAYPOLDATA[3917]:=[ ,,,[105140116,"RPn"],,[509001856961625,"JB"],]; CONWAYPOLDATA[3919]:=[ ,,,[121065751,"RPn"],,[83872331517908,"JB"],]; CONWAYPOLDATA[3923]:=[ ,,,[183086412,"RPn"],,[500526703054944,"JB"],]; CONWAYPOLDATA[3929]:=[ ,,,[121095712,"RPn"],,[373919417348275,"JB"],]; CONWAYPOLDATA[3931]:=[ ,,,[134892267,"RPn"],,[238605325368541,"JB"],]; CONWAYPOLDATA[3943]:=[ ,,,[59488044,"RPn"],,[169373675368520,"JB"],]; CONWAYPOLDATA[3947]:=[ ,,,[140181654,"RPn"],,[426967289867013,"JB"],]; CONWAYPOLDATA[3967]:=[ ,,,[41225070,"RPn"],,[263517873093442,"JB"],]; CONWAYPOLDATA[3989]:=[ ,,,[61091537,"RPn"],,[654370673327741,"JB"],]; CONWAYPOLDATA[4001]:=[ ,,,[123550883,"RPn"],,[808787833173691,"JB"],]; CONWAYPOLDATA[4003]:=[ ,,,[144188062,"RPn"],,[145977040025474,"JB"],]; CONWAYPOLDATA[4007]:=[ ,,,[139559808,"RPn"],,[508456829278453,"JB"],]; CONWAYPOLDATA[4013]:=[ ,,,[156787912,"RPn"],,[496612232268713,"JB"],]; CONWAYPOLDATA[4019]:=[ ,,,[127012459,"RPn"],,[482179375436936,"JB"],]; CONWAYPOLDATA[4021]:=[ ,,,[58014990,"RPn"],,[97825581804616,"JB"],]; CONWAYPOLDATA[4027]:=[ ,,,[47595116,"RPn"],,[260369786120965,"JB"],]; CONWAYPOLDATA[4049]:=[ ,,,[16345816,"RPn"],,[580952555322980,"JB"],]; CONWAYPOLDATA[4051]:=[ ,,,[91641732,"RPn"],,[46652605230760,"JB"],]; CONWAYPOLDATA[4057]:=[ ,,,[110577597,"RPn"],,[701793169483459,"JB"],]; CONWAYPOLDATA[4073]:=[ ,,,[12695544,"RPn"],,[1052443234756807,"JB"],]; CONWAYPOLDATA[4079]:=[ ,,,[149103777,"RPn"],,[411084049627808,"JB"],]; CONWAYPOLDATA[4091]:=[ ,,,[150597894,"RPn"],,[835529440649671,"JB"],]; CONWAYPOLDATA[4093]:=[ ,,,[113228754,"RPn"],,[192497410205293,"JB"],]; CONWAYPOLDATA[4099]:=[ ,,,[148605148,"RPn"],,[211994297279958,"JB"],]; CONWAYPOLDATA[4111]:=[ ,,,[99243663,"RPn"],,[272367149294748,"JB"],]; CONWAYPOLDATA[4127]:=[ ,,,[96014660,"RPn"],,[531635738628791,"JB"],]; CONWAYPOLDATA[4129]:=[ ,,,[832158673,"RPn"],,[255033007793009,"JB"],]; CONWAYPOLDATA[4133]:=[ ,,,[62180987,"RPn"],,[545365175062751,"JB"],]; CONWAYPOLDATA[4139]:=[ ,,,[150986583,"RPn"],,[800577479737374,"JB"],]; CONWAYPOLDATA[4153]:=[ ,,,[286216459,"RPn"],,[81465106407623,"JB"],]; CONWAYPOLDATA[4157]:=[ ,,,[67630235,"RPn"],,[471989499093308,"JB"],]; CONWAYPOLDATA[4159]:=[ ,,,[86469772,"RPn"],,[212514465734443,"JB"],]; CONWAYPOLDATA[4177]:=[ ,,,[186582418,"RPn"],,[192513908990070,"JB"],]; CONWAYPOLDATA[4201]:=[ ,,,[224148567,"RPn"],,[299547792302615,"JB"],]; CONWAYPOLDATA[4211]:=[ ,,,[87993062,"RPn"],,[1257574192618082,"JB"],]; CONWAYPOLDATA[4217]:=[ ,,,[17057768,"RPn"],,[503652747009952,"JB"],]; CONWAYPOLDATA[4219]:=[ ,,,[160170118,"RPn"],,[293580748200216,"JB"],]; CONWAYPOLDATA[4229]:=[ ,,,[135670551,"RPn"],,[352150141962672,"JB"],]; CONWAYPOLDATA[4231]:=[ ,,,[67772161,"RPn"],,[270032511205787,"JB"],]; CONWAYPOLDATA[4241]:=[ ,,,[17935192,"RPn"],,[548220015826441,"JB"],]; CONWAYPOLDATA[4243]:=[ ,,,[155658700,"RPn"],,[323880306382933,"JB"],]; CONWAYPOLDATA[4253]:=[ ,,,[118071788,"RPn"],,[1830606732817303,"JB"],]; CONWAYPOLDATA[4259]:=[ ,,,[14574300,"RPn"],,[1309103441934785,"JB"],]; CONWAYPOLDATA[4261]:=[ ,,,[163375264,"RPn"],,[186940792623279,"JB"],]; CONWAYPOLDATA[4271]:=[ ,,,[85744603,"RPn"],,[847989988452654,"JB"],]; CONWAYPOLDATA[4273]:=[ ,,,[193464353,"RPn"],,[136893910731861,"JB"],]; CONWAYPOLDATA[4283]:=[ ,,,[216368596,"RPn"],,[1148493622290387,"JB"],]; CONWAYPOLDATA[4289]:=[ ,,,[18344056,"RPn"],,[625745851474105,"JB"],]; CONWAYPOLDATA[4297]:=[ ,,,[126460715,"RPn"],,[303296860570049,"JB"],]; CONWAYPOLDATA[4327]:=[ ,,,[66505993,"RPn"],,[288964654715787,"JB"],]; CONWAYPOLDATA[4337]:=[ ,,,[36916547,"RPn"],,[660043632915205,"JB"],]; CONWAYPOLDATA[4339]:=[ ,,,[161562675,"RPn"],,[296170258465546,"JB"],]; CONWAYPOLDATA[4349]:=[ ,,,[124059576,"RPn"],,[1050144447104985,"JB"],]; CONWAYPOLDATA[4357]:=[ ,,,[130426797,"RPn"],,[263630417652273,"JB"],]; CONWAYPOLDATA[4363]:=[ ,,,[170366426,"RPn"],,[362111018580493,"JB"],]; CONWAYPOLDATA[4373]:=[ ,,,[30352995,"RPn"],,[1796690557252501,"JB"],]; CONWAYPOLDATA[4391]:=[ ,,,[89378819,"RPn"],,[640612298204281,"JB"],]; CONWAYPOLDATA[4397]:=[ ,,,[126453325,"RPn"],,[722483518333511,"JB"],]; CONWAYPOLDATA[4409]:=[ ,,,[19386376,"RPn"],,[1012598903046388,"JB"],]; CONWAYPOLDATA[4421]:=[ ,,,[75568156,"RPn"],,[1119370734877173,"JB"],]; CONWAYPOLDATA[4423]:=[ ,,,[19509856,"RPn"],,[296693567914242,"JB"],]; CONWAYPOLDATA[4441]:=[ ,,,[176174491,"RPn"],,[444132870949721,"JB"],]; CONWAYPOLDATA[4447]:=[ ,,,[130835190,"RPn"],,[218951471987166,"JB"],]; CONWAYPOLDATA[4451]:=[ ,,,[331074284,"RPn"],,[517686094232574,"JB"],]; CONWAYPOLDATA[4457]:=[ ,,,[19022479,"RPn"],,[609211845089473,"JB"],]; CONWAYPOLDATA[4463]:=[ ,,,[131122945,"RPn"],,[900665484324022,"JB"],]; CONWAYPOLDATA[4481]:=[ ,,,[37519416,"RPn"],,[763067601867919,"JB"],]; CONWAYPOLDATA[4483]:=[ ,,,[59771841,"RPn"],,[62640910157717,"JB"],]; CONWAYPOLDATA[4493]:=[ ,,,[38752127,"RPn"],,[505967624837573,"JB"],]; CONWAYPOLDATA[4507]:=[ ,,,[33414900,"RPn"],,[412344961564957,"JB"],]; CONWAYPOLDATA[4513]:=[ ,,,[173669273,"RPn"],,[355447972171783,"JB"],]; CONWAYPOLDATA[4517]:=[ ,,,[19350830,"RPn"],,[1154212574294741,"JB"],]; CONWAYPOLDATA[4519]:=[ ,,,[102088732,"RPn"],,[1163152233025710,"JB"],]; CONWAYPOLDATA[4523]:=[ ,,,[96068525,"RPn"],,[1138644101356605,"JB"],]; CONWAYPOLDATA[4547]:=[ ,,,[101561794,"RPn"],,[1082229493491854,"JB"],]; CONWAYPOLDATA[4549]:=[ ,,,[59846650,"RPn"],,[83492699894010,"JB"],]; CONWAYPOLDATA[4561]:=[ ,,,[269614404,"RPn"],,[263559558863831,"JB"],]; CONWAYPOLDATA[4567]:=[ ,,,[116979141,"RPn"],,[1697866029669461,"JB"],]; CONWAYPOLDATA[4583]:=[ ,,,[251991677,"RPn"],,[849596199235623,"JB"],]; CONWAYPOLDATA[4591]:=[ ,,,[55753115,"RPn"],,[271569282960453,"JB"],]; CONWAYPOLDATA[4597]:=[ ,,,[82608095,"RPn"],,[233328096323209,"JB"],]; CONWAYPOLDATA[4603]:=[ ,,,[188617133,"RPn"],,[448621835199613,"JB"],]; CONWAYPOLDATA[4621]:=[ ,,,[146665921,"RPn"],,[86781906777255,"JB"],]; CONWAYPOLDATA[4637]:=[ ,,,[97112693,"RPn"],,[542979529589183,"JB"],]; CONWAYPOLDATA[4639]:=[ ,,,[82634510,"RPn"],,[160370363575369,"JB"],]; CONWAYPOLDATA[4643]:=[ ,,,[33378532,"RPn"],,[867345762322935,"JB"],]; CONWAYPOLDATA[4649]:=[ ,,,[105109244,"RPn"],,[982456440726920,"JB"],]; CONWAYPOLDATA[4651]:=[ ,,,[145222827,"RPn"],,[422090975201117,"JB"],]; CONWAYPOLDATA[4657]:=[ ,,,[17193659,"RPn"],,[438996979412060,"JB"],]; CONWAYPOLDATA[4663]:=[ ,,,[126693713,"RPn"],,[432281435253408,"JB"],]; CONWAYPOLDATA[4673]:=[ ,,,[11495583,"RPn"],,[1923803619697134,"JB"],]; CONWAYPOLDATA[4679]:=[ ,,,[86332240,"RPn"],,[843223216725809,"JB"],]; CONWAYPOLDATA[4691]:=[ ,,,[21151721,"RPn"],,[799287744153501,"JB"],]; CONWAYPOLDATA[4703]:=[ ,,,[102638277,"RPn"],,[1876358488537330,"JB"],]; CONWAYPOLDATA[4721]:=[ ,,,[21074550,"RPn"],,[587031446035740,"JB"],]; CONWAYPOLDATA[4723]:=[ ,,,[176966089,"RPn"],,[1276858534476669,"JB"],]; CONWAYPOLDATA[4729]:=[ ,,,[513446463,"RPn"],,[481394973695362,"JB"],]; CONWAYPOLDATA[4733]:=[ ,,,[16385651,"RPn"],,[2943178032788062,"JB"],]; CONWAYPOLDATA[4751]:=[ ,,,[220085343,"RPn"],,[585034934999174,"JB"],]; CONWAYPOLDATA[4759]:=[ ,,,[170495937,"RPn"],,[209028236406057,"JB"],]; CONWAYPOLDATA[4783]:=[ ,,,[89992151,"RPn"],,[256338008294369,"JB"],]; CONWAYPOLDATA[4787]:=[ ,,,[175319090,"RPn"],,[1460814715387230,"JB"],]; CONWAYPOLDATA[4789]:=[ ,,,[361660493,"RPn"],,[113821281126144,"JB"],]; CONWAYPOLDATA[4793]:=[ ,,,[104271718,"RPn"],,[1055855295185965,"JB"],]; CONWAYPOLDATA[4799]:=[ ,,,[67363570,"RPn"],,[757316710458430,"JB"],]; CONWAYPOLDATA[4801]:=[ ,,,[728931036,"RPn"],,[497473401571971,"JB"],]; CONWAYPOLDATA[4813]:=[ ,,,[298714034,"RPn"],,[298957458345361,"JB"],]; CONWAYPOLDATA[4817]:=[ ,,,[180459274,"RPn"],,[914448989466988,"JB"],]; CONWAYPOLDATA[4831]:=[ ,,,[60083150,"RPn"],,[313432261470428,"JB"],]; CONWAYPOLDATA[4861]:=[ ,,,[229677400,"RPn"],,[231394275407385,"JB"],]; CONWAYPOLDATA[4871]:=[ ,,,[252897460,"RPn"],,[1641939793294433,"JB"],]; CONWAYPOLDATA[4877]:=[ ,,,[165091329,"RPn"],,[1323320062056694,"JB"],]; CONWAYPOLDATA[4889]:=[ ,,,[23843656,"RPn"],,[1708306515109704,"JB"],]; CONWAYPOLDATA[4903]:=[ ,,,[62684858,"RPn"],,[211835184295273,"JB"],]; CONWAYPOLDATA[4909]:=[ ,,,[187661258,"RPn"],,[564249261429559,"JB"],]; CONWAYPOLDATA[4919]:=[ ,,,[240819496,"RPn"],,[1604645382824754,"JB"],]; CONWAYPOLDATA[4931]:=[ ,,,[185548605,"RPn"],,[795488318346904,"JB"],]; CONWAYPOLDATA[4933]:=[ ,,,[168205436,"RPn"],,[397802803314235,"JB"],]; CONWAYPOLDATA[4937]:=[ ,,,[145384779,"RPn"],,[3935132880065116,"JB"],]; CONWAYPOLDATA[4943]:=[ ,,,[118869271,"RPn"],,[1154867685177153,"JB"],]; CONWAYPOLDATA[4951]:=[ ,,,[114625558,"RPn"],,[497921546233716,"JB"],]; CONWAYPOLDATA[4957]:=[ ,,,[164884693,"RPn"],,[603409937531407,"JB"],]; CONWAYPOLDATA[4967]:=[ ,,,[311868001,"RPn"],,[1883184096568479,"JB"],]; CONWAYPOLDATA[4969]:=[ ,,,[365783008,"RPn"],,[555541366500509,"JB"],]; CONWAYPOLDATA[4973]:=[ ,,,[161473312,"RPn"],,[2151383932086490,"JB"],]; CONWAYPOLDATA[4987]:=[ ,,,[73747758,"RPn"],,[593706213124695,"JB"],]; CONWAYPOLDATA[4993]:=[ ,,,[171035220,"RPn"],,[1572473890208970,"JB"],]; CONWAYPOLDATA[4999]:=[ ,,,[98960207,"RPn"],,[624134385227588,"JB"],]; CONWAYPOLDATA[5003]:=[ ,,,[297808580,"RPn"],,[964276591208313,"JB"],]; CONWAYPOLDATA[5009]:=[ ,,,[25029976,"RPn"],,[1784194488275483,"JB"],]; CONWAYPOLDATA[5011]:=[ ,,,[272357874,"RPn"],,[394795936156775,"JB"],]; CONWAYPOLDATA[5021]:=[ ,,,[92547075,"RPn"],,[1089094406879912,"JB"],]; CONWAYPOLDATA[5023]:=[ ,,,[63852379,"RPn"],,[613651197189594,"JB"],]; CONWAYPOLDATA[5039]:=[ ,,,[191663415,"RPn"],,[694589558318906,"JB"],]; CONWAYPOLDATA[5051]:=[ ,,,[223082468,"RPn"],,[1751846310484033,"JB"],]; CONWAYPOLDATA[5059]:=[ ,,,[45753598,"RPn"],,[654637402286341,"JB"],]; CONWAYPOLDATA[5077]:=[ ,,,[172079840,"RPn"],,[664005484386727,"JB"],]; CONWAYPOLDATA[5081]:=[ ,,,[18200145,"RPn"],,[2440810864725678,"JB"],]; CONWAYPOLDATA[5087]:=[ ,,,[69936081,"RPn"],,[1120207881068333,"JB"],]; CONWAYPOLDATA[5099]:=[ ,,,[233962518,"RPn"],,[776613560874379,"JB"],]; CONWAYPOLDATA[5101]:=[ ,,,[182121009,"RPn"],,[635751822665336,"JB"],]; CONWAYPOLDATA[5107]:=[ ,,,[361509211,"RPn"],,[505660757479992,"JB"],]; CONWAYPOLDATA[5113]:=[ ,,,[619184319,"RPn"],,[2030388827879892,"JB"],]; CONWAYPOLDATA[5119]:=[ ,,,[101796437,"RPn"],,[672900630244242,"JB"],]; CONWAYPOLDATA[5147]:=[ ,,,[204510900,"RPn"],,[1829829083719057,"JB"],]; CONWAYPOLDATA[5153]:=[ ,,,[415244204,"RPn"],,[1851129638702130,"JB"],]; CONWAYPOLDATA[5167]:=[ ,,,[94333925,"RPn"],,[681577760596485,"JB"],]; CONWAYPOLDATA[5171]:=[ ,,,[130629804,"RPn"],,[1066482019456222,"JB"],]; CONWAYPOLDATA[5179]:=[ ,,,[48128449,"RPn"],,[1360743394863242,"JB"],]; CONWAYPOLDATA[5189]:=[ ,,,[18270471,"RPn"],,[1610275721257444,"JB"],]; CONWAYPOLDATA[5197]:=[ ,,,[286572981,"RPn"],,[447508567112480,"JB"],]; CONWAYPOLDATA[5209]:=[ ,,,[642551003,"RPn"],,[607227123124241,"JB"],]; CONWAYPOLDATA[5227]:=[ ,,,[210449476,"RPn"],,[262722327173633,"JB"],]; CONWAYPOLDATA[5231]:=[ ,,,[70132024,"RPn"],,[2364925167115657,"JB"],]; CONWAYPOLDATA[5233]:=[ ,,,[354342139,"RPn"],,[596395090822345,"JB"],]; CONWAYPOLDATA[5237]:=[ ,,,[218042498,"RPn"],,[3854562027760504,"JB"],]; CONWAYPOLDATA[5261]:=[ ,,,[352686920,"RPn"],,[1025352379139491,"JB"],]; CONWAYPOLDATA[5273]:=[ ,,,[19699931,"RPn"],,[1394454725843887,"JB"],]; CONWAYPOLDATA[5279]:=[ ,,,[295861562,"RPn"],,[1283091641229693,"JB"],]; CONWAYPOLDATA[5281]:=[ ,,,[749030642,"RPn"],,[718284298544568,"JB"],]; CONWAYPOLDATA[5297]:=[ ,,,[239191335,"RPn"],,[1830625380293442,"JB"],]; CONWAYPOLDATA[5303]:=[ ,,,[221585860,"RPn"],,[2640601234102508,"JB"],]; CONWAYPOLDATA[5309]:=[ ,,,[187174106,"RPn"],,[2895954485659969,"JB"],]; CONWAYPOLDATA[5323]:=[ ,,,[80856375,"RPn"],,[728943366594131,"JB"],]; CONWAYPOLDATA[5333]:=[ ,,,[129821221,"RPn"],,[1516588073640857,"JB"],]; CONWAYPOLDATA[5347]:=[ ,,,[165944148,"RPn"],,[728852915746231,"JB"],]; CONWAYPOLDATA[5351]:=[ ,,,[101438918,"RPn"],,[1029086822481508,"JB"],]; CONWAYPOLDATA[5381]:=[ ,,,[318463726,"RPn"],,[2053801241840057,"JB"],]; CONWAYPOLDATA[5387]:=[ ,,,[27899275,"RPn"],,[1597436889960894,"JB"],]; CONWAYPOLDATA[5393]:=[ ,,,[14987150,"RPn"],,[1914176279643266,"JB"],]; CONWAYPOLDATA[5399]:=[ ,,,[113681351,"RPn"],,[1446734643636651,"JB"],]; CONWAYPOLDATA[5407]:=[ ,,,[161323255,"RPn"],,[765366953967710,"JB"],]; CONWAYPOLDATA[5413]:=[ ,,,[339514191,"RPn"],,[796173553034668,"JB"],]; CONWAYPOLDATA[5417]:=[ ,,,[487654594,"RPn"],,[2075887884570879,"JB"],]; CONWAYPOLDATA[5419]:=[ ,,,[109788943,"RPn"],,[2395571479257435,"JB"],]; CONWAYPOLDATA[5431]:=[ ,,,[112888769,"RPn"],,[834068888681413,"JB"],]; CONWAYPOLDATA[5437]:=[ ,,,[197499030,"RPn"],,[800887972522716,"JB"],]; CONWAYPOLDATA[5441]:=[ ,,,[29539192,"RPn"],,[1251634131090644,"JB"],]; CONWAYPOLDATA[5443]:=[ ,,,[254509239,"RPn"],,[877230359078533,"JB"],]; CONWAYPOLDATA[5449]:=[ ,,,[533173759,"RPn"],,[148569635622465,"JB"],]; CONWAYPOLDATA[5471]:=[ ,,,[85325723,"RPn"],,[1694716661306260,"JB"],]; CONWAYPOLDATA[5477]:=[ ,,,[115142973,"RPn"],,[2818916585039666,"JB"],]; CONWAYPOLDATA[5479]:=[ ,,,[150075292,"RPn"],,[513452602517375,"JB"],]; CONWAYPOLDATA[5483]:=[ ,,,[234721749,"RPn"],,[1632898334837998,"JB"],]; CONWAYPOLDATA[5501]:=[ ,,,[272310504,"RPn"],,[2189732348970173,"JB"],]; CONWAYPOLDATA[5503]:=[ ,,,[115904189,"RPn"],,[1727394106935161,"JB"],]; CONWAYPOLDATA[5507]:=[ ,,,[86393818,"RPn"],,[1168007376094326,"JB"],]; CONWAYPOLDATA[5519]:=[ ,,,[116290862,"RPn"],,[2520740029225847,"JB"],]; CONWAYPOLDATA[5521]:=[ ,,,[333010168,"RPn"],,[706751536866068,"JB"],]; CONWAYPOLDATA[5527]:=[ ,,,[323406883,"RPn"],,[2848766294837761,"JB"],]; CONWAYPOLDATA[5531]:=[ ,,,[59817775,"RPn"],,[1412701323804391,"JB"],]; CONWAYPOLDATA[5557]:=[ ,,,[245235969,"RPn"],,[891513709213736,"JB"],]; CONWAYPOLDATA[5563]:=[ ,,,[84307267,"RPn"],,[630179602247435,"JB"],]; CONWAYPOLDATA[5569]:=[ ,,,[462065512,"RPn"],,[625201488272016,"JB"],]; CONWAYPOLDATA[5573]:=[ ,,,[400509220,"RPn"],,[1231339290544661,"JB"],]; CONWAYPOLDATA[5581]:=[ ,,,[732450446,"RPn"],,[819099400654234,"JB"],]; CONWAYPOLDATA[5591]:=[ ,,,[338713973,"RPn"],,[1176682526754716,"JB"],]; CONWAYPOLDATA[5623]:=[ ,,,[183231083,"RPn"],,[421467900346979,"JB"],]; CONWAYPOLDATA[5639]:=[ ,,,[317385483,"RPn"],,[1344379035862600,"JB"],]; CONWAYPOLDATA[5641]:=[ ,,,[17289679,"RPn"],,[482363454940171,"JB"],]; CONWAYPOLDATA[5647]:=[ ,,,[159420460,"RPn"],,[889393238039071,"JB"],]; CONWAYPOLDATA[5651]:=[ ,,,[28899216,"RPn"],,[1624757781443190,"JB"],]; CONWAYPOLDATA[5653]:=[ ,,,[254305863,"RPn"],,[1901857765679490,"JB"],]; CONWAYPOLDATA[5657]:=[ ,,,[26503048,"RPn"],,[2029877475508985,"JB"],]; CONWAYPOLDATA[5659]:=[ ,,,[86016802,"RPn"],,[565419660633671,"JB"],]; CONWAYPOLDATA[5669]:=[ ,,,[177263964,"RPn"],,[1152571408528129,"JB"],]; CONWAYPOLDATA[5683]:=[ ,,,[346628904,"RPn"],,[939773617080626,"JB"],]; CONWAYPOLDATA[5689]:=[ ,,,[347228126,"RPn"],,[1025962218296599,"JB"],]; CONWAYPOLDATA[5693]:=[ ,,,[252558561,"RPn"],,[2741548925100618,"JB"],]; CONWAYPOLDATA[5701]:=[ ,,,[254333014,"RPn"],,[573024276954557,"JB"],]; CONWAYPOLDATA[5711]:=[ ,,,[85956280,"RPn"],,[1506342713887011,"JB"],]; CONWAYPOLDATA[5717]:=[ ,,,[322027178,"RPn"],,[8349689262795617,"JB"],]; CONWAYPOLDATA[5737]:=[ ,,,[417819978,"RPn"],,[1009152679945404,"JB"],]; CONWAYPOLDATA[5741]:=[ ,,,[92068419,"RPn"],,[2617072590593413,"JB"],]; CONWAYPOLDATA[5743]:=[ ,,,[159006451,"RPn"],,[1064866218748141,"JB"],]; CONWAYPOLDATA[5749]:=[ ,,,[216840784,"RPn"],,[620436816790819,"JB"],]; CONWAYPOLDATA[5779]:=[ ,,,[296006161,"RPn"],,[938012934963798,"JB"],]; CONWAYPOLDATA[5783]:=[ ,,,[186975963,"RPn"],,[1768931815332631,"JB"],]; CONWAYPOLDATA[5791]:=[ ,,,[367184152,"RPn"],,[747217830324809,"JB"],]; CONWAYPOLDATA[5801]:=[ ,,,[33581992,"RPn"],,[3166020949090532,"JB"],]; CONWAYPOLDATA[5807]:=[ ,,,[165772434,"RPn"],,[1712149399027004,"JB"],]; CONWAYPOLDATA[5813]:=[ ,,,[336311117,"RPn"],,[1651480611411199,"JB"],]; CONWAYPOLDATA[5821]:=[ ,,,[96686816,"RPn"],,[5610593069705829,"JB"],]; CONWAYPOLDATA[5827]:=[ ,,,[265647105,"RPn"],,[922142380020910,"JB"],]; CONWAYPOLDATA[5839]:=[ ,,,[159404706,"RPn"],,[547636855033920,"JB"],]; CONWAYPOLDATA[5843]:=[ ,,,[269782998,"RPn"],,[1927277849562152,"JB"],]; CONWAYPOLDATA[5849]:=[ ,,,[265597244,"RPn"],,[4352995564832762,"JB"],]; CONWAYPOLDATA[5851]:=[ ,,,[58000965,"RPn"],,[1171379023126621,"JB"],]; CONWAYPOLDATA[5857]:=[ ,,,[513793618,"RPn"],,[1691896464824637,"JB"],]; CONWAYPOLDATA[5861]:=[ ,,,[437101661,"RPn"],,[2963860754433261,"JB"],]; CONWAYPOLDATA[5867]:=[ ,,,[240904892,"RPn"],,[1826769904510476,"JB"],]; CONWAYPOLDATA[5869]:=[ ,,,[125901790,"RPn"],,[911114607118929,"JB"],]; CONWAYPOLDATA[5879]:=[ ,,,[202437497,"RPn"],,[3253481347872768,"JB"],]; CONWAYPOLDATA[5881]:=[ ,,,[587770695,"RPn"],,[833221041861105,"JB"],]; CONWAYPOLDATA[5897]:=[ ,,,[301879227,"RPn"],,[1356147476450937,"JB"],]; CONWAYPOLDATA[5903]:=[ ,,,[139358029,"RPn"],,[3707249844336377,"JB"],]; CONWAYPOLDATA[5923]:=[ ,,,[298951581,"RPn"],,[809546126868320,"JB"],]; CONWAYPOLDATA[5927]:=[ ,,,[127987643,"RPn"],,[2328840013345440,"JB"],]; CONWAYPOLDATA[5939]:=[ ,,,[277244400,"RPn"],,[2454533112367545,"JB"],]; CONWAYPOLDATA[5953]:=[ ,,,[669920862,"RPn"],,[1010806272878976,"JB"],]; CONWAYPOLDATA[5981]:=[ ,,,[126037616,"RPn"],,[3351811054751910,"JB"],]; CONWAYPOLDATA[5987]:=[ ,,,[284681852,"RPn"],,[3898546365524666,"JB"],]; CONWAYPOLDATA[6007]:=[ ,,,[140852139,"RPn"],,[61984973254012,"JB"],]; CONWAYPOLDATA[6011]:=[ ,,,[275850803,"RPn"],,[2818895276193139,"JB"],]; CONWAYPOLDATA[6029]:=[ ,,,[247357814,"RPn"],,[1598055044676197,"JB"],]; CONWAYPOLDATA[6037]:=[ ,,,[134504365,"RPn"],,[1815371832864651,"JB"],]; CONWAYPOLDATA[6043]:=[ ,,,[255576604,"RPn"],,[2128797578850486,"JB"],]; CONWAYPOLDATA[6047]:=[ ,,,[172170189,"RPn"],,[3484234291626568,"JB"],]; CONWAYPOLDATA[6053]:=[ ,,,[329706912,"RPn"],,[2352379968680903,"JB"],]; CONWAYPOLDATA[6067]:=[ ,,,[292301995,"RPn"],,[749126447059672,"JB"],]; CONWAYPOLDATA[6073]:=[ ,,,[610136101,"RPn"],,[2715583535991015,"JB"],]; CONWAYPOLDATA[6079]:=[ ,,,[147768349,"RPn"],,[115442101134364,"JB"],]; CONWAYPOLDATA[6089]:=[ ,,,[289787691,"RPn"],,[1971348819772084,"JB"],]; CONWAYPOLDATA[6091]:=[ ,,,[252666869,"RPn"],,[4016999552314456,"JB"],]; CONWAYPOLDATA[6101]:=[ ,,,[471833039,"RPn"],,[2518492466745079,"JB"],]; CONWAYPOLDATA[6113]:=[ ,,,[179642734,"RPn"],,[3864617277813212,"JB"],]; CONWAYPOLDATA[6121]:=[ ,,,[625027559,"RPn"],,[985987285709875,"JB"],]; CONWAYPOLDATA[6131]:=[ ,,,[142600931,"RPn"],,[2240872726039146,"JB"],]; CONWAYPOLDATA[6133]:=[ ,,,[141782699,"RPn"],,[556610680973508,"JB"],]; CONWAYPOLDATA[6143]:=[ ,,,[334910222,"RPn"],,[5598112635794095,"JB"],]; CONWAYPOLDATA[6151]:=[ ,,,[110650342,"RPn"],,[991191965466482,"JB"],]; CONWAYPOLDATA[6163]:=[ ,,,[405654826,"RPn"],,[1440850433895123,"JB"],]; CONWAYPOLDATA[6173]:=[ ,,,[150608856,"RPn"],,[3564626760521953,"JB"],]; CONWAYPOLDATA[6197]:=[ ,,,[296055480,"RPn"],,[2863745344835955,"JB"],]; CONWAYPOLDATA[6199]:=[ ,,,[192113212,"RPn"],,[401271072342325,"JB"],]; CONWAYPOLDATA[6203]:=[ ,,,[181245459,"RPn"],,[3036779306316716,"JB"],]; CONWAYPOLDATA[6211]:=[ ,,,[332406511,"RPn"],,[348029491609808,"JB"],]; CONWAYPOLDATA[6217]:=[ ,,,[720618692,"RPn"],,[823259180478041,"JB"],]; CONWAYPOLDATA[6221]:=[ ,,,[145571403,"RPn"],,[6540852246583587,"JB"],]; CONWAYPOLDATA[6229]:=[ ,,,[268955764,"RPn"],,[1504748498271271,"JB"],]; CONWAYPOLDATA[6247]:=[ ,,,[416793598,"RPn"],,[210507837288809,"JB"],]; CONWAYPOLDATA[6257]:=[ ,,,[150618507,"RPn"],,[1719912532385394,"JB"],]; CONWAYPOLDATA[6263]:=[ ,,,[297955967,"RPn"],,[6337071657236119,"JB"],]; CONWAYPOLDATA[6269]:=[ ,,,[508685469,"RPn"],,[2804252604105814,"JB"],]; CONWAYPOLDATA[6271]:=[ ,,,[60828711,"RPn"],,[729180065392114,"JB"],]; CONWAYPOLDATA[6277]:=[ ,,,[155067010,"RPn"],,[1009372144183298,"JB"],]; CONWAYPOLDATA[6287]:=[ ,,,[231719966,"RPn"],,[2073260456825460,"JB"],]; CONWAYPOLDATA[6299]:=[ ,,,[76432068,"RPn"],,[2299810991515227,"JB"],]; CONWAYPOLDATA[6301]:=[ ,,,[499417270,"RPn"],,[57427122613436,"JB"],]; CONWAYPOLDATA[6311]:=[ ,,,[113490720,"RPn"],,[2413972004167403,"JB"],]; CONWAYPOLDATA[6317]:=[ ,,,[275130620,"RPn"],,[2706910744010637,"JB"],]; CONWAYPOLDATA[6323]:=[ ,,,[275278130,"RPn"],,[1736955542161444,"JB"],]; CONWAYPOLDATA[6329]:=[ ,,,[119042164,"RPn"],,[1780821410795840,"JB"],]; CONWAYPOLDATA[6337]:=[ ,,,[274094271,"RPn"],,[1251710902014982,"JB"],]; CONWAYPOLDATA[6343]:=[ ,,,[588459142,"RPn"],,[2905679398115034,"JB"],]; CONWAYPOLDATA[6353]:=[ ,,,[317573767,"RPn"],,[2008466609023681,"JB"],]; CONWAYPOLDATA[6359]:=[ ,,,[120592089,"RPn"],,[3202331994485469,"JB"],]; CONWAYPOLDATA[6361]:=[ ,,,[432503492,"RPn"],,[1520631365801217,"JB"],]; CONWAYPOLDATA[6367]:=[ ,,,[157965273,"RPn"],,[1190640199018175,"JB"],]; CONWAYPOLDATA[6373]:=[ ,,,[365491552,"RPn"],,[1554209670890963,"JB"],]; CONWAYPOLDATA[6379]:=[ ,,,[106165699,"RPn"],,[5164025311690616,"JB"],]; CONWAYPOLDATA[6389]:=[ ,,,[367329168,"RPn"],,[7743538030263454,"JB"],]; CONWAYPOLDATA[6397]:=[ ,,,[408071029,"RPn"],,[521497100895854,"JB"],]; CONWAYPOLDATA[6421]:=[ ,,,[103647788,"RPn"],,[2678601253618901,"JB"],]; CONWAYPOLDATA[6427]:=[ ,,,[159845920,"RPn"],,[1107207193244685,"JB"],]; CONWAYPOLDATA[6449]:=[ ,,,[41512216,"RPn"],,[7288487351515098,"JB"],]; CONWAYPOLDATA[6451]:=[ ,,,[246028241,"RPn"],,[1112204871601824,"JB"],]; CONWAYPOLDATA[6469]:=[ ,,,[530697355,"RPn"],,[3924869955616893,"JB"],]; CONWAYPOLDATA[6473]:=[ ,,,[401811478,"RPn"],,[5849926115309517,"JB"],]; CONWAYPOLDATA[6481]:=[ ,,,[710116696,"RPn"],,[643430637293646,"JB"],]; CONWAYPOLDATA[6491]:=[ ,,,[319253346,"RPn"],,[2004361917010340,"JB"],]; CONWAYPOLDATA[6521]:=[ ,,,[24518966,"RPn"],,[5371562828520358,"JB"],]; CONWAYPOLDATA[6529]:=[ ,,,[758761213,"RPn"],,[476568065771791,"JB"],]; CONWAYPOLDATA[6547]:=[ ,,,[366972446,"RPn"],,[1836412080736597,"JB"],]; CONWAYPOLDATA[6551]:=[ ,,,[109028310,"RPn"],,[2952407829616001,"JB"],]; CONWAYPOLDATA[6553]:=[ ,,,[384287589,"RPn"],,[1741382689124961,"JB"],]; CONWAYPOLDATA[6563]:=[ ,,,[301458284,"RPn"],,[3055753437077859,"JB"],]; CONWAYPOLDATA[6569]:=[ ,,,[342297455,"RPn"],,[3598740067755333,"JB"],]; CONWAYPOLDATA[6571]:=[ ,,,[159524170,"RPn"],,[1100128084790152,"JB"],]; CONWAYPOLDATA[6577]:=[ ,,,[290907292,"RPn"],,[1782156199119488,"JB"],]; CONWAYPOLDATA[6581]:=[ ,,,[83078558,"RPn"],,[3526079849382626,"JB"],]; CONWAYPOLDATA[6599]:=[ ,,,[695554410,"RPn"],,[4490039948137208,"JB"],]; CONWAYPOLDATA[6607]:=[ ,,,[130197545,"RPn"],,[845891012086470,"JB"],]; CONWAYPOLDATA[6619]:=[ ,,,[161483745,"RPn"],,[413264540121615,"JB"],]; CONWAYPOLDATA[6637]:=[ ,,,[295326591,"RPn"],,[1939504325077087,"JB"],]; CONWAYPOLDATA[6653]:=[ ,,,[290024231,"RPn"],,[3058218239392708,"JB"],]; CONWAYPOLDATA[6659]:=[ ,,,[393054136,"RPn"],,[3881644027830145,"JB"],]; CONWAYPOLDATA[6661]:=[ ,,,[334422172,"RPn"],,[3213053859786212,"JB"],]; CONWAYPOLDATA[6673]:=[ ,,,[667860537,"RPn"],,[7385193521967925,"JB"],]; CONWAYPOLDATA[6679]:=[ ,,,[263680248,"RPn"],,[756045962882191,"JB"],]; CONWAYPOLDATA[6689]:=[ ,,,[113110993,"RPn"],,[9811350878895587,"JB"],]; CONWAYPOLDATA[6691]:=[ ,,,[127088856,"RPn"],,[1826978038563440,"JB"],]; CONWAYPOLDATA[6701]:=[ ,,,[313097526,"RPn"],,[3106864969950850,"JB"],]; CONWAYPOLDATA[6703]:=[ ,,,[258883271,"RPn"],,[4013315108913316,"JB"],]; CONWAYPOLDATA[6709]:=[ ,,,[165524450,"RPn"],,[334841448649067,"JB"],]; CONWAYPOLDATA[6719]:=[ ,,,[310370778,"RPn"],,[2883576409856981,"JB"],]; CONWAYPOLDATA[6733]:=[ ,,,[306311104,"RPn"],,[1712830960459920,"JB"],]; CONWAYPOLDATA[6737]:=[ ,,,[578122184,"RPn"],,[2989988534534712,"JB"],]; CONWAYPOLDATA[6761]:=[ ,,,[344932701,"RPn"],,[5762239228795906,"JB"],]; CONWAYPOLDATA[6763]:=[ ,,,[25077206,"RPn"],,[2078454746288950,"JB"],]; CONWAYPOLDATA[6779]:=[ ,,,[346311996,"RPn"],,[3922214573088243,"JB"],]; CONWAYPOLDATA[6781]:=[ ,,,[365421311,"RPn"],,[1758379416201136,"JB"],]; CONWAYPOLDATA[6791]:=[ ,,,[226751497,"RPn"],,[5112960191289830,"JB"],]; CONWAYPOLDATA[6793]:=[ ,,,[393246780,"RPn"],,[1383976885236889,"JB"],]; CONWAYPOLDATA[6803]:=[ ,,,[687048578,"RPn"],,[4090917927581611,"JB"],]; CONWAYPOLDATA[6823]:=[ ,,,[232739356,"RPn"],,[2043502008045766,"JB"],]; CONWAYPOLDATA[6827]:=[ ,,,[354027741,"RPn"],,[4153532184888115,"JB"],]; CONWAYPOLDATA[6829]:=[ ,,,[323407784,"RPn"],,[2046369560618038,"JB"],]; CONWAYPOLDATA[6833]:=[ ,,,[230682083,"RPn"],,[5741819760038854,"JB"],]; CONWAYPOLDATA[6841]:=[ ,,,[878904338,"RPn"],,[2017976900806982,"JB"],]; CONWAYPOLDATA[6857]:=[ ,,,[24534349,"RPn"],,[4264993933406845,"JB"],]; CONWAYPOLDATA[6863]:=[ ,,,[307098666,"RPn"],,[3316514137416930,"JB"],]; CONWAYPOLDATA[6869]:=[ ,,,[605722160,"RPn"],,[4950208843692178,"JB"],]; CONWAYPOLDATA[6871]:=[ ,,,[118971368,"RPn"],,[1466444722555333,"JB"],]; CONWAYPOLDATA[6883]:=[ ,,,[407824635,"RPn"],,[2243476842153253,"JB"],]; CONWAYPOLDATA[6899]:=[ ,,,[369717412,"RPn"],,[6477013048711569,"JB"],]; CONWAYPOLDATA[6907]:=[ ,,,[429311494,"RPn"],,[1924730527970513,"JB"],]; CONWAYPOLDATA[6911]:=[ ,,,[140300218,"RPn"],,[2494602771905914,"JB"],]; CONWAYPOLDATA[6917]:=[ ,,,[462927144,"RPn"],,[3597296894943891,"JB"],]; CONWAYPOLDATA[6947]:=[ ,,,[188520741,"RPn"],,[8860408666571500,"JB"],]; CONWAYPOLDATA[6949]:=[ ,,,[180757390,"RPn"],,[1352511416517004,"JB"],]; CONWAYPOLDATA[6959]:=[ ,,,[664967252,"RPn"],,[3428335060887773,"JB"],]; CONWAYPOLDATA[6961]:=[ ,,,[909962816,"RPn"],,[5467866797781009,"JB"],]; CONWAYPOLDATA[6967]:=[ ,,,[850210883,"RPn"],,[2034502273059691,"JB"],]; CONWAYPOLDATA[6971]:=[ ,,,[133383116,"RPn"],,[5944612534077766,"JB"],]; CONWAYPOLDATA[6977]:=[ ,,,[482920035,"RPn"],,[2735366802914665,"JB"],]; CONWAYPOLDATA[6983]:=[ ,,,[242156479,"RPn"],,[11310933768474846,"JB"],]; CONWAYPOLDATA[6991]:=[ ,,,[178018830,"RPn"],,[1064416791750587,"JB"],]; CONWAYPOLDATA[6997]:=[ ,,,[1020442485,"RPn"],,[882112375970767,"JB"],]; CONWAYPOLDATA[7001]:=[ ,,,[79328334,"RPn"],,[3215098911054548,"JB"],]; CONWAYPOLDATA[7013]:=[ ,,,[183144497,"RPn"],,[3919531595640742,"JB"],]; CONWAYPOLDATA[7019]:=[ ,,,[373158118,"RPn"],,[5659650286412195,"JB"],]; CONWAYPOLDATA[7027]:=[ ,,,[380104486,"RPn"],,[2386068230512176,"JB"],]; CONWAYPOLDATA[7039]:=[ ,,,[177410959,"RPn"],,[1261635362345407,"JB"],]; CONWAYPOLDATA[7043]:=[ ,,,[1282438743,"RPn"],,[6315527245187770,"JB"],]; CONWAYPOLDATA[7057]:=[ ,,,[327127240,"RPn"],,[2453523026903042,"JB"],]; CONWAYPOLDATA[7069]:=[ ,,,[344479441,"RPn"],,[2496016375402831,"JB"],]; CONWAYPOLDATA[7079]:=[ ,,,[295654442,"RPn"],,[4375821427880616,"JB"],]; CONWAYPOLDATA[7103]:=[ ,,,[500377943,"RPn"],,[9554984809546154,"JB"],]; CONWAYPOLDATA[7109]:=[ ,,,[87874351,"RPn"],,[2646858626156266,"JB"],]; CONWAYPOLDATA[7121]:=[ ,,,[50623192,"RPn"],,[3596768987469094,"JB"],]; CONWAYPOLDATA[7127]:=[ ,,,[229097420,"RPn"],,[7973285364578001,"JB"],]; CONWAYPOLDATA[7129]:=[ ,,,[839945916,"RPn"],,[762254650344690,"JB"],]; CONWAYPOLDATA[7151]:=[ ,,,[386075346,"RPn"],,[3019120784105240,"JB"],]; CONWAYPOLDATA[7159]:=[ ,,,[198397370,"RPn"],,[1333720193717767,"JB"],]; CONWAYPOLDATA[7177]:=[ ,,,[803773771,"RPn"],,[1416201840651647,"JB"],]; CONWAYPOLDATA[7187]:=[ ,,,[252680548,"RPn"],,[4784753755131737,"JB"],]; CONWAYPOLDATA[7193]:=[ ,,,[596256545,"RPn"],,[3929983353339771,"JB"],]; CONWAYPOLDATA[7207]:=[ ,,,[286485460,"RPn"],,[67504650262987,"JB"],]; CONWAYPOLDATA[7211]:=[ ,,,[461987139,"RPn"],,[3305960619075278,"JB"],]; CONWAYPOLDATA[7213]:=[ ,,,[187119651,"RPn"],,[1206864711329546,"JB"],]; CONWAYPOLDATA[7219]:=[ ,,,[446978825,"RPn"],,[13019940811112042,"JB"],]; CONWAYPOLDATA[7229]:=[ ,,,[190209450,"RPn"],,[7892882333562569,"JB"],]; CONWAYPOLDATA[7237]:=[ ,,,[393917149,"RPn"],,[1778223494389936,"JB"],]; CONWAYPOLDATA[7243]:=[ ,,,[555443943,"RPn"],,[6592878664814752,"JB"],]; CONWAYPOLDATA[7247]:=[ ,,,[207851212,"RPn"],,[4525003456797010,"JB"],]; CONWAYPOLDATA[7253]:=[ ,,,[356702542,"RPn"],,[5499258844212660,"JB"],]; CONWAYPOLDATA[7283]:=[ ,,,[156416993,"RPn"],,[5385571981970194,"JB"],]; CONWAYPOLDATA[7297]:=[ ,,,[562569517,"RPn"],,[1876783014485640,"JB"],]; CONWAYPOLDATA[7307]:=[ ,,,[143662929,"RPn"],,[2901749138786837,"JB"],]; CONWAYPOLDATA[7309]:=[ ,,,[575912661,"RPn"],,[4821282722111428,"JB"],]; CONWAYPOLDATA[7321]:=[ ,,,[33039680,"RPn"],,[2574936208424285,"JB"],]; CONWAYPOLDATA[7331]:=[ ,,,[416782014,"RPn"],,[5635505027172492,"JB"],]; CONWAYPOLDATA[7333]:=[ ,,,[1067149497,"RPn"],,[945854402640401,"JB"],]; CONWAYPOLDATA[7349]:=[ ,,,[267856354,"RPn"],,[5386388737826043,"JB"],]; CONWAYPOLDATA[7351]:=[ ,,,[193485677,"RPn"],,[2798140657736830,"JB"],]; CONWAYPOLDATA[7369]:=[ ,,,[34722735,"RPn"],,[8656674692405013,"JB"],]; CONWAYPOLDATA[7393]:=[ ,,,[360926265,"RPn"],,[429611660817123,"JB"],]; CONWAYPOLDATA[7411]:=[ ,,,[697508500,"RPn"],,[2255286858794945,"JB"],]; CONWAYPOLDATA[7417]:=[ ,,,[596608651,"RPn"],,[1676398844235784,"JB"],]; CONWAYPOLDATA[7433]:=[ ,,,[274121610,"RPn"],,[5547864367836999,"JB"],]; CONWAYPOLDATA[7451]:=[ ,,,[93420640,"RPn"],,[4326673942188215,"JB"],]; CONWAYPOLDATA[7457]:=[ ,,,[722807013,"RPn"],,[4433688166222412,"JB"],]; CONWAYPOLDATA[7459]:=[ ,,,[488057290,"RPn"],,[3094194344771941,"JB"],]; CONWAYPOLDATA[7477]:=[ ,,,[384841192,"RPn"],,[2712216355978554,"JB"],]; CONWAYPOLDATA[7481]:=[ ,,,[38115701,"RPn"],,[4437520991927583,"JB"],]; CONWAYPOLDATA[7487]:=[ ,,,[332033481,"RPn"],,[5915094303905970,"JB"],]; CONWAYPOLDATA[7489]:=[ ,,,[990143164,"RPn"],,[1609835595980899,"JB"],]; CONWAYPOLDATA[7499]:=[ ,,,[38109920,"RPn"],,[5351239360857724,"JB"],]; CONWAYPOLDATA[7507]:=[ ,,,[507142894,"RPn"],,[2524500386020550,"JB"],]; CONWAYPOLDATA[7517]:=[ ,,,[373406977,"RPn"],,[5808780537719190,"JB"],]; CONWAYPOLDATA[7523]:=[ ,,,[281518185,"RPn"],,[5914754020710493,"JB"],]; CONWAYPOLDATA[7529]:=[ ,,,[163590115,"RPn"],,[9247003846680166,"JB"],]; CONWAYPOLDATA[7537]:=[ ,,,[604979923,"RPn"],,[981278280618463,"JB"],]; CONWAYPOLDATA[7541]:=[ ,,,[370813595,"RPn"],,[7860285330875727,"JB"],]; CONWAYPOLDATA[7547]:=[ ,,,[486819237,"RPn"],,[4634029619934693,"JB"],]; CONWAYPOLDATA[7549]:=[ ,,,[440899347,"RPn"],,[2968618449148586,"JB"],]; CONWAYPOLDATA[7559]:=[ ,,,[272048423,"RPn"],,[5686182686658220,"JB"],]; CONWAYPOLDATA[7561]:=[ ,,,[2041507818,"RPn"],,[3004532227294045,"JB"],]; CONWAYPOLDATA[7573]:=[ ,,,[374136494,"RPn"],,[785230466184046,"JB"],]; CONWAYPOLDATA[7577]:=[ ,,,[37028802,"RPn"],,[3378589319800388,"JB"],]; CONWAYPOLDATA[7583]:=[ ,,,[393580454,"RPn"],,[4383411423019441,"JB"],]; CONWAYPOLDATA[7589]:=[ ,,,[387228727,"RPn"],,[9909954664252097,"JB"],]; CONWAYPOLDATA[7591]:=[ ,,,[228299331,"RPn"],,[1997165055650580,"JB"],]; CONWAYPOLDATA[7603]:=[ ,,,[517954377,"RPn"],,[5925915818793375,"JB"],]; CONWAYPOLDATA[7607]:=[ ,,,[507949823,"RPn"],,[5801588412058829,"JB"],]; CONWAYPOLDATA[7621]:=[ ,,,[577275510,"RPn"],,[689692095119184,"JB"],]; CONWAYPOLDATA[7639]:=[ ,,,[737461428,"RPn"],,[1557854457329947,"JB"],]; CONWAYPOLDATA[7643]:=[ ,,,[525685542,"RPn"],,[6632028873531563,"JB"],]; CONWAYPOLDATA[7649]:=[ ,,,[524346602,"RPn"],,[11052385692543901,"JB"],]; CONWAYPOLDATA[7669]:=[ ,,,[741584633,"RPn"],,[2693501269370584,"JB"],]; CONWAYPOLDATA[7673]:=[ ,,,[703729198,"RPn"],,[6250882572094019,"JB"],]; CONWAYPOLDATA[7681]:=[ ,,,[882101419,"RPn"],,[2770468715422931,"JB"],]; CONWAYPOLDATA[7687]:=[ ,,,[215950897,"RPn"],,[2090502215027079,"JB"],]; CONWAYPOLDATA[7691]:=[ ,,,[471304482,"RPn"],,[7591117405951165,"JB"],]; CONWAYPOLDATA[7699]:=[ ,,,[167645728,"RPn"],,[2555438131067288,"JB"],]; CONWAYPOLDATA[7703]:=[ ,,,[166716034,"RPn"],,[6478850413001227,"JB"],]; CONWAYPOLDATA[7717]:=[ ,,,[566504972,"RPn"],,[1347114474876900,"JB"],]; CONWAYPOLDATA[7723]:=[ ,,,[214792079,"RPn"],,[5390331970107104,"JB"],]; CONWAYPOLDATA[7727]:=[ ,,,[269270501,"RPn"],,[10396700608747396,"JB"],]; CONWAYPOLDATA[7741]:=[ ,,,[296890580,"RPn"],,[1062551384837831,"JB"],]; CONWAYPOLDATA[7753]:=[ ,,,[883151993,"RPn"],,[3073686070154471,"JB"],]; CONWAYPOLDATA[7757]:=[ ,,,[713713815,"RPn"],,[4526944734430438,"JB"],]; CONWAYPOLDATA[7759]:=[ ,,,[452838520,"RPn"],,[1044619671272533,"JB"],]; CONWAYPOLDATA[7789]:=[ ,,,[408587575,"RPn"],,[1663107994913367,"JB"],]; CONWAYPOLDATA[7793]:=[ ,,,[181218425,"RPn"],,[7270136970031275,"JB"],]; CONWAYPOLDATA[7817]:=[ ,,,[1025535684,"RPn"],,[10952736653533553,"JB"],]; CONWAYPOLDATA[7823]:=[ ,,,[220968463,"RPn"],,[13437923467361759,"JB"],]; CONWAYPOLDATA[7829]:=[ ,,,[221427609,"RPn"],,[3949649224481313,"JB"],]; CONWAYPOLDATA[7841]:=[ ,,,[852520578,"RPn"],,[7218630627614733,"JB"],]; CONWAYPOLDATA[7853]:=[ ,,,[227305087,"RPn"],,[7563976259656587,"JB"],]; CONWAYPOLDATA[7867]:=[ ,,,[726446650,"RPn"],,[3283969367454664,"JB"],]; CONWAYPOLDATA[7873]:=[ ,,,[670582780,"RPn"],,[3601564977782795,"JB"],]; CONWAYPOLDATA[7877]:=[ ,,,[424247345,"RPn"],,[22976000095998968,"JB"],]; CONWAYPOLDATA[7879]:=[ ,,,[485976723,"RPn"],,[1997652475085716,"JB"],]; CONWAYPOLDATA[7883]:=[ ,,,[487161519,"RPn"],,[6236874569398301,"JB"],]; CONWAYPOLDATA[7901]:=[ ,,,[238120340,"RPn"],,[7479774941827951,"JB"],]; CONWAYPOLDATA[7907]:=[ ,,,[494764713,"RPn"],,[18794110392940604,"JB"],]; CONWAYPOLDATA[7919]:=[ ,,,[246114608,"RPn"],,[17455041266950494,"JB"],]; CONWAYPOLDATA[7927]:=[ ,,,[176145870,"RPn"],,[3063816590756221,"JB"],]; CONWAYPOLDATA[7933]:=[ ,,,[816543692,"RPn"],,[1009712830262800,"JB"],]; CONWAYPOLDATA[7937]:=[ ,,,[420946735,"RPn"],,[11314509602097118,"JB"],]; CONWAYPOLDATA[7949]:=[ ,,,[1195338826,"RPn"],,[20085274345282340,"JB"],]; CONWAYPOLDATA[7951]:=[ ,,,[243388067,"RPn"],,[15859141056434358,"JB"],]; CONWAYPOLDATA[7963]:=[ ,,,[351829234,"RPn"],,[7457335356294591,"JB"],]; CONWAYPOLDATA[7993]:=[ ,,,[422533964,"RPn"],,[4015950842615623,"JB"],]; CONWAYPOLDATA[8009]:=[ ,,,[64047976,"RPn"],,[7629242690140655,"JB"],]; CONWAYPOLDATA[8011]:=[ ,,,[58264017,"RPn"],,[3842297065344730,"JB"],]; CONWAYPOLDATA[8017]:=[ ,,,[748715652,"RPn"],,[3849584665971579,"JB"],]; CONWAYPOLDATA[8039]:=[ ,,,[643111972,"RPn"],,[13683188761591993,"JB"],]; CONWAYPOLDATA[8053]:=[ ,,,[583600912,"RPn"],,[3329418362314918,"JB"],]; CONWAYPOLDATA[8059]:=[ ,,,[193818953,"RPn"],,[3336031441731936,"JB"],]; CONWAYPOLDATA[8069]:=[ ,,,[228691600,"RPn"],,[8428912795378574,"JB"],]; CONWAYPOLDATA[8081]:=[ ,,,[321324806,"RPn"],,[12213151045282855,"JB"],]; CONWAYPOLDATA[8087]:=[ ,,,[321555299,"RPn"],,[5295566016073448,"JB"],]; CONWAYPOLDATA[8089]:=[ ,,,[1879632858,"RPn"],,[433993896545464,"JB"],]; CONWAYPOLDATA[8093]:=[ ,,,[512788668,"RPn"],,[12587616199322911,"JB"],]; CONWAYPOLDATA[8101]:=[ ,,,[504554589,"RPn"],,[2042764711825489,"JB"],]; CONWAYPOLDATA[8111]:=[ ,,,[231228399,"RPn"],,[5061673051283492,"JB"],]; CONWAYPOLDATA[8117]:=[ ,,,[891676803,"RPn"],,[8160490632043423,"JB"],]; CONWAYPOLDATA[8123]:=[ ,,,[307374322,"RPn"],,[10339439291535198,"JB"],]; CONWAYPOLDATA[8147]:=[ ,,,[921482731,"RPn"],,[8561445916676959,"JB"],]; CONWAYPOLDATA[8161]:=[ ,,,[57363676,"RPn"],,[3942920855128471,"JB"],]; CONWAYPOLDATA[8167]:=[ ,,,[454395549,"RPn"],,[4132314803221130,"JB"],]; CONWAYPOLDATA[8171]:=[ ,,,[573538834,"RPn"],,[7333016528473904,"JB"],]; CONWAYPOLDATA[8179]:=[ ,,,[183643089,"RPn"],,[1496705915094704,"JB"],]; CONWAYPOLDATA[8191]:=[ ,,,[268304413,"RPn"],,[4257249434739471,"JB"],]; CONWAYPOLDATA[8209]:=[ ,,,[36784536,"RPn"],,[2238387825746178,"JB"],]; CONWAYPOLDATA[8219]:=[ ,,,[311237094,"RPn"],,[5591188380993148,"JB"],]; CONWAYPOLDATA[8221]:=[ ,,,[531890481,"RPn"],,[8587504389763434,"JB"],]; CONWAYPOLDATA[8231]:=[ ,,,[194193994,"RPn"],,[6933907697377407,"JB"],]; CONWAYPOLDATA[8233]:=[ ,,,[727723113,"RPn"],,[3409095081079626,"JB"],]; CONWAYPOLDATA[8237]:=[ ,,,[310979700,"RPn"],,[7893148547452785,"JB"],]; CONWAYPOLDATA[8243]:=[ ,,,[590528522,"RPn"],,[6291634023312720,"JB"],]; CONWAYPOLDATA[8263]:=[ ,,,[197510492,"RPn"],,[4515842539162083,"JB"],]; CONWAYPOLDATA[8269]:=[ ,,,[457366661,"RPn"],,[2424349558259933,"JB"],]; CONWAYPOLDATA[8273]:=[ ,,,[177091841,"RPn"],,[5141171873234084,"JB"],]; CONWAYPOLDATA[8287]:=[ ,,,[451757521,"RPn"],,[3091070169173497,"JB"],]; CONWAYPOLDATA[8291]:=[ ,,,[536676432,"RPn"],,[6050697804093525,"JB"],]; CONWAYPOLDATA[8293]:=[ ,,,[272707014,"RPn"],,[4170255959792115,"JB"],]; CONWAYPOLDATA[8297]:=[ ,,,[407639910,"RPn"],,[7108827050959535,"JB"],]; CONWAYPOLDATA[8311]:=[ ,,,[252355207,"RPn"],,[873865303428904,"JB"],]; CONWAYPOLDATA[8317]:=[ ,,,[479849321,"RPn"],,[3916868691180739,"JB"],]; CONWAYPOLDATA[8329]:=[ ,,,[58278020,"RPn"],,[1658477304391144,"JB"],]; CONWAYPOLDATA[8353]:=[ ,,,[477557721,"RPn"],,[2471106617304144,"JB"],]; CONWAYPOLDATA[8363]:=[ ,,,[629399382,"RPn"],,[8805104878692225,"JB"],]; CONWAYPOLDATA[8369]:=[ ,,,[69939736,"RPn"],,[8419209674072272,"JB"],]; CONWAYPOLDATA[8377]:=[ ,,,[753578171,"RPn"],,[3925754550288456,"JB"],]; CONWAYPOLDATA[8387]:=[ ,,,[36189907,"RPn"],,[11809783505454275,"JB"],]; CONWAYPOLDATA[8389]:=[ ,,,[819546583,"RPn"],,[3081409875082712,"JB"],]; CONWAYPOLDATA[8419]:=[ ,,,[265156408,"RPn"],,[3326083060688620,"JB"],]; CONWAYPOLDATA[8423]:=[ ,,,[851262077,"RPn"],,[5071849711582374,"JB"],]; CONWAYPOLDATA[8429]:=[ ,,,[565703908,"RPn"],,[13302928641661789,"JB"],]; CONWAYPOLDATA[8431]:=[ ,,,[249810533,"RPn"],,[10095845857677607,"JB"],]; CONWAYPOLDATA[8443]:=[ ,,,[610217827,"RPn"],,[5079637384817533,"JB"],]; CONWAYPOLDATA[8447]:=[ ,,,[681782716,"RPn"],,[9206809463604693,"JB"],]; CONWAYPOLDATA[8461]:=[ ,,,[567149297,"RPn"],,[7669061939289487,"JB"],]; CONWAYPOLDATA[8467]:=[ ,,,[623577618,"RPn"],,[4254362107858096,"JB"],]; CONWAYPOLDATA[8501]:=[ ,,,[845968521,"RPn"],,[16480270602049155,"JB"],]; CONWAYPOLDATA[8513]:=[ ,,,[481580415,"RPn"],,[5305056629256504,"JB"],]; CONWAYPOLDATA[8521]:=[ ,,,[1858540886,"RPn"],,[4942472693418789,"JB"],]; CONWAYPOLDATA[8527]:=[ ,,,[433529739,"RPn"],,[11956817131431550,"JB"],]; CONWAYPOLDATA[8537]:=[ ,,,[139400676,"RPn"],,[6792514065141387,"JB"],]; CONWAYPOLDATA[8539]:=[ ,,,[206242469,"RPn"],,[4467745677549150,"JB"],]; CONWAYPOLDATA[8543]:=[ ,,,[407808653,"RPn"],,[11574894498730171,"JB"],]; CONWAYPOLDATA[8563]:=[ ,,,[636633363,"RPn"],,[5325609652565205,"JB"],]; CONWAYPOLDATA[8573]:=[ ,,,[127549096,"RPn"],,[7413441449952734,"JB"],]; CONWAYPOLDATA[8581]:=[ ,,,[798504961,"RPn"],,[6390414695667242,"JB"],]; CONWAYPOLDATA[8597]:=[ ,,,[511555890,"RPn"],,[13522785810674156,"JB"],]; CONWAYPOLDATA[8599]:=[ ,,,[287877325,"RPn"],,[2696288490022882,"JB"],]; CONWAYPOLDATA[8609]:=[ ,,,[573109742,"RPn"],,[12177421253925394,"JB"],]; CONWAYPOLDATA[8623]:=[ ,,,[440825009,"RPn"],,[5454814271862218,"JB"],]; CONWAYPOLDATA[8627]:=[ ,,,[203795623,"RPn"],,[9794987907770314,"JB"],]; CONWAYPOLDATA[8629]:=[ ,,,[71249659,"RPn"],,[15533339556206983,"JB"],]; CONWAYPOLDATA[8641]:=[ ,,,[2015841625,"RPn"],,[5247121661014737,"JB"],]; CONWAYPOLDATA[8647]:=[ ,,,[297474097,"RPn"],,[2290750263326045,"JB"],]; CONWAYPOLDATA[8663]:=[ ,,,[434986561,"RPn"],,[14508917215395141,"JB"],]; CONWAYPOLDATA[8669]:=[ ,,,[128569941,"RPn"],,[8982875751554144,"JB"],]; CONWAYPOLDATA[8677]:=[ ,,,[513999451,"RPn"],,[5666672478334327,"JB"],]; CONWAYPOLDATA[8681]:=[ ,,,[349826953,"RPn"],,[16256622979512500,"JB"],]; CONWAYPOLDATA[8689]:=[ ,,,[2263779939,"RPn"],,[5335325316342032,"JB"],]; CONWAYPOLDATA[8693]:=[ ,,,[49080680,"RPn"],,[22785376520704858,"JB"],]; CONWAYPOLDATA[8699]:=[ ,,,[286362383,"RPn"],,[8762841217339890,"JB"],]; CONWAYPOLDATA[8707]:=[ ,,,[303212573,"RPn"],,[4029499423257128,"JB"],]; CONWAYPOLDATA[8713]:=[ ,,,[1208911329,"RPn"],,[22296306777454875,"JB"],]; CONWAYPOLDATA[8719]:=[ ,,,[518719470,"RPn"],,[5446259627519825,"JB"],]; CONWAYPOLDATA[8731]:=[ ,,,[665957027,"RPn"],,[17975996436420192,"JB"],]; CONWAYPOLDATA[8737]:=[ ,,,[2655034513,"RPn"],,[4375744734405416,"JB"],]; CONWAYPOLDATA[8741]:=[ ,,,[123606483,"RPn"],,[10628151828206587,"JB"],]; CONWAYPOLDATA[8747]:=[ ,,,[667194921,"RPn"],,[6667668047806108,"JB"],]; CONWAYPOLDATA[8753]:=[ ,,,[512164292,"RPn"],,[14607363021474566,"JB"],]; CONWAYPOLDATA[8761]:=[ ,,,[1579906197,"RPn"],,[6925183958967851,"JB"],]; CONWAYPOLDATA[8779]:=[ ,,,[218000139,"RPn"],,[9178323433981842,"JB"],]; CONWAYPOLDATA[8783]:=[ ,,,[833919506,"RPn"],,[11585540863763501,"JB"],]; CONWAYPOLDATA[8803]:=[ ,,,[679133846,"RPn"],,[6003087621634213,"JB"],]; CONWAYPOLDATA[8807]:=[ ,,,[816717150,"RPn"],,[17087913713004744,"JB"],]; CONWAYPOLDATA[8819]:=[ ,,,[214239969,"RPn"],,[14712057442678108,"JB"],]; CONWAYPOLDATA[8821]:=[ ,,,[839591603,"RPn"],,[203994173201756,"JB"],]; CONWAYPOLDATA[8831]:=[ ,,,[389853333,"RPn"],,[10414715788279353,"JB"],]; CONWAYPOLDATA[8837]:=[ ,,,[142160821,"RPn"],,[13968384220602935,"JB"],]; CONWAYPOLDATA[8839]:=[ ,,,[508931945,"RPn"],,[5840204306799887,"JB"],]; CONWAYPOLDATA[8849]:=[ ,,,[78198616,"RPn"],,[7926562286591316,"JB"],]; CONWAYPOLDATA[8861]:=[ ,,,[120819737,"RPn"],,[16604846242128802,"JB"],]; CONWAYPOLDATA[8863]:=[ ,,,[466379926,"RPn"],,[4534661939988597,"JB"],]; CONWAYPOLDATA[8867]:=[ ,,,[1070441976,"RPn"],,[14335133658806012,"JB"],]; CONWAYPOLDATA[8887]:=[ ,,,[464283544,"RPn"],,[12106743437532641,"JB"],]; CONWAYPOLDATA[8893]:=[ ,,,[924791968,"RPn"],,[5897958084373823,"JB"],]; CONWAYPOLDATA[8923]:=[ ,,,[1028108062,"RPn"],,[16245209331772060,"JB"],]; CONWAYPOLDATA[8929]:=[ ,,,[2216481397,"RPn"],,[4754305078342164,"JB"],]; CONWAYPOLDATA[8933]:=[ ,,,[604987427,"RPn"],,[11557595438491913,"JB"],]; CONWAYPOLDATA[8941]:=[ ,,,[940968728,"RPn"],,[5590097056769300,"JB"],]; CONWAYPOLDATA[8951]:=[ ,,,[932926939,"RPn"],,[23953650362673166,"JB"],]; CONWAYPOLDATA[8963]:=[ ,,,[1085266931,"RPn"],,[8706226038441403,"JB"],]; CONWAYPOLDATA[8969]:=[ ,,,[72837252,"RPn"],,[17015776223297714,"JB"],]; CONWAYPOLDATA[8971]:=[ ,,,[715984483,"RPn"],,[356086881135045,"JB"],]; CONWAYPOLDATA[8999]:=[ ,,,[400815467,"RPn"],,[37200069166214391,"JB"],]; CONWAYPOLDATA[9001]:=[ ,,,[1341869087,"RPn"],,[5501280893639131,"JB"],]; CONWAYPOLDATA[9007]:=[ ,,,[405594220,"RPn"],,[10965714711868282,"JB"],]; CONWAYPOLDATA[9011]:=[ ,,,[404278517,"RPn"],,[12919385456059235,"JB"],]; CONWAYPOLDATA[9013]:=[ ,,,[622041213,"RPn"],,[4799804138666747,"JB"],]; CONWAYPOLDATA[9029]:=[ ,,,[378242870,"RPn"],,[16957000778939452,"JB"],]; CONWAYPOLDATA[9041]:=[ ,,,[406266379,"RPn"],,[7338527638169988,"JB"],]; CONWAYPOLDATA[9043]:=[ ,,,[1049087476,"RPn"],,[6388475474042673,"JB"],]; CONWAYPOLDATA[9049]:=[ ,,,[51805532,"RPn"],,[1620018963910402,"JB"],]; CONWAYPOLDATA[9059]:=[ ,,,[618041218,"RPn"],,[14643565516339496,"JB"],]; CONWAYPOLDATA[9067]:=[ ,,,[303390890,"RPn"],,[4988795605582457,"JB"],]; CONWAYPOLDATA[9091]:=[ ,,,[67755226,"RPn"],,[1410783967480419,"JB"],]; CONWAYPOLDATA[9103]:=[ ,,,[465099585,"RPn"],,[3505584227731361,"JB"],]; CONWAYPOLDATA[9109]:=[ ,,,[459521733,"RPn"],,[4784434313219774,"JB"],]; CONWAYPOLDATA[9127]:=[ ,,,[464902002,"RPn"],,[5646363922148649,"JB"],]; CONWAYPOLDATA[9133]:=[ ,,,[727333860,"RPn"],,[1947434401045214,"JB"],]; CONWAYPOLDATA[9137]:=[ ,,,[387947886,"RPn"],,[12527736508748459,"JB"],]; CONWAYPOLDATA[9151]:=[ ,,,[242556409,"RPn"],,[4580804568506564,"JB"],]; CONWAYPOLDATA[9157]:=[ ,,,[728485141,"RPn"],,[4336022796465665,"JB"],]; CONWAYPOLDATA[9161]:=[ ,,,[83813992,"RPn"],,[15109005839502348,"JB"],]; CONWAYPOLDATA[9173]:=[ ,,,[324953527,"RPn"],,[17927371907599149,"JB"],]; CONWAYPOLDATA[9181]:=[ ,,,[917053368,"RPn"],,[7102609336475791,"JB"],]; CONWAYPOLDATA[9187]:=[ ,,,[221186215,"RPn"],,[5537238163883179,"JB"],]; CONWAYPOLDATA[9199]:=[ ,,,[326040160,"RPn"],,[7148142986123628,"JB"],]; CONWAYPOLDATA[9203]:=[ ,,,[404214168,"RPn"],,[14145513262789957,"JB"],]; CONWAYPOLDATA[9209]:=[ ,,,[406199784,"RPn"],,[10373864823699400,"JB"],]; CONWAYPOLDATA[9221]:=[ ,,,[1343840879,"RPn"],,[16373012113250577,"JB"],]; CONWAYPOLDATA[9227]:=[ ,,,[655412266,"RPn"],,[12606221373198064,"JB"],]; CONWAYPOLDATA[9239]:=[ ,,,[674308434,"RPn"],,[20318129064745474,"JB"],]; CONWAYPOLDATA[9241]:=[ ,,,[1240955421,"RPn"],,[798956924667943,"JB"],]; CONWAYPOLDATA[9257]:=[ ,,,[668660884,"RPn"],,[15515547260361259,"JB"],]; CONWAYPOLDATA[9277]:=[ ,,,[997156904,"RPn"],,[6363416778743259,"JB"],]; CONWAYPOLDATA[9281]:=[ ,,,[86025592,"RPn"],,[11852612928649755,"JB"],]; CONWAYPOLDATA[9283]:=[ ,,,[766803651,"RPn"],,[7423572287704453,"JB"],]; CONWAYPOLDATA[9293]:=[ ,,,[586602041,"RPn"],,[10713666857138284,"JB"],]; CONWAYPOLDATA[9311]:=[ ,,,[409432610,"RPn"],,[8917461780853603,"JB"],]; CONWAYPOLDATA[9319]:=[ ,,,[434181532,"RPn"],,[6570644609065375,"JB"],]; CONWAYPOLDATA[9323]:=[ ,,,[782199702,"RPn"],,[15698407768848055,"JB"],]; CONWAYPOLDATA[9337]:=[ ,,,[764121411,"RPn"],,[15399733366681326,"JB"],]; CONWAYPOLDATA[9341]:=[ ,,,[325440442,"RPn"],,[21075940992562567,"JB"],]; CONWAYPOLDATA[9343]:=[ ,,,[934505551,"RPn"],,[27993687694621325,"JB"],]; CONWAYPOLDATA[9349]:=[ ,,,[54598162,"RPn"],,[5726721943591194,"JB"],]; CONWAYPOLDATA[9371]:=[ ,,,[1196273749,"RPn"],,[10884626700385597,"JB"],]; CONWAYPOLDATA[9377]:=[ ,,,[318349153,"RPn"],,[10096478630459088,"JB"],]; CONWAYPOLDATA[9391]:=[ ,,,[593069826,"RPn"],,[4572706281006179,"JB"],]; CONWAYPOLDATA[9397]:=[ ,,,[604706349,"RPn"],,[4839906291968069,"JB"],]; CONWAYPOLDATA[9403]:=[ ,,,[1058420489,"RPn"],,[11334820466521754,"JB"],]; CONWAYPOLDATA[9413]:=[ ,,,[405690890,"RPn"],,[35525602329990353,"JB"],]; CONWAYPOLDATA[9419]:=[ ,,,[62429134,"RPn"],,[14749028170355055,"JB"],]; CONWAYPOLDATA[9421]:=[ ,,,[704709644,"RPn"],,[1422533987623092,"JB"],]; CONWAYPOLDATA[9431]:=[ ,,,[235718421,"RPn"],,[14947236452421247,"JB"],]; CONWAYPOLDATA[9433]:=[ ,,,[1334618577,"RPn"],,[7713898617888713,"JB"],]; CONWAYPOLDATA[9437]:=[ ,,,[147707926,"RPn"],,[11075894232334554,"JB"],]; CONWAYPOLDATA[9439]:=[ ,,,[261063884,"RPn"],,[5374301367082746,"JB"],]; CONWAYPOLDATA[9461]:=[ ,,,[1320802908,"RPn"],,[11549187805760097,"JB"],]; CONWAYPOLDATA[9463]:=[ ,,,[447703996,"RPn"],,[4962883314281614,"JB"],]; CONWAYPOLDATA[9467]:=[ ,,,[418933686,"RPn"],,[12765806100000009,"JB"],]; CONWAYPOLDATA[9473]:=[ ,,,[138324749,"RPn"],,[16952152224616821,"JB"],]; CONWAYPOLDATA[9479]:=[ ,,,[779145370,"RPn"],,[26981845280097900,"JB"],]; CONWAYPOLDATA[9491]:=[ ,,,[408559079,"RPn"],,[31828180275117871,"JB"],]; CONWAYPOLDATA[9497]:=[ ,,,[1054736823,"RPn"],,[8874476422233006,"JB"],]; CONWAYPOLDATA[9511]:=[ ,,,[360523969,"RPn"],,[6465125562716455,"JB"],]; CONWAYPOLDATA[9521]:=[ ,,,[682846123,"RPn"],,[16700393972683125,"JB"],]; CONWAYPOLDATA[9533]:=[ ,,,[143109398,"RPn"],,[46652020551892089,"JB"],]; CONWAYPOLDATA[9539]:=[ ,,,[818865918,"RPn"],,[16196366321318287,"JB"],]; CONWAYPOLDATA[9547]:=[ ,,,[958261033,"RPn"],,[2753702934257290,"JB"],]; CONWAYPOLDATA[9551]:=[ ,,,[448581828,"RPn"],,[10169079719281620,"JB"],]; CONWAYPOLDATA[9587]:=[ ,,,[808164928,"RPn"],,[40845662311698612,"JB"],]; CONWAYPOLDATA[9601]:=[ ,,,[3930217368,"RPn"],,[4789208258926695,"JB"],]; CONWAYPOLDATA[9613]:=[ ,,,[521082280,"RPn"],,[5825841871035677,"JB"],]; CONWAYPOLDATA[9619]:=[ ,,,[807784384,"RPn"],,[7863583994277650,"JB"],]; CONWAYPOLDATA[9623]:=[ ,,,[815809076,"RPn"],,[22232252536322437,"JB"],]; CONWAYPOLDATA[9629]:=[ ,,,[65380912,"RPn"],,[14481395384239156,"JB"],]; CONWAYPOLDATA[9631]:=[ ,,,[606897468,"RPn"],,[6283367788091571,"JB"],]; CONWAYPOLDATA[9643]:=[ ,,,[795103924,"RPn"],,[8643974056713133,"JB"],]; CONWAYPOLDATA[9649]:=[ ,,,[48264305,"RPn"],,[941827767356482,"JB"],]; CONWAYPOLDATA[9661]:=[ ,,,[647972933,"RPn"],,[600080254277813,"JB"],]; CONWAYPOLDATA[9677]:=[ ,,,[179914786,"RPn"],,[20669785835046182,"JB"],]; CONWAYPOLDATA[9679]:=[ ,,,[259948906,"RPn"],,[6680065398371432,"JB"],]; CONWAYPOLDATA[9689]:=[ ,,,[93760456,"RPn"],,[14860205695799945,"JB"],]; CONWAYPOLDATA[9697]:=[ ,,,[1001855262,"RPn"],,[2143534857604295,"JB"],]; CONWAYPOLDATA[9719]:=[ ,,,[806822802,"RPn"],,[35434071691198474,"JB"],]; CONWAYPOLDATA[9721]:=[ ,,,[2173265651,"RPn"],,[5166405808797090,"JB"],]; CONWAYPOLDATA[9733]:=[ ,,,[852513472,"RPn"],,[2078938377990154,"JB"],]; CONWAYPOLDATA[9739]:=[ ,,,[555327522,"RPn"],,[2249983519883696,"JB"],]; CONWAYPOLDATA[9743]:=[ ,,,[620453731,"RPn"],,[13733218697792960,"JB"],]; CONWAYPOLDATA[9749]:=[ ,,,[434239960,"RPn"],,[21526716019530297,"JB"],]; CONWAYPOLDATA[9767]:=[ ,,,[381538093,"RPn"],,[30335378678569337,"JB"],]; CONWAYPOLDATA[9769]:=[ ,,,[1396927937,"RPn"],,[8114699516908150,"JB"],]; CONWAYPOLDATA[9781]:=[ ,,,[240250709,"RPn"],,[2086664977880588,"JB"],]; CONWAYPOLDATA[9787]:=[ ,,,[256448764,"RPn"],,[8910911970394262,"JB"],]; CONWAYPOLDATA[9791]:=[ ,,,[251315399,"RPn"],,[24315733076968943,"JB"],]; CONWAYPOLDATA[9803]:=[ ,,,[268739444,"RPn"],,[11259137134310367,"JB"],]; CONWAYPOLDATA[9811]:=[ ,,,[645524559,"RPn"],,[4769272185068003,"JB"],]; CONWAYPOLDATA[9817]:=[ ,,,[629387509,"RPn"],,[6593381474707452,"JB"],]; CONWAYPOLDATA[9829]:=[ ,,,[252074544,"RPn"],,[8101597260890663,"JB"],]; CONWAYPOLDATA[9833]:=[ ,,,[1219596826,"RPn"],,[15164374712020363,"JB"],]; CONWAYPOLDATA[9839]:=[ ,,,[246870356,"RPn"],,[13073837970324888,"JB"],]; CONWAYPOLDATA[9851]:=[ ,,,[446792107,"RPn"],,[24288266338256081,"JB"],]; CONWAYPOLDATA[9857]:=[ ,,,[478478499,"RPn"],,[25635736224214067,"JB"],]; CONWAYPOLDATA[9859]:=[ ,,,[188208312,"RPn"],,[4818713482504828,"JB"],]; CONWAYPOLDATA[9871]:=[ ,,,[356402329,"RPn"],,[13511553986643406,"JB"],]; CONWAYPOLDATA[9883]:=[ ,,,[1124102305,"RPn"],,[9073881399625918,"JB"],]; CONWAYPOLDATA[9887]:=[ ,,,[658879572,"RPn"],,[16186833010147043,"JB"],]; CONWAYPOLDATA[9901]:=[ ,,,[882198904,"RPn"],,[18046676243925526,"JB"],]; CONWAYPOLDATA[9907]:=[ ,,,[846127151,"RPn"],,[7367883981553939,"JB"],]; CONWAYPOLDATA[9923]:=[ ,,,[92452593,"RPn"],,[16172843744818769,"JB"],]; CONWAYPOLDATA[9929]:=[ ,,,[474179256,"RPn"],,[17890064352168048,"JB"],]; CONWAYPOLDATA[9931]:=[ ,,,[489290449,"RPn"],,[24920779105190069,"JB"],]; CONWAYPOLDATA[9941]:=[ ,,,[774483430,"RPn"],,[20916169724042734,"JB"],]; CONWAYPOLDATA[9949]:=[ ,,,[1081058342,"RPn"],,[6864016382765695,"JB"],]; CONWAYPOLDATA[9967]:=[ ,,,[496665580,"RPn"],,[9586194719206439,"JB"],]; CONWAYPOLDATA[9973]:=[ ,,,[275583920,"RPn"],,[9863967809002268,"JB"],]; CONWAYPOLDATA[10007]:=[ ,,,[1201560509,"RPn"],,[17113609900037042,"JB"],]; CONWAYPOLDATA[10009]:=[ ,,,[1202020857,"RPn"],,[20015295940805054,"JB"],]; CONWAYPOLDATA[10037]:=[ ,,,[171994034,"RPn"],,[16986042323178638,"JB"],]; CONWAYPOLDATA[10039]:=[ ,,,[267689938,"RPn"],,[39396287738091765,"JB"],]; CONWAYPOLDATA[10061]:=[ ,,,[506078364,"RPn"],,[26866470933958787,"JB"],]; CONWAYPOLDATA[10067]:=[ ,,,[1489613992,"RPn"],,[17574792885749842,"JB"],]; CONWAYPOLDATA[10069]:=[ ,,,[693401687,"RPn"],,[5416405754804909,"JB"],]; CONWAYPOLDATA[10079]:=[ ,,,[1272826526,"RPn"],,[60880785894125243,"JB"],]; CONWAYPOLDATA[10091]:=[ ,,,[880601208,"RPn"],,[14246884169940177,"JB"],]; CONWAYPOLDATA[10093]:=[ ,,,[365336323,"RPn"],,[4413949370571941,"JB"],]; CONWAYPOLDATA[10099]:=[ ,,,[197324363,"RPn"],,[6668277692515156,"JB"],]; CONWAYPOLDATA[10103]:=[ ,,,[478498291,"RPn"],,[18388529324817523,"JB"],]; CONWAYPOLDATA[10111]:=[ ,,,[391437266,"RPn"],,[15923110612145646,"JB"],]; CONWAYPOLDATA[10133]:=[ ,,,[776633654,"RPn"],,[19738450175884832,"JB"],]; CONWAYPOLDATA[10139]:=[ ,,,[925122918,"RPn"],,[13509194631709776,"JB"],]; CONWAYPOLDATA[10141]:=[ ,,,[391929370,"RPn"],,[8600217612989282,"JB"],]; CONWAYPOLDATA[10151]:=[ ,,,[484943730,"RPn"],,[18852448941255667,"JB"],]; CONWAYPOLDATA[10159]:=[ ,,,[405801258,"RPn"],,[460178717638544,"JB"],]; CONWAYPOLDATA[10163]:=[ ,,,[1838161486,"RPn"],,[21047775378054862,"JB"],]; CONWAYPOLDATA[10169]:=[ ,,,[103286536,"RPn"],,[60086416513172299,"JB"],]; CONWAYPOLDATA[10177]:=[ ,,,[930686657,"RPn"],,[10608761917050578,"JB"],]; CONWAYPOLDATA[10181]:=[ ,,,[372380258,"RPn"],,[19094184647544862,"JB"],]; CONWAYPOLDATA[10193]:=[ ,,,[498121720,"RPn"],,[20503606903057578,"JB"],]; CONWAYPOLDATA[10211]:=[ ,,,[292626844,"RPn"],,[19611672585030334,"JB"],]; CONWAYPOLDATA[10223]:=[ ,,,[1555950828,"RPn"],,[21393178805389575,"JB"],]; CONWAYPOLDATA[10243]:=[ ,,,[1461389303,"RPn"],,[8818514641401695,"JB"],]; CONWAYPOLDATA[10247]:=[ ,,,[686210854,"RPn"],,[17847622580081043,"JB"],]; CONWAYPOLDATA[10253]:=[ ,,,[719063398,"RPn"],,[17198258458306518,"JB"],]; CONWAYPOLDATA[10259]:=[ ,,,[86339746,"RPn"],,[18889347123913224,"JB"],]; CONWAYPOLDATA[10267]:=[ ,,,[195114070,"RPn"],,[4593428403598804,"JB"],]; CONWAYPOLDATA[10271]:=[ ,,,[380900042,"RPn"],,[15229122698772475,"JB"],]; CONWAYPOLDATA[10273]:=[ ,,,[1786577440,"RPn"],,[14392843412564529,"JB"],]; CONWAYPOLDATA[10289]:=[ ,,,[105740056,"RPn"],,[21349759230630989,"JB"],]; CONWAYPOLDATA[10301]:=[ ,,,[96025924,"RPn"],,[25581665764835848,"JB"],]; CONWAYPOLDATA[10303]:=[ ,,,[315148167,"RPn"],,[103641324132118319,"JB"],]; CONWAYPOLDATA[10313]:=[ ,,,[481431469,"RPn"],,[17767460272613594,"JB"],]; CONWAYPOLDATA[10321]:=[ ,,,[60315931,"RPn"],,[8094904026035039,"JB"],]; CONWAYPOLDATA[10331]:=[ ,,,[301200307,"RPn"],,[17259255168365068,"JB"],]; CONWAYPOLDATA[10333]:=[ ,,,[1239526019,"RPn"],,[5939523465363766,"JB"],]; CONWAYPOLDATA[10337]:=[ ,,,[844584588,"RPn"],,[13094956910947378,"JB"],]; CONWAYPOLDATA[10343]:=[ ,,,[427869229,"RPn"],,[32629870995538841,"JB"],]; CONWAYPOLDATA[10357]:=[ ,,,[1063425691,"RPn"],,[18582520045588673,"JB"],]; CONWAYPOLDATA[10369]:=[ ,,,[61322279,"RPn"],,[68695782838458229,"JB"],]; CONWAYPOLDATA[10391]:=[ ,,,[408709222,"RPn"],,[27935974428732068,"JB"],]; CONWAYPOLDATA[10399]:=[ ,,,[536588406,"RPn"],,[18845594965096580,"JB"],]; CONWAYPOLDATA[10427]:=[ ,,,[936407164,"RPn"],,[38392370881190665,"JB"],]; CONWAYPOLDATA[10429]:=[ ,,,[936221766,"RPn"],,[3269218566531024,"JB"],]; CONWAYPOLDATA[10433]:=[ ,,,[314627984,"RPn"],,[14318741815513952,"JB"],]; CONWAYPOLDATA[10453]:=[ ,,,[417764603,"RPn"],,[23901580343649795,"JB"],]; CONWAYPOLDATA[10457]:=[ ,,,[712696838,"RPn"],,[26424130919689992,"JB"],]; CONWAYPOLDATA[10459]:=[ ,,,[931593591,"RPn"],,[1315849625068837,"JB"],]; CONWAYPOLDATA[10463]:=[ ,,,[622067207,"RPn"],,[23961102696745927,"JB"],]; CONWAYPOLDATA[10477]:=[ ,,,[761761718,"RPn"],,[7641910266041896,"JB"],]; CONWAYPOLDATA[10487]:=[ ,,,[606956104,"RPn"],,[21320653919957927,"JB"],]; CONWAYPOLDATA[10499]:=[ ,,,[846691857,"RPn"],,[23881668031086212,"JB"],]; CONWAYPOLDATA[10501]:=[ ,,,[717963873,"RPn"],,[11716223732357172,"JB"],]; CONWAYPOLDATA[10513]:=[ ,,,[2405416459,"RPn"],,[6423990922452826,"JB"],]; CONWAYPOLDATA[10529]:=[ ,,,[1762428255,"RPn"],,[47932075562163929,"JB"],]; CONWAYPOLDATA[10531]:=[ ,,,[652353329,"RPn"],,[22126558212605030,"JB"],]; CONWAYPOLDATA[10559]:=[ ,,,[552985412,"RPn"],,[22510328170808436,"JB"],]; CONWAYPOLDATA[10567]:=[ ,,,[315583461,"RPn"],,[6922871535338386,"JB"],]; CONWAYPOLDATA[10589]:=[ ,,,[397225159,"RPn"],,[18654236800094112,"JB"],]; CONWAYPOLDATA[10597]:=[ ,,,[431128353,"RPn"],,[11173526135933652,"JB"],]; CONWAYPOLDATA[10601]:=[ ,,,[286216402,"RPn"],,[111025205511802316,"JB"],]; CONWAYPOLDATA[10607]:=[ ,,,[448135148,"RPn"],,[24088264298712357,"JB"],]; CONWAYPOLDATA[10613]:=[ ,,,[982052731,"RPn"],,[33644179568752619,"JB"],]; CONWAYPOLDATA[10627]:=[ ,,,[790446892,"RPn"],,[8011231354584914,"JB"],]; CONWAYPOLDATA[10631]:=[ ,,,[644164194,"RPn"],,[28382107036908434,"JB"],]; CONWAYPOLDATA[10639]:=[ ,,,[632211942,"RPn"],,[32526925397983443,"JB"],]; CONWAYPOLDATA[10651]:=[ ,,,[766232947,"RPn"],,[8323305517051516,"JB"],]; CONWAYPOLDATA[10657]:=[ ,,,[1677102754,"RPn"],,[11239683274920629,"JB"],]; CONWAYPOLDATA[10663]:=[ ,,,[113571616,"RPn"],,[9135025331857957,"JB"],]; CONWAYPOLDATA[10667]:=[ ,,,[551963917,"RPn"],,[16436732070684883,"JB"],]; CONWAYPOLDATA[10687]:=[ ,,,[456805133,"RPn"],,[54074538074596505,"JB"],]; CONWAYPOLDATA[10691]:=[ ,,,[90691755,"RPn"],,[27202886596528078,"JB"],]; CONWAYPOLDATA[10709]:=[ ,,,[413988524,"RPn"],,[37968705917486375,"JB"],]; CONWAYPOLDATA[10711]:=[ ,,,[306912997,"RPn"],,[7414755266552097,"JB"],]; CONWAYPOLDATA[10723]:=[ ,,,[1034769502,"RPn"],,[12452810045533164,"JB"],]; CONWAYPOLDATA[10729]:=[ ,,,[87934891,"RPn"],,[17588443746311200,"JB"],]; CONWAYPOLDATA[10733]:=[ ,,,[1099252396,"RPn"],,[36238413886059112,"JB"],]; CONWAYPOLDATA[10739]:=[ ,,,[651051881,"RPn"],,[26312652073756827,"JB"],]; CONWAYPOLDATA[10753]:=[ ,,,[2527826004,"RPn"],,[8351548980090533,"JB"],]; CONWAYPOLDATA[10771]:=[ ,,,[341429932,"RPn"],,[4205358103124381,"JB"],]; CONWAYPOLDATA[10781]:=[ ,,,[1360529867,"RPn"],,[40108049346217011,"JB"],]; CONWAYPOLDATA[10789]:=[ ,,,[2063827812,"RPn"],,[12668467084323508,"JB"],]; CONWAYPOLDATA[10799]:=[ ,,,[685207368,"RPn"],,[147325755525773168,"JB"],]; CONWAYPOLDATA[10831]:=[ ,,,[345259794,"RPn"],,[13367723025159945,"JB"],]; CONWAYPOLDATA[10837]:=[ ,,,[1286677012,"RPn"],,[13788467140085287,"JB"],]; CONWAYPOLDATA[10847]:=[ ,,,[1248370388,"RPn"],,[38483656949936729,"JB"],]; CONWAYPOLDATA[10853]:=[ ,,,[1060012512,"RPn"],,[25213190422027945,"JB"],]; CONWAYPOLDATA[10859]:=[ ,,,[69128396,"RPn"],,[27555250790913475,"JB"],]; CONWAYPOLDATA[10861]:=[ ,,,[1528435949,"RPn"],,[12756911929064180,"JB"],]; CONWAYPOLDATA[10867]:=[ ,,,[1062749134,"RPn"],,[6690744046734544,"JB"],]; CONWAYPOLDATA[10883]:=[ ,,,[325216691,"RPn"],,[39482092594738891,"JB"],]; CONWAYPOLDATA[10889]:=[ ,,,[309443605,"RPn"],,[30774959148889265,"JB"],]; CONWAYPOLDATA[10891]:=[ ,,,[310066772,"RPn"],,[3302898480214554,"JB"],]; CONWAYPOLDATA[10903]:=[ ,,,[676116839,"RPn"],,[2523050714697072,"JB"],]; CONWAYPOLDATA[10909]:=[ ,,,[462399785,"RPn"],,[8401717936707678,"JB"],]; CONWAYPOLDATA[10937]:=[ ,,,[235998589,"RPn"],,[25291967363424896,"JB"],]; CONWAYPOLDATA[10939]:=[ ,,,[477027915,"RPn"],,[8367769996252525,"JB"],]; CONWAYPOLDATA[10949]:=[ ,,,[1538049828,"RPn"],,[28094810467495348,"JB"],]; CONWAYPOLDATA[10957]:=[ ,,,[912838632,"RPn"],,[56486936206850072,"JB"],]; CONWAYPOLDATA[10973]:=[ ,,,[929939806,"RPn"],,[21835378031000607,"JB"],]; CONWAYPOLDATA[10979]:=[ ,,,[473699936,"RPn"],,[18124149036834216,"JB"],]; CONWAYPOLDATA[10987]:=[ ,,,[1063080148,"RPn"],,[14567929685363437,"JB"],]; CONWAYPOLDATA[10993]:=[ ,,,[2644498073,"RPn"],,[11041666320683810,"JB"],]; CONWAYPOLDATA[11003]:=[ ,,,[1089517062,"RPn"],]; CONWAYPOLDATA[11027]:=[ ,,,[1089721223,"RPn"],]; CONWAYPOLDATA[11047]:=[ ,,,[473275577,"RPn"],]; CONWAYPOLDATA[11057]:=[ ,,,[971689163,"RPn"],]; CONWAYPOLDATA[11059]:=[ ,,,[63699850,"RPn"],]; CONWAYPOLDATA[11069]:=[ ,,,[77283760,"RPn"],]; CONWAYPOLDATA[11071]:=[ ,,,[456047706,"RPn"],]; CONWAYPOLDATA[11083]:=[ ,,,[1099433602,"RPn"],]; CONWAYPOLDATA[11087]:=[ ,,,[484878863,"RPn"],]; CONWAYPOLDATA[11093]:=[ ,,,[825618713,"RPn"],]; CONWAYPOLDATA[11113]:=[ ,,,[1814664009,"RPn"],]; CONWAYPOLDATA[11117]:=[ ,,,[583186706,"RPn"],]; CONWAYPOLDATA[11119]:=[ ,,,[859220728,"RPn"],]; CONWAYPOLDATA[11131]:=[ ,,,[1095724511,"RPn"],]; CONWAYPOLDATA[11149]:=[ ,,,[935835921,"RPn"],]; CONWAYPOLDATA[11159]:=[ ,,,[618532218,"RPn"],]; CONWAYPOLDATA[11161]:=[ ,,,[2104629777,"RPn"],]; CONWAYPOLDATA[11171]:=[ ,,,[580735608,"RPn"],]; CONWAYPOLDATA[11173]:=[ ,,,[2348173550,"RPn"],]; CONWAYPOLDATA[11177]:=[ ,,,[1198621483,"RPn"],]; CONWAYPOLDATA[11197]:=[ ,,,[826607330,"RPn"],]; CONWAYPOLDATA[11213]:=[ ,,,[229440408,"RPn"],]; CONWAYPOLDATA[11239]:=[ ,,,[327628092,"RPn"],]; CONWAYPOLDATA[11243]:=[ ,,,[445515123,"RPn"],]; CONWAYPOLDATA[11251]:=[ ,,,[318043281,"RPn"],]; CONWAYPOLDATA[11257]:=[ ,,,[1377327731,"RPn"],]; CONWAYPOLDATA[11261]:=[ ,,,[498378079,"RPn"],]; CONWAYPOLDATA[11273]:=[ ,,,[102347570,"RPn"],]; CONWAYPOLDATA[11279]:=[ ,,,[338674540,"RPn"],]; CONWAYPOLDATA[11287]:=[ ,,,[834617218,"RPn"],]; CONWAYPOLDATA[11299]:=[ ,,,[843199177,"RPn"],]; CONWAYPOLDATA[11311]:=[ ,,,[639648364,"RPn"],]; CONWAYPOLDATA[11317]:=[ ,,,[1152591184,"RPn"],]; CONWAYPOLDATA[11321]:=[ ,,,[963722770,"RPn"],]; CONWAYPOLDATA[11329]:=[ ,,,[736033808,"RPn"],]; CONWAYPOLDATA[11351]:=[ ,,,[349974039,"RPn"],]; CONWAYPOLDATA[11353]:=[ ,,,[1158301185,"RPn"],]; CONWAYPOLDATA[11369]:=[ ,,,[381793761,"RPn"],]; CONWAYPOLDATA[11383]:=[ ,,,[1270513550,"RPn"],]; CONWAYPOLDATA[11393]:=[ ,,,[599351554,"RPn"],]; CONWAYPOLDATA[11399]:=[ ,,,[755160963,"RPn"],]; CONWAYPOLDATA[11411]:=[ ,,,[1039576340,"RPn"],]; CONWAYPOLDATA[11423]:=[ ,,,[521894029,"RPn"],]; CONWAYPOLDATA[11437]:=[ ,,,[473823475,"RPn"],]; CONWAYPOLDATA[11443]:=[ ,,,[1016138402,"RPn"],]; CONWAYPOLDATA[11447]:=[ ,,,[1916410957,"RPn"],]; CONWAYPOLDATA[11467]:=[ ,,,[367826964,"RPn"],]; CONWAYPOLDATA[11471]:=[ ,,,[341044312,"RPn"],]; CONWAYPOLDATA[11483]:=[ ,,,[1927800491,"RPn"],]; CONWAYPOLDATA[11489]:=[ ,,,[131859256,"RPn"],]; CONWAYPOLDATA[11491]:=[ ,,,[364965654,"RPn"],]; CONWAYPOLDATA[11497]:=[ ,,,[1168348141,"RPn"],]; CONWAYPOLDATA[11503]:=[ ,,,[347747196,"RPn"],]; CONWAYPOLDATA[11519]:=[ ,,,[485594971,"RPn"],]; CONWAYPOLDATA[11527]:=[ ,,,[358973839,"RPn"],]; CONWAYPOLDATA[11549]:=[ ,,,[1198266497,"RPn"],]; CONWAYPOLDATA[11551]:=[ ,,,[337243003,"RPn"],]; CONWAYPOLDATA[11579]:=[ ,,,[496692786,"RPn"],]; CONWAYPOLDATA[11587]:=[ ,,,[1200054005,"RPn"],]; CONWAYPOLDATA[11593]:=[ ,,,[1721015634,"RPn"],]; CONWAYPOLDATA[11597]:=[ ,,,[1057356478,"RPn"],]; CONWAYPOLDATA[11617]:=[ ,,,[2907700259,"RPn"],]; CONWAYPOLDATA[11621]:=[ ,,,[932806051,"RPn"],]; CONWAYPOLDATA[11633]:=[ ,,,[640792175,"RPn"],]; CONWAYPOLDATA[11657]:=[ ,,,[893730536,"RPn"],]; CONWAYPOLDATA[11677]:=[ ,,,[2575292290,"RPn"],]; CONWAYPOLDATA[11681]:=[ ,,,[371525889,"RPn"],]; CONWAYPOLDATA[11689]:=[ ,,,[86510296,"RPn"],]; CONWAYPOLDATA[11699]:=[ ,,,[1164459967,"RPn"],]; CONWAYPOLDATA[11701]:=[ ,,,[1718607783,"RPn"],]; CONWAYPOLDATA[11717]:=[ ,,,[522367296,"RPn"],]; CONWAYPOLDATA[11719]:=[ ,,,[673737035,"RPn"],]; CONWAYPOLDATA[11731]:=[ ,,,[502016417,"RPn"],]; CONWAYPOLDATA[11743]:=[ ,,,[1792545467,"RPn"],]; CONWAYPOLDATA[11777]:=[ ,,,[372600729,"RPn"],]; CONWAYPOLDATA[11779]:=[ ,,,[414020073,"RPn"],]; CONWAYPOLDATA[11783]:=[ ,,,[402860775,"RPn"],]; CONWAYPOLDATA[11789]:=[ ,,,[1088207225,"RPn"],]; CONWAYPOLDATA[11801]:=[ ,,,[139121992,"RPn"],]; CONWAYPOLDATA[11807]:=[ ,,,[970393721,"RPn"],]; CONWAYPOLDATA[11813]:=[ ,,,[1329600404,"RPn"],]; CONWAYPOLDATA[11821]:=[ ,,,[511010011,"RPn"],]; CONWAYPOLDATA[11827]:=[ ,,,[1224484793,"RPn"],]; CONWAYPOLDATA[11831]:=[ ,,,[1676026791,"RPn"],]; CONWAYPOLDATA[11833]:=[ ,,,[948556951,"RPn"],]; CONWAYPOLDATA[11839]:=[ ,,,[529120430,"RPn"],]; CONWAYPOLDATA[11863]:=[ ,,,[703606396,"RPn"],]; CONWAYPOLDATA[11867]:=[ ,,,[1078235622,"RPn"],]; CONWAYPOLDATA[11887]:=[ ,,,[2667038645,"RPn"],]; CONWAYPOLDATA[11897]:=[ ,,,[670443541,"RPn"],]; CONWAYPOLDATA[11903]:=[ ,,,[566678029,"RPn"],]; CONWAYPOLDATA[11909]:=[ ,,,[370453265,"RPn"],]; CONWAYPOLDATA[11923]:=[ ,,,[790578366,"RPn"],]; CONWAYPOLDATA[11927]:=[ ,,,[1515289574,"RPn"],]; CONWAYPOLDATA[11933]:=[ ,,,[658952195,"RPn"],]; CONWAYPOLDATA[11939]:=[ ,,,[561407599,"RPn"],]; CONWAYPOLDATA[11941]:=[ ,,,[505868534,"RPn"],]; CONWAYPOLDATA[11953]:=[ ,,,[959586845,"RPn"],]; CONWAYPOLDATA[11959]:=[ ,,,[361412942,"RPn"],]; CONWAYPOLDATA[11969]:=[ ,,,[670886391,"RPn"],]; CONWAYPOLDATA[11971]:=[ ,,,[817427774,"RPn"],]; CONWAYPOLDATA[11981]:=[ ,,,[90744096,"RPn"],]; CONWAYPOLDATA[11987]:=[ ,,,[274993769,"RPn"],]; CONWAYPOLDATA[12007]:=[ ,,,[562624019,"RPn"],]; CONWAYPOLDATA[12011]:=[ ,,,[1410103413,"RPn"],]; CONWAYPOLDATA[12037]:=[ ,,,[963248893,"RPn"],]; CONWAYPOLDATA[12041]:=[ ,,,[686565782,"RPn"],]; CONWAYPOLDATA[12043]:=[ ,,,[401381149,"RPn"],]; CONWAYPOLDATA[12049]:=[ ,,,[5183648499,"RPn"],]; CONWAYPOLDATA[12071]:=[ ,,,[998211356,"RPn"],]; CONWAYPOLDATA[12073]:=[ ,,,[1270864352,"RPn"],]; CONWAYPOLDATA[12097]:=[ ,,,[1832804378,"RPn"],]; CONWAYPOLDATA[12101]:=[ ,,,[264346348,"RPn"],]; CONWAYPOLDATA[12107]:=[ ,,,[582104562,"RPn"],]; CONWAYPOLDATA[12109]:=[ ,,,[1134334799,"RPn"],]; CONWAYPOLDATA[12113]:=[ ,,,[77838141,"RPn"],]; CONWAYPOLDATA[12119]:=[ ,,,[1135429117,"RPn"],]; CONWAYPOLDATA[12143]:=[ ,,,[419103512,"RPn"],]; CONWAYPOLDATA[12149]:=[ ,,,[424729042,"RPn"],]; CONWAYPOLDATA[12157]:=[ ,,,[553471741,"RPn"],]; CONWAYPOLDATA[12161]:=[ ,,,[374023719,"RPn"],]; CONWAYPOLDATA[12163]:=[ ,,,[395917818,"RPn"],]; CONWAYPOLDATA[12197]:=[ ,,,[984968737,"RPn"],]; CONWAYPOLDATA[12203]:=[ ,,,[1266927665,"RPn"],]; CONWAYPOLDATA[12211]:=[ ,,,[992094908,"RPn"],]; CONWAYPOLDATA[12227]:=[ ,,,[380871052,"RPn"],]; CONWAYPOLDATA[12239]:=[ ,,,[440604013,"RPn"],]; CONWAYPOLDATA[12241]:=[ ,,,[2194431836,"RPn"],]; CONWAYPOLDATA[12251]:=[ ,,,[533298283,"RPn"],]; CONWAYPOLDATA[12253]:=[ ,,,[547145464,"RPn"],]; CONWAYPOLDATA[12263]:=[ ,,,[559756903,"RPn"],]; CONWAYPOLDATA[12269]:=[ ,,,[683788179,"RPn"],]; CONWAYPOLDATA[12277]:=[ ,,,[982516035,"RPn"],]; CONWAYPOLDATA[12281]:=[ ,,,[122392449,"RPn"],]; CONWAYPOLDATA[12289]:=[ ,,,[3604167087,"RPn"],]; CONWAYPOLDATA[12301]:=[ ,,,[1046999617,"RPn"],]; CONWAYPOLDATA[12323]:=[ ,,,[394101865,"RPn"],]; CONWAYPOLDATA[12329]:=[ ,,,[1324060629,"RPn"],]; CONWAYPOLDATA[12343]:=[ ,,,[136896220,"RPn"],]; CONWAYPOLDATA[12347]:=[ ,,,[744672266,"RPn"],]; CONWAYPOLDATA[12373]:=[ ,,,[1064226478,"RPn"],]; CONWAYPOLDATA[12377]:=[ ,,,[274917930,"RPn"],]; CONWAYPOLDATA[12379]:=[ ,,,[1379070118,"RPn"],]; CONWAYPOLDATA[12391]:=[ ,,,[586218236,"RPn"],]; CONWAYPOLDATA[12401]:=[ ,,,[153635992,"RPn"],]; CONWAYPOLDATA[12409]:=[ ,,,[2577225217,"RPn"],]; CONWAYPOLDATA[12413]:=[ ,,,[1003082119,"RPn"],]; CONWAYPOLDATA[12421]:=[ ,,,[757842480,"RPn"],]; CONWAYPOLDATA[12433]:=[ ,,,[1795648471,"RPn"],]; CONWAYPOLDATA[12437]:=[ ,,,[595259696,"RPn"],]; CONWAYPOLDATA[12451]:=[ ,,,[1225713796,"RPn"],]; CONWAYPOLDATA[12457]:=[ ,,,[1369310821,"RPn"],]; CONWAYPOLDATA[12473]:=[ ,,,[2617920554,"RPn"],]; CONWAYPOLDATA[12479]:=[ ,,,[2286340008,"RPn"],]; CONWAYPOLDATA[12487]:=[ ,,,[397798362,"RPn"],]; CONWAYPOLDATA[12491]:=[ ,,,[1219084129,"RPn"],]; CONWAYPOLDATA[12497]:=[ ,,,[4012236835,"RPn"],]; CONWAYPOLDATA[12503]:=[ ,,,[1227331994,"RPn"],]; CONWAYPOLDATA[12511]:=[ ,,,[1040902692,"RPn"],]; CONWAYPOLDATA[12517]:=[ ,,,[1075861190,"RPn"],]; CONWAYPOLDATA[12527]:=[ ,,,[286555130,"RPn"],]; CONWAYPOLDATA[12539]:=[ ,,,[1364180507,"RPn"],]; CONWAYPOLDATA[12541]:=[ ,,,[310113862,"RPn"],]; CONWAYPOLDATA[12547]:=[ ,,,[1240509345,"RPn"],]; CONWAYPOLDATA[12553]:=[ ,,,[1068536471,"RPn"],]; CONWAYPOLDATA[12569]:=[ ,,,[157828936,"RPn"],]; CONWAYPOLDATA[12577]:=[ ,,,[2508369467,"RPn"],]; CONWAYPOLDATA[12583]:=[ ,,,[2473893303,"RPn"],]; CONWAYPOLDATA[12589]:=[ ,,,[1426258168,"RPn"],]; CONWAYPOLDATA[12601]:=[ ,,,[3756610131,"RPn"],]; CONWAYPOLDATA[12611]:=[ ,,,[1217175889,"RPn"],]; CONWAYPOLDATA[12613]:=[ ,,,[559361326,"RPn"],]; CONWAYPOLDATA[12619]:=[ ,,,[433273367,"RPn"],]; CONWAYPOLDATA[12637]:=[ ,,,[1079212439,"RPn"],]; CONWAYPOLDATA[12641]:=[ ,,,[462749090,"RPn"],]; CONWAYPOLDATA[12647]:=[ ,,,[1418664583,"RPn"],]; CONWAYPOLDATA[12653]:=[ ,,,[1058258963,"RPn"],]; CONWAYPOLDATA[12659]:=[ ,,,[1559044465,"RPn"],]; CONWAYPOLDATA[12671]:=[ ,,,[1388006696,"RPn"],]; CONWAYPOLDATA[12689]:=[ ,,,[1901814634,"RPn"],]; CONWAYPOLDATA[12697]:=[ ,,,[2348424430,"RPn"],]; CONWAYPOLDATA[12703]:=[ ,,,[1774926678,"RPn"],]; CONWAYPOLDATA[12713]:=[ ,,,[1278991368,"RPn"],]; CONWAYPOLDATA[12721]:=[ ,,,[2415094584,"RPn"],]; CONWAYPOLDATA[12739]:=[ ,,,[1065375311,"RPn"],]; CONWAYPOLDATA[12743]:=[ ,,,[606936352,"RPn"],]; CONWAYPOLDATA[12757]:=[ ,,,[1276682291,"RPn"],]; CONWAYPOLDATA[12763]:=[ ,,,[1458555642,"RPn"],]; CONWAYPOLDATA[12781]:=[ ,,,[581241539,"RPn"],]; CONWAYPOLDATA[12791]:=[ ,,,[651202608,"RPn"],]; CONWAYPOLDATA[12799]:=[ ,,,[780380641,"RPn"],]; CONWAYPOLDATA[12809]:=[ ,,,[163916776,"RPn"],]; CONWAYPOLDATA[12821]:=[ ,,,[1089656792,"RPn"],]; CONWAYPOLDATA[12823]:=[ ,,,[822095356,"RPn"],]; CONWAYPOLDATA[12829]:=[ ,,,[1481159368,"RPn"],]; CONWAYPOLDATA[12841]:=[ ,,,[3125794764,"RPn"],]; CONWAYPOLDATA[12853]:=[ ,,,[1785204587,"RPn"],]; CONWAYPOLDATA[12889]:=[ ,,,[165623663,"RPn"],]; CONWAYPOLDATA[12893]:=[ ,,,[831095676,"RPn"],]; CONWAYPOLDATA[12899]:=[ ,,,[1313311687,"RPn"],]; CONWAYPOLDATA[12907]:=[ ,,,[472654342,"RPn"],]; CONWAYPOLDATA[12911]:=[ ,,,[644478410,"RPn"],]; CONWAYPOLDATA[12917]:=[ ,,,[1139589410,"RPn"],]; CONWAYPOLDATA[12919]:=[ ,,,[825692053,"RPn"],]; CONWAYPOLDATA[12923]:=[ ,,,[1462883602,"RPn"],]; CONWAYPOLDATA[12941]:=[ ,,,[257318846,"RPn"],]; CONWAYPOLDATA[12953]:=[ ,,,[758981038,"RPn"],]; CONWAYPOLDATA[12959]:=[ ,,,[497547853,"RPn"],]; CONWAYPOLDATA[12967]:=[ ,,,[1849470246,"RPn"],]; CONWAYPOLDATA[12973]:=[ ,,,[620848875,"RPn"],]; CONWAYPOLDATA[12979]:=[ ,,,[3534986400,"RPn"],]; CONWAYPOLDATA[12983]:=[ ,,,[1124418686,"RPn"],]; CONWAYPOLDATA[13001]:=[ ,,,[1124313482,"RPn"],]; CONWAYPOLDATA[13003]:=[ ,,,[1183442044,"RPn"],]; CONWAYPOLDATA[13007]:=[ ,,,[676676173,"RPn"],]; CONWAYPOLDATA[13009]:=[ ,,,[2520766946,"RPn"],]; CONWAYPOLDATA[13033]:=[ ,,,[1803988766,"RPn"],]; CONWAYPOLDATA[13037]:=[ ,,,[643819210,"RPn"],]; CONWAYPOLDATA[13043]:=[ ,,,[813778858,"RPn"],]; CONWAYPOLDATA[13049]:=[ ,,,[170119816,"RPn"],]; CONWAYPOLDATA[13063]:=[ ,,,[941424289,"RPn"],]; CONWAYPOLDATA[13093]:=[ ,,,[160520186,"RPn"],]; CONWAYPOLDATA[13099]:=[ ,,,[634358375,"RPn"],]; CONWAYPOLDATA[13103]:=[ ,,,[1195635652,"RPn"],]; CONWAYPOLDATA[13109]:=[ ,,,[659304048,"RPn"],]; CONWAYPOLDATA[13121]:=[ ,,,[860685123,"RPn"],]; CONWAYPOLDATA[13127]:=[ ,,,[1013955739,"RPn"],]; CONWAYPOLDATA[13147]:=[ ,,,[1519319910,"RPn"],]; CONWAYPOLDATA[13151]:=[ ,,,[624501550,"RPn"],]; CONWAYPOLDATA[13159]:=[ ,,,[1140306307,"RPn"],]; CONWAYPOLDATA[13163]:=[ ,,,[825241124,"RPn"],]; CONWAYPOLDATA[13171]:=[ ,,,[292027423,"RPn"],]; CONWAYPOLDATA[13177]:=[ ,,,[2252950757,"RPn"],]; CONWAYPOLDATA[13183]:=[ ,,,[1164810334,"RPn"],]; CONWAYPOLDATA[13187]:=[ ,,,[499127952,"RPn"],]; CONWAYPOLDATA[13217]:=[ ,,,[1333225227,"RPn"],]; CONWAYPOLDATA[13219]:=[ ,,,[469300941,"RPn"],]; CONWAYPOLDATA[13229]:=[ ,,,[688741429,"RPn"],]; CONWAYPOLDATA[13241]:=[ ,,,[175165192,"RPn"],]; CONWAYPOLDATA[13249]:=[ ,,,[129455986,"RPn"],]; CONWAYPOLDATA[13259]:=[ ,,,[448631530,"RPn"],]; CONWAYPOLDATA[13267]:=[ ,,,[1227025032,"RPn"],]; CONWAYPOLDATA[13291]:=[ ,,,[480017758,"RPn"],]; CONWAYPOLDATA[13297]:=[ ,,,[2798220685,"RPn"],]; CONWAYPOLDATA[13309]:=[ ,,,[2082153129,"RPn"],]; CONWAYPOLDATA[13313]:=[ ,,,[4743248834,"RPn"],]; CONWAYPOLDATA[13327]:=[ ,,,[1056551236,"RPn"],]; CONWAYPOLDATA[13331]:=[ ,,,[1599346734,"RPn"],]; CONWAYPOLDATA[13337]:=[ ,,,[4601104959,"RPn"],]; CONWAYPOLDATA[13339]:=[ ,,,[1575215851,"RPn"],]; CONWAYPOLDATA[13367]:=[ ,,,[1037399508,"RPn"],]; CONWAYPOLDATA[13381]:=[ ,,,[1969402209,"RPn"],]; CONWAYPOLDATA[13397]:=[ ,,,[4242829902,"RPn"],]; CONWAYPOLDATA[13399]:=[ ,,,[897612412,"RPn"],]; CONWAYPOLDATA[13411]:=[ ,,,[528152004,"RPn"],]; CONWAYPOLDATA[13417]:=[ ,,,[1572901749,"RPn"],]; CONWAYPOLDATA[13421]:=[ ,,,[2312639625,"RPn"],]; CONWAYPOLDATA[13441]:=[ ,,,[4516256657,"RPn"],]; CONWAYPOLDATA[13451]:=[ ,,,[1443023282,"RPn"],]; CONWAYPOLDATA[13457]:=[ ,,,[356771987,"RPn"],]; CONWAYPOLDATA[13463]:=[ ,,,[1555770822,"RPn"],]; CONWAYPOLDATA[13469]:=[ ,,,[1250125237,"RPn"],]; CONWAYPOLDATA[13477]:=[ ,,,[1928289162,"RPn"],]; CONWAYPOLDATA[13487]:=[ ,,,[727542733,"RPn"],]; CONWAYPOLDATA[13499]:=[ ,,,[522019835,"RPn"],]; CONWAYPOLDATA[13513]:=[ ,,,[2365653350,"RPn"],]; CONWAYPOLDATA[13523]:=[ ,,,[504610747,"RPn"],]; CONWAYPOLDATA[13537]:=[ ,,,[3295785712,"RPn"],]; CONWAYPOLDATA[13553]:=[ ,,,[125433018,"RPn"],]; CONWAYPOLDATA[13567]:=[ ,,,[1241380503,"RPn"],]; CONWAYPOLDATA[13577]:=[ ,,,[153012793,"RPn"],]; CONWAYPOLDATA[13591]:=[ ,,,[477533379,"RPn"],]; CONWAYPOLDATA[13597]:=[ ,,,[2340397227,"RPn"],]; CONWAYPOLDATA[13613]:=[ ,,,[868427724,"RPn"],]; CONWAYPOLDATA[13619]:=[ ,,,[358138845,"RPn"],]; CONWAYPOLDATA[13627]:=[ ,,,[1671160774,"RPn"],]; CONWAYPOLDATA[13633]:=[ ,,,[1237140223,"RPn"],]; CONWAYPOLDATA[13649]:=[ ,,,[186131416,"RPn"],]; CONWAYPOLDATA[13669]:=[ ,,,[1417707679,"RPn"],]; CONWAYPOLDATA[13679]:=[ ,,,[2226790738,"RPn"],]; CONWAYPOLDATA[13681]:=[ ,,,[2608829912,"RPn"],]; CONWAYPOLDATA[13687]:=[ ,,,[1304932270,"RPn"],]; CONWAYPOLDATA[13691]:=[ ,,,[290878988,"RPn"],]; CONWAYPOLDATA[13693]:=[ ,,,[2040982735,"RPn"],]; CONWAYPOLDATA[13697]:=[ ,,,[174486086,"RPn"],]; CONWAYPOLDATA[13709]:=[ ,,,[336555952,"RPn"],]; CONWAYPOLDATA[13711]:=[ ,,,[713301070,"RPn"],]; CONWAYPOLDATA[13721]:=[ ,,,[561202624,"RPn"],]; CONWAYPOLDATA[13723]:=[ ,,,[1694790502,"RPn"],]; CONWAYPOLDATA[13729]:=[ ,,,[5413825238,"RPn"],]; CONWAYPOLDATA[13751]:=[ ,,,[733272086,"RPn"],]; CONWAYPOLDATA[13757]:=[ ,,,[1503337448,"RPn"],]; CONWAYPOLDATA[13759]:=[ ,,,[726406411,"RPn"],]; CONWAYPOLDATA[13763]:=[ ,,,[112526290,"RPn"],]; CONWAYPOLDATA[13781]:=[ ,,,[736387742,"RPn"],]; CONWAYPOLDATA[13789]:=[ ,,,[926179559,"RPn"],]; CONWAYPOLDATA[13799]:=[ ,,,[562971609,"RPn"],]; CONWAYPOLDATA[13807]:=[ ,,,[2386457113,"RPn"],]; CONWAYPOLDATA[13829]:=[ ,,,[946180182,"RPn"],]; CONWAYPOLDATA[13831]:=[ ,,,[676391230,"RPn"],]; CONWAYPOLDATA[13841]:=[ ,,,[134603731,"RPn"],]; CONWAYPOLDATA[13859]:=[ ,,,[122485844,"RPn"],]; CONWAYPOLDATA[13873]:=[ ,,,[1329172135,"RPn"],]; CONWAYPOLDATA[13877]:=[ ,,,[1331650799,"RPn"],]; CONWAYPOLDATA[13879]:=[ ,,,[493884221,"RPn"],]; CONWAYPOLDATA[13883]:=[ ,,,[120837634,"RPn"],]; CONWAYPOLDATA[13901]:=[ ,,,[728759927,"RPn"],]; CONWAYPOLDATA[13903]:=[ ,,,[1091872108,"RPn"],]; CONWAYPOLDATA[13907]:=[ ,,,[944716419,"RPn"],]; CONWAYPOLDATA[13913]:=[ ,,,[1874818492,"RPn"],]; CONWAYPOLDATA[13921]:=[ ,,,[2861781740,"RPn"],]; CONWAYPOLDATA[13931]:=[ ,,,[1728419172,"RPn"],]; CONWAYPOLDATA[13933]:=[ ,,,[759264904,"RPn"],]; CONWAYPOLDATA[13963]:=[ ,,,[517915599,"RPn"],]; CONWAYPOLDATA[13967]:=[ ,,,[1357452735,"RPn"],]; CONWAYPOLDATA[13997]:=[ ,,,[1303134699,"RPn"],]; CONWAYPOLDATA[13999]:=[ ,,,[776860509,"RPn"],]; CONWAYPOLDATA[14009]:=[ ,,,[302202151,"RPn"],]; CONWAYPOLDATA[14011]:=[ ,,,[1761028581,"RPn"],]; CONWAYPOLDATA[14029]:=[ ,,,[1531588023,"RPn"],]; CONWAYPOLDATA[14033]:=[ ,,,[972753530,"RPn"],]; CONWAYPOLDATA[14051]:=[ ,,,[1679600338,"RPn"],]; CONWAYPOLDATA[14057]:=[ ,,,[2527392375,"RPn"],]; CONWAYPOLDATA[14071]:=[ ,,,[582173561,"RPn"],]; CONWAYPOLDATA[14081]:=[ ,,,[529980681,"RPn"],]; CONWAYPOLDATA[14083]:=[ ,,,[514268914,"RPn"],]; CONWAYPOLDATA[14087]:=[ ,,,[1133130111,"RPn"],]; CONWAYPOLDATA[14107]:=[ ,,,[1714945671,"RPn"],]; CONWAYPOLDATA[14143]:=[ ,,,[519585537,"RPn"],]; CONWAYPOLDATA[14149]:=[ ,,,[573444827,"RPn"],]; CONWAYPOLDATA[14153]:=[ ,,,[1536492142,"RPn"],]; CONWAYPOLDATA[14159]:=[ ,,,[914175848,"RPn"],]; CONWAYPOLDATA[14173]:=[ ,,,[1309160012,"RPn"],]; CONWAYPOLDATA[14177]:=[ ,,,[185888827,"RPn"],]; CONWAYPOLDATA[14197]:=[ ,,,[1609499704,"RPn"],]; CONWAYPOLDATA[14207]:=[ ,,,[749334013,"RPn"],]; CONWAYPOLDATA[14221]:=[ ,,,[2169157574,"RPn"],]; CONWAYPOLDATA[14243]:=[ ,,,[1579235356,"RPn"],]; CONWAYPOLDATA[14249]:=[ ,,,[723378986,"RPn"],]; CONWAYPOLDATA[14251]:=[ ,,,[1122579775,"RPn"],]; CONWAYPOLDATA[14281]:=[ ,,,[6710356299,"RPn"],]; CONWAYPOLDATA[14293]:=[ ,,,[1562896677,"RPn"],]; CONWAYPOLDATA[14303]:=[ ,,,[1010077865,"RPn"],]; CONWAYPOLDATA[14321]:=[ ,,,[1613360900,"RPn"],]; CONWAYPOLDATA[14323]:=[ ,,,[1435923724,"RPn"],]; CONWAYPOLDATA[14327]:=[ ,,,[803228933,"RPn"],]; CONWAYPOLDATA[14341]:=[ ,,,[810883165,"RPn"],]; CONWAYPOLDATA[14347]:=[ ,,,[790290151,"RPn"],]; CONWAYPOLDATA[14369]:=[ ,,,[206295736,"RPn"],]; CONWAYPOLDATA[14387]:=[ ,,,[1619688462,"RPn"],]; CONWAYPOLDATA[14389]:=[ ,,,[3901764409,"RPn"],]; CONWAYPOLDATA[14401]:=[ ,,,[4291454808,"RPn"],]; CONWAYPOLDATA[14407]:=[ ,,,[2470570007,"RPn"],]; CONWAYPOLDATA[14411]:=[ ,,,[762774232,"RPn"],]; CONWAYPOLDATA[14419]:=[ ,,,[1373957674,"RPn"],]; CONWAYPOLDATA[14423]:=[ ,,,[765861305,"RPn"],]; CONWAYPOLDATA[14431]:=[ ,,,[792954591,"RPn"],]; CONWAYPOLDATA[14437]:=[ ,,,[1592704282,"RPn"],]; CONWAYPOLDATA[14447]:=[ ,,,[1592030511,"RPn"],]; CONWAYPOLDATA[14449]:=[ ,,,[8334920121,"RPn"],]; CONWAYPOLDATA[14461]:=[ ,,,[733866830,"RPn"],]; CONWAYPOLDATA[14479]:=[ ,,,[1048149292,"RPn"],]; CONWAYPOLDATA[14489]:=[ ,,,[584515241,"RPn"],]; CONWAYPOLDATA[14503]:=[ ,,,[2313591078,"RPn"],]; CONWAYPOLDATA[14519]:=[ ,,,[989513420,"RPn"],]; CONWAYPOLDATA[14533]:=[ ,,,[609601220,"RPn"],]; CONWAYPOLDATA[14537]:=[ ,,,[1006309291,"RPn"],]; CONWAYPOLDATA[14543]:=[ ,,,[540214283,"RPn"],]; CONWAYPOLDATA[14549]:=[ ,,,[199001224,"RPn"],]; CONWAYPOLDATA[14551]:=[ ,,,[1470087533,"RPn"],]; CONWAYPOLDATA[14557]:=[ ,,,[1477011450,"RPn"],]; CONWAYPOLDATA[14561]:=[ ,,,[196209481,"RPn"],]; CONWAYPOLDATA[14563]:=[ ,,,[572151147,"RPn"],]; CONWAYPOLDATA[14591]:=[ ,,,[1273064761,"RPn"],]; CONWAYPOLDATA[14593]:=[ ,,,[3194174217,"RPn"],]; CONWAYPOLDATA[14621]:=[ ,,,[1017022141,"RPn"],]; CONWAYPOLDATA[14627]:=[ ,,,[1607551183,"RPn"],]; CONWAYPOLDATA[14629]:=[ ,,,[124273357,"RPn"],]; CONWAYPOLDATA[14633]:=[ ,,,[2065960108,"RPn"],]; CONWAYPOLDATA[14639]:=[ ,,,[1710859941,"RPn"],]; CONWAYPOLDATA[14653]:=[ ,,,[2711200633,"RPn"],]; CONWAYPOLDATA[14657]:=[ ,,,[179694823,"RPn"],]; CONWAYPOLDATA[14669]:=[ ,,,[382948916,"RPn"],]; CONWAYPOLDATA[14683]:=[ ,,,[858382866,"RPn"],]; CONWAYPOLDATA[14699]:=[ ,,,[1040454018,"RPn"],]; CONWAYPOLDATA[14713]:=[ ,,,[3246923697,"RPn"],]; CONWAYPOLDATA[14717]:=[ ,,,[1442604493,"RPn"],]; CONWAYPOLDATA[14723]:=[ ,,,[1720765350,"RPn"],]; CONWAYPOLDATA[14731]:=[ ,,,[626362130,"RPn"],]; CONWAYPOLDATA[14737]:=[ ,,,[1453362950,"RPn"],]; CONWAYPOLDATA[14741]:=[ ,,,[2126713554,"RPn"],]; CONWAYPOLDATA[14747]:=[ ,,,[366285988,"RPn"],]; CONWAYPOLDATA[14753]:=[ ,,,[1517095252,"RPn"],]; CONWAYPOLDATA[14759]:=[ ,,,[871194269,"RPn"],]; CONWAYPOLDATA[14767]:=[ ,,,[1480805229,"RPn"],]; CONWAYPOLDATA[14771]:=[ ,,,[213101219,"RPn"],]; CONWAYPOLDATA[14779]:=[ ,,,[579839289,"RPn"],]; CONWAYPOLDATA[14783]:=[ ,,,[2363757356,"RPn"],]; CONWAYPOLDATA[14797]:=[ ,,,[829179491,"RPn"],]; CONWAYPOLDATA[14813]:=[ ,,,[1513384960,"RPn"],]; CONWAYPOLDATA[14821]:=[ ,,,[1476260528,"RPn"],]; CONWAYPOLDATA[14827]:=[ ,,,[1891243160,"RPn"],]; CONWAYPOLDATA[14831]:=[ ,,,[1089574257,"RPn"],]; CONWAYPOLDATA[14843]:=[ ,,,[3075009469,"RPn"],]; CONWAYPOLDATA[14851]:=[ ,,,[1981836250,"RPn"],]; CONWAYPOLDATA[14867]:=[ ,,,[1059675161,"RPn"],]; CONWAYPOLDATA[14869]:=[ ,,,[1511850184,"RPn"],]; CONWAYPOLDATA[14879]:=[ ,,,[560432421,"RPn"],]; CONWAYPOLDATA[14887]:=[ ,,,[866676482,"RPn"],]; CONWAYPOLDATA[14891]:=[ ,,,[1688028871,"RPn"],]; CONWAYPOLDATA[14897]:=[ ,,,[392029455,"RPn"],]; CONWAYPOLDATA[14923]:=[ ,,,[2362475055,"RPn"],]; CONWAYPOLDATA[14929]:=[ ,,,[3707034926,"RPn"],]; CONWAYPOLDATA[14939]:=[ ,,,[1754241955,"RPn"],]; CONWAYPOLDATA[14947]:=[ ,,,[1977069586,"RPn"],]; CONWAYPOLDATA[14951]:=[ ,,,[591775550,"RPn"],]; CONWAYPOLDATA[14957]:=[ ,,,[2013301944,"RPn"],]; CONWAYPOLDATA[14969]:=[ ,,,[645672849,"RPn"],]; CONWAYPOLDATA[14983]:=[ ,,,[1122391516,"RPn"],]; CONWAYPOLDATA[15013]:=[ ,,,[1520351499,"RPn"],]; CONWAYPOLDATA[15017]:=[ ,,,[1758445652,"RPn"],]; CONWAYPOLDATA[15031]:=[ ,,,[806368060,"RPn"],]; CONWAYPOLDATA[15053]:=[ ,,,[1121282919,"RPn"],]; CONWAYPOLDATA[15061]:=[ ,,,[2410934760,"RPn"],]; CONWAYPOLDATA[15073]:=[ ,,,[3605401313,"RPn"],]; CONWAYPOLDATA[15077]:=[ ,,,[2204287556,"RPn"],]; CONWAYPOLDATA[15083]:=[ ,,,[117798232,"RPn"],]; CONWAYPOLDATA[15091]:=[ ,,,[343214615,"RPn"],]; CONWAYPOLDATA[15101]:=[ ,,,[220610511,"RPn"],]; CONWAYPOLDATA[15107]:=[ ,,,[189139642,"RPn"],]; CONWAYPOLDATA[15121]:=[ ,,,[5426533765,"RPn"],]; CONWAYPOLDATA[15131]:=[ ,,,[2053079999,"RPn"],]; CONWAYPOLDATA[15137]:=[ ,,,[182310031,"RPn"],]; CONWAYPOLDATA[15139]:=[ ,,,[624180972,"RPn"],]; CONWAYPOLDATA[15149]:=[ ,,,[1811987041,"RPn"],]; CONWAYPOLDATA[15161]:=[ ,,,[229673992,"RPn"],]; CONWAYPOLDATA[15173]:=[ ,,,[1750964202,"RPn"],]; CONWAYPOLDATA[15187]:=[ ,,,[2041345420,"RPn"],]; CONWAYPOLDATA[15193]:=[ ,,,[1524009835,"RPn"],]; CONWAYPOLDATA[15199]:=[ ,,,[1145867815,"RPn"],]; CONWAYPOLDATA[15217]:=[ ,,,[4985576154,"RPn"],]; CONWAYPOLDATA[15227]:=[ ,,,[2054700928,"RPn"],]; CONWAYPOLDATA[15233]:=[ ,,,[456334984,"RPn"],]; CONWAYPOLDATA[15241]:=[ ,,,[3448520117,"RPn"],]; CONWAYPOLDATA[15259]:=[ ,,,[610787254,"RPn"],]; CONWAYPOLDATA[15263]:=[ ,,,[2007069242,"RPn"],]; CONWAYPOLDATA[15269]:=[ ,,,[2313131350,"RPn"],]; CONWAYPOLDATA[15271]:=[ ,,,[1562421834,"RPn"],]; CONWAYPOLDATA[15277]:=[ ,,,[1801601339,"RPn"],]; CONWAYPOLDATA[15287]:=[ ,,,[2034042364,"RPn"],]; CONWAYPOLDATA[15289]:=[ ,,,[3952420557,"RPn"],]; CONWAYPOLDATA[15299]:=[ ,,,[2064263474,"RPn"],]; CONWAYPOLDATA[15307]:=[ ,,,[1400468047,"RPn"],]; CONWAYPOLDATA[15313]:=[ ,,,[4923956407,"RPn"],]; CONWAYPOLDATA[15319]:=[ ,,,[1855590473,"RPn"],]; CONWAYPOLDATA[15329]:=[ ,,,[1795332483,"RPn"],]; CONWAYPOLDATA[15331]:=[ ,,,[2005126161,"RPn"],]; CONWAYPOLDATA[15349]:=[ ,,,[5344521802,"RPn"],]; CONWAYPOLDATA[15359]:=[ ,,,[1585601735,"RPn"],]; CONWAYPOLDATA[15361]:=[ ,,,[131874192,"RPn"],]; CONWAYPOLDATA[15373]:=[ ,,,[1590828788,"RPn"],]; CONWAYPOLDATA[15377]:=[ ,,,[204544857,"RPn"],]; CONWAYPOLDATA[15383]:=[ ,,,[593245400,"RPn"],]; CONWAYPOLDATA[15391]:=[ ,,,[2500329526,"RPn"],]; CONWAYPOLDATA[15401]:=[ ,,,[1634692948,"RPn"],]; CONWAYPOLDATA[15413]:=[ ,,,[854203875,"RPn"],]; CONWAYPOLDATA[15427]:=[ ,,,[673465687,"RPn"],]; CONWAYPOLDATA[15439]:=[ ,,,[843216427,"RPn"],]; CONWAYPOLDATA[15443]:=[ ,,,[930440752,"RPn"],]; CONWAYPOLDATA[15451]:=[ ,,,[1567102227,"RPn"],]; CONWAYPOLDATA[15461]:=[ ,,,[951083417,"RPn"],]; CONWAYPOLDATA[15467]:=[ ,,,[933990267,"RPn"],]; CONWAYPOLDATA[15473]:=[ ,,,[1584295946,"RPn"],]; CONWAYPOLDATA[15493]:=[ ,,,[936830729,"RPn"],]; CONWAYPOLDATA[15497]:=[ ,,,[2396115149,"RPn"],]; CONWAYPOLDATA[15511]:=[ ,,,[1202893564,"RPn"],]; CONWAYPOLDATA[15527]:=[ ,,,[2365709252,"RPn"],]; CONWAYPOLDATA[15541]:=[ ,,,[692615753,"RPn"],]; CONWAYPOLDATA[15551]:=[ ,,,[857684310,"RPn"],]; CONWAYPOLDATA[15559]:=[ ,,,[1641925714,"RPn"],]; CONWAYPOLDATA[15569]:=[ ,,,[628240291,"RPn"],]; CONWAYPOLDATA[15581]:=[ ,,,[2184798984,"RPn"],]; CONWAYPOLDATA[15583]:=[ ,,,[916093409,"RPn"],]; CONWAYPOLDATA[15601]:=[ ,,,[2093108188,"RPn"],]; CONWAYPOLDATA[15607]:=[ ,,,[894421566,"RPn"],]; CONWAYPOLDATA[15619]:=[ ,,,[1699862634,"RPn"],]; CONWAYPOLDATA[15629]:=[ ,,,[2160302898,"RPn"],]; CONWAYPOLDATA[15641]:=[ ,,,[646223559,"RPn"],]; CONWAYPOLDATA[15643]:=[ ,,,[160528471,"RPn"],]; CONWAYPOLDATA[15647]:=[ ,,,[1146048873,"RPn"],]; CONWAYPOLDATA[15649]:=[ ,,,[6827783903,"RPn"],]; CONWAYPOLDATA[15661]:=[ ,,,[3104104168,"RPn"],]; CONWAYPOLDATA[15667]:=[ ,,,[2101900389,"RPn"],]; CONWAYPOLDATA[15671]:=[ ,,,[918571349,"RPn"],]; CONWAYPOLDATA[15679]:=[ ,,,[725232156,"RPn"],]; CONWAYPOLDATA[15683]:=[ ,,,[722280567,"RPn"],]; CONWAYPOLDATA[15727]:=[ ,,,[702226280,"RPn"],]; CONWAYPOLDATA[15731]:=[ ,,,[908842796,"RPn"],]; CONWAYPOLDATA[15733]:=[ ,,,[1207256028,"RPn"],]; CONWAYPOLDATA[15737]:=[ ,,,[1932267548,"RPn"],]; CONWAYPOLDATA[15739]:=[ ,,,[685716754,"RPn"],]; CONWAYPOLDATA[15749]:=[ ,,,[2198103681,"RPn"],]; CONWAYPOLDATA[15761]:=[ ,,,[623237226,"RPn"],]; CONWAYPOLDATA[15767]:=[ ,,,[994330093,"RPn"],]; CONWAYPOLDATA[15773]:=[ ,,,[4916191734,"RPn"],]; CONWAYPOLDATA[15787]:=[ ,,,[2131418659,"RPn"],]; CONWAYPOLDATA[15791]:=[ ,,,[964277444,"RPn"],]; CONWAYPOLDATA[15797]:=[ ,,,[1177697946,"RPn"],]; CONWAYPOLDATA[15803]:=[ ,,,[2208532464,"RPn"],]; CONWAYPOLDATA[15809]:=[ ,,,[1430113761,"RPn"],]; CONWAYPOLDATA[15817]:=[ ,,,[3752488353,"RPn"],]; CONWAYPOLDATA[15823]:=[ ,,,[937560222,"RPn"],]; CONWAYPOLDATA[15859]:=[ ,,,[2243699604,"RPn"],]; CONWAYPOLDATA[15877]:=[ ,,,[1711699375,"RPn"],]; CONWAYPOLDATA[15881]:=[ ,,,[1993716624,"RPn"],]; CONWAYPOLDATA[15887]:=[ ,,,[1462509564,"RPn"],]; CONWAYPOLDATA[15889]:=[ ,,,[4681900428,"RPn"],]; CONWAYPOLDATA[15901]:=[ ,,,[888563791,"RPn"],]; CONWAYPOLDATA[15907]:=[ ,,,[6301080842,"RPn"],]; CONWAYPOLDATA[15913]:=[ ,,,[3211736708,"RPn"],]; CONWAYPOLDATA[15919]:=[ ,,,[1773838257,"RPn"],]; CONWAYPOLDATA[15923]:=[ ,,,[2965388061,"RPn"],]; CONWAYPOLDATA[15937]:=[ ,,,[2176117672,"RPn"],]; CONWAYPOLDATA[15959]:=[ ,,,[2235504813,"RPn"],]; CONWAYPOLDATA[15971]:=[ ,,,[2262675456,"RPn"],]; CONWAYPOLDATA[15973]:=[ ,,,[2544371123,"RPn"],]; CONWAYPOLDATA[15991]:=[ ,,,[1782148989,"RPn"],]; CONWAYPOLDATA[16001]:=[ ,,,[1208427525,"RPn"],]; CONWAYPOLDATA[16007]:=[ ,,,[1455756620,"RPn"],]; CONWAYPOLDATA[16033]:=[ ,,,[6342895300,"RPn"],]; CONWAYPOLDATA[16057]:=[ ,,,[3743978583,"RPn"],]; CONWAYPOLDATA[16061]:=[ ,,,[719099165,"RPn"],]; CONWAYPOLDATA[16063]:=[ ,,,[685906168,"RPn"],]; CONWAYPOLDATA[16067]:=[ ,,,[162212434,"RPn"],]; CONWAYPOLDATA[16069]:=[ ,,,[2568163651,"RPn"],]; CONWAYPOLDATA[16073]:=[ ,,,[1990078498,"RPn"],]; CONWAYPOLDATA[16087]:=[ ,,,[1522554120,"RPn"],]; CONWAYPOLDATA[16091]:=[ ,,,[767186704,"RPn"],]; CONWAYPOLDATA[16097]:=[ ,,,[477791157,"RPn"],]; CONWAYPOLDATA[16103]:=[ ,,,[657115126,"RPn"],]; CONWAYPOLDATA[16111]:=[ ,,,[1489623067,"RPn"],]; CONWAYPOLDATA[16127]:=[ ,,,[1972251470,"RPn"],]; CONWAYPOLDATA[16139]:=[ ,,,[992790587,"RPn"],]; CONWAYPOLDATA[16141]:=[ ,,,[2808872967,"RPn"],]; CONWAYPOLDATA[16183]:=[ ,,,[1004818656,"RPn"],]; CONWAYPOLDATA[16187]:=[ ,,,[761776409,"RPn"],]; CONWAYPOLDATA[16189]:=[ ,,,[980956268,"RPn"],]; CONWAYPOLDATA[16193]:=[ ,,,[710565038,"RPn"],]; CONWAYPOLDATA[16217]:=[ ,,,[674789373,"RPn"],]; CONWAYPOLDATA[16223]:=[ ,,,[3158034077,"RPn"],]; CONWAYPOLDATA[16229]:=[ ,,,[432356791,"RPn"],]; CONWAYPOLDATA[16231]:=[ ,,,[973454228,"RPn"],]; CONWAYPOLDATA[16249]:=[ ,,,[5431520749,"RPn"],]; CONWAYPOLDATA[16253]:=[ ,,,[982103780,"RPn"],]; CONWAYPOLDATA[16267]:=[ ,,,[685898058,"RPn"],]; CONWAYPOLDATA[16273]:=[ ,,,[3859141957,"RPn"],]; CONWAYPOLDATA[16301]:=[ ,,,[952565238,"RPn"],]; CONWAYPOLDATA[16319]:=[ ,,,[3162491655,"RPn"],]; CONWAYPOLDATA[16333]:=[ ,,,[3426222411,"RPn"],]; CONWAYPOLDATA[16339]:=[ ,,,[2297263402,"RPn"],]; CONWAYPOLDATA[16349]:=[ ,,,[1863491720,"RPn"],]; CONWAYPOLDATA[16361]:=[ ,,,[791021631,"RPn"],]; CONWAYPOLDATA[16363]:=[ ,,,[3961956829,"RPn"],]; CONWAYPOLDATA[16369]:=[ ,,,[4475661094,"RPn"],]; CONWAYPOLDATA[16381]:=[ ,,,[1866500285,"RPn"],]; CONWAYPOLDATA[16411]:=[ ,,,[676083970,"RPn"],]; CONWAYPOLDATA[16417]:=[ ,,,[5887957060,"RPn"],]; CONWAYPOLDATA[16421]:=[ ,,,[2078882181,"RPn"],]; CONWAYPOLDATA[16427]:=[ ,,,[2135707126,"RPn"],]; CONWAYPOLDATA[16433]:=[ ,,,[1314902931,"RPn"],]; CONWAYPOLDATA[16447]:=[ ,,,[1573287129,"RPn"],]; CONWAYPOLDATA[16451]:=[ ,,,[1353111208,"RPn"],]; CONWAYPOLDATA[16453]:=[ ,,,[1066187308,"RPn"],]; CONWAYPOLDATA[16477]:=[ ,,,[2443308424,"RPn"],]; CONWAYPOLDATA[16481]:=[ ,,,[1037874500,"RPn"],]; CONWAYPOLDATA[16487]:=[ ,,,[1594259931,"RPn"],]; CONWAYPOLDATA[16493]:=[ ,,,[1776395060,"RPn"],]; CONWAYPOLDATA[16519]:=[ ,,,[1031495920,"RPn"],]; CONWAYPOLDATA[16529]:=[ ,,,[2182654453,"RPn"],]; CONWAYPOLDATA[16547]:=[ ,,,[725767969,"RPn"],]; CONWAYPOLDATA[16553]:=[ ,,,[2680692141,"RPn"],]; CONWAYPOLDATA[16561]:=[ ,,,[3995109403,"RPn"],]; CONWAYPOLDATA[16567]:=[ ,,,[996422218,"RPn"],]; CONWAYPOLDATA[16573]:=[ ,,,[3454558987,"RPn"],]; CONWAYPOLDATA[16603]:=[ ,,,[4672681910,"RPn"],]; CONWAYPOLDATA[16607]:=[ ,,,[3022390970,"RPn"],]; CONWAYPOLDATA[16619]:=[ ,,,[2183553793,"RPn"],]; CONWAYPOLDATA[16631]:=[ ,,,[2382740020,"RPn"],]; CONWAYPOLDATA[16633]:=[ ,,,[4038425883,"RPn"],]; CONWAYPOLDATA[16649]:=[ ,,,[276989416,"RPn"],]; CONWAYPOLDATA[16651]:=[ ,,,[3514493270,"RPn"],]; CONWAYPOLDATA[16657]:=[ ,,,[1897248962,"RPn"],]; CONWAYPOLDATA[16661]:=[ ,,,[2143321033,"RPn"],]; CONWAYPOLDATA[16673]:=[ ,,,[2093045058,"RPn"],]; CONWAYPOLDATA[16691]:=[ ,,,[2228548944,"RPn"],]; CONWAYPOLDATA[16693]:=[ ,,,[977709012,"RPn"],]; CONWAYPOLDATA[16699]:=[ ,,,[1110600396,"RPn"],]; CONWAYPOLDATA[16703]:=[ ,,,[705183962,"RPn"],]; CONWAYPOLDATA[16729]:=[ ,,,[4690778155,"RPn"],]; CONWAYPOLDATA[16741]:=[ ,,,[3231465013,"RPn"],]; CONWAYPOLDATA[16747]:=[ ,,,[836077230,"RPn"],]; CONWAYPOLDATA[16759]:=[ ,,,[1911766169,"RPn"],]; CONWAYPOLDATA[16763]:=[ ,,,[6122920434,"RPn"],]; CONWAYPOLDATA[16787]:=[ ,,,[3833747914,"RPn"],]; CONWAYPOLDATA[16811]:=[ ,,,[813921383,"RPn"],]; CONWAYPOLDATA[16823]:=[ ,,,[2465040549,"RPn"],]; CONWAYPOLDATA[16829]:=[ ,,,[3618335976,"RPn"],]; CONWAYPOLDATA[16831]:=[ ,,,[1095058528,"RPn"],]; CONWAYPOLDATA[16843]:=[ ,,,[3887633890,"RPn"],]; CONWAYPOLDATA[16871]:=[ ,,,[1138387613,"RPn"],]; CONWAYPOLDATA[16879]:=[ ,,,[1870429509,"RPn"],]; CONWAYPOLDATA[16883]:=[ ,,,[144450950,"RPn"],]; CONWAYPOLDATA[16889]:=[ ,,,[1410670617,"RPn"],]; CONWAYPOLDATA[16901]:=[ ,,,[2570675904,"RPn"],]; CONWAYPOLDATA[16903]:=[ ,,,[1641382721,"RPn"],]; CONWAYPOLDATA[16921]:=[ ,,,[4854601075,"RPn"],]; CONWAYPOLDATA[16927]:=[ ,,,[739692979,"RPn"],]; CONWAYPOLDATA[16931]:=[ ,,,[801564335,"RPn"],]; CONWAYPOLDATA[16937]:=[ ,,,[2174185756,"RPn"],]; CONWAYPOLDATA[16943]:=[ ,,,[2162282608,"RPn"],]; CONWAYPOLDATA[16963]:=[ ,,,[2553253799,"RPn"],]; CONWAYPOLDATA[16979]:=[ ,,,[171487902,"RPn"],]; CONWAYPOLDATA[16981]:=[ ,,,[1087514185,"RPn"],]; CONWAYPOLDATA[16987]:=[ ,,,[1100180045,"RPn"],]; CONWAYPOLDATA[16993]:=[ ,,,[4312500543,"RPn"],]; CONWAYPOLDATA[17011]:=[ ,,,[2549659715,"RPn"],]; CONWAYPOLDATA[17021]:=[ ,,,[222651703,"RPn"],]; CONWAYPOLDATA[17027]:=[ ,,,[1398733998,"RPn"],]; CONWAYPOLDATA[17029]:=[ ,,,[3189650913,"RPn"],]; CONWAYPOLDATA[17033]:=[ ,,,[536232909,"RPn"],]; CONWAYPOLDATA[17041]:=[ ,,,[277614938,"RPn"],]; CONWAYPOLDATA[17047]:=[ ,,,[772587090,"RPn"],]; CONWAYPOLDATA[17053]:=[ ,,,[3151718409,"RPn"],]; CONWAYPOLDATA[17077]:=[ ,,,[10650275976,"RPn"],]; CONWAYPOLDATA[17093]:=[ ,,,[512550700,"RPn"],]; CONWAYPOLDATA[17099]:=[ ,,,[815365817,"RPn"],]; CONWAYPOLDATA[17107]:=[ ,,,[874783555,"RPn"],]; CONWAYPOLDATA[17117]:=[ ,,,[4348060343,"RPn"],]; CONWAYPOLDATA[17123]:=[ ,,,[2295475136,"RPn"],]; CONWAYPOLDATA[17137]:=[ ,,,[1960215750,"RPn"],]; CONWAYPOLDATA[17159]:=[ ,,,[1172697544,"RPn"],]; CONWAYPOLDATA[17167]:=[ ,,,[778162946,"RPn"],]; CONWAYPOLDATA[17183]:=[ ,,,[2258997466,"RPn"],]; CONWAYPOLDATA[17189]:=[ ,,,[447309349,"RPn"],]; CONWAYPOLDATA[17191]:=[ ,,,[1081623341,"RPn"],]; CONWAYPOLDATA[17203]:=[ ,,,[2648522273,"RPn"],]; CONWAYPOLDATA[17207]:=[ ,,,[1184254573,"RPn"],]; CONWAYPOLDATA[17209]:=[ ,,,[150595973,"RPn"],]; CONWAYPOLDATA[17231]:=[ ,,,[1952031079,"RPn"],]; CONWAYPOLDATA[17239]:=[ ,,,[1063853174,"RPn"],]; CONWAYPOLDATA[17257]:=[ ,,,[3187316134,"RPn"],]; CONWAYPOLDATA[17291]:=[ ,,,[456586152,"RPn"],]; CONWAYPOLDATA[17293]:=[ ,,,[2334987332,"RPn"],]; CONWAYPOLDATA[17299]:=[ ,,,[2680428155,"RPn"],]; CONWAYPOLDATA[17317]:=[ ,,,[2053744251,"RPn"],]; CONWAYPOLDATA[17321]:=[ ,,,[792522358,"RPn"],]; CONWAYPOLDATA[17327]:=[ ,,,[3510814072,"RPn"],]; CONWAYPOLDATA[17333]:=[ ,,,[2073806787,"RPn"],]; CONWAYPOLDATA[17341]:=[ ,,,[3595205490,"RPn"],]; CONWAYPOLDATA[17351]:=[ ,,,[1056727964,"RPn"],]; CONWAYPOLDATA[17359]:=[ ,,,[1156126762,"RPn"],]; CONWAYPOLDATA[17377]:=[ ,,,[5365426789,"RPn"],]; CONWAYPOLDATA[17383]:=[ ,,,[1208605229,"RPn"],]; CONWAYPOLDATA[17387]:=[ ,,,[2617143403,"RPn"],]; CONWAYPOLDATA[17389]:=[ ,,,[3872895471,"RPn"],]; CONWAYPOLDATA[17393]:=[ ,,,[2989926275,"RPn"],]; CONWAYPOLDATA[17401]:=[ ,,,[2576339868,"RPn"],]; CONWAYPOLDATA[17417]:=[ ,,,[2043937204,"RPn"],]; CONWAYPOLDATA[17419]:=[ ,,,[862536626,"RPn"],]; CONWAYPOLDATA[17431]:=[ ,,,[1202965606,"RPn"],]; CONWAYPOLDATA[17443]:=[ ,,,[476036915,"RPn"],]; CONWAYPOLDATA[17449]:=[ ,,,[6055553321,"RPn"],]; CONWAYPOLDATA[17467]:=[ ,,,[848302325,"RPn"],]; CONWAYPOLDATA[17471]:=[ ,,,[1696346756,"RPn"],]; CONWAYPOLDATA[17477]:=[ ,,,[2024623067,"RPn"],]; CONWAYPOLDATA[17483]:=[ ,,,[1207113737,"RPn"],]; CONWAYPOLDATA[17489]:=[ ,,,[2057248562,"RPn"],]; CONWAYPOLDATA[17491]:=[ ,,,[1112969824,"RPn"],]; CONWAYPOLDATA[17497]:=[ ,,,[7242638197,"RPn"],]; CONWAYPOLDATA[17509]:=[ ,,,[3937809120,"RPn"],]; CONWAYPOLDATA[17519]:=[ ,,,[1212279775,"RPn"],]; CONWAYPOLDATA[17539]:=[ ,,,[221956048,"RPn"],]; CONWAYPOLDATA[17551]:=[ ,,,[793199897,"RPn"],]; CONWAYPOLDATA[17569]:=[ ,,,[6068033938,"RPn"],]; CONWAYPOLDATA[17573]:=[ ,,,[578362578,"RPn"],]; CONWAYPOLDATA[17579]:=[ ,,,[2380231760,"RPn"],]; CONWAYPOLDATA[17581]:=[ ,,,[1186260404,"RPn"],]; CONWAYPOLDATA[17597]:=[ ,,,[1162510613,"RPn"],]; CONWAYPOLDATA[17599]:=[ ,,,[3306852106,"RPn"],]; CONWAYPOLDATA[17609]:=[ ,,,[309865576,"RPn"],]; CONWAYPOLDATA[17623]:=[ ,,,[1110125642,"RPn"],]; CONWAYPOLDATA[17627]:=[ ,,,[1412768798,"RPn"],]; CONWAYPOLDATA[17657]:=[ ,,,[915815622,"RPn"],]; CONWAYPOLDATA[17659]:=[ ,,,[1103157733,"RPn"],]; CONWAYPOLDATA[17669]:=[ ,,,[2105190676,"RPn"],]; CONWAYPOLDATA[17681]:=[ ,,,[312405592,"RPn"],]; CONWAYPOLDATA[17683]:=[ ,,,[1744976128,"RPn"],]; CONWAYPOLDATA[17707]:=[ ,,,[795327615,"RPn"],]; CONWAYPOLDATA[17713]:=[ ,,,[3956304835,"RPn"],]; CONWAYPOLDATA[17729]:=[ ,,,[314104696,"RPn"],]; CONWAYPOLDATA[17737]:=[ ,,,[6519606834,"RPn"],]; CONWAYPOLDATA[17747]:=[ ,,,[2709434492,"RPn"],]; CONWAYPOLDATA[17749]:=[ ,,,[4963774087,"RPn"],]; CONWAYPOLDATA[17761]:=[ ,,,[10358588200,"RPn"],]; CONWAYPOLDATA[17783]:=[ ,,,[2074902662,"RPn"],]; CONWAYPOLDATA[17789]:=[ ,,,[5880314053,"RPn"],]; CONWAYPOLDATA[17791]:=[ ,,,[2114318025,"RPn"],]; CONWAYPOLDATA[17807]:=[ ,,,[4432963620,"RPn"],]; CONWAYPOLDATA[17827]:=[ ,,,[3696000604,"RPn"],]; CONWAYPOLDATA[17837]:=[ ,,,[2483284979,"RPn"],]; CONWAYPOLDATA[17839]:=[ ,,,[1265017013,"RPn"],]; CONWAYPOLDATA[17851]:=[ ,,,[2796055685,"RPn"],]; CONWAYPOLDATA[17863]:=[ ,,,[1246337242,"RPn"],]; CONWAYPOLDATA[17881]:=[ ,,,[9441686556,"RPn"],]; CONWAYPOLDATA[17891]:=[ ,,,[3739075874,"RPn"],]; CONWAYPOLDATA[17903]:=[ ,,,[2237284206,"RPn"],]; CONWAYPOLDATA[17909]:=[ ,,,[1192488676,"RPn"],]; CONWAYPOLDATA[17911]:=[ ,,,[1141342656,"RPn"],]; CONWAYPOLDATA[17921]:=[ ,,,[606177828,"RPn"],]; CONWAYPOLDATA[17923]:=[ ,,,[869570193,"RPn"],]; CONWAYPOLDATA[17929]:=[ ,,,[602647488,"RPn"],]; CONWAYPOLDATA[17939]:=[ ,,,[489824397,"RPn"],]; CONWAYPOLDATA[17957]:=[ ,,,[287832755,"RPn"],]; CONWAYPOLDATA[17959]:=[ ,,,[1577338976,"RPn"],]; CONWAYPOLDATA[17971]:=[ ,,,[2128503214,"RPn"],]; CONWAYPOLDATA[17977]:=[ ,,,[2151936790,"RPn"],]; CONWAYPOLDATA[17981]:=[ ,,,[1226142373,"RPn"],]; CONWAYPOLDATA[17987]:=[ ,,,[576609264,"RPn"],]; CONWAYPOLDATA[17989]:=[ ,,,[3176695501,"RPn"],]; CONWAYPOLDATA[18013]:=[ ,,,[2234692782,"RPn"],]; CONWAYPOLDATA[18041]:=[ ,,,[325261192,"RPn"],]; CONWAYPOLDATA[18043]:=[ ,,,[2852886990,"RPn"],]; CONWAYPOLDATA[18047]:=[ ,,,[1502611272,"RPn"],]; CONWAYPOLDATA[18049]:=[ ,,,[5161454494,"RPn"],]; CONWAYPOLDATA[18059]:=[ ,,,[1193988846,"RPn"],]; CONWAYPOLDATA[18061]:=[ ,,,[826688098,"RPn"],]; CONWAYPOLDATA[18077]:=[ ,,,[554620439,"RPn"],]; CONWAYPOLDATA[18089]:=[ ,,,[820752200,"RPn"],]; CONWAYPOLDATA[18097]:=[ ,,,[7799807005,"RPn"],]; CONWAYPOLDATA[18119]:=[ ,,,[1313047709,"RPn"],]; CONWAYPOLDATA[18121]:=[ ,,,[2946873285,"RPn"],]; CONWAYPOLDATA[18127]:=[ ,,,[4271446283,"RPn"],]; CONWAYPOLDATA[18131]:=[ ,,,[880260057,"RPn"],]; CONWAYPOLDATA[18133]:=[ ,,,[2544531363,"RPn"],]; CONWAYPOLDATA[18143]:=[ ,,,[1276741058,"RPn"],]; CONWAYPOLDATA[18149]:=[ ,,,[1288306767,"RPn"],]; CONWAYPOLDATA[18169]:=[ ,,,[12537900010,"RPn"],]; CONWAYPOLDATA[18181]:=[ ,,,[4144177142,"RPn"],]; CONWAYPOLDATA[18191]:=[ ,,,[1600808029,"RPn"],]; CONWAYPOLDATA[18199]:=[ ,,,[1236840449,"RPn"],]; CONWAYPOLDATA[18211]:=[ ,,,[2527741440,"RPn"],]; CONWAYPOLDATA[18217]:=[ ,,,[6852852850,"RPn"],]; CONWAYPOLDATA[18223]:=[ ,,,[5617057523,"RPn"],]; CONWAYPOLDATA[18229]:=[ ,,,[2321153259,"RPn"],]; CONWAYPOLDATA[18233]:=[ ,,,[2172224924,"RPn"],]; CONWAYPOLDATA[18251]:=[ ,,,[1210552330,"RPn"],]; CONWAYPOLDATA[18253]:=[ ,,,[1216836250,"RPn"],]; CONWAYPOLDATA[18257]:=[ ,,,[4634101287,"RPn"],]; CONWAYPOLDATA[18269]:=[ ,,,[515295416,"RPn"],]; CONWAYPOLDATA[18287]:=[ ,,,[2595949377,"RPn"],]; CONWAYPOLDATA[18289]:=[ ,,,[5529313383,"RPn"],]; CONWAYPOLDATA[18301]:=[ ,,,[2344413009,"RPn"],]; CONWAYPOLDATA[18307]:=[ ,,,[978417626,"RPn"],]; CONWAYPOLDATA[18311]:=[ ,,,[2284169086,"RPn"],]; CONWAYPOLDATA[18313]:=[ ,,,[4672543647,"RPn"],]; CONWAYPOLDATA[18329]:=[ ,,,[335732296,"RPn"],]; CONWAYPOLDATA[18341]:=[ ,,,[933795336,"RPn"],]; CONWAYPOLDATA[18353]:=[ ,,,[303466858,"RPn"],]; CONWAYPOLDATA[18367]:=[ ,,,[1867538196,"RPn"],]; CONWAYPOLDATA[18371]:=[ ,,,[634148560,"RPn"],]; CONWAYPOLDATA[18379]:=[ ,,,[1645563768,"RPn"],]; CONWAYPOLDATA[18397]:=[ ,,,[2260237029,"RPn"],]; CONWAYPOLDATA[18401]:=[ ,,,[911162320,"RPn"],]; CONWAYPOLDATA[18413]:=[ ,,,[589952522,"RPn"],]; CONWAYPOLDATA[18427]:=[ ,,,[2558588952,"RPn"],]; CONWAYPOLDATA[18433]:=[ ,,,[2323313758,"RPn"],]; CONWAYPOLDATA[18439]:=[ ,,,[1699909852,"RPn"],]; CONWAYPOLDATA[18443]:=[ ,,,[956380210,"RPn"],]; CONWAYPOLDATA[18451]:=[ ,,,[319460617,"RPn"],]; CONWAYPOLDATA[18457]:=[ ,,,[2239775412,"RPn"],]; CONWAYPOLDATA[18461]:=[ ,,,[329307320,"RPn"],]; CONWAYPOLDATA[18481]:=[ ,,,[5746796330,"RPn"],]; CONWAYPOLDATA[18493]:=[ ,,,[1242877546,"RPn"],]; CONWAYPOLDATA[18503]:=[ ,,,[1979672981,"RPn"],]; CONWAYPOLDATA[18517]:=[ ,,,[1597072739,"RPn"],]; CONWAYPOLDATA[18521]:=[ ,,,[342805192,"RPn"],]; CONWAYPOLDATA[18523]:=[ ,,,[934374215,"RPn"],]; CONWAYPOLDATA[18539]:=[ ,,,[1996780079,"RPn"],]; CONWAYPOLDATA[18541]:=[ ,,,[891080466,"RPn"],]; CONWAYPOLDATA[18553]:=[ ,,,[3626944528,"RPn"],]; CONWAYPOLDATA[18583]:=[ ,,,[3798458118,"RPn"],]; CONWAYPOLDATA[18587]:=[ ,,,[2660598943,"RPn"],]; CONWAYPOLDATA[18593]:=[ ,,,[3419736121,"RPn"],]; CONWAYPOLDATA[18617]:=[ ,,,[584164229,"RPn"],]; CONWAYPOLDATA[18637]:=[ ,,,[3125909464,"RPn"],]; CONWAYPOLDATA[18661]:=[ ,,,[1302948352,"RPn"],]; CONWAYPOLDATA[18671]:=[ ,,,[1243469936,"RPn"],]; CONWAYPOLDATA[18679]:=[ ,,,[1368124682,"RPn"],]; CONWAYPOLDATA[18691]:=[ ,,,[1000734834,"RPn"],]; CONWAYPOLDATA[18701]:=[ ,,,[202793646,"RPn"],]; CONWAYPOLDATA[18713]:=[ ,,,[2421162795,"RPn"],]; CONWAYPOLDATA[18719]:=[ ,,,[1959167985,"RPn"],]; CONWAYPOLDATA[18731]:=[ ,,,[2802363643,"RPn"],]; CONWAYPOLDATA[18743]:=[ ,,,[2768865909,"RPn"],]; CONWAYPOLDATA[18749]:=[ ,,,[6308588526,"RPn"],]; CONWAYPOLDATA[18757]:=[ ,,,[2310018337,"RPn"],]; CONWAYPOLDATA[18773]:=[ ,,,[4435121252,"RPn"],]; CONWAYPOLDATA[18787]:=[ ,,,[4536609614,"RPn"],]; CONWAYPOLDATA[18793]:=[ ,,,[2392705972,"RPn"],]; CONWAYPOLDATA[18797]:=[ ,,,[1766560860,"RPn"],]; CONWAYPOLDATA[18803]:=[ ,,,[2086437294,"RPn"],]; CONWAYPOLDATA[18839]:=[ ,,,[989292414,"RPn"],]; CONWAYPOLDATA[18859]:=[ ,,,[3037487119,"RPn"],]; CONWAYPOLDATA[18869]:=[ ,,,[288997606,"RPn"],]; CONWAYPOLDATA[18899]:=[ ,,,[2799282084,"RPn"],]; CONWAYPOLDATA[18911]:=[ ,,,[2837746852,"RPn"],]; CONWAYPOLDATA[18913]:=[ ,,,[3772973290,"RPn"],]; CONWAYPOLDATA[18917]:=[ ,,,[1387410616,"RPn"],]; CONWAYPOLDATA[18919]:=[ ,,,[1024274663,"RPn"],]; CONWAYPOLDATA[18947]:=[ ,,,[1720993906,"RPn"],]; CONWAYPOLDATA[18959]:=[ ,,,[937219219,"RPn"],]; CONWAYPOLDATA[18973]:=[ ,,,[2814777363,"RPn"],]; CONWAYPOLDATA[18979]:=[ ,,,[3075243288,"RPn"],]; CONWAYPOLDATA[19001]:=[ ,,,[360809992,"RPn"],]; CONWAYPOLDATA[19009]:=[ ,,,[7518002496,"RPn"],]; CONWAYPOLDATA[19013]:=[ ,,,[917168109,"RPn"],]; CONWAYPOLDATA[19031]:=[ ,,,[1405496454,"RPn"],]; CONWAYPOLDATA[19037]:=[ ,,,[2482957838,"RPn"],]; CONWAYPOLDATA[19051]:=[ ,,,[3261912222,"RPn"],]; CONWAYPOLDATA[19069]:=[ ,,,[2754974708,"RPn"],]; CONWAYPOLDATA[19073]:=[ ,,,[296985686,"RPn"],]; CONWAYPOLDATA[19079]:=[ ,,,[1656247997,"RPn"],]; CONWAYPOLDATA[19081]:=[ ,,,[3267621267,"RPn"],]; CONWAYPOLDATA[19087]:=[ ,,,[6847556704,"RPn"],]; CONWAYPOLDATA[19121]:=[ ,,,[240446581,"RPn"],]; CONWAYPOLDATA[19139]:=[ ,,,[3285171074,"RPn"],]; CONWAYPOLDATA[19141]:=[ ,,,[2752609789,"RPn"],]; CONWAYPOLDATA[19157]:=[ ,,,[1348940157,"RPn"],]; CONWAYPOLDATA[19163]:=[ ,,,[2895989214,"RPn"],]; CONWAYPOLDATA[19181]:=[ ,,,[2460039976,"RPn"],]; CONWAYPOLDATA[19183]:=[ ,,,[941348179,"RPn"],]; CONWAYPOLDATA[19207]:=[ ,,,[3654688758,"RPn"],]; CONWAYPOLDATA[19211]:=[ ,,,[2920994134,"RPn"],]; CONWAYPOLDATA[19213]:=[ ,,,[621252360,"RPn"],]; CONWAYPOLDATA[19219]:=[ ,,,[1039555712,"RPn"],]; CONWAYPOLDATA[19231]:=[ ,,,[3948432002,"RPn"],]; CONWAYPOLDATA[19237]:=[ ,,,[2421688221,"RPn"],]; CONWAYPOLDATA[19249]:=[ ,,,[204751620,"RPn"],]; CONWAYPOLDATA[19259]:=[ ,,,[2951461011,"RPn"],]; CONWAYPOLDATA[19267]:=[ ,,,[2080335061,"RPn"],]; CONWAYPOLDATA[19273]:=[ ,,,[6940496400,"RPn"],]; CONWAYPOLDATA[19289]:=[ ,,,[660262473,"RPn"],]; CONWAYPOLDATA[19301]:=[ ,,,[2561879635,"RPn"],]; CONWAYPOLDATA[19309]:=[ ,,,[1108838640,"RPn"],]; CONWAYPOLDATA[19319]:=[ ,,,[1480299067,"RPn"],]; CONWAYPOLDATA[19333]:=[ ,,,[1311183395,"RPn"],]; CONWAYPOLDATA[19373]:=[ ,,,[645527735,"RPn"],]; CONWAYPOLDATA[19379]:=[ ,,,[1711495145,"RPn"],]; CONWAYPOLDATA[19381]:=[ ,,,[1736033701,"RPn"],]; CONWAYPOLDATA[19387]:=[ ,,,[4022104570,"RPn"],]; CONWAYPOLDATA[19391]:=[ ,,,[2469366297,"RPn"],]; CONWAYPOLDATA[19403]:=[ ,,,[960254472,"RPn"],]; CONWAYPOLDATA[19417]:=[ ,,,[2562946920,"RPn"],]; CONWAYPOLDATA[19421]:=[ ,,,[648001089,"RPn"],]; CONWAYPOLDATA[19423]:=[ ,,,[2175220619,"RPn"],]; CONWAYPOLDATA[19427]:=[ ,,,[7778357105,"RPn"],]; CONWAYPOLDATA[19429]:=[ ,,,[217818525,"RPn"],]; CONWAYPOLDATA[19433]:=[ ,,,[257953645,"RPn"],]; CONWAYPOLDATA[19441]:=[ ,,,[5564266946,"RPn"],]; CONWAYPOLDATA[19447]:=[ ,,,[2251962603,"RPn"],]; CONWAYPOLDATA[19457]:=[ ,,,[750495407,"RPn"],]; CONWAYPOLDATA[19463]:=[ ,,,[1460386747,"RPn"],]; CONWAYPOLDATA[19469]:=[ ,,,[4878950871,"RPn"],]; CONWAYPOLDATA[19471]:=[ ,,,[2566219398,"RPn"],]; CONWAYPOLDATA[19477]:=[ ,,,[2559102513,"RPn"],]; CONWAYPOLDATA[19483]:=[ ,,,[7889387573,"RPn"],]; CONWAYPOLDATA[19489]:=[ ,,,[8631463740,"RPn"],]; CONWAYPOLDATA[19501]:=[ ,,,[2980571844,"RPn"],]; CONWAYPOLDATA[19507]:=[ ,,,[1100975082,"RPn"],]; CONWAYPOLDATA[19531]:=[ ,,,[3432905290,"RPn"],]; CONWAYPOLDATA[19541]:=[ ,,,[4866138904,"RPn"],]; CONWAYPOLDATA[19543]:=[ ,,,[1020887237,"RPn"],]; CONWAYPOLDATA[19553]:=[ ,,,[1818839616,"RPn"],]; CONWAYPOLDATA[19559]:=[ ,,,[1480753226,"RPn"],]; CONWAYPOLDATA[19571]:=[ ,,,[3675942648,"RPn"],]; CONWAYPOLDATA[19577]:=[ ,,,[1885304257,"RPn"],]; CONWAYPOLDATA[19583]:=[ ,,,[1139867686,"RPn"],]; CONWAYPOLDATA[19597]:=[ ,,,[4980283597,"RPn"],]; CONWAYPOLDATA[19603]:=[ ,,,[3458361262,"RPn"],]; CONWAYPOLDATA[19609]:=[ ,,,[383748143,"RPn"],]; CONWAYPOLDATA[19661]:=[ ,,,[1892351591,"RPn"],]; CONWAYPOLDATA[19681]:=[ ,,,[11904210309,"RPn"],]; CONWAYPOLDATA[19687]:=[ ,,,[1008663450,"RPn"],]; CONWAYPOLDATA[19697]:=[ ,,,[1932039339,"RPn"],]; CONWAYPOLDATA[19699]:=[ ,,,[2576136732,"RPn"],]; CONWAYPOLDATA[19709]:=[ ,,,[3713904835,"RPn"],]; CONWAYPOLDATA[19717]:=[ ,,,[2540574886,"RPn"],]; CONWAYPOLDATA[19727]:=[ ,,,[1556539213,"RPn"],]; CONWAYPOLDATA[19739]:=[ ,,,[1047430298,"RPn"],]; CONWAYPOLDATA[19751]:=[ ,,,[1423829846,"RPn"],]; CONWAYPOLDATA[19753]:=[ ,,,[5852497857,"RPn"],]; CONWAYPOLDATA[19759]:=[ ,,,[1401347801,"RPn"],]; CONWAYPOLDATA[19763]:=[ ,,,[224527445,"RPn"],]; CONWAYPOLDATA[19777]:=[ ,,,[5084290948,"RPn"],]; CONWAYPOLDATA[19793]:=[ ,,,[1103479546,"RPn"],]; CONWAYPOLDATA[19801]:=[ ,,,[9729280766,"RPn"],]; CONWAYPOLDATA[19813]:=[ ,,,[1551100333,"RPn"],]; CONWAYPOLDATA[19819]:=[ ,,,[1114144907,"RPn"],]; CONWAYPOLDATA[19841]:=[ ,,,[2958253421,"RPn"],]; CONWAYPOLDATA[19843]:=[ ,,,[4238821993,"RPn"],]; CONWAYPOLDATA[19853]:=[ ,,,[312347251,"RPn"],]; CONWAYPOLDATA[19861]:=[ ,,,[388203117,"RPn"],]; CONWAYPOLDATA[19867]:=[ ,,,[3504757339,"RPn"],]; CONWAYPOLDATA[19889]:=[ ,,,[395333656,"RPn"],]; CONWAYPOLDATA[19891]:=[ ,,,[3397024764,"RPn"],]; CONWAYPOLDATA[19913]:=[ ,,,[3771223508,"RPn"],]; CONWAYPOLDATA[19919]:=[ ,,,[2603931201,"RPn"],]; CONWAYPOLDATA[19927]:=[ ,,,[3118555579,"RPn"],]; CONWAYPOLDATA[19937]:=[ ,,,[3413234340,"RPn"],]; CONWAYPOLDATA[19949]:=[ ,,,[1558156545,"RPn"],]; CONWAYPOLDATA[19961]:=[ ,,,[1839945103,"RPn"],]; CONWAYPOLDATA[19963]:=[ ,,,[4683858803,"RPn"],]; CONWAYPOLDATA[19973]:=[ ,,,[2999505196,"RPn"],]; CONWAYPOLDATA[19979]:=[ ,,,[3140678823,"RPn"],]; CONWAYPOLDATA[19991]:=[ ,,,[1473616585,"RPn"],]; CONWAYPOLDATA[19993]:=[ ,,,[3410026083,"RPn"],]; CONWAYPOLDATA[19997]:=[ ,,,[1533929878,"RPn"],]; CONWAYPOLDATA[20011]:=[ ,,,[1511931117,"RPn"],]; CONWAYPOLDATA[20021]:=[ ,,,[2004122124,"RPn"],]; CONWAYPOLDATA[20023]:=[ ,,,[2004522556,"RPn"],]; CONWAYPOLDATA[20029]:=[ ,,,[2762419711,"RPn"],]; CONWAYPOLDATA[20047]:=[ ,,,[2626638131,"RPn"],]; CONWAYPOLDATA[20051]:=[ ,,,[2720559784,"RPn"],]; CONWAYPOLDATA[20063]:=[ ,,,[2363441468,"RPn"],]; CONWAYPOLDATA[20071]:=[ ,,,[1480517247,"RPn"],]; CONWAYPOLDATA[20089]:=[ ,,,[1132155780,"RPn"],]; CONWAYPOLDATA[20101]:=[ ,,,[8016580321,"RPn"],]; CONWAYPOLDATA[20107]:=[ ,,,[3638482294,"RPn"],]; CONWAYPOLDATA[20113]:=[ ,,,[6869494595,"RPn"],]; CONWAYPOLDATA[20117]:=[ ,,,[1155258961,"RPn"],]; CONWAYPOLDATA[20123]:=[ ,,,[3644275302,"RPn"],]; CONWAYPOLDATA[20129]:=[ ,,,[1907202624,"RPn"],]; CONWAYPOLDATA[20143]:=[ ,,,[1534292315,"RPn"],]; CONWAYPOLDATA[20147]:=[ ,,,[1142314759,"RPn"],]; CONWAYPOLDATA[20149]:=[ ,,,[1446718351,"RPn"],]; CONWAYPOLDATA[20161]:=[ ,,,[9162489039,"RPn"],]; CONWAYPOLDATA[20173]:=[ ,,,[1475997893,"RPn"],]; CONWAYPOLDATA[20177]:=[ ,,,[3920734112,"RPn"],]; CONWAYPOLDATA[20183]:=[ ,,,[791234154,"RPn"],]; CONWAYPOLDATA[20201]:=[ ,,,[303095810,"RPn"],]; CONWAYPOLDATA[20219]:=[ ,,,[1040146238,"RPn"],]; CONWAYPOLDATA[20231]:=[ ,,,[1614696832,"RPn"],]; CONWAYPOLDATA[20233]:=[ ,,,[4425624794,"RPn"],]; CONWAYPOLDATA[20249]:=[ ,,,[409779016,"RPn"],]; CONWAYPOLDATA[20261]:=[ ,,,[1603881023,"RPn"],]; CONWAYPOLDATA[20269]:=[ ,,,[2852030723,"RPn"],]; CONWAYPOLDATA[20287]:=[ ,,,[1470462626,"RPn"],]; CONWAYPOLDATA[20297]:=[ ,,,[4784104388,"RPn"],]; CONWAYPOLDATA[20323]:=[ ,,,[3694965278,"RPn"],]; CONWAYPOLDATA[20327]:=[ ,,,[1652666413,"RPn"],]; CONWAYPOLDATA[20333]:=[ ,,,[1139562988,"RPn"],]; CONWAYPOLDATA[20341]:=[ ,,,[1451391375,"RPn"],]; CONWAYPOLDATA[20347]:=[ ,,,[1054198420,"RPn"],]; CONWAYPOLDATA[20353]:=[ ,,,[6622886558,"RPn"],]; CONWAYPOLDATA[20357]:=[ ,,,[8123949420,"RPn"],]; CONWAYPOLDATA[20359]:=[ ,,,[2050130952,"RPn"],]; CONWAYPOLDATA[20369]:=[ ,,,[1121557881,"RPn"],]; CONWAYPOLDATA[20389]:=[ ,,,[1053907416,"RPn"],]; CONWAYPOLDATA[20393]:=[ ,,,[3161486007,"RPn"],]; CONWAYPOLDATA[20399]:=[ ,,,[2295642270,"RPn"],]; CONWAYPOLDATA[20407]:=[ ,,,[1665700973,"RPn"],]; CONWAYPOLDATA[20411]:=[ ,,,[2305259168,"RPn"],]; CONWAYPOLDATA[20431]:=[ ,,,[2087047084,"RPn"],]; CONWAYPOLDATA[20441]:=[ ,,,[417589192,"RPn"],]; CONWAYPOLDATA[20443]:=[ ,,,[1171179472,"RPn"],]; CONWAYPOLDATA[20477]:=[ ,,,[3188391764,"RPn"],]; CONWAYPOLDATA[20479]:=[ ,,,[1176846217,"RPn"],]; CONWAYPOLDATA[20483]:=[ ,,,[1678131229,"RPn"],]; CONWAYPOLDATA[20507]:=[ ,,,[3170833356,"RPn"],]; CONWAYPOLDATA[20509]:=[ ,,,[2765002873,"RPn"],]; CONWAYPOLDATA[20521]:=[ ,,,[8689576419,"RPn"],]; CONWAYPOLDATA[20533]:=[ ,,,[5320777891,"RPn"],]; CONWAYPOLDATA[20543]:=[ ,,,[2791547189,"RPn"],]; CONWAYPOLDATA[20549]:=[ ,,,[5318142849,"RPn"],]; CONWAYPOLDATA[20551]:=[ ,,,[1505484059,"RPn"],]; CONWAYPOLDATA[20563]:=[ ,,,[1539407872,"RPn"],]; CONWAYPOLDATA[20593]:=[ ,,,[5313858911,"RPn"],]; CONWAYPOLDATA[20599]:=[ ,,,[1268774809,"RPn"],]; CONWAYPOLDATA[20611]:=[ ,,,[1256199230,"RPn"],]; CONWAYPOLDATA[20627]:=[ ,,,[1082360573,"RPn"],]; CONWAYPOLDATA[20639]:=[ ,,,[2955257143,"RPn"],]; CONWAYPOLDATA[20641]:=[ ,,,[370650444,"RPn"],]; CONWAYPOLDATA[20663]:=[ ,,,[1590410452,"RPn"],]; CONWAYPOLDATA[20681]:=[ ,,,[1092535871,"RPn"],]; CONWAYPOLDATA[20693]:=[ ,,,[4088791951,"RPn"],]; CONWAYPOLDATA[20707]:=[ ,,,[1715036573,"RPn"],]; CONWAYPOLDATA[20717]:=[ ,,,[2976867166,"RPn"],]; CONWAYPOLDATA[20719]:=[ ,,,[1639453035,"RPn"],]; CONWAYPOLDATA[20731]:=[ ,,,[3758053489,"RPn"],]; CONWAYPOLDATA[20743]:=[ ,,,[2427117692,"RPn"],]; CONWAYPOLDATA[20747]:=[ ,,,[3839999994,"RPn"],]; CONWAYPOLDATA[20749]:=[ ,,,[4648439970,"RPn"],]; CONWAYPOLDATA[20753]:=[ ,,,[314013646,"RPn"],]; CONWAYPOLDATA[20759]:=[ ,,,[1225528331,"RPn"],]; CONWAYPOLDATA[20771]:=[ ,,,[3677007048,"RPn"],]; CONWAYPOLDATA[20773]:=[ ,,,[4551073480,"RPn"],]; CONWAYPOLDATA[20789]:=[ ,,,[754640702,"RPn"],]; CONWAYPOLDATA[20807]:=[ ,,,[1731641773,"RPn"],]; CONWAYPOLDATA[20809]:=[ ,,,[364760968,"RPn"],]; CONWAYPOLDATA[20849]:=[ ,,,[434430616,"RPn"],]; CONWAYPOLDATA[20857]:=[ ,,,[6467588854,"RPn"],]; CONWAYPOLDATA[20873]:=[ ,,,[403767315,"RPn"],]; CONWAYPOLDATA[20879]:=[ ,,,[3305667686,"RPn"],]; CONWAYPOLDATA[20887]:=[ ,,,[2985629557,"RPn"],]; CONWAYPOLDATA[20897]:=[ ,,,[391170946,"RPn"],]; CONWAYPOLDATA[20899]:=[ ,,,[3726291702,"RPn"],]; CONWAYPOLDATA[20903]:=[ ,,,[1747658029,"RPn"],]; CONWAYPOLDATA[20921]:=[ ,,,[437437192,"RPn"],]; CONWAYPOLDATA[20929]:=[ ,,,[6451720050,"RPn"],]; CONWAYPOLDATA[20939]:=[ ,,,[1569461808,"RPn"],]; CONWAYPOLDATA[20947]:=[ ,,,[3878672205,"RPn"],]; CONWAYPOLDATA[20959]:=[ ,,,[378666260,"RPn"],]; CONWAYPOLDATA[20963]:=[ ,,,[7904790931,"RPn"],]; CONWAYPOLDATA[20981]:=[ ,,,[3009178946,"RPn"],]; CONWAYPOLDATA[20983]:=[ ,,,[1109706941,"RPn"],]; CONWAYPOLDATA[21001]:=[ ,,,[9057815315,"RPn"],]; CONWAYPOLDATA[21011]:=[ ,,,[704036590,"RPn"],]; CONWAYPOLDATA[21013]:=[ ,,,[2982143949,"RPn"],]; CONWAYPOLDATA[21017]:=[ ,,,[5120392730,"RPn"],]; CONWAYPOLDATA[21019]:=[ ,,,[3008911890,"RPn"],]; CONWAYPOLDATA[21023]:=[ ,,,[2151199503,"RPn"],]; CONWAYPOLDATA[21031]:=[ ,,,[1128733782,"RPn"],]; CONWAYPOLDATA[21059]:=[ ,,,[1260023149,"RPn"],]; CONWAYPOLDATA[21061]:=[ ,,,[2076172326,"RPn"],]; CONWAYPOLDATA[21067]:=[ ,,,[3907717832,"RPn"],]; CONWAYPOLDATA[21089]:=[ ,,,[2011173577,"RPn"],]; CONWAYPOLDATA[21101]:=[ ,,,[4267592848,"RPn"],]; CONWAYPOLDATA[21107]:=[ ,,,[394468725,"RPn"],]; CONWAYPOLDATA[21121]:=[ ,,,[22537648852,"RPn"],]; CONWAYPOLDATA[21139]:=[ ,,,[3419930839,"RPn"],]; CONWAYPOLDATA[21143]:=[ ,,,[2591011231,"RPn"],]; CONWAYPOLDATA[21149]:=[ ,,,[4919913022,"RPn"],]; CONWAYPOLDATA[21157]:=[ ,,,[3414485918,"RPn"],]; CONWAYPOLDATA[21163]:=[ ,,,[3824535036,"RPn"],]; CONWAYPOLDATA[21169]:=[ ,,,[447300983,"RPn"],]; CONWAYPOLDATA[21179]:=[ ,,,[3420853261,"RPn"],]; CONWAYPOLDATA[21187]:=[ ,,,[1289885749,"RPn"],]; CONWAYPOLDATA[21191]:=[ ,,,[1791868585,"RPn"],]; CONWAYPOLDATA[21193]:=[ ,,,[2984970482,"RPn"],]; CONWAYPOLDATA[21211]:=[ ,,,[4038913778,"RPn"],]; CONWAYPOLDATA[21221]:=[ ,,,[3087103756,"RPn"],]; CONWAYPOLDATA[21227]:=[ ,,,[6196904247,"RPn"],]; CONWAYPOLDATA[21247]:=[ ,,,[10693976302,"RPn"],]; CONWAYPOLDATA[21269]:=[ ,,,[739438056,"RPn"],]; CONWAYPOLDATA[21277]:=[ ,,,[3862349985,"RPn"],]; CONWAYPOLDATA[21283]:=[ ,,,[3165378035,"RPn"],]; CONWAYPOLDATA[21313]:=[ ,,,[2963913663,"RPn"],]; CONWAYPOLDATA[21317]:=[ ,,,[2201236056,"RPn"],]; CONWAYPOLDATA[21319]:=[ ,,,[2072697151,"RPn"],]; CONWAYPOLDATA[21323]:=[ ,,,[329696231,"RPn"],]; CONWAYPOLDATA[21341]:=[ ,,,[2070674550,"RPn"],]; CONWAYPOLDATA[21347]:=[ ,,,[3606725081,"RPn"],]; CONWAYPOLDATA[21377]:=[ ,,,[1350192700,"RPn"],]; CONWAYPOLDATA[21379]:=[ ,,,[3887728394,"RPn"],]; CONWAYPOLDATA[21383]:=[ ,,,[2076503135,"RPn"],]; CONWAYPOLDATA[21391]:=[ ,,,[1750168844,"RPn"],]; CONWAYPOLDATA[21397]:=[ ,,,[1735467878,"RPn"],]; CONWAYPOLDATA[21401]:=[ ,,,[825971598,"RPn"],]; CONWAYPOLDATA[21407]:=[ ,,,[1252266691,"RPn"],]; CONWAYPOLDATA[21419]:=[ ,,,[3552898046,"RPn"],]; CONWAYPOLDATA[21433]:=[ ,,,[9116055029,"RPn"],]; CONWAYPOLDATA[21467]:=[ ,,,[2182142019,"RPn"],]; CONWAYPOLDATA[21481]:=[ ,,,[6700375014,"RPn"],]; CONWAYPOLDATA[21487]:=[ ,,,[3201627464,"RPn"],]; CONWAYPOLDATA[21491]:=[ ,,,[1762562876,"RPn"],]; CONWAYPOLDATA[21493]:=[ ,,,[1718107436,"RPn"],]; CONWAYPOLDATA[21499]:=[ ,,,[2609656118,"RPn"],]; CONWAYPOLDATA[21503]:=[ ,,,[2152106257,"RPn"],]; CONWAYPOLDATA[21517]:=[ ,,,[3604140539,"RPn"],]; CONWAYPOLDATA[21521]:=[ ,,,[1267307130,"RPn"],]; CONWAYPOLDATA[21523]:=[ ,,,[3694530567,"RPn"],]; CONWAYPOLDATA[21529]:=[ ,,,[9604905013,"RPn"],]; CONWAYPOLDATA[21557]:=[ ,,,[3523426981,"RPn"],]; CONWAYPOLDATA[21559]:=[ ,,,[1288150265,"RPn"],]; CONWAYPOLDATA[21563]:=[ ,,,[4184515782,"RPn"],]; CONWAYPOLDATA[21569]:=[ ,,,[1360248988,"RPn"],]; CONWAYPOLDATA[21577]:=[ ,,,[3061085841,"RPn"],]; CONWAYPOLDATA[21587]:=[ ,,,[5003391688,"RPn"],]; CONWAYPOLDATA[21589]:=[ ,,,[5865839247,"RPn"],]; CONWAYPOLDATA[21599]:=[ ,,,[1266910951,"RPn"],]; CONWAYPOLDATA[21601]:=[ ,,,[395471115,"RPn"],]; CONWAYPOLDATA[21611]:=[ ,,,[4190610623,"RPn"],]; CONWAYPOLDATA[21613]:=[ ,,,[3263498163,"RPn"],]; CONWAYPOLDATA[21617]:=[ ,,,[445504756,"RPn"],]; CONWAYPOLDATA[21647]:=[ ,,,[2174614331,"RPn"],]; CONWAYPOLDATA[21649]:=[ ,,,[4924714534,"RPn"],]; CONWAYPOLDATA[21661]:=[ ,,,[1854939737,"RPn"],]; CONWAYPOLDATA[21673]:=[ ,,,[10114680745,"RPn"],]; CONWAYPOLDATA[21683]:=[ ,,,[3755690749,"RPn"],]; CONWAYPOLDATA[21701]:=[ ,,,[3539324597,"RPn"],]; CONWAYPOLDATA[21713]:=[ ,,,[246464266,"RPn"],]; CONWAYPOLDATA[21727]:=[ ,,,[2815428117,"RPn"],]; CONWAYPOLDATA[21737]:=[ ,,,[4118791977,"RPn"],]; CONWAYPOLDATA[21739]:=[ ,,,[4231996349,"RPn"],]; CONWAYPOLDATA[21751]:=[ ,,,[1828911087,"RPn"],]; CONWAYPOLDATA[21757]:=[ ,,,[1860897972,"RPn"],]; CONWAYPOLDATA[21767]:=[ ,,,[1678039802,"RPn"],]; CONWAYPOLDATA[21773]:=[ ,,,[779342764,"RPn"],]; CONWAYPOLDATA[21787]:=[ ,,,[5603877867,"RPn"],]; CONWAYPOLDATA[21799]:=[ ,,,[2640076897,"RPn"],]; CONWAYPOLDATA[21803]:=[ ,,,[2204653953,"RPn"],]; CONWAYPOLDATA[21817]:=[ ,,,[10836503907,"RPn"],]; CONWAYPOLDATA[21821]:=[ ,,,[3199525948,"RPn"],]; CONWAYPOLDATA[21839]:=[ ,,,[2710722208,"RPn"],]; CONWAYPOLDATA[21841]:=[ ,,,[11925317057,"RPn"],]; CONWAYPOLDATA[21851]:=[ ,,,[349441198,"RPn"],]; CONWAYPOLDATA[21859]:=[ ,,,[1321354693,"RPn"],]; CONWAYPOLDATA[21863]:=[ ,,,[2802727290,"RPn"],]; CONWAYPOLDATA[21871]:=[ ,,,[1330412936,"RPn"],]; CONWAYPOLDATA[21881]:=[ ,,,[1200566711,"RPn"],]; CONWAYPOLDATA[21893]:=[ ,,,[1885972487,"RPn"],]; CONWAYPOLDATA[21911]:=[ ,,,[1329099362,"RPn"],]; CONWAYPOLDATA[21929]:=[ ,,,[1374992161,"RPn"],]; CONWAYPOLDATA[21937]:=[ ,,,[6203827481,"RPn"],]; CONWAYPOLDATA[21943]:=[ ,,,[5777679677,"RPn"],]; CONWAYPOLDATA[21961]:=[ ,,,[14883123444,"RPn"],]; CONWAYPOLDATA[21977]:=[ ,,,[403717493,"RPn"],]; CONWAYPOLDATA[21991]:=[ ,,,[1836094566,"RPn"],]; CONWAYPOLDATA[21997]:=[ ,,,[2344374276,"RPn"],]; CONWAYPOLDATA[22003]:=[ ,,,[4318022743,"RPn"],]; CONWAYPOLDATA[22013]:=[ ,,,[1701891071,"RPn"],]; CONWAYPOLDATA[22027]:=[ ,,,[1826148438,"RPn"],]; CONWAYPOLDATA[22031]:=[ ,,,[2426626533,"RPn"],]; CONWAYPOLDATA[22037]:=[ ,,,[3831881710,"RPn"],]; CONWAYPOLDATA[22039]:=[ ,,,[1876620856,"RPn"],]; CONWAYPOLDATA[22051]:=[ ,,,[1236774440,"RPn"],]; CONWAYPOLDATA[22063]:=[ ,,,[4826435696,"RPn"],]; CONWAYPOLDATA[22067]:=[ ,,,[1366874116,"RPn"],]; CONWAYPOLDATA[22073]:=[ ,,,[4731656575,"RPn"],]; CONWAYPOLDATA[22079]:=[ ,,,[6147809241,"RPn"],]; CONWAYPOLDATA[22091]:=[ ,,,[1265968939,"RPn"],]; CONWAYPOLDATA[22093]:=[ ,,,[4342887295,"RPn"],]; CONWAYPOLDATA[22109]:=[ ,,,[1872521757,"RPn"],]; CONWAYPOLDATA[22111]:=[ ,,,[1926177660,"RPn"],]; CONWAYPOLDATA[22123]:=[ ,,,[8712966568,"RPn"],]; CONWAYPOLDATA[22129]:=[ ,,,[8147654400,"RPn"],]; CONWAYPOLDATA[22133]:=[ ,,,[843178770,"RPn"],]; CONWAYPOLDATA[22147]:=[ ,,,[12132857456,"RPn"],]; CONWAYPOLDATA[22153]:=[ ,,,[3195858244,"RPn"],]; CONWAYPOLDATA[22157]:=[ ,,,[3369259893,"RPn"],]; CONWAYPOLDATA[22159]:=[ ,,,[1460721286,"RPn"],]; CONWAYPOLDATA[22171]:=[ ,,,[4288226138,"RPn"],]; CONWAYPOLDATA[22189]:=[ ,,,[13604209036,"RPn"],]; CONWAYPOLDATA[22193]:=[ ,,,[3229347819,"RPn"],]; CONWAYPOLDATA[22229]:=[ ,,,[341926480,"RPn"],]; CONWAYPOLDATA[22247]:=[ ,,,[10290750301,"RPn"],]; CONWAYPOLDATA[22259]:=[ ,,,[7713010610,"RPn"],]; CONWAYPOLDATA[22271]:=[ ,,,[1279424415,"RPn"],]; CONWAYPOLDATA[22273]:=[ ,,,[5452252221,"RPn"],]; CONWAYPOLDATA[22277]:=[ ,,,[919304961,"RPn"],]; CONWAYPOLDATA[22279]:=[ ,,,[3314892413,"RPn"],]; CONWAYPOLDATA[22283]:=[ ,,,[2406809115,"RPn"],]; CONWAYPOLDATA[22291]:=[ ,,,[2935457211,"RPn"],]; CONWAYPOLDATA[22303]:=[ ,,,[2418291993,"RPn"],]; CONWAYPOLDATA[22307]:=[ ,,,[434651897,"RPn"],]; CONWAYPOLDATA[22343]:=[ ,,,[3958017769,"RPn"],]; CONWAYPOLDATA[22349]:=[ ,,,[773141308,"RPn"],]; CONWAYPOLDATA[22367]:=[ ,,,[2001041293,"RPn"],]; CONWAYPOLDATA[22369]:=[ ,,,[11456842586,"RPn"],]; CONWAYPOLDATA[22381]:=[ ,,,[4957436272,"RPn"],]; CONWAYPOLDATA[22391]:=[ ,,,[4436619926,"RPn"],]; CONWAYPOLDATA[22397]:=[ ,,,[3906798300,"RPn"],]; CONWAYPOLDATA[22409]:=[ ,,,[3779748442,"RPn"],]; CONWAYPOLDATA[22433]:=[ ,,,[475736634,"RPn"],]; CONWAYPOLDATA[22441]:=[ ,,,[5378815981,"RPn"],]; CONWAYPOLDATA[22447]:=[ ,,,[2884910890,"RPn"],]; CONWAYPOLDATA[22453]:=[ ,,,[3788741678,"RPn"],]; CONWAYPOLDATA[22469]:=[ ,,,[3453934682,"RPn"],]; CONWAYPOLDATA[22481]:=[ ,,,[4002854458,"RPn"],]; CONWAYPOLDATA[22483]:=[ ,,,[798506230,"RPn"],]; CONWAYPOLDATA[22501]:=[ ,,,[1794229742,"RPn"],]; CONWAYPOLDATA[22511]:=[ ,,,[2965554129,"RPn"],]; CONWAYPOLDATA[22531]:=[ ,,,[1517079825,"RPn"],]; CONWAYPOLDATA[22541]:=[ ,,,[5588883166,"RPn"],]; CONWAYPOLDATA[22543]:=[ ,,,[3515716111,"RPn"],]; CONWAYPOLDATA[22549]:=[ ,,,[3484632266,"RPn"],]; CONWAYPOLDATA[22567]:=[ ,,,[7976283586,"RPn"],]; CONWAYPOLDATA[22571]:=[ ,,,[4075374624,"RPn"],]; CONWAYPOLDATA[22573]:=[ ,,,[3350420104,"RPn"],]; CONWAYPOLDATA[22613]:=[ ,,,[1320327846,"RPn"],]; CONWAYPOLDATA[22619]:=[ ,,,[434194326,"RPn"],]; CONWAYPOLDATA[22621]:=[ ,,,[3534214558,"RPn"],]; CONWAYPOLDATA[22637]:=[ ,,,[915666652,"RPn"],]; CONWAYPOLDATA[22639]:=[ ,,,[1524827212,"RPn"],]; CONWAYPOLDATA[22643]:=[ ,,,[3914680343,"RPn"],]; CONWAYPOLDATA[22651]:=[ ,,,[1416525590,"RPn"],]; CONWAYPOLDATA[22669]:=[ ,,,[3955332460,"RPn"],]; CONWAYPOLDATA[22679]:=[ ,,,[1844415046,"RPn"],]; CONWAYPOLDATA[22691]:=[ ,,,[4577977325,"RPn"],]; CONWAYPOLDATA[22697]:=[ ,,,[1018459787,"RPn"],]; CONWAYPOLDATA[22699]:=[ ,,,[1475480410,"RPn"],]; CONWAYPOLDATA[22709]:=[ ,,,[8229809729,"RPn"],]; CONWAYPOLDATA[22717]:=[ ,,,[3604778996,"RPn"],]; CONWAYPOLDATA[22721]:=[ ,,,[4068876683,"RPn"],]; CONWAYPOLDATA[22727]:=[ ,,,[1845614221,"RPn"],]; CONWAYPOLDATA[22739]:=[ ,,,[2345482374,"RPn"],]; CONWAYPOLDATA[22741]:=[ ,,,[5046182425,"RPn"],]; CONWAYPOLDATA[22751]:=[ ,,,[1970737143,"RPn"],]; CONWAYPOLDATA[22769]:=[ ,,,[4014265779,"RPn"],]; CONWAYPOLDATA[22777]:=[ ,,,[5486091004,"RPn"],]; CONWAYPOLDATA[22783]:=[ ,,,[3094045318,"RPn"],]; CONWAYPOLDATA[22787]:=[ ,,,[3904529665,"RPn"],]; CONWAYPOLDATA[22807]:=[ ,,,[2600705020,"RPn"],]; CONWAYPOLDATA[22811]:=[ ,,,[3108705897,"RPn"],]; CONWAYPOLDATA[22817]:=[ ,,,[814384367,"RPn"],]; CONWAYPOLDATA[22853]:=[ ,,,[3400914903,"RPn"],]; CONWAYPOLDATA[22859]:=[ ,,,[300938737,"RPn"],]; CONWAYPOLDATA[22861]:=[ ,,,[3927611246,"RPn"],]; CONWAYPOLDATA[22871]:=[ ,,,[2615207373,"RPn"],]; CONWAYPOLDATA[22877]:=[ ,,,[3501942531,"RPn"],]; CONWAYPOLDATA[22901]:=[ ,,,[4185844782,"RPn"],]; CONWAYPOLDATA[22907]:=[ ,,,[2016732285,"RPn"],]; CONWAYPOLDATA[22921]:=[ ,,,[414870107,"RPn"],]; CONWAYPOLDATA[22937]:=[ ,,,[3447316418,"RPn"],]; CONWAYPOLDATA[22943]:=[ ,,,[5083572287,"RPn"],]; CONWAYPOLDATA[22961]:=[ ,,,[4136584883,"RPn"],]; CONWAYPOLDATA[22963]:=[ ,,,[1335206601,"RPn"],]; CONWAYPOLDATA[22973]:=[ ,,,[5269799445,"RPn"],]; CONWAYPOLDATA[22993]:=[ ,,,[3638182395,"RPn"],]; CONWAYPOLDATA[23003]:=[ ,,,[1474308278,"RPn"],]; CONWAYPOLDATA[23011]:=[ ,,,[3542520446,"RPn"],]; CONWAYPOLDATA[23017]:=[ ,,,[3648194505,"RPn"],]; CONWAYPOLDATA[23021]:=[ ,,,[2619582613,"RPn"],]; CONWAYPOLDATA[23027]:=[ ,,,[4160817713,"RPn"],]; CONWAYPOLDATA[23029]:=[ ,,,[3528480353,"RPn"],]; CONWAYPOLDATA[23039]:=[ ,,,[5680726237,"RPn"],]; CONWAYPOLDATA[23041]:=[ ,,,[13271754257,"RPn"],]; CONWAYPOLDATA[23053]:=[ ,,,[6825532242,"RPn"],]; CONWAYPOLDATA[23057]:=[ ,,,[921034927,"RPn"],]; CONWAYPOLDATA[23059]:=[ ,,,[8363360949,"RPn"],]; CONWAYPOLDATA[23063]:=[ ,,,[6241678073,"RPn"],]; CONWAYPOLDATA[23071]:=[ ,,,[3604151623,"RPn"],]; CONWAYPOLDATA[23081]:=[ ,,,[532455592,"RPn"],]; CONWAYPOLDATA[23087]:=[ ,,,[2111583199,"RPn"],]; CONWAYPOLDATA[23099]:=[ ,,,[6788172429,"RPn"],]; CONWAYPOLDATA[23117]:=[ ,,,[816191921,"RPn"],]; CONWAYPOLDATA[23131]:=[ ,,,[2967799827,"RPn"],]; CONWAYPOLDATA[23143]:=[ ,,,[2142301229,"RPn"],]; CONWAYPOLDATA[23159]:=[ ,,,[4826960904,"RPn"],]; CONWAYPOLDATA[23167]:=[ ,,,[3560513066,"RPn"],]; CONWAYPOLDATA[23173]:=[ ,,,[3723993797,"RPn"],]; CONWAYPOLDATA[23189]:=[ ,,,[5292842874,"RPn"],]; CONWAYPOLDATA[23197]:=[ ,,,[11809082368,"RPn"],]; CONWAYPOLDATA[23201]:=[ ,,,[4221329149,"RPn"],]; CONWAYPOLDATA[23203]:=[ ,,,[2071308610,"RPn"],]; CONWAYPOLDATA[23209]:=[ ,,,[17512907997,"RPn"],]; CONWAYPOLDATA[23227]:=[ ,,,[3002391704,"RPn"],]; CONWAYPOLDATA[23251]:=[ ,,,[4722254851,"RPn"],]; CONWAYPOLDATA[23269]:=[ ,,,[5904718177,"RPn"],]; CONWAYPOLDATA[23279]:=[ ,,,[3780090585,"RPn"],]; CONWAYPOLDATA[23291]:=[ ,,,[1384999321,"RPn"],]; CONWAYPOLDATA[23293]:=[ ,,,[2047827393,"RPn"],]; CONWAYPOLDATA[23297]:=[ ,,,[10115743779,"RPn"],]; CONWAYPOLDATA[23311]:=[ ,,,[2124681098,"RPn"],]; CONWAYPOLDATA[23321]:=[ ,,,[543589192,"RPn"],]; CONWAYPOLDATA[23327]:=[ ,,,[5945329168,"RPn"],]; CONWAYPOLDATA[23333]:=[ ,,,[4221313030,"RPn"],]; CONWAYPOLDATA[23339]:=[ ,,,[4851454593,"RPn"],]; CONWAYPOLDATA[23357]:=[ ,,,[3613257831,"RPn"],]; CONWAYPOLDATA[23369]:=[ ,,,[1454603408,"RPn"],]; CONWAYPOLDATA[23371]:=[ ,,,[1500511686,"RPn"],]; CONWAYPOLDATA[23399]:=[ ,,,[2189865629,"RPn"],]; CONWAYPOLDATA[23417]:=[ ,,,[2001450993,"RPn"],]; CONWAYPOLDATA[23431]:=[ ,,,[2744965084,"RPn"],]; CONWAYPOLDATA[23447]:=[ ,,,[3741344007,"RPn"],]; CONWAYPOLDATA[23459]:=[ ,,,[957150661,"RPn"],]; CONWAYPOLDATA[23473]:=[ ,,,[3602119639,"RPn"],]; CONWAYPOLDATA[23497]:=[ ,,,[3859664219,"RPn"],]; CONWAYPOLDATA[23509]:=[ ,,,[2102856543,"RPn"],]; CONWAYPOLDATA[23531]:=[ ,,,[2154215990,"RPn"],]; CONWAYPOLDATA[23537]:=[ ,,,[3816971756,"RPn"],]; CONWAYPOLDATA[23539]:=[ ,,,[1968801962,"RPn"],]; CONWAYPOLDATA[23549]:=[ ,,,[7037995436,"RPn"],]; CONWAYPOLDATA[23557]:=[ ,,,[5304447480,"RPn"],]; CONWAYPOLDATA[23561]:=[ ,,,[1426288699,"RPn"],]; CONWAYPOLDATA[23563]:=[ ,,,[4961495971,"RPn"],]; CONWAYPOLDATA[23567]:=[ ,,,[3700985252,"RPn"],]; CONWAYPOLDATA[23581]:=[ ,,,[3892350609,"RPn"],]; CONWAYPOLDATA[23593]:=[ ,,,[3655971285,"RPn"],]; CONWAYPOLDATA[23599]:=[ ,,,[2784469612,"RPn"],]; CONWAYPOLDATA[23603]:=[ ,,,[9960182766,"RPn"],]; CONWAYPOLDATA[23609]:=[ ,,,[5311481999,"RPn"],]; CONWAYPOLDATA[23623]:=[ ,,,[3277313288,"RPn"],]; CONWAYPOLDATA[23627]:=[ ,,,[4940665599,"RPn"],]; CONWAYPOLDATA[23629]:=[ ,,,[6119532938,"RPn"],]; CONWAYPOLDATA[23633]:=[ ,,,[4994172831,"RPn"],]; CONWAYPOLDATA[23663]:=[ ,,,[3133123183,"RPn"],]; CONWAYPOLDATA[23669]:=[ ,,,[2770858825,"RPn"],]; CONWAYPOLDATA[23671]:=[ ,,,[1446676839,"RPn"],]; CONWAYPOLDATA[23677]:=[ ,,,[2107158297,"RPn"],]; CONWAYPOLDATA[23687]:=[ ,,,[2244201133,"RPn"],]; CONWAYPOLDATA[23689]:=[ ,,,[9386908395,"RPn"],]; CONWAYPOLDATA[23719]:=[ ,,,[2095597375,"RPn"],]; CONWAYPOLDATA[23741]:=[ ,,,[7107651805,"RPn"],]; CONWAYPOLDATA[23743]:=[ ,,,[3670311658,"RPn"],]; CONWAYPOLDATA[23747]:=[ ,,,[6141995323,"RPn"],]; CONWAYPOLDATA[23753]:=[ ,,,[14624199537,"RPn"],]; CONWAYPOLDATA[23761]:=[ ,,,[323933720,"RPn"],]; CONWAYPOLDATA[23767]:=[ ,,,[3357278889,"RPn"],]; CONWAYPOLDATA[23773]:=[ ,,,[6749701484,"RPn"],]; CONWAYPOLDATA[23789]:=[ ,,,[2196509739,"RPn"],]; CONWAYPOLDATA[23801]:=[ ,,,[12894953385,"RPn"],]; CONWAYPOLDATA[23813]:=[ ,,,[1116115312,"RPn"],]; CONWAYPOLDATA[23819]:=[ ,,,[1594229491,"RPn"],]; CONWAYPOLDATA[23827]:=[ ,,,[5109366574,"RPn"],]; CONWAYPOLDATA[23831]:=[ ,,,[3842772592,"RPn"],]; CONWAYPOLDATA[23833]:=[ ,,,[8519916177,"RPn"],]; CONWAYPOLDATA[23857]:=[ ,,,[3736960485,"RPn"],]; CONWAYPOLDATA[23869]:=[ ,,,[4896295710,"RPn"],]; CONWAYPOLDATA[23873]:=[ ,,,[317797379,"RPn"],]; CONWAYPOLDATA[23879]:=[ ,,,[1439688796,"RPn"],]; CONWAYPOLDATA[23887]:=[ ,,,[3362310236,"RPn"],]; CONWAYPOLDATA[23893]:=[ ,,,[2223721515,"RPn"],]; CONWAYPOLDATA[23899]:=[ ,,,[5047946782,"RPn"],]; CONWAYPOLDATA[23909]:=[ ,,,[3832875701,"RPn"],]; CONWAYPOLDATA[23911]:=[ ,,,[1690962015,"RPn"],]; CONWAYPOLDATA[23917]:=[ ,,,[3880485418,"RPn"],]; CONWAYPOLDATA[23929]:=[ ,,,[14061996502,"RPn"],]; CONWAYPOLDATA[23957]:=[ ,,,[1581689056,"RPn"],]; CONWAYPOLDATA[23971]:=[ ,,,[507394167,"RPn"],]; CONWAYPOLDATA[23977]:=[ ,,,[3846917839,"RPn"],]; CONWAYPOLDATA[23981]:=[ ,,,[2875345884,"RPn"],]; CONWAYPOLDATA[23993]:=[ ,,,[1574300698,"RPn"],]; CONWAYPOLDATA[24001]:=[ ,,,[8542411933,"RPn"],]; CONWAYPOLDATA[24007]:=[ ,,,[2305152157,"RPn"],]; CONWAYPOLDATA[24019]:=[ ,,,[5130818687,"RPn"],]; CONWAYPOLDATA[24023]:=[ ,,,[2308322029,"RPn"],]; CONWAYPOLDATA[24029]:=[ ,,,[1005421420,"RPn"],]; CONWAYPOLDATA[24043]:=[ ,,,[4525469634,"RPn"],]; CONWAYPOLDATA[24049]:=[ ,,,[11986598795,"RPn"],]; CONWAYPOLDATA[24061]:=[ ,,,[8473706746,"RPn"],]; CONWAYPOLDATA[24071]:=[ ,,,[1711568466,"RPn"],]; CONWAYPOLDATA[24077]:=[ ,,,[3997672851,"RPn"],]; CONWAYPOLDATA[24083]:=[ ,,,[2701486444,"RPn"],]; CONWAYPOLDATA[24091]:=[ ,,,[3940034875,"RPn"],]; CONWAYPOLDATA[24097]:=[ ,,,[6246014696,"RPn"],]; CONWAYPOLDATA[24103]:=[ ,,,[10283954706,"RPn"],]; CONWAYPOLDATA[24107]:=[ ,,,[1554395255,"RPn"],]; CONWAYPOLDATA[24109]:=[ ,,,[3859175850,"RPn"],]; CONWAYPOLDATA[24113]:=[ ,,,[9637411504,"RPn"],]; CONWAYPOLDATA[24121]:=[ ,,,[11584954498,"RPn"],]; CONWAYPOLDATA[24133]:=[ ,,,[6273976681,"RPn"],]; CONWAYPOLDATA[24137]:=[ ,,,[1136876840,"RPn"],]; CONWAYPOLDATA[24151]:=[ ,,,[6305657049,"RPn"],]; CONWAYPOLDATA[24169]:=[ ,,,[7577440722,"RPn"],]; CONWAYPOLDATA[24179]:=[ ,,,[4548940346,"RPn"],]; CONWAYPOLDATA[24181]:=[ ,,,[2258674684,"RPn"],]; CONWAYPOLDATA[24197]:=[ ,,,[1071975496,"RPn"],]; CONWAYPOLDATA[24203]:=[ ,,,[5245177350,"RPn"],]; CONWAYPOLDATA[24223]:=[ ,,,[9775894120,"RPn"],]; CONWAYPOLDATA[24229]:=[ ,,,[7344851749,"RPn"],]; CONWAYPOLDATA[24239]:=[ ,,,[2187933348,"RPn"],]; CONWAYPOLDATA[24247]:=[ ,,,[3903379051,"RPn"],]; CONWAYPOLDATA[24251]:=[ ,,,[4704645504,"RPn"],]; CONWAYPOLDATA[24281]:=[ ,,,[572618826,"RPn"],]; CONWAYPOLDATA[24317]:=[ ,,,[2244994076,"RPn"],]; CONWAYPOLDATA[24329]:=[ ,,,[2704289998,"RPn"],]; CONWAYPOLDATA[24337]:=[ ,,,[9216154198,"RPn"],]; CONWAYPOLDATA[24359]:=[ ,,,[2221419016,"RPn"],]; CONWAYPOLDATA[24371]:=[ ,,,[4559253569,"RPn"],]; CONWAYPOLDATA[24373]:=[ ,,,[2723853368,"RPn"],]; CONWAYPOLDATA[24379]:=[ ,,,[1060827808,"RPn"],]; CONWAYPOLDATA[24391]:=[ ,,,[2361414668,"RPn"],]; CONWAYPOLDATA[24407]:=[ ,,,[5175138250,"RPn"],]; CONWAYPOLDATA[24413]:=[ ,,,[3480073152,"RPn"],]; CONWAYPOLDATA[24419]:=[ ,,,[2806573348,"RPn"],]; CONWAYPOLDATA[24421]:=[ ,,,[7516026756,"RPn"],]; CONWAYPOLDATA[24439]:=[ ,,,[4180755297,"RPn"],]; CONWAYPOLDATA[24443]:=[ ,,,[1644671700,"RPn"],]; CONWAYPOLDATA[24469]:=[ ,,,[1103551914,"RPn"],]; CONWAYPOLDATA[24473]:=[ ,,,[1157156862,"RPn"],]; CONWAYPOLDATA[24481]:=[ ,,,[12483571860,"RPn"],]; CONWAYPOLDATA[24499]:=[ ,,,[1081900341,"RPn"],]; CONWAYPOLDATA[24509]:=[ ,,,[509566621,"RPn"],]; CONWAYPOLDATA[24517]:=[ ,,,[6374248386,"RPn"],]; CONWAYPOLDATA[24527]:=[ ,,,[11964834726,"RPn"],]; CONWAYPOLDATA[24533]:=[ ,,,[3942943762,"RPn"],]; CONWAYPOLDATA[24547]:=[ ,,,[4638990250,"RPn"],]; CONWAYPOLDATA[24551]:=[ ,,,[3013537053,"RPn"],]; CONWAYPOLDATA[24571]:=[ ,,,[4184834443,"RPn"],]; CONWAYPOLDATA[24593]:=[ ,,,[4204591434,"RPn"],]; CONWAYPOLDATA[24611]:=[ ,,,[4568589165,"RPn"],]; CONWAYPOLDATA[24623]:=[ ,,,[2419702215,"RPn"],]; CONWAYPOLDATA[24631]:=[ ,,,[1676977007,"RPn"],]; CONWAYPOLDATA[24659]:=[ ,,,[1817491597,"RPn"],]; CONWAYPOLDATA[24671]:=[ ,,,[2742329687,"RPn"],]; CONWAYPOLDATA[24677]:=[ ,,,[4183615197,"RPn"],]; CONWAYPOLDATA[24683]:=[ ,,,[501015536,"RPn"],]; CONWAYPOLDATA[24691]:=[ ,,,[5798064077,"RPn"],]; CONWAYPOLDATA[24697]:=[ ,,,[9148855473,"RPn"],]; CONWAYPOLDATA[24709]:=[ ,,,[6534492724,"RPn"],]; CONWAYPOLDATA[24733]:=[ ,,,[7852752235,"RPn"],]; CONWAYPOLDATA[24749]:=[ ,,,[4166642646,"RPn"],]; CONWAYPOLDATA[24763]:=[ ,,,[5297870511,"RPn"],]; CONWAYPOLDATA[24767]:=[ ,,,[1803235741,"RPn"],]; CONWAYPOLDATA[24781]:=[ ,,,[6626166811,"RPn"],]; CONWAYPOLDATA[24793]:=[ ,,,[6529087797,"RPn"],]; CONWAYPOLDATA[24799]:=[ ,,,[2222734376,"RPn"],]; CONWAYPOLDATA[24809]:=[ ,,,[9808511055,"RPn"],]; CONWAYPOLDATA[24821]:=[ ,,,[5958380336,"RPn"],]; CONWAYPOLDATA[24841]:=[ ,,,[5920057452,"RPn"],]; CONWAYPOLDATA[24847]:=[ ,,,[4147908489,"RPn"],]; CONWAYPOLDATA[24851]:=[ ,,,[6165359145,"RPn"],]; CONWAYPOLDATA[24859]:=[ ,,,[5514695703,"RPn"],]; CONWAYPOLDATA[24877]:=[ ,,,[1092871492,"RPn"],]; CONWAYPOLDATA[24889]:=[ ,,,[15486085145,"RPn"],]; CONWAYPOLDATA[24907]:=[ ,,,[9151977524,"RPn"],]; CONWAYPOLDATA[24917]:=[ ,,,[4103381396,"RPn"],]; CONWAYPOLDATA[24919]:=[ ,,,[2339669832,"RPn"],]; CONWAYPOLDATA[24923]:=[ ,,,[1563843483,"RPn"],]; CONWAYPOLDATA[24943]:=[ ,,,[1803553506,"RPn"],]; CONWAYPOLDATA[24953]:=[ ,,,[323316024,"RPn"],]; CONWAYPOLDATA[24967]:=[ ,,,[3511159147,"RPn"],]; CONWAYPOLDATA[24971]:=[ ,,,[4830814749,"RPn"],]; CONWAYPOLDATA[24977]:=[ ,,,[4966151936,"RPn"],]; CONWAYPOLDATA[24979]:=[ ,,,[4337328583,"RPn"],]; CONWAYPOLDATA[24989]:=[ ,,,[2415886544,"RPn"],]; CONWAYPOLDATA[25013]:=[ ,,,[4292430906,"RPn"],]; CONWAYPOLDATA[25031]:=[ ,,,[2342776458,"RPn"],]; CONWAYPOLDATA[25033]:=[ ,,,[8032564012,"RPn"],]; CONWAYPOLDATA[25037]:=[ ,,,[1178015889,"RPn"],]; CONWAYPOLDATA[25057]:=[ ,,,[4205165973,"RPn"],]; CONWAYPOLDATA[25073]:=[ ,,,[1246077957,"RPn"],]; CONWAYPOLDATA[25087]:=[ ,,,[1719538244,"RPn"],]; CONWAYPOLDATA[25097]:=[ ,,,[569300351,"RPn"],]; CONWAYPOLDATA[25111]:=[ ,,,[2475844159,"RPn"],]; CONWAYPOLDATA[25117]:=[ ,,,[4278555370,"RPn"],]; CONWAYPOLDATA[25121]:=[ ,,,[4745733718,"RPn"],]; CONWAYPOLDATA[25127]:=[ ,,,[5440673934,"RPn"],]; CONWAYPOLDATA[25147]:=[ ,,,[1876393701,"RPn"],]; CONWAYPOLDATA[25153]:=[ ,,,[4414326357,"RPn"],]; CONWAYPOLDATA[25163]:=[ ,,,[7399180152,"RPn"],]; CONWAYPOLDATA[25169]:=[ ,,,[5675735348,"RPn"],]; CONWAYPOLDATA[25171]:=[ ,,,[485926158,"RPn"],]; CONWAYPOLDATA[25183]:=[ ,,,[13317374797,"RPn"],]; CONWAYPOLDATA[25189]:=[ ,,,[2295624706,"RPn"],]; CONWAYPOLDATA[25219]:=[ ,,,[4160479308,"RPn"],]; CONWAYPOLDATA[25229]:=[ ,,,[8040457073,"RPn"],]; CONWAYPOLDATA[25237]:=[ ,,,[6055088175,"RPn"],]; CONWAYPOLDATA[25243]:=[ ,,,[6883235999,"RPn"],]; CONWAYPOLDATA[25247]:=[ ,,,[1733459025,"RPn"],]; CONWAYPOLDATA[25253]:=[ ,,,[4880268517,"RPn"],]; CONWAYPOLDATA[25261]:=[ ,,,[10155427227,"RPn"],]; CONWAYPOLDATA[25301]:=[ ,,,[3200601804,"RPn"],]; CONWAYPOLDATA[25303]:=[ ,,,[2436780115,"RPn"],]; CONWAYPOLDATA[25307]:=[ ,,,[5086656388,"RPn"],]; CONWAYPOLDATA[25309]:=[ ,,,[7498423988,"RPn"],]; CONWAYPOLDATA[25321]:=[ ,,,[5577557973,"RPn"],]; CONWAYPOLDATA[25339]:=[ ,,,[1660135266,"RPn"],]; CONWAYPOLDATA[25343]:=[ ,,,[7029083799,"RPn"],]; CONWAYPOLDATA[25349]:=[ ,,,[8115178164,"RPn"],]; CONWAYPOLDATA[25357]:=[ ,,,[4916443375,"RPn"],]; CONWAYPOLDATA[25367]:=[ ,,,[5124666712,"RPn"],]; CONWAYPOLDATA[25373]:=[ ,,,[13985115515,"RPn"],]; CONWAYPOLDATA[25391]:=[ ,,,[1913084902,"RPn"],]; CONWAYPOLDATA[25409]:=[ ,,,[4935571208,"RPn"],]; CONWAYPOLDATA[25411]:=[ ,,,[4316566577,"RPn"],]; CONWAYPOLDATA[25423]:=[ ,,,[3756095715,"RPn"],]; CONWAYPOLDATA[25439]:=[ ,,,[4279882806,"RPn"],]; CONWAYPOLDATA[25447]:=[ ,,,[4401185888,"RPn"],]; CONWAYPOLDATA[25453]:=[ ,,,[1925392187,"RPn"],]; CONWAYPOLDATA[25457]:=[ ,,,[465684904,"RPn"],]; CONWAYPOLDATA[25463]:=[ ,,,[2418883153,"RPn"],]; CONWAYPOLDATA[25469]:=[ ,,,[5837851368,"RPn"],]; CONWAYPOLDATA[25471]:=[ ,,,[2370585976,"RPn"],]; CONWAYPOLDATA[25523]:=[ ,,,[2575730116,"RPn"],]; CONWAYPOLDATA[25537]:=[ ,,,[9477316987,"RPn"],]; CONWAYPOLDATA[25541]:=[ ,,,[1210183664,"RPn"],]; CONWAYPOLDATA[25561]:=[ ,,,[20066407451,"RPn"],]; CONWAYPOLDATA[25577]:=[ ,,,[4442264517,"RPn"],]; CONWAYPOLDATA[25579]:=[ ,,,[5874396405,"RPn"],]; CONWAYPOLDATA[25583]:=[ ,,,[3805829417,"RPn"],]; CONWAYPOLDATA[25589]:=[ ,,,[456405406,"RPn"],]; CONWAYPOLDATA[25601]:=[ ,,,[4432429138,"RPn"],]; CONWAYPOLDATA[25603]:=[ ,,,[5604317481,"RPn"],]; CONWAYPOLDATA[25609]:=[ ,,,[12453528662,"RPn"],]; CONWAYPOLDATA[25621]:=[ ,,,[6360208292,"RPn"],]; CONWAYPOLDATA[25633]:=[ ,,,[4375399307,"RPn"],]; CONWAYPOLDATA[25639]:=[ ,,,[2573745379,"RPn"],]; CONWAYPOLDATA[25643]:=[ ,,,[5652204419,"RPn"],]; CONWAYPOLDATA[25657]:=[ ,,,[6937704119,"RPn"],]; CONWAYPOLDATA[25667]:=[ ,,,[5928974334,"RPn"],]; CONWAYPOLDATA[25673]:=[ ,,,[4318891774,"RPn"],]; CONWAYPOLDATA[25679]:=[ ,,,[1891720583,"RPn"],]; CONWAYPOLDATA[25693]:=[ ,,,[2492375160,"RPn"],]; CONWAYPOLDATA[25703]:=[ ,,,[6468596906,"RPn"],]; CONWAYPOLDATA[25717]:=[ ,,,[2491642981,"RPn"],]; CONWAYPOLDATA[25733]:=[ ,,,[655033517,"RPn"],]; CONWAYPOLDATA[25741]:=[ ,,,[1781302947,"RPn"],]; CONWAYPOLDATA[25747]:=[ ,,,[5798662101,"RPn"],]; CONWAYPOLDATA[25759]:=[ ,,,[2402052512,"RPn"],]; CONWAYPOLDATA[25763]:=[ ,,,[1718933128,"RPn"],]; CONWAYPOLDATA[25771]:=[ ,,,[5857181340,"RPn"],]; CONWAYPOLDATA[25793]:=[ ,,,[6401771017,"RPn"],]; CONWAYPOLDATA[25799]:=[ ,,,[1934331630,"RPn"],]; CONWAYPOLDATA[25801]:=[ ,,,[1683360451,"RPn"],]; CONWAYPOLDATA[25819]:=[ ,,,[482014914,"RPn"],]; CONWAYPOLDATA[25841]:=[ ,,,[3120119866,"RPn"],]; CONWAYPOLDATA[25847]:=[ ,,,[4414021430,"RPn"],]; CONWAYPOLDATA[25849]:=[ ,,,[597887377,"RPn"],]; CONWAYPOLDATA[25867]:=[ ,,,[5810969818,"RPn"],]; CONWAYPOLDATA[25873]:=[ ,,,[564704108,"RPn"],]; CONWAYPOLDATA[25889]:=[ ,,,[5128688570,"RPn"],]; CONWAYPOLDATA[25903]:=[ ,,,[7168085389,"RPn"],]; CONWAYPOLDATA[25913]:=[ ,,,[5321986030,"RPn"],]; CONWAYPOLDATA[25919]:=[ ,,,[4646732412,"RPn"],]; CONWAYPOLDATA[25931]:=[ ,,,[1978301923,"RPn"],]; CONWAYPOLDATA[25933]:=[ ,,,[8724561393,"RPn"],]; CONWAYPOLDATA[25939]:=[ ,,,[1776406479,"RPn"],]; CONWAYPOLDATA[25943]:=[ ,,,[3794189698,"RPn"],]; CONWAYPOLDATA[25951]:=[ ,,,[1923306466,"RPn"],]; CONWAYPOLDATA[25969]:=[ ,,,[11391405733,"RPn"],]; CONWAYPOLDATA[25981]:=[ ,,,[417540662,"RPn"],]; CONWAYPOLDATA[25997]:=[ ,,,[1838767812,"RPn"],]; CONWAYPOLDATA[25999]:=[ ,,,[412942124,"RPn"],]; CONWAYPOLDATA[26003]:=[ ,,,[5335659584,"RPn"],]; CONWAYPOLDATA[26017]:=[ ,,,[10152978153,"RPn"],]; CONWAYPOLDATA[26021]:=[ ,,,[4470485865,"RPn"],]; CONWAYPOLDATA[26029]:=[ ,,,[7254334364,"RPn"],]; CONWAYPOLDATA[26041]:=[ ,,,[14062270218,"RPn"],]; CONWAYPOLDATA[26053]:=[ ,,,[4736148819,"RPn"],]; CONWAYPOLDATA[26083]:=[ ,,,[7934266026,"RPn"],]; CONWAYPOLDATA[26099]:=[ ,,,[1745005241,"RPn"],]; CONWAYPOLDATA[26107]:=[ ,,,[5882350921,"RPn"],]; CONWAYPOLDATA[26111]:=[ ,,,[4070469908,"RPn"],]; CONWAYPOLDATA[26113]:=[ ,,,[18264398388,"RPn"],]; CONWAYPOLDATA[26119]:=[ ,,,[2682760850,"RPn"],]; CONWAYPOLDATA[26141]:=[ ,,,[6022598851,"RPn"],]; CONWAYPOLDATA[26153]:=[ ,,,[3231177000,"RPn"],]; CONWAYPOLDATA[26161]:=[ ,,,[22534536032,"RPn"],]; CONWAYPOLDATA[26171]:=[ ,,,[6164107974,"RPn"],]; CONWAYPOLDATA[26177]:=[ ,,,[5282780373,"RPn"],]; CONWAYPOLDATA[26183]:=[ ,,,[3843873869,"RPn"],]; CONWAYPOLDATA[26189]:=[ ,,,[1878982185,"RPn"],]; CONWAYPOLDATA[26203]:=[ ,,,[2509277892,"RPn"],]; CONWAYPOLDATA[26209]:=[ ,,,[8796212173,"RPn"],]; CONWAYPOLDATA[26227]:=[ ,,,[2552700140,"RPn"],]; CONWAYPOLDATA[26237]:=[ ,,,[4531051191,"RPn"],]; CONWAYPOLDATA[26249]:=[ ,,,[1987128050,"RPn"],]; CONWAYPOLDATA[26251]:=[ ,,,[5910727664,"RPn"],]; CONWAYPOLDATA[26261]:=[ ,,,[5450102898,"RPn"],]; CONWAYPOLDATA[26263]:=[ ,,,[3846715350,"RPn"],]; CONWAYPOLDATA[26267]:=[ ,,,[5468027659,"RPn"],]; CONWAYPOLDATA[26293]:=[ ,,,[3329561475,"RPn"],]; CONWAYPOLDATA[26297]:=[ ,,,[3267954490,"RPn"],]; CONWAYPOLDATA[26309]:=[ ,,,[2593225514,"RPn"],]; CONWAYPOLDATA[26317]:=[ ,,,[4696426558,"RPn"],]; CONWAYPOLDATA[26321]:=[ ,,,[692479192,"RPn"],]; CONWAYPOLDATA[26339]:=[ ,,,[2026153916,"RPn"],]; CONWAYPOLDATA[26347]:=[ ,,,[3994995613,"RPn"],]; CONWAYPOLDATA[26357]:=[ ,,,[1921978799,"RPn"],]; CONWAYPOLDATA[26371]:=[ ,,,[2713602274,"RPn"],]; CONWAYPOLDATA[26387]:=[ ,,,[576793435,"RPn"],]; CONWAYPOLDATA[26393]:=[ ,,,[18783317457,"RPn"],]; CONWAYPOLDATA[26399]:=[ ,,,[8218510288,"RPn"],]; CONWAYPOLDATA[26407]:=[ ,,,[2789212973,"RPn"],]; CONWAYPOLDATA[26417]:=[ ,,,[4621654153,"RPn"],]; CONWAYPOLDATA[26423]:=[ ,,,[5307376631,"RPn"],]; CONWAYPOLDATA[26431]:=[ ,,,[2664694130,"RPn"],]; CONWAYPOLDATA[26437]:=[ ,,,[2657103564,"RPn"],]; CONWAYPOLDATA[26449]:=[ ,,,[478621111,"RPn"],]; CONWAYPOLDATA[26459]:=[ ,,,[1092888997,"RPn"],]; CONWAYPOLDATA[26479]:=[ ,,,[2040233432,"RPn"],]; CONWAYPOLDATA[26489]:=[ ,,,[5990487353,"RPn"],]; CONWAYPOLDATA[26497]:=[ ,,,[11106456028,"RPn"],]; CONWAYPOLDATA[26501]:=[ ,,,[2465838549,"RPn"],]; CONWAYPOLDATA[26513]:=[ ,,,[1200057922,"RPn"],]; CONWAYPOLDATA[26539]:=[ ,,,[6191362929,"RPn"],]; CONWAYPOLDATA[26557]:=[ ,,,[4683751864,"RPn"],]; CONWAYPOLDATA[26561]:=[ ,,,[5583600301,"RPn"],]; CONWAYPOLDATA[26573]:=[ ,,,[5629144603,"RPn"],]; CONWAYPOLDATA[26591]:=[ ,,,[3990245482,"RPn"],]; CONWAYPOLDATA[26597]:=[ ,,,[5357779473,"RPn"],]; CONWAYPOLDATA[26627]:=[ ,,,[1980676024,"RPn"],]; CONWAYPOLDATA[26633]:=[ ,,,[1262404203,"RPn"],]; CONWAYPOLDATA[26641]:=[ ,,,[12612728560,"RPn"],]; CONWAYPOLDATA[26647]:=[ ,,,[4720862464,"RPn"],]; CONWAYPOLDATA[26669]:=[ ,,,[6764591852,"RPn"],]; CONWAYPOLDATA[26681]:=[ ,,,[360807169,"RPn"],]; CONWAYPOLDATA[26683]:=[ ,,,[1802916946,"RPn"],]; CONWAYPOLDATA[26687]:=[ ,,,[2848677133,"RPn"],]; CONWAYPOLDATA[26693]:=[ ,,,[6367535073,"RPn"],]; CONWAYPOLDATA[26699]:=[ ,,,[3520556841,"RPn"],]; CONWAYPOLDATA[26701]:=[ ,,,[2834871893,"RPn"],]; CONWAYPOLDATA[26711]:=[ ,,,[7521684056,"RPn"],]; CONWAYPOLDATA[26713]:=[ ,,,[10573806800,"RPn"],]; CONWAYPOLDATA[26717]:=[ ,,,[4840960100,"RPn"],]; CONWAYPOLDATA[26723]:=[ ,,,[5466296544,"RPn"],]; CONWAYPOLDATA[26729]:=[ ,,,[3301084961,"RPn"],]; CONWAYPOLDATA[26731]:=[ ,,,[4154932988,"RPn"],]; CONWAYPOLDATA[26737]:=[ ,,,[6387950576,"RPn"],]; CONWAYPOLDATA[26759]:=[ ,,,[3455871345,"RPn"],]; CONWAYPOLDATA[26777]:=[ ,,,[6848298084,"RPn"],]; CONWAYPOLDATA[26783]:=[ ,,,[1949695273,"RPn"],]; CONWAYPOLDATA[26801]:=[ ,,,[717971992,"RPn"],]; CONWAYPOLDATA[26813]:=[ ,,,[2545813913,"RPn"],]; CONWAYPOLDATA[26821]:=[ ,,,[4700433894,"RPn"],]; CONWAYPOLDATA[26833]:=[ ,,,[15070673956,"RPn"],]; CONWAYPOLDATA[26839]:=[ ,,,[4929707006,"RPn"],]; CONWAYPOLDATA[26849]:=[ ,,,[2676469417,"RPn"],]; CONWAYPOLDATA[26861]:=[ ,,,[3404819779,"RPn"],]; CONWAYPOLDATA[26863]:=[ ,,,[2886375629,"RPn"],]; CONWAYPOLDATA[26879]:=[ ,,,[3599178750,"RPn"],]; CONWAYPOLDATA[26881]:=[ ,,,[18064193297,"RPn"],]; CONWAYPOLDATA[26891]:=[ ,,,[454350342,"RPn"],]; CONWAYPOLDATA[26893]:=[ ,,,[16564635783,"RPn"],]; CONWAYPOLDATA[26903]:=[ ,,,[2075243619,"RPn"],]; CONWAYPOLDATA[26921]:=[ ,,,[2037219767,"RPn"],]; CONWAYPOLDATA[26927]:=[ ,,,[3508830448,"RPn"],]; CONWAYPOLDATA[26947]:=[ ,,,[6433623199,"RPn"],]; CONWAYPOLDATA[26951]:=[ ,,,[3563811590,"RPn"],]; CONWAYPOLDATA[26953]:=[ ,,,[15705944355,"RPn"],]; CONWAYPOLDATA[26959]:=[ ,,,[4086714816,"RPn"],]; CONWAYPOLDATA[26981]:=[ ,,,[1861095421,"RPn"],]; CONWAYPOLDATA[26987]:=[ ,,,[13579615519,"RPn"],]; CONWAYPOLDATA[26993]:=[ ,,,[8684295935,"RPn"],]; CONWAYPOLDATA[27011]:=[ ,,,[4996710870,"RPn"],]; CONWAYPOLDATA[27017]:=[ ,,,[3427376625,"RPn"],]; CONWAYPOLDATA[27031]:=[ ,,,[3400445744,"RPn"],]; CONWAYPOLDATA[27043]:=[ ,,,[7937553190,"RPn"],]; CONWAYPOLDATA[27059]:=[ ,,,[5541926733,"RPn"],]; CONWAYPOLDATA[27061]:=[ ,,,[4876635751,"RPn"],]; CONWAYPOLDATA[27067]:=[ ,,,[2186959468,"RPn"],]; CONWAYPOLDATA[27073]:=[ ,,,[12453796589,"RPn"],]; CONWAYPOLDATA[27077]:=[ ,,,[9185087019,"RPn"],]; CONWAYPOLDATA[27091]:=[ ,,,[6388545440,"RPn"],]; CONWAYPOLDATA[27103]:=[ ,,,[4056695734,"RPn"],]; CONWAYPOLDATA[27107]:=[ ,,,[7942757607,"RPn"],]; CONWAYPOLDATA[27109]:=[ ,,,[3674380976,"RPn"],]; CONWAYPOLDATA[27127]:=[ ,,,[2626843048,"RPn"],]; CONWAYPOLDATA[27143]:=[ ,,,[4395157423,"RPn"],]; CONWAYPOLDATA[27179]:=[ ,,,[7208930783,"RPn"],]; CONWAYPOLDATA[27191]:=[ ,,,[3555603950,"RPn"],]; CONWAYPOLDATA[27197]:=[ ,,,[5700681581,"RPn"],]; CONWAYPOLDATA[27211]:=[ ,,,[1859790227,"RPn"],]; CONWAYPOLDATA[27239]:=[ ,,,[3709570461,"RPn"],]; CONWAYPOLDATA[27241]:=[ ,,,[15465750875,"RPn"],]; CONWAYPOLDATA[27253]:=[ ,,,[8067787351,"RPn"],]; CONWAYPOLDATA[27259]:=[ ,,,[6569773369,"RPn"],]; CONWAYPOLDATA[27271]:=[ ,,,[4210369696,"RPn"],]; CONWAYPOLDATA[27277]:=[ ,,,[9509335023,"RPn"],]; CONWAYPOLDATA[27281]:=[ ,,,[631964371,"RPn"],]; CONWAYPOLDATA[27283]:=[ ,,,[4380667617,"RPn"],]; CONWAYPOLDATA[27299]:=[ ,,,[1247700797,"RPn"],]; CONWAYPOLDATA[27329]:=[ ,,,[746546296,"RPn"],]; CONWAYPOLDATA[27337]:=[ ,,,[5103899916,"RPn"],]; CONWAYPOLDATA[27361]:=[ ,,,[637949083,"RPn"],]; CONWAYPOLDATA[27367]:=[ ,,,[4189340363,"RPn"],]; CONWAYPOLDATA[27397]:=[ ,,,[2979259370,"RPn"],]; CONWAYPOLDATA[27407]:=[ ,,,[6729185901,"RPn"],]; CONWAYPOLDATA[27409]:=[ ,,,[9490421081,"RPn"],]; CONWAYPOLDATA[27427]:=[ ,,,[8254841330,"RPn"],]; CONWAYPOLDATA[27431]:=[ ,,,[2078282301,"RPn"],]; CONWAYPOLDATA[27437]:=[ ,,,[9600590420,"RPn"],]; CONWAYPOLDATA[27449]:=[ ,,,[753118216,"RPn"],]; CONWAYPOLDATA[27457]:=[ ,,,[6740171824,"RPn"],]; CONWAYPOLDATA[27479]:=[ ,,,[8943590137,"RPn"],]; CONWAYPOLDATA[27481]:=[ ,,,[459509808,"RPn"],]; CONWAYPOLDATA[27487]:=[ ,,,[2663572764,"RPn"],]; CONWAYPOLDATA[27509]:=[ ,,,[9521580136,"RPn"],]; CONWAYPOLDATA[27527]:=[ ,,,[2018472334,"RPn"],]; CONWAYPOLDATA[27529]:=[ ,,,[515893467,"RPn"],]; CONWAYPOLDATA[27539]:=[ ,,,[5807562017,"RPn"],]; CONWAYPOLDATA[27541]:=[ ,,,[394579926,"RPn"],]; CONWAYPOLDATA[27551]:=[ ,,,[3036010013,"RPn"],]; CONWAYPOLDATA[27581]:=[ ,,,[5169175860,"RPn"],]; CONWAYPOLDATA[27583]:=[ ,,,[2035515071,"RPn"],]; CONWAYPOLDATA[27611]:=[ ,,,[10431629079,"RPn"],]; CONWAYPOLDATA[27617]:=[ ,,,[11213358130,"RPn"],]; CONWAYPOLDATA[27631]:=[ ,,,[4421263947,"RPn"],]; CONWAYPOLDATA[27647]:=[ ,,,[4554290315,"RPn"],]; CONWAYPOLDATA[27653]:=[ ,,,[1400209657,"RPn"],]; CONWAYPOLDATA[27673]:=[ ,,,[5960570500,"RPn"],]; CONWAYPOLDATA[27689]:=[ ,,,[5800208656,"RPn"],]; CONWAYPOLDATA[27691]:=[ ,,,[4488821867,"RPn"],]; CONWAYPOLDATA[27697]:=[ ,,,[6531118787,"RPn"],]; CONWAYPOLDATA[27701]:=[ ,,,[9843467249,"RPn"],]; CONWAYPOLDATA[27733]:=[ ,,,[2771275493,"RPn"],]; CONWAYPOLDATA[27737]:=[ ,,,[6008139310,"RPn"],]; CONWAYPOLDATA[27739]:=[ ,,,[1961091825,"RPn"],]; CONWAYPOLDATA[27743]:=[ ,,,[7374200377,"RPn"],]; CONWAYPOLDATA[27749]:=[ ,,,[2216423629,"RPn"],]; CONWAYPOLDATA[27751]:=[ ,,,[3850479004,"RPn"],]; CONWAYPOLDATA[27763]:=[ ,,,[4377531028,"RPn"],]; CONWAYPOLDATA[27767]:=[ ,,,[2946300841,"RPn"],]; CONWAYPOLDATA[27773]:=[ ,,,[2023457463,"RPn"],]; CONWAYPOLDATA[27779]:=[ ,,,[1935307374,"RPn"],]; CONWAYPOLDATA[27791]:=[ ,,,[3614497467,"RPn"],]; CONWAYPOLDATA[27793]:=[ ,,,[11586457017,"RPn"],]; CONWAYPOLDATA[27799]:=[ ,,,[10801635045,"RPn"],]; CONWAYPOLDATA[27803]:=[ ,,,[8315849499,"RPn"],]; CONWAYPOLDATA[27809]:=[ ,,,[2265543615,"RPn"],]; CONWAYPOLDATA[27817]:=[ ,,,[12115388368,"RPn"],]; CONWAYPOLDATA[27823]:=[ ,,,[4439410063,"RPn"],]; CONWAYPOLDATA[27827]:=[ ,,,[3498271307,"RPn"],]; CONWAYPOLDATA[27847]:=[ ,,,[2080560764,"RPn"],]; CONWAYPOLDATA[27851]:=[ ,,,[3769883511,"RPn"],]; CONWAYPOLDATA[27883]:=[ ,,,[2820839464,"RPn"],]; CONWAYPOLDATA[27893]:=[ ,,,[7564693174,"RPn"],]; CONWAYPOLDATA[27901]:=[ ,,,[6702545628,"RPn"],]; CONWAYPOLDATA[27917]:=[ ,,,[6060529449,"RPn"],]; CONWAYPOLDATA[27919]:=[ ,,,[2900672427,"RPn"],]; CONWAYPOLDATA[27941]:=[ ,,,[5333042790,"RPn"],]; CONWAYPOLDATA[27943]:=[ ,,,[7752254438,"RPn"],]; CONWAYPOLDATA[27947]:=[ ,,,[8501393561,"RPn"],]; CONWAYPOLDATA[27953]:=[ ,,,[3873475166,"RPn"],]; CONWAYPOLDATA[27961]:=[ ,,,[780727055,"RPn"],]; CONWAYPOLDATA[27967]:=[ ,,,[5360127256,"RPn"],]; CONWAYPOLDATA[27983]:=[ ,,,[2271659945,"RPn"],]; CONWAYPOLDATA[27997]:=[ ,,,[5231183461,"RPn"],]; CONWAYPOLDATA[28001]:=[ ,,,[6226778380,"RPn"],]; CONWAYPOLDATA[28019]:=[ ,,,[7483258484,"RPn"],]; CONWAYPOLDATA[28027]:=[ ,,,[2227698070,"RPn"],]; CONWAYPOLDATA[28031]:=[ ,,,[2073677337,"RPn"],]; CONWAYPOLDATA[28051]:=[ ,,,[6992216670,"RPn"],]; CONWAYPOLDATA[28057]:=[ ,,,[9999122007,"RPn"],]; CONWAYPOLDATA[28069]:=[ ,,,[13134271039,"RPn"],]; CONWAYPOLDATA[28081]:=[ ,,,[16395232274,"RPn"],]; CONWAYPOLDATA[28087]:=[ ,,,[5444524518,"RPn"],]; CONWAYPOLDATA[28097]:=[ ,,,[1232250132,"RPn"],]; CONWAYPOLDATA[28099]:=[ ,,,[7081509982,"RPn"],]; CONWAYPOLDATA[28109]:=[ ,,,[6178217657,"RPn"],]; CONWAYPOLDATA[28111]:=[ ,,,[2128058925,"RPn"],]; CONWAYPOLDATA[28123]:=[ ,,,[6997058648,"RPn"],]; CONWAYPOLDATA[28151]:=[ ,,,[2210979547,"RPn"],]; CONWAYPOLDATA[28163]:=[ ,,,[6995661039,"RPn"],]; CONWAYPOLDATA[28181]:=[ ,,,[3053129542,"RPn"],]; CONWAYPOLDATA[28183]:=[ ,,,[3971294716,"RPn"],]; CONWAYPOLDATA[28201]:=[ ,,,[11684322934,"RPn"],]; CONWAYPOLDATA[28211]:=[ ,,,[6886982166,"RPn"],]; CONWAYPOLDATA[28219]:=[ ,,,[3003743239,"RPn"],]; CONWAYPOLDATA[28229]:=[ ,,,[1484252593,"RPn"],]; CONWAYPOLDATA[28277]:=[ ,,,[5316415326,"RPn"],]; CONWAYPOLDATA[28279]:=[ ,,,[5322956173,"RPn"],]; CONWAYPOLDATA[28283]:=[ ,,,[2314963552,"RPn"],]; CONWAYPOLDATA[28289]:=[ ,,,[6092064445,"RPn"],]; CONWAYPOLDATA[28297]:=[ ,,,[12616245752,"RPn"],]; CONWAYPOLDATA[28307]:=[ ,,,[2176100627,"RPn"],]; CONWAYPOLDATA[28309]:=[ ,,,[8793568054,"RPn"],]; CONWAYPOLDATA[28319]:=[ ,,,[2269597943,"RPn"],]; CONWAYPOLDATA[28349]:=[ ,,,[7147208137,"RPn"],]; CONWAYPOLDATA[28351]:=[ ,,,[3159038532,"RPn"],]; CONWAYPOLDATA[28387]:=[ ,,,[6970740109,"RPn"],]; CONWAYPOLDATA[28393]:=[ ,,,[5261052557,"RPn"],]; CONWAYPOLDATA[28403]:=[ ,,,[3226808029,"RPn"],]; CONWAYPOLDATA[28409]:=[ ,,,[2351327706,"RPn"],]; CONWAYPOLDATA[28411]:=[ ,,,[2169833305,"RPn"],]; CONWAYPOLDATA[28429]:=[ ,,,[9452301354,"RPn"],]; CONWAYPOLDATA[28433]:=[ ,,,[7958965363,"RPn"],]; CONWAYPOLDATA[28439]:=[ ,,,[2901488986,"RPn"],]; CONWAYPOLDATA[28447]:=[ ,,,[4046045260,"RPn"],]; CONWAYPOLDATA[28463]:=[ ,,,[6232685430,"RPn"],]; CONWAYPOLDATA[28477]:=[ ,,,[10142112029,"RPn"],]; CONWAYPOLDATA[28493]:=[ ,,,[3905649484,"RPn"],]; CONWAYPOLDATA[28499]:=[ ,,,[691243247,"RPn"],]; CONWAYPOLDATA[28513]:=[ ,,,[5684123581,"RPn"],]; CONWAYPOLDATA[28517]:=[ ,,,[4049414002,"RPn"],]; CONWAYPOLDATA[28537]:=[ ,,,[5434158230,"RPn"],]; CONWAYPOLDATA[28541]:=[ ,,,[6346576549,"RPn"],]; CONWAYPOLDATA[28547]:=[ ,,,[1345248830,"RPn"],]; CONWAYPOLDATA[28549]:=[ ,,,[7943987644,"RPn"],]; CONWAYPOLDATA[28559]:=[ ,,,[3063238351,"RPn"],]; CONWAYPOLDATA[28571]:=[ ,,,[7235748607,"RPn"],]; CONWAYPOLDATA[28573]:=[ ,,,[6292460354,"RPn"],]; CONWAYPOLDATA[28579]:=[ ,,,[2243994503,"RPn"],]; CONWAYPOLDATA[28591]:=[ ,,,[3021525474,"RPn"],]; CONWAYPOLDATA[28597]:=[ ,,,[5448700800,"RPn"],]; CONWAYPOLDATA[28603]:=[ ,,,[7083447143,"RPn"],]; CONWAYPOLDATA[28607]:=[ ,,,[3273327373,"RPn"],]; CONWAYPOLDATA[28619]:=[ ,,,[16328799404,"RPn"],]; CONWAYPOLDATA[28621]:=[ ,,,[3232799205,"RPn"],]; CONWAYPOLDATA[28627]:=[ ,,,[4794593100,"RPn"],]; CONWAYPOLDATA[28631]:=[ ,,,[6243648074,"RPn"],]; CONWAYPOLDATA[28643]:=[ ,,,[7383592542,"RPn"],]; CONWAYPOLDATA[28649]:=[ ,,,[3773016005,"RPn"],]; CONWAYPOLDATA[28657]:=[ ,,,[1330573172,"RPn"],]; CONWAYPOLDATA[28661]:=[ ,,,[3166266655,"RPn"],]; CONWAYPOLDATA[28663]:=[ ,,,[4615402252,"RPn"],]; CONWAYPOLDATA[28669]:=[ ,,,[9609820137,"RPn"],]; CONWAYPOLDATA[28687]:=[ ,,,[6415589373,"RPn"],]; CONWAYPOLDATA[28697]:=[ ,,,[2064232607,"RPn"],]; CONWAYPOLDATA[28703]:=[ ,,,[3294185909,"RPn"],]; CONWAYPOLDATA[28711]:=[ ,,,[3260880539,"RPn"],]; CONWAYPOLDATA[28723]:=[ ,,,[7239603429,"RPn"],]; CONWAYPOLDATA[28729]:=[ ,,,[10382143500,"RPn"],]; CONWAYPOLDATA[28751]:=[ ,,,[5400932866,"RPn"],]; CONWAYPOLDATA[28753]:=[ ,,,[8972488672,"RPn"],]; CONWAYPOLDATA[28759]:=[ ,,,[3168321515,"RPn"],]; CONWAYPOLDATA[28771]:=[ ,,,[7291348219,"RPn"],]; CONWAYPOLDATA[28789]:=[ ,,,[3899210956,"RPn"],]; CONWAYPOLDATA[28793]:=[ ,,,[5524599292,"RPn"],]; CONWAYPOLDATA[28807]:=[ ,,,[557530689,"RPn"],]; CONWAYPOLDATA[28813]:=[ ,,,[8033784727,"RPn"],]; CONWAYPOLDATA[28817]:=[ ,,,[5506150644,"RPn"],]; CONWAYPOLDATA[28837]:=[ ,,,[8064497748,"RPn"],]; CONWAYPOLDATA[28843]:=[ ,,,[2323332495,"RPn"],]; CONWAYPOLDATA[28859]:=[ ,,,[3837352373,"RPn"],]; CONWAYPOLDATA[28867]:=[ ,,,[3032911358,"RPn"],]; CONWAYPOLDATA[28871]:=[ ,,,[2929136189,"RPn"],]; CONWAYPOLDATA[28879]:=[ ,,,[3312450182,"RPn"],]; CONWAYPOLDATA[28901]:=[ ,,,[12186742475,"RPn"],]; CONWAYPOLDATA[28909]:=[ ,,,[6305168538,"RPn"],]; CONWAYPOLDATA[28921]:=[ ,,,[13833348126,"RPn"],]; CONWAYPOLDATA[28927]:=[ ,,,[4994593677,"RPn"],]; CONWAYPOLDATA[28933]:=[ ,,,[8098057372,"RPn"],]; CONWAYPOLDATA[28949]:=[ ,,,[6661135953,"RPn"],]; CONWAYPOLDATA[28961]:=[ ,,,[838391992,"RPn"],]; CONWAYPOLDATA[28979]:=[ ,,,[5573936778,"RPn"],]; CONWAYPOLDATA[29009]:=[ ,,,[4126124127,"RPn"],]; CONWAYPOLDATA[29017]:=[ ,,,[19800881618,"RPn"],]; CONWAYPOLDATA[29021]:=[ ,,,[4200035206,"RPn"],]; CONWAYPOLDATA[29023]:=[ ,,,[5582109685,"RPn"],]; CONWAYPOLDATA[29027]:=[ ,,,[2132468557,"RPn"],]; CONWAYPOLDATA[29033]:=[ ,,,[4761208772,"RPn"],]; CONWAYPOLDATA[29059]:=[ ,,,[2337186313,"RPn"],]; CONWAYPOLDATA[29063]:=[ ,,,[3929375736,"RPn"],]; CONWAYPOLDATA[29077]:=[ ,,,[8040924505,"RPn"],]; CONWAYPOLDATA[29101]:=[ ,,,[5699663660,"RPn"],]; CONWAYPOLDATA[29123]:=[ ,,,[10153442722,"RPn"],]; CONWAYPOLDATA[29129]:=[ ,,,[848149096,"RPn"],]; CONWAYPOLDATA[29131]:=[ ,,,[7561154969,"RPn"],]; CONWAYPOLDATA[29137]:=[ ,,,[5568809130,"RPn"],]; CONWAYPOLDATA[29147]:=[ ,,,[3960844126,"RPn"],]; CONWAYPOLDATA[29153]:=[ ,,,[1356372481,"RPn"],]; CONWAYPOLDATA[29167]:=[ ,,,[7324358709,"RPn"],]; CONWAYPOLDATA[29173]:=[ ,,,[9135933374,"RPn"],]; CONWAYPOLDATA[29179]:=[ ,,,[2541053228,"RPn"],]; CONWAYPOLDATA[29191]:=[ ,,,[2349320878,"RPn"],]; CONWAYPOLDATA[29201]:=[ ,,,[6794255075,"RPn"],]; CONWAYPOLDATA[29207]:=[ ,,,[3412078573,"RPn"],]; CONWAYPOLDATA[29209]:=[ ,,,[741645726,"RPn"],]; CONWAYPOLDATA[29221]:=[ ,,,[6669693252,"RPn"],]; CONWAYPOLDATA[29231]:=[ ,,,[3881672196,"RPn"],]; CONWAYPOLDATA[29243]:=[ ,,,[6778966047,"RPn"],]; CONWAYPOLDATA[29251]:=[ ,,,[6782283117,"RPn"],]; CONWAYPOLDATA[29269]:=[ ,,,[2305577674,"RPn"],]; CONWAYPOLDATA[29287]:=[ ,,,[2400216090,"RPn"],]; CONWAYPOLDATA[29297]:=[ ,,,[21938208840,"RPn"],]; CONWAYPOLDATA[29303]:=[ ,,,[9280553137,"RPn"],]; CONWAYPOLDATA[29311]:=[ ,,,[2317474218,"RPn"],]; CONWAYPOLDATA[29327]:=[ ,,,[2305366148,"RPn"],]; CONWAYPOLDATA[29333]:=[ ,,,[3362265794,"RPn"],]; CONWAYPOLDATA[29339]:=[ ,,,[787605457,"RPn"],]; CONWAYPOLDATA[29347]:=[ ,,,[3235154589,"RPn"],]; CONWAYPOLDATA[29363]:=[ ,,,[2376494407,"RPn"],]; CONWAYPOLDATA[29383]:=[ ,,,[3889486482,"RPn"],]; CONWAYPOLDATA[29387]:=[ ,,,[14326515146,"RPn"],]; CONWAYPOLDATA[29389]:=[ ,,,[7773214168,"RPn"],]; CONWAYPOLDATA[29399]:=[ ,,,[5155144062,"RPn"],]; CONWAYPOLDATA[29401]:=[ ,,,[19742742112,"RPn"],]; CONWAYPOLDATA[29411]:=[ ,,,[439194465,"RPn"],]; CONWAYPOLDATA[29423]:=[ ,,,[4894545478,"RPn"],]; CONWAYPOLDATA[29429]:=[ ,,,[6806839415,"RPn"],]; CONWAYPOLDATA[29437]:=[ ,,,[11138313188,"RPn"],]; CONWAYPOLDATA[29443]:=[ ,,,[17876346895,"RPn"],]; CONWAYPOLDATA[29453]:=[ ,,,[2199962384,"RPn"],]; CONWAYPOLDATA[29473]:=[ ,,,[13662385993,"RPn"],]; CONWAYPOLDATA[29483]:=[ ,,,[2481790493,"RPn"],]; CONWAYPOLDATA[29501]:=[ ,,,[2331641038,"RPn"],]; CONWAYPOLDATA[29527]:=[ ,,,[5877880839,"RPn"],]; CONWAYPOLDATA[29531]:=[ ,,,[2391627099,"RPn"],]; CONWAYPOLDATA[29537]:=[ ,,,[5979322598,"RPn"],]; CONWAYPOLDATA[29567]:=[ ,,,[6725309825,"RPn"],]; CONWAYPOLDATA[29569]:=[ ,,,[18023222156,"RPn"],]; CONWAYPOLDATA[29573]:=[ ,,,[6043479136,"RPn"],]; CONWAYPOLDATA[29581]:=[ ,,,[6640135823,"RPn"],]; CONWAYPOLDATA[29587]:=[ ,,,[2532055462,"RPn"],]; CONWAYPOLDATA[29599]:=[ ,,,[8476384039,"RPn"],]; CONWAYPOLDATA[29611]:=[ ,,,[6036409630,"RPn"],]; CONWAYPOLDATA[29629]:=[ ,,,[4211762357,"RPn"],]; CONWAYPOLDATA[29633]:=[ ,,,[4259921551,"RPn"],]; CONWAYPOLDATA[29641]:=[ ,,,[735245012,"RPn"],]; CONWAYPOLDATA[29663]:=[ ,,,[3519455629,"RPn"],]; CONWAYPOLDATA[29669]:=[ ,,,[3471451016,"RPn"],]; CONWAYPOLDATA[29671]:=[ ,,,[3440500811,"RPn"],]; CONWAYPOLDATA[29683]:=[ ,,,[3115616740,"RPn"],]; CONWAYPOLDATA[29717]:=[ ,,,[3391452627,"RPn"],]; CONWAYPOLDATA[29723]:=[ ,,,[6678371703,"RPn"],]; CONWAYPOLDATA[29741]:=[ ,,,[3142077170,"RPn"],]; CONWAYPOLDATA[29753]:=[ ,,,[4320403380,"RPn"],]; CONWAYPOLDATA[29759]:=[ ,,,[2450742934,"RPn"],]; CONWAYPOLDATA[29761]:=[ ,,,[11269597887,"RPn"],]; CONWAYPOLDATA[29789]:=[ ,,,[5824613383,"RPn"],]; CONWAYPOLDATA[29803]:=[ ,,,[10394869165,"RPn"],]; CONWAYPOLDATA[29819]:=[ ,,,[5104297150,"RPn"],]; CONWAYPOLDATA[29833]:=[ ,,,[5983903145,"RPn"],]; CONWAYPOLDATA[29837]:=[ ,,,[4164648462,"RPn"],]; CONWAYPOLDATA[29851]:=[ ,,,[2366646984,"RPn"],]; CONWAYPOLDATA[29863]:=[ ,,,[2519720498,"RPn"],]; CONWAYPOLDATA[29867]:=[ ,,,[7052434978,"RPn"],]; CONWAYPOLDATA[29873]:=[ ,,,[5973464829,"RPn"],]; CONWAYPOLDATA[29879]:=[ ,,,[3429481752,"RPn"],]; CONWAYPOLDATA[29881]:=[ ,,,[14948209305,"RPn"],]; CONWAYPOLDATA[29917]:=[ ,,,[3478838513,"RPn"],]; CONWAYPOLDATA[29921]:=[ ,,,[894907192,"RPn"],]; CONWAYPOLDATA[29927]:=[ ,,,[6218651043,"RPn"],]; CONWAYPOLDATA[29947]:=[ ,,,[3504697413,"RPn"],]; CONWAYPOLDATA[29959]:=[ ,,,[3381712008,"RPn"],]; CONWAYPOLDATA[29983]:=[ ,,,[15894827829,"RPn"],]; CONWAYPOLDATA[29989]:=[ ,,,[3524097359,"RPn"],]; CONWAYPOLDATA[30011]:=[ ,,,[808826463,"RPn"],]; CONWAYPOLDATA[30013]:=[ ,,,[11651316719,"RPn"],]; CONWAYPOLDATA[30029]:=[ ,,,[1418690078,"RPn"],]; CONWAYPOLDATA[30047]:=[ ,,,[3370011431,"RPn"],]; CONWAYPOLDATA[30059]:=[ ,,,[7211063925,"RPn"],]; CONWAYPOLDATA[30071]:=[ ,,,[2644804605,"RPn"],]; CONWAYPOLDATA[30089]:=[ ,,,[2275330183,"RPn"],]; CONWAYPOLDATA[30091]:=[ ,,,[5980044633,"RPn"],]; CONWAYPOLDATA[30097]:=[ ,,,[19594200405,"RPn"],]; CONWAYPOLDATA[30103]:=[ ,,,[6103533768,"RPn"],]; CONWAYPOLDATA[30109]:=[ ,,,[30500748201,"RPn"],]; CONWAYPOLDATA[30113]:=[ ,,,[668930185,"RPn"],]; CONWAYPOLDATA[30119]:=[ ,,,[7942681501,"RPn"],]; CONWAYPOLDATA[30133]:=[ ,,,[6156322570,"RPn"],]; CONWAYPOLDATA[30137]:=[ ,,,[6883953817,"RPn"],]; CONWAYPOLDATA[30139]:=[ ,,,[11532447240,"RPn"],]; CONWAYPOLDATA[30161]:=[ ,,,[4272697746,"RPn"],]; CONWAYPOLDATA[30169]:=[ ,,,[2410171248,"RPn"],]; CONWAYPOLDATA[30181]:=[ ,,,[6038191948,"RPn"],]; CONWAYPOLDATA[30187]:=[ ,,,[6971657468,"RPn"],]; CONWAYPOLDATA[30197]:=[ ,,,[1566861938,"RPn"],]; CONWAYPOLDATA[30203]:=[ ,,,[8209779462,"RPn"],]; CONWAYPOLDATA[30211]:=[ ,,,[5966914190,"RPn"],]; CONWAYPOLDATA[30223]:=[ ,,,[5411669937,"RPn"],]; CONWAYPOLDATA[30241]:=[ ,,,[11480602528,"RPn"],]; CONWAYPOLDATA[30253]:=[ ,,,[6140572424,"RPn"],]; CONWAYPOLDATA[30259]:=[ ,,,[3650657576,"RPn"],]; CONWAYPOLDATA[30269]:=[ ,,,[3407774830,"RPn"],]; CONWAYPOLDATA[30271]:=[ ,,,[2339887761,"RPn"],]; CONWAYPOLDATA[30293]:=[ ,,,[7074142534,"RPn"],]; CONWAYPOLDATA[30307]:=[ ,,,[8139672220,"RPn"],]; CONWAYPOLDATA[30313]:=[ ,,,[6066116313,"RPn"],]; CONWAYPOLDATA[30319]:=[ ,,,[14267818213,"RPn"],]; CONWAYPOLDATA[30323]:=[ ,,,[2688801058,"RPn"],]; CONWAYPOLDATA[30341]:=[ ,,,[3635033848,"RPn"],]; CONWAYPOLDATA[30347]:=[ ,,,[13427788827,"RPn"],]; CONWAYPOLDATA[30367]:=[ ,,,[11065491869,"RPn"],]; CONWAYPOLDATA[30389]:=[ ,,,[6243207329,"RPn"],]; CONWAYPOLDATA[30391]:=[ ,,,[3500800075,"RPn"],]; CONWAYPOLDATA[30403]:=[ ,,,[13540158473,"RPn"],]; CONWAYPOLDATA[30427]:=[ ,,,[6975694025,"RPn"],]; CONWAYPOLDATA[30431]:=[ ,,,[4215515148,"RPn"],]; CONWAYPOLDATA[30449]:=[ ,,,[926776216,"RPn"],]; CONWAYPOLDATA[30467]:=[ ,,,[7213519257,"RPn"],]; CONWAYPOLDATA[30469]:=[ ,,,[3696620958,"RPn"],]; CONWAYPOLDATA[30491]:=[ ,,,[15773421176,"RPn"],]; CONWAYPOLDATA[30493]:=[ ,,,[4431059808,"RPn"],]; CONWAYPOLDATA[30497]:=[ ,,,[6365882789,"RPn"],]; CONWAYPOLDATA[30509]:=[ ,,,[2708985639,"RPn"],]; CONWAYPOLDATA[30517]:=[ ,,,[10109610728,"RPn"],]; CONWAYPOLDATA[30529]:=[ ,,,[13636541088,"RPn"],]; CONWAYPOLDATA[30539]:=[ ,,,[7076497082,"RPn"],]; CONWAYPOLDATA[30553]:=[ ,,,[9926761364,"RPn"],]; CONWAYPOLDATA[30557]:=[ ,,,[7015214948,"RPn"],]; CONWAYPOLDATA[30559]:=[ ,,,[827140460,"RPn"],]; CONWAYPOLDATA[30577]:=[ ,,,[14023957593,"RPn"],]; CONWAYPOLDATA[30593]:=[ ,,,[4271578221,"RPn"],]; CONWAYPOLDATA[30631]:=[ ,,,[2488768753,"RPn"],]; CONWAYPOLDATA[30637]:=[ ,,,[3534835788,"RPn"],]; CONWAYPOLDATA[30643]:=[ ,,,[8145093260,"RPn"],]; CONWAYPOLDATA[30649]:=[ ,,,[28875311728,"RPn"],]; CONWAYPOLDATA[30661]:=[ ,,,[6263735692,"RPn"],]; CONWAYPOLDATA[30671]:=[ ,,,[3363289858,"RPn"],]; CONWAYPOLDATA[30677]:=[ ,,,[6382104436,"RPn"],]; CONWAYPOLDATA[30689]:=[ ,,,[941446456,"RPn"],]; CONWAYPOLDATA[30697]:=[ ,,,[15957405702,"RPn"],]; CONWAYPOLDATA[30703]:=[ ,,,[5389266890,"RPn"],]; CONWAYPOLDATA[30707]:=[ ,,,[4506405787,"RPn"],]; CONWAYPOLDATA[30713]:=[ ,,,[847003117,"RPn"],]; CONWAYPOLDATA[30727]:=[ ,,,[6426306237,"RPn"],]; CONWAYPOLDATA[30757]:=[ ,,,[6489603977,"RPn"],]; CONWAYPOLDATA[30763]:=[ ,,,[7394071630,"RPn"],]; CONWAYPOLDATA[30773]:=[ ,,,[12310369377,"RPn"],]; CONWAYPOLDATA[30781]:=[ ,,,[6278492915,"RPn"],]; CONWAYPOLDATA[30803]:=[ ,,,[12844481366,"RPn"],]; CONWAYPOLDATA[30809]:=[ ,,,[5591956739,"RPn"],]; CONWAYPOLDATA[30817]:=[ ,,,[6456315590,"RPn"],]; CONWAYPOLDATA[30829]:=[ ,,,[10020442359,"RPn"],]; CONWAYPOLDATA[30839]:=[ ,,,[5553949712,"RPn"],]; CONWAYPOLDATA[30841]:=[ ,,,[20773449013,"RPn"],]; CONWAYPOLDATA[30851]:=[ ,,,[8441543175,"RPn"],]; CONWAYPOLDATA[30853]:=[ ,,,[12001847855,"RPn"],]; CONWAYPOLDATA[30859]:=[ ,,,[6267185171,"RPn"],]; CONWAYPOLDATA[30869]:=[ ,,,[1649731969,"RPn"],]; CONWAYPOLDATA[30871]:=[ ,,,[3570231153,"RPn"],]; CONWAYPOLDATA[30881]:=[ ,,,[2633439040,"RPn"],]; CONWAYPOLDATA[30893]:=[ ,,,[12382624941,"RPn"],]; CONWAYPOLDATA[30911]:=[ ,,,[7357374415,"RPn"],]; CONWAYPOLDATA[30931]:=[ ,,,[12128137895,"RPn"],]; CONWAYPOLDATA[30937]:=[ ,,,[19641777567,"RPn"],]; CONWAYPOLDATA[30941]:=[ ,,,[7289111723,"RPn"],]; CONWAYPOLDATA[30949]:=[ ,,,[5413939529,"RPn"],]; CONWAYPOLDATA[30971]:=[ ,,,[6704973734,"RPn"],]; CONWAYPOLDATA[30977]:=[ ,,,[2554797101,"RPn"],]; CONWAYPOLDATA[30983]:=[ ,,,[2404590635,"RPn"],]; CONWAYPOLDATA[31013]:=[ ,,,[4583845454,"RPn"],]; CONWAYPOLDATA[31019]:=[ ,,,[8650144456,"RPn"],]; CONWAYPOLDATA[31033]:=[ ,,,[6598981262,"RPn"],]; CONWAYPOLDATA[31039]:=[ ,,,[595203871,"RPn"],]; CONWAYPOLDATA[31051]:=[ ,,,[5559122643,"RPn"],]; CONWAYPOLDATA[31063]:=[ ,,,[2749261881,"RPn"],]; CONWAYPOLDATA[31069]:=[ ,,,[7533983950,"RPn"],]; CONWAYPOLDATA[31079]:=[ ,,,[5761207478,"RPn"],]; CONWAYPOLDATA[31081]:=[ ,,,[18002954400,"RPn"],]; CONWAYPOLDATA[31091]:=[ ,,,[7356286057,"RPn"],]; CONWAYPOLDATA[31121]:=[ ,,,[4780465692,"RPn"],]; CONWAYPOLDATA[31123]:=[ ,,,[11222051236,"RPn"],]; CONWAYPOLDATA[31139]:=[ ,,,[2473775579,"RPn"],]; CONWAYPOLDATA[31147]:=[ ,,,[8459244879,"RPn"],]; CONWAYPOLDATA[31151]:=[ ,,,[12465944885,"RPn"],]; CONWAYPOLDATA[31153]:=[ ,,,[15497527155,"RPn"],]; CONWAYPOLDATA[31159]:=[ ,,,[2806709246,"RPn"],]; CONWAYPOLDATA[31177]:=[ ,,,[12275507279,"RPn"],]; CONWAYPOLDATA[31181]:=[ ,,,[3801961694,"RPn"],]; CONWAYPOLDATA[31183]:=[ ,,,[4861772716,"RPn"],]; CONWAYPOLDATA[31189]:=[ ,,,[7443785076,"RPn"],]; CONWAYPOLDATA[31193]:=[ ,,,[6466402484,"RPn"],]; CONWAYPOLDATA[31219]:=[ ,,,[6822007109,"RPn"],]; CONWAYPOLDATA[31223]:=[ ,,,[5736726687,"RPn"],]; CONWAYPOLDATA[31231]:=[ ,,,[3694033917,"RPn"],]; CONWAYPOLDATA[31237]:=[ ,,,[7805688988,"RPn"],]; CONWAYPOLDATA[31247]:=[ ,,,[11620353094,"RPn"],]; CONWAYPOLDATA[31249]:=[ ,,,[27188411216,"RPn"],]; CONWAYPOLDATA[31253]:=[ ,,,[3853432396,"RPn"],]; CONWAYPOLDATA[31259]:=[ ,,,[8457997704,"RPn"],]; CONWAYPOLDATA[31267]:=[ ,,,[2811872579,"RPn"],]; CONWAYPOLDATA[31271]:=[ ,,,[2580451656,"RPn"],]; CONWAYPOLDATA[31277]:=[ ,,,[5840760813,"RPn"],]; CONWAYPOLDATA[31307]:=[ ,,,[13592121894,"RPn"],]; CONWAYPOLDATA[31319]:=[ ,,,[4731330018,"RPn"],]; CONWAYPOLDATA[31321]:=[ ,,,[799092680,"RPn"],]; CONWAYPOLDATA[31327]:=[ ,,,[4611522368,"RPn"],]; CONWAYPOLDATA[31333]:=[ ,,,[6686932200,"RPn"],]; CONWAYPOLDATA[31337]:=[ ,,,[867376826,"RPn"],]; CONWAYPOLDATA[31357]:=[ ,,,[12569578880,"RPn"],]; CONWAYPOLDATA[31379]:=[ ,,,[4798915988,"RPn"],]; CONWAYPOLDATA[31387]:=[ ,,,[10351369828,"RPn"],]; CONWAYPOLDATA[31391]:=[ ,,,[4464616397,"RPn"],]; CONWAYPOLDATA[31393]:=[ ,,,[10673117717,"RPn"],]; CONWAYPOLDATA[31397]:=[ ,,,[9779631753,"RPn"],]; CONWAYPOLDATA[31469]:=[ ,,,[617107092,"RPn"],]; CONWAYPOLDATA[31477]:=[ ,,,[530387456,"RPn"],]; CONWAYPOLDATA[31481]:=[ ,,,[14828747284,"RPn"],]; CONWAYPOLDATA[31489]:=[ ,,,[897058639,"RPn"],]; CONWAYPOLDATA[31511]:=[ ,,,[7504596745,"RPn"],]; CONWAYPOLDATA[31513]:=[ ,,,[12715306429,"RPn"],]; CONWAYPOLDATA[31517]:=[ ,,,[1940501692,"RPn"],]; CONWAYPOLDATA[31531]:=[ ,,,[6610221904,"RPn"],]; CONWAYPOLDATA[31541]:=[ ,,,[4974047244,"RPn"],]; CONWAYPOLDATA[31543]:=[ ,,,[2648287197,"RPn"],]; CONWAYPOLDATA[31547]:=[ ,,,[2545653620,"RPn"],]; CONWAYPOLDATA[31567]:=[ ,,,[2778527346,"RPn"],]; CONWAYPOLDATA[31573]:=[ ,,,[3583409213,"RPn"],]; CONWAYPOLDATA[31583]:=[ ,,,[7945745894,"RPn"],]; CONWAYPOLDATA[31601]:=[ ,,,[2640137149,"RPn"],]; CONWAYPOLDATA[31607]:=[ ,,,[7971759510,"RPn"],]; CONWAYPOLDATA[31627]:=[ ,,,[2686682026,"RPn"],]; CONWAYPOLDATA[31643]:=[ ,,,[4676835402,"RPn"],]; CONWAYPOLDATA[31649]:=[ ,,,[4879041492,"RPn"],]; CONWAYPOLDATA[31657]:=[ ,,,[6753261187,"RPn"],]; CONWAYPOLDATA[31663]:=[ ,,,[6811344563,"RPn"],]; CONWAYPOLDATA[31667]:=[ ,,,[2685709939,"RPn"],]; CONWAYPOLDATA[31687]:=[ ,,,[5701600348,"RPn"],]; CONWAYPOLDATA[31699]:=[ ,,,[10579319359,"RPn"],]; CONWAYPOLDATA[31721]:=[ ,,,[12015407275,"RPn"],]; CONWAYPOLDATA[31723]:=[ ,,,[5891405225,"RPn"],]; CONWAYPOLDATA[31727]:=[ ,,,[4026283213,"RPn"],]; CONWAYPOLDATA[31729]:=[ ,,,[24902061451,"RPn"],]; CONWAYPOLDATA[31741]:=[ ,,,[7052310609,"RPn"],]; CONWAYPOLDATA[31751]:=[ ,,,[3720613942,"RPn"],]; CONWAYPOLDATA[31769]:=[ ,,,[5589501404,"RPn"],]; CONWAYPOLDATA[31771]:=[ ,,,[8945506312,"RPn"],]; CONWAYPOLDATA[31793]:=[ ,,,[3836048004,"RPn"],]; CONWAYPOLDATA[31799]:=[ ,,,[2920261176,"RPn"],]; CONWAYPOLDATA[31817]:=[ ,,,[997303868,"RPn"],]; CONWAYPOLDATA[31847]:=[ ,,,[4056798253,"RPn"],]; CONWAYPOLDATA[31849]:=[ ,,,[10941660266,"RPn"],]; CONWAYPOLDATA[31859]:=[ ,,,[7617391325,"RPn"],]; CONWAYPOLDATA[31873]:=[ ,,,[17806074572,"RPn"],]; CONWAYPOLDATA[31883]:=[ ,,,[4705643855,"RPn"],]; CONWAYPOLDATA[31891]:=[ ,,,[7927656128,"RPn"],]; CONWAYPOLDATA[31907]:=[ ,,,[4739689131,"RPn"],]; CONWAYPOLDATA[31957]:=[ ,,,[13053156222,"RPn"],]; CONWAYPOLDATA[31963]:=[ ,,,[11207730063,"RPn"],]; CONWAYPOLDATA[31973]:=[ ,,,[9736673746,"RPn"],]; CONWAYPOLDATA[31981]:=[ ,,,[23223738719,"RPn"],]; CONWAYPOLDATA[31991]:=[ ,,,[5901795660,"RPn"],]; CONWAYPOLDATA[32003]:=[ ,,,[556724190,"RPn"],]; CONWAYPOLDATA[32009]:=[ ,,,[4721231476,"RPn"],]; CONWAYPOLDATA[32027]:=[ ,,,[15033217586,"RPn"],]; CONWAYPOLDATA[32029]:=[ ,,,[13052297937,"RPn"],]; CONWAYPOLDATA[32051]:=[ ,,,[3892081144,"RPn"],]; CONWAYPOLDATA[32057]:=[ ,,,[1677574870,"RPn"],]; CONWAYPOLDATA[32059]:=[ ,,,[1622185402,"RPn"],]; CONWAYPOLDATA[32063]:=[ ,,,[2635738920,"RPn"],]; CONWAYPOLDATA[32069]:=[ ,,,[6711207908,"RPn"],]; CONWAYPOLDATA[32077]:=[ ,,,[6866466776,"RPn"],]; CONWAYPOLDATA[32083]:=[ ,,,[8958054847,"RPn"],]; CONWAYPOLDATA[32089]:=[ ,,,[13018667758,"RPn"],]; CONWAYPOLDATA[32099]:=[ ,,,[8009021492,"RPn"],]; CONWAYPOLDATA[32117]:=[ ,,,[7888898712,"RPn"],]; CONWAYPOLDATA[32119]:=[ ,,,[3957125041,"RPn"],]; CONWAYPOLDATA[32141]:=[ ,,,[2638551115,"RPn"],]; CONWAYPOLDATA[32143]:=[ ,,,[1825754549,"RPn"],]; CONWAYPOLDATA[32159]:=[ ,,,[6070204211,"RPn"],]; CONWAYPOLDATA[32173]:=[ ,,,[8044987347,"RPn"],]; CONWAYPOLDATA[32183]:=[ ,,,[4142853229,"RPn"],]; CONWAYPOLDATA[32189]:=[ ,,,[4732909617,"RPn"],]; CONWAYPOLDATA[32191]:=[ ,,,[2835061376,"RPn"],]; CONWAYPOLDATA[32203]:=[ ,,,[2854345110,"RPn"],]; CONWAYPOLDATA[32213]:=[ ,,,[1803928002,"RPn"],]; CONWAYPOLDATA[32233]:=[ ,,,[21684815221,"RPn"],]; CONWAYPOLDATA[32237]:=[ ,,,[6827538706,"RPn"],]; CONWAYPOLDATA[32251]:=[ ,,,[2893462970,"RPn"],]; CONWAYPOLDATA[32257]:=[ ,,,[21536289294,"RPn"],]; CONWAYPOLDATA[32261]:=[ ,,,[2000214263,"RPn"],]; CONWAYPOLDATA[32297]:=[ ,,,[10148040373,"RPn"],]; CONWAYPOLDATA[32299]:=[ ,,,[7977853012,"RPn"],]; CONWAYPOLDATA[32303]:=[ ,,,[7967599561,"RPn"],]; CONWAYPOLDATA[32309]:=[ ,,,[1857412103,"RPn"],]; CONWAYPOLDATA[32321]:=[ ,,,[659865542,"RPn"],]; CONWAYPOLDATA[32323]:=[ ,,,[11427828975,"RPn"],]; CONWAYPOLDATA[32327]:=[ ,,,[3766321794,"RPn"],]; CONWAYPOLDATA[32341]:=[ ,,,[6863180635,"RPn"],]; CONWAYPOLDATA[32353]:=[ ,,,[17793276484,"RPn"],]; CONWAYPOLDATA[32359]:=[ ,,,[3985269725,"RPn"],]; CONWAYPOLDATA[32363]:=[ ,,,[887814181,"RPn"],]; CONWAYPOLDATA[32369]:=[ ,,,[5010818313,"RPn"],]; CONWAYPOLDATA[32371]:=[ ,,,[7290434767,"RPn"],]; CONWAYPOLDATA[32377]:=[ ,,,[16564299844,"RPn"],]; CONWAYPOLDATA[32381]:=[ ,,,[2041168718,"RPn"],]; CONWAYPOLDATA[32401]:=[ ,,,[649899265,"RPn"],]; CONWAYPOLDATA[32411]:=[ ,,,[2038360203,"RPn"],]; CONWAYPOLDATA[32413]:=[ ,,,[6954922241,"RPn"],]; CONWAYPOLDATA[32423]:=[ ,,,[10096068283,"RPn"],]; CONWAYPOLDATA[32429]:=[ ,,,[2666150238,"RPn"],]; CONWAYPOLDATA[32441]:=[ ,,,[8333671170,"RPn"],]; CONWAYPOLDATA[32443]:=[ ,,,[2881197946,"RPn"],]; CONWAYPOLDATA[32467]:=[ ,,,[9375495592,"RPn"],]; CONWAYPOLDATA[32479]:=[ ,,,[4099726739,"RPn"],]; CONWAYPOLDATA[32491]:=[ ,,,[11165369697,"RPn"],]; CONWAYPOLDATA[32497]:=[ ,,,[22721999898,"RPn"],]; CONWAYPOLDATA[32503]:=[ ,,,[4210276108,"RPn"],]; CONWAYPOLDATA[32507]:=[ ,,,[13401043259,"RPn"],]; CONWAYPOLDATA[32531]:=[ ,,,[7954349998,"RPn"],]; CONWAYPOLDATA[32533]:=[ ,,,[18819364512,"RPn"],]; CONWAYPOLDATA[32537]:=[ ,,,[12587231286,"RPn"],]; CONWAYPOLDATA[32561]:=[ ,,,[632595114,"RPn"],]; CONWAYPOLDATA[32563]:=[ ,,,[8224111282,"RPn"],]; CONWAYPOLDATA[32569]:=[ ,,,[668120473,"RPn"],]; CONWAYPOLDATA[32573]:=[ ,,,[6257761897,"RPn"],]; CONWAYPOLDATA[32579]:=[ ,,,[760915130,"RPn"],]; CONWAYPOLDATA[32587]:=[ ,,,[9422042247,"RPn"],]; CONWAYPOLDATA[32603]:=[ ,,,[10366352073,"RPn"],]; CONWAYPOLDATA[32609]:=[ ,,,[3819231301,"RPn"],]; CONWAYPOLDATA[32611]:=[ ,,,[7316669185,"RPn"],]; CONWAYPOLDATA[32621]:=[ ,,,[4147401322,"RPn"],]; CONWAYPOLDATA[32633]:=[ ,,,[14765225082,"RPn"],]; CONWAYPOLDATA[32647]:=[ ,,,[5900161725,"RPn"],]; CONWAYPOLDATA[32653]:=[ ,,,[7129488675,"RPn"],]; CONWAYPOLDATA[32687]:=[ ,,,[7401350102,"RPn"],]; CONWAYPOLDATA[32693]:=[ ,,,[5032989273,"RPn"],]; CONWAYPOLDATA[32707]:=[ ,,,[1828681080,"RPn"],]; CONWAYPOLDATA[32713]:=[ ,,,[7017756330,"RPn"],]; CONWAYPOLDATA[32717]:=[ ,,,[3105334057,"RPn"],]; CONWAYPOLDATA[32719]:=[ ,,,[5352533932,"RPn"],]; CONWAYPOLDATA[32749]:=[ ,,,[4227830404,"RPn"],]; CONWAYPOLDATA[32771]:=[ ,,,[8574728778,"RPn"],]; CONWAYPOLDATA[32779]:=[ ,,,[4076035874,"RPn"],]; CONWAYPOLDATA[32783]:=[ ,,,[4174816708,"RPn"],]; CONWAYPOLDATA[32789]:=[ ,,,[12884634286,"RPn"],]; CONWAYPOLDATA[32797]:=[ ,,,[10619307835,"RPn"],]; CONWAYPOLDATA[32801]:=[ ,,,[5053551670,"RPn"],]; CONWAYPOLDATA[32803]:=[ ,,,[848482403,"RPn"],]; CONWAYPOLDATA[32831]:=[ ,,,[2760594648,"RPn"],]; CONWAYPOLDATA[32833]:=[ ,,,[11763998239,"RPn"],]; CONWAYPOLDATA[32839]:=[ ,,,[9324042954,"RPn"],]; CONWAYPOLDATA[32843]:=[ ,,,[12451011203,"RPn"],]; CONWAYPOLDATA[32869]:=[ ,,,[11707609116,"RPn"],]; CONWAYPOLDATA[32887]:=[ ,,,[3030043748,"RPn"],]; CONWAYPOLDATA[32909]:=[ ,,,[17949687508,"RPn"],]; CONWAYPOLDATA[32911]:=[ ,,,[2779169398,"RPn"],]; CONWAYPOLDATA[32917]:=[ ,,,[10447329130,"RPn"],]; CONWAYPOLDATA[32933]:=[ ,,,[3934307914,"RPn"],]; CONWAYPOLDATA[32939]:=[ ,,,[697779778,"RPn"],]; CONWAYPOLDATA[32941]:=[ ,,,[4005098546,"RPn"],]; CONWAYPOLDATA[32957]:=[ ,,,[10372490708,"RPn"],]; CONWAYPOLDATA[32969]:=[ ,,,[1086559336,"RPn"],]; CONWAYPOLDATA[32971]:=[ ,,,[8422277106,"RPn"],]; CONWAYPOLDATA[32983]:=[ ,,,[3821938111,"RPn"],]; CONWAYPOLDATA[32987]:=[ ,,,[3100679041,"RPn"],]; CONWAYPOLDATA[32993]:=[ ,,,[2152364344,"RPn"],]; CONWAYPOLDATA[32999]:=[ ,,,[6484171511,"RPn"],]; CONWAYPOLDATA[33013]:=[ ,,,[7108260126,"RPn"],]; CONWAYPOLDATA[33023]:=[ ,,,[8530435319,"RPn"],]; CONWAYPOLDATA[33029]:=[ ,,,[4184080693,"RPn"],]; CONWAYPOLDATA[33037]:=[ ,,,[7415022504,"RPn"],]; CONWAYPOLDATA[33049]:=[ ,,,[22432174024,"RPn"],]; CONWAYPOLDATA[33053]:=[ ,,,[5132271524,"RPn"],]; CONWAYPOLDATA[33071]:=[ ,,,[1014353723,"RPn"],]; CONWAYPOLDATA[33073]:=[ ,,,[7161329768,"RPn"],]; CONWAYPOLDATA[33083]:=[ ,,,[9742050261,"RPn"],]; CONWAYPOLDATA[33091]:=[ ,,,[4208314837,"RPn"],]; CONWAYPOLDATA[33107]:=[ ,,,[5038521225,"RPn"],]; CONWAYPOLDATA[33113]:=[ ,,,[749280967,"RPn"],]; CONWAYPOLDATA[33119]:=[ ,,,[5484042741,"RPn"],]; CONWAYPOLDATA[33149]:=[ ,,,[8248167331,"RPn"],]; CONWAYPOLDATA[33151]:=[ ,,,[3063351309,"RPn"],]; CONWAYPOLDATA[33161]:=[ ,,,[2880497107,"RPn"],]; CONWAYPOLDATA[33179]:=[ ,,,[7679578163,"RPn"],]; CONWAYPOLDATA[33181]:=[ ,,,[8454054272,"RPn"],]; CONWAYPOLDATA[33191]:=[ ,,,[2882771121,"RPn"],]; CONWAYPOLDATA[33199]:=[ ,,,[7298268969,"RPn"],]; CONWAYPOLDATA[33203]:=[ ,,,[5123853759,"RPn"],]; CONWAYPOLDATA[33211]:=[ ,,,[3041031639,"RPn"],]; CONWAYPOLDATA[33223]:=[ ,,,[2990070010,"RPn"],]; CONWAYPOLDATA[33247]:=[ ,,,[11953593138,"RPn"],]; CONWAYPOLDATA[33287]:=[ ,,,[2990603946,"RPn"],]; CONWAYPOLDATA[33289]:=[ ,,,[27183830718,"RPn"],]; CONWAYPOLDATA[33301]:=[ ,,,[14276138702,"RPn"],]; CONWAYPOLDATA[33311]:=[ ,,,[2917510635,"RPn"],]; CONWAYPOLDATA[33317]:=[ ,,,[4407905736,"RPn"],]; CONWAYPOLDATA[33329]:=[ ,,,[1110422296,"RPn"],]; CONWAYPOLDATA[33331]:=[ ,,,[6194299705,"RPn"],]; CONWAYPOLDATA[33343]:=[ ,,,[14452456667,"RPn"],]; CONWAYPOLDATA[33347]:=[ ,,,[8697264419,"RPn"],]; CONWAYPOLDATA[33349]:=[ ,,,[7638421707,"RPn"],]; CONWAYPOLDATA[33353]:=[ ,,,[574738899,"RPn"],]; CONWAYPOLDATA[33359]:=[ ,,,[6639875444,"RPn"],]; CONWAYPOLDATA[33377]:=[ ,,,[7252154565,"RPn"],]; CONWAYPOLDATA[33391]:=[ ,,,[5330806374,"RPn"],]; CONWAYPOLDATA[33403]:=[ ,,,[6474870926,"RPn"],]; CONWAYPOLDATA[33409]:=[ ,,,[870605138,"RPn"],]; CONWAYPOLDATA[33413]:=[ ,,,[15333292528,"RPn"],]; CONWAYPOLDATA[33427]:=[ ,,,[11954765428,"RPn"],]; CONWAYPOLDATA[33457]:=[ ,,,[14285068386,"RPn"],]; CONWAYPOLDATA[33461]:=[ ,,,[4449844549,"RPn"],]; CONWAYPOLDATA[33469]:=[ ,,,[11970120914,"RPn"],]; CONWAYPOLDATA[33479]:=[ ,,,[3123155490,"RPn"],]; CONWAYPOLDATA[33487]:=[ ,,,[5372587312,"RPn"],]; CONWAYPOLDATA[33493]:=[ ,,,[10095794992,"RPn"],]; CONWAYPOLDATA[33503]:=[ ,,,[6292667477,"RPn"],]; CONWAYPOLDATA[33521]:=[ ,,,[12330163520,"RPn"],]; CONWAYPOLDATA[33529]:=[ ,,,[851971897,"RPn"],]; CONWAYPOLDATA[33533]:=[ ,,,[7380680368,"RPn"],]; CONWAYPOLDATA[33547]:=[ ,,,[8953291738,"RPn"],]; CONWAYPOLDATA[33563]:=[ ,,,[16510042458,"RPn"],]; CONWAYPOLDATA[33569]:=[ ,,,[1126474936,"RPn"],]; CONWAYPOLDATA[33577]:=[ ,,,[12356772506,"RPn"],]; CONWAYPOLDATA[33581]:=[ ,,,[3317634897,"RPn"],]; CONWAYPOLDATA[33587]:=[ ,,,[11039072883,"RPn"],]; CONWAYPOLDATA[33589]:=[ ,,,[4282631091,"RPn"],]; CONWAYPOLDATA[33599]:=[ ,,,[4284141303,"RPn"],]; CONWAYPOLDATA[33601]:=[ ,,,[14542546430,"RPn"],]; CONWAYPOLDATA[33613]:=[ ,,,[4004955342,"RPn"],]; CONWAYPOLDATA[33617]:=[ ,,,[13495712738,"RPn"],]; CONWAYPOLDATA[33619]:=[ ,,,[3208059458,"RPn"],]; CONWAYPOLDATA[33623]:=[ ,,,[5215532519,"RPn"],]; CONWAYPOLDATA[33629]:=[ ,,,[672849034,"RPn"],]; CONWAYPOLDATA[33637]:=[ ,,,[7563548548,"RPn"],]; CONWAYPOLDATA[33641]:=[ ,,,[5623126794,"RPn"],]; CONWAYPOLDATA[33647]:=[ ,,,[6383744374,"RPn"],]; CONWAYPOLDATA[33679]:=[ ,,,[4508776128,"RPn"],]; CONWAYPOLDATA[33703]:=[ ,,,[4543434029,"RPn"],]; CONWAYPOLDATA[33713]:=[ ,,,[3119160476,"RPn"],]; CONWAYPOLDATA[33721]:=[ ,,,[28427005337,"RPn"],]; CONWAYPOLDATA[33739]:=[ ,,,[3240664691,"RPn"],]; CONWAYPOLDATA[33749]:=[ ,,,[14531610673,"RPn"],]; CONWAYPOLDATA[33751]:=[ ,,,[4192954238,"RPn"],]; CONWAYPOLDATA[33757]:=[ ,,,[7758607611,"RPn"],]; CONWAYPOLDATA[33767]:=[ ,,,[5151290923,"RPn"],]; CONWAYPOLDATA[33769]:=[ ,,,[6824444759,"RPn"],]; CONWAYPOLDATA[33773]:=[ ,,,[5402329082,"RPn"],]; CONWAYPOLDATA[33791]:=[ ,,,[13307166135,"RPn"],]; CONWAYPOLDATA[33797]:=[ ,,,[17098409258,"RPn"],]; CONWAYPOLDATA[33809]:=[ ,,,[8923547463,"RPn"],]; CONWAYPOLDATA[33811]:=[ ,,,[828437137,"RPn"],]; CONWAYPOLDATA[33827]:=[ ,,,[10298156574,"RPn"],]; CONWAYPOLDATA[33829]:=[ ,,,[8995604708,"RPn"],]; CONWAYPOLDATA[33851]:=[ ,,,[7994082907,"RPn"],]; CONWAYPOLDATA[33857]:=[ ,,,[5602148508,"RPn"],]; CONWAYPOLDATA[33863]:=[ ,,,[6569455868,"RPn"],]; CONWAYPOLDATA[33871]:=[ ,,,[5494553635,"RPn"],]; CONWAYPOLDATA[33889]:=[ ,,,[32988399838,"RPn"],]; CONWAYPOLDATA[33893]:=[ ,,,[5204744654,"RPn"],]; CONWAYPOLDATA[33911]:=[ ,,,[4360072925,"RPn"],]; CONWAYPOLDATA[33923]:=[ ,,,[27149255362,"RPn"],]; CONWAYPOLDATA[33931]:=[ ,,,[4064255182,"RPn"],]; CONWAYPOLDATA[33937]:=[ ,,,[7596831392,"RPn"],]; CONWAYPOLDATA[33941]:=[ ,,,[4355512768,"RPn"],]; CONWAYPOLDATA[33961]:=[ ,,,[16977579367,"RPn"],]; CONWAYPOLDATA[33967]:=[ ,,,[6469252922,"RPn"],]; CONWAYPOLDATA[33997]:=[ ,,,[4448677437,"RPn"],]; CONWAYPOLDATA[34019]:=[ ,,,[747567527,"RPn"],]; CONWAYPOLDATA[34031]:=[ ,,,[5790238533,"RPn"],]; CONWAYPOLDATA[34033]:=[ ,,,[14552680972,"RPn"],]; CONWAYPOLDATA[34039]:=[ ,,,[4475243489,"RPn"],]; CONWAYPOLDATA[34057]:=[ ,,,[29836384109,"RPn"],]; CONWAYPOLDATA[34061]:=[ ,,,[2116414298,"RPn"],]; CONWAYPOLDATA[34123]:=[ ,,,[10479173302,"RPn"],]; CONWAYPOLDATA[34127]:=[ ,,,[3483035752,"RPn"],]; CONWAYPOLDATA[34129]:=[ ,,,[21904879565,"RPn"],]; CONWAYPOLDATA[34141]:=[ ,,,[7593436376,"RPn"],]; CONWAYPOLDATA[34147]:=[ ,,,[3092147441,"RPn"],]; CONWAYPOLDATA[34157]:=[ ,,,[14658783965,"RPn"],]; CONWAYPOLDATA[34159]:=[ ,,,[8864875365,"RPn"],]; CONWAYPOLDATA[34171]:=[ ,,,[10136929665,"RPn"],]; CONWAYPOLDATA[34183]:=[ ,,,[3236480626,"RPn"],]; CONWAYPOLDATA[34211]:=[ ,,,[9229956747,"RPn"],]; CONWAYPOLDATA[34213]:=[ ,,,[12449050099,"RPn"],]; CONWAYPOLDATA[34217]:=[ ,,,[15093221354,"RPn"],]; CONWAYPOLDATA[34231]:=[ ,,,[5312856592,"RPn"],]; CONWAYPOLDATA[34253]:=[ ,,,[5459825443,"RPn"],]; CONWAYPOLDATA[34259]:=[ ,,,[9167125999,"RPn"],]; CONWAYPOLDATA[34261]:=[ ,,,[4454032785,"RPn"],]; CONWAYPOLDATA[34267]:=[ ,,,[3111100932,"RPn"],]; CONWAYPOLDATA[34273]:=[ ,,,[21844890472,"RPn"],]; CONWAYPOLDATA[34283]:=[ ,,,[9289218833,"RPn"],]; CONWAYPOLDATA[34297]:=[ ,,,[7914067052,"RPn"],]; CONWAYPOLDATA[34301]:=[ ,,,[3404374253,"RPn"],]; CONWAYPOLDATA[34303]:=[ ,,,[3067648701,"RPn"],]; CONWAYPOLDATA[34313]:=[ ,,,[869457110,"RPn"],]; CONWAYPOLDATA[34319]:=[ ,,,[23402366352,"RPn"],]; CONWAYPOLDATA[34327]:=[ ,,,[3423774985,"RPn"],]; CONWAYPOLDATA[34337]:=[ ,,,[7863207340,"RPn"],]; CONWAYPOLDATA[34351]:=[ ,,,[4655350576,"RPn"],]; CONWAYPOLDATA[34361]:=[ ,,,[9303859251,"RPn"],]; CONWAYPOLDATA[34367]:=[ ,,,[5396684382,"RPn"],]; CONWAYPOLDATA[34369]:=[ ,,,[22013310138,"RPn"],]; CONWAYPOLDATA[34381]:=[ ,,,[13639252135,"RPn"],]; CONWAYPOLDATA[34403]:=[ ,,,[16014665308,"RPn"],]; CONWAYPOLDATA[34421]:=[ ,,,[28359496323,"RPn"],]; CONWAYPOLDATA[34429]:=[ ,,,[4288889390,"RPn"],]; CONWAYPOLDATA[34439]:=[ ,,,[4171113935,"RPn"],]; CONWAYPOLDATA[34457]:=[ ,,,[868247489,"RPn"],]; CONWAYPOLDATA[34469]:=[ ,,,[9172924759,"RPn"],]; CONWAYPOLDATA[34471]:=[ ,,,[4235072595,"RPn"],]; CONWAYPOLDATA[34483]:=[ ,,,[10372934681,"RPn"],]; CONWAYPOLDATA[34487]:=[ ,,,[5734256956,"RPn"],]; CONWAYPOLDATA[34499]:=[ ,,,[8969222517,"RPn"],]; CONWAYPOLDATA[34501]:=[ ,,,[15265898984,"RPn"],]; CONWAYPOLDATA[34511]:=[ ,,,[5619943802,"RPn"],]; CONWAYPOLDATA[34513]:=[ ,,,[10691644229,"RPn"],]; CONWAYPOLDATA[34519]:=[ ,,,[4447635077,"RPn"],]; CONWAYPOLDATA[34537]:=[ ,,,[8340547357,"RPn"],]; CONWAYPOLDATA[34543]:=[ ,,,[4559848721,"RPn"],]; CONWAYPOLDATA[34549]:=[ ,,,[7826350423,"RPn"],]; CONWAYPOLDATA[34583]:=[ ,,,[5895329432,"RPn"],]; CONWAYPOLDATA[34589]:=[ ,,,[7988122018,"RPn"],]; CONWAYPOLDATA[34591]:=[ ,,,[3238236468,"RPn"],]; CONWAYPOLDATA[34603]:=[ ,,,[10325915835,"RPn"],]; CONWAYPOLDATA[34607]:=[ ,,,[5623810545,"RPn"],]; CONWAYPOLDATA[34613]:=[ ,,,[2240499492,"RPn"],]; CONWAYPOLDATA[34631]:=[ ,,,[4308027145,"RPn"],]; CONWAYPOLDATA[34649]:=[ ,,,[9276126336,"RPn"],]; CONWAYPOLDATA[34651]:=[ ,,,[10545650691,"RPn"],]; CONWAYPOLDATA[34667]:=[ ,,,[9189181692,"RPn"],]; CONWAYPOLDATA[34673]:=[ ,,,[1018692743,"RPn"],]; CONWAYPOLDATA[34679]:=[ ,,,[7002487724,"RPn"],]; CONWAYPOLDATA[34687]:=[ ,,,[6724421825,"RPn"],]; CONWAYPOLDATA[34693]:=[ ,,,[10537374282,"RPn"],]; CONWAYPOLDATA[34703]:=[ ,,,[6868938310,"RPn"],]; CONWAYPOLDATA[34721]:=[ ,,,[10831632605,"RPn"],]; CONWAYPOLDATA[34729]:=[ ,,,[17649555645,"RPn"],]; CONWAYPOLDATA[34739]:=[ ,,,[2239136990,"RPn"],]; CONWAYPOLDATA[34747]:=[ ,,,[10865942854,"RPn"],]; CONWAYPOLDATA[34757]:=[ ,,,[13916146690,"RPn"],]; CONWAYPOLDATA[34759]:=[ ,,,[5708540094,"RPn"],]; CONWAYPOLDATA[34763]:=[ ,,,[10590200322,"RPn"],]; CONWAYPOLDATA[34781]:=[ ,,,[4812125257,"RPn"],]; CONWAYPOLDATA[34807]:=[ ,,,[4710048436,"RPn"],]; CONWAYPOLDATA[34819]:=[ ,,,[4367695362,"RPn"],]; CONWAYPOLDATA[34841]:=[ ,,,[1213477192,"RPn"],]; CONWAYPOLDATA[34843]:=[ ,,,[10445199699,"RPn"],]; CONWAYPOLDATA[34847]:=[ ,,,[8449805108,"RPn"],]; CONWAYPOLDATA[34849]:=[ ,,,[1008111879,"RPn"],]; CONWAYPOLDATA[34871]:=[ ,,,[3208864298,"RPn"],]; CONWAYPOLDATA[34877]:=[ ,,,[4310832079,"RPn"],]; CONWAYPOLDATA[34883]:=[ ,,,[871830821,"RPn"],]; CONWAYPOLDATA[34897]:=[ ,,,[14292450222,"RPn"],]; CONWAYPOLDATA[34913]:=[ ,,,[734813914,"RPn"],]; CONWAYPOLDATA[34919]:=[ ,,,[3404113653,"RPn"],]; CONWAYPOLDATA[34939]:=[ ,,,[12976973504,"RPn"],]; CONWAYPOLDATA[34949]:=[ ,,,[2395299615,"RPn"],]; CONWAYPOLDATA[34961]:=[ ,,,[761100973,"RPn"],]; CONWAYPOLDATA[34963]:=[ ,,,[3598356999,"RPn"],]; CONWAYPOLDATA[34981]:=[ ,,,[8083269558,"RPn"],]; CONWAYPOLDATA[35023]:=[ ,,,[4906302029,"RPn"],]; CONWAYPOLDATA[35027]:=[ ,,,[14652389561,"RPn"],]; CONWAYPOLDATA[35051]:=[ ,,,[9703553893,"RPn"],]; CONWAYPOLDATA[35053]:=[ ,,,[15949605744,"RPn"],]; CONWAYPOLDATA[35059]:=[ ,,,[3307851719,"RPn"],]; CONWAYPOLDATA[35069]:=[ ,,,[2054622574,"RPn"],]; CONWAYPOLDATA[35081]:=[ ,,,[5776156815,"RPn"],]; CONWAYPOLDATA[35083]:=[ ,,,[14601369187,"RPn"],]; CONWAYPOLDATA[35089]:=[ ,,,[13149462405,"RPn"],]; CONWAYPOLDATA[35099]:=[ ,,,[9689816031,"RPn"],]; CONWAYPOLDATA[35107]:=[ ,,,[11032585394,"RPn"],]; CONWAYPOLDATA[35111]:=[ ,,,[8601563015,"RPn"],]; CONWAYPOLDATA[35117]:=[ ,,,[5975403371,"RPn"],]; CONWAYPOLDATA[35129]:=[ ,,,[6021251119,"RPn"],]; CONWAYPOLDATA[35141]:=[ ,,,[9441508177,"RPn"],]; CONWAYPOLDATA[35149]:=[ ,,,[8593825055,"RPn"],]; CONWAYPOLDATA[35153]:=[ ,,,[9738048910,"RPn"],]; CONWAYPOLDATA[35159]:=[ ,,,[4668833939,"RPn"],]; CONWAYPOLDATA[35171]:=[ ,,,[2293360228,"RPn"],]; CONWAYPOLDATA[35201]:=[ ,,,[1238687992,"RPn"],]; CONWAYPOLDATA[35221]:=[ ,,,[3174680062,"RPn"],]; CONWAYPOLDATA[35227]:=[ ,,,[14402523725,"RPn"],]; CONWAYPOLDATA[35251]:=[ ,,,[9917199084,"RPn"],]; CONWAYPOLDATA[35257]:=[ ,,,[15726525885,"RPn"],]; CONWAYPOLDATA[35267]:=[ ,,,[9910908677,"RPn"],]; CONWAYPOLDATA[35279]:=[ ,,,[3125966382,"RPn"],]; CONWAYPOLDATA[35281]:=[ ,,,[40720518760,"RPn"],]; CONWAYPOLDATA[35291]:=[ ,,,[10779283042,"RPn"],]; CONWAYPOLDATA[35311]:=[ ,,,[4481566198,"RPn"],]; CONWAYPOLDATA[35317]:=[ ,,,[8322274470,"RPn"],]; CONWAYPOLDATA[35323]:=[ ,,,[6970040332,"RPn"],]; CONWAYPOLDATA[35327]:=[ ,,,[5837080215,"RPn"],]; CONWAYPOLDATA[35339]:=[ ,,,[5719617152,"RPn"],]; CONWAYPOLDATA[35353]:=[ ,,,[10763857209,"RPn"],]; CONWAYPOLDATA[35363]:=[ ,,,[9799582384,"RPn"],]; CONWAYPOLDATA[35381]:=[ ,,,[18540245480,"RPn"],]; CONWAYPOLDATA[35393]:=[ ,,,[9489677342,"RPn"],]; CONWAYPOLDATA[35401]:=[ ,,,[18397651906,"RPn"],]; CONWAYPOLDATA[35407]:=[ ,,,[12076123868,"RPn"],]; CONWAYPOLDATA[35419]:=[ ,,,[11290302118,"RPn"],]; CONWAYPOLDATA[35423]:=[ ,,,[7394232448,"RPn"],]; CONWAYPOLDATA[35437]:=[ ,,,[8437159899,"RPn"],]; CONWAYPOLDATA[35447]:=[ ,,,[6997131464,"RPn"],]; CONWAYPOLDATA[35449]:=[ ,,,[8632788636,"RPn"],]; CONWAYPOLDATA[35461]:=[ ,,,[8802235809,"RPn"],]; CONWAYPOLDATA[35491]:=[ ,,,[8436459144,"RPn"],]; CONWAYPOLDATA[35507]:=[ ,,,[3672098435,"RPn"],]; CONWAYPOLDATA[35509]:=[ ,,,[9508173914,"RPn"],]; CONWAYPOLDATA[35521]:=[ ,,,[18850675018,"RPn"],]; CONWAYPOLDATA[35527]:=[ ,,,[7045608062,"RPn"],]; CONWAYPOLDATA[35531]:=[ ,,,[6017494635,"RPn"],]; CONWAYPOLDATA[35533]:=[ ,,,[8752381963,"RPn"],]; CONWAYPOLDATA[35537]:=[ ,,,[6123025103,"RPn"],]; CONWAYPOLDATA[35543]:=[ ,,,[4852081564,"RPn"],]; CONWAYPOLDATA[35569]:=[ ,,,[23907667792,"RPn"],]; CONWAYPOLDATA[35573]:=[ ,,,[5877264343,"RPn"],]; CONWAYPOLDATA[35591]:=[ ,,,[5066592413,"RPn"],]; CONWAYPOLDATA[35593]:=[ ,,,[13817629721,"RPn"],]; CONWAYPOLDATA[35597]:=[ ,,,[12564637495,"RPn"],]; CONWAYPOLDATA[35603]:=[ ,,,[10090317438,"RPn"],]; CONWAYPOLDATA[35617]:=[ ,,,[41699279484,"RPn"],]; CONWAYPOLDATA[35671]:=[ ,,,[10092039323,"RPn"],]; CONWAYPOLDATA[35677]:=[ ,,,[26641692721,"RPn"],]; CONWAYPOLDATA[35729]:=[ ,,,[3341090251,"RPn"],]; CONWAYPOLDATA[35731]:=[ ,,,[8407432840,"RPn"],]; CONWAYPOLDATA[35747]:=[ ,,,[716798846,"RPn"],]; CONWAYPOLDATA[35753]:=[ ,,,[8556479469,"RPn"],]; CONWAYPOLDATA[35759]:=[ ,,,[6245380879,"RPn"],]; CONWAYPOLDATA[35771]:=[ ,,,[824163846,"RPn"],]; CONWAYPOLDATA[35797]:=[ ,,,[12320253492,"RPn"],]; CONWAYPOLDATA[35801]:=[ ,,,[5785942817,"RPn"],]; CONWAYPOLDATA[35803]:=[ ,,,[3580837059,"RPn"],]; CONWAYPOLDATA[35809]:=[ ,,,[18692083159,"RPn"],]; CONWAYPOLDATA[35831]:=[ ,,,[4835859264,"RPn"],]; CONWAYPOLDATA[35837]:=[ ,,,[9990603025,"RPn"],]; CONWAYPOLDATA[35839]:=[ ,,,[4598358740,"RPn"],]; CONWAYPOLDATA[35851]:=[ ,,,[11443961861,"RPn"],]; CONWAYPOLDATA[35863]:=[ ,,,[4779892369,"RPn"],]; CONWAYPOLDATA[35869]:=[ ,,,[4772155246,"RPn"],]; CONWAYPOLDATA[35879]:=[ ,,,[21543796710,"RPn"],]; CONWAYPOLDATA[35897]:=[ ,,,[13760109837,"RPn"],]; CONWAYPOLDATA[35899]:=[ ,,,[14110173750,"RPn"],]; CONWAYPOLDATA[35911]:=[ ,,,[6266541334,"RPn"],]; CONWAYPOLDATA[35923]:=[ ,,,[11613905902,"RPn"],]; CONWAYPOLDATA[35933]:=[ ,,,[8697690451,"RPn"],]; CONWAYPOLDATA[35951]:=[ ,,,[4609816986,"RPn"],]; CONWAYPOLDATA[35963]:=[ ,,,[3344523039,"RPn"],]; CONWAYPOLDATA[35969]:=[ ,,,[1269166168,"RPn"],]; CONWAYPOLDATA[35977]:=[ ,,,[8840556266,"RPn"],]; CONWAYPOLDATA[35983]:=[ ,,,[7628108139,"RPn"],]; CONWAYPOLDATA[35993]:=[ ,,,[5953638126,"RPn"],]; CONWAYPOLDATA[35999]:=[ ,,,[4591132478,"RPn"],]; CONWAYPOLDATA[36007]:=[ ,,,[8973268466,"RPn"],]; CONWAYPOLDATA[36011]:=[ ,,,[11670877014,"RPn"],]; CONWAYPOLDATA[36013]:=[ ,,,[4997487999,"RPn"],]; CONWAYPOLDATA[36017]:=[ ,,,[905575434,"RPn"],]; CONWAYPOLDATA[36037]:=[ ,,,[8938761630,"RPn"],]; CONWAYPOLDATA[36061]:=[ ,,,[13888713847,"RPn"],]; CONWAYPOLDATA[36067]:=[ ,,,[1063255165,"RPn"],]; CONWAYPOLDATA[36073]:=[ ,,,[20632926326,"RPn"],]; CONWAYPOLDATA[36083]:=[ ,,,[2554532070,"RPn"],]; CONWAYPOLDATA[36097]:=[ ,,,[19544504073,"RPn"],]; CONWAYPOLDATA[36107]:=[ ,,,[6335117580,"RPn"],]; CONWAYPOLDATA[36109]:=[ ,,,[4836186699,"RPn"],]; CONWAYPOLDATA[36131]:=[ ,,,[4982898474,"RPn"],]; CONWAYPOLDATA[36137]:=[ ,,,[2015577315,"RPn"],]; CONWAYPOLDATA[36151]:=[ ,,,[5093061336,"RPn"],]; CONWAYPOLDATA[36161]:=[ ,,,[2446797907,"RPn"],]; CONWAYPOLDATA[36187]:=[ ,,,[7745356922,"RPn"],]; CONWAYPOLDATA[36191]:=[ ,,,[6490928239,"RPn"],]; CONWAYPOLDATA[36209]:=[ ,,,[1223646949,"RPn"],]; CONWAYPOLDATA[36217]:=[ ,,,[15549044629,"RPn"],]; CONWAYPOLDATA[36229]:=[ ,,,[13973923821,"RPn"],]; CONWAYPOLDATA[36241]:=[ ,,,[29985187322,"RPn"],]; CONWAYPOLDATA[36251]:=[ ,,,[10254827886,"RPn"],]; CONWAYPOLDATA[36263]:=[ ,,,[11598539240,"RPn"],]; CONWAYPOLDATA[36269]:=[ ,,,[10142371969,"RPn"],]; CONWAYPOLDATA[36277]:=[ ,,,[4674908161,"RPn"],]; CONWAYPOLDATA[36293]:=[ ,,,[8628805924,"RPn"],]; CONWAYPOLDATA[36299]:=[ ,,,[10264740119,"RPn"],]; CONWAYPOLDATA[36307]:=[ ,,,[10489382758,"RPn"],]; CONWAYPOLDATA[36313]:=[ ,,,[24901966572,"RPn"],]; CONWAYPOLDATA[36319]:=[ ,,,[2285482038,"RPn"],]; CONWAYPOLDATA[36341]:=[ ,,,[9130421865,"RPn"],]; CONWAYPOLDATA[36343]:=[ ,,,[3491617395,"RPn"],]; CONWAYPOLDATA[36353]:=[ ,,,[3864178491,"RPn"],]; CONWAYPOLDATA[36373]:=[ ,,,[9028396943,"RPn"],]; CONWAYPOLDATA[36383]:=[ ,,,[6420980994,"RPn"],]; CONWAYPOLDATA[36389]:=[ ,,,[16972011548,"RPn"],]; CONWAYPOLDATA[36433]:=[ ,,,[9163883196,"RPn"],]; CONWAYPOLDATA[36451]:=[ ,,,[6643231208,"RPn"],]; CONWAYPOLDATA[36457]:=[ ,,,[8715884366,"RPn"],]; CONWAYPOLDATA[36467]:=[ ,,,[10607593896,"RPn"],]; CONWAYPOLDATA[36469]:=[ ,,,[12841865441,"RPn"],]; CONWAYPOLDATA[36473]:=[ ,,,[10027448947,"RPn"],]; CONWAYPOLDATA[36479]:=[ ,,,[7725668543,"RPn"],]; CONWAYPOLDATA[36493]:=[ ,,,[8950857070,"RPn"],]; CONWAYPOLDATA[36497]:=[ ,,,[8889793275,"RPn"],]; CONWAYPOLDATA[36523]:=[ ,,,[24779504151,"RPn"],]; CONWAYPOLDATA[36527]:=[ ,,,[5336740813,"RPn"],]; CONWAYPOLDATA[36529]:=[ ,,,[1294259006,"RPn"],]; CONWAYPOLDATA[36541]:=[ ,,,[5099917757,"RPn"],]; CONWAYPOLDATA[36551]:=[ ,,,[3454069507,"RPn"],]; CONWAYPOLDATA[36559]:=[ ,,,[4765758128,"RPn"],]; CONWAYPOLDATA[36563]:=[ ,,,[19546945432,"RPn"],]; CONWAYPOLDATA[36571]:=[ ,,,[3827411149,"RPn"],]; CONWAYPOLDATA[36583]:=[ ,,,[1276124796,"RPn"],]; CONWAYPOLDATA[36587]:=[ ,,,[1109903234,"RPn"],]; CONWAYPOLDATA[36599]:=[ ,,,[13108224661,"RPn"],]; CONWAYPOLDATA[36607]:=[ ,,,[7396371139,"RPn"],]; CONWAYPOLDATA[36629]:=[ ,,,[5200988341,"RPn"],]; CONWAYPOLDATA[36637]:=[ ,,,[2586865301,"RPn"],]; CONWAYPOLDATA[36643]:=[ ,,,[3958689865,"RPn"],]; CONWAYPOLDATA[36653]:=[ ,,,[17301535510,"RPn"],]; CONWAYPOLDATA[36671]:=[ ,,,[6411887692,"RPn"],]; CONWAYPOLDATA[36677]:=[ ,,,[17107289789,"RPn"],]; CONWAYPOLDATA[36683]:=[ ,,,[15508398546,"RPn"],]; CONWAYPOLDATA[36691]:=[ ,,,[11782544141,"RPn"],]; CONWAYPOLDATA[36697]:=[ ,,,[9245405488,"RPn"],]; CONWAYPOLDATA[36709]:=[ ,,,[9294315003,"RPn"],]; CONWAYPOLDATA[36713]:=[ ,,,[10241605335,"RPn"],]; CONWAYPOLDATA[36721]:=[ ,,,[17300511651,"RPn"],]; CONWAYPOLDATA[36739]:=[ ,,,[4037065017,"RPn"],]; CONWAYPOLDATA[36749]:=[ ,,,[2403090610,"RPn"],]; CONWAYPOLDATA[36761]:=[ ,,,[6362593886,"RPn"],]; CONWAYPOLDATA[36767]:=[ ,,,[6228109203,"RPn"],]; CONWAYPOLDATA[36779]:=[ ,,,[11587334289,"RPn"],]; CONWAYPOLDATA[36781]:=[ ,,,[4989600119,"RPn"],]; CONWAYPOLDATA[36787]:=[ ,,,[11635801676,"RPn"],]; CONWAYPOLDATA[36791]:=[ ,,,[10306078892,"RPn"],]; CONWAYPOLDATA[36793]:=[ ,,,[18939895832,"RPn"],]; CONWAYPOLDATA[36809]:=[ ,,,[3711745945,"RPn"],]; CONWAYPOLDATA[36821]:=[ ,,,[12969129443,"RPn"],]; CONWAYPOLDATA[36833]:=[ ,,,[13387727346,"RPn"],]; CONWAYPOLDATA[36847]:=[ ,,,[7501828121,"RPn"],]; CONWAYPOLDATA[36857]:=[ ,,,[10692031418,"RPn"],]; CONWAYPOLDATA[36871]:=[ ,,,[5245157862,"RPn"],]; CONWAYPOLDATA[36877]:=[ ,,,[13094543301,"RPn"],]; CONWAYPOLDATA[36887]:=[ ,,,[5229949526,"RPn"],]; CONWAYPOLDATA[36899]:=[ ,,,[6532525164,"RPn"],]; CONWAYPOLDATA[36901]:=[ ,,,[9099675899,"RPn"],]; CONWAYPOLDATA[36913]:=[ ,,,[8869492558,"RPn"],]; CONWAYPOLDATA[36919]:=[ ,,,[4844178912,"RPn"],]; CONWAYPOLDATA[36923]:=[ ,,,[16264507656,"RPn"],]; CONWAYPOLDATA[36929]:=[ ,,,[6254406230,"RPn"],]; CONWAYPOLDATA[36931]:=[ ,,,[3847693168,"RPn"],]; CONWAYPOLDATA[36943]:=[ ,,,[15012342198,"RPn"],]; CONWAYPOLDATA[36947]:=[ ,,,[901174279,"RPn"],]; CONWAYPOLDATA[36973]:=[ ,,,[4957376815,"RPn"],]; CONWAYPOLDATA[36979]:=[ ,,,[8910607759,"RPn"],]; CONWAYPOLDATA[36997]:=[ ,,,[9022199413,"RPn"],]; CONWAYPOLDATA[37003]:=[ ,,,[11919591377,"RPn"],]; CONWAYPOLDATA[37013]:=[ ,,,[7949837207,"RPn"],]; CONWAYPOLDATA[37019]:=[ ,,,[4944590813,"RPn"],]; CONWAYPOLDATA[37021]:=[ ,,,[25879196867,"RPn"],]; CONWAYPOLDATA[37039]:=[ ,,,[3695936618,"RPn"],]; CONWAYPOLDATA[37049]:=[ ,,,[21464449303,"RPn"],]; CONWAYPOLDATA[37057]:=[ ,,,[4017275261,"RPn"],]; CONWAYPOLDATA[37061]:=[ ,,,[5117753492,"RPn"],]; CONWAYPOLDATA[37087]:=[ ,,,[8207501451,"RPn"],]; CONWAYPOLDATA[37097]:=[ ,,,[16105477068,"RPn"],]; CONWAYPOLDATA[37117]:=[ ,,,[9587395336,"RPn"],]; CONWAYPOLDATA[37123]:=[ ,,,[5218862712,"RPn"],]; CONWAYPOLDATA[37139]:=[ ,,,[10446197949,"RPn"],]; CONWAYPOLDATA[37159]:=[ ,,,[5400763381,"RPn"],]; CONWAYPOLDATA[37171]:=[ ,,,[3659893834,"RPn"],]; CONWAYPOLDATA[37181]:=[ ,,,[5110677176,"RPn"],]; CONWAYPOLDATA[37189]:=[ ,,,[10806491189,"RPn"],]; CONWAYPOLDATA[37199]:=[ ,,,[25649231293,"RPn"],]; CONWAYPOLDATA[37201]:=[ ,,,[1025371170,"RPn"],]; CONWAYPOLDATA[37217]:=[ ,,,[2333952507,"RPn"],]; CONWAYPOLDATA[37223]:=[ ,,,[6646576108,"RPn"],]; CONWAYPOLDATA[37243]:=[ ,,,[10437090051,"RPn"],]; CONWAYPOLDATA[37253]:=[ ,,,[10768426688,"RPn"],]; CONWAYPOLDATA[37273]:=[ ,,,[9618931296,"RPn"],]; CONWAYPOLDATA[37277]:=[ ,,,[8188377653,"RPn"],]; CONWAYPOLDATA[37307]:=[ ,,,[6503095093,"RPn"],]; CONWAYPOLDATA[37309]:=[ ,,,[6285745709,"RPn"],]; CONWAYPOLDATA[37313]:=[ ,,,[1129203322,"RPn"],]; CONWAYPOLDATA[37321]:=[ ,,,[25821466898,"RPn"],]; CONWAYPOLDATA[37337]:=[ ,,,[2105956151,"RPn"],]; CONWAYPOLDATA[37339]:=[ ,,,[7742652382,"RPn"],]; CONWAYPOLDATA[37357]:=[ ,,,[9333795884,"RPn"],]; CONWAYPOLDATA[37361]:=[ ,,,[1395395992,"RPn"],]; CONWAYPOLDATA[37363]:=[ ,,,[3582401806,"RPn"],]; CONWAYPOLDATA[37369]:=[ ,,,[20803060724,"RPn"],]; CONWAYPOLDATA[37379]:=[ ,,,[6690093422,"RPn"],]; CONWAYPOLDATA[37397]:=[ ,,,[6601617618,"RPn"],]; CONWAYPOLDATA[37409]:=[ ,,,[3597062398,"RPn"],]; CONWAYPOLDATA[37423]:=[ ,,,[26608576312,"RPn"],]; CONWAYPOLDATA[37441]:=[ ,,,[1258204822,"RPn"],]; CONWAYPOLDATA[37447]:=[ ,,,[9154331070,"RPn"],]; CONWAYPOLDATA[37463]:=[ ,,,[5613755629,"RPn"],]; CONWAYPOLDATA[37483]:=[ ,,,[3826901853,"RPn"],]; CONWAYPOLDATA[37489]:=[ ,,,[74332214505,"RPn"],]; CONWAYPOLDATA[37493]:=[ ,,,[3831447165,"RPn"],]; CONWAYPOLDATA[37501]:=[ ,,,[15348709290,"RPn"],]; CONWAYPOLDATA[37507]:=[ ,,,[5626800157,"RPn"],]; CONWAYPOLDATA[37511]:=[ ,,,[9638338928,"RPn"],]; CONWAYPOLDATA[37517]:=[ ,,,[10564562100,"RPn"],]; CONWAYPOLDATA[37529]:=[ ,,,[19318428043,"RPn"],]; CONWAYPOLDATA[37537]:=[ ,,,[3951294781,"RPn"],]; CONWAYPOLDATA[37547]:=[ ,,,[4030482717,"RPn"],]; CONWAYPOLDATA[37549]:=[ ,,,[17632221873,"RPn"],]; CONWAYPOLDATA[37561]:=[ ,,,[12023989770,"RPn"],]; CONWAYPOLDATA[37567]:=[ ,,,[7981898060,"RPn"],]; CONWAYPOLDATA[37571]:=[ ,,,[5467933058,"RPn"],]; CONWAYPOLDATA[37573]:=[ ,,,[4954187920,"RPn"],]; CONWAYPOLDATA[37579]:=[ ,,,[3555424350,"RPn"],]; CONWAYPOLDATA[37589]:=[ ,,,[5548925771,"RPn"],]; CONWAYPOLDATA[37591]:=[ ,,,[15377876650,"RPn"],]; CONWAYPOLDATA[37607]:=[ ,,,[20911221927,"RPn"],]; CONWAYPOLDATA[37619]:=[ ,,,[11185595843,"RPn"],]; CONWAYPOLDATA[37633]:=[ ,,,[18364979271,"RPn"],]; CONWAYPOLDATA[37643]:=[ ,,,[12340655264,"RPn"],]; CONWAYPOLDATA[37649]:=[ ,,,[11124601821,"RPn"],]; CONWAYPOLDATA[37657]:=[ ,,,[9586568437,"RPn"],]; CONWAYPOLDATA[37663]:=[ ,,,[3666078760,"RPn"],]; CONWAYPOLDATA[37691]:=[ ,,,[8033949729,"RPn"],]; CONWAYPOLDATA[37693]:=[ ,,,[5095829751,"RPn"],]; CONWAYPOLDATA[37699]:=[ ,,,[1303405229,"RPn"],]; CONWAYPOLDATA[37717]:=[ ,,,[5478243387,"RPn"],]; CONWAYPOLDATA[37747]:=[ ,,,[8092201863,"RPn"],]; CONWAYPOLDATA[37781]:=[ ,,,[12381778227,"RPn"],]; CONWAYPOLDATA[37783]:=[ ,,,[15702803718,"RPn"],]; CONWAYPOLDATA[37799]:=[ ,,,[3578280145,"RPn"],]; CONWAYPOLDATA[37811]:=[ ,,,[7062300775,"RPn"],]; CONWAYPOLDATA[37813]:=[ ,,,[15029986868,"RPn"],]; CONWAYPOLDATA[37831]:=[ ,,,[5497109120,"RPn"],]; CONWAYPOLDATA[37847]:=[ ,,,[5175993572,"RPn"],]; CONWAYPOLDATA[37853]:=[ ,,,[25212104211,"RPn"],]; CONWAYPOLDATA[37861]:=[ ,,,[5134330212,"RPn"],]; CONWAYPOLDATA[37871]:=[ ,,,[12759232230,"RPn"],]; CONWAYPOLDATA[37879]:=[ ,,,[1094816744,"RPn"],]; CONWAYPOLDATA[37889]:=[ ,,,[2387082781,"RPn"],]; CONWAYPOLDATA[37897]:=[ ,,,[24388500664,"RPn"],]; CONWAYPOLDATA[37907]:=[ ,,,[11340713006,"RPn"],]; CONWAYPOLDATA[37951]:=[ ,,,[5431471221,"RPn"],]; CONWAYPOLDATA[37957]:=[ ,,,[5491125321,"RPn"],]; CONWAYPOLDATA[37963]:=[ ,,,[12349553717,"RPn"],]; CONWAYPOLDATA[37967]:=[ ,,,[9992306933,"RPn"],]; CONWAYPOLDATA[37987]:=[ ,,,[14312589917,"RPn"],]; CONWAYPOLDATA[37991]:=[ ,,,[3977999626,"RPn"],]; CONWAYPOLDATA[37993]:=[ ,,,[24426155626,"RPn"],]; CONWAYPOLDATA[37997]:=[ ,,,[11219602174,"RPn"],]; CONWAYPOLDATA[38011]:=[ ,,,[12300359602,"RPn"],]; CONWAYPOLDATA[38039]:=[ ,,,[7049501604,"RPn"],]; CONWAYPOLDATA[38047]:=[ ,,,[15923011926,"RPn"],]; CONWAYPOLDATA[38053]:=[ ,,,[5617878554,"RPn"],]; CONWAYPOLDATA[38069]:=[ ,,,[3714773022,"RPn"],]; CONWAYPOLDATA[38083]:=[ ,,,[5104645323,"RPn"],]; CONWAYPOLDATA[38113]:=[ ,,,[25871409311,"RPn"],]; CONWAYPOLDATA[38119]:=[ ,,,[7265138332,"RPn"],]; CONWAYPOLDATA[38149]:=[ ,,,[11290272854,"RPn"],]; CONWAYPOLDATA[38153]:=[ ,,,[963401406,"RPn"],]; CONWAYPOLDATA[38167]:=[ ,,,[8512805850,"RPn"],]; CONWAYPOLDATA[38177]:=[ ,,,[11563469710,"RPn"],]; CONWAYPOLDATA[38183]:=[ ,,,[9958470052,"RPn"],]; CONWAYPOLDATA[38189]:=[ ,,,[9802772601,"RPn"],]; CONWAYPOLDATA[38197]:=[ ,,,[9755437408,"RPn"],]; CONWAYPOLDATA[38201]:=[ ,,,[4283210726,"RPn"],]; CONWAYPOLDATA[38219]:=[ ,,,[11221327716,"RPn"],]; CONWAYPOLDATA[38231]:=[ ,,,[15864297542,"RPn"],]; CONWAYPOLDATA[38237]:=[ ,,,[11214759154,"RPn"],]; CONWAYPOLDATA[38239]:=[ ,,,[3662034326,"RPn"],]; CONWAYPOLDATA[38261]:=[ ,,,[7257805614,"RPn"],]; CONWAYPOLDATA[38273]:=[ ,,,[2293777439,"RPn"],]; CONWAYPOLDATA[38281]:=[ ,,,[30256843042,"RPn"],]; CONWAYPOLDATA[38287]:=[ ,,,[6625297348,"RPn"],]; CONWAYPOLDATA[38299]:=[ ,,,[11671352159,"RPn"],]; CONWAYPOLDATA[38303]:=[ ,,,[15683814506,"RPn"],]; CONWAYPOLDATA[38317]:=[ ,,,[11472416338,"RPn"],]; CONWAYPOLDATA[38321]:=[ ,,,[7288922450,"RPn"],]; CONWAYPOLDATA[38327]:=[ ,,,[8511468530,"RPn"],]; CONWAYPOLDATA[38329]:=[ ,,,[21527904482,"RPn"],]; CONWAYPOLDATA[38333]:=[ ,,,[17324676018,"RPn"],]; CONWAYPOLDATA[38351]:=[ ,,,[5836293542,"RPn"],]; CONWAYPOLDATA[38371]:=[ ,,,[8301297263,"RPn"],]; CONWAYPOLDATA[38377]:=[ ,,,[16190104995,"RPn"],]; CONWAYPOLDATA[38393]:=[ ,,,[2251019986,"RPn"],]; CONWAYPOLDATA[38431]:=[ ,,,[4362187523,"RPn"],]; CONWAYPOLDATA[38447]:=[ ,,,[6810040221,"RPn"],]; CONWAYPOLDATA[38449]:=[ ,,,[12962080689,"RPn"],]; CONWAYPOLDATA[38453]:=[ ,,,[18897380775,"RPn"],]; CONWAYPOLDATA[38459]:=[ ,,,[13272662410,"RPn"],]; CONWAYPOLDATA[38461]:=[ ,,,[11642721628,"RPn"],]; CONWAYPOLDATA[38501]:=[ ,,,[780607777,"RPn"],]; CONWAYPOLDATA[38543]:=[ ,,,[5942097229,"RPn"],]; CONWAYPOLDATA[38557]:=[ ,,,[15726359263,"RPn"],]; CONWAYPOLDATA[38561]:=[ ,,,[1486487992,"RPn"],]; CONWAYPOLDATA[38567]:=[ ,,,[10245439256,"RPn"],]; CONWAYPOLDATA[38569]:=[ ,,,[23800081396,"RPn"],]; CONWAYPOLDATA[38593]:=[ ,,,[23196978736,"RPn"],]; CONWAYPOLDATA[38603]:=[ ,,,[6860139132,"RPn"],]; CONWAYPOLDATA[38609]:=[ ,,,[11914505749,"RPn"],]; CONWAYPOLDATA[38611]:=[ ,,,[8583379747,"RPn"],]; CONWAYPOLDATA[38629]:=[ ,,,[5724663286,"RPn"],]; CONWAYPOLDATA[38639]:=[ ,,,[4129620432,"RPn"],]; CONWAYPOLDATA[38651]:=[ ,,,[7393511141,"RPn"],]; CONWAYPOLDATA[38653]:=[ ,,,[5896515152,"RPn"],]; CONWAYPOLDATA[38669]:=[ ,,,[23731397316,"RPn"],]; CONWAYPOLDATA[38671]:=[ ,,,[5336017941,"RPn"],]; CONWAYPOLDATA[38677]:=[ ,,,[5941290006,"RPn"],]; CONWAYPOLDATA[38693]:=[ ,,,[4238895538,"RPn"],]; CONWAYPOLDATA[38699]:=[ ,,,[10281008536,"RPn"],]; CONWAYPOLDATA[38707]:=[ ,,,[13429703308,"RPn"],]; CONWAYPOLDATA[38711]:=[ ,,,[8834972826,"RPn"],]; CONWAYPOLDATA[38713]:=[ ,,,[9918735161,"RPn"],]; CONWAYPOLDATA[38723]:=[ ,,,[17956319778,"RPn"],]; CONWAYPOLDATA[38729]:=[ ,,,[4158100359,"RPn"],]; CONWAYPOLDATA[38737]:=[ ,,,[9918763803,"RPn"],]; CONWAYPOLDATA[38747]:=[ ,,,[6808700336,"RPn"],]; CONWAYPOLDATA[38749]:=[ ,,,[9949464485,"RPn"],]; CONWAYPOLDATA[38767]:=[ ,,,[23476519865,"RPn"],]; CONWAYPOLDATA[38783]:=[ ,,,[6916792923,"RPn"],]; CONWAYPOLDATA[38791]:=[ ,,,[7191036795,"RPn"],]; CONWAYPOLDATA[38803]:=[ ,,,[10539399244,"RPn"],]; CONWAYPOLDATA[38821]:=[ ,,,[10225334939,"RPn"],]; CONWAYPOLDATA[38833]:=[ ,,,[28608076940,"RPn"],]; CONWAYPOLDATA[38839]:=[ ,,,[3971171239,"RPn"],]; CONWAYPOLDATA[38851]:=[ ,,,[3938053916,"RPn"],]; CONWAYPOLDATA[38861]:=[ ,,,[907637530,"RPn"],]; CONWAYPOLDATA[38867]:=[ ,,,[4086515249,"RPn"],]; CONWAYPOLDATA[38873]:=[ ,,,[7327288392,"RPn"],]; CONWAYPOLDATA[38891]:=[ ,,,[16153571307,"RPn"],]; CONWAYPOLDATA[38903]:=[ ,,,[8610400995,"RPn"],]; CONWAYPOLDATA[38917]:=[ ,,,[17601264014,"RPn"],]; CONWAYPOLDATA[38921]:=[ ,,,[11584173999,"RPn"],]; CONWAYPOLDATA[38923]:=[ ,,,[13634726902,"RPn"],]; CONWAYPOLDATA[38933]:=[ ,,,[7357441543,"RPn"],]; CONWAYPOLDATA[38953]:=[ ,,,[10484472626,"RPn"],]; CONWAYPOLDATA[38959]:=[ ,,,[10309252665,"RPn"],]; CONWAYPOLDATA[38971]:=[ ,,,[12990242403,"RPn"],]; CONWAYPOLDATA[38977]:=[ ,,,[10136163740,"RPn"],]; CONWAYPOLDATA[38993]:=[ ,,,[15064243679,"RPn"],]; CONWAYPOLDATA[39019]:=[ ,,,[5884845582,"RPn"],]; CONWAYPOLDATA[39023]:=[ ,,,[8570348334,"RPn"],]; CONWAYPOLDATA[39041]:=[ ,,,[11705780156,"RPn"],]; CONWAYPOLDATA[39043]:=[ ,,,[16123431540,"RPn"],]; CONWAYPOLDATA[39047]:=[ ,,,[5886803819,"RPn"],]; CONWAYPOLDATA[39079]:=[ ,,,[5694162014,"RPn"],]; CONWAYPOLDATA[39089]:=[ ,,,[1527480856,"RPn"],]; CONWAYPOLDATA[39097]:=[ ,,,[10346356406,"RPn"],]; CONWAYPOLDATA[39103]:=[ ,,,[27407331808,"RPn"],]; CONWAYPOLDATA[39107]:=[ ,,,[3862637499,"RPn"],]; CONWAYPOLDATA[39113]:=[ ,,,[7329072169,"RPn"],]; CONWAYPOLDATA[39119]:=[ ,,,[4041931567,"RPn"],]; CONWAYPOLDATA[39133]:=[ ,,,[5544246046,"RPn"],]; CONWAYPOLDATA[39139]:=[ ,,,[10541933101,"RPn"],]; CONWAYPOLDATA[39157]:=[ ,,,[13254174622,"RPn"],]; CONWAYPOLDATA[39161]:=[ ,,,[13639697981,"RPn"],]; CONWAYPOLDATA[39163]:=[ ,,,[13803390982,"RPn"],]; CONWAYPOLDATA[39181]:=[ ,,,[10745898609,"RPn"],]; CONWAYPOLDATA[39191]:=[ ,,,[4472751268,"RPn"],]; CONWAYPOLDATA[39199]:=[ ,,,[24462763151,"RPn"],]; CONWAYPOLDATA[39209]:=[ ,,,[1536875176,"RPn"],]; CONWAYPOLDATA[39217]:=[ ,,,[22571344357,"RPn"],]; CONWAYPOLDATA[39227]:=[ ,,,[13848543174,"RPn"],]; CONWAYPOLDATA[39229]:=[ ,,,[10150621439,"RPn"],]; CONWAYPOLDATA[39233]:=[ ,,,[7319347716,"RPn"],]; CONWAYPOLDATA[39239]:=[ ,,,[4507266220,"RPn"],]; CONWAYPOLDATA[39241]:=[ ,,,[1228047102,"RPn"],]; CONWAYPOLDATA[39251]:=[ ,,,[13190926568,"RPn"],]; CONWAYPOLDATA[39293]:=[ ,,,[15193463605,"RPn"],]; CONWAYPOLDATA[39301]:=[ ,,,[24684997408,"RPn"],]; CONWAYPOLDATA[39313]:=[ ,,,[1283254956,"RPn"],]; CONWAYPOLDATA[39317]:=[ ,,,[10700514722,"RPn"],]; CONWAYPOLDATA[39323]:=[ ,,,[11695485985,"RPn"],]; CONWAYPOLDATA[39341]:=[ ,,,[10512269271,"RPn"],]; CONWAYPOLDATA[39343]:=[ ,,,[13322956151,"RPn"],]; CONWAYPOLDATA[39359]:=[ ,,,[10370230613,"RPn"],]; CONWAYPOLDATA[39367]:=[ ,,,[5849818102,"RPn"],]; CONWAYPOLDATA[39371]:=[ ,,,[7603603119,"RPn"],]; CONWAYPOLDATA[39373]:=[ ,,,[1511962595,"RPn"],]; CONWAYPOLDATA[39383]:=[ ,,,[15466688680,"RPn"],]; CONWAYPOLDATA[39397]:=[ ,,,[20063749589,"RPn"],]; CONWAYPOLDATA[39409]:=[ ,,,[23041929990,"RPn"],]; CONWAYPOLDATA[39419]:=[ ,,,[13261300563,"RPn"],]; CONWAYPOLDATA[39439]:=[ ,,,[5609014583,"RPn"],]; CONWAYPOLDATA[39443]:=[ ,,,[21438690450,"RPn"],]; CONWAYPOLDATA[39451]:=[ ,,,[10810639179,"RPn"],]; CONWAYPOLDATA[39461]:=[ ,,,[19513740729,"RPn"],]; CONWAYPOLDATA[39499]:=[ ,,,[4052597402,"RPn"],]; CONWAYPOLDATA[39503]:=[ ,,,[7428855179,"RPn"],]; CONWAYPOLDATA[39509]:=[ ,,,[17170255822,"RPn"],]; CONWAYPOLDATA[39511]:=[ ,,,[4169911921,"RPn"],]; CONWAYPOLDATA[39521]:=[ ,,,[1561435192,"RPn"],]; CONWAYPOLDATA[39541]:=[ ,,,[5486392834,"RPn"],]; CONWAYPOLDATA[39551]:=[ ,,,[13579203041,"RPn"],]; CONWAYPOLDATA[39563]:=[ ,,,[16675646250,"RPn"],]; CONWAYPOLDATA[39569]:=[ ,,,[5528659821,"RPn"],]; CONWAYPOLDATA[39581]:=[ ,,,[14099622984,"RPn"],]; CONWAYPOLDATA[39607]:=[ ,,,[8707440525,"RPn"],]; CONWAYPOLDATA[39619]:=[ ,,,[11779322987,"RPn"],]; CONWAYPOLDATA[39623]:=[ ,,,[3976524662,"RPn"],]; CONWAYPOLDATA[39631]:=[ ,,,[10611120991,"RPn"],]; CONWAYPOLDATA[39659]:=[ ,,,[12220762216,"RPn"],]; CONWAYPOLDATA[39667]:=[ ,,,[7662553727,"RPn"],]; CONWAYPOLDATA[39671]:=[ ,,,[3955000352,"RPn"],]; CONWAYPOLDATA[39679]:=[ ,,,[5876777338,"RPn"],]; CONWAYPOLDATA[39703]:=[ ,,,[3969069212,"RPn"],]; CONWAYPOLDATA[39709]:=[ ,,,[12568295596,"RPn"],]; CONWAYPOLDATA[39719]:=[ ,,,[7835486294,"RPn"],]; CONWAYPOLDATA[39727]:=[ ,,,[4562129502,"RPn"],]; CONWAYPOLDATA[39733]:=[ ,,,[20108672637,"RPn"],]; CONWAYPOLDATA[39749]:=[ ,,,[5917791373,"RPn"],]; CONWAYPOLDATA[39761]:=[ ,,,[3990573007,"RPn"],]; CONWAYPOLDATA[39769]:=[ ,,,[23390694129,"RPn"],]; CONWAYPOLDATA[39779]:=[ ,,,[21616942856,"RPn"],]; CONWAYPOLDATA[39791]:=[ ,,,[11897031519,"RPn"],]; CONWAYPOLDATA[39799]:=[ ,,,[5577312466,"RPn"],]; CONWAYPOLDATA[39821]:=[ ,,,[5673417335,"RPn"],]; CONWAYPOLDATA[39827]:=[ ,,,[13801210485,"RPn"],]; CONWAYPOLDATA[39829]:=[ ,,,[18865523633,"RPn"],]; CONWAYPOLDATA[39839]:=[ ,,,[4556227081,"RPn"],]; CONWAYPOLDATA[39841]:=[ ,,,[20546760710,"RPn"],]; CONWAYPOLDATA[39847]:=[ ,,,[26875685789,"RPn"],]; CONWAYPOLDATA[39857]:=[ ,,,[31469134210,"RPn"],]; CONWAYPOLDATA[39863]:=[ ,,,[17170269721,"RPn"],]; CONWAYPOLDATA[39869]:=[ ,,,[1400478365,"RPn"],]; CONWAYPOLDATA[39877]:=[ ,,,[15411064807,"RPn"],]; CONWAYPOLDATA[39883]:=[ ,,,[4284471161,"RPn"],]; CONWAYPOLDATA[39887]:=[ ,,,[23416500984,"RPn"],]; CONWAYPOLDATA[39901]:=[ ,,,[20419576158,"RPn"],]; CONWAYPOLDATA[39929]:=[ ,,,[4124985135,"RPn"],]; CONWAYPOLDATA[39937]:=[ ,,,[29521230720,"RPn"],]; CONWAYPOLDATA[39953]:=[ ,,,[5641163838,"RPn"],]; CONWAYPOLDATA[39971]:=[ ,,,[14326725590,"RPn"],]; CONWAYPOLDATA[39979]:=[ ,,,[10742956988,"RPn"],]; CONWAYPOLDATA[39983]:=[ ,,,[19183203677,"RPn"],]; CONWAYPOLDATA[39989]:=[ ,,,[3063477314,"RPn"],]; CONWAYPOLDATA[40009]:=[ ,,,[20438117553,"JB"],]; CONWAYPOLDATA[40013]:=[ ,,,[10802549690,"JB"],]; CONWAYPOLDATA[40031]:=[ ,,,[22433532543,"JB"],]; CONWAYPOLDATA[40037]:=[ ,,,[19042437979,"JB"],]; CONWAYPOLDATA[40039]:=[ ,,,[6368603346,"JB"],]; CONWAYPOLDATA[40063]:=[ ,,,[8025059596,"JB"],]; CONWAYPOLDATA[40087]:=[ ,,,[10510370446,"JB"],]; CONWAYPOLDATA[40093]:=[ ,,,[10886011269,"JB"],]; CONWAYPOLDATA[40099]:=[ ,,,[5764672342,"JB"],]; CONWAYPOLDATA[40111]:=[ ,,,[6000284715,"JB"],]; CONWAYPOLDATA[40123]:=[ ,,,[4596771743,"JB"],]; CONWAYPOLDATA[40127]:=[ ,,,[10676791530,"JB"],]; CONWAYPOLDATA[40129]:=[ ,,,[1506763699,"JB"],]; CONWAYPOLDATA[40151]:=[ ,,,[5806798235,"JB"],]; CONWAYPOLDATA[40153]:=[ ,,,[33641187230,"JB"],]; CONWAYPOLDATA[40163]:=[ ,,,[7989826407,"JB"],]; CONWAYPOLDATA[40169]:=[ ,,,[7652756869,"JB"],]; CONWAYPOLDATA[40177]:=[ ,,,[29986586084,"JB"],]; CONWAYPOLDATA[40189]:=[ ,,,[20717349124,"JB"],]; CONWAYPOLDATA[40193]:=[ ,,,[12325625576,"JB"],]; CONWAYPOLDATA[40213]:=[ ,,,[1588011376,"JB"],]; CONWAYPOLDATA[40231]:=[ ,,,[6407591373,"JB"],]; CONWAYPOLDATA[40237]:=[ ,,,[10593154759,"JB"],]; CONWAYPOLDATA[40241]:=[ ,,,[4741033659,"JB"],]; CONWAYPOLDATA[40253]:=[ ,,,[11087125310,"JB"],]; CONWAYPOLDATA[40277]:=[ ,,,[6352246780,"JB"],]; CONWAYPOLDATA[40283]:=[ ,,,[14604198822,"JB"],]; CONWAYPOLDATA[40289]:=[ ,,,[1622720056,"JB"],]; CONWAYPOLDATA[40343]:=[ ,,,[19530207677,"JB"],]; CONWAYPOLDATA[40351]:=[ ,,,[5864775747,"JB"],]; CONWAYPOLDATA[40357]:=[ ,,,[12569591225,"JB"],]; CONWAYPOLDATA[40361]:=[ ,,,[2729775877,"JB"],]; CONWAYPOLDATA[40387]:=[ ,,,[22245603859,"JB"],]; CONWAYPOLDATA[40423]:=[ ,,,[6222676200,"JB"],]; CONWAYPOLDATA[40427]:=[ ,,,[14119614876,"JB"],]; CONWAYPOLDATA[40429]:=[ ,,,[17332276175,"JB"],]; CONWAYPOLDATA[40433]:=[ ,,,[10906518724,"JB"],]; CONWAYPOLDATA[40459]:=[ ,,,[4394616123,"JB"],]; CONWAYPOLDATA[40471]:=[ ,,,[4156088406,"JB"],]; CONWAYPOLDATA[40483]:=[ ,,,[14123992423,"JB"],]; CONWAYPOLDATA[40487]:=[ ,,,[12800491386,"JB"],]; CONWAYPOLDATA[40493]:=[ ,,,[6442922218,"JB"],]; CONWAYPOLDATA[40499]:=[ ,,,[5836594385,"JB"],]; CONWAYPOLDATA[40507]:=[ ,,,[12951303112,"JB"],]; CONWAYPOLDATA[40519]:=[ ,,,[19398592813,"JB"],]; CONWAYPOLDATA[40529]:=[ ,,,[1642113496,"JB"],]; CONWAYPOLDATA[40531]:=[ ,,,[14200076383,"JB"],]; CONWAYPOLDATA[40543]:=[ ,,,[5763876684,"JB"],]; CONWAYPOLDATA[40559]:=[ ,,,[9372130373,"JB"],]; CONWAYPOLDATA[40577]:=[ ,,,[19057069207,"JB"],]; CONWAYPOLDATA[40583]:=[ ,,,[24549793029,"JB"],]; CONWAYPOLDATA[40591]:=[ ,,,[9177543931,"JB"],]; CONWAYPOLDATA[40597]:=[ ,,,[15946217423,"JB"],]; CONWAYPOLDATA[40609]:=[ ,,,[42532364089,"JB"],]; CONWAYPOLDATA[40627]:=[ ,,,[32585007233,"JB"],]; CONWAYPOLDATA[40637]:=[ ,,,[10757426642,"JB"],]; CONWAYPOLDATA[40639]:=[ ,,,[5932684422,"JB"],]; CONWAYPOLDATA[40693]:=[ ,,,[21508610696,"JB"],]; CONWAYPOLDATA[40697]:=[ ,,,[4639824276,"JB"],]; CONWAYPOLDATA[40699]:=[ ,,,[5897569995,"JB"],]; CONWAYPOLDATA[40709]:=[ ,,,[11042031289,"JB"],]; CONWAYPOLDATA[40739]:=[ ,,,[6046971250,"JB"],]; CONWAYPOLDATA[40751]:=[ ,,,[6061466758,"JB"],]; CONWAYPOLDATA[40759]:=[ ,,,[8306317372,"JB"],]; CONWAYPOLDATA[40763]:=[ ,,,[1050992431,"JB"],]; CONWAYPOLDATA[40771]:=[ ,,,[14692441425,"JB"],]; CONWAYPOLDATA[40787]:=[ ,,,[22500923505,"JB"],]; CONWAYPOLDATA[40801]:=[ ,,,[17488818250,"JB"],]; CONWAYPOLDATA[40813]:=[ ,,,[11006613094,"JB"],]; CONWAYPOLDATA[40819]:=[ ,,,[4349101177,"JB"],]; CONWAYPOLDATA[40823]:=[ ,,,[6665906029,"JB"],]; CONWAYPOLDATA[40829]:=[ ,,,[5940578673,"JB"],]; CONWAYPOLDATA[40841]:=[ ,,,[4530042882,"JB"],]; CONWAYPOLDATA[40847]:=[ ,,,[14542920803,"JB"],]; CONWAYPOLDATA[40849]:=[ ,,,[34659886323,"JB"],]; CONWAYPOLDATA[40853]:=[ ,,,[16067525755,"JB"],]; CONWAYPOLDATA[40867]:=[ ,,,[14365813044,"JB"],]; CONWAYPOLDATA[40879]:=[ ,,,[5991921189,"JB"],]; CONWAYPOLDATA[40883]:=[ ,,,[4361112261,"JB"],]; CONWAYPOLDATA[40897]:=[ ,,,[41659606364,"JB"],]; CONWAYPOLDATA[40903]:=[ ,,,[6586282869,"JB"],]; CONWAYPOLDATA[40927]:=[ ,,,[10022653960,"JB"],]; CONWAYPOLDATA[40933]:=[ ,,,[26753235740,"JB"],]; CONWAYPOLDATA[40939]:=[ ,,,[4714658059,"JB"],]; CONWAYPOLDATA[40949]:=[ ,,,[2802672409,"JB"],]; CONWAYPOLDATA[40961]:=[ ,,,[13221063895,"JB"],]; CONWAYPOLDATA[40973]:=[ ,,,[11103273272,"JB"],]; CONWAYPOLDATA[40993]:=[ ,,,[11585359679,"JB"],]; CONWAYPOLDATA[41011]:=[ ,,,[4606314511,"JB"],]; CONWAYPOLDATA[41017]:=[ ,,,[11685004999,"JB"],]; CONWAYPOLDATA[41023]:=[ ,,,[4408823861,"JB"],]; CONWAYPOLDATA[41039]:=[ ,,,[13257279610,"JB"],]; CONWAYPOLDATA[41047]:=[ ,,,[18151599110,"JB"],]; CONWAYPOLDATA[41051]:=[ ,,,[4476734705,"JB"],]; CONWAYPOLDATA[41057]:=[ ,,,[4402665284,"JB"],]; CONWAYPOLDATA[41077]:=[ ,,,[11290793915,"JB"],]; CONWAYPOLDATA[41081]:=[ ,,,[11801749683,"JB"],]; CONWAYPOLDATA[41113]:=[ ,,,[28722939647,"JB"],]; CONWAYPOLDATA[41117]:=[ ,,,[15042983388,"JB"],]; CONWAYPOLDATA[41131]:=[ ,,,[4236616403,"JB"],]; CONWAYPOLDATA[41141]:=[ ,,,[1030870039,"JB"],]; CONWAYPOLDATA[41143]:=[ ,,,[6126933277,"JB"],]; CONWAYPOLDATA[41149]:=[ ,,,[15238873768,"JB"],]; CONWAYPOLDATA[41161]:=[ ,,,[1293649091,"JB"],]; CONWAYPOLDATA[41177]:=[ ,,,[3039356727,"JB"],]; CONWAYPOLDATA[41179]:=[ ,,,[6634060440,"JB"],]; CONWAYPOLDATA[41183]:=[ ,,,[4816145940,"JB"],]; CONWAYPOLDATA[41189]:=[ ,,,[1096986639,"JB"],]; CONWAYPOLDATA[41201]:=[ ,,,[8131717770,"JB"],]; CONWAYPOLDATA[41203]:=[ ,,,[9689421092,"JB"],]; CONWAYPOLDATA[41213]:=[ ,,,[11872847107,"JB"],]; CONWAYPOLDATA[41221]:=[ ,,,[12825460721,"JB"],]; CONWAYPOLDATA[41227]:=[ ,,,[38388603506,"JB"],]; CONWAYPOLDATA[41231]:=[ ,,,[13529416654,"JB"],]; CONWAYPOLDATA[41233]:=[ ,,,[22023988460,"JB"],]; CONWAYPOLDATA[41243]:=[ ,,,[28428717416,"JB"],]; CONWAYPOLDATA[41257]:=[ ,,,[15304737982,"JB"],]; CONWAYPOLDATA[41263]:=[ ,,,[4308764991,"JB"],]; CONWAYPOLDATA[41269]:=[ ,,,[26605794150,"JB"],]; CONWAYPOLDATA[41281]:=[ ,,,[28677456626,"JB"],]; CONWAYPOLDATA[41299]:=[ ,,,[11382912980,"JB"],]; CONWAYPOLDATA[41333]:=[ ,,,[3375666112,"JB"],]; CONWAYPOLDATA[41341]:=[ ,,,[13269592841,"JB"],]; CONWAYPOLDATA[41351]:=[ ,,,[4574040872,"JB"],]; CONWAYPOLDATA[41357]:=[ ,,,[13564268862,"JB"],]; CONWAYPOLDATA[41381]:=[ ,,,[6324258233,"JB"],]; CONWAYPOLDATA[41387]:=[ ,,,[20474728320,"JB"],]; CONWAYPOLDATA[41389]:=[ ,,,[4726209916,"JB"],]; CONWAYPOLDATA[41399]:=[ ,,,[31723060131,"JB"],]; CONWAYPOLDATA[41411]:=[ ,,,[5038352139,"JB"],]; CONWAYPOLDATA[41413]:=[ ,,,[14626408998,"JB"],]; CONWAYPOLDATA[41443]:=[ ,,,[15457410142,"JB"],]; CONWAYPOLDATA[41453]:=[ ,,,[4415905186,"JB"],]; CONWAYPOLDATA[41467]:=[ ,,,[1034601664,"JB"],]; CONWAYPOLDATA[41479]:=[ ,,,[6661900714,"JB"],]; CONWAYPOLDATA[41491]:=[ ,,,[10055551318,"JB"],]; CONWAYPOLDATA[41507]:=[ ,,,[14713152320,"JB"],]; CONWAYPOLDATA[41513]:=[ ,,,[11484862044,"JB"],]; CONWAYPOLDATA[41519]:=[ ,,,[7987010037,"JB"],]; CONWAYPOLDATA[41521]:=[ ,,,[1094202935,"JB"],]; CONWAYPOLDATA[41539]:=[ ,,,[2618493946,"JB"],]; CONWAYPOLDATA[41543]:=[ ,,,[18463994070,"JB"],]; CONWAYPOLDATA[41549]:=[ ,,,[6057387164,"JB"],]; CONWAYPOLDATA[41579]:=[ ,,,[8313845789,"JB"],]; CONWAYPOLDATA[41593]:=[ ,,,[25949207217,"JB"],]; CONWAYPOLDATA[41597]:=[ ,,,[7962372951,"JB"],]; CONWAYPOLDATA[41603]:=[ ,,,[8114956373,"JB"],]; CONWAYPOLDATA[41609]:=[ ,,,[7846708441,"JB"],]; CONWAYPOLDATA[41611]:=[ ,,,[5132051076,"JB"],]; CONWAYPOLDATA[41617]:=[ ,,,[19009272244,"JB"],]; CONWAYPOLDATA[41621]:=[ ,,,[3367055661,"JB"],]; CONWAYPOLDATA[41627]:=[ ,,,[5087360553,"JB"],]; CONWAYPOLDATA[41641]:=[ ,,,[55172159681,"JB"],]; CONWAYPOLDATA[41647]:=[ ,,,[6213315933,"JB"],]; CONWAYPOLDATA[41651]:=[ ,,,[1706608076,"JB"],]; CONWAYPOLDATA[41659]:=[ ,,,[11542334156,"JB"],]; CONWAYPOLDATA[41669]:=[ ,,,[2921038571,"JB"],]; CONWAYPOLDATA[41681]:=[ ,,,[13845302816,"JB"],]; CONWAYPOLDATA[41687]:=[ ,,,[6951057133,"JB"],]; CONWAYPOLDATA[41719]:=[ ,,,[6430775261,"JB"],]; CONWAYPOLDATA[41729]:=[ ,,,[13544899571,"JB"],]; CONWAYPOLDATA[41737]:=[ ,,,[11842998966,"JB"],]; CONWAYPOLDATA[41759]:=[ ,,,[6956172468,"JB"],]; CONWAYPOLDATA[41761]:=[ ,,,[18321385939,"JB"],]; CONWAYPOLDATA[41771]:=[ ,,,[13920352836,"JB"],]; CONWAYPOLDATA[41777]:=[ ,,,[8191759494,"JB"],]; CONWAYPOLDATA[41801]:=[ ,,,[5063313332,"JB"],]; CONWAYPOLDATA[41809]:=[ ,,,[32536934473,"JB"],]; CONWAYPOLDATA[41813]:=[ ,,,[11882460155,"JB"],]; CONWAYPOLDATA[41843]:=[ ,,,[13815303312,"JB"],]; CONWAYPOLDATA[41849]:=[ ,,,[1750836616,"JB"],]; CONWAYPOLDATA[41851]:=[ ,,,[16998160324,"JB"],]; CONWAYPOLDATA[41863]:=[ ,,,[10235670955,"JB"],]; CONWAYPOLDATA[41879]:=[ ,,,[4859387899,"JB"],]; CONWAYPOLDATA[41887]:=[ ,,,[10043999959,"JB"],]; CONWAYPOLDATA[41893]:=[ ,,,[12254247111,"JB"],]; CONWAYPOLDATA[41897]:=[ ,,,[15665372097,"JB"],]; CONWAYPOLDATA[41903]:=[ ,,,[25714697821,"JB"],]; CONWAYPOLDATA[41911]:=[ ,,,[8782491964,"JB"],]; CONWAYPOLDATA[41927]:=[ ,,,[10181091488,"JB"],]; CONWAYPOLDATA[41941]:=[ ,,,[22502395027,"JB"],]; CONWAYPOLDATA[41947]:=[ ,,,[5197149411,"JB"],]; CONWAYPOLDATA[41953]:=[ ,,,[26400351657,"JB"],]; CONWAYPOLDATA[41957]:=[ ,,,[8514459883,"JB"],]; CONWAYPOLDATA[41959]:=[ ,,,[5133054271,"JB"],]; CONWAYPOLDATA[41969]:=[ ,,,[1760893336,"JB"],]; CONWAYPOLDATA[41981]:=[ ,,,[13729466242,"JB"],]; CONWAYPOLDATA[41983]:=[ ,,,[10476227911,"JB"],]; CONWAYPOLDATA[41999]:=[ ,,,[13621703677,"JB"],]; CONWAYPOLDATA[42013]:=[ ,,,[15184380479,"JB"],]; CONWAYPOLDATA[42017]:=[ ,,,[14111241385,"JB"],]; CONWAYPOLDATA[42019]:=[ ,,,[4469645070,"JB"],]; CONWAYPOLDATA[42023]:=[ ,,,[7063562029,"JB"],]; CONWAYPOLDATA[42043]:=[ ,,,[5039946673,"JB"],]; CONWAYPOLDATA[42061]:=[ ,,,[13766186757,"JB"],]; CONWAYPOLDATA[42071]:=[ ,,,[10163848755,"JB"],]; CONWAYPOLDATA[42073]:=[ ,,,[22847363998,"JB"],]; CONWAYPOLDATA[42083]:=[ ,,,[13940077918,"JB"],]; CONWAYPOLDATA[42089]:=[ ,,,[1770978856,"JB"],]; CONWAYPOLDATA[42101]:=[ ,,,[8214410314,"JB"],]; CONWAYPOLDATA[42131]:=[ ,,,[11608817873,"JB"],]; CONWAYPOLDATA[42139]:=[ ,,,[3116895415,"JB"],]; CONWAYPOLDATA[42157]:=[ ,,,[14179970679,"JB"],]; CONWAYPOLDATA[42169]:=[ ,,,[22986448418,"JB"],]; CONWAYPOLDATA[42179]:=[ ,,,[1496089132,"JB"],]; CONWAYPOLDATA[42181]:=[ ,,,[3267129365,"JB"],]; CONWAYPOLDATA[42187]:=[ ,,,[15749630536,"JB"],]; CONWAYPOLDATA[42193]:=[ ,,,[23016154936,"JB"],]; CONWAYPOLDATA[42197]:=[ ,,,[31688470107,"JB"],]; CONWAYPOLDATA[42209]:=[ ,,,[8189601228,"JB"],]; CONWAYPOLDATA[42221]:=[ ,,,[4681802250,"JB"],]; CONWAYPOLDATA[42223]:=[ ,,,[22435233278,"JB"],]; CONWAYPOLDATA[42227]:=[ ,,,[8876791034,"JB"],]; CONWAYPOLDATA[42239]:=[ ,,,[9842489548,"JB"],]; CONWAYPOLDATA[42257]:=[ ,,,[8323445807,"JB"],]; CONWAYPOLDATA[42281]:=[ ,,,[1497635312,"JB"],]; CONWAYPOLDATA[42283]:=[ ,,,[14143917200,"JB"],]; CONWAYPOLDATA[42293]:=[ ,,,[11854051214,"JB"],]; CONWAYPOLDATA[42299]:=[ ,,,[4840020778,"JB"],]; CONWAYPOLDATA[42307]:=[ ,,,[26304377253,"JB"],]; CONWAYPOLDATA[42323]:=[ ,,,[6963741776,"JB"],]; CONWAYPOLDATA[42331]:=[ ,,,[14046187761,"JB"],]; CONWAYPOLDATA[42337]:=[ ,,,[19350972595,"JB"],]; CONWAYPOLDATA[42349]:=[ ,,,[7141142476,"JB"],]; CONWAYPOLDATA[42359]:=[ ,,,[4889457018,"JB"],]; CONWAYPOLDATA[42373]:=[ ,,,[6471882533,"JB"],]; CONWAYPOLDATA[42379]:=[ ,,,[15791220603,"JB"],]; CONWAYPOLDATA[42391]:=[ ,,,[3039307533,"JB"],]; CONWAYPOLDATA[42397]:=[ ,,,[12194776303,"JB"],]; CONWAYPOLDATA[42403]:=[ ,,,[15491724037,"JB"],]; CONWAYPOLDATA[42407]:=[ ,,,[4907974150,"JB"],]; CONWAYPOLDATA[42409]:=[ ,,,[37452405730,"JB"],]; CONWAYPOLDATA[42433]:=[ ,,,[1033201127,"JB"],]; CONWAYPOLDATA[42437]:=[ ,,,[6770441419,"JB"],]; CONWAYPOLDATA[42443]:=[ ,,,[15676788925,"JB"],]; CONWAYPOLDATA[42451]:=[ ,,,[4968677298,"JB"],]; CONWAYPOLDATA[42457]:=[ ,,,[41189658561,"JB"],]; CONWAYPOLDATA[42461]:=[ ,,,[3011419044,"JB"],]; CONWAYPOLDATA[42463]:=[ ,,,[9015361996,"JB"],]; CONWAYPOLDATA[42467]:=[ ,,,[5027370866,"JB"],]; CONWAYPOLDATA[42473]:=[ ,,,[14291867192,"JB"],]; CONWAYPOLDATA[42487]:=[ ,,,[5017374809,"JB"],]; CONWAYPOLDATA[42491]:=[ ,,,[14428711363,"JB"],]; CONWAYPOLDATA[42499]:=[ ,,,[15876818921,"JB"],]; CONWAYPOLDATA[42509]:=[ ,,,[8979643671,"JB"],]; CONWAYPOLDATA[42533]:=[ ,,,[22901638654,"JB"],]; CONWAYPOLDATA[42557]:=[ ,,,[11851273362,"JB"],]; CONWAYPOLDATA[42569]:=[ ,,,[14411351832,"JB"],]; CONWAYPOLDATA[42571]:=[ ,,,[15899374511,"JB"],]; CONWAYPOLDATA[42577]:=[ ,,,[26769948141,"JB"],]; CONWAYPOLDATA[42589]:=[ ,,,[22897081483,"JB"],]; CONWAYPOLDATA[42611]:=[ ,,,[16053822085,"JB"],]; CONWAYPOLDATA[42641]:=[ ,,,[1817743192,"JB"],]; CONWAYPOLDATA[42643]:=[ ,,,[13896841986,"JB"],]; CONWAYPOLDATA[42649]:=[ ,,,[26498292850,"JB"],]; CONWAYPOLDATA[42667]:=[ ,,,[28579721951,"JB"],]; CONWAYPOLDATA[42677]:=[ ,,,[8920858666,"JB"],]; CONWAYPOLDATA[42683]:=[ ,,,[14207292650,"JB"],]; CONWAYPOLDATA[42689]:=[ ,,,[8216522589,"JB"],]; CONWAYPOLDATA[42697]:=[ ,,,[54138984762,"JB"],]; CONWAYPOLDATA[42701]:=[ ,,,[6402032830,"JB"],]; CONWAYPOLDATA[42703]:=[ ,,,[5098439284,"JB"],]; CONWAYPOLDATA[42709]:=[ ,,,[21175463878,"JB"],]; CONWAYPOLDATA[42719]:=[ ,,,[12007755572,"JB"],]; CONWAYPOLDATA[42727]:=[ ,,,[7086230226,"JB"],]; CONWAYPOLDATA[42737]:=[ ,,,[12636006056,"JB"],]; CONWAYPOLDATA[42743]:=[ ,,,[19423145838,"JB"],]; CONWAYPOLDATA[42751]:=[ ,,,[5273207603,"JB"],]; CONWAYPOLDATA[42767]:=[ ,,,[27223718758,"JB"],]; CONWAYPOLDATA[42773]:=[ ,,,[13847587661,"JB"],]; CONWAYPOLDATA[42787]:=[ ,,,[19791811447,"JB"],]; CONWAYPOLDATA[42793]:=[ ,,,[28619487682,"JB"],]; CONWAYPOLDATA[42797]:=[ ,,,[16483949304,"JB"],]; CONWAYPOLDATA[42821]:=[ ,,,[14530407111,"JB"],]; CONWAYPOLDATA[42829]:=[ ,,,[6873754699,"JB"],]; CONWAYPOLDATA[42839]:=[ ,,,[10188056669,"JB"],]; CONWAYPOLDATA[42841]:=[ ,,,[23722475476,"JB"],]; CONWAYPOLDATA[42853]:=[ ,,,[27367168539,"JB"],]; CONWAYPOLDATA[42859]:=[ ,,,[10833769453,"JB"],]; CONWAYPOLDATA[42863]:=[ ,,,[9023518765,"JB"],]; CONWAYPOLDATA[42899]:=[ ,,,[8346601038,"JB"],]; CONWAYPOLDATA[42901]:=[ ,,,[5374937593,"JB"],]; CONWAYPOLDATA[42923]:=[ ,,,[30647494155,"JB"],]; CONWAYPOLDATA[42929]:=[ ,,,[7162617795,"JB"],]; CONWAYPOLDATA[42937]:=[ ,,,[20266865123,"JB"],]; CONWAYPOLDATA[42943]:=[ ,,,[10359397551,"JB"],]; CONWAYPOLDATA[42953]:=[ ,,,[47647505185,"JB"],]; CONWAYPOLDATA[42961]:=[ ,,,[30573066778,"JB"],]; CONWAYPOLDATA[42967]:=[ ,,,[6810828074,"JB"],]; CONWAYPOLDATA[42979]:=[ ,,,[12443065188,"JB"],]; CONWAYPOLDATA[42989]:=[ ,,,[1264048558,"JB"],]; CONWAYPOLDATA[43003]:=[ ,,,[12944462044,"JB"],]; CONWAYPOLDATA[43013]:=[ ,,,[8478034354,"JB"],]; CONWAYPOLDATA[43019]:=[ ,,,[15897972585,"JB"],]; CONWAYPOLDATA[43037]:=[ ,,,[12845167318,"JB"],]; CONWAYPOLDATA[43049]:=[ ,,,[8512035724,"JB"],]; CONWAYPOLDATA[43051]:=[ ,,,[16519960232,"JB"],]; CONWAYPOLDATA[43063]:=[ ,,,[12871143136,"JB"],]; CONWAYPOLDATA[43067]:=[ ,,,[9072192753,"JB"],]; CONWAYPOLDATA[43093]:=[ ,,,[3525093591,"JB"],]; CONWAYPOLDATA[43103]:=[ ,,,[7431302029,"JB"],]; CONWAYPOLDATA[43117]:=[ ,,,[12580807613,"JB"],]; CONWAYPOLDATA[43133]:=[ ,,,[7094300177,"JB"],]; CONWAYPOLDATA[43151]:=[ ,,,[8661182429,"JB"],]; CONWAYPOLDATA[43159]:=[ ,,,[7087916255,"JB"],]; CONWAYPOLDATA[43177]:=[ ,,,[27963324993,"JB"],]; CONWAYPOLDATA[43189]:=[ ,,,[1587627642,"JB"],]; CONWAYPOLDATA[43201]:=[ ,,,[27411725739,"JB"],]; CONWAYPOLDATA[43207]:=[ ,,,[11025994333,"JB"],]; CONWAYPOLDATA[43223]:=[ ,,,[20372815271,"JB"],]; CONWAYPOLDATA[43237]:=[ ,,,[14152075420,"JB"],]; CONWAYPOLDATA[43261]:=[ ,,,[19944575571,"JB"],]; CONWAYPOLDATA[43271]:=[ ,,,[11233757407,"JB"],]; CONWAYPOLDATA[43283]:=[ ,,,[14798457702,"JB"],]; CONWAYPOLDATA[43291]:=[ ,,,[12748376974,"JB"],]; CONWAYPOLDATA[43313]:=[ ,,,[9260492655,"JB"],]; CONWAYPOLDATA[43319]:=[ ,,,[7310471132,"JB"],]; CONWAYPOLDATA[43321]:=[ ,,,[27550769741,"JB"],]; CONWAYPOLDATA[43331]:=[ ,,,[14899927655,"JB"],]; CONWAYPOLDATA[43391]:=[ ,,,[4939284329,"JB"],]; CONWAYPOLDATA[43397]:=[ ,,,[14620839875,"JB"],]; CONWAYPOLDATA[43399]:=[ ,,,[1786519848,"JB"],]; CONWAYPOLDATA[43403]:=[ ,,,[5176589006,"JB"],]; CONWAYPOLDATA[43411]:=[ ,,,[4723290447,"JB"],]; CONWAYPOLDATA[43427]:=[ ,,,[9409284665,"JB"],]; CONWAYPOLDATA[43441]:=[ ,,,[20355540350,"JB"],]; CONWAYPOLDATA[43451]:=[ ,,,[14247148392,"JB"],]; CONWAYPOLDATA[43457]:=[ ,,,[1127969895,"JB"],]; CONWAYPOLDATA[43481]:=[ ,,,[14635008910,"JB"],]; CONWAYPOLDATA[43487]:=[ ,,,[16824728922,"JB"],]; CONWAYPOLDATA[43499]:=[ ,,,[18088406667,"JB"],]; CONWAYPOLDATA[43517]:=[ ,,,[18312823942,"JB"],]; CONWAYPOLDATA[43541]:=[ ,,,[24222119548,"JB"],]; CONWAYPOLDATA[43543]:=[ ,,,[7341523975,"JB"],]; CONWAYPOLDATA[43573]:=[ ,,,[7114686588,"JB"],]; CONWAYPOLDATA[43577]:=[ ,,,[35905399884,"JB"],]; CONWAYPOLDATA[43579]:=[ ,,,[16794997970,"JB"],]; CONWAYPOLDATA[43591]:=[ ,,,[5522413028,"JB"],]; CONWAYPOLDATA[43597]:=[ ,,,[18217747601,"JB"],]; CONWAYPOLDATA[43607]:=[ ,,,[5268946601,"JB"],]; CONWAYPOLDATA[43609]:=[ ,,,[30426784276,"JB"],]; CONWAYPOLDATA[43613]:=[ ,,,[12889691313,"JB"],]; CONWAYPOLDATA[43627]:=[ ,,,[21956771070,"JB"],]; CONWAYPOLDATA[43633]:=[ ,,,[57084923006,"JB"],]; CONWAYPOLDATA[43649]:=[ ,,,[5514047226,"JB"],]; CONWAYPOLDATA[43651]:=[ ,,,[12786207271,"JB"],]; CONWAYPOLDATA[43661]:=[ ,,,[13288487318,"JB"],]; CONWAYPOLDATA[43669]:=[ ,,,[22334422714,"JB"],]; CONWAYPOLDATA[43691]:=[ ,,,[8731471592,"JB"],]; CONWAYPOLDATA[43711]:=[ ,,,[13250596264,"JB"],]; CONWAYPOLDATA[43717]:=[ ,,,[43156110895,"JB"],]; CONWAYPOLDATA[43721]:=[ ,,,[4883548261,"JB"],]; CONWAYPOLDATA[43753]:=[ ,,,[20652816103,"JB"],]; CONWAYPOLDATA[43759]:=[ ,,,[7116001065,"JB"],]; CONWAYPOLDATA[43777]:=[ ,,,[20634682948,"JB"],]; CONWAYPOLDATA[43781]:=[ ,,,[8905493212,"JB"],]; CONWAYPOLDATA[43783]:=[ ,,,[12641509376,"JB"],]; CONWAYPOLDATA[43787]:=[ ,,,[7046554338,"JB"],]; CONWAYPOLDATA[43789]:=[ ,,,[22268063965,"JB"],]; CONWAYPOLDATA[43793]:=[ ,,,[8654898179,"JB"],]; CONWAYPOLDATA[43801]:=[ ,,,[24717999356,"JB"],]; CONWAYPOLDATA[43853]:=[ ,,,[7246313575,"JB"],]; CONWAYPOLDATA[43867]:=[ ,,,[11415948083,"JB"],]; CONWAYPOLDATA[43889]:=[ ,,,[15053137001,"JB"],]; CONWAYPOLDATA[43891]:=[ ,,,[5064450820,"JB"],]; CONWAYPOLDATA[43913]:=[ ,,,[3703271119,"JB"],]; CONWAYPOLDATA[43933]:=[ ,,,[12843417155,"JB"],]; CONWAYPOLDATA[43943]:=[ ,,,[5035648090,"JB"],]; CONWAYPOLDATA[43951]:=[ ,,,[7431191135,"JB"],]; CONWAYPOLDATA[43961]:=[ ,,,[1845614669,"JB"],]; CONWAYPOLDATA[43963]:=[ ,,,[1403298972,"JB"],]; CONWAYPOLDATA[43969]:=[ ,,,[32537851453,"JB"],]; CONWAYPOLDATA[43973]:=[ ,,,[7537807689,"JB"],]; CONWAYPOLDATA[43987]:=[ ,,,[39798161979,"JB"],]; CONWAYPOLDATA[43991]:=[ ,,,[8873424627,"JB"],]; CONWAYPOLDATA[43997]:=[ ,,,[9645374318,"JB"],]; CONWAYPOLDATA[44017]:=[ ,,,[22500962207,"JB"],]; CONWAYPOLDATA[44021]:=[ ,,,[6916711585,"JB"],]; CONWAYPOLDATA[44027]:=[ ,,,[7730877040,"JB"],]; CONWAYPOLDATA[44029]:=[ ,,,[13569693777,"JB"],]; CONWAYPOLDATA[44041]:=[ ,,,[65776818987,"JB"],]; CONWAYPOLDATA[44053]:=[ ,,,[13142683916,"JB"],]; CONWAYPOLDATA[44059]:=[ ,,,[17338670449,"JB"],]; CONWAYPOLDATA[44071]:=[ ,,,[7511284959,"JB"],]; CONWAYPOLDATA[44087]:=[ ,,,[9348736529,"JB"],]; CONWAYPOLDATA[44089]:=[ ,,,[11357679125,"JB"],]; CONWAYPOLDATA[44101]:=[ ,,,[14815334047,"JB"],]; CONWAYPOLDATA[44111]:=[ ,,,[5426976337,"JB"],]; CONWAYPOLDATA[44119]:=[ ,,,[4989417716,"JB"],]; CONWAYPOLDATA[44123]:=[ ,,,[16793478540,"JB"],]; CONWAYPOLDATA[44129]:=[ ,,,[14737100198,"JB"],]; CONWAYPOLDATA[44131]:=[ ,,,[17527597534,"JB"],]; CONWAYPOLDATA[44159]:=[ ,,,[6911987486,"JB"],]; CONWAYPOLDATA[44171]:=[ ,,,[14896758094,"JB"],]; CONWAYPOLDATA[44179]:=[ ,,,[16623320690,"JB"],]; CONWAYPOLDATA[44189]:=[ ,,,[4981823673,"JB"],]; CONWAYPOLDATA[44201]:=[ ,,,[1285807096,"JB"],]; CONWAYPOLDATA[44203]:=[ ,,,[1362911104,"JB"],]; CONWAYPOLDATA[44207]:=[ ,,,[7762837619,"JB"],]; CONWAYPOLDATA[44221]:=[ ,,,[24881387862,"JB"],]; CONWAYPOLDATA[44249]:=[ ,,,[15054350534,"JB"],]; CONWAYPOLDATA[44257]:=[ ,,,[20645846248,"JB"],]; CONWAYPOLDATA[44263]:=[ ,,,[5771054206,"JB"],]; CONWAYPOLDATA[44267]:=[ ,,,[5206374673,"JB"],]; CONWAYPOLDATA[44269]:=[ ,,,[20994617521,"JB"],]; CONWAYPOLDATA[44273]:=[ ,,,[3497389911,"JB"],]; CONWAYPOLDATA[44279]:=[ ,,,[13693502152,"JB"],]; CONWAYPOLDATA[44281]:=[ ,,,[1564049208,"JB"],]; CONWAYPOLDATA[44293]:=[ ,,,[19101356252,"JB"],]; CONWAYPOLDATA[44351]:=[ ,,,[5170705705,"JB"],]; CONWAYPOLDATA[44357]:=[ ,,,[13307854071,"JB"],]; CONWAYPOLDATA[44371]:=[ ,,,[5410111661,"JB"],]; CONWAYPOLDATA[44381]:=[ ,,,[12813327274,"JB"],]; CONWAYPOLDATA[44383]:=[ ,,,[7615101994,"JB"],]; CONWAYPOLDATA[44389]:=[ ,,,[21078826876,"JB"],]; CONWAYPOLDATA[44417]:=[ ,,,[8903121151,"JB"],]; CONWAYPOLDATA[44449]:=[ ,,,[17729239296,"JB"],]; CONWAYPOLDATA[44453]:=[ ,,,[19216365107,"JB"],]; CONWAYPOLDATA[44483]:=[ ,,,[17808324222,"JB"],]; CONWAYPOLDATA[44491]:=[ ,,,[17814507850,"JB"],]; CONWAYPOLDATA[44497]:=[ ,,,[13678600290,"JB"],]; CONWAYPOLDATA[44501]:=[ ,,,[13693135706,"JB"],]; CONWAYPOLDATA[44507]:=[ ,,,[14897205014,"JB"],]; CONWAYPOLDATA[44519]:=[ ,,,[5606233164,"JB"],]; CONWAYPOLDATA[44531]:=[ ,,,[14997506430,"JB"],]; CONWAYPOLDATA[44533]:=[ ,,,[19649651856,"JB"],]; CONWAYPOLDATA[44537]:=[ ,,,[3533610120,"JB"],]; CONWAYPOLDATA[44543]:=[ ,,,[17252706566,"JB"],]; CONWAYPOLDATA[44549]:=[ ,,,[1199437278,"JB"],]; CONWAYPOLDATA[44563]:=[ ,,,[15215011404,"JB"],]; CONWAYPOLDATA[44579]:=[ ,,,[5434269260,"JB"],]; CONWAYPOLDATA[44587]:=[ ,,,[5857483367,"JB"],]; CONWAYPOLDATA[44617]:=[ ,,,[25522039430,"JB"],]; CONWAYPOLDATA[44621]:=[ ,,,[3117580030,"JB"],]; CONWAYPOLDATA[44623]:=[ ,,,[19648354742,"JB"],]; CONWAYPOLDATA[44633]:=[ ,,,[3119578905,"JB"],]; CONWAYPOLDATA[44641]:=[ ,,,[106917650274,"JB"],]; CONWAYPOLDATA[44647]:=[ ,,,[7973239853,"JB"],]; CONWAYPOLDATA[44651]:=[ ,,,[5297885803,"JB"],]; CONWAYPOLDATA[44657]:=[ ,,,[3586894900,"JB"],]; CONWAYPOLDATA[44683]:=[ ,,,[17751483510,"JB"],]; CONWAYPOLDATA[44687]:=[ ,,,[14995259099,"JB"],]; CONWAYPOLDATA[44699]:=[ ,,,[26988675115,"JB"],]; CONWAYPOLDATA[44701]:=[ ,,,[7498458649,"JB"],]; CONWAYPOLDATA[44711]:=[ ,,,[7469061979,"JB"],]; CONWAYPOLDATA[44729]:=[ ,,,[17496195643,"JB"],]; CONWAYPOLDATA[44741]:=[ ,,,[13128575337,"JB"],]; CONWAYPOLDATA[44753]:=[ ,,,[1799115356,"JB"],]; CONWAYPOLDATA[44771]:=[ ,,,[3680041893,"JB"],]; CONWAYPOLDATA[44773]:=[ ,,,[21445550637,"JB"],]; CONWAYPOLDATA[44777]:=[ ,,,[15641546420,"JB"],]; CONWAYPOLDATA[44789]:=[ ,,,[7145233961,"JB"],]; CONWAYPOLDATA[44797]:=[ ,,,[39836045831,"JB"],]; CONWAYPOLDATA[44809]:=[ ,,,[25994686709,"JB"],]; CONWAYPOLDATA[44819]:=[ ,,,[9785601186,"JB"],]; CONWAYPOLDATA[44839]:=[ ,,,[21180239724,"JB"],]; CONWAYPOLDATA[44843]:=[ ,,,[11862587853,"JB"],]; CONWAYPOLDATA[44851]:=[ ,,,[24138539104,"JB"],]; CONWAYPOLDATA[44867]:=[ ,,,[17413645441,"JB"],]; CONWAYPOLDATA[44879]:=[ ,,,[25773695554,"JB"],]; CONWAYPOLDATA[44887]:=[ ,,,[21168439883,"JB"],]; CONWAYPOLDATA[44893]:=[ ,,,[7619554216,"JB"],]; CONWAYPOLDATA[44909]:=[ ,,,[26060243612,"JB"],]; CONWAYPOLDATA[44917]:=[ ,,,[15778803101,"JB"],]; CONWAYPOLDATA[44927]:=[ ,,,[1119760555,"JB"],]; CONWAYPOLDATA[44939]:=[ ,,,[3656776310,"JB"],]; CONWAYPOLDATA[44953]:=[ ,,,[47524131793,"JB"],]; CONWAYPOLDATA[44959]:=[ ,,,[7464362937,"JB"],]; CONWAYPOLDATA[44963]:=[ ,,,[17379773207,"JB"],]; CONWAYPOLDATA[44971]:=[ ,,,[5149314416,"JB"],]; CONWAYPOLDATA[44983]:=[ ,,,[7747781957,"JB"],]; CONWAYPOLDATA[44987]:=[ ,,,[5754737042,"JB"],]; CONWAYPOLDATA[45007]:=[ ,,,[34169044361,"JB"],]; CONWAYPOLDATA[45013]:=[ ,,,[20227266747,"JB"],]; CONWAYPOLDATA[45053]:=[ ,,,[15474353912,"JB"],]; CONWAYPOLDATA[45061]:=[ ,,,[13884736054,"JB"],]; CONWAYPOLDATA[45077]:=[ ,,,[34433373685,"JB"],]; CONWAYPOLDATA[45083]:=[ ,,,[5694253400,"JB"],]; CONWAYPOLDATA[45119]:=[ ,,,[8075127913,"JB"],]; CONWAYPOLDATA[45121]:=[ ,,,[29933000681,"JB"],]; CONWAYPOLDATA[45127]:=[ ,,,[12037040611,"JB"],]; CONWAYPOLDATA[45131]:=[ ,,,[9452101249,"JB"],]; CONWAYPOLDATA[45137]:=[ ,,,[52754726356,"JB"],]; CONWAYPOLDATA[45139]:=[ ,,,[15650007275,"JB"],]; CONWAYPOLDATA[45161]:=[ ,,,[9701486023,"JB"],]; CONWAYPOLDATA[45179]:=[ ,,,[3909429234,"JB"],]; CONWAYPOLDATA[45181]:=[ ,,,[18371588584,"JB"],]; CONWAYPOLDATA[45191]:=[ ,,,[11444846716,"JB"],]; CONWAYPOLDATA[45197]:=[ ,,,[9576837529,"JB"],]; CONWAYPOLDATA[45233]:=[ ,,,[3435898683,"JB"],]; CONWAYPOLDATA[45247]:=[ ,,,[7862209219,"JB"],]; CONWAYPOLDATA[45259]:=[ ,,,[8005321405,"JB"],]; CONWAYPOLDATA[45263]:=[ ,,,[8194775629,"JB"],]; CONWAYPOLDATA[45281]:=[ ,,,[6137477305,"JB"],]; CONWAYPOLDATA[45289]:=[ ,,,[26181253891,"JB"],]; CONWAYPOLDATA[45293]:=[ ,,,[7483581220,"JB"],]; CONWAYPOLDATA[45307]:=[ ,,,[18474201094,"JB"],]; CONWAYPOLDATA[45317]:=[ ,,,[7421882311,"JB"],]; CONWAYPOLDATA[45319]:=[ ,,,[10268877532,"JB"],]; CONWAYPOLDATA[45329]:=[ ,,,[5298370826,"JB"],]; CONWAYPOLDATA[45337]:=[ ,,,[13820440411,"JB"],]; CONWAYPOLDATA[45341]:=[ ,,,[3973367855,"JB"],]; CONWAYPOLDATA[45343]:=[ ,,,[7743314802,"JB"],]; CONWAYPOLDATA[45361]:=[ ,,,[26694404179,"JB"],]; CONWAYPOLDATA[45377]:=[ ,,,[1687207617,"JB"],]; CONWAYPOLDATA[45389]:=[ ,,,[1380778771,"JB"],]; CONWAYPOLDATA[45403]:=[ ,,,[5354602808,"JB"],]; CONWAYPOLDATA[45413]:=[ ,,,[10188906095,"JB"],]; CONWAYPOLDATA[45427]:=[ ,,,[11378509536,"JB"],]; CONWAYPOLDATA[45433]:=[ ,,,[25980861057,"JB"],]; CONWAYPOLDATA[45439]:=[ ,,,[16114168890,"JB"],]; CONWAYPOLDATA[45481]:=[ ,,,[38858056793,"JB"],]; CONWAYPOLDATA[45491]:=[ ,,,[16110819616,"JB"],]; CONWAYPOLDATA[45497]:=[ ,,,[57413483249,"JB"],]; CONWAYPOLDATA[45503]:=[ ,,,[8281910029,"JB"],]; CONWAYPOLDATA[45523]:=[ ,,,[17981539479,"JB"],]; CONWAYPOLDATA[45533]:=[ ,,,[20528735184,"JB"],]; CONWAYPOLDATA[45541]:=[ ,,,[30228931744,"JB"],]; CONWAYPOLDATA[45553]:=[ ,,,[14494782393,"JB"],]; CONWAYPOLDATA[45557]:=[ ,,,[14497330771,"JB"],]; CONWAYPOLDATA[45569]:=[ ,,,[10169770440,"JB"],]; CONWAYPOLDATA[45587]:=[ ,,,[28472728462,"JB"],]; CONWAYPOLDATA[45589]:=[ ,,,[19988177929,"JB"],]; CONWAYPOLDATA[45599]:=[ ,,,[14527339818,"JB"],]; CONWAYPOLDATA[45613]:=[ ,,,[26293705078,"JB"],]; CONWAYPOLDATA[45631]:=[ ,,,[5391120138,"JB"],]; CONWAYPOLDATA[45641]:=[ ,,,[32897165632,"JB"],]; CONWAYPOLDATA[45659]:=[ ,,,[3968588964,"JB"],]; CONWAYPOLDATA[45667]:=[ ,,,[24279728225,"JB"],]; CONWAYPOLDATA[45673]:=[ ,,,[22326378268,"JB"],]; CONWAYPOLDATA[45677]:=[ ,,,[26757129832,"JB"],]; CONWAYPOLDATA[45691]:=[ ,,,[13707528462,"JB"],]; CONWAYPOLDATA[45697]:=[ ,,,[14279398570,"JB"],]; CONWAYPOLDATA[45707]:=[ ,,,[7413858230,"JB"],]; CONWAYPOLDATA[45737]:=[ ,,,[1761469084,"JB"],]; CONWAYPOLDATA[45751]:=[ ,,,[5573112317,"JB"],]; CONWAYPOLDATA[45757]:=[ ,,,[16492332783,"JB"],]; CONWAYPOLDATA[45763]:=[ ,,,[14659399084,"JB"],]; CONWAYPOLDATA[45767]:=[ ,,,[11680013007,"JB"],]; CONWAYPOLDATA[45779]:=[ ,,,[13691949554,"JB"],]; CONWAYPOLDATA[45817]:=[ ,,,[14597296205,"JB"],]; CONWAYPOLDATA[45821]:=[ ,,,[3348736145,"JB"],]; CONWAYPOLDATA[45823]:=[ ,,,[5588985490,"JB"],]; CONWAYPOLDATA[45827]:=[ ,,,[10245313257,"JB"],]; CONWAYPOLDATA[45833]:=[ ,,,[25163004500,"JB"],]; CONWAYPOLDATA[45841]:=[ ,,,[37152067662,"JB"],]; CONWAYPOLDATA[45853]:=[ ,,,[24379764987,"JB"],]; CONWAYPOLDATA[45863]:=[ ,,,[7420679273,"JB"],]; CONWAYPOLDATA[45869]:=[ ,,,[7541047078,"JB"],]; CONWAYPOLDATA[45887]:=[ ,,,[8119658768,"JB"],]; CONWAYPOLDATA[45893]:=[ ,,,[56574045036,"JB"],]; CONWAYPOLDATA[45943]:=[ ,,,[11949131104,"JB"],]; CONWAYPOLDATA[45949]:=[ ,,,[22672844817,"JB"],]; CONWAYPOLDATA[45953]:=[ ,,,[18636652730,"JB"],]; CONWAYPOLDATA[45959]:=[ ,,,[16296417981,"JB"],]; CONWAYPOLDATA[45971]:=[ ,,,[18939316466,"JB"],]; CONWAYPOLDATA[45979]:=[ ,,,[16117616599,"JB"],]; CONWAYPOLDATA[45989]:=[ ,,,[20670261931,"JB"],]; CONWAYPOLDATA[46021]:=[ ,,,[7790158756,"JB"],]; CONWAYPOLDATA[46027]:=[ ,,,[18345855905,"JB"],]; CONWAYPOLDATA[46049]:=[ ,,,[18197551725,"JB"],]; CONWAYPOLDATA[46051]:=[ ,,,[7530121370,"JB"],]; CONWAYPOLDATA[46061]:=[ ,,,[16623000353,"JB"],]; CONWAYPOLDATA[46073]:=[ ,,,[5777277767,"JB"],]; CONWAYPOLDATA[46091]:=[ ,,,[42128095822,"JB"],]; CONWAYPOLDATA[46093]:=[ ,,,[14253799322,"JB"],]; CONWAYPOLDATA[46099]:=[ ,,,[18827154295,"JB"],]; CONWAYPOLDATA[46103]:=[ ,,,[25505009464,"JB"],]; CONWAYPOLDATA[46133]:=[ ,,,[7719388759,"JB"],]; CONWAYPOLDATA[46141]:=[ ,,,[20995400817,"JB"],]; CONWAYPOLDATA[46147]:=[ ,,,[5422872413,"JB"],]; CONWAYPOLDATA[46153]:=[ ,,,[27178763257,"JB"],]; CONWAYPOLDATA[46171]:=[ ,,,[7650119164,"JB"],]; CONWAYPOLDATA[46181]:=[ ,,,[27214601845,"JB"],]; CONWAYPOLDATA[46183]:=[ ,,,[10664162716,"JB"],]; CONWAYPOLDATA[46187]:=[ ,,,[5932027347,"JB"],]; CONWAYPOLDATA[46199]:=[ ,,,[8537020829,"JB"],]; CONWAYPOLDATA[46219]:=[ ,,,[6277141050,"JB"],]; CONWAYPOLDATA[46229]:=[ ,,,[6333095628,"JB"],]; CONWAYPOLDATA[46237]:=[ ,,,[27592345885,"JB"],]; CONWAYPOLDATA[46261]:=[ ,,,[7501406196,"JB"],]; CONWAYPOLDATA[46271]:=[ ,,,[10334211418,"JB"],]; CONWAYPOLDATA[46273]:=[ ,,,[14426579488,"JB"],]; CONWAYPOLDATA[46279]:=[ ,,,[8258996622,"JB"],]; CONWAYPOLDATA[46301]:=[ ,,,[3492715937,"JB"],]; CONWAYPOLDATA[46307]:=[ ,,,[29179429912,"JB"],]; CONWAYPOLDATA[46309]:=[ ,,,[26918958612,"JB"],]; CONWAYPOLDATA[46327]:=[ ,,,[5811490518,"JB"],]; CONWAYPOLDATA[46337]:=[ ,,,[2065471778,"JB"],]; CONWAYPOLDATA[46349]:=[ ,,,[38470828727,"JB"],]; CONWAYPOLDATA[46351]:=[ ,,,[8292796466,"JB"],]; CONWAYPOLDATA[46381]:=[ ,,,[12415497992,"JB"],]; CONWAYPOLDATA[46399]:=[ ,,,[10764150412,"JB"],]; CONWAYPOLDATA[46411]:=[ ,,,[16910961717,"JB"],]; CONWAYPOLDATA[46439]:=[ ,,,[12750663359,"JB"],]; CONWAYPOLDATA[46441]:=[ ,,,[40106076079,"JB"],]; CONWAYPOLDATA[46447]:=[ ,,,[10786433260,"JB"],]; CONWAYPOLDATA[46451]:=[ ,,,[12727063045,"JB"],]; CONWAYPOLDATA[46457]:=[ ,,,[2005734521,"JB"],]; CONWAYPOLDATA[46471]:=[ ,,,[8403490346,"JB"],]; CONWAYPOLDATA[46477]:=[ ,,,[22824018116,"JB"],]; CONWAYPOLDATA[46489]:=[ ,,,[45312084505,"JB"],]; CONWAYPOLDATA[46499]:=[ ,,,[16283252317,"JB"],]; CONWAYPOLDATA[46507]:=[ ,,,[3583689901,"JB"],]; CONWAYPOLDATA[46511]:=[ ,,,[15079470854,"JB"],]; CONWAYPOLDATA[46523]:=[ ,,,[12861004217,"JB"],]; CONWAYPOLDATA[46549]:=[ ,,,[14683928601,"JB"],]; CONWAYPOLDATA[46559]:=[ ,,,[5495032864,"JB"],]; CONWAYPOLDATA[46567]:=[ ,,,[14438843425,"JB"],]; CONWAYPOLDATA[46573]:=[ ,,,[14991289826,"JB"],]; CONWAYPOLDATA[46589]:=[ ,,,[10677919268,"JB"],]; CONWAYPOLDATA[46591]:=[ ,,,[3269383658,"JB"],]; CONWAYPOLDATA[46601]:=[ ,,,[3903998778,"JB"],]; CONWAYPOLDATA[46619]:=[ ,,,[21615924974,"JB"],]; CONWAYPOLDATA[46633]:=[ ,,,[23699916531,"JB"],]; CONWAYPOLDATA[46639]:=[ ,,,[8132442436,"JB"],]; CONWAYPOLDATA[46643]:=[ ,,,[10437024254,"JB"],]; CONWAYPOLDATA[46649]:=[ ,,,[9941088511,"JB"],]; CONWAYPOLDATA[46663]:=[ ,,,[6139964208,"JB"],]; CONWAYPOLDATA[46679]:=[ ,,,[19571291063,"JB"],]; CONWAYPOLDATA[46681]:=[ ,,,[32308013473,"JB"],]; CONWAYPOLDATA[46687]:=[ ,,,[10898193100,"JB"],]; CONWAYPOLDATA[46691]:=[ ,,,[19288425630,"JB"],]; CONWAYPOLDATA[46703]:=[ ,,,[20799134352,"JB"],]; CONWAYPOLDATA[46723]:=[ ,,,[6247145440,"JB"],]; CONWAYPOLDATA[46727]:=[ ,,,[26200389629,"JB"],]; CONWAYPOLDATA[46747]:=[ ,,,[18591655878,"JB"],]; CONWAYPOLDATA[46751]:=[ ,,,[8343370475,"JB"],]; CONWAYPOLDATA[46757]:=[ ,,,[14670102266,"JB"],]; CONWAYPOLDATA[46769]:=[ ,,,[2186778136,"JB"],]; CONWAYPOLDATA[46771]:=[ ,,,[19053149043,"JB"],]; CONWAYPOLDATA[46807]:=[ ,,,[12094928803,"JB"],]; CONWAYPOLDATA[46811]:=[ ,,,[1944014021,"JB"],]; CONWAYPOLDATA[46817]:=[ ,,,[26055299098,"JB"],]; CONWAYPOLDATA[46819]:=[ ,,,[12106503841,"JB"],]; CONWAYPOLDATA[46829]:=[ ,,,[7962194385,"JB"],]; CONWAYPOLDATA[46831]:=[ ,,,[7953496057,"JB"],]; CONWAYPOLDATA[46853]:=[ ,,,[12187121244,"JB"],]; CONWAYPOLDATA[46861]:=[ ,,,[49977771977,"JB"],]; CONWAYPOLDATA[46867]:=[ ,,,[18835472366,"JB"],]; CONWAYPOLDATA[46877]:=[ ,,,[3815412786,"JB"],]; CONWAYPOLDATA[46889]:=[ ,,,[5974971495,"JB"],]; CONWAYPOLDATA[46901]:=[ ,,,[1262762535,"JB"],]; CONWAYPOLDATA[46919]:=[ ,,,[12749440638,"JB"],]; CONWAYPOLDATA[46933]:=[ ,,,[8329715775,"JB"],]; CONWAYPOLDATA[46957]:=[ ,,,[8375954880,"JB"],]; CONWAYPOLDATA[46993]:=[ ,,,[34666783098,"JB"],]; CONWAYPOLDATA[46997]:=[ ,,,[10754699488,"JB"],]; CONWAYPOLDATA[47017]:=[ ,,,[28011647216,"JB"],]; CONWAYPOLDATA[47041]:=[ ,,,[36658298673,"JB"],]; CONWAYPOLDATA[47051]:=[ ,,,[8554154108,"JB"],]; CONWAYPOLDATA[47057]:=[ ,,,[17150770679,"JB"],]; CONWAYPOLDATA[47059]:=[ ,,,[5914469240,"JB"],]; CONWAYPOLDATA[47087]:=[ ,,,[8868553933,"JB"],]; CONWAYPOLDATA[47093]:=[ ,,,[15503816183,"JB"],]; CONWAYPOLDATA[47111]:=[ ,,,[31043322347,"JB"],]; CONWAYPOLDATA[47119]:=[ ,,,[8796457637,"JB"],]; CONWAYPOLDATA[47123]:=[ ,,,[45837908669,"JB"],]; CONWAYPOLDATA[47129]:=[ ,,,[1770495146,"JB"],]; CONWAYPOLDATA[47137]:=[ ,,,[53042464776,"JB"],]; CONWAYPOLDATA[47143]:=[ ,,,[10623769342,"JB"],]; CONWAYPOLDATA[47147]:=[ ,,,[19218955935,"JB"],]; CONWAYPOLDATA[47149]:=[ ,,,[2043060470,"JB"],]; CONWAYPOLDATA[47161]:=[ ,,,[50192461936,"JB"],]; CONWAYPOLDATA[47189]:=[ ,,,[2127940768,"JB"],]; CONWAYPOLDATA[47207]:=[ ,,,[10592165044,"JB"],]; CONWAYPOLDATA[47221]:=[ ,,,[6376204415,"JB"],]; CONWAYPOLDATA[47237]:=[ ,,,[15466716438,"JB"],]; CONWAYPOLDATA[47251]:=[ ,,,[1481602366,"JB"],]; CONWAYPOLDATA[47269]:=[ ,,,[1648931802,"JB"],]; CONWAYPOLDATA[47279]:=[ ,,,[10447855264,"JB"],]; CONWAYPOLDATA[47287]:=[ ,,,[12614894856,"JB"],]; CONWAYPOLDATA[47293]:=[ ,,,[61776102912,"JB"],]; CONWAYPOLDATA[47297]:=[ ,,,[3718632034,"JB"],]; CONWAYPOLDATA[47303]:=[ ,,,[10131451151,"JB"],]; CONWAYPOLDATA[47309]:=[ ,,,[3957681706,"JB"],]; CONWAYPOLDATA[47317]:=[ ,,,[10680582514,"JB"],]; CONWAYPOLDATA[47339]:=[ ,,,[20168496918,"JB"],]; CONWAYPOLDATA[47351]:=[ ,,,[7879585221,"JB"],]; CONWAYPOLDATA[47353]:=[ ,,,[24444849783,"JB"],]; CONWAYPOLDATA[47363]:=[ ,,,[17438961876,"JB"],]; CONWAYPOLDATA[47381]:=[ ,,,[21619050063,"JB"],]; CONWAYPOLDATA[47387]:=[ ,,,[20191885024,"JB"],]; CONWAYPOLDATA[47389]:=[ ,,,[21345853773,"JB"],]; CONWAYPOLDATA[47407]:=[ ,,,[19924640626,"JB"],]; CONWAYPOLDATA[47417]:=[ ,,,[17187050325,"JB"],]; CONWAYPOLDATA[47419]:=[ ,,,[19121711752,"JB"],]; CONWAYPOLDATA[47431]:=[ ,,,[1740385695,"JB"],]; CONWAYPOLDATA[47441]:=[ ,,,[2250079192,"JB"],]; CONWAYPOLDATA[47459]:=[ ,,,[14669102312,"JB"],]; CONWAYPOLDATA[47491]:=[ ,,,[6611981968,"JB"],]; CONWAYPOLDATA[47497]:=[ ,,,[41866800619,"JB"],]; CONWAYPOLDATA[47501]:=[ ,,,[11281535004,"JB"],]; CONWAYPOLDATA[47507]:=[ ,,,[37927878550,"JB"],]; CONWAYPOLDATA[47513]:=[ ,,,[1514761956,"JB"],]; CONWAYPOLDATA[47521]:=[ ,,,[46547627374,"JB"],]; CONWAYPOLDATA[47527]:=[ ,,,[12968977655,"JB"],]; CONWAYPOLDATA[47533]:=[ ,,,[8399556432,"JB"],]; CONWAYPOLDATA[47543]:=[ ,,,[7931265894,"JB"],]; CONWAYPOLDATA[47563]:=[ ,,,[5966397848,"JB"],]; CONWAYPOLDATA[47569]:=[ ,,,[33818942722,"JB"],]; CONWAYPOLDATA[47581]:=[ ,,,[28547458058,"JB"],]; CONWAYPOLDATA[47591]:=[ ,,,[7998904927,"JB"],]; CONWAYPOLDATA[47599]:=[ ,,,[6542196959,"JB"],]; CONWAYPOLDATA[47609]:=[ ,,,[17894461573,"JB"],]; CONWAYPOLDATA[47623]:=[ ,,,[11339560156,"JB"],]; CONWAYPOLDATA[47629]:=[ ,,,[31236050790,"JB"],]; CONWAYPOLDATA[47639]:=[ ,,,[5821009417,"JB"],]; CONWAYPOLDATA[47653]:=[ ,,,[8743277147,"JB"],]; CONWAYPOLDATA[47657]:=[ ,,,[21797549291,"JB"],]; CONWAYPOLDATA[47659]:=[ ,,,[17324952023,"JB"],]; CONWAYPOLDATA[47681]:=[ ,,,[10370045331,"JB"],]; CONWAYPOLDATA[47699]:=[ ,,,[8536499236,"JB"],]; CONWAYPOLDATA[47701]:=[ ,,,[17880624450,"JB"],]; CONWAYPOLDATA[47711]:=[ ,,,[8190642803,"JB"],]; CONWAYPOLDATA[47713]:=[ ,,,[24270457998,"JB"],]; CONWAYPOLDATA[47717]:=[ ,,,[8903658183,"JB"],]; CONWAYPOLDATA[47737]:=[ ,,,[54181065372,"JB"],]; CONWAYPOLDATA[47741]:=[ ,,,[26424929949,"JB"],]; CONWAYPOLDATA[47743]:=[ ,,,[11396779276,"JB"],]; CONWAYPOLDATA[47777]:=[ ,,,[6778648540,"JB"],]; CONWAYPOLDATA[47779]:=[ ,,,[6678166391,"JB"],]; CONWAYPOLDATA[47791]:=[ ,,,[3484871936,"JB"],]; CONWAYPOLDATA[47797]:=[ ,,,[15531969734,"JB"],]; CONWAYPOLDATA[47807]:=[ ,,,[8422302616,"JB"],]; CONWAYPOLDATA[47809]:=[ ,,,[38321017103,"JB"],]; CONWAYPOLDATA[47819]:=[ ,,,[1386942278,"JB"],]; CONWAYPOLDATA[47837]:=[ ,,,[3578016254,"JB"],]; CONWAYPOLDATA[47843]:=[ ,,,[6299152911,"JB"],]; CONWAYPOLDATA[47857]:=[ ,,,[19486365410,"JB"],]; CONWAYPOLDATA[47869]:=[ ,,,[8602346516,"JB"],]; CONWAYPOLDATA[47881]:=[ ,,,[43514731639,"JB"],]; CONWAYPOLDATA[47903]:=[ ,,,[6360081317,"JB"],]; CONWAYPOLDATA[47911]:=[ ,,,[9034289807,"JB"],]; CONWAYPOLDATA[47917]:=[ ,,,[15746436628,"JB"],]; CONWAYPOLDATA[47933]:=[ ,,,[16026494418,"JB"],]; CONWAYPOLDATA[47939]:=[ ,,,[6450240391,"JB"],]; CONWAYPOLDATA[47947]:=[ ,,,[31735927514,"JB"],]; CONWAYPOLDATA[47951]:=[ ,,,[13192327078,"JB"],]; CONWAYPOLDATA[47963]:=[ ,,,[10574786316,"JB"],]; CONWAYPOLDATA[47969]:=[ ,,,[2300449336,"JB"],]; CONWAYPOLDATA[47977]:=[ ,,,[29325413510,"JB"],]; CONWAYPOLDATA[47981]:=[ ,,,[33538239192,"JB"],]; CONWAYPOLDATA[48017]:=[ ,,,[11106236069,"JB"],]; CONWAYPOLDATA[48023]:=[ ,,,[29585817753,"JB"],]; CONWAYPOLDATA[48029]:=[ ,,,[1931822440,"JB"],]; CONWAYPOLDATA[48049]:=[ ,,,[47659082382,"JB"],]; CONWAYPOLDATA[48073]:=[ ,,,[15385379071,"JB"],]; CONWAYPOLDATA[48079]:=[ ,,,[10756185807,"JB"],]; CONWAYPOLDATA[48091]:=[ ,,,[15336075634,"JB"],]; CONWAYPOLDATA[48109]:=[ ,,,[27437861645,"JB"],]; CONWAYPOLDATA[48119]:=[ ,,,[11259124222,"JB"],]; CONWAYPOLDATA[48121]:=[ ,,,[19889516096,"JB"],]; CONWAYPOLDATA[48131]:=[ ,,,[13418441496,"JB"],]; CONWAYPOLDATA[48157]:=[ ,,,[4317130584,"JB"],]; CONWAYPOLDATA[48163]:=[ ,,,[8631772863,"JB"],]; CONWAYPOLDATA[48179]:=[ ,,,[23049700828,"JB"],]; CONWAYPOLDATA[48187]:=[ ,,,[6574296973,"JB"],]; CONWAYPOLDATA[48193]:=[ ,,,[29345777953,"JB"],]; CONWAYPOLDATA[48197]:=[ ,,,[17924175120,"JB"],]; CONWAYPOLDATA[48221]:=[ ,,,[11570291405,"JB"],]; CONWAYPOLDATA[48239]:=[ ,,,[20248416735,"JB"],]; CONWAYPOLDATA[48247]:=[ ,,,[15557824117,"JB"],]; CONWAYPOLDATA[48259]:=[ ,,,[20469151370,"JB"],]; CONWAYPOLDATA[48271]:=[ ,,,[6613513174,"JB"],]; CONWAYPOLDATA[48281]:=[ ,,,[11411504039,"JB"],]; CONWAYPOLDATA[48299]:=[ ,,,[18389651056,"JB"],]; CONWAYPOLDATA[48311]:=[ ,,,[11669328813,"JB"],]; CONWAYPOLDATA[48313]:=[ ,,,[16323996445,"JB"],]; CONWAYPOLDATA[48337]:=[ ,,,[25040692838,"JB"],]; CONWAYPOLDATA[48341]:=[ ,,,[8450635236,"JB"],]; CONWAYPOLDATA[48353]:=[ ,,,[17611951664,"JB"],]; CONWAYPOLDATA[48371]:=[ ,,,[8618744782,"JB"],]; CONWAYPOLDATA[48383]:=[ ,,,[9363465229,"JB"],]; CONWAYPOLDATA[48397]:=[ ,,,[25311872990,"JB"],]; CONWAYPOLDATA[48407]:=[ ,,,[5951398620,"JB"],]; CONWAYPOLDATA[48409]:=[ ,,,[67548514756,"JB"],]; CONWAYPOLDATA[48413]:=[ ,,,[16311453201,"JB"],]; CONWAYPOLDATA[48437]:=[ ,,,[38960736885,"JB"],]; CONWAYPOLDATA[48449]:=[ ,,,[6936346435,"JB"],]; CONWAYPOLDATA[48463]:=[ ,,,[13875683850,"JB"],]; CONWAYPOLDATA[48473]:=[ ,,,[11474819401,"JB"],]; CONWAYPOLDATA[48479]:=[ ,,,[6121443337,"JB"],]; CONWAYPOLDATA[48481]:=[ ,,,[41592043841,"JB"],]; CONWAYPOLDATA[48487]:=[ ,,,[21090535856,"JB"],]; CONWAYPOLDATA[48491]:=[ ,,,[18155903240,"JB"],]; CONWAYPOLDATA[48497]:=[ ,,,[2173247567,"JB"],]; CONWAYPOLDATA[48523]:=[ ,,,[13742247356,"JB"],]; CONWAYPOLDATA[48527]:=[ ,,,[20492515362,"JB"],]; CONWAYPOLDATA[48533]:=[ ,,,[22725431653,"JB"],]; CONWAYPOLDATA[48539]:=[ ,,,[20924628973,"JB"],]; CONWAYPOLDATA[48541]:=[ ,,,[18333159046,"JB"],]; CONWAYPOLDATA[48563]:=[ ,,,[2322865418,"JB"],]; CONWAYPOLDATA[48571]:=[ ,,,[18271681637,"JB"],]; CONWAYPOLDATA[48589]:=[ ,,,[9252268801,"JB"],]; CONWAYPOLDATA[48593]:=[ ,,,[42367119064,"JB"],]; CONWAYPOLDATA[48611]:=[ ,,,[29954584312,"JB"],]; CONWAYPOLDATA[48619]:=[ ,,,[8360912194,"JB"],]; CONWAYPOLDATA[48623]:=[ ,,,[9419636549,"JB"],]; CONWAYPOLDATA[48647]:=[ ,,,[16439669891,"JB"],]; CONWAYPOLDATA[48649]:=[ ,,,[6544993222,"JB"],]; CONWAYPOLDATA[48661]:=[ ,,,[15989274687,"JB"],]; CONWAYPOLDATA[48673]:=[ ,,,[1512221452,"JB"],]; CONWAYPOLDATA[48677]:=[ ,,,[11427996646,"JB"],]; CONWAYPOLDATA[48679]:=[ ,,,[16319440037,"JB"],]; CONWAYPOLDATA[48731]:=[ ,,,[11007796865,"JB"],]; CONWAYPOLDATA[48733]:=[ ,,,[16133693181,"JB"],]; CONWAYPOLDATA[48751]:=[ ,,,[11883105004,"JB"],]; CONWAYPOLDATA[48757]:=[ ,,,[30725003664,"JB"],]; CONWAYPOLDATA[48761]:=[ ,,,[6230436778,"JB"],]; CONWAYPOLDATA[48767]:=[ ,,,[18506930204,"JB"],]; CONWAYPOLDATA[48779]:=[ ,,,[18697868724,"JB"],]; CONWAYPOLDATA[48781]:=[ ,,,[18790294863,"JB"],]; CONWAYPOLDATA[48787]:=[ ,,,[20695542976,"JB"],]; CONWAYPOLDATA[48799]:=[ ,,,[16133534991,"JB"],]; CONWAYPOLDATA[48809]:=[ ,,,[2381732776,"JB"],]; CONWAYPOLDATA[48817]:=[ ,,,[40328065424,"JB"],]; CONWAYPOLDATA[48821]:=[ ,,,[11382420868,"JB"],]; CONWAYPOLDATA[48823]:=[ ,,,[6879209528,"JB"],]; CONWAYPOLDATA[48847]:=[ ,,,[13355649049,"JB"],]; CONWAYPOLDATA[48857]:=[ ,,,[23089231919,"JB"],]; CONWAYPOLDATA[48859]:=[ ,,,[4561671678,"JB"],]; CONWAYPOLDATA[48869]:=[ ,,,[21192090721,"JB"],]; CONWAYPOLDATA[48871]:=[ ,,,[15538729937,"JB"],]; CONWAYPOLDATA[48883]:=[ ,,,[20991337862,"JB"],]; CONWAYPOLDATA[48889]:=[ ,,,[83552181036,"JB"],]; CONWAYPOLDATA[48907]:=[ ,,,[18999635897,"JB"],]; CONWAYPOLDATA[48947]:=[ ,,,[21561936654,"JB"],]; CONWAYPOLDATA[48953]:=[ ,,,[6767752253,"JB"],]; CONWAYPOLDATA[48973]:=[ ,,,[16641074378,"JB"],]; CONWAYPOLDATA[48989]:=[ ,,,[9098677983,"JB"],]; CONWAYPOLDATA[48991]:=[ ,,,[9097089805,"JB"],]; CONWAYPOLDATA[49003]:=[ ,,,[11601460263,"JB"],]; CONWAYPOLDATA[49009]:=[ ,,,[78085941701,"JB"],]; CONWAYPOLDATA[49019]:=[ ,,,[23853625782,"JB"],]; CONWAYPOLDATA[49031]:=[ ,,,[33514159443,"JB"],]; CONWAYPOLDATA[49033]:=[ ,,,[21226385710,"JB"],]; CONWAYPOLDATA[49037]:=[ ,,,[45479610837,"JB"],]; CONWAYPOLDATA[49043]:=[ ,,,[21359795878,"JB"],]; CONWAYPOLDATA[49057]:=[ ,,,[16367917112,"JB"],]; CONWAYPOLDATA[49069]:=[ ,,,[18426734365,"JB"],]; CONWAYPOLDATA[49081]:=[ ,,,[30606911611,"JB"],]; CONWAYPOLDATA[49103]:=[ ,,,[28349126025,"JB"],]; CONWAYPOLDATA[49109]:=[ ,,,[18533933038,"JB"],]; CONWAYPOLDATA[49117]:=[ ,,,[22961067811,"JB"],]; CONWAYPOLDATA[49121]:=[ ,,,[11799699260,"JB"],]; CONWAYPOLDATA[49123]:=[ ,,,[42855543801,"JB"],]; CONWAYPOLDATA[49139]:=[ ,,,[11544372689,"JB"],]; CONWAYPOLDATA[49157]:=[ ,,,[30707689704,"JB"],]; CONWAYPOLDATA[49169]:=[ ,,,[11406027947,"JB"],]; CONWAYPOLDATA[49171]:=[ ,,,[6494259827,"JB"],]; CONWAYPOLDATA[49177]:=[ ,,,[41042583258,"JB"],]; CONWAYPOLDATA[49193]:=[ ,,,[4708065261,"JB"],]; CONWAYPOLDATA[49199]:=[ ,,,[11931200304,"JB"],]; CONWAYPOLDATA[49201]:=[ ,,,[59724700299,"JB"],]; CONWAYPOLDATA[49207]:=[ ,,,[16785934706,"JB"],]; CONWAYPOLDATA[49211]:=[ ,,,[18539309243,"JB"],]; CONWAYPOLDATA[49223]:=[ ,,,[6746110601,"JB"],]; CONWAYPOLDATA[49253]:=[ ,,,[31269301365,"JB"],]; CONWAYPOLDATA[49261]:=[ ,,,[16849528008,"JB"],]; CONWAYPOLDATA[49277]:=[ ,,,[15885623600,"JB"],]; CONWAYPOLDATA[49279]:=[ ,,,[23975366920,"JB"],]; CONWAYPOLDATA[49297]:=[ ,,,[26082106062,"JB"],]; CONWAYPOLDATA[49307]:=[ ,,,[2239326714,"JB"],]; CONWAYPOLDATA[49331]:=[ ,,,[21436687390,"JB"],]; CONWAYPOLDATA[49333]:=[ ,,,[30608166522,"JB"],]; CONWAYPOLDATA[49339]:=[ ,,,[16745064543,"JB"],]; CONWAYPOLDATA[49363]:=[ ,,,[7091044315,"JB"],]; CONWAYPOLDATA[49367]:=[ ,,,[21426018510,"JB"],]; CONWAYPOLDATA[49369]:=[ ,,,[26592266280,"JB"],]; CONWAYPOLDATA[49391]:=[ ,,,[6287128574,"JB"],]; CONWAYPOLDATA[49393]:=[ ,,,[28087724599,"JB"],]; CONWAYPOLDATA[49409]:=[ ,,,[2440656376,"JB"],]; CONWAYPOLDATA[49411]:=[ ,,,[26556732528,"JB"],]; CONWAYPOLDATA[49417]:=[ ,,,[38541010143,"JB"],]; CONWAYPOLDATA[49429]:=[ ,,,[16032147865,"JB"],]; CONWAYPOLDATA[49433]:=[ ,,,[33058615351,"JB"],]; CONWAYPOLDATA[49451]:=[ ,,,[20949668905,"JB"],]; CONWAYPOLDATA[49459]:=[ ,,,[1501525784,"JB"],]; CONWAYPOLDATA[49463]:=[ ,,,[21178622178,"JB"],]; CONWAYPOLDATA[49477]:=[ ,,,[9023169978,"JB"],]; CONWAYPOLDATA[49481]:=[ ,,,[2447775592,"JB"],]; CONWAYPOLDATA[49499]:=[ ,,,[18506785120,"JB"],]; CONWAYPOLDATA[49523]:=[ ,,,[7089663159,"JB"],]; CONWAYPOLDATA[49529]:=[ ,,,[19392188431,"JB"],]; CONWAYPOLDATA[49531]:=[ ,,,[29438947984,"JB"],]; CONWAYPOLDATA[49537]:=[ ,,,[40837064385,"JB"],]; CONWAYPOLDATA[49547]:=[ ,,,[18527852917,"JB"],]; CONWAYPOLDATA[49549]:=[ ,,,[19576512612,"JB"],]; CONWAYPOLDATA[49559]:=[ ,,,[23782372931,"JB"],]; CONWAYPOLDATA[49597]:=[ ,,,[29072819062,"JB"],]; CONWAYPOLDATA[49603]:=[ ,,,[8860782305,"JB"],]; CONWAYPOLDATA[49613]:=[ ,,,[17167636005,"JB"],]; CONWAYPOLDATA[49627]:=[ ,,,[13845287852,"JB"],]; CONWAYPOLDATA[49633]:=[ ,,,[26007344574,"JB"],]; CONWAYPOLDATA[49639]:=[ ,,,[16374863684,"JB"],]; CONWAYPOLDATA[49663]:=[ ,,,[12331869196,"JB"],]; CONWAYPOLDATA[49667]:=[ ,,,[21473527452,"JB"],]; CONWAYPOLDATA[49669]:=[ ,,,[16804016082,"JB"],]; CONWAYPOLDATA[49681]:=[ ,,,[35866651476,"JB"],]; CONWAYPOLDATA[49697]:=[ ,,,[1636074940,"JB"],]; CONWAYPOLDATA[49711]:=[ ,,,[26110603335,"JB"],]; CONWAYPOLDATA[49727]:=[ ,,,[9890899213,"JB"],]; CONWAYPOLDATA[49739]:=[ ,,,[4665120290,"JB"],]; CONWAYPOLDATA[49741]:=[ ,,,[9820614337,"JB"],]; CONWAYPOLDATA[49747]:=[ ,,,[14090340283,"JB"],]; CONWAYPOLDATA[49757]:=[ ,,,[18794363313,"JB"],]; CONWAYPOLDATA[49783]:=[ ,,,[14394654887,"JB"],]; CONWAYPOLDATA[49787]:=[ ,,,[34492831898,"JB"],]; CONWAYPOLDATA[49789]:=[ ,,,[28551253111,"JB"],]; CONWAYPOLDATA[49801]:=[ ,,,[26369131503,"JB"],]; CONWAYPOLDATA[49807]:=[ ,,,[36330321557,"JB"],]; CONWAYPOLDATA[49811]:=[ ,,,[14127595070,"JB"],]; CONWAYPOLDATA[49823]:=[ ,,,[21259723220,"JB"],]; CONWAYPOLDATA[49831]:=[ ,,,[8878987254,"JB"],]; CONWAYPOLDATA[49843]:=[ ,,,[18708520209,"JB"],]; CONWAYPOLDATA[49853]:=[ ,,,[11298683922,"JB"],]; CONWAYPOLDATA[49871]:=[ ,,,[9948067613,"JB"],]; CONWAYPOLDATA[49877]:=[ ,,,[19273570096,"JB"],]; CONWAYPOLDATA[49891]:=[ ,,,[21843926205,"JB"],]; CONWAYPOLDATA[49919]:=[ ,,,[9407185638,"JB"],]; CONWAYPOLDATA[49921]:=[ ,,,[59808652809,"JB"],]; CONWAYPOLDATA[49927]:=[ ,,,[27419359206,"JB"],]; CONWAYPOLDATA[49937]:=[ ,,,[4479448777,"JB"],]; CONWAYPOLDATA[49939]:=[ ,,,[17212824710,"JB"],]; CONWAYPOLDATA[49943]:=[ ,,,[9977013229,"JB"],]; CONWAYPOLDATA[49957]:=[ ,,,[24407841194,"JB"],]; CONWAYPOLDATA[49991]:=[ ,,,[6724689345,"JB"],]; CONWAYPOLDATA[49993]:=[ ,,,[46790248453,"JB"],]; CONWAYPOLDATA[49999]:=[ ,,,[34347563038,"JB"],]; CONWAYPOLDATA[50021]:=[ ,,,[22518553824,"JB"],]; CONWAYPOLDATA[50023]:=[ ,,,[14498666323,"JB"],]; CONWAYPOLDATA[50033]:=[ ,,,[11803585233,"JB"],]; CONWAYPOLDATA[50047]:=[ ,,,[27007012757,"JB"],]; CONWAYPOLDATA[50051]:=[ ,,,[8909828767,"JB"],]; CONWAYPOLDATA[50053]:=[ ,,,[16900695770,"JB"],]; CONWAYPOLDATA[50069]:=[ ,,,[9246742922,"JB"],]; CONWAYPOLDATA[50077]:=[ ,,,[17319681299,"JB"],]; CONWAYPOLDATA[50087]:=[ ,,,[9529903234,"JB"],]; CONWAYPOLDATA[50093]:=[ ,,,[21734951958,"JB"],]; CONWAYPOLDATA[50101]:=[ ,,,[32591001108,"JB"],]; CONWAYPOLDATA[50111]:=[ ,,,[10044048413,"JB"],]; CONWAYPOLDATA[50119]:=[ ,,,[12559370332,"JB"],]; CONWAYPOLDATA[50123]:=[ ,,,[26618871735,"JB"],]; CONWAYPOLDATA[50129]:=[ ,,,[12242404125,"JB"],]; CONWAYPOLDATA[50131]:=[ ,,,[21714794093,"JB"],]; CONWAYPOLDATA[50147]:=[ ,,,[26642198456,"JB"],]; CONWAYPOLDATA[50153]:=[ ,,,[24643830072,"JB"],]; CONWAYPOLDATA[50159]:=[ ,,,[7307363763,"JB"],]; CONWAYPOLDATA[50177]:=[ ,,,[16426043077,"JB"],]; CONWAYPOLDATA[50207]:=[ ,,,[42206765590,"JB"],]; CONWAYPOLDATA[50221]:=[ ,,,[19916141983,"JB"],]; CONWAYPOLDATA[50227]:=[ ,,,[22041867817,"JB"],]; CONWAYPOLDATA[50231]:=[ ,,,[21582251471,"JB"],]; CONWAYPOLDATA[50261]:=[ ,,,[27787447246,"JB"],]; CONWAYPOLDATA[50263]:=[ ,,,[10028222448,"JB"],]; CONWAYPOLDATA[50273]:=[ ,,,[4591634185,"JB"],]; CONWAYPOLDATA[50287]:=[ ,,,[14922818114,"JB"],]; CONWAYPOLDATA[50291]:=[ ,,,[7268960560,"JB"],]; CONWAYPOLDATA[50311]:=[ ,,,[6361373154,"JB"],]; CONWAYPOLDATA[50321]:=[ ,,,[7571347987,"JB"],]; CONWAYPOLDATA[50329]:=[ ,,,[2410356475,"JB"],]; CONWAYPOLDATA[50333]:=[ ,,,[9209680677,"JB"],]; CONWAYPOLDATA[50341]:=[ ,,,[32558796867,"JB"],]; CONWAYPOLDATA[50359]:=[ ,,,[12679942972,"JB"],]; CONWAYPOLDATA[50363]:=[ ,,,[6817891127,"JB"],]; CONWAYPOLDATA[50377]:=[ ,,,[17487468769,"JB"],]; CONWAYPOLDATA[50383]:=[ ,,,[9228654113,"JB"],]; CONWAYPOLDATA[50387]:=[ ,,,[11672299713,"JB"],]; CONWAYPOLDATA[50411]:=[ ,,,[10137349636,"JB"],]; CONWAYPOLDATA[50417]:=[ ,,,[25252362793,"JB"],]; CONWAYPOLDATA[50423]:=[ ,,,[22219096647,"JB"],]; CONWAYPOLDATA[50441]:=[ ,,,[8937590355,"JB"],]; CONWAYPOLDATA[50459]:=[ ,,,[12330615373,"JB"],]; CONWAYPOLDATA[50461]:=[ ,,,[40288011946,"JB"],]; CONWAYPOLDATA[50497]:=[ ,,,[17138984787,"JB"],]; CONWAYPOLDATA[50503]:=[ ,,,[27244297882,"JB"],]; CONWAYPOLDATA[50513]:=[ ,,,[1536959054,"JB"],]; CONWAYPOLDATA[50527]:=[ ,,,[28082350806,"JB"],]; CONWAYPOLDATA[50539]:=[ ,,,[4494433272,"JB"],]; CONWAYPOLDATA[50543]:=[ ,,,[6903314574,"JB"],]; CONWAYPOLDATA[50549]:=[ ,,,[1381301976,"JB"],]; CONWAYPOLDATA[50551]:=[ ,,,[10205539189,"JB"],]; CONWAYPOLDATA[50581]:=[ ,,,[25023836970,"JB"],]; CONWAYPOLDATA[50587]:=[ ,,,[7222306004,"JB"],]; CONWAYPOLDATA[50591]:=[ ,,,[14521741829,"JB"],]; CONWAYPOLDATA[50593]:=[ ,,,[29494302401,"JB"],]; CONWAYPOLDATA[50599]:=[ ,,,[9755335406,"JB"],]; CONWAYPOLDATA[50627]:=[ ,,,[42324728899,"JB"],]; CONWAYPOLDATA[50647]:=[ ,,,[9040084327,"JB"],]; CONWAYPOLDATA[50651]:=[ ,,,[7255958356,"JB"],]; CONWAYPOLDATA[50671]:=[ ,,,[9065244595,"JB"],]; CONWAYPOLDATA[50683]:=[ ,,,[23118543622,"JB"],]; CONWAYPOLDATA[50707]:=[ ,,,[7433443375,"JB"],]; CONWAYPOLDATA[50723]:=[ ,,,[17925812540,"JB"],]; CONWAYPOLDATA[50741]:=[ ,,,[11745222236,"JB"],]; CONWAYPOLDATA[50753]:=[ ,,,[20049718888,"JB"],]; CONWAYPOLDATA[50767]:=[ ,,,[32894629956,"JB"],]; CONWAYPOLDATA[50773]:=[ ,,,[9112179548,"JB"],]; CONWAYPOLDATA[50777]:=[ ,,,[32817835204,"JB"],]; CONWAYPOLDATA[50789]:=[ ,,,[17511437734,"JB"],]; CONWAYPOLDATA[50821]:=[ ,,,[27933711831,"JB"],]; CONWAYPOLDATA[50833]:=[ ,,,[32579073039,"JB"],]; CONWAYPOLDATA[50839]:=[ ,,,[6727575712,"JB"],]; CONWAYPOLDATA[50849]:=[ ,,,[7622163405,"JB"],]; CONWAYPOLDATA[50857]:=[ ,,,[24955682490,"JB"],]; CONWAYPOLDATA[50867]:=[ ,,,[7256787956,"JB"],]; CONWAYPOLDATA[50873]:=[ ,,,[4093750313,"JB"],]; CONWAYPOLDATA[50891]:=[ ,,,[12759086176,"JB"],]; CONWAYPOLDATA[50893]:=[ ,,,[9966834229,"JB"],]; CONWAYPOLDATA[50909]:=[ ,,,[23325180168,"JB"],]; CONWAYPOLDATA[50923]:=[ ,,,[19779053355,"JB"],]; CONWAYPOLDATA[50929]:=[ ,,,[54056702688,"JB"],]; CONWAYPOLDATA[50951]:=[ ,,,[36036317597,"JB"],]; CONWAYPOLDATA[50957]:=[ ,,,[33415358494,"JB"],]; CONWAYPOLDATA[50969]:=[ ,,,[2597227336,"JB"],]; CONWAYPOLDATA[50971]:=[ ,,,[23362455910,"JB"],]; CONWAYPOLDATA[50989]:=[ ,,,[17728773324,"JB"],]; CONWAYPOLDATA[50993]:=[ ,,,[11895086120,"JB"],]; CONWAYPOLDATA[51001]:=[ ,,,[1576797924,"JB"],]; CONWAYPOLDATA[51031]:=[ ,,,[6729968283,"JB"],]; CONWAYPOLDATA[51043]:=[ ,,,[6755847310,"JB"],]; CONWAYPOLDATA[51047]:=[ ,,,[7407021799,"JB"],]; CONWAYPOLDATA[51059]:=[ ,,,[20463221786,"JB"],]; CONWAYPOLDATA[51061]:=[ ,,,[10009385710,"JB"],]; CONWAYPOLDATA[51071]:=[ ,,,[12128290020,"JB"],]; CONWAYPOLDATA[51109]:=[ ,,,[38593581417,"JB"],]; CONWAYPOLDATA[51131]:=[ ,,,[14665751343,"JB"],]; CONWAYPOLDATA[51133]:=[ ,,,[17568071610,"JB"],]; CONWAYPOLDATA[51137]:=[ ,,,[7067184540,"JB"],]; CONWAYPOLDATA[51151]:=[ ,,,[9713472601,"JB"],]; CONWAYPOLDATA[51157]:=[ ,,,[5034002276,"JB"],]; CONWAYPOLDATA[51169]:=[ ,,,[28386821468,"JB"],]; CONWAYPOLDATA[51193]:=[ ,,,[86273771150,"JB"],]; CONWAYPOLDATA[51197]:=[ ,,,[9448406352,"JB"],]; CONWAYPOLDATA[51199]:=[ ,,,[9579947300,"JB"],]; CONWAYPOLDATA[51203]:=[ ,,,[20941207754,"JB"],]; CONWAYPOLDATA[51217]:=[ ,,,[17729840112,"JB"],]; CONWAYPOLDATA[51229]:=[ ,,,[9730436262,"JB"],]; CONWAYPOLDATA[51239]:=[ ,,,[36046021655,"JB"],]; CONWAYPOLDATA[51241]:=[ ,,,[49380234343,"JB"],]; CONWAYPOLDATA[51257]:=[ ,,,[12078917081,"JB"],]; CONWAYPOLDATA[51263]:=[ ,,,[14917071638,"JB"],]; CONWAYPOLDATA[51283]:=[ ,,,[23434074550,"JB"],]; CONWAYPOLDATA[51287]:=[ ,,,[10521220333,"JB"],]; CONWAYPOLDATA[51307]:=[ ,,,[10529427773,"JB"],]; CONWAYPOLDATA[51329]:=[ ,,,[6723893687,"JB"],]; CONWAYPOLDATA[51341]:=[ ,,,[23722725144,"JB"],]; CONWAYPOLDATA[51343]:=[ ,,,[31632627677,"JB"],]; CONWAYPOLDATA[51347]:=[ ,,,[23037242328,"JB"],]; CONWAYPOLDATA[51349]:=[ ,,,[25248097914,"JB"],]; CONWAYPOLDATA[51361]:=[ ,,,[86310927873,"JB"],]; CONWAYPOLDATA[51383]:=[ ,,,[10560645229,"JB"],]; CONWAYPOLDATA[51407]:=[ ,,,[7891180133,"JB"],]; CONWAYPOLDATA[51413]:=[ ,,,[10355092332,"JB"],]; CONWAYPOLDATA[51419]:=[ ,,,[21023583694,"JB"],]; CONWAYPOLDATA[51421]:=[ ,,,[10327753589,"JB"],]; CONWAYPOLDATA[51427]:=[ ,,,[86349378611,"JB"],]; CONWAYPOLDATA[51431]:=[ ,,,[10381964529,"JB"],]; CONWAYPOLDATA[51437]:=[ ,,,[47575675849,"JB"],]; CONWAYPOLDATA[51439]:=[ ,,,[20073915436,"JB"],]; CONWAYPOLDATA[51449]:=[ ,,,[6870293667,"JB"],]; CONWAYPOLDATA[51461]:=[ ,,,[20473861774,"JB"],]; CONWAYPOLDATA[51473]:=[ ,,,[44232498985,"JB"],]; CONWAYPOLDATA[51479]:=[ ,,,[33259140495,"JB"],]; CONWAYPOLDATA[51481]:=[ ,,,[46923541530,"JB"],]; CONWAYPOLDATA[51487]:=[ ,,,[15264402380,"JB"],]; CONWAYPOLDATA[51503]:=[ ,,,[9371228370,"JB"],]; CONWAYPOLDATA[51511]:=[ ,,,[9741399749,"JB"],]; CONWAYPOLDATA[51517]:=[ ,,,[18256079296,"JB"],]; CONWAYPOLDATA[51521]:=[ ,,,[12946299925,"JB"],]; CONWAYPOLDATA[51539]:=[ ,,,[7480318923,"JB"],]; CONWAYPOLDATA[51551]:=[ ,,,[20473221906,"JB"],]; CONWAYPOLDATA[51563]:=[ ,,,[22972296199,"JB"],]; CONWAYPOLDATA[51577]:=[ ,,,[18389985668,"JB"],]; CONWAYPOLDATA[51581]:=[ ,,,[4944864148,"JB"],]; CONWAYPOLDATA[51593]:=[ ,,,[6747796880,"JB"],]; CONWAYPOLDATA[51599]:=[ ,,,[7598984737,"JB"],]; CONWAYPOLDATA[51607]:=[ ,,,[23008774525,"JB"],]; CONWAYPOLDATA[51613]:=[ ,,,[27997833143,"JB"],]; CONWAYPOLDATA[51631]:=[ ,,,[10050283951,"JB"],]; CONWAYPOLDATA[51637]:=[ ,,,[53272550343,"JB"],]; CONWAYPOLDATA[51647]:=[ ,,,[17593653851,"JB"],]; CONWAYPOLDATA[51659]:=[ ,,,[1823924315,"JB"],]; CONWAYPOLDATA[51673]:=[ ,,,[28731273140,"JB"],]; CONWAYPOLDATA[51679]:=[ ,,,[9588211592,"JB"],]; CONWAYPOLDATA[51683]:=[ ,,,[20838895700,"JB"],]; CONWAYPOLDATA[51691]:=[ ,,,[1789128902,"JB"],]; CONWAYPOLDATA[51713]:=[ ,,,[4881914055,"JB"],]; CONWAYPOLDATA[51719]:=[ ,,,[20565905206,"JB"],]; CONWAYPOLDATA[51721]:=[ ,,,[71983322409,"JB"],]; CONWAYPOLDATA[51749]:=[ ,,,[4425626231,"JB"],]; CONWAYPOLDATA[51767]:=[ ,,,[18148785467,"JB"],]; CONWAYPOLDATA[51769]:=[ ,,,[71165653632,"JB"],]; CONWAYPOLDATA[51787]:=[ ,,,[15548736031,"JB"],]; CONWAYPOLDATA[51797]:=[ ,,,[20580243028,"JB"],]; CONWAYPOLDATA[51803]:=[ ,,,[12861597039,"JB"],]; CONWAYPOLDATA[51817]:=[ ,,,[1504765690,"JB"],]; CONWAYPOLDATA[51827]:=[ ,,,[20575370829,"JB"],]; CONWAYPOLDATA[51829]:=[ ,,,[34894807174,"JB"],]; CONWAYPOLDATA[51839]:=[ ,,,[6820249881,"JB"],]; CONWAYPOLDATA[51853]:=[ ,,,[15810550094,"JB"],]; CONWAYPOLDATA[51859]:=[ ,,,[2167187613,"JB"],]; CONWAYPOLDATA[51869]:=[ ,,,[13073944535,"JB"],]; CONWAYPOLDATA[51871]:=[ ,,,[1815744362,"JB"],]; CONWAYPOLDATA[51893]:=[ ,,,[7020863437,"JB"],]; CONWAYPOLDATA[51899]:=[ ,,,[21105662534,"JB"],]; CONWAYPOLDATA[51907]:=[ ,,,[10303124255,"JB"],]; CONWAYPOLDATA[51913]:=[ ,,,[28764733745,"JB"],]; CONWAYPOLDATA[51929]:=[ ,,,[7735447701,"JB"],]; CONWAYPOLDATA[51941]:=[ ,,,[7120176165,"JB"],]; CONWAYPOLDATA[51949]:=[ ,,,[18295918312,"JB"],]; CONWAYPOLDATA[51971]:=[ ,,,[7432840451,"JB"],]; CONWAYPOLDATA[51973]:=[ ,,,[18865627299,"JB"],]; CONWAYPOLDATA[51977]:=[ ,,,[20654412355,"JB"],]; CONWAYPOLDATA[51991]:=[ ,,,[28872785929,"JB"],]; CONWAYPOLDATA[52009]:=[ ,,,[56421703622,"JB"],]; CONWAYPOLDATA[52021]:=[ ,,,[34510471297,"JB"],]; CONWAYPOLDATA[52027]:=[ ,,,[7240181376,"JB"],]; CONWAYPOLDATA[52051]:=[ ,,,[4830697159,"JB"],]; CONWAYPOLDATA[52057]:=[ ,,,[48620300981,"JB"],]; CONWAYPOLDATA[52067]:=[ ,,,[45612045744,"JB"],]; CONWAYPOLDATA[52069]:=[ ,,,[10311380279,"JB"],]; CONWAYPOLDATA[52081]:=[ ,,,[56424607498,"JB"],]; CONWAYPOLDATA[52103]:=[ ,,,[10858682029,"JB"],]; CONWAYPOLDATA[52121]:=[ ,,,[2715973192,"JB"],]; CONWAYPOLDATA[52127]:=[ ,,,[10712359140,"JB"],]; CONWAYPOLDATA[52147]:=[ ,,,[24064901856,"JB"],]; CONWAYPOLDATA[52153]:=[ ,,,[29321876889,"JB"],]; CONWAYPOLDATA[52163]:=[ ,,,[31966321010,"JB"],]; CONWAYPOLDATA[52177]:=[ ,,,[17801957573,"JB"],]; CONWAYPOLDATA[52181]:=[ ,,,[9663399393,"JB"],]; CONWAYPOLDATA[52183]:=[ ,,,[7772762219,"JB"],]; CONWAYPOLDATA[52189]:=[ ,,,[64746456248,"JB"],]; CONWAYPOLDATA[52201]:=[ ,,,[40587425939,"JB"],]; CONWAYPOLDATA[52223]:=[ ,,,[26336058905,"JB"],]; CONWAYPOLDATA[52237]:=[ ,,,[2551620745,"JB"],]; CONWAYPOLDATA[52249]:=[ ,,,[2727920303,"JB"],]; CONWAYPOLDATA[52253]:=[ ,,,[18814737712,"JB"],]; CONWAYPOLDATA[52259]:=[ ,,,[10453367772,"JB"],]; CONWAYPOLDATA[52267]:=[ ,,,[24586187734,"JB"],]; CONWAYPOLDATA[52289]:=[ ,,,[21404659020,"JB"],]; CONWAYPOLDATA[52291]:=[ ,,,[18603150749,"JB"],]; CONWAYPOLDATA[52301]:=[ ,,,[27322303907,"JB"],]; CONWAYPOLDATA[52313]:=[ ,,,[31680177360,"JB"],]; CONWAYPOLDATA[52321]:=[ ,,,[51766397417,"JB"],]; CONWAYPOLDATA[52361]:=[ ,,,[1491398369,"JB"],]; CONWAYPOLDATA[52363]:=[ ,,,[57578564257,"JB"],]; CONWAYPOLDATA[52369]:=[ ,,,[95878107855,"JB"],]; CONWAYPOLDATA[52379]:=[ ,,,[8096117274,"JB"],]; CONWAYPOLDATA[52387]:=[ ,,,[7887543883,"JB"],]; CONWAYPOLDATA[52391]:=[ ,,,[15828264149,"JB"],]; CONWAYPOLDATA[52433]:=[ ,,,[12668809030,"JB"],]; CONWAYPOLDATA[52453]:=[ ,,,[30240465827,"JB"],]; CONWAYPOLDATA[52457]:=[ ,,,[5361315231,"JB"],]; CONWAYPOLDATA[52489]:=[ ,,,[2083603351,"JB"],]; CONWAYPOLDATA[52501]:=[ ,,,[42778969832,"JB"],]; CONWAYPOLDATA[52511]:=[ ,,,[9774660102,"JB"],]; CONWAYPOLDATA[52517]:=[ ,,,[4462947179,"JB"],]; CONWAYPOLDATA[52529]:=[ ,,,[2758665496,"JB"],]; CONWAYPOLDATA[52541]:=[ ,,,[13440880999,"JB"],]; CONWAYPOLDATA[52543]:=[ ,,,[7101554254,"JB"],]; CONWAYPOLDATA[52553]:=[ ,,,[30238470673,"JB"],]; CONWAYPOLDATA[52561]:=[ ,,,[2643975990,"JB"],]; CONWAYPOLDATA[52567]:=[ ,,,[13816237180,"JB"],]; CONWAYPOLDATA[52571]:=[ ,,,[10520929090,"JB"],]; CONWAYPOLDATA[52579]:=[ ,,,[13651401246,"JB"],]; CONWAYPOLDATA[52583]:=[ ,,,[7864366068,"JB"],]; CONWAYPOLDATA[52609]:=[ ,,,[34722466101,"JB"],]; CONWAYPOLDATA[52627]:=[ ,,,[8274648467,"JB"],]; CONWAYPOLDATA[52631]:=[ ,,,[7723125584,"JB"],]; CONWAYPOLDATA[52639]:=[ ,,,[13854111052,"JB"],]; CONWAYPOLDATA[52667]:=[ ,,,[40564439404,"JB"],]; CONWAYPOLDATA[52673]:=[ ,,,[8209929821,"JB"],]; CONWAYPOLDATA[52691]:=[ ,,,[21081616411,"JB"],]; CONWAYPOLDATA[52697]:=[ ,,,[12731964082,"JB"],]; CONWAYPOLDATA[52709]:=[ ,,,[10738404572,"JB"],]; CONWAYPOLDATA[52711]:=[ ,,,[9802770115,"JB"],]; CONWAYPOLDATA[52721]:=[ ,,,[7077583369,"JB"],]; CONWAYPOLDATA[52727]:=[ ,,,[26501697472,"JB"],]; CONWAYPOLDATA[52733]:=[ ,,,[27018068950,"JB"],]; CONWAYPOLDATA[52747]:=[ ,,,[15517956415,"JB"],]; CONWAYPOLDATA[52757]:=[ ,,,[4617081614,"JB"],]; CONWAYPOLDATA[52769]:=[ ,,,[8276078887,"JB"],]; CONWAYPOLDATA[52783]:=[ ,,,[11143969229,"JB"],]; CONWAYPOLDATA[52807]:=[ ,,,[2612309488,"JB"],]; CONWAYPOLDATA[52813]:=[ ,,,[21627346006,"JB"],]; CONWAYPOLDATA[52817]:=[ ,,,[13509849165,"JB"],]; CONWAYPOLDATA[52837]:=[ ,,,[30025206459,"JB"],]; CONWAYPOLDATA[52859]:=[ ,,,[15589757735,"JB"],]; CONWAYPOLDATA[52861]:=[ ,,,[2027166500,"JB"],]; CONWAYPOLDATA[52879]:=[ ,,,[10022368389,"JB"],]; CONWAYPOLDATA[52883]:=[ ,,,[41162170531,"JB"],]; CONWAYPOLDATA[52889]:=[ ,,,[9932342647,"JB"],]; CONWAYPOLDATA[52901]:=[ ,,,[13992367404,"JB"],]; CONWAYPOLDATA[52903]:=[ ,,,[18815480983,"JB"],]; CONWAYPOLDATA[52919]:=[ ,,,[13003574205,"JB"],]; CONWAYPOLDATA[52937]:=[ ,,,[18368821383,"JB"],]; CONWAYPOLDATA[52951]:=[ ,,,[9983805151,"JB"],]; CONWAYPOLDATA[52957]:=[ ,,,[33041196230,"JB"],]; CONWAYPOLDATA[52963]:=[ ,,,[30483966876,"JB"],]; CONWAYPOLDATA[52967]:=[ ,,,[11221800493,"JB"],]; CONWAYPOLDATA[52973]:=[ ,,,[27697250890,"JB"],]; CONWAYPOLDATA[52981]:=[ ,,,[28005332754,"JB"],]; CONWAYPOLDATA[52999]:=[ ,,,[18999452516,"JB"],]; CONWAYPOLDATA[53003]:=[ ,,,[21999584191,"JB"],]; CONWAYPOLDATA[53017]:=[ ,,,[29964148065,"JB"],]; CONWAYPOLDATA[53047]:=[ ,,,[9890825341,"JB"],]; CONWAYPOLDATA[53051]:=[ ,,,[13147417132,"JB"],]; CONWAYPOLDATA[53069]:=[ ,,,[19493835772,"JB"],]; CONWAYPOLDATA[53077]:=[ ,,,[11122444583,"JB"],]; CONWAYPOLDATA[53087]:=[ ,,,[11272705933,"JB"],]; CONWAYPOLDATA[53089]:=[ ,,,[69485909304,"JB"],]; CONWAYPOLDATA[53093]:=[ ,,,[11156856836,"JB"],]; CONWAYPOLDATA[53101]:=[ ,,,[21458698213,"JB"],]; CONWAYPOLDATA[53113]:=[ ,,,[53291831476,"JB"],]; CONWAYPOLDATA[53117]:=[ ,,,[35372469397,"JB"],]; CONWAYPOLDATA[53129]:=[ ,,,[21813332920,"JB"],]; CONWAYPOLDATA[53147]:=[ ,,,[7258976703,"JB"],]; CONWAYPOLDATA[53149]:=[ ,,,[21684632559,"JB"],]; CONWAYPOLDATA[53161]:=[ ,,,[56181714356,"JB"],]; CONWAYPOLDATA[53171]:=[ ,,,[8236560099,"JB"],]; CONWAYPOLDATA[53173]:=[ ,,,[2620737669,"JB"],]; CONWAYPOLDATA[53189]:=[ ,,,[13795152231,"JB"],]; CONWAYPOLDATA[53197]:=[ ,,,[27158398427,"JB"],]; CONWAYPOLDATA[53201]:=[ ,,,[2829707992,"JB"],]; CONWAYPOLDATA[53231]:=[ ,,,[21818056148,"JB"],]; CONWAYPOLDATA[53233]:=[ ,,,[18821006252,"JB"],]; CONWAYPOLDATA[53239]:=[ ,,,[8113357408,"JB"],]; CONWAYPOLDATA[53267]:=[ ,,,[25174996275,"JB"],]; CONWAYPOLDATA[53269]:=[ ,,,[16886965504,"JB"],]; CONWAYPOLDATA[53279]:=[ ,,,[7910599532,"JB"],]; CONWAYPOLDATA[53281]:=[ ,,,[69987577247,"JB"],]; CONWAYPOLDATA[53299]:=[ ,,,[24790377583,"JB"],]; CONWAYPOLDATA[53309]:=[ ,,,[1480284314,"JB"],]; CONWAYPOLDATA[53323]:=[ ,,,[41414694350,"JB"],]; CONWAYPOLDATA[53327]:=[ ,,,[13653578450,"JB"],]; CONWAYPOLDATA[53353]:=[ ,,,[50421519422,"JB"],]; CONWAYPOLDATA[53359]:=[ ,,,[19880976454,"JB"],]; CONWAYPOLDATA[53377]:=[ ,,,[30612456783,"JB"],]; CONWAYPOLDATA[53381]:=[ ,,,[27231943485,"JB"],]; CONWAYPOLDATA[53401]:=[ ,,,[2112383364,"JB"],]; CONWAYPOLDATA[53407]:=[ ,,,[11409016973,"JB"],]; CONWAYPOLDATA[53411]:=[ ,,,[25094196954,"JB"],]; CONWAYPOLDATA[53419]:=[ ,,,[24439780111,"JB"],]; CONWAYPOLDATA[53437]:=[ ,,,[10186160942,"JB"],]; CONWAYPOLDATA[53441]:=[ ,,,[7455607354,"JB"],]; CONWAYPOLDATA[53453]:=[ ,,,[19109394049,"JB"],]; CONWAYPOLDATA[53479]:=[ ,,,[8459468660,"JB"],]; CONWAYPOLDATA[53503]:=[ ,,,[10437900273,"JB"],]; CONWAYPOLDATA[53507]:=[ ,,,[8280315266,"JB"],]; CONWAYPOLDATA[53527]:=[ ,,,[14325484540,"JB"],]; CONWAYPOLDATA[53549]:=[ ,,,[13741262441,"JB"],]; CONWAYPOLDATA[53551]:=[ ,,,[19014300022,"JB"],]; CONWAYPOLDATA[53569]:=[ ,,,[1632943846,"JB"],]; CONWAYPOLDATA[53591]:=[ ,,,[13293622700,"JB"],]; CONWAYPOLDATA[53593]:=[ ,,,[18960131545,"JB"],]; CONWAYPOLDATA[53597]:=[ ,,,[34388424769,"JB"],]; CONWAYPOLDATA[53609]:=[ ,,,[22689902035,"JB"],]; CONWAYPOLDATA[53611]:=[ ,,,[1469316687,"JB"],]; CONWAYPOLDATA[53617]:=[ ,,,[18940902276,"JB"],]; CONWAYPOLDATA[53623]:=[ ,,,[14376916156,"JB"],]; CONWAYPOLDATA[53629]:=[ ,,,[1662016345,"JB"],]; CONWAYPOLDATA[53633]:=[ ,,,[21599349928,"JB"],]; CONWAYPOLDATA[53639]:=[ ,,,[8275907682,"JB"],]; CONWAYPOLDATA[53653]:=[ ,,,[11181338855,"JB"],]; CONWAYPOLDATA[53657]:=[ ,,,[1691590585,"JB"],]; CONWAYPOLDATA[53681]:=[ ,,,[2881005592,"JB"],]; CONWAYPOLDATA[53693]:=[ ,,,[10454134488,"JB"],]; CONWAYPOLDATA[53699]:=[ ,,,[27460755719,"JB"],]; CONWAYPOLDATA[53717]:=[ ,,,[19299712347,"JB"],]; CONWAYPOLDATA[53719]:=[ ,,,[10172391003,"JB"],]; CONWAYPOLDATA[53731]:=[ ,,,[18889401717,"JB"],]; CONWAYPOLDATA[53759]:=[ ,,,[11559690269,"JB"],]; CONWAYPOLDATA[53773]:=[ ,,,[19215674006,"JB"],]; CONWAYPOLDATA[53777]:=[ ,,,[48574774354,"JB"],]; CONWAYPOLDATA[53783]:=[ ,,,[10428577488,"JB"],]; CONWAYPOLDATA[53791]:=[ ,,,[7260870559,"JB"],]; CONWAYPOLDATA[53813]:=[ ,,,[10239322390,"JB"],]; CONWAYPOLDATA[53819]:=[ ,,,[11308717377,"JB"],]; CONWAYPOLDATA[53831]:=[ ,,,[16642714953,"JB"],]; CONWAYPOLDATA[53849]:=[ ,,,[2899068616,"JB"],]; CONWAYPOLDATA[53857]:=[ ,,,[46176399378,"JB"],]; CONWAYPOLDATA[53861]:=[ ,,,[28982119353,"JB"],]; CONWAYPOLDATA[53881]:=[ ,,,[72020415848,"JB"],]; CONWAYPOLDATA[53887]:=[ ,,,[10950485047,"JB"],]; CONWAYPOLDATA[53891]:=[ ,,,[8092218671,"JB"],]; CONWAYPOLDATA[53897]:=[ ,,,[14482932358,"JB"],]; CONWAYPOLDATA[53899]:=[ ,,,[4905779184,"JB"],]; CONWAYPOLDATA[53917]:=[ ,,,[22231650529,"JB"],]; CONWAYPOLDATA[53923]:=[ ,,,[20353398124,"JB"],]; CONWAYPOLDATA[53927]:=[ ,,,[11632269613,"JB"],]; CONWAYPOLDATA[53939]:=[ ,,,[13960168348,"JB"],]; CONWAYPOLDATA[53951]:=[ ,,,[14553066453,"JB"],]; CONWAYPOLDATA[53959]:=[ ,,,[11286496115,"JB"],]; CONWAYPOLDATA[53987]:=[ ,,,[14454641343,"JB"],]; CONWAYPOLDATA[53993]:=[ ,,,[10491163861,"JB"],]; CONWAYPOLDATA[54001]:=[ ,,,[42926042923,"JB"],]; CONWAYPOLDATA[54011]:=[ ,,,[5498967934,"JB"],]; CONWAYPOLDATA[54013]:=[ ,,,[20382129633,"JB"],]; CONWAYPOLDATA[54037]:=[ ,,,[19314985282,"JB"],]; CONWAYPOLDATA[54049]:=[ ,,,[66151381846,"JB"],]; CONWAYPOLDATA[54059]:=[ ,,,[7764277936,"JB"],]; CONWAYPOLDATA[54083]:=[ ,,,[22266403766,"JB"],]; CONWAYPOLDATA[54091]:=[ ,,,[10469908054,"JB"],]; CONWAYPOLDATA[54101]:=[ ,,,[14634374604,"JB"],]; CONWAYPOLDATA[54121]:=[ ,,,[43252853761,"JB"],]; CONWAYPOLDATA[54133]:=[ ,,,[19287858570,"JB"],]; CONWAYPOLDATA[54139]:=[ ,,,[26335645857,"JB"],]; CONWAYPOLDATA[54151]:=[ ,,,[10927292749,"JB"],]; CONWAYPOLDATA[54163]:=[ ,,,[26170586668,"JB"],]; CONWAYPOLDATA[54167]:=[ ,,,[25597482527,"JB"],]; CONWAYPOLDATA[54181]:=[ ,,,[36815230968,"JB"],]; CONWAYPOLDATA[54193]:=[ ,,,[38146073359,"JB"],]; CONWAYPOLDATA[54217]:=[ ,,,[19892108871,"JB"],]; CONWAYPOLDATA[54251]:=[ ,,,[25475130331,"JB"],]; CONWAYPOLDATA[54269]:=[ ,,,[26401868502,"JB"],]; CONWAYPOLDATA[54277]:=[ ,,,[11339767953,"JB"],]; CONWAYPOLDATA[54287]:=[ ,,,[11788096333,"JB"],]; CONWAYPOLDATA[54293]:=[ ,,,[8762184393,"JB"],]; CONWAYPOLDATA[54311]:=[ ,,,[31415003119,"JB"],]; CONWAYPOLDATA[54319]:=[ ,,,[20202539759,"JB"],]; CONWAYPOLDATA[54323]:=[ ,,,[23565914955,"JB"],]; CONWAYPOLDATA[54331]:=[ ,,,[26275721215,"JB"],]; CONWAYPOLDATA[54347]:=[ ,,,[34483606278,"JB"],]; CONWAYPOLDATA[54361]:=[ ,,,[50099913022,"JB"],]; CONWAYPOLDATA[54367]:=[ ,,,[8302384575,"JB"],]; CONWAYPOLDATA[54371]:=[ ,,,[14635368302,"JB"],]; CONWAYPOLDATA[54377]:=[ ,,,[5768584050,"JB"],]; CONWAYPOLDATA[54401]:=[ ,,,[13601120419,"JB"],]; CONWAYPOLDATA[54403]:=[ ,,,[5289114065,"JB"],]; CONWAYPOLDATA[54409]:=[ ,,,[52525686881,"JB"],]; CONWAYPOLDATA[54413]:=[ ,,,[13870635484,"JB"],]; CONWAYPOLDATA[54419]:=[ ,,,[26140003395,"JB"],]; CONWAYPOLDATA[54421]:=[ ,,,[26654426224,"JB"],]; CONWAYPOLDATA[54437]:=[ ,,,[2185917737,"JB"],]; CONWAYPOLDATA[54443]:=[ ,,,[25222026384,"JB"],]; CONWAYPOLDATA[54449]:=[ ,,,[1985972829,"JB"],]; CONWAYPOLDATA[54469]:=[ ,,,[37132170930,"JB"],]; CONWAYPOLDATA[54493]:=[ ,,,[28289822980,"JB"],]; CONWAYPOLDATA[54497]:=[ ,,,[14753536837,"JB"],]; CONWAYPOLDATA[54499]:=[ ,,,[16881337748,"JB"],]; CONWAYPOLDATA[54503]:=[ ,,,[14473925693,"JB"],]; CONWAYPOLDATA[54517]:=[ ,,,[70598915318,"JB"],]; CONWAYPOLDATA[54521]:=[ ,,,[13619727450,"JB"],]; CONWAYPOLDATA[54539]:=[ ,,,[13594063908,"JB"],]; CONWAYPOLDATA[54541]:=[ ,,,[20307686860,"JB"],]; CONWAYPOLDATA[54547]:=[ ,,,[14757363571,"JB"],]; CONWAYPOLDATA[54559]:=[ ,,,[8896335984,"JB"],]; CONWAYPOLDATA[54563]:=[ ,,,[23721591630,"JB"],]; CONWAYPOLDATA[54577]:=[ ,,,[44679133593,"JB"],]; CONWAYPOLDATA[54581]:=[ ,,,[2858789047,"JB"],]; CONWAYPOLDATA[54583]:=[ ,,,[11211566537,"JB"],]; CONWAYPOLDATA[54601]:=[ ,,,[68458679221,"JB"],]; CONWAYPOLDATA[54617]:=[ ,,,[23571113310,"JB"],]; CONWAYPOLDATA[54623]:=[ ,,,[13882326209,"JB"],]; CONWAYPOLDATA[54629]:=[ ,,,[37924544383,"JB"],]; CONWAYPOLDATA[54631]:=[ ,,,[10739252724,"JB"],]; CONWAYPOLDATA[54647]:=[ ,,,[23544496014,"JB"],]; CONWAYPOLDATA[54667]:=[ ,,,[40497204268,"JB"],]; CONWAYPOLDATA[54673]:=[ ,,,[20608221933,"JB"],]; CONWAYPOLDATA[54679]:=[ ,,,[2645041953,"JB"],]; CONWAYPOLDATA[54709]:=[ ,,,[20922909962,"JB"],]; CONWAYPOLDATA[54713]:=[ ,,,[20385407249,"JB"],]; CONWAYPOLDATA[54721]:=[ ,,,[62366453968,"JB"],]; CONWAYPOLDATA[54727]:=[ ,,,[17818782841,"JB"],]; CONWAYPOLDATA[54751]:=[ ,,,[23980828504,"JB"],]; CONWAYPOLDATA[54767]:=[ ,,,[16972567140,"JB"],]; CONWAYPOLDATA[54773]:=[ ,,,[8722928890,"JB"],]; CONWAYPOLDATA[54779]:=[ ,,,[26076885604,"JB"],]; CONWAYPOLDATA[54787]:=[ ,,,[23231934269,"JB"],]; CONWAYPOLDATA[54799]:=[ ,,,[7743427497,"JB"],]; CONWAYPOLDATA[54829]:=[ ,,,[27055589368,"JB"],]; CONWAYPOLDATA[54833]:=[ ,,,[5838672676,"JB"],]; CONWAYPOLDATA[54851]:=[ ,,,[47581706678,"JB"],]; CONWAYPOLDATA[54869]:=[ ,,,[14775288929,"JB"],]; CONWAYPOLDATA[54877]:=[ ,,,[38866196236,"JB"],]; CONWAYPOLDATA[54881]:=[ ,,,[14676496547,"JB"],]; CONWAYPOLDATA[54907]:=[ ,,,[23216052277,"JB"],]; CONWAYPOLDATA[54917]:=[ ,,,[17380571498,"JB"],]; CONWAYPOLDATA[54919]:=[ ,,,[11400854889,"JB"],]; CONWAYPOLDATA[54941]:=[ ,,,[11834511166,"JB"],]; CONWAYPOLDATA[54949]:=[ ,,,[27174148768,"JB"],]; CONWAYPOLDATA[54959]:=[ ,,,[7751142572,"JB"],]; CONWAYPOLDATA[54973]:=[ ,,,[4691560753,"JB"],]; CONWAYPOLDATA[54979]:=[ ,,,[11427770006,"JB"],]; CONWAYPOLDATA[54983]:=[ ,,,[20823986510,"JB"],]; CONWAYPOLDATA[55001]:=[ ,,,[26451190925,"JB"],]; CONWAYPOLDATA[55009]:=[ ,,,[74747549423,"JB"],]; CONWAYPOLDATA[55021]:=[ ,,,[22744085797,"JB"],]; CONWAYPOLDATA[55049]:=[ ,,,[14651731748,"JB"],]; CONWAYPOLDATA[55051]:=[ ,,,[8026160547,"JB"],]; CONWAYPOLDATA[55057]:=[ ,,,[38501965737,"JB"],]; CONWAYPOLDATA[55061]:=[ ,,,[10946236924,"JB"],]; CONWAYPOLDATA[55073]:=[ ,,,[23349024448,"JB"],]; CONWAYPOLDATA[55079]:=[ ,,,[8147506009,"JB"],]; CONWAYPOLDATA[55103]:=[ ,,,[11780194860,"JB"],]; CONWAYPOLDATA[55109]:=[ ,,,[29303990316,"JB"],]; CONWAYPOLDATA[55117]:=[ ,,,[5282523519,"JB"],]; CONWAYPOLDATA[55127]:=[ ,,,[17429448468,"JB"],]; CONWAYPOLDATA[55147]:=[ ,,,[12164545853,"JB"],]; CONWAYPOLDATA[55163]:=[ ,,,[42294796014,"JB"],]; CONWAYPOLDATA[55171]:=[ ,,,[41706351947,"JB"],]; CONWAYPOLDATA[55201]:=[ ,,,[2837221005,"JB"],]; CONWAYPOLDATA[55207]:=[ ,,,[8530199196,"JB"],]; CONWAYPOLDATA[55213]:=[ ,,,[20982375540,"JB"],]; CONWAYPOLDATA[55217]:=[ ,,,[36337424231,"JB"],]; CONWAYPOLDATA[55219]:=[ ,,,[7667323809,"JB"],]; CONWAYPOLDATA[55229]:=[ ,,,[14346285042,"JB"],]; CONWAYPOLDATA[55243]:=[ ,,,[8896332722,"JB"],]; CONWAYPOLDATA[55249]:=[ ,,,[27256320675,"JB"],]; CONWAYPOLDATA[55259]:=[ ,,,[2551971144,"JB"],]; CONWAYPOLDATA[55291]:=[ ,,,[1620247475,"JB"],]; CONWAYPOLDATA[55313]:=[ ,,,[2921853915,"JB"],]; CONWAYPOLDATA[55331]:=[ ,,,[20999165791,"JB"],]; CONWAYPOLDATA[55333]:=[ ,,,[26585127187,"JB"],]; CONWAYPOLDATA[55337]:=[ ,,,[23547110917,"JB"],]; CONWAYPOLDATA[55339]:=[ ,,,[26217625998,"JB"],]; CONWAYPOLDATA[55343]:=[ ,,,[52067745924,"JB"],]; CONWAYPOLDATA[55351]:=[ ,,,[11770999018,"JB"],]; CONWAYPOLDATA[55373]:=[ ,,,[11734590789,"JB"],]; CONWAYPOLDATA[55381]:=[ ,,,[36012436733,"JB"],]; CONWAYPOLDATA[55399]:=[ ,,,[8583576465,"JB"],]; CONWAYPOLDATA[55411]:=[ ,,,[8693653436,"JB"],]; CONWAYPOLDATA[55439]:=[ ,,,[14641218157,"JB"],]; CONWAYPOLDATA[55441]:=[ ,,,[64100884238,"JB"],]; CONWAYPOLDATA[55457]:=[ ,,,[5935174514,"JB"],]; CONWAYPOLDATA[55469]:=[ ,,,[4995926425,"JB"],]; CONWAYPOLDATA[55487]:=[ ,,,[21128728274,"JB"],]; CONWAYPOLDATA[55501]:=[ ,,,[21562305009,"JB"],]; CONWAYPOLDATA[55511]:=[ ,,,[17941543788,"JB"],]; CONWAYPOLDATA[55529]:=[ ,,,[8540304674,"JB"],]; CONWAYPOLDATA[55541]:=[ ,,,[14787458006,"JB"],]; CONWAYPOLDATA[55547]:=[ ,,,[13984957098,"JB"],]; CONWAYPOLDATA[55579]:=[ ,,,[8716287835,"JB"],]; CONWAYPOLDATA[55589]:=[ ,,,[39271627298,"JB"],]; CONWAYPOLDATA[55603]:=[ ,,,[26561441896,"JB"],]; CONWAYPOLDATA[55609]:=[ ,,,[3090192143,"JB"],]; CONWAYPOLDATA[55619]:=[ ,,,[23555147073,"JB"],]; CONWAYPOLDATA[55621]:=[ ,,,[23868917837,"JB"],]; CONWAYPOLDATA[55631]:=[ ,,,[14525309738,"JB"],]; CONWAYPOLDATA[55633]:=[ ,,,[51482388774,"JB"],]; CONWAYPOLDATA[55639]:=[ ,,,[21159734259,"JB"],]; CONWAYPOLDATA[55661]:=[ ,,,[39252972117,"JB"],]; CONWAYPOLDATA[55663]:=[ ,,,[10902656150,"JB"],]; CONWAYPOLDATA[55667]:=[ ,,,[43139809656,"JB"],]; CONWAYPOLDATA[55673]:=[ ,,,[14701513440,"JB"],]; CONWAYPOLDATA[55681]:=[ ,,,[38892009210,"JB"],]; CONWAYPOLDATA[55691]:=[ ,,,[8669529354,"JB"],]; CONWAYPOLDATA[55697]:=[ ,,,[8158663654,"JB"],]; CONWAYPOLDATA[55711]:=[ ,,,[9218164907,"JB"],]; CONWAYPOLDATA[55717]:=[ ,,,[30482770702,"JB"],]; CONWAYPOLDATA[55721]:=[ ,,,[23703044751,"JB"],]; CONWAYPOLDATA[55733]:=[ ,,,[5397852518,"JB"],]; CONWAYPOLDATA[55763]:=[ ,,,[14233728804,"JB"],]; CONWAYPOLDATA[55787]:=[ ,,,[11842352788,"JB"],]; CONWAYPOLDATA[55793]:=[ ,,,[39009572915,"JB"],]; CONWAYPOLDATA[55799]:=[ ,,,[17176717775,"JB"],]; CONWAYPOLDATA[55807]:=[ ,,,[20275352787,"JB"],]; CONWAYPOLDATA[55813]:=[ ,,,[32927214230,"JB"],]; CONWAYPOLDATA[55817]:=[ ,,,[2731516532,"JB"],]; CONWAYPOLDATA[55819]:=[ ,,,[26776709216,"JB"],]; CONWAYPOLDATA[55823]:=[ ,,,[27468544500,"JB"],]; CONWAYPOLDATA[55829]:=[ ,,,[23708008168,"JB"],]; CONWAYPOLDATA[55837]:=[ ,,,[21456372321,"JB"],]; CONWAYPOLDATA[55843]:=[ ,,,[27311694442,"JB"],]; CONWAYPOLDATA[55849]:=[ ,,,[33798362740,"JB"],]; CONWAYPOLDATA[55871]:=[ ,,,[11435899771,"JB"],]; CONWAYPOLDATA[55889]:=[ ,,,[3122909656,"JB"],]; CONWAYPOLDATA[55897]:=[ ,,,[39810402375,"JB"],]; CONWAYPOLDATA[55901]:=[ ,,,[12115032425,"JB"],]; CONWAYPOLDATA[55903]:=[ ,,,[8699009938,"JB"],]; CONWAYPOLDATA[55921]:=[ ,,,[27427516970,"JB"],]; CONWAYPOLDATA[55927]:=[ ,,,[11376334781,"JB"],]; CONWAYPOLDATA[55931]:=[ ,,,[2948850119,"JB"],]; CONWAYPOLDATA[55933]:=[ ,,,[21460373442,"JB"],]; CONWAYPOLDATA[55949]:=[ ,,,[4710234414,"JB"],]; CONWAYPOLDATA[55967]:=[ ,,,[18040178917,"JB"],]; CONWAYPOLDATA[55987]:=[ ,,,[27101907027,"JB"],]; CONWAYPOLDATA[55997]:=[ ,,,[39738159058,"JB"],]; CONWAYPOLDATA[56003]:=[ ,,,[8721123180,"JB"],]; CONWAYPOLDATA[56009]:=[ ,,,[8718192916,"JB"],]; CONWAYPOLDATA[56039]:=[ ,,,[15701343261,"JB"],]; CONWAYPOLDATA[56041]:=[ ,,,[2270949450,"JB"],]; CONWAYPOLDATA[56053]:=[ ,,,[31061321528,"JB"],]; CONWAYPOLDATA[56081]:=[ ,,,[2802591897,"JB"],]; CONWAYPOLDATA[56087]:=[ ,,,[18791556746,"JB"],]; CONWAYPOLDATA[56093]:=[ ,,,[21715114813,"JB"],]; CONWAYPOLDATA[56099]:=[ ,,,[14999638424,"JB"],]; CONWAYPOLDATA[56101]:=[ ,,,[49715471985,"JB"],]; CONWAYPOLDATA[56113]:=[ ,,,[53274467787,"JB"],]; CONWAYPOLDATA[56123]:=[ ,,,[27631261084,"JB"],]; CONWAYPOLDATA[56131]:=[ ,,,[9354343414,"JB"],]; CONWAYPOLDATA[56149]:=[ ,,,[3099480955,"JB"],]; CONWAYPOLDATA[56167]:=[ ,,,[12592304401,"JB"],]; CONWAYPOLDATA[56171]:=[ ,,,[7958082598,"JB"],]; CONWAYPOLDATA[56179]:=[ ,,,[12530164163,"JB"],]; CONWAYPOLDATA[56197]:=[ ,,,[12429933458,"JB"],]; CONWAYPOLDATA[56207]:=[ ,,,[12636682573,"JB"],]; CONWAYPOLDATA[56209]:=[ ,,,[3082895030,"JB"],]; CONWAYPOLDATA[56237]:=[ ,,,[21872143938,"JB"],]; CONWAYPOLDATA[56239]:=[ ,,,[11896966780,"JB"],]; CONWAYPOLDATA[56249]:=[ ,,,[9241204462,"JB"],]; CONWAYPOLDATA[56263]:=[ ,,,[15827400796,"JB"],]; CONWAYPOLDATA[56267]:=[ ,,,[24851783494,"JB"],]; CONWAYPOLDATA[56269]:=[ ,,,[24463960594,"JB"],]; CONWAYPOLDATA[56299]:=[ ,,,[2651007322,"JB"],]; CONWAYPOLDATA[56311]:=[ ,,,[21768481142,"JB"],]; CONWAYPOLDATA[56333]:=[ ,,,[2510930811,"JB"],]; CONWAYPOLDATA[56359]:=[ ,,,[8685880006,"JB"],]; CONWAYPOLDATA[56369]:=[ ,,,[3176787736,"JB"],]; CONWAYPOLDATA[56377]:=[ ,,,[76126990645,"JB"],]; CONWAYPOLDATA[56383]:=[ ,,,[18331240963,"JB"],]; CONWAYPOLDATA[56393]:=[ ,,,[21789240129,"JB"],]; CONWAYPOLDATA[56401]:=[ ,,,[46332744701,"JB"],]; CONWAYPOLDATA[56417]:=[ ,,,[30749408849,"JB"],]; CONWAYPOLDATA[56431]:=[ ,,,[20830149309,"JB"],]; CONWAYPOLDATA[56437]:=[ ,,,[12037447732,"JB"],]; CONWAYPOLDATA[56443]:=[ ,,,[18294474494,"JB"],]; CONWAYPOLDATA[56453]:=[ ,,,[4804601926,"JB"],]; CONWAYPOLDATA[56467]:=[ ,,,[8195733316,"JB"],]; CONWAYPOLDATA[56473]:=[ ,,,[104385427354,"JB"],]; CONWAYPOLDATA[56477]:=[ ,,,[23953138196,"JB"],]; CONWAYPOLDATA[56479]:=[ ,,,[11346518148,"JB"],]; CONWAYPOLDATA[56489]:=[ ,,,[11285767846,"JB"],]; CONWAYPOLDATA[56501]:=[ ,,,[15961589004,"JB"],]; CONWAYPOLDATA[56503]:=[ ,,,[8396910833,"JB"],]; CONWAYPOLDATA[56509]:=[ ,,,[11825581923,"JB"],]; CONWAYPOLDATA[56519]:=[ ,,,[36795281988,"JB"],]; CONWAYPOLDATA[56527]:=[ ,,,[12271389906,"JB"],]; CONWAYPOLDATA[56531]:=[ ,,,[49578252312,"JB"],]; CONWAYPOLDATA[56533]:=[ ,,,[11610408347,"JB"],]; CONWAYPOLDATA[56543]:=[ ,,,[12788217229,"JB"],]; CONWAYPOLDATA[56569]:=[ ,,,[108145106933,"JB"],]; CONWAYPOLDATA[56591]:=[ ,,,[16011857559,"JB"],]; CONWAYPOLDATA[56597]:=[ ,,,[18592680472,"JB"],]; CONWAYPOLDATA[56599]:=[ ,,,[16017007612,"JB"],]; CONWAYPOLDATA[56611]:=[ ,,,[3160139268,"JB"],]; CONWAYPOLDATA[56629]:=[ ,,,[28861196368,"JB"],]; CONWAYPOLDATA[56633]:=[ ,,,[1786091557,"JB"],]; CONWAYPOLDATA[56659]:=[ ,,,[28347347587,"JB"],]; CONWAYPOLDATA[56663]:=[ ,,,[12842555629,"JB"],]; CONWAYPOLDATA[56671]:=[ ,,,[9020266402,"JB"],]; CONWAYPOLDATA[56681]:=[ ,,,[3212055592,"JB"],]; CONWAYPOLDATA[56687]:=[ ,,,[15364217737,"JB"],]; CONWAYPOLDATA[56701]:=[ ,,,[22334240397,"JB"],]; CONWAYPOLDATA[56711]:=[ ,,,[9180773664,"JB"],]; CONWAYPOLDATA[56713]:=[ ,,,[34527101257,"JB"],]; CONWAYPOLDATA[56731]:=[ ,,,[21030862474,"JB"],]; CONWAYPOLDATA[56737]:=[ ,,,[41566263791,"JB"],]; CONWAYPOLDATA[56747]:=[ ,,,[25238398493,"JB"],]; CONWAYPOLDATA[56767]:=[ ,,,[56583812894,"JB"],]; CONWAYPOLDATA[56773]:=[ ,,,[12094465738,"JB"],]; CONWAYPOLDATA[56779]:=[ ,,,[28606111887,"JB"],]; CONWAYPOLDATA[56783]:=[ ,,,[31086137270,"JB"],]; CONWAYPOLDATA[56807]:=[ ,,,[28077541439,"JB"],]; CONWAYPOLDATA[56809]:=[ ,,,[87135007633,"JB"],]; CONWAYPOLDATA[56813]:=[ ,,,[48355191880,"JB"],]; CONWAYPOLDATA[56821]:=[ ,,,[25435750193,"JB"],]; CONWAYPOLDATA[56827]:=[ ,,,[28092654760,"JB"],]; CONWAYPOLDATA[56843]:=[ ,,,[25372555168,"JB"],]; CONWAYPOLDATA[56857]:=[ ,,,[40829750848,"JB"],]; CONWAYPOLDATA[56873]:=[ ,,,[1788428361,"JB"],]; CONWAYPOLDATA[56891]:=[ ,,,[27763661367,"JB"],]; CONWAYPOLDATA[56893]:=[ ,,,[21513519022,"JB"],]; CONWAYPOLDATA[56897]:=[ ,,,[28723767691,"JB"],]; CONWAYPOLDATA[56909]:=[ ,,,[29147310168,"JB"],]; CONWAYPOLDATA[56911]:=[ ,,,[11531705200,"JB"],]; CONWAYPOLDATA[56921]:=[ ,,,[24983651481,"JB"],]; CONWAYPOLDATA[56923]:=[ ,,,[15655020386,"JB"],]; CONWAYPOLDATA[56929]:=[ ,,,[40584854901,"JB"],]; CONWAYPOLDATA[56941]:=[ ,,,[30976302589,"JB"],]; CONWAYPOLDATA[56951]:=[ ,,,[8675915353,"JB"],]; CONWAYPOLDATA[56957]:=[ ,,,[4980889652,"JB"],]; CONWAYPOLDATA[56963]:=[ ,,,[22436187701,"JB"],]; CONWAYPOLDATA[56983]:=[ ,,,[11821921115,"JB"],]; CONWAYPOLDATA[56989]:=[ ,,,[8195417129,"JB"],]; CONWAYPOLDATA[56993]:=[ ,,,[5450240593,"JB"],]; CONWAYPOLDATA[56999]:=[ ,,,[45483378045,"JB"],]; CONWAYPOLDATA[57037]:=[ ,,,[6447063226,"JB"],]; CONWAYPOLDATA[57041]:=[ ,,,[21508621004,"JB"],]; CONWAYPOLDATA[57047]:=[ ,,,[11727265891,"JB"],]; CONWAYPOLDATA[57059]:=[ ,,,[12018565408,"JB"],]; CONWAYPOLDATA[57073]:=[ ,,,[35086539923,"JB"],]; CONWAYPOLDATA[57077]:=[ ,,,[21242746631,"JB"],]; CONWAYPOLDATA[57089]:=[ ,,,[26053935289,"JB"],]; CONWAYPOLDATA[57097]:=[ ,,,[44635865242,"JB"],]; CONWAYPOLDATA[57107]:=[ ,,,[25113659857,"JB"],]; CONWAYPOLDATA[57119]:=[ ,,,[12968412017,"JB"],]; CONWAYPOLDATA[57131]:=[ ,,,[24913343696,"JB"],]; CONWAYPOLDATA[57139]:=[ ,,,[21321760686,"JB"],]; CONWAYPOLDATA[57143]:=[ ,,,[11869515393,"JB"],]; CONWAYPOLDATA[57149]:=[ ,,,[2738294337,"JB"],]; CONWAYPOLDATA[57163]:=[ ,,,[28244695606,"JB"],]; CONWAYPOLDATA[57173]:=[ ,,,[25090656917,"JB"],]; CONWAYPOLDATA[57179]:=[ ,,,[9527107803,"JB"],]; CONWAYPOLDATA[57191]:=[ ,,,[18769857443,"JB"],]; CONWAYPOLDATA[57193]:=[ ,,,[51341812947,"JB"],]; CONWAYPOLDATA[57203]:=[ ,,,[35705082948,"JB"],]; CONWAYPOLDATA[57221]:=[ ,,,[11616664096,"JB"],]; CONWAYPOLDATA[57223]:=[ ,,,[12270213447,"JB"],]; CONWAYPOLDATA[57241]:=[ ,,,[68210379046,"JB"],]; CONWAYPOLDATA[57251]:=[ ,,,[12433772182,"JB"],]; CONWAYPOLDATA[57259]:=[ ,,,[8603336529,"JB"],]; CONWAYPOLDATA[57269]:=[ ,,,[41451531278,"JB"],]; CONWAYPOLDATA[57271]:=[ ,,,[22535336709,"JB"],]; CONWAYPOLDATA[57283]:=[ ,,,[29161400510,"JB"],]; CONWAYPOLDATA[57287]:=[ ,,,[25153976974,"JB"],]; CONWAYPOLDATA[57301]:=[ ,,,[8739262021,"JB"],]; CONWAYPOLDATA[57329]:=[ ,,,[3285926296,"JB"],]; CONWAYPOLDATA[57331]:=[ ,,,[29243109827,"JB"],]; CONWAYPOLDATA[57347]:=[ ,,,[29597704254,"JB"],]; CONWAYPOLDATA[57349]:=[ ,,,[29154511132,"JB"],]; CONWAYPOLDATA[57367]:=[ ,,,[19664547098,"JB"],]; CONWAYPOLDATA[57373]:=[ ,,,[51182912286,"JB"],]; CONWAYPOLDATA[57383]:=[ ,,,[15323212027,"JB"],]; CONWAYPOLDATA[57389]:=[ ,,,[12594934276,"JB"],]; CONWAYPOLDATA[57397]:=[ ,,,[22493941699,"JB"],]; CONWAYPOLDATA[57413]:=[ ,,,[49348482957,"JB"],]; CONWAYPOLDATA[57427]:=[ ,,,[36175334674,"JB"],]; CONWAYPOLDATA[57457]:=[ ,,,[35642760471,"JB"],]; CONWAYPOLDATA[57467]:=[ ,,,[26137658145,"JB"],]; CONWAYPOLDATA[57487]:=[ ,,,[12379480534,"JB"],]; CONWAYPOLDATA[57493]:=[ ,,,[22381794933,"JB"],]; CONWAYPOLDATA[57503]:=[ ,,,[39678450077,"JB"],]; CONWAYPOLDATA[57527]:=[ ,,,[8599538654,"JB"],]; CONWAYPOLDATA[57529]:=[ ,,,[1686462642,"JB"],]; CONWAYPOLDATA[57557]:=[ ,,,[5885088138,"JB"],]; CONWAYPOLDATA[57559]:=[ ,,,[38637572377,"JB"],]; CONWAYPOLDATA[57571]:=[ ,,,[16482577313,"JB"],]; CONWAYPOLDATA[57587]:=[ ,,,[9450141876,"JB"],]; CONWAYPOLDATA[57593]:=[ ,,,[32738625667,"JB"],]; CONWAYPOLDATA[57601]:=[ ,,,[56078490375,"JB"],]; CONWAYPOLDATA[57637]:=[ ,,,[23048459932,"JB"],]; CONWAYPOLDATA[57641]:=[ ,,,[2930814289,"JB"],]; CONWAYPOLDATA[57649]:=[ ,,,[95776261494,"JB"],]; CONWAYPOLDATA[57653]:=[ ,,,[25794759344,"JB"],]; CONWAYPOLDATA[57667]:=[ ,,,[22354900888,"JB"],]; CONWAYPOLDATA[57679]:=[ ,,,[13120588207,"JB"],]; CONWAYPOLDATA[57689]:=[ ,,,[3327328456,"JB"],]; CONWAYPOLDATA[57697]:=[ ,,,[22869417592,"JB"],]; CONWAYPOLDATA[57709]:=[ ,,,[22926862358,"JB"],]; CONWAYPOLDATA[57713]:=[ ,,,[15618638341,"JB"],]; CONWAYPOLDATA[57719]:=[ ,,,[25591796541,"JB"],]; CONWAYPOLDATA[57727]:=[ ,,,[18595656240,"JB"],]; CONWAYPOLDATA[57731]:=[ ,,,[6259425946,"JB"],]; CONWAYPOLDATA[57737]:=[ ,,,[39784257223,"JB"],]; CONWAYPOLDATA[57751]:=[ ,,,[13059695644,"JB"],]; CONWAYPOLDATA[57773]:=[ ,,,[16688366556,"JB"],]; CONWAYPOLDATA[57781]:=[ ,,,[66611496893,"JB"],]; CONWAYPOLDATA[57787]:=[ ,,,[28521005000,"JB"],]; CONWAYPOLDATA[57791]:=[ ,,,[29338179086,"JB"],]; CONWAYPOLDATA[57793]:=[ ,,,[21735253789,"JB"],]; CONWAYPOLDATA[57803]:=[ ,,,[28810171262,"JB"],]; CONWAYPOLDATA[57809]:=[ ,,,[9415178406,"JB"],]; CONWAYPOLDATA[57829]:=[ ,,,[12309770095,"JB"],]; CONWAYPOLDATA[57839]:=[ ,,,[12775709687,"JB"],]; CONWAYPOLDATA[57847]:=[ ,,,[22918634321,"JB"],]; CONWAYPOLDATA[57853]:=[ ,,,[35967383664,"JB"],]; CONWAYPOLDATA[57859]:=[ ,,,[28580205219,"JB"],]; CONWAYPOLDATA[57881]:=[ ,,,[10019490508,"JB"],]; CONWAYPOLDATA[57899]:=[ ,,,[28957142670,"JB"],]; CONWAYPOLDATA[57901]:=[ ,,,[42732153923,"JB"],]; CONWAYPOLDATA[57917]:=[ ,,,[5882745526,"JB"],]; CONWAYPOLDATA[57923]:=[ ,,,[30195259902,"JB"],]; CONWAYPOLDATA[57943]:=[ ,,,[19619499805,"JB"],]; CONWAYPOLDATA[57947]:=[ ,,,[20035522937,"JB"],]; CONWAYPOLDATA[57973]:=[ ,,,[26650477970,"JB"],]; CONWAYPOLDATA[57977]:=[ ,,,[22037637473,"JB"],]; CONWAYPOLDATA[57991]:=[ ,,,[12769966152,"JB"],]; CONWAYPOLDATA[58013]:=[ ,,,[25568185518,"JB"],]; CONWAYPOLDATA[58027]:=[ ,,,[30066980187,"JB"],]; CONWAYPOLDATA[58031]:=[ ,,,[19548844946,"JB"],]; CONWAYPOLDATA[58043]:=[ ,,,[16329063063,"JB"],]; CONWAYPOLDATA[58049]:=[ ,,,[3368989816,"JB"],]; CONWAYPOLDATA[58057]:=[ ,,,[48961558159,"JB"],]; CONWAYPOLDATA[58061]:=[ ,,,[15712467823,"JB"],]; CONWAYPOLDATA[58067]:=[ ,,,[30181020056,"JB"],]; CONWAYPOLDATA[58073]:=[ ,,,[8999863180,"JB"],]; CONWAYPOLDATA[58099]:=[ ,,,[8988961092,"JB"],]; CONWAYPOLDATA[58109]:=[ ,,,[29845944582,"JB"],]; CONWAYPOLDATA[58111]:=[ ,,,[18898336433,"JB"],]; CONWAYPOLDATA[58129]:=[ ,,,[3376713623,"JB"],]; CONWAYPOLDATA[58147]:=[ ,,,[12865140047,"JB"],]; CONWAYPOLDATA[58151]:=[ ,,,[9140930150,"JB"],]; CONWAYPOLDATA[58153]:=[ ,,,[2316350306,"JB"],]; CONWAYPOLDATA[58169]:=[ ,,,[2523254888,"JB"],]; CONWAYPOLDATA[58171]:=[ ,,,[30065215984,"JB"],]; CONWAYPOLDATA[58189]:=[ ,,,[29932363417,"JB"],]; CONWAYPOLDATA[58193]:=[ ,,,[6665018872,"JB"],]; CONWAYPOLDATA[58199]:=[ ,,,[16046861083,"JB"],]; CONWAYPOLDATA[58207]:=[ ,,,[8685299303,"JB"],]; CONWAYPOLDATA[58211]:=[ ,,,[53384493148,"JB"],]; CONWAYPOLDATA[58217]:=[ ,,,[6203894608,"JB"],]; CONWAYPOLDATA[58229]:=[ ,,,[6361343565,"JB"],]; CONWAYPOLDATA[58231]:=[ ,,,[13260712712,"JB"],]; CONWAYPOLDATA[58237]:=[ ,,,[1859216240,"JB"],]; CONWAYPOLDATA[58243]:=[ ,,,[10124147720,"JB"],]; CONWAYPOLDATA[58271]:=[ ,,,[19170576301,"JB"],]; CONWAYPOLDATA[58309]:=[ ,,,[44198746787,"JB"],]; CONWAYPOLDATA[58313]:=[ ,,,[2059556850,"JB"],]; CONWAYPOLDATA[58321]:=[ ,,,[85032367937,"JB"],]; CONWAYPOLDATA[58337]:=[ ,,,[1727008551,"JB"],]; CONWAYPOLDATA[58363]:=[ ,,,[29669589771,"JB"],]; CONWAYPOLDATA[58367]:=[ ,,,[16159837829,"JB"],]; CONWAYPOLDATA[58369]:=[ ,,,[1762043379,"JB"],]; CONWAYPOLDATA[58379]:=[ ,,,[16991674984,"JB"],]; CONWAYPOLDATA[58391]:=[ ,,,[13460118158,"JB"],]; CONWAYPOLDATA[58393]:=[ ,,,[36703737657,"JB"],]; CONWAYPOLDATA[58403]:=[ ,,,[25965448175,"JB"],]; CONWAYPOLDATA[58411]:=[ ,,,[22316565073,"JB"],]; CONWAYPOLDATA[58417]:=[ ,,,[51187545753,"JB"],]; CONWAYPOLDATA[58427]:=[ ,,,[26681449103,"JB"],]; CONWAYPOLDATA[58439]:=[ ,,,[25892275552,"JB"],]; CONWAYPOLDATA[58441]:=[ ,,,[50190825602,"JB"],]; CONWAYPOLDATA[58451]:=[ ,,,[40997180704,"JB"],]; CONWAYPOLDATA[58453]:=[ ,,,[13398129038,"JB"],]; CONWAYPOLDATA[58477]:=[ ,,,[12770792035,"JB"],]; CONWAYPOLDATA[58481]:=[ ,,,[15405942241,"JB"],]; CONWAYPOLDATA[58511]:=[ ,,,[22962173875,"JB"],]; CONWAYPOLDATA[58537]:=[ ,,,[61072588699,"JB"],]; CONWAYPOLDATA[58543]:=[ ,,,[16859564404,"JB"],]; CONWAYPOLDATA[58549]:=[ ,,,[44532135206,"JB"],]; CONWAYPOLDATA[58567]:=[ ,,,[26014700035,"JB"],]; CONWAYPOLDATA[58573]:=[ ,,,[68383860356,"JB"],]; CONWAYPOLDATA[58579]:=[ ,,,[8928845498,"JB"],]; CONWAYPOLDATA[58601]:=[ ,,,[3433373992,"JB"],]; CONWAYPOLDATA[58603]:=[ ,,,[9097236707,"JB"],]; CONWAYPOLDATA[58613]:=[ ,,,[19361339227,"JB"],]; CONWAYPOLDATA[58631]:=[ ,,,[20303387640,"JB"],]; CONWAYPOLDATA[58657]:=[ ,,,[54169739505,"JB"],]; CONWAYPOLDATA[58661]:=[ ,,,[23945713507,"JB"],]; CONWAYPOLDATA[58679]:=[ ,,,[9446673542,"JB"],]; CONWAYPOLDATA[58687]:=[ ,,,[37152274852,"JB"],]; CONWAYPOLDATA[58693]:=[ ,,,[12421023513,"JB"],]; CONWAYPOLDATA[58699]:=[ ,,,[26832897775,"JB"],]; CONWAYPOLDATA[58711]:=[ ,,,[13284361843,"JB"],]; CONWAYPOLDATA[58727]:=[ ,,,[13795207213,"JB"],]; CONWAYPOLDATA[58733]:=[ ,,,[23751214071,"JB"],]; CONWAYPOLDATA[58741]:=[ ,,,[23726194794,"JB"],]; CONWAYPOLDATA[58757]:=[ ,,,[13736916546,"JB"],]; CONWAYPOLDATA[58763]:=[ ,,,[15777160346,"JB"],]; CONWAYPOLDATA[58771]:=[ ,,,[8755762362,"JB"],]; CONWAYPOLDATA[58787]:=[ ,,,[48044557557,"JB"],]; CONWAYPOLDATA[58789]:=[ ,,,[33657584337,"JB"],]; CONWAYPOLDATA[58831]:=[ ,,,[9822011954,"JB"],]; CONWAYPOLDATA[58889]:=[ ,,,[17154895704,"JB"],]; CONWAYPOLDATA[58897]:=[ ,,,[54563653230,"JB"],]; CONWAYPOLDATA[58901]:=[ ,,,[13054758741,"JB"],]; CONWAYPOLDATA[58907]:=[ ,,,[26269046489,"JB"],]; CONWAYPOLDATA[58909]:=[ ,,,[44567191589,"JB"],]; CONWAYPOLDATA[58913]:=[ ,,,[26133924629,"JB"],]; CONWAYPOLDATA[58921]:=[ ,,,[3469386335,"JB"],]; CONWAYPOLDATA[58937]:=[ ,,,[40155487276,"JB"],]; CONWAYPOLDATA[58943]:=[ ,,,[23479767226,"JB"],]; CONWAYPOLDATA[58963]:=[ ,,,[23962268388,"JB"],]; CONWAYPOLDATA[58967]:=[ ,,,[27734597752,"JB"],]; CONWAYPOLDATA[58979]:=[ ,,,[26537483094,"JB"],]; CONWAYPOLDATA[58991]:=[ ,,,[17399159493,"JB"],]; CONWAYPOLDATA[58997]:=[ ,,,[51175944704,"JB"],]; CONWAYPOLDATA[59009]:=[ ,,,[16392169122,"JB"],]; CONWAYPOLDATA[59011]:=[ ,,,[30587171632,"JB"],]; CONWAYPOLDATA[59021]:=[ ,,,[23505467378,"JB"],]; CONWAYPOLDATA[59023]:=[ ,,,[66189631688,"JB"],]; CONWAYPOLDATA[59029]:=[ ,,,[27466961079,"JB"],]; CONWAYPOLDATA[59051]:=[ ,,,[24408435605,"JB"],]; CONWAYPOLDATA[59053]:=[ ,,,[26916652680,"JB"],]; CONWAYPOLDATA[59063]:=[ ,,,[13953515629,"JB"],]; CONWAYPOLDATA[59069]:=[ ,,,[6304316234,"JB"],]; CONWAYPOLDATA[59077]:=[ ,,,[5385223017,"JB"],]; CONWAYPOLDATA[59083]:=[ ,,,[8817546922,"JB"],]; CONWAYPOLDATA[59093]:=[ ,,,[50999209072,"JB"],]; CONWAYPOLDATA[59107]:=[ ,,,[6168938485,"JB"],]; CONWAYPOLDATA[59113]:=[ ,,,[72807472265,"JB"],]; CONWAYPOLDATA[59119]:=[ ,,,[26958973431,"JB"],]; CONWAYPOLDATA[59123]:=[ ,,,[13806048224,"JB"],]; CONWAYPOLDATA[59141]:=[ ,,,[51326108263,"JB"],]; CONWAYPOLDATA[59149]:=[ ,,,[13940591216,"JB"],]; CONWAYPOLDATA[59159]:=[ ,,,[17498403981,"JB"],]; CONWAYPOLDATA[59167]:=[ ,,,[17503432780,"JB"],]; CONWAYPOLDATA[59183]:=[ ,,,[27310113721,"JB"],]; CONWAYPOLDATA[59197]:=[ ,,,[12328189631,"JB"],]; CONWAYPOLDATA[59207]:=[ ,,,[20188462072,"JB"],]; CONWAYPOLDATA[59209]:=[ ,,,[36826044114,"JB"],]; CONWAYPOLDATA[59219]:=[ ,,,[10074158625,"JB"],]; CONWAYPOLDATA[59221]:=[ ,,,[23750463610,"JB"],]; CONWAYPOLDATA[59233]:=[ ,,,[23372986407,"JB"],]; CONWAYPOLDATA[59239]:=[ ,,,[23216652688,"JB"],]; CONWAYPOLDATA[59243]:=[ ,,,[31281370376,"JB"],]; CONWAYPOLDATA[59263]:=[ ,,,[20833374286,"JB"],]; CONWAYPOLDATA[59273]:=[ ,,,[41054317266,"JB"],]; CONWAYPOLDATA[59281]:=[ ,,,[3372081130,"JB"],]; CONWAYPOLDATA[59333]:=[ ,,,[23995689194,"JB"],]; CONWAYPOLDATA[59341]:=[ ,,,[27825410301,"JB"],]; CONWAYPOLDATA[59351]:=[ ,,,[23416996414,"JB"],]; CONWAYPOLDATA[59357]:=[ ,,,[27115108600,"JB"],]; CONWAYPOLDATA[59359]:=[ ,,,[10507433391,"JB"],]; CONWAYPOLDATA[59369]:=[ ,,,[17004231507,"JB"],]; CONWAYPOLDATA[59377]:=[ ,,,[24574062110,"JB"],]; CONWAYPOLDATA[59387]:=[ ,,,[26679372204,"JB"],]; CONWAYPOLDATA[59393]:=[ ,,,[30138027567,"JB"],]; CONWAYPOLDATA[59399]:=[ ,,,[9188193721,"JB"],]; CONWAYPOLDATA[59407]:=[ ,,,[19429712830,"JB"],]; CONWAYPOLDATA[59417]:=[ ,,,[16502418166,"JB"],]; CONWAYPOLDATA[59419]:=[ ,,,[31775142118,"JB"],]; CONWAYPOLDATA[59441]:=[ ,,,[16538388315,"JB"],]; CONWAYPOLDATA[59443]:=[ ,,,[37401178944,"JB"],]; CONWAYPOLDATA[59447]:=[ ,,,[31493296642,"JB"],]; CONWAYPOLDATA[59453]:=[ ,,,[34888863445,"JB"],]; CONWAYPOLDATA[59467]:=[ ,,,[30705131315,"JB"],]; CONWAYPOLDATA[59471]:=[ ,,,[28097668671,"JB"],]; CONWAYPOLDATA[59473]:=[ ,,,[23550832226,"JB"],]; CONWAYPOLDATA[59497]:=[ ,,,[116207458020,"JB"],]; CONWAYPOLDATA[59509]:=[ ,,,[10005843270,"JB"],]; CONWAYPOLDATA[59513]:=[ ,,,[5980580399,"JB"],]; CONWAYPOLDATA[59539]:=[ ,,,[10037441856,"JB"],]; CONWAYPOLDATA[59557]:=[ ,,,[23759907810,"JB"],]; CONWAYPOLDATA[59561]:=[ ,,,[27190728162,"JB"],]; CONWAYPOLDATA[59567]:=[ ,,,[9777863488,"JB"],]; CONWAYPOLDATA[59581]:=[ ,,,[27483285362,"JB"],]; CONWAYPOLDATA[59611]:=[ ,,,[27205387404,"JB"],]; CONWAYPOLDATA[59617]:=[ ,,,[38818715302,"JB"],]; CONWAYPOLDATA[59621]:=[ ,,,[17562856078,"JB"],]; CONWAYPOLDATA[59627]:=[ ,,,[28309587808,"JB"],]; CONWAYPOLDATA[59629]:=[ ,,,[24810911354,"JB"],]; CONWAYPOLDATA[59651]:=[ ,,,[6395064410,"JB"],]; CONWAYPOLDATA[59659]:=[ ,,,[21018760588,"JB"],]; CONWAYPOLDATA[59663]:=[ ,,,[38171552123,"JB"],]; CONWAYPOLDATA[59669]:=[ ,,,[44729374127,"JB"],]; CONWAYPOLDATA[59671]:=[ ,,,[12955588519,"JB"],]; CONWAYPOLDATA[59693]:=[ ,,,[9207824331,"JB"],]; CONWAYPOLDATA[59699]:=[ ,,,[8977953515,"JB"],]; CONWAYPOLDATA[59707]:=[ ,,,[20618797434,"JB"],]; CONWAYPOLDATA[59723]:=[ ,,,[6816245715,"JB"],]; CONWAYPOLDATA[59729]:=[ ,,,[10531178367,"JB"],]; CONWAYPOLDATA[59743]:=[ ,,,[20256401840,"JB"],]; CONWAYPOLDATA[59747]:=[ ,,,[10207655458,"JB"],]; CONWAYPOLDATA[59753]:=[ ,,,[21277923799,"JB"],]; CONWAYPOLDATA[59771]:=[ ,,,[32152733574,"JB"],]; CONWAYPOLDATA[59779]:=[ ,,,[21402496043,"JB"],]; CONWAYPOLDATA[59791]:=[ ,,,[12885618204,"JB"],]; CONWAYPOLDATA[59797]:=[ ,,,[27441979445,"JB"],]; CONWAYPOLDATA[59809]:=[ ,,,[109832410291,"JB"],]; CONWAYPOLDATA[59833]:=[ ,,,[42171973729,"JB"],]; CONWAYPOLDATA[59863]:=[ ,,,[59318186842,"JB"],]; CONWAYPOLDATA[59879]:=[ ,,,[9887280373,"JB"],]; CONWAYPOLDATA[59887]:=[ ,,,[14224959113,"JB"],]; CONWAYPOLDATA[59921]:=[ ,,,[6886960217,"JB"],]; CONWAYPOLDATA[59929]:=[ ,,,[82106205901,"JB"],]; CONWAYPOLDATA[59951]:=[ ,,,[25009159171,"JB"],]; CONWAYPOLDATA[59957]:=[ ,,,[20918757474,"JB"],]; CONWAYPOLDATA[59971]:=[ ,,,[28719212338,"JB"],]; CONWAYPOLDATA[59981]:=[ ,,,[46022041739,"JB"],]; CONWAYPOLDATA[59999]:=[ ,,,[14291521811,"JB"],]; CONWAYPOLDATA[60013]:=[ ,,,[17539879490,"JB"],]; CONWAYPOLDATA[60017]:=[ ,,,[5494016200,"JB"],]; CONWAYPOLDATA[60029]:=[ ,,,[28340051076,"JB"],]; CONWAYPOLDATA[60037]:=[ ,,,[13126669793,"JB"],]; CONWAYPOLDATA[60041]:=[ ,,,[10316724951,"JB"],]; CONWAYPOLDATA[60077]:=[ ,,,[13195252205,"JB"],]; CONWAYPOLDATA[60083]:=[ ,,,[2821257350,"JB"],]; CONWAYPOLDATA[60089]:=[ ,,,[17028801980,"JB"],]; CONWAYPOLDATA[60091]:=[ ,,,[24268892081,"JB"],]; CONWAYPOLDATA[60101]:=[ ,,,[18060410604,"JB"],]; CONWAYPOLDATA[60103]:=[ ,,,[43347726077,"JB"],]; CONWAYPOLDATA[60107]:=[ ,,,[17929196818,"JB"],]; CONWAYPOLDATA[60127]:=[ ,,,[24443188805,"JB"],]; CONWAYPOLDATA[60133]:=[ ,,,[28656321023,"JB"],]; CONWAYPOLDATA[60139]:=[ ,,,[23986380014,"JB"],]; CONWAYPOLDATA[60149]:=[ ,,,[32560698768,"JB"],]; CONWAYPOLDATA[60161]:=[ ,,,[3618623992,"JB"],]; CONWAYPOLDATA[60167]:=[ ,,,[9896268165,"JB"],]; CONWAYPOLDATA[60169]:=[ ,,,[53167795340,"JB"],]; CONWAYPOLDATA[60209]:=[ ,,,[16900907139,"JB"],]; CONWAYPOLDATA[60217]:=[ ,,,[45693803728,"JB"],]; CONWAYPOLDATA[60223]:=[ ,,,[39894425238,"JB"],]; CONWAYPOLDATA[60251]:=[ ,,,[10616647963,"JB"],]; CONWAYPOLDATA[60257]:=[ ,,,[28954874414,"JB"],]; CONWAYPOLDATA[60259]:=[ ,,,[23706794488,"JB"],]; CONWAYPOLDATA[60271]:=[ ,,,[38542219625,"JB"],]; CONWAYPOLDATA[60289]:=[ ,,,[61542830340,"JB"],]; CONWAYPOLDATA[60293]:=[ ,,,[3351627579,"JB"],]; CONWAYPOLDATA[60317]:=[ ,,,[16730307243,"JB"],]; CONWAYPOLDATA[60331]:=[ ,,,[20051369848,"JB"],]; CONWAYPOLDATA[60337]:=[ ,,,[46898924376,"JB"],]; CONWAYPOLDATA[60343]:=[ ,,,[20660055314,"JB"],]; CONWAYPOLDATA[60353]:=[ ,,,[17205071125,"JB"],]; CONWAYPOLDATA[60373]:=[ ,,,[24958258575,"JB"],]; CONWAYPOLDATA[60383]:=[ ,,,[25284415127,"JB"],]; CONWAYPOLDATA[60397]:=[ ,,,[27728443896,"JB"],]; CONWAYPOLDATA[60413]:=[ ,,,[71883616312,"JB"],]; CONWAYPOLDATA[60427]:=[ ,,,[20319908147,"JB"],]; CONWAYPOLDATA[60443]:=[ ,,,[16565975670,"JB"],]; CONWAYPOLDATA[60449]:=[ ,,,[10033143676,"JB"],]; CONWAYPOLDATA[60457]:=[ ,,,[42881061887,"JB"],]; CONWAYPOLDATA[60493]:=[ ,,,[25582550195,"JB"],]; CONWAYPOLDATA[60497]:=[ ,,,[25324225694,"JB"],]; CONWAYPOLDATA[60509]:=[ ,,,[24628131146,"JB"],]; CONWAYPOLDATA[60521]:=[ ,,,[17657667484,"JB"],]; CONWAYPOLDATA[60527]:=[ ,,,[18022761633,"JB"],]; CONWAYPOLDATA[60539]:=[ ,,,[29159335820,"JB"],]; CONWAYPOLDATA[60589]:=[ ,,,[10103821642,"JB"],]; CONWAYPOLDATA[60601]:=[ ,,,[62337824671,"JB"],]; CONWAYPOLDATA[60607]:=[ ,,,[21198389179,"JB"],]; CONWAYPOLDATA[60611]:=[ ,,,[17456513509,"JB"],]; CONWAYPOLDATA[60617]:=[ ,,,[2270591589,"JB"],]; CONWAYPOLDATA[60623]:=[ ,,,[9668944144,"JB"],]; CONWAYPOLDATA[60631]:=[ ,,,[16994808675,"JB"],]; CONWAYPOLDATA[60637]:=[ ,,,[35670806718,"JB"],]; CONWAYPOLDATA[60647]:=[ ,,,[35011209870,"JB"],]; CONWAYPOLDATA[60649]:=[ ,,,[91759935594,"JB"],]; CONWAYPOLDATA[60659]:=[ ,,,[31704396896,"JB"],]; CONWAYPOLDATA[60661]:=[ ,,,[13998314345,"JB"],]; CONWAYPOLDATA[60679]:=[ ,,,[13218252684,"JB"],]; CONWAYPOLDATA[60689]:=[ ,,,[28747286901,"JB"],]; CONWAYPOLDATA[60703]:=[ ,,,[65217907034,"JB"],]; CONWAYPOLDATA[60719]:=[ ,,,[25740666396,"JB"],]; CONWAYPOLDATA[60727]:=[ ,,,[46779404826,"JB"],]; CONWAYPOLDATA[60733]:=[ ,,,[39396768306,"JB"],]; CONWAYPOLDATA[60737]:=[ ,,,[25123191946,"JB"],]; CONWAYPOLDATA[60757]:=[ ,,,[35491809122,"JB"],]; CONWAYPOLDATA[60761]:=[ ,,,[2116062592,"JB"],]; CONWAYPOLDATA[60763]:=[ ,,,[21422907098,"JB"],]; CONWAYPOLDATA[60773]:=[ ,,,[6972607838,"JB"],]; CONWAYPOLDATA[60779]:=[ ,,,[17405403790,"JB"],]; CONWAYPOLDATA[60793]:=[ ,,,[24735091087,"JB"],]; CONWAYPOLDATA[60811]:=[ ,,,[32571587822,"JB"],]; CONWAYPOLDATA[60821]:=[ ,,,[14631099762,"JB"],]; CONWAYPOLDATA[60859]:=[ ,,,[13112558425,"JB"],]; CONWAYPOLDATA[60869]:=[ ,,,[28561013051,"JB"],]; CONWAYPOLDATA[60887]:=[ ,,,[39600417711,"JB"],]; CONWAYPOLDATA[60889]:=[ ,,,[31540623799,"JB"],]; CONWAYPOLDATA[60899]:=[ ,,,[6203598435,"JB"],]; CONWAYPOLDATA[60901]:=[ ,,,[25877504813,"JB"],]; CONWAYPOLDATA[60913]:=[ ,,,[24532893494,"JB"],]; CONWAYPOLDATA[60917]:=[ ,,,[14589256000,"JB"],]; CONWAYPOLDATA[60919]:=[ ,,,[25569958306,"JB"],]; CONWAYPOLDATA[60923]:=[ ,,,[13825012700,"JB"],]; CONWAYPOLDATA[60937]:=[ ,,,[81098859578,"JB"],]; CONWAYPOLDATA[60943]:=[ ,,,[9338844382,"JB"],]; CONWAYPOLDATA[60953]:=[ ,,,[17193927008,"JB"],]; CONWAYPOLDATA[60961]:=[ ,,,[2813533040,"JB"],]; CONWAYPOLDATA[61001]:=[ ,,,[29422124325,"JB"],]; CONWAYPOLDATA[61007]:=[ ,,,[55137943584,"JB"],]; CONWAYPOLDATA[61027]:=[ ,,,[32297319212,"JB"],]; CONWAYPOLDATA[61031]:=[ ,,,[32837729572,"JB"],]; CONWAYPOLDATA[61043]:=[ ,,,[77081804080,"JB"],]; CONWAYPOLDATA[61051]:=[ ,,,[6981975516,"JB"],]; CONWAYPOLDATA[61057]:=[ ,,,[24286642895,"JB"],]; CONWAYPOLDATA[61091]:=[ ,,,[28817418885,"JB"],]; CONWAYPOLDATA[61099]:=[ ,,,[24505648021,"JB"],]; CONWAYPOLDATA[61121]:=[ ,,,[10475589314,"JB"],]; CONWAYPOLDATA[61129]:=[ ,,,[10300297636,"JB"],]; CONWAYPOLDATA[61141]:=[ ,,,[29426979883,"JB"],]; CONWAYPOLDATA[61151]:=[ ,,,[11145809348,"JB"],]; CONWAYPOLDATA[61153]:=[ ,,,[32229098682,"JB"],]; CONWAYPOLDATA[61169]:=[ ,,,[3740912536,"JB"],]; CONWAYPOLDATA[61211]:=[ ,,,[10546532880,"JB"],]; CONWAYPOLDATA[61223]:=[ ,,,[20868777900,"JB"],]; CONWAYPOLDATA[61231]:=[ ,,,[2450525858,"JB"],]; CONWAYPOLDATA[61253]:=[ ,,,[85217623722,"JB"],]; CONWAYPOLDATA[61261]:=[ ,,,[40070513797,"JB"],]; CONWAYPOLDATA[61283]:=[ ,,,[40195397136,"JB"],]; CONWAYPOLDATA[61291]:=[ ,,,[11067315873,"JB"],]; CONWAYPOLDATA[61297]:=[ ,,,[32323930908,"JB"],]; CONWAYPOLDATA[61331]:=[ ,,,[33445020922,"JB"],]; CONWAYPOLDATA[61333]:=[ ,,,[13399052514,"JB"],]; CONWAYPOLDATA[61339]:=[ ,,,[24659750138,"JB"],]; CONWAYPOLDATA[61343]:=[ ,,,[32527003069,"JB"],]; CONWAYPOLDATA[61357]:=[ ,,,[39682087543,"JB"],]; CONWAYPOLDATA[61363]:=[ ,,,[9606868557,"JB"],]; CONWAYPOLDATA[61379]:=[ ,,,[18802904241,"JB"],]; CONWAYPOLDATA[61381]:=[ ,,,[28851893532,"JB"],]; CONWAYPOLDATA[61403]:=[ ,,,[40306280068,"JB"],]; CONWAYPOLDATA[61409]:=[ ,,,[29747072284,"JB"],]; CONWAYPOLDATA[61417]:=[ ,,,[55421349631,"JB"],]; CONWAYPOLDATA[61441]:=[ ,,,[47444678776,"JB"],]; CONWAYPOLDATA[61463]:=[ ,,,[56408713126,"JB"],]; CONWAYPOLDATA[61469]:=[ ,,,[78993381619,"JB"],]; CONWAYPOLDATA[61471]:=[ ,,,[25875664214,"JB"],]; CONWAYPOLDATA[61483]:=[ ,,,[10035255262,"JB"],]; CONWAYPOLDATA[61487]:=[ ,,,[15122358733,"JB"],]; CONWAYPOLDATA[61493]:=[ ,,,[81316928863,"JB"],]; CONWAYPOLDATA[61507]:=[ ,,,[10374262678,"JB"],]; CONWAYPOLDATA[61511]:=[ ,,,[14992937191,"JB"],]; CONWAYPOLDATA[61519]:=[ ,,,[10196220582,"JB"],]; CONWAYPOLDATA[61543]:=[ ,,,[14169352608,"JB"],]; CONWAYPOLDATA[61547]:=[ ,,,[28794333123,"JB"],]; CONWAYPOLDATA[61553]:=[ ,,,[1911466865,"JB"],]; CONWAYPOLDATA[61559]:=[ ,,,[18559053563,"JB"],]; CONWAYPOLDATA[61561]:=[ ,,,[2338948641,"JB"],]; CONWAYPOLDATA[61583]:=[ ,,,[25339372266,"JB"],]; CONWAYPOLDATA[61603]:=[ ,,,[10726437568,"JB"],]; CONWAYPOLDATA[61609]:=[ ,,,[101570260856,"JB"],]; CONWAYPOLDATA[61613]:=[ ,,,[14520643777,"JB"],]; CONWAYPOLDATA[61627]:=[ ,,,[14436309634,"JB"],]; CONWAYPOLDATA[61631]:=[ ,,,[10706968748,"JB"],]; CONWAYPOLDATA[61637]:=[ ,,,[2740257748,"JB"],]; CONWAYPOLDATA[61643]:=[ ,,,[32971299627,"JB"],]; CONWAYPOLDATA[61651]:=[ ,,,[33157387426,"JB"],]; CONWAYPOLDATA[61657]:=[ ,,,[26409727786,"JB"],]; CONWAYPOLDATA[61667]:=[ ,,,[32774283826,"JB"],]; CONWAYPOLDATA[61673]:=[ ,,,[2935943170,"JB"],]; CONWAYPOLDATA[61681]:=[ ,,,[140616519607,"JB"],]; CONWAYPOLDATA[61687]:=[ ,,,[21823195057,"JB"],]; CONWAYPOLDATA[61703]:=[ ,,,[17805449606,"JB"],]; CONWAYPOLDATA[61717]:=[ ,,,[14955325159,"JB"],]; CONWAYPOLDATA[61723]:=[ ,,,[15238668029,"JB"],]; CONWAYPOLDATA[61729]:=[ ,,,[2365146642,"JB"],]; CONWAYPOLDATA[61751]:=[ ,,,[25189591429,"JB"],]; CONWAYPOLDATA[61757]:=[ ,,,[18444530893,"JB"],]; CONWAYPOLDATA[61781]:=[ ,,,[68054180961,"JB"],]; CONWAYPOLDATA[61813]:=[ ,,,[25890684117,"JB"],]; CONWAYPOLDATA[61819]:=[ ,,,[2441850503,"JB"],]; CONWAYPOLDATA[61837]:=[ ,,,[3468808358,"JB"],]; CONWAYPOLDATA[61843]:=[ ,,,[34420576942,"JB"],]; CONWAYPOLDATA[61861]:=[ ,,,[48591877363,"JB"],]; CONWAYPOLDATA[61871]:=[ ,,,[26666462890,"JB"],]; CONWAYPOLDATA[61879]:=[ ,,,[13438448070,"JB"],]; CONWAYPOLDATA[61909]:=[ ,,,[10474074171,"JB"],]; CONWAYPOLDATA[61927]:=[ ,,,[21698911168,"JB"],]; CONWAYPOLDATA[61933]:=[ ,,,[15320985545,"JB"],]; CONWAYPOLDATA[61949]:=[ ,,,[14816590128,"JB"],]; CONWAYPOLDATA[61961]:=[ ,,,[3838421992,"JB"],]; CONWAYPOLDATA[61967]:=[ ,,,[11433841010,"JB"],]; CONWAYPOLDATA[61979]:=[ ,,,[18088757089,"JB"],]; CONWAYPOLDATA[61981]:=[ ,,,[18023764902,"JB"],]; CONWAYPOLDATA[61987]:=[ ,,,[56632438968,"JB"],]; CONWAYPOLDATA[61991]:=[ ,,,[29933532192,"JB"],]; CONWAYPOLDATA[62003]:=[ ,,,[34537593095,"JB"],]; CONWAYPOLDATA[62011]:=[ ,,,[25218509460,"JB"],]; CONWAYPOLDATA[62017]:=[ ,,,[26395613533,"JB"],]; CONWAYPOLDATA[62039]:=[ ,,,[19080652818,"JB"],]; CONWAYPOLDATA[62047]:=[ ,,,[22922085260,"JB"],]; CONWAYPOLDATA[62053]:=[ ,,,[30153538398,"JB"],]; CONWAYPOLDATA[62057]:=[ ,,,[7070960754,"JB"],]; CONWAYPOLDATA[62071]:=[ ,,,[13949215837,"JB"],]; CONWAYPOLDATA[62081]:=[ ,,,[2878944300,"JB"],]; CONWAYPOLDATA[62099]:=[ ,,,[29754735852,"JB"],]; CONWAYPOLDATA[62119]:=[ ,,,[22538574658,"JB"],]; CONWAYPOLDATA[62129]:=[ ,,,[10300677558,"JB"],]; CONWAYPOLDATA[62131]:=[ ,,,[7030184783,"JB"],]; CONWAYPOLDATA[62137]:=[ ,,,[57028158004,"JB"],]; CONWAYPOLDATA[62141]:=[ ,,,[26021854457,"JB"],]; CONWAYPOLDATA[62143]:=[ ,,,[14232052006,"JB"],]; CONWAYPOLDATA[62171]:=[ ,,,[2826728859,"JB"],]; CONWAYPOLDATA[62189]:=[ ,,,[26091457141,"JB"],]; CONWAYPOLDATA[62191]:=[ ,,,[9988185558,"JB"],]; CONWAYPOLDATA[62201]:=[ ,,,[3868217992,"JB"],]; CONWAYPOLDATA[62207]:=[ ,,,[38501467480,"JB"],]; CONWAYPOLDATA[62213]:=[ ,,,[48551585119,"JB"],]; CONWAYPOLDATA[62219]:=[ ,,,[11575596076,"JB"],]; CONWAYPOLDATA[62233]:=[ ,,,[41360798603,"JB"],]; CONWAYPOLDATA[62273]:=[ ,,,[17689019291,"JB"],]; CONWAYPOLDATA[62297]:=[ ,,,[6538693123,"JB"],]; CONWAYPOLDATA[62299]:=[ ,,,[68476880337,"JB"],]; CONWAYPOLDATA[62303]:=[ ,,,[11125945139,"JB"],]; CONWAYPOLDATA[62311]:=[ ,,,[18972266353,"JB"],]; CONWAYPOLDATA[62323]:=[ ,,,[33966159648,"JB"],]; CONWAYPOLDATA[62327]:=[ ,,,[25905033342,"JB"],]; CONWAYPOLDATA[62347]:=[ ,,,[10599301738,"JB"],]; CONWAYPOLDATA[62351]:=[ ,,,[14834238172,"JB"],]; CONWAYPOLDATA[62383]:=[ ,,,[15566305229,"JB"],]; CONWAYPOLDATA[62401]:=[ ,,,[68311061128,"JB"],]; CONWAYPOLDATA[62417]:=[ ,,,[38550986215,"JB"],]; CONWAYPOLDATA[62423]:=[ ,,,[10761038552,"JB"],]; CONWAYPOLDATA[62459]:=[ ,,,[9879389872,"JB"],]; CONWAYPOLDATA[62467]:=[ ,,,[46409795186,"JB"],]; CONWAYPOLDATA[62473]:=[ ,,,[60974397681,"JB"],]; CONWAYPOLDATA[62477]:=[ ,,,[45287952900,"JB"],]; CONWAYPOLDATA[62483]:=[ ,,,[33870284778,"JB"],]; CONWAYPOLDATA[62497]:=[ ,,,[50487014017,"JB"],]; CONWAYPOLDATA[62501]:=[ ,,,[14578483254,"JB"],]; CONWAYPOLDATA[62507]:=[ ,,,[29977919653,"JB"],]; CONWAYPOLDATA[62533]:=[ ,,,[26564768798,"JB"],]; CONWAYPOLDATA[62539]:=[ ,,,[33258115124,"JB"],]; CONWAYPOLDATA[62549]:=[ ,,,[26259884123,"JB"],]; CONWAYPOLDATA[62563]:=[ ,,,[10117187859,"JB"],]; CONWAYPOLDATA[62581]:=[ ,,,[42899650988,"JB"],]; CONWAYPOLDATA[62591]:=[ ,,,[14736612820,"JB"],]; CONWAYPOLDATA[62597]:=[ ,,,[14518622988,"JB"],]; CONWAYPOLDATA[62603]:=[ ,,,[33799171893,"JB"],]; CONWAYPOLDATA[62617]:=[ ,,,[26927251132,"JB"],]; CONWAYPOLDATA[62627]:=[ ,,,[11728033038,"JB"],]; CONWAYPOLDATA[62633]:=[ ,,,[17926879896,"JB"],]; CONWAYPOLDATA[62639]:=[ ,,,[22103236024,"JB"],]; CONWAYPOLDATA[62653]:=[ ,,,[15480365895,"JB"],]; CONWAYPOLDATA[62659]:=[ ,,,[21640225538,"JB"],]; CONWAYPOLDATA[62683]:=[ ,,,[11752372990,"JB"],]; CONWAYPOLDATA[62687]:=[ ,,,[58520257802,"JB"],]; CONWAYPOLDATA[62701]:=[ ,,,[26050008266,"JB"],]; CONWAYPOLDATA[62723]:=[ ,,,[11604444955,"JB"],]; CONWAYPOLDATA[62731]:=[ ,,,[21994366844,"JB"],]; CONWAYPOLDATA[62743]:=[ ,,,[6055577909,"JB"],]; CONWAYPOLDATA[62753]:=[ ,,,[38462631516,"JB"],]; CONWAYPOLDATA[62761]:=[ ,,,[2644874069,"JB"],]; CONWAYPOLDATA[62773]:=[ ,,,[94437333303,"JB"],]; CONWAYPOLDATA[62791]:=[ ,,,[13820299103,"JB"],]; CONWAYPOLDATA[62801]:=[ ,,,[11471293464,"JB"],]; CONWAYPOLDATA[62819]:=[ ,,,[30179629620,"JB"],]; CONWAYPOLDATA[62827]:=[ ,,,[11164357903,"JB"],]; CONWAYPOLDATA[62851]:=[ ,,,[35551793854,"JB"],]; CONWAYPOLDATA[62861]:=[ ,,,[15054455171,"JB"],]; CONWAYPOLDATA[62869]:=[ ,,,[25936165869,"JB"],]; CONWAYPOLDATA[62873]:=[ ,,,[46297476648,"JB"],]; CONWAYPOLDATA[62897]:=[ ,,,[31137851720,"JB"],]; CONWAYPOLDATA[62903]:=[ ,,,[37754758023,"JB"],]; CONWAYPOLDATA[62921]:=[ ,,,[35579119911,"JB"],]; CONWAYPOLDATA[62927]:=[ ,,,[10317385071,"JB"],]; CONWAYPOLDATA[62929]:=[ ,,,[97977684138,"JB"],]; CONWAYPOLDATA[62939]:=[ ,,,[18560585224,"JB"],]; CONWAYPOLDATA[62969]:=[ ,,,[3964339336,"JB"],]; CONWAYPOLDATA[62971]:=[ ,,,[11252413942,"JB"],]; CONWAYPOLDATA[62981]:=[ ,,,[31328953737,"JB"],]; CONWAYPOLDATA[62983]:=[ ,,,[15867181229,"JB"],]; CONWAYPOLDATA[62987]:=[ ,,,[34518765612,"JB"],]; CONWAYPOLDATA[62989]:=[ ,,,[42376983554,"JB"],]; CONWAYPOLDATA[63029]:=[ ,,,[26251326386,"JB"],]; CONWAYPOLDATA[63031]:=[ ,,,[15186058833,"JB"],]; CONWAYPOLDATA[63059]:=[ ,,,[2691547299,"JB"],]; CONWAYPOLDATA[63067]:=[ ,,,[34676759282,"JB"],]; CONWAYPOLDATA[63073]:=[ ,,,[26764586044,"JB"],]; CONWAYPOLDATA[63079]:=[ ,,,[30554899892,"JB"],]; CONWAYPOLDATA[63097]:=[ ,,,[42559936057,"JB"],]; CONWAYPOLDATA[63103]:=[ ,,,[11687432839,"JB"],]; CONWAYPOLDATA[63113]:=[ ,,,[6410324300,"JB"],]; CONWAYPOLDATA[63127]:=[ ,,,[27139117954,"JB"],]; CONWAYPOLDATA[63131]:=[ ,,,[18587281546,"JB"],]; CONWAYPOLDATA[63149]:=[ ,,,[2316494769,"JB"],]; CONWAYPOLDATA[63179]:=[ ,,,[34430849169,"JB"],]; CONWAYPOLDATA[63197]:=[ ,,,[18182092887,"JB"],]; CONWAYPOLDATA[63199]:=[ ,,,[30806668548,"JB"],]; CONWAYPOLDATA[63211]:=[ ,,,[26385029939,"JB"],]; CONWAYPOLDATA[63241]:=[ ,,,[3256532061,"JB"],]; CONWAYPOLDATA[63247]:=[ ,,,[23773914835,"JB"],]; CONWAYPOLDATA[63277]:=[ ,,,[26290897455,"JB"],]; CONWAYPOLDATA[63281]:=[ ,,,[2750128985,"JB"],]; CONWAYPOLDATA[63299]:=[ ,,,[11847294038,"JB"],]; CONWAYPOLDATA[63311]:=[ ,,,[15278843647,"JB"],]; CONWAYPOLDATA[63313]:=[ ,,,[42296882785,"JB"],]; CONWAYPOLDATA[63317]:=[ ,,,[31712889305,"JB"],]; CONWAYPOLDATA[63331]:=[ ,,,[35920583230,"JB"],]; CONWAYPOLDATA[63337]:=[ ,,,[66597778776,"JB"],]; CONWAYPOLDATA[63347]:=[ ,,,[35514988776,"JB"],]; CONWAYPOLDATA[63353]:=[ ,,,[7982097885,"JB"],]; CONWAYPOLDATA[63361]:=[ ,,,[147496424551,"JB"],]; CONWAYPOLDATA[63367]:=[ ,,,[10196954276,"JB"],]; CONWAYPOLDATA[63377]:=[ ,,,[3341235443,"JB"],]; CONWAYPOLDATA[63389]:=[ ,,,[51268389312,"JB"],]; CONWAYPOLDATA[63391]:=[ ,,,[27466242656,"JB"],]; CONWAYPOLDATA[63397]:=[ ,,,[27636337227,"JB"],]; CONWAYPOLDATA[63409]:=[ ,,,[3963125916,"JB"],]; CONWAYPOLDATA[63419]:=[ ,,,[19069776207,"JB"],]; CONWAYPOLDATA[63421]:=[ ,,,[26738039918,"JB"],]; CONWAYPOLDATA[63439]:=[ ,,,[11960535307,"JB"],]; CONWAYPOLDATA[63443]:=[ ,,,[31386076861,"JB"],]; CONWAYPOLDATA[63463]:=[ ,,,[15845568771,"JB"],]; CONWAYPOLDATA[63467]:=[ ,,,[19323607091,"JB"],]; CONWAYPOLDATA[63473]:=[ ,,,[2700966572,"JB"],]; CONWAYPOLDATA[63487]:=[ ,,,[23016830931,"JB"],]; CONWAYPOLDATA[63493]:=[ ,,,[26236831434,"JB"],]; CONWAYPOLDATA[63499]:=[ ,,,[11431407478,"JB"],]; CONWAYPOLDATA[63521]:=[ ,,,[18944566564,"JB"],]; CONWAYPOLDATA[63527]:=[ ,,,[11826948649,"JB"],]; CONWAYPOLDATA[63533]:=[ ,,,[31168273275,"JB"],]; CONWAYPOLDATA[63541]:=[ ,,,[26719498830,"JB"],]; CONWAYPOLDATA[63559]:=[ ,,,[27735304392,"JB"],]; CONWAYPOLDATA[63577]:=[ ,,,[27610918912,"JB"],]; CONWAYPOLDATA[63587]:=[ ,,,[47687897283,"JB"],]; CONWAYPOLDATA[63589]:=[ ,,,[51337116605,"JB"],]; CONWAYPOLDATA[63599]:=[ ,,,[15269483917,"JB"],]; CONWAYPOLDATA[63601]:=[ ,,,[68743776867,"JB"],]; CONWAYPOLDATA[63607]:=[ ,,,[20228997820,"JB"],]; CONWAYPOLDATA[63611]:=[ ,,,[14176156629,"JB"],]; CONWAYPOLDATA[63617]:=[ ,,,[2728342282,"JB"],]; CONWAYPOLDATA[63629]:=[ ,,,[39899837032,"JB"],]; CONWAYPOLDATA[63647]:=[ ,,,[30883115580,"JB"],]; CONWAYPOLDATA[63649]:=[ ,,,[71967860658,"JB"],]; CONWAYPOLDATA[63659]:=[ ,,,[31229450268,"JB"],]; CONWAYPOLDATA[63667]:=[ ,,,[44435109312,"JB"],]; CONWAYPOLDATA[63671]:=[ ,,,[16119587081,"JB"],]; CONWAYPOLDATA[63689]:=[ ,,,[4055524456,"JB"],]; CONWAYPOLDATA[63691]:=[ ,,,[26546345124,"JB"],]; CONWAYPOLDATA[63697]:=[ ,,,[60858916473,"JB"],]; CONWAYPOLDATA[63703]:=[ ,,,[10940162114,"JB"],]; CONWAYPOLDATA[63709]:=[ ,,,[112909995399,"JB"],]; CONWAYPOLDATA[63719]:=[ ,,,[27527117765,"JB"],]; CONWAYPOLDATA[63727]:=[ ,,,[40393677591,"JB"],]; CONWAYPOLDATA[63737]:=[ ,,,[10977805935,"JB"],]; CONWAYPOLDATA[63743]:=[ ,,,[27203727601,"JB"],]; CONWAYPOLDATA[63761]:=[ ,,,[4064699992,"JB"],]; CONWAYPOLDATA[63773]:=[ ,,,[15487273052,"JB"],]; CONWAYPOLDATA[63781]:=[ ,,,[27363388403,"JB"],]; CONWAYPOLDATA[63793]:=[ ,,,[47727370885,"JB"],]; CONWAYPOLDATA[63799]:=[ ,,,[14347693317,"JB"],]; CONWAYPOLDATA[63803]:=[ ,,,[11055018206,"JB"],]; CONWAYPOLDATA[63809]:=[ ,,,[10600908218,"JB"],]; CONWAYPOLDATA[63823]:=[ ,,,[15075758479,"JB"],]; CONWAYPOLDATA[63839]:=[ ,,,[19638280887,"JB"],]; CONWAYPOLDATA[63841]:=[ ,,,[75418118480,"JB"],]; CONWAYPOLDATA[63853]:=[ ,,,[28322764388,"JB"],]; CONWAYPOLDATA[63857]:=[ ,,,[18973702699,"JB"],]; CONWAYPOLDATA[63863]:=[ ,,,[27715137019,"JB"],]; CONWAYPOLDATA[63901]:=[ ,,,[19044798443,"JB"],]; CONWAYPOLDATA[63907]:=[ ,,,[43189948277,"JB"],]; CONWAYPOLDATA[63913]:=[ ,,,[27752494612,"JB"],]; CONWAYPOLDATA[63929]:=[ ,,,[19633043406,"JB"],]; CONWAYPOLDATA[63949]:=[ ,,,[28508592100,"JB"],]; CONWAYPOLDATA[63977]:=[ ,,,[7139513318,"JB"],]; CONWAYPOLDATA[63997]:=[ ,,,[15428780744,"JB"],]; CONWAYPOLDATA[64007]:=[ ,,,[36071016841,"JB"],]; CONWAYPOLDATA[64013]:=[ ,,,[26937054480,"JB"],]; CONWAYPOLDATA[64019]:=[ ,,,[32232926312,"JB"],]; CONWAYPOLDATA[64033]:=[ ,,,[51902012188,"JB"],]; CONWAYPOLDATA[64037]:=[ ,,,[39476889392,"JB"],]; CONWAYPOLDATA[64063]:=[ ,,,[24144768136,"JB"],]; CONWAYPOLDATA[64067]:=[ ,,,[55510147418,"JB"],]; CONWAYPOLDATA[64081]:=[ ,,,[61052980518,"JB"],]; CONWAYPOLDATA[64091]:=[ ,,,[18954080069,"JB"],]; CONWAYPOLDATA[64109]:=[ ,,,[19147819686,"JB"],]; CONWAYPOLDATA[64123]:=[ ,,,[11769520160,"JB"],]; CONWAYPOLDATA[64151]:=[ ,,,[14796299865,"JB"],]; CONWAYPOLDATA[64153]:=[ ,,,[64652687722,"JB"],]; CONWAYPOLDATA[64157]:=[ ,,,[31273329652,"JB"],]; CONWAYPOLDATA[64171]:=[ ,,,[27216589553,"JB"],]; CONWAYPOLDATA[64187]:=[ ,,,[36654435661,"JB"],]; CONWAYPOLDATA[64189]:=[ ,,,[32359664761,"JB"],]; CONWAYPOLDATA[64217]:=[ ,,,[19462567278,"JB"],]; CONWAYPOLDATA[64223]:=[ ,,,[16498118029,"JB"],]; CONWAYPOLDATA[64231]:=[ ,,,[36127111348,"JB"],]; CONWAYPOLDATA[64237]:=[ ,,,[16023148808,"JB"],]; CONWAYPOLDATA[64271]:=[ ,,,[15371245180,"JB"],]; CONWAYPOLDATA[64279]:=[ ,,,[12255177053,"JB"],]; CONWAYPOLDATA[64283]:=[ ,,,[35138694877,"JB"],]; CONWAYPOLDATA[64301]:=[ ,,,[6536582458,"JB"],]; CONWAYPOLDATA[64303]:=[ ,,,[22763390612,"JB"],]; CONWAYPOLDATA[64319]:=[ ,,,[31701098500,"JB"],]; CONWAYPOLDATA[64327]:=[ ,,,[22819295656,"JB"],]; CONWAYPOLDATA[64333]:=[ ,,,[28055042305,"JB"],]; CONWAYPOLDATA[64373]:=[ ,,,[2738234303,"JB"],]; CONWAYPOLDATA[64381]:=[ ,,,[53257765870,"JB"],]; CONWAYPOLDATA[64399]:=[ ,,,[14948231484,"JB"],]; CONWAYPOLDATA[64403]:=[ ,,,[3447428192,"JB"],]; CONWAYPOLDATA[64433]:=[ ,,,[3604253157,"JB"],]; CONWAYPOLDATA[64439]:=[ ,,,[20669389208,"JB"],]; CONWAYPOLDATA[64451]:=[ ,,,[32577982521,"JB"],]; CONWAYPOLDATA[64453]:=[ ,,,[27436159683,"JB"],]; CONWAYPOLDATA[64483]:=[ ,,,[7419994329,"JB"],]; CONWAYPOLDATA[64489]:=[ ,,,[61728419384,"JB"],]; CONWAYPOLDATA[64499]:=[ ,,,[32370113132,"JB"],]; CONWAYPOLDATA[64513]:=[ ,,,[28234501533,"JB"],]; CONWAYPOLDATA[64553]:=[ ,,,[3873696427,"JB"],]; CONWAYPOLDATA[64567]:=[ ,,,[24102861103,"JB"],]; CONWAYPOLDATA[64577]:=[ ,,,[48213640242,"JB"],]; CONWAYPOLDATA[64579]:=[ ,,,[16345461534,"JB"],]; CONWAYPOLDATA[64591]:=[ ,,,[15999901204,"JB"],]; CONWAYPOLDATA[64601]:=[ ,,,[4172513992,"JB"],]; CONWAYPOLDATA[64609]:=[ ,,,[85933135876,"JB"],]; CONWAYPOLDATA[64613]:=[ ,,,[15365165241,"JB"],]; CONWAYPOLDATA[64621]:=[ ,,,[31908428144,"JB"],]; CONWAYPOLDATA[64627]:=[ ,,,[45468390482,"JB"],]; CONWAYPOLDATA[64633]:=[ ,,,[53867145828,"JB"],]; CONWAYPOLDATA[64661]:=[ ,,,[28475346521,"JB"],]; CONWAYPOLDATA[64663]:=[ ,,,[16274901150,"JB"],]; CONWAYPOLDATA[64667]:=[ ,,,[37240690630,"JB"],]; CONWAYPOLDATA[64679]:=[ ,,,[29019397589,"JB"],]; CONWAYPOLDATA[64693]:=[ ,,,[16581204060,"JB"],]; CONWAYPOLDATA[64709]:=[ ,,,[12033738606,"JB"],]; CONWAYPOLDATA[64717]:=[ ,,,[44655312455,"JB"],]; CONWAYPOLDATA[64747]:=[ ,,,[23306135884,"JB"],]; CONWAYPOLDATA[64763]:=[ ,,,[69953236348,"JB"],]; CONWAYPOLDATA[64781]:=[ ,,,[10898755442,"JB"],]; CONWAYPOLDATA[64783]:=[ ,,,[12173697450,"JB"],]; CONWAYPOLDATA[64793]:=[ ,,,[40468217564,"JB"],]; CONWAYPOLDATA[64811]:=[ ,,,[12208512883,"JB"],]; CONWAYPOLDATA[64817]:=[ ,,,[41653543164,"JB"],]; CONWAYPOLDATA[64849]:=[ ,,,[61566538180,"JB"],]; CONWAYPOLDATA[64853]:=[ ,,,[7967126199,"JB"],]; CONWAYPOLDATA[64871]:=[ ,,,[15173975617,"JB"],]; CONWAYPOLDATA[64877]:=[ ,,,[29184204806,"JB"],]; CONWAYPOLDATA[64879]:=[ ,,,[15355172452,"JB"],]; CONWAYPOLDATA[64891]:=[ ,,,[12588789119,"JB"],]; CONWAYPOLDATA[64901]:=[ ,,,[28709995768,"JB"],]; CONWAYPOLDATA[64919]:=[ ,,,[24597679269,"JB"],]; CONWAYPOLDATA[64921]:=[ ,,,[2137199327,"JB"],]; CONWAYPOLDATA[64927]:=[ ,,,[28896930039,"JB"],]; CONWAYPOLDATA[64937]:=[ ,,,[3475298369,"JB"],]; CONWAYPOLDATA[64951]:=[ ,,,[12098227920,"JB"],]; CONWAYPOLDATA[64969]:=[ ,,,[62556051353,"JB"],]; CONWAYPOLDATA[64997]:=[ ,,,[32981037730,"JB"],]; CONWAYPOLDATA[65003]:=[ ,,,[2235323169,"JB"],]; CONWAYPOLDATA[65011]:=[ ,,,[37537286391,"JB"],]; CONWAYPOLDATA[65027]:=[ ,,,[20483635056,"JB"],]; CONWAYPOLDATA[65029]:=[ ,,,[16381845566,"JB"],]; CONWAYPOLDATA[65033]:=[ ,,,[3812364529,"JB"],]; CONWAYPOLDATA[65053]:=[ ,,,[7945963743,"JB"],]; CONWAYPOLDATA[65063]:=[ ,,,[45664661744,"JB"],]; CONWAYPOLDATA[65071]:=[ ,,,[15321032024,"JB"],]; CONWAYPOLDATA[65089]:=[ ,,,[97440055499,"JB"],]; CONWAYPOLDATA[65099]:=[ ,,,[7744177042,"JB"],]; CONWAYPOLDATA[65101]:=[ ,,,[46411414316,"JB"],]; CONWAYPOLDATA[65111]:=[ ,,,[12313401661,"JB"],]; CONWAYPOLDATA[65119]:=[ ,,,[32799528637,"JB"],]; CONWAYPOLDATA[65123]:=[ ,,,[37553698936,"JB"],]; CONWAYPOLDATA[65129]:=[ ,,,[15152848014,"JB"],]; CONWAYPOLDATA[65141]:=[ ,,,[80582934616,"JB"],]; CONWAYPOLDATA[65147]:=[ ,,,[45136447482,"JB"],]; CONWAYPOLDATA[65167]:=[ ,,,[16986690893,"JB"],]; CONWAYPOLDATA[65171]:=[ ,,,[32064066831,"JB"],]; CONWAYPOLDATA[65173]:=[ ,,,[29267369458,"JB"],]; CONWAYPOLDATA[65179]:=[ ,,,[36559161818,"JB"],]; CONWAYPOLDATA[65183]:=[ ,,,[16995033229,"JB"],]; CONWAYPOLDATA[65203]:=[ ,,,[46201867757,"JB"],]; CONWAYPOLDATA[65213]:=[ ,,,[33984646331,"JB"],]; CONWAYPOLDATA[65239]:=[ ,,,[28071885030,"JB"],]; CONWAYPOLDATA[65257]:=[ ,,,[54312748535,"JB"],]; CONWAYPOLDATA[65267]:=[ ,,,[38337574734,"JB"],]; CONWAYPOLDATA[65269]:=[ ,,,[28770314126,"JB"],]; CONWAYPOLDATA[65287]:=[ ,,,[23955628339,"JB"],]; CONWAYPOLDATA[65293]:=[ ,,,[67948074554,"JB"],]; CONWAYPOLDATA[65309]:=[ ,,,[15373542675,"JB"],]; CONWAYPOLDATA[65323]:=[ ,,,[11871867345,"JB"],]; CONWAYPOLDATA[65327]:=[ ,,,[41143859183,"JB"],]; CONWAYPOLDATA[65353]:=[ ,,,[28328957033,"JB"],]; CONWAYPOLDATA[65357]:=[ ,,,[16621004029,"JB"],]; CONWAYPOLDATA[65371]:=[ ,,,[12363290377,"JB"],]; CONWAYPOLDATA[65381]:=[ ,,,[47020903726,"JB"],]; CONWAYPOLDATA[65393]:=[ ,,,[58228804495,"JB"],]; CONWAYPOLDATA[65407]:=[ ,,,[27877967764,"JB"],]; CONWAYPOLDATA[65413]:=[ ,,,[28491809589,"JB"],]; CONWAYPOLDATA[65419]:=[ ,,,[32133812803,"JB"],]; CONWAYPOLDATA[65423]:=[ ,,,[29336850819,"JB"],]; CONWAYPOLDATA[65437]:=[ ,,,[70835814254,"JB"],]; CONWAYPOLDATA[65447]:=[ ,,,[23687625397,"JB"],]; CONWAYPOLDATA[65449]:=[ ,,,[51401942937,"JB"],]; CONWAYPOLDATA[65479]:=[ ,,,[3848004400,"JB"],]; CONWAYPOLDATA[65497]:=[ ,,,[62820006623,"JB"],]; CONWAYPOLDATA[65519]:=[ ,,,[15597191075,"JB"],]; CONWAYPOLDATA[65521]:=[ ,,,[88619838878,"JB"],]; CONWAYPOLDATA[65537]:=[ ,,,[33213758381,"JB"],]; CONWAYPOLDATA[65539]:=[ ,,,[29278761784,"JB"],]; CONWAYPOLDATA[65543]:=[ ,,,[50188962368,"JB"],]; CONWAYPOLDATA[65551]:=[ ,,,[30078273009,"JB"],]; CONWAYPOLDATA[65557]:=[ ,,,[8260575347,"JB"],]; CONWAYPOLDATA[65563]:=[ ,,,[3901588570,"JB"],]; CONWAYPOLDATA[65579]:=[ ,,,[32720773210,"JB"],]; CONWAYPOLDATA[65581]:=[ ,,,[16614224961,"JB"],]; CONWAYPOLDATA[65587]:=[ ,,,[45619562548,"JB"],]; CONWAYPOLDATA[65599]:=[ ,,,[16103767315,"JB"],]; CONWAYPOLDATA[65609]:=[ ,,,[4303753576,"JB"],]; CONWAYPOLDATA[65617]:=[ ,,,[50432504426,"JB"],]; CONWAYPOLDATA[65629]:=[ ,,,[12846286091,"JB"],]; CONWAYPOLDATA[65633]:=[ ,,,[42251112487,"JB"],]; CONWAYPOLDATA[65647]:=[ ,,,[12222552345,"JB"],]; CONWAYPOLDATA[65651]:=[ ,,,[12458262017,"JB"],]; CONWAYPOLDATA[65657]:=[ ,,,[3598660173,"JB"],]; CONWAYPOLDATA[65677]:=[ ,,,[16364672415,"JB"],]; CONWAYPOLDATA[65687]:=[ ,,,[24139447009,"JB"],]; CONWAYPOLDATA[65699]:=[ ,,,[16817038731,"JB"],]; CONWAYPOLDATA[65701]:=[ ,,,[2348285148,"JB"],]; CONWAYPOLDATA[65707]:=[ ,,,[12731979685,"JB"],]; CONWAYPOLDATA[65713]:=[ ,,,[30057257636,"JB"],]; CONWAYPOLDATA[65717]:=[ ,,,[33959194035,"JB"],]; CONWAYPOLDATA[65719]:=[ ,,,[21594671932,"JB"],]; CONWAYPOLDATA[65729]:=[ ,,,[19755376785,"JB"],]; CONWAYPOLDATA[65731]:=[ ,,,[4072889963,"JB"],]; CONWAYPOLDATA[65761]:=[ ,,,[73492783821,"JB"],]; CONWAYPOLDATA[65777]:=[ ,,,[33654144283,"JB"],]; CONWAYPOLDATA[65789]:=[ ,,,[20740903298,"JB"],]; CONWAYPOLDATA[65809]:=[ ,,,[102020336452,"JB"],]; CONWAYPOLDATA[65827]:=[ ,,,[2742747784,"JB"],]; CONWAYPOLDATA[65831]:=[ ,,,[21556558474,"JB"],]; CONWAYPOLDATA[65837]:=[ ,,,[81721822177,"JB"],]; CONWAYPOLDATA[65839]:=[ ,,,[28522969100,"JB"],]; CONWAYPOLDATA[65843]:=[ ,,,[2402216014,"JB"],]; CONWAYPOLDATA[65851]:=[ ,,,[15934229877,"JB"],]; CONWAYPOLDATA[65867]:=[ ,,,[34381651864,"JB"],]; CONWAYPOLDATA[65881]:=[ ,,,[81206172350,"JB"],]; CONWAYPOLDATA[65899]:=[ ,,,[16772613483,"JB"],]; CONWAYPOLDATA[65921]:=[ ,,,[7921660652,"JB"],]; CONWAYPOLDATA[65927]:=[ ,,,[52155640829,"JB"],]; CONWAYPOLDATA[65929]:=[ ,,,[63832589665,"JB"],]; CONWAYPOLDATA[65951]:=[ ,,,[34676508205,"JB"],]; CONWAYPOLDATA[65957]:=[ ,,,[8461095876,"JB"],]; CONWAYPOLDATA[65963]:=[ ,,,[32978399741,"JB"],]; CONWAYPOLDATA[65981]:=[ ,,,[43302538530,"JB"],]; CONWAYPOLDATA[65983]:=[ ,,,[16509870365,"JB"],]; CONWAYPOLDATA[65993]:=[ ,,,[6825392021,"JB"],]; CONWAYPOLDATA[66029]:=[ ,,,[7141828700,"JB"],]; CONWAYPOLDATA[66037]:=[ ,,,[29300947087,"JB"],]; CONWAYPOLDATA[66041]:=[ ,,,[12123278455,"JB"],]; CONWAYPOLDATA[66047]:=[ ,,,[12019695394,"JB"],]; CONWAYPOLDATA[66067]:=[ ,,,[11471675682,"JB"],]; CONWAYPOLDATA[66071]:=[ ,,,[32762825005,"JB"],]; CONWAYPOLDATA[66083]:=[ ,,,[20355810824,"JB"],]; CONWAYPOLDATA[66089]:=[ ,,,[4366962856,"JB"],]; CONWAYPOLDATA[66103]:=[ ,,,[17351244267,"JB"],]; CONWAYPOLDATA[66107]:=[ ,,,[65106206129,"JB"],]; CONWAYPOLDATA[66109]:=[ ,,,[46866124500,"JB"],]; CONWAYPOLDATA[66137]:=[ ,,,[2435428891,"JB"],]; CONWAYPOLDATA[66161]:=[ ,,,[19911152953,"JB"],]; CONWAYPOLDATA[66169]:=[ ,,,[89856972662,"JB"],]; CONWAYPOLDATA[66173]:=[ ,,,[20735177206,"JB"],]; CONWAYPOLDATA[66179]:=[ ,,,[3060050783,"JB"],]; CONWAYPOLDATA[66191]:=[ ,,,[15793768330,"JB"],]; CONWAYPOLDATA[66221]:=[ ,,,[29187965288,"JB"],]; CONWAYPOLDATA[66239]:=[ ,,,[33258800634,"JB"],]; CONWAYPOLDATA[66271]:=[ ,,,[11030078972,"JB"],]; CONWAYPOLDATA[66293]:=[ ,,,[6818102466,"JB"],]; CONWAYPOLDATA[66301]:=[ ,,,[57144102611,"JB"],]; CONWAYPOLDATA[66337]:=[ ,,,[57003450442,"JB"],]; CONWAYPOLDATA[66343]:=[ ,,,[12338404802,"JB"],]; CONWAYPOLDATA[66347]:=[ ,,,[38692110768,"JB"],]; CONWAYPOLDATA[66359]:=[ ,,,[15912954572,"JB"],]; CONWAYPOLDATA[66361]:=[ ,,,[157739632490,"JB"],]; CONWAYPOLDATA[66373]:=[ ,,,[65982394897,"JB"],]; CONWAYPOLDATA[66377]:=[ ,,,[6876126187,"JB"],]; CONWAYPOLDATA[66383]:=[ ,,,[47147131712,"JB"],]; CONWAYPOLDATA[66403]:=[ ,,,[38395077841,"JB"],]; CONWAYPOLDATA[66413]:=[ ,,,[29067641842,"JB"],]; CONWAYPOLDATA[66431]:=[ ,,,[42625982605,"JB"],]; CONWAYPOLDATA[66449]:=[ ,,,[16503672337,"JB"],]; CONWAYPOLDATA[66457]:=[ ,,,[28881547635,"JB"],]; CONWAYPOLDATA[66463]:=[ ,,,[11995906880,"JB"],]; CONWAYPOLDATA[66467]:=[ ,,,[59964799260,"JB"],]; CONWAYPOLDATA[66491]:=[ ,,,[12012729499,"JB"],]; CONWAYPOLDATA[66499]:=[ ,,,[29637739815,"JB"],]; CONWAYPOLDATA[66509]:=[ ,,,[86849713508,"JB"],]; CONWAYPOLDATA[66523]:=[ ,,,[38509100334,"JB"],]; CONWAYPOLDATA[66529]:=[ ,,,[117370927522,"JB"],]; CONWAYPOLDATA[66533]:=[ ,,,[12122312602,"JB"],]; CONWAYPOLDATA[66541]:=[ ,,,[12202288586,"JB"],]; CONWAYPOLDATA[66553]:=[ ,,,[30433089638,"JB"],]; CONWAYPOLDATA[66569]:=[ ,,,[4125147795,"JB"],]; CONWAYPOLDATA[66571]:=[ ,,,[30992129057,"JB"],]; CONWAYPOLDATA[66587]:=[ ,,,[11953898003,"JB"],]; CONWAYPOLDATA[66593]:=[ ,,,[20899147565,"JB"],]; CONWAYPOLDATA[66601]:=[ ,,,[2817022504,"JB"],]; CONWAYPOLDATA[66617]:=[ ,,,[2487079081,"JB"],]; CONWAYPOLDATA[66629]:=[ ,,,[7479505026,"JB"],]; CONWAYPOLDATA[66643]:=[ ,,,[11368496086,"JB"],]; CONWAYPOLDATA[66653]:=[ ,,,[6921047563,"JB"],]; CONWAYPOLDATA[66683]:=[ ,,,[31125823964,"JB"],]; CONWAYPOLDATA[66697]:=[ ,,,[47897450100,"JB"],]; CONWAYPOLDATA[66701]:=[ ,,,[15991164547,"JB"],]; CONWAYPOLDATA[66713]:=[ ,,,[7869532196,"JB"],]; CONWAYPOLDATA[66721]:=[ ,,,[65768090691,"JB"],]; CONWAYPOLDATA[66733]:=[ ,,,[47857370753,"JB"],]; CONWAYPOLDATA[66739]:=[ ,,,[39037109360,"JB"],]; CONWAYPOLDATA[66749]:=[ ,,,[11685613935,"JB"],]; CONWAYPOLDATA[66751]:=[ ,,,[35290452691,"JB"],]; CONWAYPOLDATA[66763]:=[ ,,,[15671145467,"JB"],]; CONWAYPOLDATA[66791]:=[ ,,,[31033503083,"JB"],]; CONWAYPOLDATA[66797]:=[ ,,,[29879567245,"JB"],]; CONWAYPOLDATA[66809]:=[ ,,,[21803785246,"JB"],]; CONWAYPOLDATA[66821]:=[ ,,,[16689814351,"JB"],]; CONWAYPOLDATA[66841]:=[ ,,,[109614895342,"JB"],]; CONWAYPOLDATA[66851]:=[ ,,,[16973936859,"JB"],]; CONWAYPOLDATA[66853]:=[ ,,,[17436599462,"JB"],]; CONWAYPOLDATA[66863]:=[ ,,,[13086225776,"JB"],]; CONWAYPOLDATA[66877]:=[ ,,,[44092474244,"JB"],]; CONWAYPOLDATA[66883]:=[ ,,,[11242631004,"JB"],]; CONWAYPOLDATA[66889]:=[ ,,,[92175985133,"JB"],]; CONWAYPOLDATA[66919]:=[ ,,,[17681003591,"JB"],]; CONWAYPOLDATA[66923]:=[ ,,,[52041533261,"JB"],]; CONWAYPOLDATA[66931]:=[ ,,,[12279897504,"JB"],]; CONWAYPOLDATA[66943]:=[ ,,,[25268572555,"JB"],]; CONWAYPOLDATA[66947]:=[ ,,,[12462920469,"JB"],]; CONWAYPOLDATA[66949]:=[ ,,,[57784083604,"JB"],]; CONWAYPOLDATA[66959]:=[ ,,,[22416935781,"JB"],]; CONWAYPOLDATA[66973]:=[ ,,,[30993430077,"JB"],]; CONWAYPOLDATA[66977]:=[ ,,,[30085331658,"JB"],]; CONWAYPOLDATA[67003]:=[ ,,,[35469311109,"JB"],]; CONWAYPOLDATA[67021]:=[ ,,,[58358870862,"JB"],]; CONWAYPOLDATA[67033]:=[ ,,,[74595797131,"JB"],]; CONWAYPOLDATA[67043]:=[ ,,,[34544106881,"JB"],]; CONWAYPOLDATA[67049]:=[ ,,,[11420389124,"JB"],]; CONWAYPOLDATA[67057]:=[ ,,,[94369316105,"JB"],]; CONWAYPOLDATA[67061]:=[ ,,,[58424482056,"JB"],]; CONWAYPOLDATA[67073]:=[ ,,,[30112959937,"JB"],]; CONWAYPOLDATA[67079]:=[ ,,,[13001587186,"JB"],]; CONWAYPOLDATA[67103]:=[ ,,,[34226287773,"JB"],]; CONWAYPOLDATA[67121]:=[ ,,,[48012389637,"JB"],]; CONWAYPOLDATA[67129]:=[ ,,,[79772747157,"JB"],]; CONWAYPOLDATA[67139]:=[ ,,,[6905716125,"JB"],]; CONWAYPOLDATA[67141]:=[ ,,,[47913563268,"JB"],]; CONWAYPOLDATA[67153]:=[ ,,,[49160092338,"JB"],]; CONWAYPOLDATA[67157]:=[ ,,,[4299055357,"JB"],]; CONWAYPOLDATA[67169]:=[ ,,,[12022915158,"JB"],]; CONWAYPOLDATA[67181]:=[ ,,,[29780732673,"JB"],]; CONWAYPOLDATA[67187]:=[ ,,,[38741166381,"JB"],]; CONWAYPOLDATA[67189]:=[ ,,,[11373417981,"JB"],]; CONWAYPOLDATA[67211]:=[ ,,,[40625688952,"JB"],]; CONWAYPOLDATA[67213]:=[ ,,,[29400243249,"JB"],]; CONWAYPOLDATA[67217]:=[ ,,,[31394372023,"JB"],]; CONWAYPOLDATA[67219]:=[ ,,,[8018352864,"JB"],]; CONWAYPOLDATA[67231]:=[ ,,,[12232075374,"JB"],]; CONWAYPOLDATA[67247]:=[ ,,,[26863360836,"JB"],]; CONWAYPOLDATA[67261]:=[ ,,,[17250361411,"JB"],]; CONWAYPOLDATA[67271]:=[ ,,,[47689959147,"JB"],]; CONWAYPOLDATA[67273]:=[ ,,,[49492342469,"JB"],]; CONWAYPOLDATA[67289]:=[ ,,,[35744455115,"JB"],]; CONWAYPOLDATA[67307]:=[ ,,,[34273464779,"JB"],]; CONWAYPOLDATA[67339]:=[ ,,,[34426525041,"JB"],]; CONWAYPOLDATA[67343]:=[ ,,,[18140049229,"JB"],]; CONWAYPOLDATA[67349]:=[ ,,,[44209163233,"JB"],]; CONWAYPOLDATA[67369]:=[ ,,,[193195226592,"JB"],]; CONWAYPOLDATA[67391]:=[ ,,,[16323852373,"JB"],]; CONWAYPOLDATA[67399]:=[ ,,,[16158573258,"JB"],]; CONWAYPOLDATA[67409]:=[ ,,,[4543164376,"JB"],]; CONWAYPOLDATA[67411]:=[ ,,,[39103705471,"JB"],]; CONWAYPOLDATA[67421]:=[ ,,,[7200832486,"JB"],]; CONWAYPOLDATA[67427]:=[ ,,,[35527151448,"JB"],]; CONWAYPOLDATA[67429]:=[ ,,,[17859110084,"JB"],]; CONWAYPOLDATA[67433]:=[ ,,,[4185364014,"JB"],]; CONWAYPOLDATA[67447]:=[ ,,,[13165991638,"JB"],]; CONWAYPOLDATA[67453]:=[ ,,,[98648663442,"JB"],]; CONWAYPOLDATA[67477]:=[ ,,,[58331302376,"JB"],]; CONWAYPOLDATA[67481]:=[ ,,,[11403816636,"JB"],]; CONWAYPOLDATA[67489]:=[ ,,,[127389874308,"JB"],]; CONWAYPOLDATA[67493]:=[ ,,,[6852564292,"JB"],]; CONWAYPOLDATA[67499]:=[ ,,,[34222735491,"JB"],]; CONWAYPOLDATA[67511]:=[ ,,,[17186680347,"JB"],]; CONWAYPOLDATA[67523]:=[ ,,,[34928905149,"JB"],]; CONWAYPOLDATA[67531]:=[ ,,,[2729265375,"JB"],]; CONWAYPOLDATA[67537]:=[ ,,,[76108728508,"JB"],]; CONWAYPOLDATA[67547]:=[ ,,,[2514031795,"JB"],]; CONWAYPOLDATA[67559]:=[ ,,,[13532675738,"JB"],]; CONWAYPOLDATA[67567]:=[ ,,,[29866641013,"JB"],]; CONWAYPOLDATA[67577]:=[ ,,,[31913846446,"JB"],]; CONWAYPOLDATA[67579]:=[ ,,,[40955306851,"JB"],]; CONWAYPOLDATA[67589]:=[ ,,,[3971867587,"JB"],]; CONWAYPOLDATA[67601]:=[ ,,,[9114913237,"JB"],]; CONWAYPOLDATA[67607]:=[ ,,,[27339932770,"JB"],]; CONWAYPOLDATA[67619]:=[ ,,,[12170946669,"JB"],]; CONWAYPOLDATA[67631]:=[ ,,,[12608514968,"JB"],]; CONWAYPOLDATA[67651]:=[ ,,,[48497175334,"JB"],]; CONWAYPOLDATA[67679]:=[ ,,,[45746063452,"JB"],]; CONWAYPOLDATA[67699]:=[ ,,,[13222494789,"JB"],]; CONWAYPOLDATA[67709]:=[ ,,,[3448961044,"JB"],]; CONWAYPOLDATA[67723]:=[ ,,,[2625146654,"JB"],]; CONWAYPOLDATA[67733]:=[ ,,,[2498128508,"JB"],]; CONWAYPOLDATA[67741]:=[ ,,,[59654418131,"JB"],]; CONWAYPOLDATA[67751]:=[ ,,,[25653509657,"JB"],]; CONWAYPOLDATA[67757]:=[ ,,,[22954784220,"JB"],]; CONWAYPOLDATA[67759]:=[ ,,,[17862830863,"JB"],]; CONWAYPOLDATA[67763]:=[ ,,,[49339188984,"JB"],]; CONWAYPOLDATA[67777]:=[ ,,,[77169468888,"JB"],]; CONWAYPOLDATA[67783]:=[ ,,,[17674010555,"JB"],]; CONWAYPOLDATA[67789]:=[ ,,,[13394157360,"JB"],]; CONWAYPOLDATA[67801]:=[ ,,,[58212718193,"JB"],]; CONWAYPOLDATA[67807]:=[ ,,,[16842987575,"JB"],]; CONWAYPOLDATA[67819]:=[ ,,,[3166876034,"JB"],]; CONWAYPOLDATA[67829]:=[ ,,,[8943728455,"JB"],]; CONWAYPOLDATA[67843]:=[ ,,,[4072547461,"JB"],]; CONWAYPOLDATA[67853]:=[ ,,,[30444894719,"JB"],]; CONWAYPOLDATA[67867]:=[ ,,,[40544424472,"JB"],]; CONWAYPOLDATA[67883]:=[ ,,,[39748687003,"JB"],]; CONWAYPOLDATA[67891]:=[ ,,,[12411289495,"JB"],]; CONWAYPOLDATA[67901]:=[ ,,,[23052457404,"JB"],]; CONWAYPOLDATA[67927]:=[ ,,,[12847984491,"JB"],]; CONWAYPOLDATA[67931]:=[ ,,,[36916286784,"JB"],]; CONWAYPOLDATA[67933]:=[ ,,,[17295945601,"JB"],]; CONWAYPOLDATA[67939]:=[ ,,,[31532799829,"JB"],]; CONWAYPOLDATA[67943]:=[ ,,,[16681569194,"JB"],]; CONWAYPOLDATA[67957]:=[ ,,,[45528947421,"JB"],]; CONWAYPOLDATA[67961]:=[ ,,,[4617881992,"JB"],]; CONWAYPOLDATA[67967]:=[ ,,,[18477780493,"JB"],]; CONWAYPOLDATA[67979]:=[ ,,,[22922382844,"JB"],]; CONWAYPOLDATA[67987]:=[ ,,,[13201987610,"JB"],]; CONWAYPOLDATA[67993]:=[ ,,,[69344972817,"JB"],]; CONWAYPOLDATA[68023]:=[ ,,,[27657811688,"JB"],]; CONWAYPOLDATA[68041]:=[ ,,,[3608010129,"JB"],]; CONWAYPOLDATA[68053]:=[ ,,,[17340040511,"JB"],]; CONWAYPOLDATA[68059]:=[ ,,,[36600769022,"JB"],]; CONWAYPOLDATA[68071]:=[ ,,,[13600109309,"JB"],]; CONWAYPOLDATA[68087]:=[ ,,,[59783926529,"JB"],]; CONWAYPOLDATA[68099]:=[ ,,,[36317060504,"JB"],]; CONWAYPOLDATA[68111]:=[ ,,,[27023175479,"JB"],]; CONWAYPOLDATA[68113]:=[ ,,,[92165948034,"JB"],]; CONWAYPOLDATA[68141]:=[ ,,,[54908290367,"JB"],]; CONWAYPOLDATA[68147]:=[ ,,,[35937184158,"JB"],]; CONWAYPOLDATA[68161]:=[ ,,,[166777357228,"JB"],]; CONWAYPOLDATA[68171]:=[ ,,,[36180258490,"JB"],]; CONWAYPOLDATA[68207]:=[ ,,,[22540912951,"JB"],]; CONWAYPOLDATA[68209]:=[ ,,,[116209378538,"JB"],]; CONWAYPOLDATA[68213]:=[ ,,,[16326372274,"JB"],]; CONWAYPOLDATA[68219]:=[ ,,,[40564995753,"JB"],]; CONWAYPOLDATA[68227]:=[ ,,,[37157720515,"JB"],]; CONWAYPOLDATA[68239]:=[ ,,,[16890722000,"JB"],]; CONWAYPOLDATA[68261]:=[ ,,,[32377011434,"JB"],]; CONWAYPOLDATA[68279]:=[ ,,,[36324837681,"JB"],]; CONWAYPOLDATA[68281]:=[ ,,,[83547470830,"JB"],]; CONWAYPOLDATA[68311]:=[ ,,,[16458305858,"JB"],]; CONWAYPOLDATA[68329]:=[ ,,,[59082924718,"JB"],]; CONWAYPOLDATA[68351]:=[ ,,,[26063945092,"JB"],]; CONWAYPOLDATA[68371]:=[ ,,,[32691183431,"JB"],]; CONWAYPOLDATA[68389]:=[ ,,,[17002326070,"JB"],]; CONWAYPOLDATA[68399]:=[ ,,,[23330146518,"JB"],]; CONWAYPOLDATA[68437]:=[ ,,,[18552791643,"JB"],]; CONWAYPOLDATA[68443]:=[ ,,,[32790562204,"JB"],]; CONWAYPOLDATA[68447]:=[ ,,,[18739693453,"JB"],]; CONWAYPOLDATA[68449]:=[ ,,,[4189626399,"JB"],]; CONWAYPOLDATA[68473]:=[ ,,,[69683739596,"JB"],]; CONWAYPOLDATA[68477]:=[ ,,,[18493651869,"JB"],]; CONWAYPOLDATA[68483]:=[ ,,,[86877944700,"JB"],]; CONWAYPOLDATA[68489]:=[ ,,,[12441848721,"JB"],]; CONWAYPOLDATA[68491]:=[ ,,,[27902959446,"JB"],]; CONWAYPOLDATA[68501]:=[ ,,,[22846590525,"JB"],]; CONWAYPOLDATA[68507]:=[ ,,,[21939914808,"JB"],]; CONWAYPOLDATA[68521]:=[ ,,,[3028970812,"JB"],]; CONWAYPOLDATA[68531]:=[ ,,,[2492609538,"JB"],]; CONWAYPOLDATA[68539]:=[ ,,,[17401640868,"JB"],]; CONWAYPOLDATA[68543]:=[ ,,,[18708400597,"JB"],]; CONWAYPOLDATA[68567]:=[ ,,,[18458510673,"JB"],]; CONWAYPOLDATA[68581]:=[ ,,,[12144940715,"JB"],]; CONWAYPOLDATA[68597]:=[ ,,,[59457410110,"JB"],]; CONWAYPOLDATA[68611]:=[ ,,,[40113146708,"JB"],]; CONWAYPOLDATA[68633]:=[ ,,,[8939516886,"JB"],]; CONWAYPOLDATA[68639]:=[ ,,,[35711087093,"JB"],]; CONWAYPOLDATA[68659]:=[ ,,,[13373194045,"JB"],]; CONWAYPOLDATA[68669]:=[ ,,,[17461153322,"JB"],]; CONWAYPOLDATA[68683]:=[ ,,,[42455709622,"JB"],]; CONWAYPOLDATA[68687]:=[ ,,,[17611758927,"JB"],]; CONWAYPOLDATA[68699]:=[ ,,,[3070914001,"JB"],]; CONWAYPOLDATA[68711]:=[ ,,,[26569306913,"JB"],]; CONWAYPOLDATA[68713]:=[ ,,,[78864452486,"JB"],]; CONWAYPOLDATA[68729]:=[ ,,,[4722850696,"JB"],]; CONWAYPOLDATA[68737]:=[ ,,,[55865584333,"JB"],]; CONWAYPOLDATA[68743]:=[ ,,,[23627725276,"JB"],]; CONWAYPOLDATA[68749]:=[ ,,,[3618741119,"JB"],]; CONWAYPOLDATA[68767]:=[ ,,,[11995921784,"JB"],]; CONWAYPOLDATA[68771]:=[ ,,,[32141846135,"JB"],]; CONWAYPOLDATA[68777]:=[ ,,,[3304666076,"JB"],]; CONWAYPOLDATA[68791]:=[ ,,,[12635118137,"JB"],]; CONWAYPOLDATA[68813]:=[ ,,,[18158443255,"JB"],]; CONWAYPOLDATA[68819]:=[ ,,,[42407850639,"JB"],]; CONWAYPOLDATA[68821]:=[ ,,,[8737514174,"JB"],]; CONWAYPOLDATA[68863]:=[ ,,,[52162689558,"JB"],]; CONWAYPOLDATA[68879]:=[ ,,,[80044905824,"JB"],]; CONWAYPOLDATA[68881]:=[ ,,,[94890052336,"JB"],]; CONWAYPOLDATA[68891]:=[ ,,,[17208076219,"JB"],]; CONWAYPOLDATA[68897]:=[ ,,,[45960017454,"JB"],]; CONWAYPOLDATA[68899]:=[ ,,,[13601558289,"JB"],]; CONWAYPOLDATA[68903]:=[ ,,,[26220072013,"JB"],]; CONWAYPOLDATA[68909]:=[ ,,,[37773570896,"JB"],]; CONWAYPOLDATA[68917]:=[ ,,,[7401823639,"JB"],]; CONWAYPOLDATA[68927]:=[ ,,,[41592343907,"JB"],]; CONWAYPOLDATA[68947]:=[ ,,,[170534819795,"JB"],]; CONWAYPOLDATA[68963]:=[ ,,,[13198414794,"JB"],]; CONWAYPOLDATA[68993]:=[ ,,,[9189867603,"JB"],]; CONWAYPOLDATA[69001]:=[ ,,,[156979483051,"JB"],]; CONWAYPOLDATA[69011]:=[ ,,,[47279298084,"JB"],]; CONWAYPOLDATA[69019]:=[ ,,,[12800263742,"JB"],]; CONWAYPOLDATA[69029]:=[ ,,,[13124690859,"JB"],]; CONWAYPOLDATA[69031]:=[ ,,,[18099168862,"JB"],]; CONWAYPOLDATA[69061]:=[ ,,,[32737400198,"JB"],]; CONWAYPOLDATA[69067]:=[ ,,,[42931770934,"JB"],]; CONWAYPOLDATA[69073]:=[ ,,,[2853060275,"JB"],]; CONWAYPOLDATA[69109]:=[ ,,,[18036481476,"JB"],]; CONWAYPOLDATA[69119]:=[ ,,,[21542042267,"JB"],]; CONWAYPOLDATA[69127]:=[ ,,,[19113892013,"JB"],]; CONWAYPOLDATA[69143]:=[ ,,,[12540673344,"JB"],]; CONWAYPOLDATA[69149]:=[ ,,,[13450794333,"JB"],]; CONWAYPOLDATA[69151]:=[ ,,,[18352952015,"JB"],]; CONWAYPOLDATA[69163]:=[ ,,,[43051200982,"JB"],]; CONWAYPOLDATA[69191]:=[ ,,,[27607762539,"JB"],]; CONWAYPOLDATA[69193]:=[ ,,,[40728037705,"JB"],]; CONWAYPOLDATA[69197]:=[ ,,,[47830765524,"JB"],]; CONWAYPOLDATA[69203]:=[ ,,,[76573396314,"JB"],]; CONWAYPOLDATA[69221]:=[ ,,,[60638634317,"JB"],]; CONWAYPOLDATA[69233]:=[ ,,,[21618488884,"JB"],]; CONWAYPOLDATA[69239]:=[ ,,,[17857568975,"JB"],]; CONWAYPOLDATA[69247]:=[ ,,,[28125084535,"JB"],]; CONWAYPOLDATA[69257]:=[ ,,,[14306072208,"JB"],]; CONWAYPOLDATA[69259]:=[ ,,,[41134097505,"JB"],]; CONWAYPOLDATA[69263]:=[ ,,,[42475950333,"JB"],]; CONWAYPOLDATA[69313]:=[ ,,,[4646258339,"JB"],]; CONWAYPOLDATA[69317]:=[ ,,,[22763009633,"JB"],]; CONWAYPOLDATA[69337]:=[ ,,,[75490104059,"JB"],]; CONWAYPOLDATA[69341]:=[ ,,,[52889362366,"JB"],]; CONWAYPOLDATA[69371]:=[ ,,,[41190696156,"JB"],]; CONWAYPOLDATA[69379]:=[ ,,,[42242514216,"JB"],]; CONWAYPOLDATA[69383]:=[ ,,,[19255725229,"JB"],]; CONWAYPOLDATA[69389]:=[ ,,,[22424859466,"JB"],]; CONWAYPOLDATA[69401]:=[ ,,,[23336016855,"JB"],]; CONWAYPOLDATA[69403]:=[ ,,,[38305111983,"JB"],]; CONWAYPOLDATA[69427]:=[ ,,,[41995142616,"JB"],]; CONWAYPOLDATA[69431]:=[ ,,,[37956608524,"JB"],]; CONWAYPOLDATA[69439]:=[ ,,,[19209466085,"JB"],]; CONWAYPOLDATA[69457]:=[ ,,,[33588710635,"JB"],]; CONWAYPOLDATA[69463]:=[ ,,,[22583463251,"JB"],]; CONWAYPOLDATA[69467]:=[ ,,,[12671336538,"JB"],]; CONWAYPOLDATA[69473]:=[ ,,,[3091826395,"JB"],]; CONWAYPOLDATA[69481]:=[ ,,,[13563802903,"JB"],]; CONWAYPOLDATA[69491]:=[ ,,,[41086414770,"JB"],]; CONWAYPOLDATA[69493]:=[ ,,,[33272414486,"JB"],]; CONWAYPOLDATA[69497]:=[ ,,,[37720052729,"JB"],]; CONWAYPOLDATA[69499]:=[ ,,,[27576925207,"JB"],]; CONWAYPOLDATA[69539]:=[ ,,,[36419590933,"JB"],]; CONWAYPOLDATA[69557]:=[ ,,,[21985924347,"JB"],]; CONWAYPOLDATA[69593]:=[ ,,,[9107844692,"JB"],]; CONWAYPOLDATA[69623]:=[ ,,,[31523762699,"JB"],]; CONWAYPOLDATA[69653]:=[ ,,,[7697004767,"JB"],]; CONWAYPOLDATA[69661]:=[ ,,,[37176961130,"JB"],]; CONWAYPOLDATA[69677]:=[ ,,,[24115140025,"JB"],]; CONWAYPOLDATA[69691]:=[ ,,,[13546327509,"JB"],]; CONWAYPOLDATA[69697]:=[ ,,,[61005505317,"JB"],]; CONWAYPOLDATA[69709]:=[ ,,,[57600267875,"JB"],]; CONWAYPOLDATA[69737]:=[ ,,,[22283551772,"JB"],]; CONWAYPOLDATA[69739]:=[ ,,,[12636148890,"JB"],]; CONWAYPOLDATA[69761]:=[ ,,,[23297871890,"JB"],]; CONWAYPOLDATA[69763]:=[ ,,,[51688592673,"JB"],]; CONWAYPOLDATA[69767]:=[ ,,,[28549702910,"JB"],]; CONWAYPOLDATA[69779]:=[ ,,,[38418642706,"JB"],]; CONWAYPOLDATA[69809]:=[ ,,,[3493032936,"JB"],]; CONWAYPOLDATA[69821]:=[ ,,,[47038407707,"JB"],]; CONWAYPOLDATA[69827]:=[ ,,,[121631721129,"JB"],]; CONWAYPOLDATA[69829]:=[ ,,,[71181727398,"JB"],]; CONWAYPOLDATA[69833]:=[ ,,,[53104155690,"JB"],]; CONWAYPOLDATA[69847]:=[ ,,,[18635109763,"JB"],]; CONWAYPOLDATA[69857]:=[ ,,,[22555218592,"JB"],]; CONWAYPOLDATA[69859]:=[ ,,,[8671318244,"JB"],]; CONWAYPOLDATA[69877]:=[ ,,,[32096462658,"JB"],]; CONWAYPOLDATA[69899]:=[ ,,,[24120117831,"JB"],]; CONWAYPOLDATA[69911]:=[ ,,,[24437110413,"JB"],]; CONWAYPOLDATA[69929]:=[ ,,,[13357907512,"JB"],]; CONWAYPOLDATA[69931]:=[ ,,,[14622082586,"JB"],]; CONWAYPOLDATA[69941]:=[ ,,,[32399468842,"JB"],]; CONWAYPOLDATA[69959]:=[ ,,,[28272110923,"JB"],]; CONWAYPOLDATA[69991]:=[ ,,,[19491863584,"JB"],]; CONWAYPOLDATA[69997]:=[ ,,,[14502748429,"JB"],]; CONWAYPOLDATA[70001]:=[ ,,,[24050453576,"JB"],]; CONWAYPOLDATA[70003]:=[ ,,,[52009358879,"JB"],]; CONWAYPOLDATA[70009]:=[ ,,,[161046253304,"JB"],]; CONWAYPOLDATA[70019]:=[ ,,,[27174864039,"JB"],]; CONWAYPOLDATA[70039]:=[ ,,,[13428717551,"JB"],]; CONWAYPOLDATA[70051]:=[ ,,,[32054567046,"JB"],]; CONWAYPOLDATA[70061]:=[ ,,,[19496645143,"JB"],]; CONWAYPOLDATA[70067]:=[ ,,,[4845133052,"JB"],]; CONWAYPOLDATA[70079]:=[ ,,,[17587376242,"JB"],]; CONWAYPOLDATA[70099]:=[ ,,,[12999579157,"JB"],]; CONWAYPOLDATA[70111]:=[ ,,,[18749153737,"JB"],]; CONWAYPOLDATA[70117]:=[ ,,,[32836912974,"JB"],]; CONWAYPOLDATA[70121]:=[ ,,,[36975855121,"JB"],]; CONWAYPOLDATA[70123]:=[ ,,,[72405784144,"JB"],]; CONWAYPOLDATA[70139]:=[ ,,,[7890918058,"JB"],]; CONWAYPOLDATA[70141]:=[ ,,,[63889893808,"JB"],]; CONWAYPOLDATA[70157]:=[ ,,,[27556757561,"JB"],]; CONWAYPOLDATA[70163]:=[ ,,,[7957326158,"JB"],]; CONWAYPOLDATA[70177]:=[ ,,,[33167966046,"JB"],]; CONWAYPOLDATA[70181]:=[ ,,,[4582047316,"JB"],]; CONWAYPOLDATA[70183]:=[ ,,,[24627986716,"JB"],]; CONWAYPOLDATA[70199]:=[ ,,,[43160451187,"JB"],]; CONWAYPOLDATA[70201]:=[ ,,,[43271615610,"JB"],]; CONWAYPOLDATA[70207]:=[ ,,,[27596054874,"JB"],]; CONWAYPOLDATA[70223]:=[ ,,,[17425626786,"JB"],]; CONWAYPOLDATA[70229]:=[ ,,,[23030406659,"JB"],]; CONWAYPOLDATA[70237]:=[ ,,,[18771821570,"JB"],]; CONWAYPOLDATA[70241]:=[ ,,,[23473067145,"JB"],]; CONWAYPOLDATA[70249]:=[ ,,,[170715888369,"JB"],]; CONWAYPOLDATA[70271]:=[ ,,,[29491192749,"JB"],]; CONWAYPOLDATA[70289]:=[ ,,,[24281053897,"JB"],]; CONWAYPOLDATA[70297]:=[ ,,,[52738215345,"JB"],]; CONWAYPOLDATA[70309]:=[ ,,,[58133098313,"JB"],]; CONWAYPOLDATA[70313]:=[ ,,,[58348750862,"JB"],]; CONWAYPOLDATA[70321]:=[ ,,,[86665077148,"JB"],]; CONWAYPOLDATA[70327]:=[ ,,,[74055104608,"JB"],]; CONWAYPOLDATA[70351]:=[ ,,,[14359061212,"JB"],]; CONWAYPOLDATA[70373]:=[ ,,,[33306274188,"JB"],]; CONWAYPOLDATA[70379]:=[ ,,,[4049255771,"JB"],]; CONWAYPOLDATA[70381]:=[ ,,,[8903900320,"JB"],]; CONWAYPOLDATA[70393]:=[ ,,,[52953627006,"JB"],]; CONWAYPOLDATA[70423]:=[ ,,,[19837314029,"JB"],]; CONWAYPOLDATA[70429]:=[ ,,,[14093054197,"JB"],]; CONWAYPOLDATA[70439]:=[ ,,,[32375807144,"JB"],]; CONWAYPOLDATA[70451]:=[ ,,,[28853347958,"JB"],]; CONWAYPOLDATA[70457]:=[ ,,,[24139413687,"JB"],]; CONWAYPOLDATA[70459]:=[ ,,,[13592527529,"JB"],]; CONWAYPOLDATA[70481]:=[ ,,,[13364043375,"JB"],]; CONWAYPOLDATA[70487]:=[ ,,,[72708891219,"JB"],]; CONWAYPOLDATA[70489]:=[ ,,,[102590184040,"JB"],]; CONWAYPOLDATA[70501]:=[ ,,,[54278085393,"JB"],]; CONWAYPOLDATA[70507]:=[ ,,,[13092585846,"JB"],]; CONWAYPOLDATA[70529]:=[ ,,,[38823252285,"JB"],]; CONWAYPOLDATA[70537]:=[ ,,,[79071694857,"JB"],]; CONWAYPOLDATA[70549]:=[ ,,,[18927238467,"JB"],]; CONWAYPOLDATA[70571]:=[ ,,,[38723083983,"JB"],]; CONWAYPOLDATA[70573]:=[ ,,,[44824440952,"JB"],]; CONWAYPOLDATA[70583]:=[ ,,,[19927557229,"JB"],]; CONWAYPOLDATA[70589]:=[ ,,,[23395382861,"JB"],]; CONWAYPOLDATA[70607]:=[ ,,,[24063501068,"JB"],]; CONWAYPOLDATA[70619]:=[ ,,,[14325558485,"JB"],]; CONWAYPOLDATA[70621]:=[ ,,,[37863590398,"JB"],]; CONWAYPOLDATA[70627]:=[ ,,,[68620910699,"JB"],]; CONWAYPOLDATA[70639]:=[ ,,,[19284376364,"JB"],]; CONWAYPOLDATA[70657]:=[ ,,,[42492625208,"JB"],]; CONWAYPOLDATA[70663]:=[ ,,,[13848676069,"JB"],]; CONWAYPOLDATA[70667]:=[ ,,,[19161639720,"JB"],]; CONWAYPOLDATA[70687]:=[ ,,,[94935256424,"JB"],]; CONWAYPOLDATA[70709]:=[ ,,,[34092697897,"JB"],]; CONWAYPOLDATA[70717]:=[ ,,,[32833832385,"JB"],]; CONWAYPOLDATA[70729]:=[ ,,,[3404045334,"JB"],]; CONWAYPOLDATA[70753]:=[ ,,,[79549366730,"JB"],]; CONWAYPOLDATA[70769]:=[ ,,,[23842854562,"JB"],]; CONWAYPOLDATA[70783]:=[ ,,,[37675950545,"JB"],]; CONWAYPOLDATA[70793]:=[ ,,,[33864185518,"JB"],]; CONWAYPOLDATA[70823]:=[ ,,,[14549381364,"JB"],]; CONWAYPOLDATA[70841]:=[ ,,,[8463657637,"JB"],]; CONWAYPOLDATA[70843]:=[ ,,,[40039896858,"JB"],]; CONWAYPOLDATA[70849]:=[ ,,,[178383966462,"JB"],]; CONWAYPOLDATA[70853]:=[ ,,,[19804051179,"JB"],]; CONWAYPOLDATA[70867]:=[ ,,,[19943603744,"JB"],]; CONWAYPOLDATA[70877]:=[ ,,,[13922865251,"JB"],]; CONWAYPOLDATA[70879]:=[ ,,,[13134658372,"JB"],]; CONWAYPOLDATA[70891]:=[ ,,,[14692088862,"JB"],]; CONWAYPOLDATA[70901]:=[ ,,,[19863836865,"JB"],]; CONWAYPOLDATA[70913]:=[ ,,,[23096576842,"JB"],]; CONWAYPOLDATA[70919]:=[ ,,,[32993220863,"JB"],]; CONWAYPOLDATA[70921]:=[ ,,,[74256343722,"JB"],]; CONWAYPOLDATA[70937]:=[ ,,,[59328018079,"JB"],]; CONWAYPOLDATA[70949]:=[ ,,,[4463046847,"JB"],]; CONWAYPOLDATA[70951]:=[ ,,,[19201681989,"JB"],]; CONWAYPOLDATA[70957]:=[ ,,,[18793600065,"JB"],]; CONWAYPOLDATA[70969]:=[ ,,,[84970261114,"JB"],]; CONWAYPOLDATA[70979]:=[ ,,,[14175570987,"JB"],]; CONWAYPOLDATA[70981]:=[ ,,,[14773985346,"JB"],]; CONWAYPOLDATA[70991]:=[ ,,,[14410676070,"JB"],]; CONWAYPOLDATA[70997]:=[ ,,,[48088540006,"JB"],]; CONWAYPOLDATA[70999]:=[ ,,,[50106479276,"JB"],]; CONWAYPOLDATA[71011]:=[ ,,,[33797046366,"JB"],]; CONWAYPOLDATA[71023]:=[ ,,,[19304335498,"JB"],]; CONWAYPOLDATA[71039]:=[ ,,,[35168496312,"JB"],]; CONWAYPOLDATA[71059]:=[ ,,,[33223138044,"JB"],]; CONWAYPOLDATA[71069]:=[ ,,,[48557681045,"JB"],]; CONWAYPOLDATA[71081]:=[ ,,,[40301718626,"JB"],]; CONWAYPOLDATA[71089]:=[ ,,,[113997751699,"JB"],]; CONWAYPOLDATA[71119]:=[ ,,,[45253659774,"JB"],]; CONWAYPOLDATA[71129]:=[ ,,,[13178567736,"JB"],]; CONWAYPOLDATA[71143]:=[ ,,,[40424875466,"JB"],]; CONWAYPOLDATA[71147]:=[ ,,,[23536139072,"JB"],]; CONWAYPOLDATA[71153]:=[ ,,,[48586754900,"JB"],]; CONWAYPOLDATA[71161]:=[ ,,,[65531595623,"JB"],]; CONWAYPOLDATA[71167]:=[ ,,,[14336307485,"JB"],]; CONWAYPOLDATA[71171]:=[ ,,,[23923064087,"JB"],]; CONWAYPOLDATA[71191]:=[ ,,,[13531842901,"JB"],]; CONWAYPOLDATA[71209]:=[ ,,,[3264719030,"JB"],]; CONWAYPOLDATA[71233]:=[ ,,,[39476758747,"JB"],]; CONWAYPOLDATA[71237]:=[ ,,,[35144132819,"JB"],]; CONWAYPOLDATA[71249]:=[ ,,,[25328307013,"JB"],]; CONWAYPOLDATA[71257]:=[ ,,,[76162616913,"JB"],]; CONWAYPOLDATA[71261]:=[ ,,,[65660312969,"JB"],]; CONWAYPOLDATA[71263]:=[ ,,,[14045082149,"JB"],]; CONWAYPOLDATA[71287]:=[ ,,,[13098701105,"JB"],]; CONWAYPOLDATA[71293]:=[ ,,,[9879213601,"JB"],]; CONWAYPOLDATA[71317]:=[ ,,,[64754053077,"JB"],]; CONWAYPOLDATA[71327]:=[ ,,,[20349878413,"JB"],]; CONWAYPOLDATA[71329]:=[ ,,,[3043323121,"JB"],]; CONWAYPOLDATA[71333]:=[ ,,,[59504918607,"JB"],]; CONWAYPOLDATA[71339]:=[ ,,,[69190982712,"JB"],]; CONWAYPOLDATA[71341]:=[ ,,,[35626482609,"JB"],]; CONWAYPOLDATA[71347]:=[ ,,,[39608501093,"JB"],]; CONWAYPOLDATA[71353]:=[ ,,,[64042813802,"JB"],]; CONWAYPOLDATA[71359]:=[ ,,,[23565881602,"JB"],]; CONWAYPOLDATA[71363]:=[ ,,,[54643291369,"JB"],]; CONWAYPOLDATA[71387]:=[ ,,,[79648331964,"JB"],]; CONWAYPOLDATA[71389]:=[ ,,,[44088275853,"JB"],]; CONWAYPOLDATA[71399]:=[ ,,,[12761071882,"JB"],]; CONWAYPOLDATA[71411]:=[ ,,,[38558155219,"JB"],]; CONWAYPOLDATA[71413]:=[ ,,,[45897849232,"JB"],]; CONWAYPOLDATA[71419]:=[ ,,,[40632554510,"JB"],]; CONWAYPOLDATA[71429]:=[ ,,,[34198990909,"JB"],]; CONWAYPOLDATA[71437]:=[ ,,,[54942696761,"JB"],]; CONWAYPOLDATA[71443]:=[ ,,,[28140754724,"JB"],]; CONWAYPOLDATA[71453]:=[ ,,,[18028306432,"JB"],]; CONWAYPOLDATA[71471]:=[ ,,,[23369444645,"JB"],]; CONWAYPOLDATA[71473]:=[ ,,,[33878273478,"JB"],]; CONWAYPOLDATA[71479]:=[ ,,,[55115455494,"JB"],]; CONWAYPOLDATA[71483]:=[ ,,,[23831574406,"JB"],]; CONWAYPOLDATA[71503]:=[ ,,,[35580178815,"JB"],]; CONWAYPOLDATA[71527]:=[ ,,,[33503962073,"JB"],]; CONWAYPOLDATA[71537]:=[ ,,,[2616966537,"JB"],]; CONWAYPOLDATA[71549]:=[ ,,,[25527252222,"JB"],]; CONWAYPOLDATA[71551]:=[ ,,,[19946057623,"JB"],]; CONWAYPOLDATA[71563]:=[ ,,,[45170064661,"JB"],]; CONWAYPOLDATA[71569]:=[ ,,,[168224723744,"JB"],]; CONWAYPOLDATA[71593]:=[ ,,,[79501162785,"JB"],]; CONWAYPOLDATA[71597]:=[ ,,,[5075439735,"JB"],]; CONWAYPOLDATA[71633]:=[ ,,,[23248131988,"JB"],]; CONWAYPOLDATA[71647]:=[ ,,,[35085965785,"JB"],]; CONWAYPOLDATA[71663]:=[ ,,,[13959020786,"JB"],]; CONWAYPOLDATA[71671]:=[ ,,,[18552181707,"JB"],]; CONWAYPOLDATA[71693]:=[ ,,,[9089453621,"JB"],]; CONWAYPOLDATA[71699]:=[ ,,,[35669177017,"JB"],]; CONWAYPOLDATA[71707]:=[ ,,,[9676572824,"JB"],]; CONWAYPOLDATA[71711]:=[ ,,,[38740003281,"JB"],]; CONWAYPOLDATA[71713]:=[ ,,,[65095396078,"JB"],]; CONWAYPOLDATA[71719]:=[ ,,,[20008596937,"JB"],]; CONWAYPOLDATA[71741]:=[ ,,,[20113665467,"JB"],]; CONWAYPOLDATA[71761]:=[ ,,,[70654875990,"JB"],]; CONWAYPOLDATA[71777]:=[ ,,,[50587568279,"JB"],]; CONWAYPOLDATA[71789]:=[ ,,,[3508328432,"JB"],]; CONWAYPOLDATA[71807]:=[ ,,,[61874081309,"JB"],]; CONWAYPOLDATA[71809]:=[ ,,,[92568910098,"JB"],]; CONWAYPOLDATA[71821]:=[ ,,,[54971290655,"JB"],]; CONWAYPOLDATA[71837]:=[ ,,,[18495585044,"JB"],]; CONWAYPOLDATA[71843]:=[ ,,,[43997946376,"JB"],]; CONWAYPOLDATA[71849]:=[ ,,,[39264616315,"JB"],]; CONWAYPOLDATA[71861]:=[ ,,,[29918752469,"JB"],]; CONWAYPOLDATA[71867]:=[ ,,,[14329992334,"JB"],]; CONWAYPOLDATA[71879]:=[ ,,,[14549028401,"JB"],]; CONWAYPOLDATA[71881]:=[ ,,,[3727676786,"JB"],]; CONWAYPOLDATA[71887]:=[ ,,,[14360506558,"JB"],]; CONWAYPOLDATA[71899]:=[ ,,,[46083879749,"JB"],]; CONWAYPOLDATA[71909]:=[ ,,,[20622638294,"JB"],]; CONWAYPOLDATA[71917]:=[ ,,,[33993943313,"JB"],]; CONWAYPOLDATA[71933]:=[ ,,,[35537851255,"JB"],]; CONWAYPOLDATA[71941]:=[ ,,,[34526572191,"JB"],]; CONWAYPOLDATA[71947]:=[ ,,,[46259834539,"JB"],]; CONWAYPOLDATA[71963]:=[ ,,,[46607556582,"JB"],]; CONWAYPOLDATA[71971]:=[ ,,,[44371057125,"JB"],]; CONWAYPOLDATA[71983]:=[ ,,,[30522951493,"JB"],]; CONWAYPOLDATA[71987]:=[ ,,,[138139381665,"JB"],]; CONWAYPOLDATA[71993]:=[ ,,,[9042392796,"JB"],]; CONWAYPOLDATA[71999]:=[ ,,,[40419590616,"JB"],]; CONWAYPOLDATA[72019]:=[ ,,,[9705352461,"JB"],]; CONWAYPOLDATA[72031]:=[ ,,,[19552310736,"JB"],]; CONWAYPOLDATA[72043]:=[ ,,,[44503266481,"JB"],]; CONWAYPOLDATA[72047]:=[ ,,,[30479195167,"JB"],]; CONWAYPOLDATA[72053]:=[ ,,,[40602297820,"JB"],]; CONWAYPOLDATA[72073]:=[ ,,,[55466588002,"JB"],]; CONWAYPOLDATA[72077]:=[ ,,,[23862172007,"JB"],]; CONWAYPOLDATA[72089]:=[ ,,,[5195958856,"JB"],]; CONWAYPOLDATA[72091]:=[ ,,,[14757892794,"JB"],]; CONWAYPOLDATA[72101]:=[ ,,,[66936765877,"JB"],]; CONWAYPOLDATA[72103]:=[ ,,,[14575333044,"JB"],]; CONWAYPOLDATA[72109]:=[ ,,,[34548359319,"JB"],]; CONWAYPOLDATA[72139]:=[ ,,,[44880629601,"JB"],]; CONWAYPOLDATA[72161]:=[ ,,,[24008541994,"JB"],]; CONWAYPOLDATA[72167]:=[ ,,,[20832014893,"JB"],]; CONWAYPOLDATA[72169]:=[ ,,,[2672129401,"JB"],]; CONWAYPOLDATA[72173]:=[ ,,,[8663286057,"JB"],]; CONWAYPOLDATA[72211]:=[ ,,,[14953670515,"JB"],]; CONWAYPOLDATA[72221]:=[ ,,,[34334224507,"JB"],]; CONWAYPOLDATA[72223]:=[ ,,,[93260476558,"JB"],]; CONWAYPOLDATA[72227]:=[ ,,,[14830803274,"JB"],]; CONWAYPOLDATA[72229]:=[ ,,,[52126874783,"JB"],]; CONWAYPOLDATA[72251]:=[ ,,,[26100384753,"JB"],]; CONWAYPOLDATA[72253]:=[ ,,,[33954936087,"JB"],]; CONWAYPOLDATA[72269]:=[ ,,,[19870939705,"JB"],]; CONWAYPOLDATA[72271]:=[ ,,,[20404343704,"JB"],]; CONWAYPOLDATA[72277]:=[ ,,,[10057850494,"JB"],]; CONWAYPOLDATA[72287]:=[ ,,,[20901352333,"JB"],]; CONWAYPOLDATA[72307]:=[ ,,,[4668139923,"JB"],]; CONWAYPOLDATA[72313]:=[ ,,,[35887857210,"JB"],]; CONWAYPOLDATA[72337]:=[ ,,,[91842382709,"JB"],]; CONWAYPOLDATA[72341]:=[ ,,,[51315956444,"JB"],]; CONWAYPOLDATA[72353]:=[ ,,,[3993813250,"JB"],]; CONWAYPOLDATA[72367]:=[ ,,,[35953734778,"JB"],]; CONWAYPOLDATA[72379]:=[ ,,,[66586508632,"JB"],]; CONWAYPOLDATA[72383]:=[ ,,,[26141409987,"JB"],]; CONWAYPOLDATA[72421]:=[ ,,,[41511427522,"JB"],]; CONWAYPOLDATA[72431]:=[ ,,,[35729777727,"JB"],]; CONWAYPOLDATA[72461]:=[ ,,,[34646140237,"JB"],]; CONWAYPOLDATA[72467]:=[ ,,,[72734620633,"JB"],]; CONWAYPOLDATA[72469]:=[ ,,,[41158551149,"JB"],]; CONWAYPOLDATA[72481]:=[ ,,,[44676563601,"JB"],]; CONWAYPOLDATA[72493]:=[ ,,,[36582867522,"JB"],]; CONWAYPOLDATA[72497]:=[ ,,,[34197994857,"JB"],]; CONWAYPOLDATA[72503]:=[ ,,,[14474788937,"JB"],]; CONWAYPOLDATA[72533]:=[ ,,,[9949206546,"JB"],]; CONWAYPOLDATA[72547]:=[ ,,,[47367097054,"JB"],]; CONWAYPOLDATA[72551]:=[ ,,,[50355182379,"JB"],]; CONWAYPOLDATA[72559]:=[ ,,,[77069920474,"JB"],]; CONWAYPOLDATA[72577]:=[ ,,,[79010515593,"JB"],]; CONWAYPOLDATA[72613]:=[ ,,,[35821735614,"JB"],]; CONWAYPOLDATA[72617]:=[ ,,,[26106537673,"JB"],]; CONWAYPOLDATA[72623]:=[ ,,,[46547276117,"JB"],]; CONWAYPOLDATA[72643]:=[ ,,,[93285089596,"JB"],]; CONWAYPOLDATA[72647]:=[ ,,,[21110055853,"JB"],]; CONWAYPOLDATA[72649]:=[ ,,,[93139287212,"JB"],]; CONWAYPOLDATA[72661]:=[ ,,,[20351110874,"JB"],]; CONWAYPOLDATA[72671]:=[ ,,,[20291996008,"JB"],]; CONWAYPOLDATA[72673]:=[ ,,,[79219674537,"JB"],]; CONWAYPOLDATA[72679]:=[ ,,,[18843629694,"JB"],]; CONWAYPOLDATA[72689]:=[ ,,,[15602403097,"JB"],]; CONWAYPOLDATA[72701]:=[ ,,,[47568409704,"JB"],]; CONWAYPOLDATA[72707]:=[ ,,,[41066295035,"JB"],]; CONWAYPOLDATA[72719]:=[ ,,,[31036396492,"JB"],]; CONWAYPOLDATA[72727]:=[ ,,,[4682164267,"JB"],]; CONWAYPOLDATA[72733]:=[ ,,,[36257618701,"JB"],]; CONWAYPOLDATA[72739]:=[ ,,,[83151587852,"JB"],]; CONWAYPOLDATA[72763]:=[ ,,,[88412138412,"JB"],]; CONWAYPOLDATA[72767]:=[ ,,,[24409544621,"JB"],]; CONWAYPOLDATA[72797]:=[ ,,,[36803833698,"JB"],]; CONWAYPOLDATA[72817]:=[ ,,,[135524815895,"JB"],]; CONWAYPOLDATA[72823]:=[ ,,,[29393110557,"JB"],]; CONWAYPOLDATA[72859]:=[ ,,,[13706307941,"JB"],]; CONWAYPOLDATA[72869]:=[ ,,,[47788510368,"JB"],]; CONWAYPOLDATA[72871]:=[ ,,,[14256409575,"JB"],]; CONWAYPOLDATA[72883]:=[ ,,,[45463613690,"JB"],]; CONWAYPOLDATA[72889]:=[ ,,,[4323775487,"JB"],]; CONWAYPOLDATA[72893]:=[ ,,,[35701533542,"JB"],]; CONWAYPOLDATA[72901]:=[ ,,,[41975958396,"JB"],]; CONWAYPOLDATA[72907]:=[ ,,,[45631251883,"JB"],]; CONWAYPOLDATA[72911]:=[ ,,,[34743695553,"JB"],]; CONWAYPOLDATA[72923]:=[ ,,,[46556012123,"JB"],]; CONWAYPOLDATA[72931]:=[ ,,,[52288463908,"JB"],]; CONWAYPOLDATA[72937]:=[ ,,,[34835002953,"JB"],]; CONWAYPOLDATA[72949]:=[ ,,,[67682301049,"JB"],]; CONWAYPOLDATA[72953]:=[ ,,,[52644562722,"JB"],]; CONWAYPOLDATA[72959]:=[ ,,,[95812385341,"JB"],]; CONWAYPOLDATA[72973]:=[ ,,,[40614874504,"JB"],]; CONWAYPOLDATA[72977]:=[ ,,,[3307463597,"JB"],]; CONWAYPOLDATA[72997]:=[ ,,,[52377537412,"JB"],]; CONWAYPOLDATA[73009]:=[ ,,,[9805035698,"JB"],]; CONWAYPOLDATA[73013]:=[ ,,,[24101080211,"JB"],]; CONWAYPOLDATA[73019]:=[ ,,,[19494320546,"JB"],]; CONWAYPOLDATA[73037]:=[ ,,,[19281110669,"JB"],]; CONWAYPOLDATA[73039]:=[ ,,,[15007104216,"JB"],]; CONWAYPOLDATA[73043]:=[ ,,,[42200301080,"JB"],]; CONWAYPOLDATA[73061]:=[ ,,,[36328632459,"JB"],]; CONWAYPOLDATA[73063]:=[ ,,,[19536753951,"JB"],]; CONWAYPOLDATA[73079]:=[ ,,,[24310971706,"JB"],]; CONWAYPOLDATA[73091]:=[ ,,,[24582476759,"JB"],]; CONWAYPOLDATA[73121]:=[ ,,,[13785794617,"JB"],]; CONWAYPOLDATA[73127]:=[ ,,,[21389940013,"JB"],]; CONWAYPOLDATA[73133]:=[ ,,,[96200537729,"JB"],]; CONWAYPOLDATA[73141]:=[ ,,,[24616115544,"JB"],]; CONWAYPOLDATA[73181]:=[ ,,,[40927864691,"JB"],]; CONWAYPOLDATA[73189]:=[ ,,,[68366503603,"JB"],]; CONWAYPOLDATA[73237]:=[ ,,,[36960004137,"JB"],]; CONWAYPOLDATA[73243]:=[ ,,,[15981476117,"JB"],]; CONWAYPOLDATA[73259]:=[ ,,,[42060116413,"JB"],]; CONWAYPOLDATA[73277]:=[ ,,,[26847300540,"JB"],]; CONWAYPOLDATA[73291]:=[ ,,,[64178949846,"JB"],]; CONWAYPOLDATA[73303]:=[ ,,,[31479313628,"JB"],]; CONWAYPOLDATA[73309]:=[ ,,,[53249458332,"JB"],]; CONWAYPOLDATA[73327]:=[ ,,,[26883951340,"JB"],]; CONWAYPOLDATA[73331]:=[ ,,,[24656375456,"JB"],]; CONWAYPOLDATA[73351]:=[ ,,,[37113478824,"JB"],]; CONWAYPOLDATA[73361]:=[ ,,,[25305363434,"JB"],]; CONWAYPOLDATA[73363]:=[ ,,,[21528225629,"JB"],]; CONWAYPOLDATA[73369]:=[ ,,,[91324742119,"JB"],]; CONWAYPOLDATA[73379]:=[ ,,,[10686990941,"JB"],]; CONWAYPOLDATA[73387]:=[ ,,,[48470352214,"JB"],]; CONWAYPOLDATA[73417]:=[ ,,,[117093654314,"JB"],]; CONWAYPOLDATA[73421]:=[ ,,,[18903117504,"JB"],]; CONWAYPOLDATA[73433]:=[ ,,,[8933858783,"JB"],]; CONWAYPOLDATA[73453]:=[ ,,,[59308963775,"JB"],]; CONWAYPOLDATA[73459]:=[ ,,,[46793823756,"JB"],]; CONWAYPOLDATA[73471]:=[ ,,,[26989645324,"JB"],]; CONWAYPOLDATA[73477]:=[ ,,,[48233535794,"JB"],]; CONWAYPOLDATA[73483]:=[ ,,,[48402590755,"JB"],]; CONWAYPOLDATA[73517]:=[ ,,,[36336512422,"JB"],]; CONWAYPOLDATA[73523]:=[ ,,,[3406173546,"JB"],]; CONWAYPOLDATA[73529]:=[ ,,,[3131011881,"JB"],]; CONWAYPOLDATA[73547]:=[ ,,,[75217399466,"JB"],]; CONWAYPOLDATA[73553]:=[ ,,,[42632422098,"JB"],]; CONWAYPOLDATA[73561]:=[ ,,,[89721910347,"JB"],]; CONWAYPOLDATA[73571]:=[ ,,,[48373815354,"JB"],]; CONWAYPOLDATA[73583]:=[ ,,,[20894628685,"JB"],]; CONWAYPOLDATA[73589]:=[ ,,,[78850613502,"JB"],]; CONWAYPOLDATA[73597]:=[ ,,,[52547448435,"JB"],]; CONWAYPOLDATA[73607]:=[ ,,,[37404795588,"JB"],]; CONWAYPOLDATA[73609]:=[ ,,,[81161283419,"JB"],]; CONWAYPOLDATA[73613]:=[ ,,,[67789696411,"JB"],]; CONWAYPOLDATA[73637]:=[ ,,,[25839591487,"JB"],]; CONWAYPOLDATA[73643]:=[ ,,,[79746605485,"JB"],]; CONWAYPOLDATA[73651]:=[ ,,,[48360940575,"JB"],]; CONWAYPOLDATA[73673]:=[ ,,,[25961112762,"JB"],]; CONWAYPOLDATA[73679]:=[ ,,,[37307656380,"JB"],]; CONWAYPOLDATA[73681]:=[ ,,,[4268708749,"JB"],]; CONWAYPOLDATA[73693]:=[ ,,,[53165593773,"JB"],]; CONWAYPOLDATA[73699]:=[ ,,,[10381241142,"JB"],]; CONWAYPOLDATA[73709]:=[ ,,,[24654849703,"JB"],]; CONWAYPOLDATA[73721]:=[ ,,,[3927560002,"JB"],]; CONWAYPOLDATA[73727]:=[ ,,,[65227161629,"JB"],]; CONWAYPOLDATA[73751]:=[ ,,,[19435674794,"JB"],]; CONWAYPOLDATA[73757]:=[ ,,,[20246739044,"JB"],]; CONWAYPOLDATA[73771]:=[ ,,,[35847246948,"JB"],]; CONWAYPOLDATA[73783]:=[ ,,,[32545017256,"JB"],]; CONWAYPOLDATA[73819]:=[ ,,,[19764446701,"JB"],]; CONWAYPOLDATA[73823]:=[ ,,,[13755734887,"JB"],]; CONWAYPOLDATA[73847]:=[ ,,,[21813222253,"JB"],]; CONWAYPOLDATA[73849]:=[ ,,,[4012363875,"JB"],]; CONWAYPOLDATA[73859]:=[ ,,,[21397173879,"JB"],]; CONWAYPOLDATA[73867]:=[ ,,,[14692811105,"JB"],]; CONWAYPOLDATA[73877]:=[ ,,,[25602813122,"JB"],]; CONWAYPOLDATA[73883]:=[ ,,,[5371146336,"JB"],]; CONWAYPOLDATA[73897]:=[ ,,,[91957870187,"JB"],]; CONWAYPOLDATA[73907]:=[ ,,,[52002738970,"JB"],]; CONWAYPOLDATA[73939]:=[ ,,,[10899126175,"JB"],]; CONWAYPOLDATA[73943]:=[ ,,,[21366791114,"JB"],]; CONWAYPOLDATA[73951]:=[ ,,,[21233994339,"JB"],]; CONWAYPOLDATA[73961]:=[ ,,,[5469341992,"JB"],]; CONWAYPOLDATA[73973]:=[ ,,,[48953038239,"JB"],]; CONWAYPOLDATA[73999]:=[ ,,,[57559308167,"JB"],]; CONWAYPOLDATA[74017]:=[ ,,,[59264301652,"JB"],]; CONWAYPOLDATA[74021]:=[ ,,,[10434222225,"JB"],]; CONWAYPOLDATA[74027]:=[ ,,,[81174528933,"JB"],]; CONWAYPOLDATA[74047]:=[ ,,,[32344099838,"JB"],]; CONWAYPOLDATA[74051]:=[ ,,,[15392388968,"JB"],]; CONWAYPOLDATA[74071]:=[ ,,,[21313041412,"JB"],]; CONWAYPOLDATA[74077]:=[ ,,,[21613446295,"JB"],]; CONWAYPOLDATA[74093]:=[ ,,,[52999241553,"JB"],]; CONWAYPOLDATA[74099]:=[ ,,,[4211935360,"JB"],]; CONWAYPOLDATA[74101]:=[ ,,,[49418105104,"JB"],]; CONWAYPOLDATA[74131]:=[ ,,,[49391706158,"JB"],]; CONWAYPOLDATA[74143]:=[ ,,,[21988441229,"JB"],]; CONWAYPOLDATA[74149]:=[ ,,,[42981728385,"JB"],]; CONWAYPOLDATA[74159]:=[ ,,,[32996453791,"JB"],]; CONWAYPOLDATA[74161]:=[ ,,,[4541026359,"JB"],]; CONWAYPOLDATA[74167]:=[ ,,,[14479771749,"JB"],]; CONWAYPOLDATA[74177]:=[ ,,,[10921153890,"JB"],]; CONWAYPOLDATA[74189]:=[ ,,,[49535550168,"JB"],]; CONWAYPOLDATA[74197]:=[ ,,,[37569205773,"JB"],]; CONWAYPOLDATA[74201]:=[ ,,,[3463851088,"JB"],]; CONWAYPOLDATA[74203]:=[ ,,,[15410033824,"JB"],]; CONWAYPOLDATA[74209]:=[ ,,,[5407906685,"JB"],]; CONWAYPOLDATA[74219]:=[ ,,,[25379558147,"JB"],]; CONWAYPOLDATA[74231]:=[ ,,,[54394843729,"JB"],]; CONWAYPOLDATA[74257]:=[ ,,,[181072724225,"JB"],]; CONWAYPOLDATA[74279]:=[ ,,,[27586180701,"JB"],]; CONWAYPOLDATA[74287]:=[ ,,,[27592494700,"JB"],]; CONWAYPOLDATA[74293]:=[ ,,,[36473108253,"JB"],]; CONWAYPOLDATA[74297]:=[ ,,,[30827459837,"JB"],]; CONWAYPOLDATA[74311]:=[ ,,,[21739980306,"JB"],]; CONWAYPOLDATA[74317]:=[ ,,,[36311955055,"JB"],]; CONWAYPOLDATA[74323]:=[ ,,,[15950830650,"JB"],]; CONWAYPOLDATA[74353]:=[ ,,,[58583992706,"JB"],]; CONWAYPOLDATA[74357]:=[ ,,,[10361127453,"JB"],]; CONWAYPOLDATA[74363]:=[ ,,,[48217564106,"JB"],]; CONWAYPOLDATA[74377]:=[ ,,,[131551492429,"JB"],]; CONWAYPOLDATA[74381]:=[ ,,,[9999335356,"JB"],]; CONWAYPOLDATA[74383]:=[ ,,,[105122592968,"JB"],]; CONWAYPOLDATA[74411]:=[ ,,,[43473212943,"JB"],]; CONWAYPOLDATA[74413]:=[ ,,,[42649513303,"JB"],]; CONWAYPOLDATA[74419]:=[ ,,,[48175511747,"JB"],]; CONWAYPOLDATA[74441]:=[ ,,,[5540569192,"JB"],]; CONWAYPOLDATA[74449]:=[ ,,,[80847147073,"JB"],]; CONWAYPOLDATA[74453]:=[ ,,,[38255738274,"JB"],]; CONWAYPOLDATA[74471]:=[ ,,,[30613464220,"JB"],]; CONWAYPOLDATA[74489]:=[ ,,,[44126166268,"JB"],]; CONWAYPOLDATA[74507]:=[ ,,,[42247778719,"JB"],]; CONWAYPOLDATA[74509]:=[ ,,,[60468300515,"JB"],]; CONWAYPOLDATA[74521]:=[ ,,,[60875757787,"JB"],]; CONWAYPOLDATA[74527]:=[ ,,,[32011656840,"JB"],]; CONWAYPOLDATA[74531]:=[ ,,,[42254307018,"JB"],]; CONWAYPOLDATA[74551]:=[ ,,,[16132314554,"JB"],]; CONWAYPOLDATA[74561]:=[ ,,,[5558447992,"JB"],]; CONWAYPOLDATA[74567]:=[ ,,,[22240651693,"JB"],]; CONWAYPOLDATA[74573]:=[ ,,,[37484491317,"JB"],]; CONWAYPOLDATA[74587]:=[ ,,,[50033705472,"JB"],]; CONWAYPOLDATA[74597]:=[ ,,,[20429358213,"JB"],]; CONWAYPOLDATA[74609]:=[ ,,,[14714760028,"JB"],]; CONWAYPOLDATA[74611]:=[ ,,,[14262713373,"JB"],]; CONWAYPOLDATA[74623]:=[ ,,,[30795046528,"JB"],]; CONWAYPOLDATA[74653]:=[ ,,,[19528552925,"JB"],]; CONWAYPOLDATA[74687]:=[ ,,,[31504320971,"JB"],]; CONWAYPOLDATA[74699]:=[ ,,,[43674339031,"JB"],]; CONWAYPOLDATA[74707]:=[ ,,,[44451113244,"JB"],]; CONWAYPOLDATA[74713]:=[ ,,,[92826494443,"JB"],]; CONWAYPOLDATA[74717]:=[ ,,,[10643361935,"JB"],]; CONWAYPOLDATA[74719]:=[ ,,,[3919758747,"JB"],]; CONWAYPOLDATA[74729]:=[ ,,,[27207707968,"JB"],]; CONWAYPOLDATA[74731]:=[ ,,,[31409588764,"JB"],]; CONWAYPOLDATA[74747]:=[ ,,,[43024298455,"JB"],]; CONWAYPOLDATA[74759]:=[ ,,,[21858709262,"JB"],]; CONWAYPOLDATA[74761]:=[ ,,,[104918690287,"JB"],]; CONWAYPOLDATA[74771]:=[ ,,,[26386386818,"JB"],]; CONWAYPOLDATA[74779]:=[ ,,,[38424665699,"JB"],]; CONWAYPOLDATA[74797]:=[ ,,,[44209739216,"JB"],]; CONWAYPOLDATA[74821]:=[ ,,,[39186975009,"JB"],]; CONWAYPOLDATA[74827]:=[ ,,,[31976944318,"JB"],]; CONWAYPOLDATA[74831]:=[ ,,,[25852239732,"JB"],]; CONWAYPOLDATA[74843]:=[ ,,,[44091957220,"JB"],]; CONWAYPOLDATA[74857]:=[ ,,,[59213608716,"JB"],]; CONWAYPOLDATA[74861]:=[ ,,,[10038860102,"JB"],]; CONWAYPOLDATA[74869]:=[ ,,,[210644081240,"JB"],]; CONWAYPOLDATA[74873]:=[ ,,,[26319282090,"JB"],]; CONWAYPOLDATA[74887]:=[ ,,,[15874621150,"JB"],]; CONWAYPOLDATA[74891]:=[ ,,,[53898753138,"JB"],]; CONWAYPOLDATA[74897]:=[ ,,,[8963672963,"JB"],]; CONWAYPOLDATA[74903]:=[ ,,,[22441538029,"JB"],]; CONWAYPOLDATA[74923]:=[ ,,,[22453524029,"JB"],]; CONWAYPOLDATA[74929]:=[ ,,,[151586162473,"JB"],]; CONWAYPOLDATA[74933]:=[ ,,,[37960083673,"JB"],]; CONWAYPOLDATA[74941]:=[ ,,,[47779608789,"JB"],]; CONWAYPOLDATA[74959]:=[ ,,,[28093958572,"JB"],]; CONWAYPOLDATA[75011]:=[ ,,,[45012450864,"JB"],]; CONWAYPOLDATA[75013]:=[ ,,,[61397840450,"JB"],]; CONWAYPOLDATA[75017]:=[ ,,,[48430825169,"JB"],]; CONWAYPOLDATA[75029]:=[ ,,,[25744775801,"JB"],]; CONWAYPOLDATA[75037]:=[ ,,,[60442903798,"JB"],]; CONWAYPOLDATA[75041]:=[ ,,,[15819393213,"JB"],]; CONWAYPOLDATA[75079]:=[ ,,,[20650328795,"JB"],]; CONWAYPOLDATA[75083]:=[ ,,,[42370012649,"JB"],]; CONWAYPOLDATA[75109]:=[ ,,,[44813334198,"JB"],]; CONWAYPOLDATA[75133]:=[ ,,,[38605589392,"JB"],]; CONWAYPOLDATA[75149]:=[ ,,,[4285221429,"JB"],]; CONWAYPOLDATA[75161]:=[ ,,,[15595531698,"JB"],]; CONWAYPOLDATA[75167]:=[ ,,,[33770127761,"JB"],]; CONWAYPOLDATA[75169]:=[ ,,,[4444968484,"JB"],]; CONWAYPOLDATA[75181]:=[ ,,,[38561312255,"JB"],]; CONWAYPOLDATA[75193]:=[ ,,,[59979651475,"JB"],]; CONWAYPOLDATA[75209]:=[ ,,,[5655491176,"JB"],]; CONWAYPOLDATA[75211]:=[ ,,,[37995694670,"JB"],]; CONWAYPOLDATA[75217]:=[ ,,,[135085820721,"JB"],]; CONWAYPOLDATA[75223]:=[ ,,,[21817302808,"JB"],]; CONWAYPOLDATA[75227]:=[ ,,,[14229638414,"JB"],]; CONWAYPOLDATA[75239]:=[ ,,,[96163944020,"JB"],]; CONWAYPOLDATA[75253]:=[ ,,,[20279027936,"JB"],]; CONWAYPOLDATA[75269]:=[ ,,,[21604084727,"JB"],]; CONWAYPOLDATA[75277]:=[ ,,,[38059524263,"JB"],]; CONWAYPOLDATA[75289]:=[ ,,,[231518418220,"JB"],]; CONWAYPOLDATA[75307]:=[ ,,,[39049089327,"JB"],]; CONWAYPOLDATA[75323]:=[ ,,,[42707387772,"JB"],]; CONWAYPOLDATA[75329]:=[ ,,,[5673554296,"JB"],]; CONWAYPOLDATA[75337]:=[ ,,,[38508055533,"JB"],]; CONWAYPOLDATA[75347]:=[ ,,,[66661977353,"JB"],]; CONWAYPOLDATA[75353]:=[ ,,,[54832418925,"JB"],]; CONWAYPOLDATA[75367]:=[ ,,,[32493050080,"JB"],]; CONWAYPOLDATA[75377]:=[ ,,,[54730862818,"JB"],]; CONWAYPOLDATA[75389]:=[ ,,,[20893835185,"JB"],]; CONWAYPOLDATA[75391]:=[ ,,,[21797045923,"JB"],]; CONWAYPOLDATA[75401]:=[ ,,,[44641463657,"JB"],]; CONWAYPOLDATA[75403]:=[ ,,,[14979786192,"JB"],]; CONWAYPOLDATA[75407]:=[ ,,,[22744560973,"JB"],]; CONWAYPOLDATA[75431]:=[ ,,,[21921908101,"JB"],]; CONWAYPOLDATA[75437]:=[ ,,,[21063217394,"JB"],]; CONWAYPOLDATA[75479]:=[ ,,,[15524143344,"JB"],]; CONWAYPOLDATA[75503]:=[ ,,,[22802510029,"JB"],]; CONWAYPOLDATA[75511]:=[ ,,,[16230787409,"JB"],]; CONWAYPOLDATA[75521]:=[ ,,,[27243143459,"JB"],]; CONWAYPOLDATA[75527]:=[ ,,,[14414403482,"JB"],]; CONWAYPOLDATA[75533]:=[ ,,,[21316092399,"JB"],]; CONWAYPOLDATA[75539]:=[ ,,,[5366894874,"JB"],]; CONWAYPOLDATA[75541]:=[ ,,,[38911773430,"JB"],]; CONWAYPOLDATA[75553]:=[ ,,,[60825378162,"JB"],]; CONWAYPOLDATA[75557]:=[ ,,,[8827022084,"JB"],]; CONWAYPOLDATA[75571]:=[ ,,,[14529960601,"JB"],]; CONWAYPOLDATA[75577]:=[ ,,,[102811927737,"JB"],]; CONWAYPOLDATA[75583]:=[ ,,,[118604238941,"JB"],]; CONWAYPOLDATA[75611]:=[ ,,,[21411825426,"JB"],]; CONWAYPOLDATA[75617]:=[ ,,,[15203402789,"JB"],]; CONWAYPOLDATA[75619]:=[ ,,,[31504312163,"JB"],]; CONWAYPOLDATA[75629]:=[ ,,,[74273501435,"JB"],]; CONWAYPOLDATA[75641]:=[ ,,,[17135258297,"JB"],]; CONWAYPOLDATA[75653]:=[ ,,,[39128412479,"JB"],]; CONWAYPOLDATA[75659]:=[ ,,,[16487987577,"JB"],]; CONWAYPOLDATA[75679]:=[ ,,,[27543599093,"JB"],]; CONWAYPOLDATA[75683]:=[ ,,,[14830537950,"JB"],]; CONWAYPOLDATA[75689]:=[ ,,,[5727916456,"JB"],]; CONWAYPOLDATA[75703]:=[ ,,,[55325644980,"JB"],]; CONWAYPOLDATA[75707]:=[ ,,,[37784833753,"JB"],]; CONWAYPOLDATA[75709]:=[ ,,,[73537665882,"JB"],]; CONWAYPOLDATA[75721]:=[ ,,,[119867327384,"JB"],]; CONWAYPOLDATA[75731]:=[ ,,,[112585415421,"JB"],]; CONWAYPOLDATA[75743]:=[ ,,,[27717317682,"JB"],]; CONWAYPOLDATA[75767]:=[ ,,,[43857046052,"JB"],]; CONWAYPOLDATA[75773]:=[ ,,,[37674184056,"JB"],]; CONWAYPOLDATA[75781]:=[ ,,,[51593902455,"JB"],]; CONWAYPOLDATA[75787]:=[ ,,,[17082010870,"JB"],]; CONWAYPOLDATA[75793]:=[ ,,,[49996170323,"JB"],]; CONWAYPOLDATA[75797]:=[ ,,,[43189509587,"JB"],]; CONWAYPOLDATA[75821]:=[ ,,,[3506721252,"JB"],]; CONWAYPOLDATA[75833]:=[ ,,,[25934127673,"JB"],]; CONWAYPOLDATA[75853]:=[ ,,,[9400158883,"JB"],]; CONWAYPOLDATA[75869]:=[ ,,,[4369599188,"JB"],]; CONWAYPOLDATA[75883]:=[ ,,,[43329648300,"JB"],]; CONWAYPOLDATA[75913]:=[ ,,,[72929846844,"JB"],]; CONWAYPOLDATA[75931]:=[ ,,,[20799551040,"JB"],]; CONWAYPOLDATA[75937]:=[ ,,,[3265215073,"JB"],]; CONWAYPOLDATA[75941]:=[ ,,,[21760893552,"JB"],]; CONWAYPOLDATA[75967]:=[ ,,,[28854621580,"JB"],]; CONWAYPOLDATA[75979]:=[ ,,,[49913568283,"JB"],]; CONWAYPOLDATA[75983]:=[ ,,,[45475825505,"JB"],]; CONWAYPOLDATA[75989]:=[ ,,,[5522956511,"JB"],]; CONWAYPOLDATA[75991]:=[ ,,,[27768859204,"JB"],]; CONWAYPOLDATA[75997]:=[ ,,,[39759046504,"JB"],]; CONWAYPOLDATA[76001]:=[ ,,,[15643133831,"JB"],]; CONWAYPOLDATA[76003]:=[ ,,,[32362685429,"JB"],]; CONWAYPOLDATA[76031]:=[ ,,,[16264551527,"JB"],]; CONWAYPOLDATA[76039]:=[ ,,,[21013909935,"JB"],]; CONWAYPOLDATA[76079]:=[ ,,,[45664517786,"JB"],]; CONWAYPOLDATA[76081]:=[ ,,,[3507866674,"JB"],]; CONWAYPOLDATA[76091]:=[ ,,,[49983340901,"JB"],]; CONWAYPOLDATA[76099]:=[ ,,,[39802059977,"JB"],]; CONWAYPOLDATA[76103]:=[ ,,,[40176219662,"JB"],]; CONWAYPOLDATA[76123]:=[ ,,,[22499903482,"JB"],]; CONWAYPOLDATA[76129]:=[ ,,,[283982333879,"JB"],]; CONWAYPOLDATA[76147]:=[ ,,,[49720183652,"JB"],]; CONWAYPOLDATA[76157]:=[ ,,,[40523444330,"JB"],]; CONWAYPOLDATA[76159]:=[ ,,,[39998402167,"JB"],]; CONWAYPOLDATA[76163]:=[ ,,,[22315911328,"JB"],]; CONWAYPOLDATA[76207]:=[ ,,,[34653380492,"JB"],]; CONWAYPOLDATA[76213]:=[ ,,,[45686340133,"JB"],]; CONWAYPOLDATA[76231]:=[ ,,,[27547596476,"JB"],]; CONWAYPOLDATA[76243]:=[ ,,,[32342585575,"JB"],]; CONWAYPOLDATA[76249]:=[ ,,,[4330180717,"JB"],]; CONWAYPOLDATA[76253]:=[ ,,,[27804131392,"JB"],]; CONWAYPOLDATA[76259]:=[ ,,,[45153030161,"JB"],]; CONWAYPOLDATA[76261]:=[ ,,,[52341127264,"JB"],]; CONWAYPOLDATA[76283]:=[ ,,,[45132531820,"JB"],]; CONWAYPOLDATA[76289]:=[ ,,,[27443975996,"JB"],]; CONWAYPOLDATA[76303]:=[ ,,,[52323332496,"JB"],]; CONWAYPOLDATA[76333]:=[ ,,,[22263664450,"JB"],]; CONWAYPOLDATA[76343]:=[ ,,,[4444078721,"JB"],]; CONWAYPOLDATA[76367]:=[ ,,,[46038991460,"JB"],]; CONWAYPOLDATA[76369]:=[ ,,,[69985620777,"JB"],]; CONWAYPOLDATA[76379]:=[ ,,,[3106563069,"JB"],]; CONWAYPOLDATA[76387]:=[ ,,,[16848069497,"JB"],]; CONWAYPOLDATA[76403]:=[ ,,,[46033189517,"JB"],]; CONWAYPOLDATA[76421]:=[ ,,,[40697010080,"JB"],]; CONWAYPOLDATA[76423]:=[ ,,,[110967800888,"JB"],]; CONWAYPOLDATA[76441]:=[ ,,,[138113981016,"JB"],]; CONWAYPOLDATA[76463]:=[ ,,,[33368223816,"JB"],]; CONWAYPOLDATA[76471]:=[ ,,,[21160290416,"JB"],]; CONWAYPOLDATA[76481]:=[ ,,,[14725345819,"JB"],]; CONWAYPOLDATA[76487]:=[ ,,,[15799384186,"JB"],]; CONWAYPOLDATA[76493]:=[ ,,,[14980848080,"JB"],]; CONWAYPOLDATA[76507]:=[ ,,,[52126437805,"JB"],]; CONWAYPOLDATA[76511]:=[ ,,,[68531132240,"JB"],]; CONWAYPOLDATA[76519]:=[ ,,,[39698057203,"JB"],]; CONWAYPOLDATA[76537]:=[ ,,,[61865699012,"JB"],]; CONWAYPOLDATA[76541]:=[ ,,,[52726186344,"JB"],]; CONWAYPOLDATA[76543]:=[ ,,,[38261779042,"JB"],]; CONWAYPOLDATA[76561]:=[ ,,,[120821373483,"JB"],]; CONWAYPOLDATA[76579]:=[ ,,,[15590335729,"JB"],]; CONWAYPOLDATA[76597]:=[ ,,,[61998454374,"JB"],]; CONWAYPOLDATA[76603]:=[ ,,,[51452626439,"JB"],]; CONWAYPOLDATA[76607]:=[ ,,,[46739156417,"JB"],]; CONWAYPOLDATA[76631]:=[ ,,,[40636116580,"JB"],]; CONWAYPOLDATA[76649]:=[ ,,,[4313652428,"JB"],]; CONWAYPOLDATA[76651]:=[ ,,,[33375378423,"JB"],]; CONWAYPOLDATA[76667]:=[ ,,,[45898539560,"JB"],]; CONWAYPOLDATA[76673]:=[ ,,,[57997374028,"JB"],]; CONWAYPOLDATA[76679]:=[ ,,,[27781415139,"JB"],]; CONWAYPOLDATA[76697]:=[ ,,,[9784006202,"JB"],]; CONWAYPOLDATA[76717]:=[ ,,,[56428038597,"JB"],]; CONWAYPOLDATA[76733]:=[ ,,,[21964744519,"JB"],]; CONWAYPOLDATA[76753]:=[ ,,,[38369054964,"JB"],]; CONWAYPOLDATA[76757]:=[ ,,,[21476455088,"JB"],]; CONWAYPOLDATA[76771]:=[ ,,,[52638803862,"JB"],]; CONWAYPOLDATA[76777]:=[ ,,,[88419771393,"JB"],]; CONWAYPOLDATA[76781]:=[ ,,,[58237083225,"JB"],]; CONWAYPOLDATA[76801]:=[ ,,,[121716068041,"JB"],]; CONWAYPOLDATA[76819]:=[ ,,,[52337168802,"JB"],]; CONWAYPOLDATA[76829]:=[ ,,,[40146840294,"JB"],]; CONWAYPOLDATA[76831]:=[ ,,,[16306841962,"JB"],]; CONWAYPOLDATA[76837]:=[ ,,,[10527437375,"JB"],]; CONWAYPOLDATA[76847]:=[ ,,,[57002107572,"JB"],]; CONWAYPOLDATA[76871]:=[ ,,,[16319021468,"JB"],]; CONWAYPOLDATA[76873]:=[ ,,,[134625455593,"JB"],]; CONWAYPOLDATA[76883]:=[ ,,,[26848773730,"JB"],]; CONWAYPOLDATA[76907]:=[ ,,,[45691525400,"JB"],]; CONWAYPOLDATA[76913]:=[ ,,,[4035625113,"JB"],]; CONWAYPOLDATA[76919]:=[ ,,,[21479323087,"JB"],]; CONWAYPOLDATA[76943]:=[ ,,,[29019360232,"JB"],]; CONWAYPOLDATA[76949]:=[ ,,,[11481945037,"JB"],]; CONWAYPOLDATA[76961]:=[ ,,,[5922071992,"JB"],]; CONWAYPOLDATA[76963]:=[ ,,,[46657664308,"JB"],]; CONWAYPOLDATA[76991]:=[ ,,,[27975603755,"JB"],]; CONWAYPOLDATA[77003]:=[ ,,,[16149454177,"JB"],]; CONWAYPOLDATA[77017]:=[ ,,,[64272072813,"JB"],]; CONWAYPOLDATA[77023]:=[ ,,,[41425280093,"JB"],]; CONWAYPOLDATA[77029]:=[ ,,,[4478928236,"JB"],]; CONWAYPOLDATA[77041]:=[ ,,,[4633014624,"JB"],]; CONWAYPOLDATA[77047]:=[ ,,,[22528388709,"JB"],]; CONWAYPOLDATA[77069]:=[ ,,,[11764043369,"JB"],]; CONWAYPOLDATA[77081]:=[ ,,,[5940555592,"JB"],]; CONWAYPOLDATA[77093]:=[ ,,,[29397719506,"JB"],]; CONWAYPOLDATA[77101]:=[ ,,,[26862296811,"JB"],]; CONWAYPOLDATA[77137]:=[ ,,,[29297635394,"JB"],]; CONWAYPOLDATA[77141]:=[ ,,,[29753360844,"JB"],]; CONWAYPOLDATA[77153]:=[ ,,,[3582908170,"JB"],]; CONWAYPOLDATA[77167]:=[ ,,,[74507825201,"JB"],]; CONWAYPOLDATA[77171]:=[ ,,,[28082141047,"JB"],]; CONWAYPOLDATA[77191]:=[ ,,,[64993664141,"JB"],]; CONWAYPOLDATA[77201]:=[ ,,,[16570808648,"JB"],]; CONWAYPOLDATA[77213]:=[ ,,,[27078753528,"JB"],]; CONWAYPOLDATA[77237]:=[ ,,,[22298630850,"JB"],]; CONWAYPOLDATA[77239]:=[ ,,,[16644618308,"JB"],]; CONWAYPOLDATA[77243]:=[ ,,,[16013323575,"JB"],]; CONWAYPOLDATA[77249]:=[ ,,,[27893764164,"JB"],]; CONWAYPOLDATA[77261]:=[ ,,,[118004124786,"JB"],]; CONWAYPOLDATA[77263]:=[ ,,,[71633926877,"JB"],]; CONWAYPOLDATA[77267]:=[ ,,,[46459488097,"JB"],]; CONWAYPOLDATA[77269]:=[ ,,,[59435855685,"JB"],]; CONWAYPOLDATA[77279]:=[ ,,,[34206931129,"JB"],]; CONWAYPOLDATA[77291]:=[ ,,,[5060473645,"JB"],]; CONWAYPOLDATA[77317]:=[ ,,,[118766411751,"JB"],]; CONWAYPOLDATA[77323]:=[ ,,,[52394451417,"JB"],]; CONWAYPOLDATA[77339]:=[ ,,,[27896796014,"JB"],]; CONWAYPOLDATA[77347]:=[ ,,,[16857159877,"JB"],]; CONWAYPOLDATA[77351]:=[ ,,,[44941008365,"JB"],]; CONWAYPOLDATA[77359]:=[ ,,,[16263569368,"JB"],]; CONWAYPOLDATA[77369]:=[ ,,,[45151387868,"JB"],]; CONWAYPOLDATA[77377]:=[ ,,,[65618558954,"JB"],]; CONWAYPOLDATA[77383]:=[ ,,,[23122427318,"JB"],]; CONWAYPOLDATA[77417]:=[ ,,,[58353373421,"JB"],]; CONWAYPOLDATA[77419]:=[ ,,,[15708934454,"JB"],]; CONWAYPOLDATA[77431]:=[ ,,,[15385462272,"JB"],]; CONWAYPOLDATA[77447]:=[ ,,,[29061909308,"JB"],]; CONWAYPOLDATA[77471]:=[ ,,,[21447923828,"JB"],]; CONWAYPOLDATA[77477]:=[ ,,,[29404225996,"JB"],]; CONWAYPOLDATA[77479]:=[ ,,,[34980993716,"JB"],]; CONWAYPOLDATA[77489]:=[ ,,,[23336742221,"JB"],]; CONWAYPOLDATA[77491]:=[ ,,,[15663488306,"JB"],]; CONWAYPOLDATA[77509]:=[ ,,,[45623037546,"JB"],]; CONWAYPOLDATA[77513]:=[ ,,,[11456266377,"JB"],]; CONWAYPOLDATA[77521]:=[ ,,,[4734595082,"JB"],]; CONWAYPOLDATA[77527]:=[ ,,,[63183574681,"JB"],]; CONWAYPOLDATA[77543]:=[ ,,,[24051357229,"JB"],]; CONWAYPOLDATA[77549]:=[ ,,,[10512154697,"JB"],]; CONWAYPOLDATA[77551]:=[ ,,,[22080708481,"JB"],]; CONWAYPOLDATA[77557]:=[ ,,,[39352034020,"JB"],]; CONWAYPOLDATA[77563]:=[ ,,,[64530244238,"JB"],]; CONWAYPOLDATA[77569]:=[ ,,,[6013924583,"JB"],]; CONWAYPOLDATA[77573]:=[ ,,,[10118079111,"JB"],]; CONWAYPOLDATA[77587]:=[ ,,,[15967714950,"JB"],]; CONWAYPOLDATA[77591]:=[ ,,,[39151099566,"JB"],]; CONWAYPOLDATA[77611]:=[ ,,,[53928469018,"JB"],]; CONWAYPOLDATA[77617]:=[ ,,,[40710892680,"JB"],]; CONWAYPOLDATA[77621]:=[ ,,,[54224633424,"JB"],]; CONWAYPOLDATA[77641]:=[ ,,,[259094849421,"JB"],]; CONWAYPOLDATA[77647]:=[ ,,,[40857230227,"JB"],]; CONWAYPOLDATA[77659]:=[ ,,,[53921361767,"JB"],]; CONWAYPOLDATA[77681]:=[ ,,,[6033405592,"JB"],]; CONWAYPOLDATA[77687]:=[ ,,,[22262608221,"JB"],]; CONWAYPOLDATA[77689]:=[ ,,,[53134381607,"JB"],]; CONWAYPOLDATA[77699]:=[ ,,,[58414418998,"JB"],]; CONWAYPOLDATA[77711]:=[ ,,,[47407051587,"JB"],]; CONWAYPOLDATA[77713]:=[ ,,,[75861099217,"JB"],]; CONWAYPOLDATA[77719]:=[ ,,,[54258276352,"JB"],]; CONWAYPOLDATA[77723]:=[ ,,,[52881174742,"JB"],]; CONWAYPOLDATA[77731]:=[ ,,,[16277493250,"JB"],]; CONWAYPOLDATA[77743]:=[ ,,,[15546034484,"JB"],]; CONWAYPOLDATA[77747]:=[ ,,,[54400819854,"JB"],]; CONWAYPOLDATA[77761]:=[ ,,,[99796056820,"JB"],]; CONWAYPOLDATA[77773]:=[ ,,,[41363258960,"JB"],]; CONWAYPOLDATA[77783]:=[ ,,,[36157271989,"JB"],]; CONWAYPOLDATA[77797]:=[ ,,,[63918326393,"JB"],]; CONWAYPOLDATA[77801]:=[ ,,,[84740538003,"JB"],]; CONWAYPOLDATA[77813]:=[ ,,,[46031992038,"JB"],]; CONWAYPOLDATA[77839]:=[ ,,,[39466318978,"JB"],]; CONWAYPOLDATA[77849]:=[ ,,,[82958307722,"JB"],]; CONWAYPOLDATA[77863]:=[ ,,,[24250275629,"JB"],]; CONWAYPOLDATA[77867]:=[ ,,,[15339643268,"JB"],]; CONWAYPOLDATA[77893]:=[ ,,,[63843050127,"JB"],]; CONWAYPOLDATA[77899]:=[ ,,,[18044991768,"JB"],]; CONWAYPOLDATA[77929]:=[ ,,,[58382224802,"JB"],]; CONWAYPOLDATA[77933]:=[ ,,,[17416856507,"JB"],]; CONWAYPOLDATA[77951]:=[ ,,,[40820834034,"JB"],]; CONWAYPOLDATA[77969]:=[ ,,,[17656158022,"JB"],]; CONWAYPOLDATA[77977]:=[ ,,,[64143880205,"JB"],]; CONWAYPOLDATA[77983]:=[ ,,,[40739254999,"JB"],]; CONWAYPOLDATA[77999]:=[ ,,,[47221842595,"JB"],]; CONWAYPOLDATA[78007]:=[ ,,,[36448926767,"JB"],]; CONWAYPOLDATA[78017]:=[ ,,,[10306357771,"JB"],]; CONWAYPOLDATA[78031]:=[ ,,,[4773936587,"JB"],]; CONWAYPOLDATA[78041]:=[ ,,,[29802687288,"JB"],]; CONWAYPOLDATA[78049]:=[ ,,,[3644263915,"JB"],]; CONWAYPOLDATA[78059]:=[ ,,,[21729986363,"JB"],]; CONWAYPOLDATA[78079]:=[ ,,,[33670787972,"JB"],]; CONWAYPOLDATA[78101]:=[ ,,,[42253187709,"JB"],]; CONWAYPOLDATA[78121]:=[ ,,,[102868404754,"JB"],]; CONWAYPOLDATA[78137]:=[ ,,,[17959945727,"JB"],]; CONWAYPOLDATA[78139]:=[ ,,,[48776551695,"JB"],]; CONWAYPOLDATA[78157]:=[ ,,,[52589891381,"JB"],]; CONWAYPOLDATA[78163]:=[ ,,,[18199082108,"JB"],]; CONWAYPOLDATA[78167]:=[ ,,,[40157358251,"JB"],]; CONWAYPOLDATA[78173]:=[ ,,,[4474388003,"JB"],]; CONWAYPOLDATA[78179]:=[ ,,,[16514453783,"JB"],]; CONWAYPOLDATA[78191]:=[ ,,,[41302519177,"JB"],]; CONWAYPOLDATA[78193]:=[ ,,,[40305051013,"JB"],]; CONWAYPOLDATA[78203]:=[ ,,,[18293558574,"JB"],]; CONWAYPOLDATA[78229]:=[ ,,,[95457842046,"JB"],]; CONWAYPOLDATA[78233]:=[ ,,,[17948918960,"JB"],]; CONWAYPOLDATA[78241]:=[ ,,,[250751060074,"JB"],]; CONWAYPOLDATA[78259]:=[ ,,,[10598538113,"JB"],]; CONWAYPOLDATA[78277]:=[ ,,,[49017527068,"JB"],]; CONWAYPOLDATA[78283]:=[ ,,,[34329678842,"JB"],]; CONWAYPOLDATA[78301]:=[ ,,,[65159038467,"JB"],]; CONWAYPOLDATA[78307]:=[ ,,,[72511890467,"JB"],]; CONWAYPOLDATA[78311]:=[ ,,,[15917415563,"JB"],]; CONWAYPOLDATA[78317]:=[ ,,,[46508707086,"JB"],]; CONWAYPOLDATA[78341]:=[ ,,,[53586889163,"JB"],]; CONWAYPOLDATA[78347]:=[ ,,,[17416773143,"JB"],]; CONWAYPOLDATA[78367]:=[ ,,,[73695699869,"JB"],]; CONWAYPOLDATA[78401]:=[ ,,,[6097637788,"JB"],]; CONWAYPOLDATA[78427]:=[ ,,,[46919423315,"JB"],]; CONWAYPOLDATA[78437]:=[ ,,,[46732686165,"JB"],]; CONWAYPOLDATA[78439]:=[ ,,,[64645658734,"JB"],]; CONWAYPOLDATA[78467]:=[ ,,,[23623902758,"JB"],]; CONWAYPOLDATA[78479]:=[ ,,,[17688146380,"JB"],]; CONWAYPOLDATA[78487]:=[ ,,,[36650289523,"JB"],]; CONWAYPOLDATA[78497]:=[ ,,,[84326422714,"JB"],]; CONWAYPOLDATA[78509]:=[ ,,,[30818001372,"JB"],]; CONWAYPOLDATA[78511]:=[ ,,,[21782327376,"JB"],]; CONWAYPOLDATA[78517]:=[ ,,,[55483723984,"JB"],]; CONWAYPOLDATA[78539]:=[ ,,,[55514820918,"JB"],]; CONWAYPOLDATA[78541]:=[ ,,,[66721836158,"JB"],]; CONWAYPOLDATA[78553]:=[ ,,,[92557743057,"JB"],]; CONWAYPOLDATA[78569]:=[ ,,,[28786974482,"JB"],]; CONWAYPOLDATA[78571]:=[ ,,,[12009184497,"JB"],]; CONWAYPOLDATA[78577]:=[ ,,,[73214669794,"JB"],]; CONWAYPOLDATA[78583]:=[ ,,,[34045770421,"JB"],]; CONWAYPOLDATA[78593]:=[ ,,,[79194000674,"JB"],]; CONWAYPOLDATA[78607]:=[ ,,,[42421761086,"JB"],]; CONWAYPOLDATA[78623]:=[ ,,,[48987553992,"JB"],]; CONWAYPOLDATA[78643]:=[ ,,,[17513638825,"JB"],]; CONWAYPOLDATA[78649]:=[ ,,,[79049873964,"JB"],]; CONWAYPOLDATA[78653]:=[ ,,,[71588623502,"JB"],]; CONWAYPOLDATA[78691]:=[ ,,,[42145955315,"JB"],]; CONWAYPOLDATA[78697]:=[ ,,,[42810853217,"JB"],]; CONWAYPOLDATA[78707]:=[ ,,,[46587302958,"JB"],]; CONWAYPOLDATA[78713]:=[ ,,,[53554593517,"JB"],]; CONWAYPOLDATA[78721]:=[ ,,,[3559291301,"JB"],]; CONWAYPOLDATA[78737]:=[ ,,,[60579775381,"JB"],]; CONWAYPOLDATA[78779]:=[ ,,,[48244495939,"JB"],]; CONWAYPOLDATA[78781]:=[ ,,,[15937553872,"JB"],]; CONWAYPOLDATA[78787]:=[ ,,,[55621258392,"JB"],]; CONWAYPOLDATA[78791]:=[ ,,,[21797136206,"JB"],]; CONWAYPOLDATA[78797]:=[ ,,,[30183900025,"JB"],]; CONWAYPOLDATA[78803]:=[ ,,,[49038161266,"JB"],]; CONWAYPOLDATA[78809]:=[ ,,,[5091455448,"JB"],]; CONWAYPOLDATA[78823]:=[ ,,,[16877817232,"JB"],]; CONWAYPOLDATA[78839]:=[ ,,,[46928205212,"JB"],]; CONWAYPOLDATA[78853]:=[ ,,,[41319523976,"JB"],]; CONWAYPOLDATA[78857]:=[ ,,,[24654483339,"JB"],]; CONWAYPOLDATA[78877]:=[ ,,,[43352928881,"JB"],]; CONWAYPOLDATA[78887]:=[ ,,,[66797567255,"JB"],]; CONWAYPOLDATA[78889]:=[ ,,,[66982441019,"JB"],]; CONWAYPOLDATA[78893]:=[ ,,,[42032691435,"JB"],]; CONWAYPOLDATA[78901]:=[ ,,,[35923783112,"JB"],]; CONWAYPOLDATA[78919]:=[ ,,,[24570089030,"JB"],]; CONWAYPOLDATA[78929]:=[ ,,,[12108261106,"JB"],]; CONWAYPOLDATA[78941]:=[ ,,,[5689751518,"JB"],]; CONWAYPOLDATA[78977]:=[ ,,,[30804978853,"JB"],]; CONWAYPOLDATA[78979]:=[ ,,,[42186474895,"JB"],]; CONWAYPOLDATA[78989]:=[ ,,,[5154190230,"JB"],]; CONWAYPOLDATA[79031]:=[ ,,,[35403912232,"JB"],]; CONWAYPOLDATA[79039]:=[ ,,,[16200228641,"JB"],]; CONWAYPOLDATA[79043]:=[ ,,,[30936718815,"JB"],]; CONWAYPOLDATA[79063]:=[ ,,,[25003515629,"JB"],]; CONWAYPOLDATA[79087]:=[ ,,,[103812838770,"JB"],]; CONWAYPOLDATA[79103]:=[ ,,,[35493516105,"JB"],]; CONWAYPOLDATA[79111]:=[ ,,,[17116772410,"JB"],]; CONWAYPOLDATA[79133]:=[ ,,,[9580948844,"JB"],]; CONWAYPOLDATA[79139]:=[ ,,,[56048851389,"JB"],]; CONWAYPOLDATA[79147]:=[ ,,,[56377674454,"JB"],]; CONWAYPOLDATA[79151]:=[ ,,,[17904193666,"JB"],]; CONWAYPOLDATA[79153]:=[ ,,,[161970229839,"JB"],]; CONWAYPOLDATA[79159]:=[ ,,,[31330419772,"JB"],]; CONWAYPOLDATA[79181]:=[ ,,,[43088716582,"JB"],]; CONWAYPOLDATA[79187]:=[ ,,,[10862793478,"JB"],]; CONWAYPOLDATA[79193]:=[ ,,,[99848672614,"JB"],]; CONWAYPOLDATA[79201]:=[ ,,,[104904734151,"JB"],]; CONWAYPOLDATA[79229]:=[ ,,,[23420963921,"JB"],]; CONWAYPOLDATA[79231]:=[ ,,,[31387439884,"JB"],]; CONWAYPOLDATA[79241]:=[ ,,,[18735187356,"JB"],]; CONWAYPOLDATA[79259]:=[ ,,,[85213887190,"JB"],]; CONWAYPOLDATA[79273]:=[ ,,,[94262255937,"JB"],]; CONWAYPOLDATA[79279]:=[ ,,,[41861690373,"JB"],]; CONWAYPOLDATA[79283]:=[ ,,,[29928777521,"JB"],]; CONWAYPOLDATA[79301]:=[ ,,,[23206882545,"JB"],]; CONWAYPOLDATA[79309]:=[ ,,,[66556985201,"JB"],]; CONWAYPOLDATA[79319]:=[ ,,,[16150696830,"JB"],]; CONWAYPOLDATA[79333]:=[ ,,,[42649579471,"JB"],]; CONWAYPOLDATA[79337]:=[ ,,,[4786163202,"JB"],]; CONWAYPOLDATA[79349]:=[ ,,,[42551297997,"JB"],]; CONWAYPOLDATA[79357]:=[ ,,,[49258715118,"JB"],]; CONWAYPOLDATA[79367]:=[ ,,,[75588495869,"JB"],]; CONWAYPOLDATA[79379]:=[ ,,,[18864339973,"JB"],]; CONWAYPOLDATA[79393]:=[ ,,,[106924904545,"JB"],]; CONWAYPOLDATA[79397]:=[ ,,,[24636015735,"JB"],]; CONWAYPOLDATA[79399]:=[ ,,,[43193214801,"JB"],]; CONWAYPOLDATA[79411]:=[ ,,,[56754406414,"JB"],]; CONWAYPOLDATA[79423]:=[ ,,,[41783169535,"JB"],]; CONWAYPOLDATA[79427]:=[ ,,,[31338081706,"JB"],]; CONWAYPOLDATA[79433]:=[ ,,,[294888419564,"JB"],]; CONWAYPOLDATA[79451]:=[ ,,,[41430200662,"JB"],]; CONWAYPOLDATA[79481]:=[ ,,,[3718915996,"JB"],]; CONWAYPOLDATA[79493]:=[ ,,,[23435569814,"JB"],]; CONWAYPOLDATA[79531]:=[ ,,,[54137149357,"JB"],]; CONWAYPOLDATA[79537]:=[ ,,,[132610369830,"JB"],]; CONWAYPOLDATA[79549]:=[ ,,,[50258421810,"JB"],]; CONWAYPOLDATA[79559]:=[ ,,,[49719203672,"JB"],]; CONWAYPOLDATA[79561]:=[ ,,,[6138210718,"JB"],]; CONWAYPOLDATA[79579]:=[ ,,,[36512038895,"JB"],]; CONWAYPOLDATA[79589]:=[ ,,,[10540607984,"JB"],]; CONWAYPOLDATA[79601]:=[ ,,,[15865912121,"JB"],]; CONWAYPOLDATA[79609]:=[ ,,,[56472315953,"JB"],]; CONWAYPOLDATA[79613]:=[ ,,,[81078516106,"JB"],]; CONWAYPOLDATA[79621]:=[ ,,,[63344795561,"JB"],]; CONWAYPOLDATA[79627]:=[ ,,,[25311591882,"JB"],]; CONWAYPOLDATA[79631]:=[ ,,,[38045621407,"JB"],]; CONWAYPOLDATA[79633]:=[ ,,,[41629424891,"JB"],]; CONWAYPOLDATA[79657]:=[ ,,,[149449755067,"JB"],]; CONWAYPOLDATA[79669]:=[ ,,,[22574290829,"JB"],]; CONWAYPOLDATA[79687]:=[ ,,,[41933929074,"JB"],]; CONWAYPOLDATA[79691]:=[ ,,,[10307473023,"JB"],]; CONWAYPOLDATA[79693]:=[ ,,,[47860906243,"JB"],]; CONWAYPOLDATA[79697]:=[ ,,,[29230149905,"JB"],]; CONWAYPOLDATA[79699]:=[ ,,,[55438544703,"JB"],]; CONWAYPOLDATA[79757]:=[ ,,,[23214231936,"JB"],]; CONWAYPOLDATA[79769]:=[ ,,,[6362136136,"JB"],]; CONWAYPOLDATA[79777]:=[ ,,,[44189357852,"JB"],]; CONWAYPOLDATA[79801]:=[ ,,,[156454089976,"JB"],]; CONWAYPOLDATA[79811]:=[ ,,,[57107244643,"JB"],]; CONWAYPOLDATA[79813]:=[ ,,,[60615020421,"JB"],]; CONWAYPOLDATA[79817]:=[ ,,,[12571257320,"JB"],]; CONWAYPOLDATA[79823]:=[ ,,,[55650520207,"JB"],]; CONWAYPOLDATA[79829]:=[ ,,,[16580004328,"JB"],]; CONWAYPOLDATA[79841]:=[ ,,,[55745225726,"JB"],]; CONWAYPOLDATA[79843]:=[ ,,,[54334199461,"JB"],]; CONWAYPOLDATA[79847]:=[ ,,,[44129360883,"JB"],]; CONWAYPOLDATA[79861]:=[ ,,,[47874034089,"JB"],]; CONWAYPOLDATA[79867]:=[ ,,,[54938273026,"JB"],]; CONWAYPOLDATA[79873]:=[ ,,,[81308717182,"JB"],]; CONWAYPOLDATA[79889]:=[ ,,,[49416938733,"JB"],]; CONWAYPOLDATA[79901]:=[ ,,,[23209722383,"JB"],]; CONWAYPOLDATA[79903]:=[ ,,,[22858650243,"JB"],]; CONWAYPOLDATA[79907]:=[ ,,,[56727976977,"JB"],]; CONWAYPOLDATA[79939]:=[ ,,,[41711290874,"JB"],]; CONWAYPOLDATA[79943]:=[ ,,,[16525657079,"JB"],]; CONWAYPOLDATA[79967]:=[ ,,,[16084722319,"JB"],]; CONWAYPOLDATA[79973]:=[ ,,,[43630629693,"JB"],]; CONWAYPOLDATA[79979]:=[ ,,,[24618975824,"JB"],]; CONWAYPOLDATA[79987]:=[ ,,,[49152171476,"JB"],]; CONWAYPOLDATA[79997]:=[ ,,,[42868632368,"JB"],]; CONWAYPOLDATA[79999]:=[ ,,,[17959775503,"JB"],]; CONWAYPOLDATA[80021]:=[ ,,,[81927660369,"JB"],]; CONWAYPOLDATA[80039]:=[ ,,,[23347136194,"JB"],]; CONWAYPOLDATA[80051]:=[ ,,,[18607534748,"JB"],]; CONWAYPOLDATA[80071]:=[ ,,,[16861751538,"JB"],]; CONWAYPOLDATA[80077]:=[ ,,,[42410620973,"JB"],]; CONWAYPOLDATA[80107]:=[ ,,,[67409880288,"JB"],]; CONWAYPOLDATA[80111]:=[ ,,,[16456802186,"JB"],]; CONWAYPOLDATA[80141]:=[ ,,,[25630293917,"JB"],]; CONWAYPOLDATA[80147]:=[ ,,,[54659051797,"JB"],]; CONWAYPOLDATA[80149]:=[ ,,,[18497106822,"JB"],]; CONWAYPOLDATA[80153]:=[ ,,,[42840736514,"JB"],]; CONWAYPOLDATA[80167]:=[ ,,,[18106278122,"JB"],]; CONWAYPOLDATA[80173]:=[ ,,,[29186740137,"JB"],]; CONWAYPOLDATA[80177]:=[ ,,,[18588636568,"JB"],]; CONWAYPOLDATA[80191]:=[ ,,,[16998006090,"JB"],]; CONWAYPOLDATA[80207]:=[ ,,,[17669201070,"JB"],]; CONWAYPOLDATA[80209]:=[ ,,,[81128676408,"JB"],]; CONWAYPOLDATA[80221]:=[ ,,,[81786673259,"JB"],]; CONWAYPOLDATA[80231]:=[ ,,,[17789619637,"JB"],]; CONWAYPOLDATA[80233]:=[ ,,,[89492048673,"JB"],]; CONWAYPOLDATA[80239]:=[ ,,,[23840852400,"JB"],]; CONWAYPOLDATA[80251]:=[ ,,,[19202539533,"JB"],]; CONWAYPOLDATA[80263]:=[ ,,,[16756024935,"JB"],]; CONWAYPOLDATA[80273]:=[ ,,,[5310460318,"JB"],]; CONWAYPOLDATA[80279]:=[ ,,,[36296945676,"JB"],]; CONWAYPOLDATA[80287]:=[ ,,,[24234550666,"JB"],]; CONWAYPOLDATA[80309]:=[ ,,,[29320735593,"JB"],]; CONWAYPOLDATA[80317]:=[ ,,,[24481906674,"JB"],]; CONWAYPOLDATA[80329]:=[ ,,,[81561246871,"JB"],]; CONWAYPOLDATA[80341]:=[ ,,,[88680476143,"JB"],]; CONWAYPOLDATA[80347]:=[ ,,,[68750678186,"JB"],]; CONWAYPOLDATA[80363]:=[ ,,,[58123343382,"JB"],]; CONWAYPOLDATA[80369]:=[ ,,,[6458211736,"JB"],]; CONWAYPOLDATA[80387]:=[ ,,,[75682591988,"JB"],]; CONWAYPOLDATA[80407]:=[ ,,,[37847494496,"JB"],]; CONWAYPOLDATA[80429]:=[ ,,,[22729959263,"JB"],]; CONWAYPOLDATA[80447]:=[ ,,,[43075507049,"JB"],]; CONWAYPOLDATA[80449]:=[ ,,,[108959803811,"JB"],]; CONWAYPOLDATA[80471]:=[ ,,,[31675799747,"JB"],]; CONWAYPOLDATA[80473]:=[ ,,,[83733041708,"JB"],]; CONWAYPOLDATA[80489]:=[ ,,,[18736068445,"JB"],]; CONWAYPOLDATA[80491]:=[ ,,,[45016765009,"JB"],]; CONWAYPOLDATA[80513]:=[ ,,,[89528282152,"JB"],]; CONWAYPOLDATA[80527]:=[ ,,,[18105368575,"JB"],]; CONWAYPOLDATA[80537]:=[ ,,,[50863706112,"JB"],]; CONWAYPOLDATA[80557]:=[ ,,,[43132634512,"JB"],]; CONWAYPOLDATA[80567]:=[ ,,,[71280444750,"JB"],]; CONWAYPOLDATA[80599]:=[ ,,,[16650302621,"JB"],]; CONWAYPOLDATA[80603]:=[ ,,,[16403516532,"JB"],]; CONWAYPOLDATA[80611]:=[ ,,,[45097179064,"JB"],]; CONWAYPOLDATA[80621]:=[ ,,,[44266330609,"JB"],]; CONWAYPOLDATA[80627]:=[ ,,,[49063142042,"JB"],]; CONWAYPOLDATA[80629]:=[ ,,,[23427078468,"JB"],]; CONWAYPOLDATA[80651]:=[ ,,,[56744188629,"JB"],]; CONWAYPOLDATA[80657]:=[ ,,,[12767599818,"JB"],]; CONWAYPOLDATA[80669]:=[ ,,,[117001188236,"JB"],]; CONWAYPOLDATA[80671]:=[ ,,,[18898875844,"JB"],]; CONWAYPOLDATA[80677]:=[ ,,,[44671580995,"JB"],]; CONWAYPOLDATA[80681]:=[ ,,,[50587551770,"JB"],]; CONWAYPOLDATA[80683]:=[ ,,,[24308577658,"JB"],]; CONWAYPOLDATA[80687]:=[ ,,,[24910820263,"JB"],]; CONWAYPOLDATA[80701]:=[ ,,,[51001982889,"JB"],]; CONWAYPOLDATA[80713]:=[ ,,,[122755029584,"JB"],]; CONWAYPOLDATA[80737]:=[ ,,,[122466725827,"JB"],]; CONWAYPOLDATA[80747]:=[ ,,,[50496670645,"JB"],]; CONWAYPOLDATA[80749]:=[ ,,,[84025229179,"JB"],]; CONWAYPOLDATA[80761]:=[ ,,,[187179123623,"JB"],]; CONWAYPOLDATA[80777]:=[ ,,,[11135513338,"JB"],]; CONWAYPOLDATA[80779]:=[ ,,,[16420189669,"JB"],]; CONWAYPOLDATA[80783]:=[ ,,,[19175379932,"JB"],]; CONWAYPOLDATA[80789]:=[ ,,,[43928857174,"JB"],]; CONWAYPOLDATA[80803]:=[ ,,,[91212850492,"JB"],]; CONWAYPOLDATA[80809]:=[ ,,,[280001972884,"JB"],]; CONWAYPOLDATA[80819]:=[ ,,,[51647543590,"JB"],]; CONWAYPOLDATA[80831]:=[ ,,,[24718523962,"JB"],]; CONWAYPOLDATA[80833]:=[ ,,,[136866435605,"JB"],]; CONWAYPOLDATA[80849]:=[ ,,,[6535590616,"JB"],]; CONWAYPOLDATA[80863]:=[ ,,,[37481132585,"JB"],]; CONWAYPOLDATA[80897]:=[ ,,,[10148528653,"JB"],]; CONWAYPOLDATA[80909]:=[ ,,,[32050563081,"JB"],]; CONWAYPOLDATA[80911]:=[ ,,,[44617238199,"JB"],]; CONWAYPOLDATA[80917]:=[ ,,,[56255925916,"JB"],]; CONWAYPOLDATA[80923]:=[ ,,,[51917607266,"JB"],]; CONWAYPOLDATA[80929]:=[ ,,,[4596767219,"JB"],]; CONWAYPOLDATA[80933]:=[ ,,,[23881871508,"JB"],]; CONWAYPOLDATA[80953]:=[ ,,,[58371970187,"JB"],]; CONWAYPOLDATA[80963]:=[ ,,,[38812852575,"JB"],]; CONWAYPOLDATA[80989]:=[ ,,,[24251103195,"JB"],]; CONWAYPOLDATA[81001]:=[ ,,,[97551772339,"JB"],]; CONWAYPOLDATA[81013]:=[ ,,,[129796679229,"JB"],]; CONWAYPOLDATA[81017]:=[ ,,,[117230950867,"JB"],]; CONWAYPOLDATA[81019]:=[ ,,,[19050240529,"JB"],]; CONWAYPOLDATA[81023]:=[ ,,,[58652306636,"JB"],]; CONWAYPOLDATA[81031]:=[ ,,,[71049196271,"JB"],]; CONWAYPOLDATA[81041]:=[ ,,,[38976101669,"JB"],]; CONWAYPOLDATA[81043]:=[ ,,,[19540763993,"JB"],]; CONWAYPOLDATA[81047]:=[ ,,,[110275952179,"JB"],]; CONWAYPOLDATA[81049]:=[ ,,,[151084089299,"JB"],]; CONWAYPOLDATA[81071]:=[ ,,,[43012137986,"JB"],]; CONWAYPOLDATA[81077]:=[ ,,,[26017852533,"JB"],]; CONWAYPOLDATA[81083]:=[ ,,,[96884698291,"JB"],]; CONWAYPOLDATA[81097]:=[ ,,,[69217668154,"JB"],]; CONWAYPOLDATA[81101]:=[ ,,,[11135978312,"JB"],]; CONWAYPOLDATA[81119]:=[ ,,,[25397304364,"JB"],]; CONWAYPOLDATA[81131]:=[ ,,,[49646736225,"JB"],]; CONWAYPOLDATA[81157]:=[ ,,,[65456204472,"JB"],]; CONWAYPOLDATA[81163]:=[ ,,,[16986523109,"JB"],]; CONWAYPOLDATA[81173]:=[ ,,,[39040479044,"JB"],]; CONWAYPOLDATA[81181]:=[ ,,,[77696630305,"JB"],]; CONWAYPOLDATA[81197]:=[ ,,,[44606708710,"JB"],]; CONWAYPOLDATA[81199]:=[ ,,,[24514708897,"JB"],]; CONWAYPOLDATA[81203]:=[ ,,,[59344776462,"JB"],]; CONWAYPOLDATA[81223]:=[ ,,,[79165134077,"JB"],]; CONWAYPOLDATA[81233]:=[ ,,,[78441834123,"JB"],]; CONWAYPOLDATA[81239]:=[ ,,,[17366054842,"JB"],]; CONWAYPOLDATA[81281]:=[ ,,,[51346914604,"JB"],]; CONWAYPOLDATA[81283]:=[ ,,,[51228935884,"JB"],]; CONWAYPOLDATA[81293]:=[ ,,,[65356970626,"JB"],]; CONWAYPOLDATA[81299]:=[ ,,,[25509431129,"JB"],]; CONWAYPOLDATA[81307]:=[ ,,,[59000749780,"JB"],]; CONWAYPOLDATA[81331]:=[ ,,,[44918623326,"JB"],]; CONWAYPOLDATA[81343]:=[ ,,,[26360419301,"JB"],]; CONWAYPOLDATA[81349]:=[ ,,,[83320086272,"JB"],]; CONWAYPOLDATA[81353]:=[ ,,,[11989642437,"JB"],]; CONWAYPOLDATA[81359]:=[ ,,,[16658906133,"JB"],]; CONWAYPOLDATA[81371]:=[ ,,,[17122492677,"JB"],]; CONWAYPOLDATA[81373]:=[ ,,,[50387382197,"JB"],]; CONWAYPOLDATA[81401]:=[ ,,,[19826434568,"JB"],]; CONWAYPOLDATA[81409]:=[ ,,,[46193501832,"JB"],]; CONWAYPOLDATA[81421]:=[ ,,,[211065622786,"JB"],]; CONWAYPOLDATA[81439]:=[ ,,,[17973424425,"JB"],]; CONWAYPOLDATA[81457]:=[ ,,,[99527746713,"JB"],]; CONWAYPOLDATA[81463]:=[ ,,,[16858442003,"JB"],]; CONWAYPOLDATA[81509]:=[ ,,,[3375206183,"JB"],]; CONWAYPOLDATA[81517]:=[ ,,,[85577361772,"JB"],]; CONWAYPOLDATA[81527]:=[ ,,,[26586280813,"JB"],]; CONWAYPOLDATA[81533]:=[ ,,,[38630335403,"JB"],]; CONWAYPOLDATA[81547]:=[ ,,,[25385825744,"JB"],]; CONWAYPOLDATA[81551]:=[ ,,,[39733849084,"JB"],]; CONWAYPOLDATA[81553]:=[ ,,,[99762480057,"JB"],]; CONWAYPOLDATA[81559]:=[ ,,,[31775957319,"JB"],]; CONWAYPOLDATA[81563]:=[ ,,,[77786388413,"JB"],]; CONWAYPOLDATA[81569]:=[ ,,,[18200898818,"JB"],]; CONWAYPOLDATA[81611]:=[ ,,,[59942626614,"JB"],]; CONWAYPOLDATA[81619]:=[ ,,,[44195953932,"JB"],]; CONWAYPOLDATA[81629]:=[ ,,,[44550169558,"JB"],]; CONWAYPOLDATA[81637]:=[ ,,,[24494528756,"JB"],]; CONWAYPOLDATA[81647]:=[ ,,,[57418497696,"JB"],]; CONWAYPOLDATA[81649]:=[ ,,,[6138126884,"JB"],]; CONWAYPOLDATA[81667]:=[ ,,,[37955146588,"JB"],]; CONWAYPOLDATA[81671]:=[ ,,,[16736021327,"JB"],]; CONWAYPOLDATA[81677]:=[ ,,,[32819288789,"JB"],]; CONWAYPOLDATA[81689]:=[ ,,,[25512209904,"JB"],]; CONWAYPOLDATA[81701]:=[ ,,,[86126416368,"JB"],]; CONWAYPOLDATA[81703]:=[ ,,,[39597032141,"JB"],]; CONWAYPOLDATA[81707]:=[ ,,,[12727989634,"JB"],]; CONWAYPOLDATA[81727]:=[ ,,,[39176981631,"JB"],]; CONWAYPOLDATA[81737]:=[ ,,,[50311085191,"JB"],]; CONWAYPOLDATA[81749]:=[ ,,,[10975293746,"JB"],]; CONWAYPOLDATA[81761]:=[ ,,,[5225427283,"JB"],]; CONWAYPOLDATA[81769]:=[ ,,,[3936114364,"JB"],]; CONWAYPOLDATA[81773]:=[ ,,,[3664248132,"JB"],]; CONWAYPOLDATA[81799]:=[ ,,,[11536767365,"JB"],]; CONWAYPOLDATA[81817]:=[ ,,,[44602128470,"JB"],]; CONWAYPOLDATA[81839]:=[ ,,,[106858491731,"JB"],]; CONWAYPOLDATA[81847]:=[ ,,,[38052634631,"JB"],]; CONWAYPOLDATA[81853]:=[ ,,,[12787812348,"JB"],]; CONWAYPOLDATA[81869]:=[ ,,,[59679144373,"JB"],]; CONWAYPOLDATA[81883]:=[ ,,,[39464658215,"JB"],]; CONWAYPOLDATA[81899]:=[ ,,,[12634722530,"JB"],]; CONWAYPOLDATA[81901]:=[ ,,,[45918860365,"JB"],]; CONWAYPOLDATA[81919]:=[ ,,,[26398643510,"JB"],]; CONWAYPOLDATA[81929]:=[ ,,,[57881937284,"JB"],]; CONWAYPOLDATA[81931]:=[ ,,,[26684926703,"JB"],]; CONWAYPOLDATA[81937]:=[ ,,,[105841382322,"JB"],]; CONWAYPOLDATA[81943]:=[ ,,,[38452899957,"JB"],]; CONWAYPOLDATA[81953]:=[ ,,,[65266221861,"JB"],]; CONWAYPOLDATA[81967]:=[ ,,,[73523907203,"JB"],]; CONWAYPOLDATA[81971]:=[ ,,,[57938250396,"JB"],]; CONWAYPOLDATA[81973]:=[ ,,,[44917843109,"JB"],]; CONWAYPOLDATA[82003]:=[ ,,,[52467979492,"JB"],]; CONWAYPOLDATA[82007]:=[ ,,,[18566302798,"JB"],]; CONWAYPOLDATA[82009]:=[ ,,,[113563438925,"JB"],]; CONWAYPOLDATA[82013]:=[ ,,,[25268861415,"JB"],]; CONWAYPOLDATA[82021]:=[ ,,,[47091126857,"JB"],]; CONWAYPOLDATA[82031]:=[ ,,,[24662210006,"JB"],]; CONWAYPOLDATA[82037]:=[ ,,,[46130061398,"JB"],]; CONWAYPOLDATA[82039]:=[ ,,,[18651402587,"JB"],]; CONWAYPOLDATA[82051]:=[ ,,,[59023797107,"JB"],]; CONWAYPOLDATA[82067]:=[ ,,,[5371613420,"JB"],]; CONWAYPOLDATA[82073]:=[ ,,,[5228050103,"JB"],]; CONWAYPOLDATA[82129]:=[ ,,,[167062048331,"JB"],]; CONWAYPOLDATA[82139]:=[ ,,,[30610658997,"JB"],]; CONWAYPOLDATA[82141]:=[ ,,,[18070855724,"JB"],]; CONWAYPOLDATA[82153]:=[ ,,,[105022012768,"JB"],]; CONWAYPOLDATA[82163]:=[ ,,,[60234434769,"JB"],]; CONWAYPOLDATA[82171]:=[ ,,,[17144321784,"JB"],]; CONWAYPOLDATA[82183]:=[ ,,,[19629080839,"JB"],]; CONWAYPOLDATA[82189]:=[ ,,,[19766372321,"JB"],]; CONWAYPOLDATA[82193]:=[ ,,,[58213110062,"JB"],]; CONWAYPOLDATA[82207]:=[ ,,,[33789625420,"JB"],]; CONWAYPOLDATA[82217]:=[ ,,,[20170872132,"JB"],]; CONWAYPOLDATA[82219]:=[ ,,,[25963362479,"JB"],]; CONWAYPOLDATA[82223]:=[ ,,,[39646039476,"JB"],]; CONWAYPOLDATA[82231]:=[ ,,,[37461318829,"JB"],]; CONWAYPOLDATA[82237]:=[ ,,,[73753677796,"JB"],]; CONWAYPOLDATA[82241]:=[ ,,,[6762595192,"JB"],]; CONWAYPOLDATA[82261]:=[ ,,,[72195708568,"JB"],]; CONWAYPOLDATA[82267]:=[ ,,,[12347454032,"JB"],]; CONWAYPOLDATA[82279]:=[ ,,,[47388507777,"JB"],]; CONWAYPOLDATA[82301]:=[ ,,,[4113403982,"JB"],]; CONWAYPOLDATA[82307]:=[ ,,,[58510235548,"JB"],]; CONWAYPOLDATA[82339]:=[ ,,,[17638825260,"JB"],]; CONWAYPOLDATA[82349]:=[ ,,,[99152807547,"JB"],]; CONWAYPOLDATA[82351]:=[ ,,,[33908106604,"JB"],]; CONWAYPOLDATA[82361]:=[ ,,,[58904422481,"JB"],]; CONWAYPOLDATA[82373]:=[ ,,,[39452630725,"JB"],]; CONWAYPOLDATA[82387]:=[ ,,,[58794493908,"JB"],]; CONWAYPOLDATA[82393]:=[ ,,,[106440468164,"JB"],]; CONWAYPOLDATA[82421]:=[ ,,,[10646979940,"JB"],]; CONWAYPOLDATA[82457]:=[ ,,,[6402950967,"JB"],]; CONWAYPOLDATA[82463]:=[ ,,,[20099036847,"JB"],]; CONWAYPOLDATA[82469]:=[ ,,,[17645891932,"JB"],]; CONWAYPOLDATA[82471]:=[ ,,,[44836926102,"JB"],]; CONWAYPOLDATA[82483]:=[ ,,,[61061834970,"JB"],]; CONWAYPOLDATA[82487]:=[ ,,,[60875323518,"JB"],]; CONWAYPOLDATA[82493]:=[ ,,,[47252155388,"JB"],]; CONWAYPOLDATA[82499]:=[ ,,,[18040386332,"JB"],]; CONWAYPOLDATA[82507]:=[ ,,,[53949842176,"JB"],]; CONWAYPOLDATA[82529]:=[ ,,,[19481795743,"JB"],]; CONWAYPOLDATA[82531]:=[ ,,,[26650827992,"JB"],]; CONWAYPOLDATA[82549]:=[ ,,,[65135371001,"JB"],]; CONWAYPOLDATA[82559]:=[ ,,,[18870510637,"JB"],]; CONWAYPOLDATA[82561]:=[ ,,,[6217586356,"JB"],]; CONWAYPOLDATA[82567]:=[ ,,,[46574475930,"JB"],]; CONWAYPOLDATA[82571]:=[ ,,,[33949479511,"JB"],]; CONWAYPOLDATA[82591]:=[ ,,,[19864291780,"JB"],]; CONWAYPOLDATA[82601]:=[ ,,,[6821933992,"JB"],]; CONWAYPOLDATA[82609]:=[ ,,,[154998605839,"JB"],]; CONWAYPOLDATA[82613]:=[ ,,,[44877364314,"JB"],]; CONWAYPOLDATA[82619]:=[ ,,,[19409846910,"JB"],]; CONWAYPOLDATA[82633]:=[ ,,,[45791324854,"JB"],]; CONWAYPOLDATA[82651]:=[ ,,,[59577402983,"JB"],]; CONWAYPOLDATA[82657]:=[ ,,,[106478086154,"JB"],]; CONWAYPOLDATA[82699]:=[ ,,,[26795220294,"JB"],]; CONWAYPOLDATA[82721]:=[ ,,,[6025149483,"JB"],]; CONWAYPOLDATA[82723]:=[ ,,,[59799298580,"JB"],]; CONWAYPOLDATA[82727]:=[ ,,,[18843390611,"JB"],]; CONWAYPOLDATA[82729]:=[ ,,,[157412439299,"JB"],]; CONWAYPOLDATA[82757]:=[ ,,,[47091629497,"JB"],]; CONWAYPOLDATA[82759]:=[ ,,,[17428217813,"JB"],]; CONWAYPOLDATA[82763]:=[ ,,,[52330217272,"JB"],]; CONWAYPOLDATA[82781]:=[ ,,,[12233127839,"JB"],]; CONWAYPOLDATA[82787]:=[ ,,,[78879288028,"JB"],]; CONWAYPOLDATA[82793]:=[ ,,,[12897990301,"JB"],]; CONWAYPOLDATA[82799]:=[ ,,,[31293550867,"JB"],]; CONWAYPOLDATA[82811]:=[ ,,,[51576926699,"JB"],]; CONWAYPOLDATA[82813]:=[ ,,,[46651544170,"JB"],]; CONWAYPOLDATA[82837]:=[ ,,,[54460025934,"JB"],]; CONWAYPOLDATA[82847]:=[ ,,,[60001111285,"JB"],]; CONWAYPOLDATA[82883]:=[ ,,,[128281417305,"JB"],]; CONWAYPOLDATA[82889]:=[ ,,,[6869591656,"JB"],]; CONWAYPOLDATA[82891]:=[ ,,,[61002305196,"JB"],]; CONWAYPOLDATA[82903]:=[ ,,,[40490571330,"JB"],]; CONWAYPOLDATA[82913]:=[ ,,,[53781268714,"JB"],]; CONWAYPOLDATA[82939]:=[ ,,,[17458576563,"JB"],]; CONWAYPOLDATA[82963]:=[ ,,,[24973439300,"JB"],]; CONWAYPOLDATA[82981]:=[ ,,,[24771156198,"JB"],]; CONWAYPOLDATA[82997]:=[ ,,,[25228017113,"JB"],]; CONWAYPOLDATA[83003]:=[ ,,,[31428338925,"JB"],]; CONWAYPOLDATA[83009]:=[ ,,,[6889497976,"JB"],]; CONWAYPOLDATA[83023]:=[ ,,,[59059407329,"JB"],]; CONWAYPOLDATA[83047]:=[ ,,,[38439964893,"JB"],]; CONWAYPOLDATA[83059]:=[ ,,,[59658954050,"JB"],]; CONWAYPOLDATA[83063]:=[ ,,,[20298520630,"JB"],]; CONWAYPOLDATA[83071]:=[ ,,,[44992167395,"JB"],]; CONWAYPOLDATA[83077]:=[ ,,,[53116110734,"JB"],]; CONWAYPOLDATA[83089]:=[ ,,,[4013198707,"JB"],]; CONWAYPOLDATA[83093]:=[ ,,,[87741970259,"JB"],]; CONWAYPOLDATA[83101]:=[ ,,,[47931077883,"JB"],]; CONWAYPOLDATA[83117]:=[ ,,,[46510195277,"JB"],]; CONWAYPOLDATA[83137]:=[ ,,,[75208723137,"JB"],]; CONWAYPOLDATA[83177]:=[ ,,,[32767828684,"JB"],]; CONWAYPOLDATA[83203]:=[ ,,,[61030398938,"JB"],]; CONWAYPOLDATA[83207]:=[ ,,,[27468461259,"JB"],]; CONWAYPOLDATA[83219]:=[ ,,,[19792806962,"JB"],]; CONWAYPOLDATA[83221]:=[ ,,,[96152544755,"JB"],]; CONWAYPOLDATA[83227]:=[ ,,,[3525745406,"JB"],]; CONWAYPOLDATA[83231]:=[ ,,,[94194686713,"JB"],]; CONWAYPOLDATA[83233]:=[ ,,,[62015992744,"JB"],]; CONWAYPOLDATA[83243]:=[ ,,,[72859850883,"JB"],]; CONWAYPOLDATA[83257]:=[ ,,,[46552485499,"JB"],]; CONWAYPOLDATA[83267]:=[ ,,,[34221321463,"JB"],]; CONWAYPOLDATA[83269]:=[ ,,,[110206854578,"JB"],]; CONWAYPOLDATA[83273]:=[ ,,,[19710136192,"JB"],]; CONWAYPOLDATA[83299]:=[ ,,,[3677234357,"JB"],]; CONWAYPOLDATA[83311]:=[ ,,,[26457490837,"JB"],]; CONWAYPOLDATA[83339]:=[ ,,,[55061327251,"JB"],]; CONWAYPOLDATA[83341]:=[ ,,,[27619707456,"JB"],]; CONWAYPOLDATA[83357]:=[ ,,,[60183503931,"JB"],]; CONWAYPOLDATA[83383]:=[ ,,,[76479304518,"JB"],]; CONWAYPOLDATA[83389]:=[ ,,,[55434171976,"JB"],]; CONWAYPOLDATA[83399]:=[ ,,,[38573955684,"JB"],]; CONWAYPOLDATA[83401]:=[ ,,,[116320208717,"JB"],]; CONWAYPOLDATA[83407]:=[ ,,,[27826576973,"JB"],]; CONWAYPOLDATA[83417]:=[ ,,,[67645598064,"JB"],]; CONWAYPOLDATA[83423]:=[ ,,,[19206227026,"JB"],]; CONWAYPOLDATA[83431]:=[ ,,,[48167719828,"JB"],]; CONWAYPOLDATA[83437]:=[ ,,,[132000254297,"JB"],]; CONWAYPOLDATA[83443]:=[ ,,,[17608141862,"JB"],]; CONWAYPOLDATA[83449]:=[ ,,,[184566072640,"JB"],]; CONWAYPOLDATA[83459]:=[ ,,,[19875844311,"JB"],]; CONWAYPOLDATA[83471]:=[ ,,,[19694982461,"JB"],]; CONWAYPOLDATA[83477]:=[ ,,,[48096692661,"JB"],]; CONWAYPOLDATA[83497]:=[ ,,,[45740658574,"JB"],]; CONWAYPOLDATA[83537]:=[ ,,,[25539934087,"JB"],]; CONWAYPOLDATA[83557]:=[ ,,,[54391763380,"JB"],]; CONWAYPOLDATA[83561]:=[ ,,,[6981437992,"JB"],]; CONWAYPOLDATA[83563]:=[ ,,,[60737599426,"JB"],]; CONWAYPOLDATA[83579]:=[ ,,,[80547088198,"JB"],]; CONWAYPOLDATA[83591]:=[ ,,,[34936524093,"JB"],]; CONWAYPOLDATA[83597]:=[ ,,,[12924179799,"JB"],]; CONWAYPOLDATA[83609]:=[ ,,,[27255363477,"JB"],]; CONWAYPOLDATA[83617]:=[ ,,,[129672072967,"JB"],]; CONWAYPOLDATA[83621]:=[ ,,,[26813491757,"JB"],]; CONWAYPOLDATA[83639]:=[ ,,,[59566357595,"JB"],]; CONWAYPOLDATA[83641]:=[ ,,,[103115468601,"JB"],]; CONWAYPOLDATA[83653]:=[ ,,,[62702440767,"JB"],]; CONWAYPOLDATA[83663]:=[ ,,,[67165744024,"JB"],]; CONWAYPOLDATA[83689]:=[ ,,,[244301999698,"JB"],]; CONWAYPOLDATA[83701]:=[ ,,,[18482436321,"JB"],]; CONWAYPOLDATA[83717]:=[ ,,,[69216043564,"JB"],]; CONWAYPOLDATA[83719]:=[ ,,,[19517159319,"JB"],]; CONWAYPOLDATA[83737]:=[ ,,,[108826028734,"JB"],]; CONWAYPOLDATA[83761]:=[ ,,,[75657960871,"JB"],]; CONWAYPOLDATA[83773]:=[ ,,,[25383972962,"JB"],]; CONWAYPOLDATA[83777]:=[ ,,,[5158066116,"JB"],]; CONWAYPOLDATA[83791]:=[ ,,,[48248114668,"JB"],]; CONWAYPOLDATA[83813]:=[ ,,,[68576886171,"JB"],]; CONWAYPOLDATA[83833]:=[ ,,,[130361823999,"JB"],]; CONWAYPOLDATA[83843]:=[ ,,,[4026811606,"JB"],]; CONWAYPOLDATA[83857]:=[ ,,,[47417024512,"JB"],]; CONWAYPOLDATA[83869]:=[ ,,,[54589661154,"JB"],]; CONWAYPOLDATA[83873]:=[ ,,,[69191031353,"JB"],]; CONWAYPOLDATA[83891]:=[ ,,,[32106847413,"JB"],]; CONWAYPOLDATA[83903]:=[ ,,,[28158518029,"JB"],]; CONWAYPOLDATA[83911]:=[ ,,,[47920145616,"JB"],]; CONWAYPOLDATA[83921]:=[ ,,,[52898343538,"JB"],]; CONWAYPOLDATA[83933]:=[ ,,,[47741677933,"JB"],]; CONWAYPOLDATA[83939]:=[ ,,,[52994551896,"JB"],]; CONWAYPOLDATA[83969]:=[ ,,,[53874174527,"JB"],]; CONWAYPOLDATA[83983]:=[ ,,,[40800705048,"JB"],]; CONWAYPOLDATA[83987]:=[ ,,,[27522539902,"JB"],]; CONWAYPOLDATA[84011]:=[ ,,,[33988834342,"JB"],]; CONWAYPOLDATA[84017]:=[ ,,,[5769531410,"JB"],]; CONWAYPOLDATA[84047]:=[ ,,,[32614102167,"JB"],]; CONWAYPOLDATA[84053]:=[ ,,,[46096346262,"JB"],]; CONWAYPOLDATA[84059]:=[ ,,,[19737305379,"JB"],]; CONWAYPOLDATA[84061]:=[ ,,,[32656101348,"JB"],]; CONWAYPOLDATA[84067]:=[ ,,,[61480971313,"JB"],]; CONWAYPOLDATA[84089]:=[ ,,,[18945672148,"JB"],]; CONWAYPOLDATA[84121]:=[ ,,,[105959316339,"JB"],]; CONWAYPOLDATA[84127]:=[ ,,,[40605326712,"JB"],]; CONWAYPOLDATA[84131]:=[ ,,,[56133717560,"JB"],]; CONWAYPOLDATA[84137]:=[ ,,,[25306979274,"JB"],]; CONWAYPOLDATA[84143]:=[ ,,,[28319841229,"JB"],]; CONWAYPOLDATA[84163]:=[ ,,,[62641426783,"JB"],]; CONWAYPOLDATA[84179]:=[ ,,,[55797797615,"JB"],]; CONWAYPOLDATA[84181]:=[ ,,,[63777377584,"JB"],]; CONWAYPOLDATA[84191]:=[ ,,,[35439864693,"JB"],]; CONWAYPOLDATA[84199]:=[ ,,,[39354275815,"JB"],]; CONWAYPOLDATA[84211]:=[ ,,,[47176518001,"JB"],]; CONWAYPOLDATA[84221]:=[ ,,,[35315212838,"JB"],]; CONWAYPOLDATA[84223]:=[ ,,,[18720835777,"JB"],]; CONWAYPOLDATA[84229]:=[ ,,,[24858167856,"JB"],]; CONWAYPOLDATA[84239]:=[ ,,,[41256302978,"JB"],]; CONWAYPOLDATA[84247]:=[ ,,,[76074704017,"JB"],]; CONWAYPOLDATA[84263]:=[ ,,,[48658849037,"JB"],]; CONWAYPOLDATA[84299]:=[ ,,,[19552984454,"JB"],]; CONWAYPOLDATA[84307]:=[ ,,,[83132603493,"JB"],]; CONWAYPOLDATA[84313]:=[ ,,,[47151202125,"JB"],]; CONWAYPOLDATA[84317]:=[ ,,,[117331742937,"JB"],]; CONWAYPOLDATA[84319]:=[ ,,,[75691648564,"JB"],]; CONWAYPOLDATA[84347]:=[ ,,,[63987321142,"JB"],]; CONWAYPOLDATA[84349]:=[ ,,,[48274788380,"JB"],]; CONWAYPOLDATA[84377]:=[ ,,,[5655452805,"JB"],]; CONWAYPOLDATA[84389]:=[ ,,,[89239764111,"JB"],]; CONWAYPOLDATA[84391]:=[ ,,,[76766273153,"JB"],]; CONWAYPOLDATA[84401]:=[ ,,,[20386723949,"JB"],]; CONWAYPOLDATA[84407]:=[ ,,,[70856131411,"JB"],]; CONWAYPOLDATA[84421]:=[ ,,,[92181147164,"JB"],]; CONWAYPOLDATA[84431]:=[ ,,,[25886122452,"JB"],]; CONWAYPOLDATA[84437]:=[ ,,,[33570884647,"JB"],]; CONWAYPOLDATA[84443]:=[ ,,,[34923935942,"JB"],]; CONWAYPOLDATA[84449]:=[ ,,,[35139313352,"JB"],]; CONWAYPOLDATA[84457]:=[ ,,,[49432090906,"JB"],]; CONWAYPOLDATA[84463]:=[ ,,,[40738532017,"JB"],]; CONWAYPOLDATA[84467]:=[ ,,,[84772094806,"JB"],]; CONWAYPOLDATA[84481]:=[ ,,,[5106538533,"JB"],]; CONWAYPOLDATA[84499]:=[ ,,,[61452827241,"JB"],]; CONWAYPOLDATA[84503]:=[ ,,,[39358370804,"JB"],]; CONWAYPOLDATA[84509]:=[ ,,,[26130351820,"JB"],]; CONWAYPOLDATA[84521]:=[ ,,,[98037598323,"JB"],]; CONWAYPOLDATA[84523]:=[ ,,,[19185875772,"JB"],]; CONWAYPOLDATA[84533]:=[ ,,,[126714797936,"JB"],]; CONWAYPOLDATA[84551]:=[ ,,,[20127450120,"JB"],]; CONWAYPOLDATA[84559]:=[ ,,,[26179043608,"JB"],]; CONWAYPOLDATA[84589]:=[ ,,,[119633545990,"JB"],]; CONWAYPOLDATA[84629]:=[ ,,,[20597852312,"JB"],]; CONWAYPOLDATA[84631]:=[ ,,,[19503637111,"JB"],]; CONWAYPOLDATA[84649]:=[ ,,,[105643898940,"JB"],]; CONWAYPOLDATA[84653]:=[ ,,,[56800215983,"JB"],]; CONWAYPOLDATA[84659]:=[ ,,,[4866537958,"JB"],]; CONWAYPOLDATA[84673]:=[ ,,,[62588418804,"JB"],]; CONWAYPOLDATA[84691]:=[ ,,,[19105103928,"JB"],]; CONWAYPOLDATA[84697]:=[ ,,,[92517497506,"JB"],]; CONWAYPOLDATA[84701]:=[ ,,,[47235121971,"JB"],]; CONWAYPOLDATA[84713]:=[ ,,,[35033061153,"JB"],]; CONWAYPOLDATA[84719]:=[ ,,,[46960250027,"JB"],]; CONWAYPOLDATA[84731]:=[ ,,,[46980373917,"JB"],]; CONWAYPOLDATA[84737]:=[ ,,,[11990539714,"JB"],]; CONWAYPOLDATA[84751]:=[ ,,,[18010604518,"JB"],]; CONWAYPOLDATA[84761]:=[ ,,,[55791215905,"JB"],]; CONWAYPOLDATA[84787]:=[ ,,,[18439052827,"JB"],]; CONWAYPOLDATA[84793]:=[ ,,,[157360460472,"JB"],]; CONWAYPOLDATA[84809]:=[ ,,,[34834533472,"JB"],]; CONWAYPOLDATA[84811]:=[ ,,,[54365038357,"JB"],]; CONWAYPOLDATA[84827]:=[ ,,,[26972865327,"JB"],]; CONWAYPOLDATA[84857]:=[ ,,,[14331498733,"JB"],]; CONWAYPOLDATA[84859]:=[ ,,,[48233261589,"JB"],]; CONWAYPOLDATA[84869]:=[ ,,,[19478793407,"JB"],]; CONWAYPOLDATA[84871]:=[ ,,,[20044917654,"JB"],]; CONWAYPOLDATA[84913]:=[ ,,,[49539772639,"JB"],]; CONWAYPOLDATA[84919]:=[ ,,,[27592390997,"JB"],]; CONWAYPOLDATA[84947]:=[ ,,,[136456822074,"JB"],]; CONWAYPOLDATA[84961]:=[ ,,,[122399064661,"JB"],]; CONWAYPOLDATA[84967]:=[ ,,,[49155873546,"JB"],]; CONWAYPOLDATA[84977]:=[ ,,,[70588609386,"JB"],]; CONWAYPOLDATA[84979]:=[ ,,,[47437062361,"JB"],]; CONWAYPOLDATA[84991]:=[ ,,,[48966374779,"JB"],]; CONWAYPOLDATA[85009]:=[ ,,,[206287939953,"JB"],]; CONWAYPOLDATA[85021]:=[ ,,,[35350711555,"JB"],]; CONWAYPOLDATA[85027]:=[ ,,,[77222116591,"JB"],]; CONWAYPOLDATA[85037]:=[ ,,,[18496312835,"JB"],]; CONWAYPOLDATA[85049]:=[ ,,,[33330107760,"JB"],]; CONWAYPOLDATA[85061]:=[ ,,,[49250404063,"JB"],]; CONWAYPOLDATA[85081]:=[ ,,,[180014039483,"JB"],]; CONWAYPOLDATA[85087]:=[ ,,,[20393226728,"JB"],]; CONWAYPOLDATA[85091]:=[ ,,,[33409024063,"JB"],]; CONWAYPOLDATA[85093]:=[ ,,,[91820707861,"JB"],]; CONWAYPOLDATA[85103]:=[ ,,,[49335570753,"JB"],]; CONWAYPOLDATA[85109]:=[ ,,,[13289089480,"JB"],]; CONWAYPOLDATA[85121]:=[ ,,,[56774174828,"JB"],]; CONWAYPOLDATA[85133]:=[ ,,,[13361028421,"JB"],]; CONWAYPOLDATA[85147]:=[ ,,,[56703814946,"JB"],]; CONWAYPOLDATA[85159]:=[ ,,,[18871830516,"JB"],]; CONWAYPOLDATA[85193]:=[ ,,,[12454364673,"JB"],]; CONWAYPOLDATA[85199]:=[ ,,,[36293581221,"JB"],]; CONWAYPOLDATA[85201]:=[ ,,,[186898788044,"JB"],]; CONWAYPOLDATA[85213]:=[ ,,,[56912228872,"JB"],]; CONWAYPOLDATA[85223]:=[ ,,,[20146291090,"JB"],]; CONWAYPOLDATA[85229]:=[ ,,,[36284712631,"JB"],]; CONWAYPOLDATA[85237]:=[ ,,,[47638362643,"JB"],]; CONWAYPOLDATA[85243]:=[ ,,,[27630154565,"JB"],]; CONWAYPOLDATA[85247]:=[ ,,,[29067863053,"JB"],]; CONWAYPOLDATA[85259]:=[ ,,,[49055129796,"JB"],]; CONWAYPOLDATA[85297]:=[ ,,,[48530154650,"JB"],]; CONWAYPOLDATA[85303]:=[ ,,,[42469975221,"JB"],]; CONWAYPOLDATA[85313]:=[ ,,,[35753313295,"JB"],]; CONWAYPOLDATA[85331]:=[ ,,,[62230533006,"JB"],]; CONWAYPOLDATA[85333]:=[ ,,,[13488672648,"JB"],]; CONWAYPOLDATA[85361]:=[ ,,,[32949431364,"JB"],]; CONWAYPOLDATA[85363]:=[ ,,,[27086192081,"JB"],]; CONWAYPOLDATA[85369]:=[ ,,,[122150916619,"JB"],]; CONWAYPOLDATA[85381]:=[ ,,,[85952028134,"JB"],]; CONWAYPOLDATA[85411]:=[ ,,,[62477975680,"JB"],]; CONWAYPOLDATA[85427]:=[ ,,,[50588160862,"JB"],]; CONWAYPOLDATA[85429]:=[ ,,,[55370122924,"JB"],]; CONWAYPOLDATA[85439]:=[ ,,,[36498344661,"JB"],]; CONWAYPOLDATA[85447]:=[ ,,,[40481968852,"JB"],]; CONWAYPOLDATA[85451]:=[ ,,,[64207539598,"JB"],]; CONWAYPOLDATA[85453]:=[ ,,,[49976247069,"JB"],]; CONWAYPOLDATA[85469]:=[ ,,,[36524407932,"JB"],]; CONWAYPOLDATA[85487]:=[ ,,,[41772538659,"JB"],]; CONWAYPOLDATA[85513]:=[ ,,,[50364762641,"JB"],]; CONWAYPOLDATA[85517]:=[ ,,,[48627959297,"JB"],]; CONWAYPOLDATA[85523]:=[ ,,,[62833577056,"JB"],]; CONWAYPOLDATA[85531]:=[ ,,,[21287211887,"JB"],]; CONWAYPOLDATA[85549]:=[ ,,,[48678664237,"JB"],]; CONWAYPOLDATA[85571]:=[ ,,,[65900965374,"JB"],]; CONWAYPOLDATA[85577]:=[ ,,,[57333166923,"JB"],]; CONWAYPOLDATA[85597]:=[ ,,,[77029681869,"JB"],]; CONWAYPOLDATA[85601]:=[ ,,,[4903738889,"JB"],]; CONWAYPOLDATA[85607]:=[ ,,,[33000214400,"JB"],]; CONWAYPOLDATA[85619]:=[ ,,,[14533482780,"JB"],]; CONWAYPOLDATA[85621]:=[ ,,,[130179452725,"JB"],]; CONWAYPOLDATA[85627]:=[ ,,,[65987248774,"JB"],]; CONWAYPOLDATA[85639]:=[ ,,,[36669849052,"JB"],]; CONWAYPOLDATA[85643]:=[ ,,,[5734398353,"JB"],]; CONWAYPOLDATA[85661]:=[ ,,,[57257868266,"JB"],]; CONWAYPOLDATA[85667]:=[ ,,,[86783326682,"JB"],]; CONWAYPOLDATA[85669]:=[ ,,,[48710536712,"JB"],]; CONWAYPOLDATA[85691]:=[ ,,,[63338331270,"JB"],]; CONWAYPOLDATA[85703]:=[ ,,,[35556803457,"JB"],]; CONWAYPOLDATA[85711]:=[ ,,,[29302276709,"JB"],]; CONWAYPOLDATA[85717]:=[ ,,,[79806384267,"JB"],]; CONWAYPOLDATA[85733]:=[ ,,,[55843732746,"JB"],]; CONWAYPOLDATA[85751]:=[ ,,,[56412238625,"JB"],]; CONWAYPOLDATA[85781]:=[ ,,,[34697556692,"JB"],]; CONWAYPOLDATA[85793]:=[ ,,,[21481366101,"JB"],]; CONWAYPOLDATA[85817]:=[ ,,,[34945540573,"JB"],]; CONWAYPOLDATA[85819]:=[ ,,,[55291551141,"JB"],]; CONWAYPOLDATA[85829]:=[ ,,,[56896816563,"JB"],]; CONWAYPOLDATA[85831]:=[ ,,,[27028954382,"JB"],]; CONWAYPOLDATA[85837]:=[ ,,,[66311314264,"JB"],]; CONWAYPOLDATA[85843]:=[ ,,,[42118867953,"JB"],]; CONWAYPOLDATA[85847]:=[ ,,,[29478486253,"JB"],]; CONWAYPOLDATA[85853]:=[ ,,,[50758955045,"JB"],]; CONWAYPOLDATA[85889]:=[ ,,,[18987567122,"JB"],]; CONWAYPOLDATA[85903]:=[ ,,,[48107483966,"JB"],]; CONWAYPOLDATA[85909]:=[ ,,,[6297902883,"JB"],]; CONWAYPOLDATA[85931]:=[ ,,,[20295355444,"JB"],]; CONWAYPOLDATA[85933]:=[ ,,,[26833352652,"JB"],]; CONWAYPOLDATA[85991]:=[ ,,,[57747342052,"JB"],]; CONWAYPOLDATA[85999]:=[ ,,,[50490786894,"JB"],]; CONWAYPOLDATA[86011]:=[ ,,,[51208369077,"JB"],]; CONWAYPOLDATA[86017]:=[ ,,,[110982918153,"JB"],]; CONWAYPOLDATA[86027]:=[ ,,,[65852636178,"JB"],]; CONWAYPOLDATA[86029]:=[ ,,,[78854869634,"JB"],]; CONWAYPOLDATA[86069]:=[ ,,,[7144243416,"JB"],]; CONWAYPOLDATA[86077]:=[ ,,,[14520759520,"JB"],]; CONWAYPOLDATA[86083]:=[ ,,,[63202827266,"JB"],]; CONWAYPOLDATA[86111]:=[ ,,,[42293675994,"JB"],]; CONWAYPOLDATA[86113]:=[ ,,,[95486916733,"JB"],]; CONWAYPOLDATA[86117]:=[ ,,,[35297291494,"JB"],]; CONWAYPOLDATA[86131]:=[ ,,,[20759552015,"JB"],]; CONWAYPOLDATA[86137]:=[ ,,,[50360341603,"JB"],]; CONWAYPOLDATA[86143]:=[ ,,,[21624735722,"JB"],]; CONWAYPOLDATA[86161]:=[ ,,,[167537738167,"JB"],]; CONWAYPOLDATA[86171]:=[ ,,,[19041378219,"JB"],]; CONWAYPOLDATA[86179]:=[ ,,,[64476370074,"JB"],]; CONWAYPOLDATA[86183]:=[ ,,,[27698354375,"JB"],]; CONWAYPOLDATA[86197]:=[ ,,,[57780865997,"JB"],]; CONWAYPOLDATA[86201]:=[ ,,,[18993355941,"JB"],]; CONWAYPOLDATA[86209]:=[ ,,,[109350943971,"JB"],]; CONWAYPOLDATA[86239]:=[ ,,,[51631116825,"JB"],]; CONWAYPOLDATA[86243]:=[ ,,,[102457805161,"JB"],]; CONWAYPOLDATA[86249]:=[ ,,,[7437855016,"JB"],]; CONWAYPOLDATA[86257]:=[ ,,,[78289440915,"JB"],]; CONWAYPOLDATA[86263]:=[ ,,,[28235173848,"JB"],]; CONWAYPOLDATA[86269]:=[ ,,,[22235662218,"JB"],]; CONWAYPOLDATA[86287]:=[ ,,,[20737699869,"JB"],]; CONWAYPOLDATA[86291]:=[ ,,,[63465477264,"JB"],]; CONWAYPOLDATA[86293]:=[ ,,,[81028436658,"JB"],]; CONWAYPOLDATA[86297]:=[ ,,,[13635702676,"JB"],]; CONWAYPOLDATA[86311]:=[ ,,,[27905554657,"JB"],]; CONWAYPOLDATA[86323]:=[ ,,,[58872544971,"JB"],]; CONWAYPOLDATA[86341]:=[ ,,,[27905842907,"JB"],]; CONWAYPOLDATA[86351]:=[ ,,,[21151763814,"JB"],]; CONWAYPOLDATA[86353]:=[ ,,,[183530089501,"JB"],]; CONWAYPOLDATA[86357]:=[ ,,,[26293374863,"JB"],]; CONWAYPOLDATA[86369]:=[ ,,,[7458567736,"JB"],]; CONWAYPOLDATA[86371]:=[ ,,,[18905920935,"JB"],]; CONWAYPOLDATA[86381]:=[ ,,,[95290422724,"JB"],]; CONWAYPOLDATA[86389]:=[ ,,,[58655712110,"JB"],]; CONWAYPOLDATA[86399]:=[ ,,,[81865126087,"JB"],]; CONWAYPOLDATA[86413]:=[ ,,,[27222255327,"JB"],]; CONWAYPOLDATA[86423]:=[ ,,,[52246506117,"JB"],]; CONWAYPOLDATA[86441]:=[ ,,,[7471009192,"JB"],]; CONWAYPOLDATA[86453]:=[ ,,,[13439032399,"JB"],]; CONWAYPOLDATA[86461]:=[ ,,,[94232028221,"JB"],]; CONWAYPOLDATA[86467]:=[ ,,,[20907893536,"JB"],]; CONWAYPOLDATA[86477]:=[ ,,,[29494450961,"JB"],]; CONWAYPOLDATA[86491]:=[ ,,,[20620751767,"JB"],]; CONWAYPOLDATA[86501]:=[ ,,,[59388213063,"JB"],]; CONWAYPOLDATA[86509]:=[ ,,,[81887083663,"JB"],]; CONWAYPOLDATA[86531]:=[ ,,,[59828917898,"JB"],]; CONWAYPOLDATA[86533]:=[ ,,,[58167136470,"JB"],]; CONWAYPOLDATA[86539]:=[ ,,,[56713939426,"JB"],]; CONWAYPOLDATA[86561]:=[ ,,,[36257892634,"JB"],]; CONWAYPOLDATA[86573]:=[ ,,,[94661775111,"JB"],]; CONWAYPOLDATA[86579]:=[ ,,,[21322849280,"JB"],]; CONWAYPOLDATA[86587]:=[ ,,,[58282835334,"JB"],]; CONWAYPOLDATA[86599]:=[ ,,,[18864552965,"JB"],]; CONWAYPOLDATA[86627]:=[ ,,,[125020346283,"JB"],]; CONWAYPOLDATA[86629]:=[ ,,,[52394778524,"JB"],]; CONWAYPOLDATA[86677]:=[ ,,,[73236517674,"JB"],]; CONWAYPOLDATA[86689]:=[ ,,,[112575895815,"JB"],]; CONWAYPOLDATA[86693]:=[ ,,,[27337077078,"JB"],]; CONWAYPOLDATA[86711]:=[ ,,,[27325497570,"JB"],]; CONWAYPOLDATA[86719]:=[ ,,,[27539959869,"JB"],]; CONWAYPOLDATA[86729]:=[ ,,,[21260139960,"JB"],]; CONWAYPOLDATA[86743]:=[ ,,,[19332412413,"JB"],]; CONWAYPOLDATA[86753]:=[ ,,,[59202676287,"JB"],]; CONWAYPOLDATA[86767]:=[ ,,,[41892929710,"JB"],]; CONWAYPOLDATA[86771]:=[ ,,,[43823693556,"JB"],]; CONWAYPOLDATA[86783]:=[ ,,,[19972326408,"JB"],]; CONWAYPOLDATA[86813]:=[ ,,,[5963879476,"JB"],]; CONWAYPOLDATA[86837]:=[ ,,,[59909540998,"JB"],]; CONWAYPOLDATA[86843]:=[ ,,,[64885268510,"JB"],]; CONWAYPOLDATA[86851]:=[ ,,,[65106549387,"JB"],]; CONWAYPOLDATA[86857]:=[ ,,,[172423131276,"JB"],]; CONWAYPOLDATA[86861]:=[ ,,,[75286424308,"JB"],]; CONWAYPOLDATA[86869]:=[ ,,,[87675578667,"JB"],]; CONWAYPOLDATA[86923]:=[ ,,,[65189990004,"JB"],]; CONWAYPOLDATA[86927]:=[ ,,,[35375116509,"JB"],]; CONWAYPOLDATA[86929]:=[ ,,,[96837341292,"JB"],]; CONWAYPOLDATA[86939]:=[ ,,,[34880448436,"JB"],]; CONWAYPOLDATA[86951]:=[ ,,,[22398229803,"JB"],]; CONWAYPOLDATA[86959]:=[ ,,,[27523132216,"JB"],]; CONWAYPOLDATA[86969]:=[ ,,,[29051994453,"JB"],]; CONWAYPOLDATA[86981]:=[ ,,,[28716777152,"JB"],]; CONWAYPOLDATA[86993]:=[ ,,,[72557207597,"JB"],]; CONWAYPOLDATA[87011]:=[ ,,,[57228439867,"JB"],]; CONWAYPOLDATA[87013]:=[ ,,,[52642255914,"JB"],]; CONWAYPOLDATA[87037]:=[ ,,,[52825888634,"JB"],]; CONWAYPOLDATA[87041]:=[ ,,,[21882542608,"JB"],]; CONWAYPOLDATA[87049]:=[ ,,,[67792455484,"JB"],]; CONWAYPOLDATA[87071]:=[ ,,,[22488436684,"JB"],]; CONWAYPOLDATA[87083]:=[ ,,,[20387523630,"JB"],]; CONWAYPOLDATA[87103]:=[ ,,,[51973924588,"JB"],]; CONWAYPOLDATA[87107]:=[ ,,,[105816276997,"JB"],]; CONWAYPOLDATA[87119]:=[ ,,,[5108483929,"JB"],]; CONWAYPOLDATA[87121]:=[ ,,,[7149149267,"JB"],]; CONWAYPOLDATA[87133]:=[ ,,,[37320370901,"JB"],]; CONWAYPOLDATA[87149]:=[ ,,,[11926689248,"JB"],]; CONWAYPOLDATA[87151]:=[ ,,,[52502115480,"JB"],]; CONWAYPOLDATA[87179]:=[ ,,,[27714552818,"JB"],]; CONWAYPOLDATA[87181]:=[ ,,,[29212696663,"JB"],]; CONWAYPOLDATA[87187]:=[ ,,,[19263618905,"JB"],]; CONWAYPOLDATA[87211]:=[ ,,,[3836935169,"JB"],]; CONWAYPOLDATA[87221]:=[ ,,,[67001515011,"JB"],]; CONWAYPOLDATA[87223]:=[ ,,,[30202446544,"JB"],]; CONWAYPOLDATA[87251]:=[ ,,,[60361288814,"JB"],]; CONWAYPOLDATA[87253]:=[ ,,,[60134069578,"JB"],]; CONWAYPOLDATA[87257]:=[ ,,,[13646645775,"JB"],]; CONWAYPOLDATA[87277]:=[ ,,,[29029115698,"JB"],]; CONWAYPOLDATA[87281]:=[ ,,,[60782750246,"JB"],]; CONWAYPOLDATA[87293]:=[ ,,,[36741710995,"JB"],]; CONWAYPOLDATA[87299]:=[ ,,,[28557510779,"JB"],]; CONWAYPOLDATA[87313]:=[ ,,,[97148372890,"JB"],]; CONWAYPOLDATA[87317]:=[ ,,,[14413242558,"JB"],]; CONWAYPOLDATA[87323]:=[ ,,,[35762086776,"JB"],]; CONWAYPOLDATA[87337]:=[ ,,,[50824457100,"JB"],]; CONWAYPOLDATA[87359]:=[ ,,,[59654403554,"JB"],]; CONWAYPOLDATA[87383]:=[ ,,,[37163290841,"JB"],]; CONWAYPOLDATA[87403]:=[ ,,,[68036068456,"JB"],]; CONWAYPOLDATA[87407]:=[ ,,,[43016655799,"JB"],]; CONWAYPOLDATA[87421]:=[ ,,,[91148806288,"JB"],]; CONWAYPOLDATA[87427]:=[ ,,,[66493828830,"JB"],]; CONWAYPOLDATA[87433]:=[ ,,,[50461256491,"JB"],]; CONWAYPOLDATA[87443]:=[ ,,,[28412154448,"JB"],]; CONWAYPOLDATA[87473]:=[ ,,,[80419702123,"JB"],]; CONWAYPOLDATA[87481]:=[ ,,,[279723559364,"JB"],]; CONWAYPOLDATA[87491]:=[ ,,,[21016738058,"JB"],]; CONWAYPOLDATA[87509]:=[ ,,,[22330459113,"JB"],]; CONWAYPOLDATA[87511]:=[ ,,,[20781237173,"JB"],]; CONWAYPOLDATA[87517]:=[ ,,,[52984104557,"JB"],]; CONWAYPOLDATA[87523]:=[ ,,,[67872686134,"JB"],]; CONWAYPOLDATA[87539]:=[ ,,,[126785097255,"JB"],]; CONWAYPOLDATA[87541]:=[ ,,,[59192072742,"JB"],]; CONWAYPOLDATA[87547]:=[ ,,,[81992930775,"JB"],]; CONWAYPOLDATA[87553]:=[ ,,,[83786732604,"JB"],]; CONWAYPOLDATA[87557]:=[ ,,,[120617997861,"JB"],]; CONWAYPOLDATA[87559]:=[ ,,,[51500977977,"JB"],]; CONWAYPOLDATA[87583]:=[ ,,,[52503731345,"JB"],]; CONWAYPOLDATA[87587]:=[ ,,,[38112869943,"JB"],]; CONWAYPOLDATA[87589]:=[ ,,,[26965149542,"JB"],]; CONWAYPOLDATA[87613]:=[ ,,,[76254850682,"JB"],]; CONWAYPOLDATA[87623]:=[ ,,,[29086805347,"JB"],]; CONWAYPOLDATA[87629]:=[ ,,,[36791999571,"JB"],]; CONWAYPOLDATA[87631]:=[ ,,,[30211751197,"JB"],]; CONWAYPOLDATA[87641]:=[ ,,,[22984816304,"JB"],]; CONWAYPOLDATA[87643]:=[ ,,,[19964023687,"JB"],]; CONWAYPOLDATA[87649]:=[ ,,,[144724188188,"JB"],]; CONWAYPOLDATA[87671]:=[ ,,,[76567204848,"JB"],]; CONWAYPOLDATA[87679]:=[ ,,,[30097745691,"JB"],]; CONWAYPOLDATA[87683]:=[ ,,,[29797839990,"JB"],]; CONWAYPOLDATA[87691]:=[ ,,,[53782994891,"JB"],]; CONWAYPOLDATA[87697]:=[ ,,,[89222138544,"JB"],]; CONWAYPOLDATA[87701]:=[ ,,,[38220709709,"JB"],]; CONWAYPOLDATA[87719]:=[ ,,,[38383115118,"JB"],]; CONWAYPOLDATA[87721]:=[ ,,,[160296443035,"JB"],]; CONWAYPOLDATA[87739]:=[ ,,,[89849298435,"JB"],]; CONWAYPOLDATA[87743]:=[ ,,,[65751708686,"JB"],]; CONWAYPOLDATA[87751]:=[ ,,,[38500839004,"JB"],]; CONWAYPOLDATA[87767]:=[ ,,,[30811834093,"JB"],]; CONWAYPOLDATA[87793]:=[ ,,,[53409486106,"JB"],]; CONWAYPOLDATA[87797]:=[ ,,,[28511373376,"JB"],]; CONWAYPOLDATA[87803]:=[ ,,,[15009835052,"JB"],]; CONWAYPOLDATA[87811]:=[ ,,,[53842719628,"JB"],]; CONWAYPOLDATA[87833]:=[ ,,,[205445427321,"JB"],]; CONWAYPOLDATA[87853]:=[ ,,,[29492252102,"JB"],]; CONWAYPOLDATA[87869]:=[ ,,,[35032315874,"JB"],]; CONWAYPOLDATA[87877]:=[ ,,,[52262121565,"JB"],]; CONWAYPOLDATA[87881]:=[ ,,,[59645274108,"JB"],]; CONWAYPOLDATA[87887]:=[ ,,,[58211251359,"JB"],]; CONWAYPOLDATA[87911]:=[ ,,,[37950123797,"JB"],]; CONWAYPOLDATA[87917]:=[ ,,,[54047503254,"JB"],]; CONWAYPOLDATA[87931]:=[ ,,,[7375300566,"JB"],]; CONWAYPOLDATA[87943]:=[ ,,,[53568807536,"JB"],]; CONWAYPOLDATA[87959]:=[ ,,,[38683136781,"JB"],]; CONWAYPOLDATA[87961]:=[ ,,,[5687470313,"JB"],]; CONWAYPOLDATA[87973]:=[ ,,,[83435088743,"JB"],]; CONWAYPOLDATA[87977]:=[ ,,,[37518847377,"JB"],]; CONWAYPOLDATA[87991]:=[ ,,,[81894983526,"JB"],]; CONWAYPOLDATA[88001]:=[ ,,,[6430057074,"JB"],]; CONWAYPOLDATA[88003]:=[ ,,,[19483072175,"JB"],]; CONWAYPOLDATA[88007]:=[ ,,,[20360243441,"JB"],]; CONWAYPOLDATA[88019]:=[ ,,,[27952457889,"JB"],]; CONWAYPOLDATA[88037]:=[ ,,,[21630955013,"JB"],]; CONWAYPOLDATA[88069]:=[ ,,,[97995080854,"JB"],]; CONWAYPOLDATA[88079]:=[ ,,,[50924283145,"JB"],]; CONWAYPOLDATA[88093]:=[ ,,,[52307156798,"JB"],]; CONWAYPOLDATA[88117]:=[ ,,,[52387495079,"JB"],]; CONWAYPOLDATA[88129]:=[ ,,,[68910797110,"JB"],]; CONWAYPOLDATA[88169]:=[ ,,,[7281877713,"JB"],]; CONWAYPOLDATA[88177]:=[ ,,,[120844726788,"JB"],]; CONWAYPOLDATA[88211]:=[ ,,,[58402297827,"JB"],]; CONWAYPOLDATA[88223]:=[ ,,,[21456098274,"JB"],]; CONWAYPOLDATA[88237]:=[ ,,,[53140203830,"JB"],]; CONWAYPOLDATA[88241]:=[ ,,,[20980444886,"JB"],]; CONWAYPOLDATA[88259]:=[ ,,,[22400928533,"JB"],]; CONWAYPOLDATA[88261]:=[ ,,,[30669461848,"JB"],]; CONWAYPOLDATA[88289]:=[ ,,,[12723327793,"JB"],]; CONWAYPOLDATA[88301]:=[ ,,,[22358166406,"JB"],]; CONWAYPOLDATA[88321]:=[ ,,,[107969154657,"JB"],]; CONWAYPOLDATA[88327]:=[ ,,,[44311447730,"JB"],]; CONWAYPOLDATA[88337]:=[ ,,,[54512586029,"JB"],]; CONWAYPOLDATA[88339]:=[ ,,,[43957398064,"JB"],]; CONWAYPOLDATA[88379]:=[ ,,,[131935883120,"JB"],]; CONWAYPOLDATA[88397]:=[ ,,,[53521378004,"JB"],]; CONWAYPOLDATA[88411]:=[ ,,,[29577634819,"JB"],]; CONWAYPOLDATA[88423]:=[ ,,,[22636553275,"JB"],]; CONWAYPOLDATA[88427]:=[ ,,,[38568143468,"JB"],]; CONWAYPOLDATA[88463]:=[ ,,,[31302455629,"JB"],]; CONWAYPOLDATA[88469]:=[ ,,,[28413234856,"JB"],]; CONWAYPOLDATA[88471]:=[ ,,,[27617815139,"JB"],]; CONWAYPOLDATA[88493]:=[ ,,,[52036361806,"JB"],]; CONWAYPOLDATA[88499]:=[ ,,,[30325775334,"JB"],]; CONWAYPOLDATA[88513]:=[ ,,,[124009545426,"JB"],]; CONWAYPOLDATA[88523]:=[ ,,,[6176603804,"JB"],]; CONWAYPOLDATA[88547]:=[ ,,,[124431380128,"JB"],]; CONWAYPOLDATA[88589]:=[ ,,,[154579389047,"JB"],]; CONWAYPOLDATA[88591]:=[ ,,,[84300449294,"JB"],]; CONWAYPOLDATA[88607]:=[ ,,,[94213342109,"JB"],]; CONWAYPOLDATA[88609]:=[ ,,,[162750719978,"JB"],]; CONWAYPOLDATA[88643]:=[ ,,,[5396497199,"JB"],]; CONWAYPOLDATA[88651]:=[ ,,,[20566322795,"JB"],]; CONWAYPOLDATA[88657]:=[ ,,,[99788063669,"JB"],]; CONWAYPOLDATA[88661]:=[ ,,,[38336395775,"JB"],]; CONWAYPOLDATA[88663]:=[ ,,,[86471693958,"JB"],]; CONWAYPOLDATA[88667]:=[ ,,,[92660561682,"JB"],]; CONWAYPOLDATA[88681]:=[ ,,,[7057233987,"JB"],]; CONWAYPOLDATA[88721]:=[ ,,,[62694162327,"JB"],]; CONWAYPOLDATA[88729]:=[ ,,,[179998045100,"JB"],]; CONWAYPOLDATA[88741]:=[ ,,,[84905702723,"JB"],]; CONWAYPOLDATA[88747]:=[ ,,,[92022119295,"JB"],]; CONWAYPOLDATA[88771]:=[ ,,,[45447023629,"JB"],]; CONWAYPOLDATA[88789]:=[ ,,,[83523634724,"JB"],]; CONWAYPOLDATA[88793]:=[ ,,,[19843459643,"JB"],]; CONWAYPOLDATA[88799]:=[ ,,,[39425512821,"JB"],]; CONWAYPOLDATA[88801]:=[ ,,,[210355360847,"JB"],]; CONWAYPOLDATA[88807]:=[ ,,,[31546377773,"JB"],]; CONWAYPOLDATA[88811]:=[ ,,,[70755812513,"JB"],]; CONWAYPOLDATA[88813]:=[ ,,,[11964620926,"JB"],]; CONWAYPOLDATA[88817]:=[ ,,,[14191624348,"JB"],]; CONWAYPOLDATA[88819]:=[ ,,,[12904778969,"JB"],]; CONWAYPOLDATA[88843]:=[ ,,,[71037085942,"JB"],]; CONWAYPOLDATA[88853]:=[ ,,,[20992409782,"JB"],]; CONWAYPOLDATA[88861]:=[ ,,,[78692635772,"JB"],]; CONWAYPOLDATA[88867]:=[ ,,,[70800783237,"JB"],]; CONWAYPOLDATA[88873]:=[ ,,,[68399149259,"JB"],]; CONWAYPOLDATA[88883]:=[ ,,,[59648670238,"JB"],]; CONWAYPOLDATA[88897]:=[ ,,,[102733017988,"JB"],]; CONWAYPOLDATA[88903]:=[ ,,,[28439447382,"JB"],]; CONWAYPOLDATA[88919]:=[ ,,,[53332549195,"JB"],]; CONWAYPOLDATA[88937]:=[ ,,,[62467303252,"JB"],]; CONWAYPOLDATA[88951]:=[ ,,,[39561046204,"JB"],]; CONWAYPOLDATA[88969]:=[ ,,,[4632882744,"JB"],]; CONWAYPOLDATA[88993]:=[ ,,,[164883204643,"JB"],]; CONWAYPOLDATA[88997]:=[ ,,,[94531456441,"JB"],]; CONWAYPOLDATA[89003]:=[ ,,,[21510601054,"JB"],]; CONWAYPOLDATA[89009]:=[ ,,,[63343254853,"JB"],]; CONWAYPOLDATA[89017]:=[ ,,,[51881065979,"JB"],]; CONWAYPOLDATA[89021]:=[ ,,,[102744299320,"JB"],]; CONWAYPOLDATA[89041]:=[ ,,,[202645651658,"JB"],]; CONWAYPOLDATA[89051]:=[ ,,,[60161786990,"JB"],]; CONWAYPOLDATA[89057]:=[ ,,,[5542195227,"JB"],]; CONWAYPOLDATA[89069]:=[ ,,,[132738640012,"JB"],]; CONWAYPOLDATA[89071]:=[ ,,,[23016391761,"JB"],]; CONWAYPOLDATA[89083]:=[ ,,,[70987570212,"JB"],]; CONWAYPOLDATA[89087]:=[ ,,,[29182674030,"JB"],]; CONWAYPOLDATA[89101]:=[ ,,,[60116088298,"JB"],]; CONWAYPOLDATA[89107]:=[ ,,,[71414448724,"JB"],]; CONWAYPOLDATA[89113]:=[ ,,,[84495699025,"JB"],]; CONWAYPOLDATA[89119]:=[ ,,,[30895685807,"JB"],]; CONWAYPOLDATA[89123]:=[ ,,,[21243803900,"JB"],]; CONWAYPOLDATA[89137]:=[ ,,,[54266605605,"JB"],]; CONWAYPOLDATA[89153]:=[ ,,,[14771849726,"JB"],]; CONWAYPOLDATA[89189]:=[ ,,,[55091331790,"JB"],]; CONWAYPOLDATA[89203]:=[ ,,,[71129134157,"JB"],]; CONWAYPOLDATA[89209]:=[ ,,,[7000141043,"JB"],]; CONWAYPOLDATA[89213]:=[ ,,,[15392364957,"JB"],]; CONWAYPOLDATA[89227]:=[ ,,,[63131314675,"JB"],]; CONWAYPOLDATA[89231]:=[ ,,,[20764499869,"JB"],]; CONWAYPOLDATA[89237]:=[ ,,,[62753332379,"JB"],]; CONWAYPOLDATA[89261]:=[ ,,,[20177716835,"JB"],]; CONWAYPOLDATA[89269]:=[ ,,,[71719964368,"JB"],]; CONWAYPOLDATA[89273]:=[ ,,,[95026019942,"JB"],]; CONWAYPOLDATA[89293]:=[ ,,,[30439805119,"JB"],]; CONWAYPOLDATA[89303]:=[ ,,,[22255915059,"JB"],]; CONWAYPOLDATA[89317]:=[ ,,,[83995582459,"JB"],]; CONWAYPOLDATA[89329]:=[ ,,,[118869117694,"JB"],]; CONWAYPOLDATA[89363]:=[ ,,,[6379356486,"JB"],]; CONWAYPOLDATA[89371]:=[ ,,,[70628292624,"JB"],]; CONWAYPOLDATA[89381]:=[ ,,,[12284882166,"JB"],]; CONWAYPOLDATA[89387]:=[ ,,,[62791507118,"JB"],]; CONWAYPOLDATA[89393]:=[ ,,,[54218463577,"JB"],]; CONWAYPOLDATA[89399]:=[ ,,,[20761934368,"JB"],]; CONWAYPOLDATA[89413]:=[ ,,,[62950686174,"JB"],]; CONWAYPOLDATA[89417]:=[ ,,,[13920885648,"JB"],]; CONWAYPOLDATA[89431]:=[ ,,,[21701952488,"JB"],]; CONWAYPOLDATA[89443]:=[ ,,,[85892917889,"JB"],]; CONWAYPOLDATA[89449]:=[ ,,,[86536361673,"JB"],]; CONWAYPOLDATA[89459]:=[ ,,,[60358971351,"JB"],]; CONWAYPOLDATA[89477]:=[ ,,,[78118521191,"JB"],]; CONWAYPOLDATA[89491]:=[ ,,,[72077125294,"JB"],]; CONWAYPOLDATA[89501]:=[ ,,,[80044413843,"JB"],]; CONWAYPOLDATA[89513]:=[ ,,,[180704100214,"JB"],]; CONWAYPOLDATA[89519]:=[ ,,,[46036667584,"JB"],]; CONWAYPOLDATA[89521]:=[ ,,,[87064454253,"JB"],]; CONWAYPOLDATA[89527]:=[ ,,,[29111405066,"JB"],]; CONWAYPOLDATA[89533]:=[ ,,,[52612097726,"JB"],]; CONWAYPOLDATA[89561]:=[ ,,,[61408574385,"JB"],]; CONWAYPOLDATA[89563]:=[ ,,,[62178485811,"JB"],]; CONWAYPOLDATA[89567]:=[ ,,,[37176932963,"JB"],]; CONWAYPOLDATA[89591]:=[ ,,,[23210698747,"JB"],]; CONWAYPOLDATA[89597]:=[ ,,,[55038899520,"JB"],]; CONWAYPOLDATA[89599]:=[ ,,,[30218517139,"JB"],]; CONWAYPOLDATA[89603]:=[ ,,,[95346552302,"JB"],]; CONWAYPOLDATA[89611]:=[ ,,,[68894729022,"JB"],]; CONWAYPOLDATA[89627]:=[ ,,,[111088812541,"JB"],]; CONWAYPOLDATA[89633]:=[ ,,,[23912471009,"JB"],]; CONWAYPOLDATA[89653]:=[ ,,,[28404580701,"JB"],]; CONWAYPOLDATA[89657]:=[ ,,,[36336547591,"JB"],]; CONWAYPOLDATA[89659]:=[ ,,,[46113058254,"JB"],]; CONWAYPOLDATA[89669]:=[ ,,,[31043676809,"JB"],]; CONWAYPOLDATA[89671]:=[ ,,,[31641488408,"JB"],]; CONWAYPOLDATA[89681]:=[ ,,,[72308176045,"JB"],]; CONWAYPOLDATA[89689]:=[ ,,,[6572678994,"JB"],]; CONWAYPOLDATA[89753]:=[ ,,,[14549320315,"JB"],]; CONWAYPOLDATA[89759]:=[ ,,,[28727906517,"JB"],]; CONWAYPOLDATA[89767]:=[ ,,,[45795622490,"JB"],]; CONWAYPOLDATA[89779]:=[ ,,,[71529083998,"JB"],]; CONWAYPOLDATA[89783]:=[ ,,,[46496640479,"JB"],]; CONWAYPOLDATA[89797]:=[ ,,,[32027267416,"JB"],]; CONWAYPOLDATA[89809]:=[ ,,,[141613794904,"JB"],]; CONWAYPOLDATA[89819]:=[ ,,,[70147740812,"JB"],]; CONWAYPOLDATA[89821]:=[ ,,,[53178612873,"JB"],]; CONWAYPOLDATA[89833]:=[ ,,,[150757111774,"JB"],]; CONWAYPOLDATA[89839]:=[ ,,,[4353867464,"JB"],]; CONWAYPOLDATA[89849]:=[ ,,,[22796218736,"JB"],]; CONWAYPOLDATA[89867]:=[ ,,,[56230141370,"JB"],]; CONWAYPOLDATA[89891]:=[ ,,,[40401150393,"JB"],]; CONWAYPOLDATA[89897]:=[ ,,,[4864146879,"JB"],]; CONWAYPOLDATA[89899]:=[ ,,,[15632716910,"JB"],]; CONWAYPOLDATA[89909]:=[ ,,,[61336009711,"JB"],]; CONWAYPOLDATA[89917]:=[ ,,,[184306741333,"JB"],]; CONWAYPOLDATA[89923]:=[ ,,,[201009288130,"JB"],]; CONWAYPOLDATA[89939]:=[ ,,,[23308501303,"JB"],]; CONWAYPOLDATA[89959]:=[ ,,,[29510060404,"JB"],]; CONWAYPOLDATA[89963]:=[ ,,,[38366160760,"JB"],]; CONWAYPOLDATA[89977]:=[ ,,,[55059535638,"JB"],]; CONWAYPOLDATA[89983]:=[ ,,,[28856918222,"JB"],]; CONWAYPOLDATA[89989]:=[ ,,,[87913673684,"JB"],]; CONWAYPOLDATA[90001]:=[ ,,,[191526268059,"JB"],]; CONWAYPOLDATA[90007]:=[ ,,,[46816781028,"JB"],]; CONWAYPOLDATA[90011]:=[ ,,,[93744836304,"JB"],]; CONWAYPOLDATA[90017]:=[ ,,,[5915107090,"JB"],]; CONWAYPOLDATA[90019]:=[ ,,,[21521832553,"JB"],]; CONWAYPOLDATA[90023]:=[ ,,,[44637544463,"JB"],]; CONWAYPOLDATA[90031]:=[ ,,,[31535788590,"JB"],]; CONWAYPOLDATA[90053]:=[ ,,,[32102813866,"JB"],]; CONWAYPOLDATA[90059]:=[ ,,,[55185993786,"JB"],]; CONWAYPOLDATA[90067]:=[ ,,,[142115818632,"JB"],]; CONWAYPOLDATA[90071]:=[ ,,,[20728399521,"JB"],]; CONWAYPOLDATA[90073]:=[ ,,,[182899531620,"JB"],]; CONWAYPOLDATA[90089]:=[ ,,,[64780117055,"JB"],]; CONWAYPOLDATA[90107]:=[ ,,,[126008151798,"JB"],]; CONWAYPOLDATA[90121]:=[ ,,,[137879182037,"JB"],]; CONWAYPOLDATA[90127]:=[ ,,,[29408530230,"JB"],]; CONWAYPOLDATA[90149]:=[ ,,,[15923288319,"JB"],]; CONWAYPOLDATA[90163]:=[ ,,,[24221207996,"JB"],]; CONWAYPOLDATA[90173]:=[ ,,,[37985827117,"JB"],]; CONWAYPOLDATA[90187]:=[ ,,,[21098256595,"JB"],]; CONWAYPOLDATA[90191]:=[ ,,,[120465232605,"JB"],]; CONWAYPOLDATA[90197]:=[ ,,,[6056187370,"JB"],]; CONWAYPOLDATA[90199]:=[ ,,,[40678937212,"JB"],]; CONWAYPOLDATA[90203]:=[ ,,,[64858031671,"JB"],]; CONWAYPOLDATA[90217]:=[ ,,,[56661237957,"JB"],]; CONWAYPOLDATA[90227]:=[ ,,,[15616850070,"JB"],]; CONWAYPOLDATA[90239]:=[ ,,,[20922904786,"JB"],]; CONWAYPOLDATA[90247]:=[ ,,,[79835113368,"JB"],]; CONWAYPOLDATA[90263]:=[ ,,,[61811560827,"JB"],]; CONWAYPOLDATA[90271]:=[ ,,,[30576141768,"JB"],]; CONWAYPOLDATA[90281]:=[ ,,,[30773452506,"JB"],]; CONWAYPOLDATA[90289]:=[ ,,,[71526674956,"JB"],]; CONWAYPOLDATA[90313]:=[ ,,,[89528902539,"JB"],]; CONWAYPOLDATA[90353]:=[ ,,,[15334259398,"JB"],]; CONWAYPOLDATA[90359]:=[ ,,,[88541428726,"JB"],]; CONWAYPOLDATA[90371]:=[ ,,,[38591037761,"JB"],]; CONWAYPOLDATA[90373]:=[ ,,,[12618691622,"JB"],]; CONWAYPOLDATA[90379]:=[ ,,,[72538637297,"JB"],]; CONWAYPOLDATA[90397]:=[ ,,,[32189015747,"JB"],]; CONWAYPOLDATA[90401]:=[ ,,,[4887078066,"JB"],]; CONWAYPOLDATA[90403]:=[ ,,,[29216351140,"JB"],]; CONWAYPOLDATA[90407]:=[ ,,,[98080022909,"JB"],]; CONWAYPOLDATA[90437]:=[ ,,,[56286180062,"JB"],]; CONWAYPOLDATA[90439]:=[ ,,,[21793085843,"JB"],]; CONWAYPOLDATA[90469]:=[ ,,,[63780825940,"JB"],]; CONWAYPOLDATA[90473]:=[ ,,,[6714091806,"JB"],]; CONWAYPOLDATA[90481]:=[ ,,,[69650283232,"JB"],]; CONWAYPOLDATA[90499]:=[ ,,,[88412726555,"JB"],]; CONWAYPOLDATA[90511]:=[ ,,,[31895895381,"JB"],]; CONWAYPOLDATA[90523]:=[ ,,,[65143157015,"JB"],]; CONWAYPOLDATA[90527]:=[ ,,,[62956821101,"JB"],]; CONWAYPOLDATA[90529]:=[ ,,,[201445311865,"JB"],]; CONWAYPOLDATA[90533]:=[ ,,,[81700962654,"JB"],]; CONWAYPOLDATA[90547]:=[ ,,,[86760324462,"JB"],]; CONWAYPOLDATA[90583]:=[ ,,,[32820757229,"JB"],]; CONWAYPOLDATA[90599]:=[ ,,,[29852914105,"JB"],]; CONWAYPOLDATA[90617]:=[ ,,,[54175826538,"JB"],]; CONWAYPOLDATA[90619]:=[ ,,,[45245613608,"JB"],]; CONWAYPOLDATA[90631]:=[ ,,,[31474877469,"JB"],]; CONWAYPOLDATA[90641]:=[ ,,,[23427888632,"JB"],]; CONWAYPOLDATA[90647]:=[ ,,,[54051355753,"JB"],]; CONWAYPOLDATA[90659]:=[ ,,,[97311013468,"JB"],]; CONWAYPOLDATA[90677]:=[ ,,,[74000230224,"JB"],]; CONWAYPOLDATA[90679]:=[ ,,,[31831049373,"JB"],]; CONWAYPOLDATA[90697]:=[ ,,,[57095303354,"JB"],]; CONWAYPOLDATA[90703]:=[ ,,,[23339786666,"JB"],]; CONWAYPOLDATA[90709]:=[ ,,,[5886107016,"JB"],]; CONWAYPOLDATA[90731]:=[ ,,,[71995502157,"JB"],]; CONWAYPOLDATA[90749]:=[ ,,,[53881402011,"JB"],]; CONWAYPOLDATA[90787]:=[ ,,,[29803737937,"JB"],]; CONWAYPOLDATA[90793]:=[ ,,,[87995032124,"JB"],]; CONWAYPOLDATA[90803]:=[ ,,,[62364317629,"JB"],]; CONWAYPOLDATA[90821]:=[ ,,,[41241906924,"JB"],]; CONWAYPOLDATA[90823]:=[ ,,,[74178141265,"JB"],]; CONWAYPOLDATA[90833]:=[ ,,,[62474664904,"JB"],]; CONWAYPOLDATA[90841]:=[ ,,,[169707975284,"JB"],]; CONWAYPOLDATA[90847]:=[ ,,,[24194373045,"JB"],]; CONWAYPOLDATA[90863]:=[ ,,,[33023975629,"JB"],]; CONWAYPOLDATA[90887]:=[ ,,,[48604458978,"JB"],]; CONWAYPOLDATA[90901]:=[ ,,,[63826228053,"JB"],]; CONWAYPOLDATA[90907]:=[ ,,,[33055966973,"JB"],]; CONWAYPOLDATA[90911]:=[ ,,,[22878207712,"JB"],]; CONWAYPOLDATA[90917]:=[ ,,,[63815824223,"JB"],]; CONWAYPOLDATA[90931]:=[ ,,,[22975990436,"JB"],]; CONWAYPOLDATA[90947]:=[ ,,,[14602723163,"JB"],]; CONWAYPOLDATA[90971]:=[ ,,,[39030288813,"JB"],]; CONWAYPOLDATA[90977]:=[ ,,,[98116874963,"JB"],]; CONWAYPOLDATA[90989]:=[ ,,,[30188876356,"JB"],]; CONWAYPOLDATA[90997]:=[ ,,,[173270845591,"JB"],]; CONWAYPOLDATA[91009]:=[ ,,,[139961740012,"JB"],]; CONWAYPOLDATA[91019]:=[ ,,,[40357005431,"JB"],]; CONWAYPOLDATA[91033]:=[ ,,,[124304104977,"JB"],]; CONWAYPOLDATA[91079]:=[ ,,,[106215236859,"JB"],]; CONWAYPOLDATA[91081]:=[ ,,,[253377960674,"JB"],]; CONWAYPOLDATA[91097]:=[ ,,,[5228056833,"JB"],]; CONWAYPOLDATA[91099]:=[ ,,,[74262629416,"JB"],]; CONWAYPOLDATA[91121]:=[ ,,,[6762453900,"JB"],]; CONWAYPOLDATA[91127]:=[ ,,,[29497445397,"JB"],]; CONWAYPOLDATA[91129]:=[ ,,,[6682125061,"JB"],]; CONWAYPOLDATA[91139]:=[ ,,,[14962927605,"JB"],]; CONWAYPOLDATA[91141]:=[ ,,,[64980434212,"JB"],]; CONWAYPOLDATA[91151]:=[ ,,,[24886592933,"JB"],]; CONWAYPOLDATA[91153]:=[ ,,,[74579470394,"JB"],]; CONWAYPOLDATA[91159]:=[ ,,,[24051299407,"JB"],]; CONWAYPOLDATA[91163]:=[ ,,,[63078323429,"JB"],]; CONWAYPOLDATA[91183]:=[ ,,,[31962376993,"JB"],]; CONWAYPOLDATA[91193]:=[ ,,,[22934401152,"JB"],]; CONWAYPOLDATA[91199]:=[ ,,,[38517806462,"JB"],]; CONWAYPOLDATA[91229]:=[ ,,,[15122940103,"JB"],]; CONWAYPOLDATA[91237]:=[ ,,,[54907977635,"JB"],]; CONWAYPOLDATA[91243]:=[ ,,,[58276265404,"JB"],]; CONWAYPOLDATA[91249]:=[ ,,,[182933805241,"JB"],]; CONWAYPOLDATA[91253]:=[ ,,,[107094338296,"JB"],]; CONWAYPOLDATA[91283]:=[ ,,,[113142996427,"JB"],]; CONWAYPOLDATA[91291]:=[ ,,,[237633211732,"JB"],]; CONWAYPOLDATA[91297]:=[ ,,,[56940204262,"JB"],]; CONWAYPOLDATA[91303]:=[ ,,,[29916980104,"JB"],]; CONWAYPOLDATA[91309]:=[ ,,,[91709572593,"JB"],]; CONWAYPOLDATA[91331]:=[ ,,,[32511552727,"JB"],]; CONWAYPOLDATA[91367]:=[ ,,,[57290124122,"JB"],]; CONWAYPOLDATA[91369]:=[ ,,,[5373959111,"JB"],]; CONWAYPOLDATA[91373]:=[ ,,,[172774099021,"JB"],]; CONWAYPOLDATA[91381]:=[ ,,,[41243078128,"JB"],]; CONWAYPOLDATA[91387]:=[ ,,,[72952231588,"JB"],]; CONWAYPOLDATA[91393]:=[ ,,,[399802608422,"JB"],]; CONWAYPOLDATA[91397]:=[ ,,,[12856176213,"JB"],]; CONWAYPOLDATA[91411]:=[ ,,,[55746632708,"JB"],]; CONWAYPOLDATA[91423]:=[ ,,,[24256807478,"JB"],]; CONWAYPOLDATA[91433]:=[ ,,,[22241168686,"JB"],]; CONWAYPOLDATA[91453]:=[ ,,,[55889671896,"JB"],]; CONWAYPOLDATA[91457]:=[ ,,,[7778966595,"JB"],]; CONWAYPOLDATA[91459]:=[ ,,,[74617190988,"JB"],]; CONWAYPOLDATA[91463]:=[ ,,,[49767945121,"JB"],]; CONWAYPOLDATA[91493]:=[ ,,,[80195993320,"JB"],]; CONWAYPOLDATA[91499]:=[ ,,,[63237429375,"JB"],]; CONWAYPOLDATA[91513]:=[ ,,,[56259538533,"JB"],]; CONWAYPOLDATA[91529]:=[ ,,,[8376459496,"JB"],]; CONWAYPOLDATA[91541]:=[ ,,,[13666796679,"JB"],]; CONWAYPOLDATA[91571]:=[ ,,,[72192287127,"JB"],]; CONWAYPOLDATA[91573]:=[ ,,,[33503264077,"JB"],]; CONWAYPOLDATA[91577]:=[ ,,,[63802520096,"JB"],]; CONWAYPOLDATA[91583]:=[ ,,,[25074692741,"JB"],]; CONWAYPOLDATA[91591]:=[ ,,,[41944190044,"JB"],]; CONWAYPOLDATA[91621]:=[ ,,,[31494535510,"JB"],]; CONWAYPOLDATA[91631]:=[ ,,,[40375550799,"JB"],]; CONWAYPOLDATA[91639]:=[ ,,,[31473047997,"JB"],]; CONWAYPOLDATA[91673]:=[ ,,,[41226814871,"JB"],]; CONWAYPOLDATA[91691]:=[ ,,,[23571188754,"JB"],]; CONWAYPOLDATA[91703]:=[ ,,,[33637394029,"JB"],]; CONWAYPOLDATA[91711]:=[ ,,,[56846788228,"JB"],]; CONWAYPOLDATA[91733]:=[ ,,,[56880973045,"JB"],]; CONWAYPOLDATA[91753]:=[ ,,,[75213053712,"JB"],]; CONWAYPOLDATA[91757]:=[ ,,,[97218743670,"JB"],]; CONWAYPOLDATA[91771]:=[ ,,,[74261643828,"JB"],]; CONWAYPOLDATA[91781]:=[ ,,,[106721570087,"JB"],]; CONWAYPOLDATA[91801]:=[ ,,,[92460773800,"JB"],]; CONWAYPOLDATA[91807]:=[ ,,,[42142259020,"JB"],]; CONWAYPOLDATA[91811]:=[ ,,,[65890183994,"JB"],]; CONWAYPOLDATA[91813]:=[ ,,,[89972424791,"JB"],]; CONWAYPOLDATA[91823]:=[ ,,,[49359453655,"JB"],]; CONWAYPOLDATA[91837]:=[ ,,,[55095679575,"JB"],]; CONWAYPOLDATA[91841]:=[ ,,,[39658413259,"JB"],]; CONWAYPOLDATA[91867]:=[ ,,,[90551923897,"JB"],]; CONWAYPOLDATA[91873]:=[ ,,,[57992442557,"JB"],]; CONWAYPOLDATA[91909]:=[ ,,,[81037727755,"JB"],]; CONWAYPOLDATA[91921]:=[ ,,,[140975744715,"JB"],]; CONWAYPOLDATA[91939]:=[ ,,,[30255378061,"JB"],]; CONWAYPOLDATA[91943]:=[ ,,,[30946174945,"JB"],]; CONWAYPOLDATA[91951]:=[ ,,,[32932066751,"JB"],]; CONWAYPOLDATA[91957]:=[ ,,,[40271924458,"JB"],]; CONWAYPOLDATA[91961]:=[ ,,,[32624912024,"JB"],]; CONWAYPOLDATA[91967]:=[ ,,,[33831348493,"JB"],]; CONWAYPOLDATA[91969]:=[ ,,,[141721102067,"JB"],]; CONWAYPOLDATA[91997]:=[ ,,,[55878885805,"JB"],]; CONWAYPOLDATA[92003]:=[ ,,,[117954746227,"JB"],]; CONWAYPOLDATA[92009]:=[ ,,,[21982238229,"JB"],]; CONWAYPOLDATA[92033]:=[ ,,,[4670490687,"JB"],]; CONWAYPOLDATA[92041]:=[ ,,,[5953303928,"JB"],]; CONWAYPOLDATA[92051]:=[ ,,,[23819945225,"JB"],]; CONWAYPOLDATA[92077]:=[ ,,,[30996340897,"JB"],]; CONWAYPOLDATA[92083]:=[ ,,,[107976249553,"JB"],]; CONWAYPOLDATA[92107]:=[ ,,,[72688910155,"JB"],]; CONWAYPOLDATA[92111]:=[ ,,,[67111429836,"JB"],]; CONWAYPOLDATA[92119]:=[ ,,,[57121886475,"JB"],]; CONWAYPOLDATA[92143]:=[ ,,,[48459109421,"JB"],]; CONWAYPOLDATA[92153]:=[ ,,,[65093469542,"JB"],]; CONWAYPOLDATA[92173]:=[ ,,,[109326856167,"JB"],]; CONWAYPOLDATA[92177]:=[ ,,,[74746974545,"JB"],]; CONWAYPOLDATA[92179]:=[ ,,,[24850260076,"JB"],]; CONWAYPOLDATA[92189]:=[ ,,,[22224831933,"JB"],]; CONWAYPOLDATA[92203]:=[ ,,,[99903517953,"JB"],]; CONWAYPOLDATA[92219]:=[ ,,,[65241714837,"JB"],]; CONWAYPOLDATA[92221]:=[ ,,,[72427975660,"JB"],]; CONWAYPOLDATA[92227]:=[ ,,,[33681392630,"JB"],]; CONWAYPOLDATA[92233]:=[ ,,,[134433194592,"JB"],]; CONWAYPOLDATA[92237]:=[ ,,,[14617811999,"JB"],]; CONWAYPOLDATA[92243]:=[ ,,,[41711362172,"JB"],]; CONWAYPOLDATA[92251]:=[ ,,,[57841100249,"JB"],]; CONWAYPOLDATA[92269]:=[ ,,,[32706038826,"JB"],]; CONWAYPOLDATA[92297]:=[ ,,,[56387929183,"JB"],]; CONWAYPOLDATA[92311]:=[ ,,,[50914316679,"JB"],]; CONWAYPOLDATA[92317]:=[ ,,,[41113929858,"JB"],]; CONWAYPOLDATA[92333]:=[ ,,,[32544704845,"JB"],]; CONWAYPOLDATA[92347]:=[ ,,,[4336892166,"JB"],]; CONWAYPOLDATA[92353]:=[ ,,,[107821019269,"JB"],]; CONWAYPOLDATA[92357]:=[ ,,,[124300607950,"JB"],]; CONWAYPOLDATA[92363]:=[ ,,,[108705339770,"JB"],]; CONWAYPOLDATA[92369]:=[ ,,,[41939497870,"JB"],]; CONWAYPOLDATA[92377]:=[ ,,,[89666196942,"JB"],]; CONWAYPOLDATA[92381]:=[ ,,,[57208781872,"JB"],]; CONWAYPOLDATA[92383]:=[ ,,,[42672723916,"JB"],]; CONWAYPOLDATA[92387]:=[ ,,,[73297074192,"JB"],]; CONWAYPOLDATA[92399]:=[ ,,,[42603608130,"JB"],]; CONWAYPOLDATA[92401]:=[ ,,,[279934281193,"JB"],]; CONWAYPOLDATA[92413]:=[ ,,,[30373288299,"JB"],]; CONWAYPOLDATA[92419]:=[ ,,,[76870797118,"JB"],]; CONWAYPOLDATA[92431]:=[ ,,,[32630176488,"JB"],]; CONWAYPOLDATA[92459]:=[ ,,,[64873949811,"JB"],]; CONWAYPOLDATA[92461]:=[ ,,,[32734707520,"JB"],]; CONWAYPOLDATA[92467]:=[ ,,,[73060488377,"JB"],]; CONWAYPOLDATA[92479]:=[ ,,,[31456546898,"JB"],]; CONWAYPOLDATA[92489]:=[ ,,,[8553105256,"JB"],]; CONWAYPOLDATA[92503]:=[ ,,,[93282707792,"JB"],]; CONWAYPOLDATA[92507]:=[ ,,,[76601531436,"JB"],]; CONWAYPOLDATA[92551]:=[ ,,,[48593624904,"JB"],]; CONWAYPOLDATA[92557]:=[ ,,,[59438531933,"JB"],]; CONWAYPOLDATA[92567]:=[ ,,,[41015882303,"JB"],]; CONWAYPOLDATA[92569]:=[ ,,,[230702405780,"JB"],]; CONWAYPOLDATA[92581]:=[ ,,,[6739341320,"JB"],]; CONWAYPOLDATA[92593]:=[ ,,,[128600936217,"JB"],]; CONWAYPOLDATA[92623]:=[ ,,,[49238294188,"JB"],]; CONWAYPOLDATA[92627]:=[ ,,,[5250746751,"JB"],]; CONWAYPOLDATA[92639]:=[ ,,,[66584651813,"JB"],]; CONWAYPOLDATA[92641]:=[ ,,,[193220129378,"JB"],]; CONWAYPOLDATA[92647]:=[ ,,,[32758960086,"JB"],]; CONWAYPOLDATA[92657]:=[ ,,,[8505541975,"JB"],]; CONWAYPOLDATA[92669]:=[ ,,,[82883987623,"JB"],]; CONWAYPOLDATA[92671]:=[ ,,,[23797264106,"JB"],]; CONWAYPOLDATA[92681]:=[ ,,,[65129348409,"JB"],]; CONWAYPOLDATA[92683]:=[ ,,,[24530502296,"JB"],]; CONWAYPOLDATA[92693]:=[ ,,,[31070230137,"JB"],]; CONWAYPOLDATA[92699]:=[ ,,,[21979489096,"JB"],]; CONWAYPOLDATA[92707]:=[ ,,,[21923536776,"JB"],]; CONWAYPOLDATA[92717]:=[ ,,,[111011083989,"JB"],]; CONWAYPOLDATA[92723]:=[ ,,,[31694297693,"JB"],]; CONWAYPOLDATA[92737]:=[ ,,,[144335032172,"JB"],]; CONWAYPOLDATA[92753]:=[ ,,,[13953390311,"JB"],]; CONWAYPOLDATA[92761]:=[ ,,,[254811313152,"JB"],]; CONWAYPOLDATA[92767]:=[ ,,,[57875383196,"JB"],]; CONWAYPOLDATA[92779]:=[ ,,,[77214023846,"JB"],]; CONWAYPOLDATA[92789]:=[ ,,,[57849023685,"JB"],]; CONWAYPOLDATA[92791]:=[ ,,,[31795764066,"JB"],]; CONWAYPOLDATA[92801]:=[ ,,,[21856398722,"JB"],]; CONWAYPOLDATA[92809]:=[ ,,,[75448519710,"JB"],]; CONWAYPOLDATA[92821]:=[ ,,,[112003851971,"JB"],]; CONWAYPOLDATA[92831]:=[ ,,,[22055253142,"JB"],]; CONWAYPOLDATA[92849]:=[ ,,,[76387429397,"JB"],]; CONWAYPOLDATA[92857]:=[ ,,,[129335315313,"JB"],]; CONWAYPOLDATA[92861]:=[ ,,,[16929953217,"JB"],]; CONWAYPOLDATA[92863]:=[ ,,,[49051072373,"JB"],]; CONWAYPOLDATA[92867]:=[ ,,,[92100290050,"JB"],]; CONWAYPOLDATA[92893]:=[ ,,,[32253935893,"JB"],]; CONWAYPOLDATA[92899]:=[ ,,,[7995816937,"JB"],]; CONWAYPOLDATA[92921]:=[ ,,,[8633197192,"JB"],]; CONWAYPOLDATA[92927]:=[ ,,,[103624012829,"JB"],]; CONWAYPOLDATA[92941]:=[ ,,,[92173028519,"JB"],]; CONWAYPOLDATA[92951]:=[ ,,,[21661486953,"JB"],]; CONWAYPOLDATA[92957]:=[ ,,,[66475409842,"JB"],]; CONWAYPOLDATA[92959]:=[ ,,,[48806356735,"JB"],]; CONWAYPOLDATA[92987]:=[ ,,,[23022186397,"JB"],]; CONWAYPOLDATA[92993]:=[ ,,,[41525001230,"JB"],]; CONWAYPOLDATA[93001]:=[ ,,,[76738752153,"JB"],]; CONWAYPOLDATA[93047]:=[ ,,,[74120868017,"JB"],]; CONWAYPOLDATA[93053]:=[ ,,,[59809164381,"JB"],]; CONWAYPOLDATA[93059]:=[ ,,,[66244142211,"JB"],]; CONWAYPOLDATA[93077]:=[ ,,,[33706811705,"JB"],]; CONWAYPOLDATA[93083]:=[ ,,,[73815191334,"JB"],]; CONWAYPOLDATA[93089]:=[ ,,,[6264796614,"JB"],]; CONWAYPOLDATA[93097]:=[ ,,,[91746534928,"JB"],]; CONWAYPOLDATA[93103]:=[ ,,,[73704058925,"JB"],]; CONWAYPOLDATA[93113]:=[ ,,,[103010818790,"JB"],]; CONWAYPOLDATA[93131]:=[ ,,,[48087819332,"JB"],]; CONWAYPOLDATA[93133]:=[ ,,,[8027505808,"JB"],]; CONWAYPOLDATA[93139]:=[ ,,,[77014869461,"JB"],]; CONWAYPOLDATA[93151]:=[ ,,,[32930462070,"JB"],]; CONWAYPOLDATA[93169]:=[ ,,,[95168406751,"JB"],]; CONWAYPOLDATA[93179]:=[ ,,,[76848727999,"JB"],]; CONWAYPOLDATA[93187]:=[ ,,,[48474293224,"JB"],]; CONWAYPOLDATA[93199]:=[ ,,,[49186704247,"JB"],]; CONWAYPOLDATA[93229]:=[ ,,,[68588202390,"JB"],]; CONWAYPOLDATA[93239]:=[ ,,,[67041544942,"JB"],]; CONWAYPOLDATA[93241]:=[ ,,,[265982353566,"JB"],]; CONWAYPOLDATA[93251]:=[ ,,,[77982734019,"JB"],]; CONWAYPOLDATA[93253]:=[ ,,,[32594534586,"JB"],]; CONWAYPOLDATA[93257]:=[ ,,,[8621516396,"JB"],]; CONWAYPOLDATA[93263]:=[ ,,,[16062499969,"JB"],]; CONWAYPOLDATA[93281]:=[ ,,,[25246969058,"JB"],]; CONWAYPOLDATA[93283]:=[ ,,,[78216769389,"JB"],]; CONWAYPOLDATA[93287]:=[ ,,,[34809484333,"JB"],]; CONWAYPOLDATA[93307]:=[ ,,,[130543584334,"JB"],]; CONWAYPOLDATA[93319]:=[ ,,,[31587921589,"JB"],]; CONWAYPOLDATA[93323]:=[ ,,,[67472529002,"JB"],]; CONWAYPOLDATA[93329]:=[ ,,,[22891457136,"JB"],]; CONWAYPOLDATA[93337]:=[ ,,,[130675906833,"JB"],]; CONWAYPOLDATA[93371]:=[ ,,,[104219309637,"JB"],]; CONWAYPOLDATA[93377]:=[ ,,,[7255392903,"JB"],]; CONWAYPOLDATA[93383]:=[ ,,,[49335359501,"JB"],]; CONWAYPOLDATA[93407]:=[ ,,,[40767298341,"JB"],]; CONWAYPOLDATA[93419]:=[ ,,,[66032005705,"JB"],]; CONWAYPOLDATA[93427]:=[ ,,,[22324101371,"JB"],]; CONWAYPOLDATA[93463]:=[ ,,,[50384501358,"JB"],]; CONWAYPOLDATA[93479]:=[ ,,,[40973154413,"JB"],]; CONWAYPOLDATA[93481]:=[ ,,,[75777007369,"JB"],]; CONWAYPOLDATA[93487]:=[ ,,,[25497457412,"JB"],]; CONWAYPOLDATA[93491]:=[ ,,,[22317423594,"JB"],]; CONWAYPOLDATA[93493]:=[ ,,,[110894291134,"JB"],]; CONWAYPOLDATA[93497]:=[ ,,,[6905314435,"JB"],]; CONWAYPOLDATA[93503]:=[ ,,,[92688962887,"JB"],]; CONWAYPOLDATA[93523]:=[ ,,,[101081341816,"JB"],]; CONWAYPOLDATA[93529]:=[ ,,,[214638112118,"JB"],]; CONWAYPOLDATA[93553]:=[ ,,,[92961183727,"JB"],]; CONWAYPOLDATA[93557]:=[ ,,,[57387302460,"JB"],]; CONWAYPOLDATA[93559]:=[ ,,,[34446552623,"JB"],]; CONWAYPOLDATA[93563]:=[ ,,,[4637356537,"JB"],]; CONWAYPOLDATA[93581]:=[ ,,,[113317607227,"JB"],]; CONWAYPOLDATA[93601]:=[ ,,,[112735571649,"JB"],]; CONWAYPOLDATA[93607]:=[ ,,,[49052501785,"JB"],]; CONWAYPOLDATA[93629]:=[ ,,,[76324956367,"JB"],]; CONWAYPOLDATA[93637]:=[ ,,,[69362075940,"JB"],]; CONWAYPOLDATA[93683]:=[ ,,,[163667011492,"JB"],]; CONWAYPOLDATA[93701]:=[ ,,,[41232843949,"JB"],]; CONWAYPOLDATA[93703]:=[ ,,,[22074833854,"JB"],]; CONWAYPOLDATA[93719]:=[ ,,,[76632245652,"JB"],]; CONWAYPOLDATA[93739]:=[ ,,,[5656867436,"JB"],]; CONWAYPOLDATA[93761]:=[ ,,,[5257460559,"JB"],]; CONWAYPOLDATA[93763]:=[ ,,,[22415826649,"JB"],]; CONWAYPOLDATA[93787]:=[ ,,,[172647236235,"JB"],]; CONWAYPOLDATA[93809]:=[ ,,,[8799002776,"JB"],]; CONWAYPOLDATA[93811]:=[ ,,,[76192637525,"JB"],]; CONWAYPOLDATA[93827]:=[ ,,,[22667758759,"JB"],]; CONWAYPOLDATA[93851]:=[ ,,,[75447945114,"JB"],]; CONWAYPOLDATA[93871]:=[ ,,,[23175060225,"JB"],]; CONWAYPOLDATA[93887]:=[ ,,,[24508074711,"JB"],]; CONWAYPOLDATA[93889]:=[ ,,,[94701327642,"JB"],]; CONWAYPOLDATA[93893]:=[ ,,,[24714984927,"JB"],]; CONWAYPOLDATA[93901]:=[ ,,,[70055122755,"JB"],]; CONWAYPOLDATA[93911]:=[ ,,,[25838578640,"JB"],]; CONWAYPOLDATA[93913]:=[ ,,,[59340525576,"JB"],]; CONWAYPOLDATA[93923]:=[ ,,,[70017811965,"JB"],]; CONWAYPOLDATA[93937]:=[ ,,,[128073330067,"JB"],]; CONWAYPOLDATA[93941]:=[ ,,,[70131465670,"JB"],]; CONWAYPOLDATA[93949]:=[ ,,,[5662869926,"JB"],]; CONWAYPOLDATA[93967]:=[ ,,,[25719707581,"JB"],]; CONWAYPOLDATA[93971]:=[ ,,,[41169634812,"JB"],]; CONWAYPOLDATA[93979]:=[ ,,,[31572151074,"JB"],]; CONWAYPOLDATA[93983]:=[ ,,,[52897015793,"JB"],]; CONWAYPOLDATA[93997]:=[ ,,,[32990785080,"JB"],]; CONWAYPOLDATA[94007]:=[ ,,,[101883282493,"JB"],]; CONWAYPOLDATA[94009]:=[ ,,,[8834025743,"JB"],]; CONWAYPOLDATA[94033]:=[ ,,,[122032642227,"JB"],]; CONWAYPOLDATA[94049]:=[ ,,,[40848678369,"JB"],]; CONWAYPOLDATA[94057]:=[ ,,,[131422742226,"JB"],]; CONWAYPOLDATA[94063]:=[ ,,,[23508789341,"JB"],]; CONWAYPOLDATA[94079]:=[ ,,,[58548654478,"JB"],]; CONWAYPOLDATA[94099]:=[ ,,,[22693103040,"JB"],]; CONWAYPOLDATA[94109]:=[ ,,,[158220097489,"JB"],]; CONWAYPOLDATA[94111]:=[ ,,,[35047783402,"JB"],]; CONWAYPOLDATA[94117]:=[ ,,,[96691288186,"JB"],]; CONWAYPOLDATA[94121]:=[ ,,,[8857633192,"JB"],]; CONWAYPOLDATA[94151]:=[ ,,,[50829017924,"JB"],]; CONWAYPOLDATA[94153]:=[ ,,,[59411672841,"JB"],]; CONWAYPOLDATA[94169]:=[ ,,,[8866670536,"JB"],]; CONWAYPOLDATA[94201]:=[ ,,,[244646496880,"JB"],]; CONWAYPOLDATA[94207]:=[ ,,,[26486203849,"JB"],]; CONWAYPOLDATA[94219]:=[ ,,,[31918759071,"JB"],]; CONWAYPOLDATA[94229]:=[ ,,,[84933780297,"JB"],]; CONWAYPOLDATA[94253]:=[ ,,,[42164079552,"JB"],]; CONWAYPOLDATA[94261]:=[ ,,,[68439612971,"JB"],]; CONWAYPOLDATA[94273]:=[ ,,,[61926708156,"JB"],]; CONWAYPOLDATA[94291]:=[ ,,,[75950080428,"JB"],]; CONWAYPOLDATA[94307]:=[ ,,,[40435540857,"JB"],]; CONWAYPOLDATA[94309]:=[ ,,,[23482941006,"JB"],]; CONWAYPOLDATA[94321]:=[ ,,,[6060878825,"JB"],]; CONWAYPOLDATA[94327]:=[ ,,,[53214105418,"JB"],]; CONWAYPOLDATA[94331]:=[ ,,,[23178258674,"JB"],]; CONWAYPOLDATA[94343]:=[ ,,,[53065673273,"JB"],]; CONWAYPOLDATA[94349]:=[ ,,,[33365297315,"JB"],]; CONWAYPOLDATA[94351]:=[ ,,,[60070073769,"JB"],]; CONWAYPOLDATA[94379]:=[ ,,,[23676954111,"JB"],]; CONWAYPOLDATA[94397]:=[ ,,,[42747870246,"JB"],]; CONWAYPOLDATA[94399]:=[ ,,,[33998366247,"JB"],]; CONWAYPOLDATA[94421]:=[ ,,,[33083324403,"JB"],]; CONWAYPOLDATA[94427]:=[ ,,,[22316405047,"JB"],]; CONWAYPOLDATA[94433]:=[ ,,,[41091292326,"JB"],]; CONWAYPOLDATA[94439]:=[ ,,,[24883637678,"JB"],]; CONWAYPOLDATA[94441]:=[ ,,,[184195837591,"JB"],]; CONWAYPOLDATA[94447]:=[ ,,,[107041696349,"JB"],]; CONWAYPOLDATA[94463]:=[ ,,,[69391008397,"JB"],]; CONWAYPOLDATA[94477]:=[ ,,,[89075372004,"JB"],]; CONWAYPOLDATA[94483]:=[ ,,,[76040863232,"JB"],]; CONWAYPOLDATA[94513]:=[ ,,,[96372921332,"JB"],]; CONWAYPOLDATA[94529]:=[ ,,,[69193337423,"JB"],]; CONWAYPOLDATA[94531]:=[ ,,,[24849553042,"JB"],]; CONWAYPOLDATA[94541]:=[ ,,,[35012597565,"JB"],]; CONWAYPOLDATA[94543]:=[ ,,,[31959693895,"JB"],]; CONWAYPOLDATA[94547]:=[ ,,,[42883871886,"JB"],]; CONWAYPOLDATA[94559]:=[ ,,,[24162566722,"JB"],]; CONWAYPOLDATA[94561]:=[ ,,,[184232156143,"JB"],]; CONWAYPOLDATA[94573]:=[ ,,,[34706021250,"JB"],]; CONWAYPOLDATA[94583]:=[ ,,,[35783397229,"JB"],]; CONWAYPOLDATA[94597]:=[ ,,,[60070230169,"JB"],]; CONWAYPOLDATA[94603]:=[ ,,,[169576539726,"JB"],]; CONWAYPOLDATA[94613]:=[ ,,,[61464957001,"JB"],]; CONWAYPOLDATA[94621]:=[ ,,,[94060370577,"JB"],]; CONWAYPOLDATA[94649]:=[ ,,,[97137795458,"JB"],]; CONWAYPOLDATA[94651]:=[ ,,,[76849229224,"JB"],]; CONWAYPOLDATA[94687]:=[ ,,,[114953047989,"JB"],]; CONWAYPOLDATA[94693]:=[ ,,,[211438200538,"JB"],]; CONWAYPOLDATA[94709]:=[ ,,,[70569380664,"JB"],]; CONWAYPOLDATA[94723]:=[ ,,,[80751357502,"JB"],]; CONWAYPOLDATA[94727]:=[ ,,,[77625271606,"JB"],]; CONWAYPOLDATA[94747]:=[ ,,,[79448865141,"JB"],]; CONWAYPOLDATA[94771]:=[ ,,,[6464519462,"JB"],]; CONWAYPOLDATA[94777]:=[ ,,,[149510338402,"JB"],]; CONWAYPOLDATA[94781]:=[ ,,,[62073309055,"JB"],]; CONWAYPOLDATA[94789]:=[ ,,,[61186015135,"JB"],]; CONWAYPOLDATA[94793]:=[ ,,,[14856243342,"JB"],]; CONWAYPOLDATA[94811]:=[ ,,,[24161445620,"JB"],]; CONWAYPOLDATA[94819]:=[ ,,,[78749075882,"JB"],]; CONWAYPOLDATA[94823]:=[ ,,,[35965226029,"JB"],]; CONWAYPOLDATA[94837]:=[ ,,,[59245717109,"JB"],]; CONWAYPOLDATA[94841]:=[ ,,,[43564833989,"JB"],]; CONWAYPOLDATA[94847]:=[ ,,,[34542708323,"JB"],]; CONWAYPOLDATA[94849]:=[ ,,,[60092911843,"JB"],]; CONWAYPOLDATA[94873]:=[ ,,,[96058153521,"JB"],]; CONWAYPOLDATA[94889]:=[ ,,,[78020108028,"JB"],]; CONWAYPOLDATA[94903]:=[ ,,,[51935287141,"JB"],]; CONWAYPOLDATA[94907]:=[ ,,,[7893605006,"JB"],]; CONWAYPOLDATA[94933]:=[ ,,,[81109805872,"JB"],]; CONWAYPOLDATA[94949]:=[ ,,,[44967086810,"JB"],]; CONWAYPOLDATA[94951]:=[ ,,,[26950037287,"JB"],]; CONWAYPOLDATA[94961]:=[ ,,,[43041643019,"JB"],]; CONWAYPOLDATA[94993]:=[ ,,,[61066250060,"JB"],]; CONWAYPOLDATA[94999]:=[ ,,,[33532557025,"JB"],]; CONWAYPOLDATA[95003]:=[ ,,,[8451751891,"JB"],]; CONWAYPOLDATA[95009]:=[ ,,,[9025569976,"JB"],]; CONWAYPOLDATA[95021]:=[ ,,,[35995190075,"JB"],]; CONWAYPOLDATA[95027]:=[ ,,,[42682517376,"JB"],]; CONWAYPOLDATA[95063]:=[ ,,,[35304496945,"JB"],]; CONWAYPOLDATA[95071]:=[ ,,,[35214108261,"JB"],]; CONWAYPOLDATA[95083]:=[ ,,,[78581345352,"JB"],]; CONWAYPOLDATA[95087]:=[ ,,,[60694222279,"JB"],]; CONWAYPOLDATA[95089]:=[ ,,,[259139870928,"JB"],]; CONWAYPOLDATA[95093]:=[ ,,,[88908721840,"JB"],]; CONWAYPOLDATA[95101]:=[ ,,,[33316638231,"JB"],]; CONWAYPOLDATA[95107]:=[ ,,,[23712267459,"JB"],]; CONWAYPOLDATA[95111]:=[ ,,,[59740931109,"JB"],]; CONWAYPOLDATA[95131]:=[ ,,,[61054885545,"JB"],]; CONWAYPOLDATA[95143]:=[ ,,,[45260571676,"JB"],]; CONWAYPOLDATA[95153]:=[ ,,,[7064444182,"JB"],]; CONWAYPOLDATA[95177]:=[ ,,,[114429689094,"JB"],]; CONWAYPOLDATA[95189]:=[ ,,,[16981051279,"JB"],]; CONWAYPOLDATA[95191]:=[ ,,,[45182027399,"JB"],]; CONWAYPOLDATA[95203]:=[ ,,,[68041108087,"JB"],]; CONWAYPOLDATA[95213]:=[ ,,,[62746795198,"JB"],]; CONWAYPOLDATA[95219]:=[ ,,,[22873889058,"JB"],]; CONWAYPOLDATA[95231]:=[ ,,,[51201232854,"JB"],]; CONWAYPOLDATA[95233]:=[ ,,,[97207941959,"JB"],]; CONWAYPOLDATA[95239]:=[ ,,,[104513469066,"JB"],]; CONWAYPOLDATA[95257]:=[ ,,,[61666714609,"JB"],]; CONWAYPOLDATA[95261]:=[ ,,,[42281213808,"JB"],]; CONWAYPOLDATA[95267]:=[ ,,,[68195834015,"JB"],]; CONWAYPOLDATA[95273]:=[ ,,,[116876629118,"JB"],]; CONWAYPOLDATA[95279]:=[ ,,,[25860149792,"JB"],]; CONWAYPOLDATA[95287]:=[ ,,,[62669497607,"JB"],]; CONWAYPOLDATA[95311]:=[ ,,,[61155921909,"JB"],]; CONWAYPOLDATA[95317]:=[ ,,,[77319530016,"JB"],]; CONWAYPOLDATA[95327]:=[ ,,,[71379999662,"JB"],]; CONWAYPOLDATA[95339]:=[ ,,,[43966342564,"JB"],]; CONWAYPOLDATA[95369]:=[ ,,,[70979713419,"JB"],]; CONWAYPOLDATA[95383]:=[ ,,,[52467326813,"JB"],]; CONWAYPOLDATA[95393]:=[ ,,,[107184910305,"JB"],]; CONWAYPOLDATA[95401]:=[ ,,,[241293074658,"JB"],]; CONWAYPOLDATA[95413]:=[ ,,,[33856253509,"JB"],]; CONWAYPOLDATA[95419]:=[ ,,,[72658992190,"JB"],]; CONWAYPOLDATA[95429]:=[ ,,,[16292688601,"JB"],]; CONWAYPOLDATA[95441]:=[ ,,,[26981838790,"JB"],]; CONWAYPOLDATA[95443]:=[ ,,,[51681907288,"JB"],]; CONWAYPOLDATA[95461]:=[ ,,,[62735632748,"JB"],]; CONWAYPOLDATA[95467]:=[ ,,,[8583819843,"JB"],]; CONWAYPOLDATA[95471]:=[ ,,,[43959717464,"JB"],]; CONWAYPOLDATA[95479]:=[ ,,,[89008292708,"JB"],]; CONWAYPOLDATA[95483]:=[ ,,,[26517538762,"JB"],]; CONWAYPOLDATA[95507]:=[ ,,,[100120561144,"JB"],]; CONWAYPOLDATA[95527]:=[ ,,,[35226918631,"JB"],]; CONWAYPOLDATA[95531]:=[ ,,,[80333928522,"JB"],]; CONWAYPOLDATA[95539]:=[ ,,,[33858639447,"JB"],]; CONWAYPOLDATA[95549]:=[ ,,,[82165833768,"JB"],]; CONWAYPOLDATA[95561]:=[ ,,,[25804623516,"JB"],]; CONWAYPOLDATA[95569]:=[ ,,,[118445160406,"JB"],]; CONWAYPOLDATA[95581]:=[ ,,,[34044231744,"JB"],]; CONWAYPOLDATA[95597]:=[ ,,,[16522698691,"JB"],]; CONWAYPOLDATA[95603]:=[ ,,,[41704227474,"JB"],]; CONWAYPOLDATA[95617]:=[ ,,,[98525191060,"JB"],]; CONWAYPOLDATA[95621]:=[ ,,,[136583410846,"JB"],]; CONWAYPOLDATA[95629]:=[ ,,,[96341722939,"JB"],]; CONWAYPOLDATA[95633]:=[ ,,,[25481986651,"JB"],]; CONWAYPOLDATA[95651]:=[ ,,,[26133001014,"JB"],]; CONWAYPOLDATA[95701]:=[ ,,,[99074938757,"JB"],]; CONWAYPOLDATA[95707]:=[ ,,,[70282913987,"JB"],]; CONWAYPOLDATA[95713]:=[ ,,,[62617837430,"JB"],]; CONWAYPOLDATA[95717]:=[ ,,,[26080872445,"JB"],]; CONWAYPOLDATA[95723]:=[ ,,,[24731855789,"JB"],]; CONWAYPOLDATA[95731]:=[ ,,,[61637840317,"JB"],]; CONWAYPOLDATA[95737]:=[ ,,,[62601371198,"JB"],]; CONWAYPOLDATA[95747]:=[ ,,,[7119363937,"JB"],]; CONWAYPOLDATA[95773]:=[ ,,,[81917903189,"JB"],]; CONWAYPOLDATA[95783]:=[ ,,,[36697149229,"JB"],]; CONWAYPOLDATA[95789]:=[ ,,,[62160259983,"JB"],]; CONWAYPOLDATA[95791]:=[ ,,,[35589613397,"JB"],]; CONWAYPOLDATA[95801]:=[ ,,,[42432178923,"JB"],]; CONWAYPOLDATA[95803]:=[ ,,,[106303583621,"JB"],]; CONWAYPOLDATA[95813]:=[ ,,,[115775255300,"JB"],]; CONWAYPOLDATA[95819]:=[ ,,,[41739139678,"JB"],]; CONWAYPOLDATA[95857]:=[ ,,,[61478749673,"JB"],]; CONWAYPOLDATA[95869]:=[ ,,,[71064430160,"JB"],]; CONWAYPOLDATA[95873]:=[ ,,,[5856402208,"JB"],]; CONWAYPOLDATA[95881]:=[ ,,,[154853184349,"JB"],]; CONWAYPOLDATA[95891]:=[ ,,,[26086667097,"JB"],]; CONWAYPOLDATA[95911]:=[ ,,,[25853865074,"JB"],]; CONWAYPOLDATA[95917]:=[ ,,,[34805114041,"JB"],]; CONWAYPOLDATA[95923]:=[ ,,,[23394660473,"JB"],]; CONWAYPOLDATA[95929]:=[ ,,,[4634521874,"JB"],]; CONWAYPOLDATA[95947]:=[ ,,,[27383465696,"JB"],]; CONWAYPOLDATA[95957]:=[ ,,,[54155539963,"JB"],]; CONWAYPOLDATA[95959]:=[ ,,,[32951552931,"JB"],]; CONWAYPOLDATA[95971]:=[ ,,,[60365087206,"JB"],]; CONWAYPOLDATA[95987]:=[ ,,,[127980139011,"JB"],]; CONWAYPOLDATA[95989]:=[ ,,,[80331178337,"JB"],]; CONWAYPOLDATA[96001]:=[ ,,,[163951179814,"JB"],]; CONWAYPOLDATA[96013]:=[ ,,,[91923902345,"JB"],]; CONWAYPOLDATA[96017]:=[ ,,,[15721919600,"JB"],]; CONWAYPOLDATA[96043]:=[ ,,,[71763521688,"JB"],]; CONWAYPOLDATA[96053]:=[ ,,,[64328903321,"JB"],]; CONWAYPOLDATA[96059]:=[ ,,,[44347366414,"JB"],]; CONWAYPOLDATA[96079]:=[ ,,,[35515506274,"JB"],]; CONWAYPOLDATA[96097]:=[ ,,,[63277952565,"JB"],]; CONWAYPOLDATA[96137]:=[ ,,,[72197925633,"JB"],]; CONWAYPOLDATA[96149]:=[ ,,,[62088120603,"JB"],]; CONWAYPOLDATA[96157]:=[ ,,,[17479419465,"JB"],]; CONWAYPOLDATA[96167]:=[ ,,,[54626798852,"JB"],]; CONWAYPOLDATA[96179]:=[ ,,,[35377425393,"JB"],]; CONWAYPOLDATA[96181]:=[ ,,,[64755108609,"JB"],]; CONWAYPOLDATA[96199]:=[ ,,,[70817663445,"JB"],]; CONWAYPOLDATA[96211]:=[ ,,,[61296028102,"JB"],]; CONWAYPOLDATA[96221]:=[ ,,,[16537791935,"JB"],]; CONWAYPOLDATA[96223]:=[ ,,,[37035078029,"JB"],]; CONWAYPOLDATA[96233]:=[ ,,,[111006401464,"JB"],]; CONWAYPOLDATA[96259]:=[ ,,,[83194054709,"JB"],]; CONWAYPOLDATA[96263]:=[ ,,,[90243674615,"JB"],]; CONWAYPOLDATA[96269]:=[ ,,,[33187486255,"JB"],]; CONWAYPOLDATA[96281]:=[ ,,,[9268875592,"JB"],]; CONWAYPOLDATA[96289]:=[ ,,,[135154417948,"JB"],]; CONWAYPOLDATA[96293]:=[ ,,,[62548081082,"JB"],]; CONWAYPOLDATA[96323]:=[ ,,,[191226969566,"JB"],]; CONWAYPOLDATA[96329]:=[ ,,,[42053099256,"JB"],]; CONWAYPOLDATA[96331]:=[ ,,,[6466025723,"JB"],]; CONWAYPOLDATA[96337]:=[ ,,,[99997613331,"JB"],]; CONWAYPOLDATA[96353]:=[ ,,,[118321869415,"JB"],]; CONWAYPOLDATA[96377]:=[ ,,,[73994405523,"JB"],]; CONWAYPOLDATA[96401]:=[ ,,,[43693946055,"JB"],]; CONWAYPOLDATA[96419]:=[ ,,,[4995854072,"JB"],]; CONWAYPOLDATA[96431]:=[ ,,,[71679862379,"JB"],]; CONWAYPOLDATA[96443]:=[ ,,,[9077118719,"JB"],]; CONWAYPOLDATA[96451]:=[ ,,,[25894971580,"JB"],]; CONWAYPOLDATA[96457]:=[ ,,,[64015617195,"JB"],]; CONWAYPOLDATA[96461]:=[ ,,,[61711310596,"JB"],]; CONWAYPOLDATA[96469]:=[ ,,,[27328606551,"JB"],]; CONWAYPOLDATA[96479]:=[ ,,,[24114250708,"JB"],]; CONWAYPOLDATA[96487]:=[ ,,,[46548319900,"JB"],]; CONWAYPOLDATA[96493]:=[ ,,,[71198517971,"JB"],]; CONWAYPOLDATA[96497]:=[ ,,,[6065415435,"JB"],]; CONWAYPOLDATA[96517]:=[ ,,,[101714054384,"JB"],]; CONWAYPOLDATA[96527]:=[ ,,,[108999929364,"JB"],]; CONWAYPOLDATA[96553]:=[ ,,,[63734055987,"JB"],]; CONWAYPOLDATA[96557]:=[ ,,,[34506864763,"JB"],]; CONWAYPOLDATA[96581]:=[ ,,,[117692930535,"JB"],]; CONWAYPOLDATA[96587]:=[ ,,,[35422219795,"JB"],]; CONWAYPOLDATA[96589]:=[ ,,,[25212916443,"JB"],]; CONWAYPOLDATA[96601]:=[ ,,,[192762368860,"JB"],]; CONWAYPOLDATA[96643]:=[ ,,,[82443147369,"JB"],]; CONWAYPOLDATA[96661]:=[ ,,,[15133536150,"JB"],]; CONWAYPOLDATA[96667]:=[ ,,,[79976572449,"JB"],]; CONWAYPOLDATA[96671]:=[ ,,,[55667318660,"JB"],]; CONWAYPOLDATA[96697]:=[ ,,,[116933071288,"JB"],]; CONWAYPOLDATA[96703]:=[ ,,,[51579639549,"JB"],]; CONWAYPOLDATA[96731]:=[ ,,,[71427524636,"JB"],]; CONWAYPOLDATA[96737]:=[ ,,,[5066987326,"JB"],]; CONWAYPOLDATA[96739]:=[ ,,,[63418799276,"JB"],]; CONWAYPOLDATA[96749]:=[ ,,,[70283794797,"JB"],]; CONWAYPOLDATA[96757]:=[ ,,,[73251531724,"JB"],]; CONWAYPOLDATA[96763]:=[ ,,,[25024072961,"JB"],]; CONWAYPOLDATA[96769]:=[ ,,,[251038623667,"JB"],]; CONWAYPOLDATA[96779]:=[ ,,,[37085035349,"JB"],]; CONWAYPOLDATA[96787]:=[ ,,,[27145753105,"JB"],]; CONWAYPOLDATA[96797]:=[ ,,,[121367079309,"JB"],]; CONWAYPOLDATA[96799]:=[ ,,,[25289125952,"JB"],]; CONWAYPOLDATA[96821]:=[ ,,,[80191315505,"JB"],]; CONWAYPOLDATA[96823]:=[ ,,,[25342839317,"JB"],]; CONWAYPOLDATA[96827]:=[ ,,,[27243341549,"JB"],]; CONWAYPOLDATA[96847]:=[ ,,,[64336140032,"JB"],]; CONWAYPOLDATA[96851]:=[ ,,,[24770224358,"JB"],]; CONWAYPOLDATA[96857]:=[ ,,,[25894137811,"JB"],]; CONWAYPOLDATA[96893]:=[ ,,,[65480289402,"JB"],]; CONWAYPOLDATA[96907]:=[ ,,,[15695445350,"JB"],]; CONWAYPOLDATA[96911]:=[ ,,,[23911044863,"JB"],]; CONWAYPOLDATA[96931]:=[ ,,,[81008241563,"JB"],]; CONWAYPOLDATA[96953]:=[ ,,,[9171947709,"JB"],]; CONWAYPOLDATA[96959]:=[ ,,,[26682147217,"JB"],]; CONWAYPOLDATA[96973]:=[ ,,,[61263662482,"JB"],]; CONWAYPOLDATA[96979]:=[ ,,,[54525957858,"JB"],]; CONWAYPOLDATA[96989]:=[ ,,,[138620267395,"JB"],]; CONWAYPOLDATA[96997]:=[ ,,,[33158036464,"JB"],]; CONWAYPOLDATA[97001]:=[ ,,,[26160393695,"JB"],]; CONWAYPOLDATA[97003]:=[ ,,,[108983258519,"JB"],]; CONWAYPOLDATA[97007]:=[ ,,,[54197325870,"JB"],]; CONWAYPOLDATA[97021]:=[ ,,,[99790658489,"JB"],]; CONWAYPOLDATA[97039]:=[ ,,,[36909948121,"JB"],]; CONWAYPOLDATA[97073]:=[ ,,,[128805775411,"JB"],]; CONWAYPOLDATA[97081]:=[ ,,,[244439279097,"JB"],]; CONWAYPOLDATA[97103]:=[ ,,,[82128260860,"JB"],]; CONWAYPOLDATA[97117]:=[ ,,,[71836279498,"JB"],]; CONWAYPOLDATA[97127]:=[ ,,,[37734228013,"JB"],]; CONWAYPOLDATA[97151]:=[ ,,,[74784216736,"JB"],]; CONWAYPOLDATA[97157]:=[ ,,,[55599259136,"JB"],]; CONWAYPOLDATA[97159]:=[ ,,,[34092898785,"JB"],]; CONWAYPOLDATA[97169]:=[ ,,,[9440648536,"JB"],]; CONWAYPOLDATA[97171]:=[ ,,,[81896301836,"JB"],]; CONWAYPOLDATA[97177]:=[ ,,,[147993477084,"JB"],]; CONWAYPOLDATA[97187]:=[ ,,,[17909328801,"JB"],]; CONWAYPOLDATA[97213]:=[ ,,,[18369660124,"JB"],]; CONWAYPOLDATA[97231]:=[ ,,,[24429191525,"JB"],]; CONWAYPOLDATA[97241]:=[ ,,,[9454645192,"JB"],]; CONWAYPOLDATA[97259]:=[ ,,,[17543967462,"JB"],]; CONWAYPOLDATA[97283]:=[ ,,,[71709828660,"JB"],]; CONWAYPOLDATA[97301]:=[ ,,,[24422161798,"JB"],]; CONWAYPOLDATA[97303]:=[ ,,,[25781013671,"JB"],]; CONWAYPOLDATA[97327]:=[ ,,,[27017293916,"JB"],]; CONWAYPOLDATA[97367]:=[ ,,,[64828409110,"JB"],]; CONWAYPOLDATA[97369]:=[ ,,,[141231008175,"JB"],]; CONWAYPOLDATA[97373]:=[ ,,,[17891315022,"JB"],]; CONWAYPOLDATA[97379]:=[ ,,,[72835986358,"JB"],]; CONWAYPOLDATA[97381]:=[ ,,,[64080690623,"JB"],]; CONWAYPOLDATA[97387]:=[ ,,,[101191910092,"JB"],]; CONWAYPOLDATA[97397]:=[ ,,,[35673112207,"JB"],]; CONWAYPOLDATA[97423]:=[ ,,,[53044387928,"JB"],]; CONWAYPOLDATA[97429]:=[ ,,,[66446480577,"JB"],]; CONWAYPOLDATA[97441]:=[ ,,,[281825973430,"JB"],]; CONWAYPOLDATA[97453]:=[ ,,,[63675302937,"JB"],]; CONWAYPOLDATA[97459]:=[ ,,,[75205601778,"JB"],]; CONWAYPOLDATA[97463]:=[ ,,,[82226121900,"JB"],]; CONWAYPOLDATA[97499]:=[ ,,,[44055800643,"JB"],]; CONWAYPOLDATA[97501]:=[ ,,,[45843702694,"JB"],]; CONWAYPOLDATA[97511]:=[ ,,,[103879540928,"JB"],]; CONWAYPOLDATA[97523]:=[ ,,,[85595937102,"JB"],]; CONWAYPOLDATA[97547]:=[ ,,,[74367881862,"JB"],]; CONWAYPOLDATA[97549]:=[ ,,,[9150193751,"JB"],]; CONWAYPOLDATA[97553]:=[ ,,,[119507692865,"JB"],]; CONWAYPOLDATA[97561]:=[ ,,,[122189298851,"JB"],]; CONWAYPOLDATA[97571]:=[ ,,,[24341817940,"JB"],]; CONWAYPOLDATA[97577]:=[ ,,,[65894235988,"JB"],]; CONWAYPOLDATA[97579]:=[ ,,,[63357947123,"JB"],]; CONWAYPOLDATA[97583]:=[ ,,,[71831529386,"JB"],]; CONWAYPOLDATA[97607]:=[ ,,,[38108115373,"JB"],]; CONWAYPOLDATA[97609]:=[ ,,,[157665767928,"JB"],]; CONWAYPOLDATA[97613]:=[ ,,,[38016749434,"JB"],]; CONWAYPOLDATA[97649]:=[ ,,,[76239456753,"JB"],]; CONWAYPOLDATA[97651]:=[ ,,,[84502585805,"JB"],]; CONWAYPOLDATA[97673]:=[ ,,,[7131789444,"JB"],]; CONWAYPOLDATA[97687]:=[ ,,,[34781260981,"JB"],]; CONWAYPOLDATA[97711]:=[ ,,,[94593921400,"JB"],]; CONWAYPOLDATA[97729]:=[ ,,,[215175314408,"JB"],]; CONWAYPOLDATA[97771]:=[ ,,,[37484717006,"JB"],]; CONWAYPOLDATA[97777]:=[ ,,,[85522413053,"JB"],]; CONWAYPOLDATA[97787]:=[ ,,,[82907045573,"JB"],]; CONWAYPOLDATA[97789]:=[ ,,,[37344641212,"JB"],]; CONWAYPOLDATA[97813]:=[ ,,,[63653570386,"JB"],]; CONWAYPOLDATA[97829]:=[ ,,,[66287169480,"JB"],]; CONWAYPOLDATA[97841]:=[ ,,,[62568830301,"JB"],]; CONWAYPOLDATA[97843]:=[ ,,,[81949089553,"JB"],]; CONWAYPOLDATA[97847]:=[ ,,,[142362003420,"JB"],]; CONWAYPOLDATA[97849]:=[ ,,,[44600944099,"JB"],]; CONWAYPOLDATA[97859]:=[ ,,,[25950641058,"JB"],]; CONWAYPOLDATA[97861]:=[ ,,,[104806390894,"JB"],]; CONWAYPOLDATA[97871]:=[ ,,,[24325249831,"JB"],]; CONWAYPOLDATA[97879]:=[ ,,,[27102401469,"JB"],]; CONWAYPOLDATA[97883]:=[ ,,,[83626341052,"JB"],]; CONWAYPOLDATA[97919]:=[ ,,,[46489493248,"JB"],]; CONWAYPOLDATA[97927]:=[ ,,,[64327462887,"JB"],]; CONWAYPOLDATA[97931]:=[ ,,,[76107860100,"JB"],]; CONWAYPOLDATA[97943]:=[ ,,,[45509117012,"JB"],]; CONWAYPOLDATA[97961]:=[ ,,,[43398780184,"JB"],]; CONWAYPOLDATA[97967]:=[ ,,,[64600811343,"JB"],]; CONWAYPOLDATA[97973]:=[ ,,,[47135985978,"JB"],]; CONWAYPOLDATA[97987]:=[ ,,,[83253478708,"JB"],]; CONWAYPOLDATA[98009]:=[ ,,,[84759849356,"JB"],]; CONWAYPOLDATA[98011]:=[ ,,,[5184781910,"JB"],]; CONWAYPOLDATA[98017]:=[ ,,,[83414231313,"JB"],]; CONWAYPOLDATA[98041]:=[ ,,,[325705437548,"JB"],]; CONWAYPOLDATA[98047]:=[ ,,,[38452464653,"JB"],]; CONWAYPOLDATA[98057]:=[ ,,,[6564327811,"JB"],]; CONWAYPOLDATA[98081]:=[ ,,,[6390369480,"JB"],]; CONWAYPOLDATA[98101]:=[ ,,,[93849302662,"JB"],]; CONWAYPOLDATA[98123]:=[ ,,,[45923526462,"JB"],]; CONWAYPOLDATA[98129]:=[ ,,,[37738941468,"JB"],]; CONWAYPOLDATA[98143]:=[ ,,,[27052921669,"JB"],]; CONWAYPOLDATA[98179]:=[ ,,,[83900533495,"JB"],]; CONWAYPOLDATA[98207]:=[ ,,,[26656620636,"JB"],]; CONWAYPOLDATA[98213]:=[ ,,,[93537177285,"JB"],]; CONWAYPOLDATA[98221]:=[ ,,,[64213157404,"JB"],]; CONWAYPOLDATA[98227]:=[ ,,,[54159224539,"JB"],]; CONWAYPOLDATA[98251]:=[ ,,,[73328847844,"JB"],]; CONWAYPOLDATA[98257]:=[ ,,,[125118105642,"JB"],]; CONWAYPOLDATA[98269]:=[ ,,,[33833230550,"JB"],]; CONWAYPOLDATA[98297]:=[ ,,,[15637578248,"JB"],]; CONWAYPOLDATA[98299]:=[ ,,,[15320292348,"JB"],]; CONWAYPOLDATA[98317]:=[ ,,,[62894073125,"JB"],]; CONWAYPOLDATA[98321]:=[ ,,,[9665839192,"JB"],]; CONWAYPOLDATA[98323]:=[ ,,,[28915024489,"JB"],]; CONWAYPOLDATA[98327]:=[ ,,,[35354751106,"JB"],]; CONWAYPOLDATA[98347]:=[ ,,,[101584091507,"JB"],]; CONWAYPOLDATA[98369]:=[ ,,,[73211915205,"JB"],]; CONWAYPOLDATA[98377]:=[ ,,,[85470724621,"JB"],]; CONWAYPOLDATA[98387]:=[ ,,,[86749687255,"JB"],]; CONWAYPOLDATA[98389]:=[ ,,,[63982366702,"JB"],]; CONWAYPOLDATA[98407]:=[ ,,,[76191226128,"JB"],]; CONWAYPOLDATA[98411]:=[ ,,,[63315669182,"JB"],]; CONWAYPOLDATA[98419]:=[ ,,,[76535240095,"JB"],]; CONWAYPOLDATA[98429]:=[ ,,,[121841420371,"JB"],]; CONWAYPOLDATA[98443]:=[ ,,,[85900082043,"JB"],]; CONWAYPOLDATA[98453]:=[ ,,,[46207537210,"JB"],]; CONWAYPOLDATA[98459]:=[ ,,,[86314574647,"JB"],]; CONWAYPOLDATA[98467]:=[ ,,,[54396420214,"JB"],]; CONWAYPOLDATA[98473]:=[ ,,,[63124048727,"JB"],]; CONWAYPOLDATA[98479]:=[ ,,,[28875815425,"JB"],]; CONWAYPOLDATA[98491]:=[ ,,,[64754188340,"JB"],]; CONWAYPOLDATA[98507]:=[ ,,,[115350022383,"JB"],]; CONWAYPOLDATA[98519]:=[ ,,,[73297150817,"JB"],]; CONWAYPOLDATA[98533]:=[ ,,,[183366661413,"JB"],]; CONWAYPOLDATA[98543]:=[ ,,,[153956685195,"JB"],]; CONWAYPOLDATA[98561]:=[ ,,,[27512218982,"JB"],]; CONWAYPOLDATA[98563]:=[ ,,,[28108886283,"JB"],]; CONWAYPOLDATA[98573]:=[ ,,,[97078830468,"JB"],]; CONWAYPOLDATA[98597]:=[ ,,,[184630178680,"JB"],]; CONWAYPOLDATA[98621]:=[ ,,,[48629620623,"JB"],]; CONWAYPOLDATA[98627]:=[ ,,,[5110949769,"JB"],]; CONWAYPOLDATA[98639]:=[ ,,,[28162420897,"JB"],]; CONWAYPOLDATA[98641]:=[ ,,,[202315354324,"JB"],]; CONWAYPOLDATA[98663]:=[ ,,,[36863950010,"JB"],]; CONWAYPOLDATA[98669]:=[ ,,,[122716608682,"JB"],]; CONWAYPOLDATA[98689]:=[ ,,,[145357153016,"JB"],]; CONWAYPOLDATA[98711]:=[ ,,,[66685795439,"JB"],]; CONWAYPOLDATA[98713]:=[ ,,,[67224145283,"JB"],]; CONWAYPOLDATA[98717]:=[ ,,,[64810178427,"JB"],]; CONWAYPOLDATA[98729]:=[ ,,,[27968839684,"JB"],]; CONWAYPOLDATA[98731]:=[ ,,,[29015461206,"JB"],]; CONWAYPOLDATA[98737]:=[ ,,,[64365761672,"JB"],]; CONWAYPOLDATA[98773]:=[ ,,,[66160723500,"JB"],]; CONWAYPOLDATA[98779]:=[ ,,,[35151099826,"JB"],]; CONWAYPOLDATA[98801]:=[ ,,,[46678433652,"JB"],]; CONWAYPOLDATA[98807]:=[ ,,,[87652480161,"JB"],]; CONWAYPOLDATA[98809]:=[ ,,,[318816427754,"JB"],]; CONWAYPOLDATA[98837]:=[ ,,,[123601302211,"JB"],]; CONWAYPOLDATA[98849]:=[ ,,,[9769938616,"JB"],]; CONWAYPOLDATA[98867]:=[ ,,,[47948616529,"JB"],]; CONWAYPOLDATA[98869]:=[ ,,,[67769756052,"JB"],]; CONWAYPOLDATA[98873]:=[ ,,,[8599380305,"JB"],]; CONWAYPOLDATA[98887]:=[ ,,,[127121216243,"JB"],]; CONWAYPOLDATA[98893]:=[ ,,,[97033317137,"JB"],]; CONWAYPOLDATA[98897]:=[ ,,,[67010530366,"JB"],]; CONWAYPOLDATA[98899]:=[ ,,,[27341123047,"JB"],]; CONWAYPOLDATA[98909]:=[ ,,,[38086295178,"JB"],]; CONWAYPOLDATA[98911]:=[ ,,,[25259297726,"JB"],]; CONWAYPOLDATA[98927]:=[ ,,,[39145809613,"JB"],]; CONWAYPOLDATA[98929]:=[ ,,,[87726378980,"JB"],]; CONWAYPOLDATA[98939]:=[ ,,,[48007379460,"JB"],]; CONWAYPOLDATA[98947]:=[ ,,,[74227664675,"JB"],]; CONWAYPOLDATA[98953]:=[ ,,,[8141061226,"JB"],]; CONWAYPOLDATA[98963]:=[ ,,,[83733287043,"JB"],]; CONWAYPOLDATA[98981]:=[ ,,,[48985795884,"JB"],]; CONWAYPOLDATA[98993]:=[ ,,,[8247601798,"JB"],]; CONWAYPOLDATA[98999]:=[ ,,,[26208896280,"JB"],]; CONWAYPOLDATA[99013]:=[ ,,,[64076064930,"JB"],]; CONWAYPOLDATA[99017]:=[ ,,,[67393247594,"JB"],]; CONWAYPOLDATA[99023]:=[ ,,,[57279359240,"JB"],]; CONWAYPOLDATA[99041]:=[ ,,,[9448313324,"JB"],]; CONWAYPOLDATA[99053]:=[ ,,,[65749895607,"JB"],]; CONWAYPOLDATA[99079]:=[ ,,,[25936603386,"JB"],]; CONWAYPOLDATA[99083]:=[ ,,,[77563163232,"JB"],]; CONWAYPOLDATA[99089]:=[ ,,,[85482990324,"JB"],]; CONWAYPOLDATA[99103]:=[ ,,,[49106626636,"JB"],]; CONWAYPOLDATA[99109]:=[ ,,,[68757760737,"JB"],]; CONWAYPOLDATA[99119]:=[ ,,,[64413374232,"JB"],]; CONWAYPOLDATA[99131]:=[ ,,,[47079790181,"JB"],]; CONWAYPOLDATA[99133]:=[ ,,,[68318101750,"JB"],]; CONWAYPOLDATA[99137]:=[ ,,,[263782738233,"JB"],]; CONWAYPOLDATA[99139]:=[ ,,,[64031104210,"JB"],]; CONWAYPOLDATA[99149]:=[ ,,,[48270690652,"JB"],]; CONWAYPOLDATA[99173]:=[ ,,,[65172826201,"JB"],]; CONWAYPOLDATA[99181]:=[ ,,,[126287861574,"JB"],]; CONWAYPOLDATA[99191]:=[ ,,,[75416405176,"JB"],]; CONWAYPOLDATA[99223]:=[ ,,,[49225621756,"JB"],]; CONWAYPOLDATA[99233]:=[ ,,,[78319149088,"JB"],]; CONWAYPOLDATA[99241]:=[ ,,,[222485718404,"JB"],]; CONWAYPOLDATA[99251]:=[ ,,,[25684372292,"JB"],]; CONWAYPOLDATA[99257]:=[ ,,,[8712382435,"JB"],]; CONWAYPOLDATA[99259]:=[ ,,,[88670446918,"JB"],]; CONWAYPOLDATA[99277]:=[ ,,,[96163871836,"JB"],]; CONWAYPOLDATA[99289]:=[ ,,,[221907042755,"JB"],]; CONWAYPOLDATA[99317]:=[ ,,,[66303234666,"JB"],]; CONWAYPOLDATA[99347]:=[ ,,,[26383880833,"JB"],]; CONWAYPOLDATA[99349]:=[ ,,,[35174612810,"JB"],]; CONWAYPOLDATA[99367]:=[ ,,,[67925095129,"JB"],]; CONWAYPOLDATA[99371]:=[ ,,,[38574431008,"JB"],]; CONWAYPOLDATA[99377]:=[ ,,,[25659240780,"JB"],]; CONWAYPOLDATA[99391]:=[ ,,,[39124173855,"JB"],]; CONWAYPOLDATA[99397]:=[ ,,,[104768910867,"JB"],]; CONWAYPOLDATA[99401]:=[ ,,,[9879365992,"JB"],]; CONWAYPOLDATA[99409]:=[ ,,,[25238453976,"JB"],]; CONWAYPOLDATA[99431]:=[ ,,,[39281906890,"JB"],]; CONWAYPOLDATA[99439]:=[ ,,,[38735368624,"JB"],]; CONWAYPOLDATA[99469]:=[ ,,,[84751168886,"JB"],]; CONWAYPOLDATA[99487]:=[ ,,,[37804761542,"JB"],]; CONWAYPOLDATA[99497]:=[ ,,,[5996982684,"JB"],]; CONWAYPOLDATA[99523]:=[ ,,,[5910272883,"JB"],]; CONWAYPOLDATA[99527]:=[ ,,,[64498671409,"JB"],]; CONWAYPOLDATA[99529]:=[ ,,,[7176239965,"JB"],]; CONWAYPOLDATA[99551]:=[ ,,,[38955600470,"JB"],]; CONWAYPOLDATA[99559]:=[ ,,,[69144721093,"JB"],]; CONWAYPOLDATA[99563]:=[ ,,,[74827269593,"JB"],]; CONWAYPOLDATA[99571]:=[ ,,,[78068941265,"JB"],]; CONWAYPOLDATA[99577]:=[ ,,,[155038700426,"JB"],]; CONWAYPOLDATA[99581]:=[ ,,,[47244412994,"JB"],]; CONWAYPOLDATA[99607]:=[ ,,,[25106641602,"JB"],]; CONWAYPOLDATA[99611]:=[ ,,,[6580103440,"JB"],]; CONWAYPOLDATA[99623]:=[ ,,,[88171635024,"JB"],]; CONWAYPOLDATA[99643]:=[ ,,,[36964563713,"JB"],]; CONWAYPOLDATA[99661]:=[ ,,,[66417977181,"JB"],]; CONWAYPOLDATA[99667]:=[ ,,,[84487018233,"JB"],]; CONWAYPOLDATA[99679]:=[ ,,,[25733629041,"JB"],]; CONWAYPOLDATA[99689]:=[ ,,,[129191560797,"JB"],]; CONWAYPOLDATA[99707]:=[ ,,,[47909811744,"JB"],]; CONWAYPOLDATA[99709]:=[ ,,,[55631838888,"JB"],]; CONWAYPOLDATA[99713]:=[ ,,,[117612779772,"JB"],]; CONWAYPOLDATA[99719]:=[ ,,,[64884660332,"JB"],]; CONWAYPOLDATA[99721]:=[ ,,,[245365714373,"JB"],]; CONWAYPOLDATA[99733]:=[ ,,,[69150075018,"JB"],]; CONWAYPOLDATA[99761]:=[ ,,,[17508753830,"JB"],]; CONWAYPOLDATA[99767]:=[ ,,,[57403337863,"JB"],]; CONWAYPOLDATA[99787]:=[ ,,,[25435706302,"JB"],]; CONWAYPOLDATA[99793]:=[ ,,,[108261433985,"JB"],]; CONWAYPOLDATA[99809]:=[ ,,,[47273434954,"JB"],]; CONWAYPOLDATA[99817]:=[ ,,,[118769653063,"JB"],]; CONWAYPOLDATA[99823]:=[ ,,,[26253648667,"JB"],]; CONWAYPOLDATA[99829]:=[ ,,,[65680693630,"JB"],]; CONWAYPOLDATA[99833]:=[ ,,,[47482771129,"JB"],]; CONWAYPOLDATA[99839]:=[ ,,,[38282665527,"JB"],]; CONWAYPOLDATA[99859]:=[ ,,,[75551721658,"JB"],]; CONWAYPOLDATA[99871]:=[ ,,,[26857109581,"JB"],]; CONWAYPOLDATA[99877]:=[ ,,,[127789425438,"JB"],]; CONWAYPOLDATA[99881]:=[ ,,,[9444247961,"JB"],]; CONWAYPOLDATA[99901]:=[ ,,,[127429919364,"JB"],]; CONWAYPOLDATA[99907]:=[ ,,,[77998593786,"JB"],]; CONWAYPOLDATA[99923]:=[ ,,,[28831282807,"JB"],]; CONWAYPOLDATA[99929]:=[ ,,,[16859321380,"JB"],]; CONWAYPOLDATA[99961]:=[ ,,,[309362201700,"JB"],]; CONWAYPOLDATA[99971]:=[ ,,,[8063460920,"JB"],]; CONWAYPOLDATA[99989]:=[ ,,,[6572576939,"JB"],]; CONWAYPOLDATA[99991]:=[ ,,,[36350628155,"JB"],]; CONWAYPOLDATA[100003]:=[ ,,,[199811994182,"JB"],]; CONWAYPOLDATA[100019]:=[ ,,,[119516303786,"JB"],]; CONWAYPOLDATA[100043]:=[ ,,,[28035049892,"JB"],]; CONWAYPOLDATA[100049]:=[ ,,,[76141190917,"JB"],]; CONWAYPOLDATA[100057]:=[ ,,,[245336462129,"JB"],]; CONWAYPOLDATA[100069]:=[ ,,,[26543802605,"JB"],]; CONWAYPOLDATA[100103]:=[ ,,,[88588352121,"JB"],]; CONWAYPOLDATA[100109]:=[ ,,,[129016574951,"JB"],]; CONWAYPOLDATA[100129]:=[ ,,,[279229341795,"JB"],]; CONWAYPOLDATA[100151]:=[ ,,,[50150212653,"JB"],]; CONWAYPOLDATA[100153]:=[ ,,,[108825749040,"JB"],]; CONWAYPOLDATA[100169]:=[ ,,,[10032626536,"JB"],]; CONWAYPOLDATA[100183]:=[ ,,,[86500707144,"JB"],]; CONWAYPOLDATA[100189]:=[ ,,,[90339820168,"JB"],]; CONWAYPOLDATA[100193]:=[ ,,,[5411924898,"JB"],]; CONWAYPOLDATA[100207]:=[ ,,,[58124769732,"JB"],]; CONWAYPOLDATA[100213]:=[ ,,,[95653408715,"JB"],]; CONWAYPOLDATA[100237]:=[ ,,,[76525937655,"JB"],]; CONWAYPOLDATA[100267]:=[ ,,,[70373496892,"JB"],]; CONWAYPOLDATA[100271]:=[ ,,,[76148805543,"JB"],]; CONWAYPOLDATA[100279]:=[ ,,,[65472058824,"JB"],]; CONWAYPOLDATA[100291]:=[ ,,,[27795750944,"JB"],]; CONWAYPOLDATA[100297]:=[ ,,,[48329112433,"JB"],]; CONWAYPOLDATA[100313]:=[ ,,,[5512399979,"JB"],]; CONWAYPOLDATA[100333]:=[ ,,,[129063555218,"JB"],]; CONWAYPOLDATA[100343]:=[ ,,,[99306055443,"JB"],]; CONWAYPOLDATA[100357]:=[ ,,,[65889388352,"JB"],]; CONWAYPOLDATA[100361]:=[ ,,,[46600924216,"JB"],]; CONWAYPOLDATA[100363]:=[ ,,,[90343059171,"JB"],]; CONWAYPOLDATA[100379]:=[ ,,,[26264466489,"JB"],]; CONWAYPOLDATA[100391]:=[ ,,,[27243206068,"JB"],]; CONWAYPOLDATA[100393]:=[ ,,,[167669561881,"JB"],]; CONWAYPOLDATA[100403]:=[ ,,,[149184299567,"JB"],]; CONWAYPOLDATA[100411]:=[ ,,,[15455361533,"JB"],]; CONWAYPOLDATA[100417]:=[ ,,,[68407675417,"JB"],]; CONWAYPOLDATA[100447]:=[ ,,,[27675659678,"JB"],]; CONWAYPOLDATA[100459]:=[ ,,,[88435162751,"JB"],]; CONWAYPOLDATA[100469]:=[ ,,,[36075403832,"JB"],]; CONWAYPOLDATA[100483]:=[ ,,,[39157823171,"JB"],]; CONWAYPOLDATA[100493]:=[ ,,,[9326353360,"JB"],]; CONWAYPOLDATA[100501]:=[ ,,,[65710367830,"JB"],]; CONWAYPOLDATA[100511]:=[ ,,,[35400778299,"JB"],]; CONWAYPOLDATA[100517]:=[ ,,,[136970696256,"JB"],]; CONWAYPOLDATA[100519]:=[ ,,,[38573362104,"JB"],]; CONWAYPOLDATA[100523]:=[ ,,,[137655392018,"JB"],]; CONWAYPOLDATA[100537]:=[ ,,,[89510805606,"JB"],]; CONWAYPOLDATA[100547]:=[ ,,,[25860185667,"JB"],]; CONWAYPOLDATA[100549]:=[ ,,,[65751303729,"JB"],]; CONWAYPOLDATA[100559]:=[ ,,,[68715484272,"JB"],]; CONWAYPOLDATA[100591]:=[ ,,,[50008815656,"JB"],]; CONWAYPOLDATA[100609]:=[ ,,,[211204549956,"JB"],]; CONWAYPOLDATA[100613]:=[ ,,,[68983593031,"JB"],]; CONWAYPOLDATA[100621]:=[ ,,,[100847196026,"JB"],]; CONWAYPOLDATA[100649]:=[ ,,,[38284564676,"JB"],]; CONWAYPOLDATA[100669]:=[ ,,,[127222260798,"JB"],]; CONWAYPOLDATA[100673]:=[ ,,,[16778564875,"JB"],]; CONWAYPOLDATA[100693]:=[ ,,,[106982687554,"JB"],]; CONWAYPOLDATA[100699]:=[ ,,,[86998800353,"JB"],]; CONWAYPOLDATA[100703]:=[ ,,,[58904810013,"JB"],]; CONWAYPOLDATA[100733]:=[ ,,,[46720670533,"JB"],]; CONWAYPOLDATA[100741]:=[ ,,,[106762188835,"JB"],]; CONWAYPOLDATA[100747]:=[ ,,,[107860745672,"JB"],]; CONWAYPOLDATA[100769]:=[ ,,,[16088879312,"JB"],]; CONWAYPOLDATA[100787]:=[ ,,,[47957881360,"JB"],]; CONWAYPOLDATA[100799]:=[ ,,,[47466551514,"JB"],]; CONWAYPOLDATA[100801]:=[ ,,,[208884973062,"JB"],]; CONWAYPOLDATA[100811]:=[ ,,,[47559504661,"JB"],]; CONWAYPOLDATA[100823]:=[ ,,,[68239627803,"JB"],]; CONWAYPOLDATA[100829]:=[ ,,,[130754139741,"JB"],]; CONWAYPOLDATA[100847]:=[ ,,,[78975100951,"JB"],]; CONWAYPOLDATA[100853]:=[ ,,,[128812981458,"JB"],]; CONWAYPOLDATA[100907]:=[ ,,,[81180186037,"JB"],]; CONWAYPOLDATA[100913]:=[ ,,,[9621751814,"JB"],]; CONWAYPOLDATA[100927]:=[ ,,,[56375299028,"JB"],]; CONWAYPOLDATA[100931]:=[ ,,,[18036874357,"JB"],]; CONWAYPOLDATA[100937]:=[ ,,,[9594364664,"JB"],]; CONWAYPOLDATA[100943]:=[ ,,,[78890386567,"JB"],]; CONWAYPOLDATA[100957]:=[ ,,,[97282064245,"JB"],]; CONWAYPOLDATA[100981]:=[ ,,,[101034418956,"JB"],]; CONWAYPOLDATA[100987]:=[ ,,,[26555339548,"JB"],]; CONWAYPOLDATA[100999]:=[ ,,,[39117215700,"JB"],]; CONWAYPOLDATA[101009]:=[ ,,,[17769301265,"JB"],]; CONWAYPOLDATA[101021]:=[ ,,,[70959372864,"JB"],]; CONWAYPOLDATA[101027]:=[ ,,,[25836847036,"JB"],]; CONWAYPOLDATA[101051]:=[ ,,,[101677314100,"JB"],]; CONWAYPOLDATA[101063]:=[ ,,,[51067740285,"JB"],]; CONWAYPOLDATA[101081]:=[ ,,,[99977296567,"JB"],]; CONWAYPOLDATA[101089]:=[ ,,,[180135543581,"JB"],]; CONWAYPOLDATA[101107]:=[ ,,,[59554146250,"JB"],]; CONWAYPOLDATA[101111]:=[ ,,,[77769727889,"JB"],]; CONWAYPOLDATA[101113]:=[ ,,,[70521059629,"JB"],]; CONWAYPOLDATA[101117]:=[ ,,,[80874185538,"JB"],]; CONWAYPOLDATA[101119]:=[ ,,,[27485155393,"JB"],]; CONWAYPOLDATA[101141]:=[ ,,,[39995803889,"JB"],]; CONWAYPOLDATA[101149]:=[ ,,,[117693840783,"JB"],]; CONWAYPOLDATA[101159]:=[ ,,,[38413107077,"JB"],]; CONWAYPOLDATA[101161]:=[ ,,,[152627366890,"JB"],]; CONWAYPOLDATA[101173]:=[ ,,,[70171164650,"JB"],]; CONWAYPOLDATA[101183]:=[ ,,,[40801032925,"JB"],]; CONWAYPOLDATA[101197]:=[ ,,,[36206060268,"JB"],]; CONWAYPOLDATA[101203]:=[ ,,,[169912752797,"JB"],]; CONWAYPOLDATA[101207]:=[ ,,,[60130013708,"JB"],]; CONWAYPOLDATA[101209]:=[ ,,,[180804008385,"JB"],]; CONWAYPOLDATA[101221]:=[ ,,,[129154756934,"JB"],]; CONWAYPOLDATA[101267]:=[ ,,,[28015616819,"JB"],]; CONWAYPOLDATA[101273]:=[ ,,,[68877083852,"JB"],]; CONWAYPOLDATA[101279]:=[ ,,,[46423761642,"JB"],]; CONWAYPOLDATA[101281]:=[ ,,,[172473136691,"JB"],]; CONWAYPOLDATA[101287]:=[ ,,,[133366618643,"JB"],]; CONWAYPOLDATA[101293]:=[ ,,,[70907227155,"JB"],]; CONWAYPOLDATA[101323]:=[ ,,,[27170978328,"JB"],]; CONWAYPOLDATA[101333]:=[ ,,,[81732664477,"JB"],]; CONWAYPOLDATA[101341]:=[ ,,,[108982516766,"JB"],]; CONWAYPOLDATA[101347]:=[ ,,,[89450990489,"JB"],]; CONWAYPOLDATA[101359]:=[ ,,,[40742567720,"JB"],]; CONWAYPOLDATA[101363]:=[ ,,,[28070252866,"JB"],]; CONWAYPOLDATA[101377]:=[ ,,,[68815417244,"JB"],]; CONWAYPOLDATA[101383]:=[ ,,,[57644346143,"JB"],]; CONWAYPOLDATA[101399]:=[ ,,,[51407873421,"JB"],]; CONWAYPOLDATA[101411]:=[ ,,,[89307191508,"JB"],]; CONWAYPOLDATA[101419]:=[ ,,,[30376207530,"JB"],]; CONWAYPOLDATA[101429]:=[ ,,,[92589868368,"JB"],]; CONWAYPOLDATA[101449]:=[ ,,,[193880502748,"JB"],]; CONWAYPOLDATA[101467]:=[ ,,,[88530566304,"JB"],]; CONWAYPOLDATA[101477]:=[ ,,,[39651528890,"JB"],]; CONWAYPOLDATA[101483]:=[ ,,,[81878209613,"JB"],]; CONWAYPOLDATA[101489]:=[ ,,,[10298799256,"JB"],]; CONWAYPOLDATA[101501]:=[ ,,,[26584532916,"JB"],]; CONWAYPOLDATA[101503]:=[ ,,,[101281418956,"JB"],]; CONWAYPOLDATA[101513]:=[ ,,,[17302383288,"JB"],]; CONWAYPOLDATA[101527]:=[ ,,,[112511003081,"JB"],]; CONWAYPOLDATA[101531]:=[ ,,,[70823558238,"JB"],]; CONWAYPOLDATA[101533]:=[ ,,,[214642995731,"JB"],]; CONWAYPOLDATA[101537]:=[ ,,,[79711824927,"JB"],]; CONWAYPOLDATA[101561]:=[ ,,,[30778873541,"JB"],]; CONWAYPOLDATA[101573]:=[ ,,,[39560855188,"JB"],]; CONWAYPOLDATA[101581]:=[ ,,,[68578755236,"JB"],]; CONWAYPOLDATA[101599]:=[ ,,,[28548201422,"JB"],]; CONWAYPOLDATA[101603]:=[ ,,,[50734848434,"JB"],]; CONWAYPOLDATA[101611]:=[ ,,,[68535501781,"JB"],]; CONWAYPOLDATA[101627]:=[ ,,,[91828734424,"JB"],]; CONWAYPOLDATA[101641]:=[ ,,,[175165761670,"JB"],]; CONWAYPOLDATA[101653]:=[ ,,,[72287481365,"JB"],]; CONWAYPOLDATA[101663]:=[ ,,,[51371025546,"JB"],]; CONWAYPOLDATA[101681]:=[ ,,,[50426048250,"JB"],]; CONWAYPOLDATA[101693]:=[ ,,,[30222142672,"JB"],]; CONWAYPOLDATA[101701]:=[ ,,,[38868088182,"JB"],]; CONWAYPOLDATA[101719]:=[ ,,,[29902029276,"JB"],]; CONWAYPOLDATA[101723]:=[ ,,,[110620202197,"JB"],]; CONWAYPOLDATA[101737]:=[ ,,,[130282570941,"JB"],]; CONWAYPOLDATA[101741]:=[ ,,,[18331896864,"JB"],]; CONWAYPOLDATA[101747]:=[ ,,,[19797320780,"JB"],]; CONWAYPOLDATA[101749]:=[ ,,,[109328690008,"JB"],]; CONWAYPOLDATA[101771]:=[ ,,,[132091430490,"JB"],]; CONWAYPOLDATA[101789]:=[ ,,,[70812266155,"JB"],]; CONWAYPOLDATA[101797]:=[ ,,,[71233977707,"JB"],]; CONWAYPOLDATA[101807]:=[ ,,,[51416301864,"JB"],]; CONWAYPOLDATA[101833]:=[ ,,,[133987380753,"JB"],]; CONWAYPOLDATA[101837]:=[ ,,,[68797309236,"JB"],]; CONWAYPOLDATA[101839]:=[ ,,,[30038125938,"JB"],]; CONWAYPOLDATA[101863]:=[ ,,,[68959519332,"JB"],]; CONWAYPOLDATA[101869]:=[ ,,,[30490614134,"JB"],]; CONWAYPOLDATA[101873]:=[ ,,,[50327095717,"JB"],]; CONWAYPOLDATA[101879]:=[ ,,,[59897924235,"JB"],]; CONWAYPOLDATA[101891]:=[ ,,,[67866028917,"JB"],]; CONWAYPOLDATA[101917]:=[ ,,,[155805002253,"JB"],]; CONWAYPOLDATA[101921]:=[ ,,,[47495491774,"JB"],]; CONWAYPOLDATA[101929]:=[ ,,,[234125510780,"JB"],]; CONWAYPOLDATA[101939]:=[ ,,,[50621786073,"JB"],]; CONWAYPOLDATA[101957]:=[ ,,,[80964155659,"JB"],]; CONWAYPOLDATA[101963]:=[ ,,,[80524361585,"JB"],]; CONWAYPOLDATA[101977]:=[ ,,,[175462238067,"JB"],]; CONWAYPOLDATA[101987]:=[ ,,,[82960611243,"JB"],]; CONWAYPOLDATA[101999]:=[ ,,,[38934854289,"JB"],]; CONWAYPOLDATA[102001]:=[ ,,,[341455181598,"JB"],]; CONWAYPOLDATA[102013]:=[ ,,,[71331570125,"JB"],]; CONWAYPOLDATA[102019]:=[ ,,,[93205476573,"JB"],]; CONWAYPOLDATA[102023]:=[ ,,,[36630643994,"JB"],]; CONWAYPOLDATA[102031]:=[ ,,,[38007873906,"JB"],]; CONWAYPOLDATA[102043]:=[ ,,,[60923242510,"JB"],]; CONWAYPOLDATA[102059]:=[ ,,,[31078700505,"JB"],]; CONWAYPOLDATA[102061]:=[ ,,,[70080900079,"JB"],]; CONWAYPOLDATA[102071]:=[ ,,,[26881928922,"JB"],]; CONWAYPOLDATA[102077]:=[ ,,,[93776710824,"JB"],]; CONWAYPOLDATA[102079]:=[ ,,,[37308139160,"JB"],]; CONWAYPOLDATA[102101]:=[ ,,,[19995357741,"JB"],]; CONWAYPOLDATA[102103]:=[ ,,,[363491989361,"JB"],]; CONWAYPOLDATA[102107]:=[ ,,,[26230165125,"JB"],]; CONWAYPOLDATA[102121]:=[ ,,,[176671270306,"JB"],]; CONWAYPOLDATA[102139]:=[ ,,,[41683334459,"JB"],]; CONWAYPOLDATA[102149]:=[ ,,,[47342894883,"JB"],]; CONWAYPOLDATA[102161]:=[ ,,,[6876456916,"JB"],]; CONWAYPOLDATA[102181]:=[ ,,,[123995621696,"JB"],]; CONWAYPOLDATA[102191]:=[ ,,,[70816830146,"JB"],]; CONWAYPOLDATA[102197]:=[ ,,,[40084013933,"JB"],]; CONWAYPOLDATA[102199]:=[ ,,,[10364613795,"JB"],]; CONWAYPOLDATA[102203]:=[ ,,,[9919618776,"JB"],]; CONWAYPOLDATA[102217]:=[ ,,,[111872417825,"JB"],]; CONWAYPOLDATA[102229]:=[ ,,,[131776861246,"JB"],]; CONWAYPOLDATA[102233]:=[ ,,,[79422773043,"JB"],]; CONWAYPOLDATA[102241]:=[ ,,,[93739251897,"JB"],]; CONWAYPOLDATA[102251]:=[ ,,,[89769220432,"JB"],]; CONWAYPOLDATA[102253]:=[ ,,,[104483649197,"JB"],]; CONWAYPOLDATA[102259]:=[ ,,,[10300037778,"JB"],]; CONWAYPOLDATA[102293]:=[ ,,,[16344580128,"JB"],]; CONWAYPOLDATA[102299]:=[ ,,,[37850630002,"JB"],]; CONWAYPOLDATA[102301]:=[ ,,,[102132919464,"JB"],]; CONWAYPOLDATA[102317]:=[ ,,,[39736444024,"JB"],]; CONWAYPOLDATA[102329]:=[ ,,,[29488761907,"JB"],]; CONWAYPOLDATA[102337]:=[ ,,,[68192771640,"JB"],]; CONWAYPOLDATA[102359]:=[ ,,,[40882184611,"JB"],]; CONWAYPOLDATA[102367]:=[ ,,,[38274918936,"JB"],]; CONWAYPOLDATA[102397]:=[ ,,,[111934870967,"JB"],]; CONWAYPOLDATA[102407]:=[ ,,,[61240614889,"JB"],]; CONWAYPOLDATA[102409]:=[ ,,,[152555512628,"JB"],]; CONWAYPOLDATA[102433]:=[ ,,,[195210358126,"JB"],]; CONWAYPOLDATA[102437]:=[ ,,,[26921263098,"JB"],]; CONWAYPOLDATA[102451]:=[ ,,,[29787833155,"JB"],]; CONWAYPOLDATA[102461]:=[ ,,,[131891692720,"JB"],]; CONWAYPOLDATA[102481]:=[ ,,,[152895503153,"JB"],]; CONWAYPOLDATA[102497]:=[ ,,,[80131744615,"JB"],]; CONWAYPOLDATA[102499]:=[ ,,,[5806773351,"JB"],]; CONWAYPOLDATA[102503]:=[ ,,,[100100842200,"JB"],]; CONWAYPOLDATA[102523]:=[ ,,,[90837018370,"JB"],]; CONWAYPOLDATA[102533]:=[ ,,,[70184658766,"JB"],]; CONWAYPOLDATA[102539]:=[ ,,,[94627500918,"JB"],]; CONWAYPOLDATA[102547]:=[ ,,,[93574342596,"JB"],]; CONWAYPOLDATA[102551]:=[ ,,,[58621638347,"JB"],]; CONWAYPOLDATA[102559]:=[ ,,,[71423215752,"JB"],]; CONWAYPOLDATA[102563]:=[ ,,,[114732612767,"JB"],]; CONWAYPOLDATA[102587]:=[ ,,,[93179874689,"JB"],]; CONWAYPOLDATA[102593]:=[ ,,,[47825471034,"JB"],]; CONWAYPOLDATA[102607]:=[ ,,,[112542538422,"JB"],]; CONWAYPOLDATA[102611]:=[ ,,,[47681382093,"JB"],]; CONWAYPOLDATA[102643]:=[ ,,,[132550296203,"JB"],]; CONWAYPOLDATA[102647]:=[ ,,,[42145215853,"JB"],]; CONWAYPOLDATA[102653]:=[ ,,,[47606149976,"JB"],]; CONWAYPOLDATA[102667]:=[ ,,,[126286056688,"JB"],]; CONWAYPOLDATA[102673]:=[ ,,,[158125044537,"JB"],]; CONWAYPOLDATA[102677]:=[ ,,,[51173498064,"JB"],]; CONWAYPOLDATA[102679]:=[ ,,,[143812515440,"JB"],]; CONWAYPOLDATA[102701]:=[ ,,,[133087966480,"JB"],]; CONWAYPOLDATA[102761]:=[ ,,,[82114362647,"JB"],]; CONWAYPOLDATA[102763]:=[ ,,,[95041388182,"JB"],]; CONWAYPOLDATA[102769]:=[ ,,,[248871473782,"JB"],]; CONWAYPOLDATA[102793]:=[ ,,,[70962839176,"JB"],]; CONWAYPOLDATA[102797]:=[ ,,,[101935663939,"JB"],]; CONWAYPOLDATA[102811]:=[ ,,,[92331371961,"JB"],]; CONWAYPOLDATA[102829]:=[ ,,,[155508708018,"JB"],]; CONWAYPOLDATA[102841]:=[ ,,,[154912380702,"JB"],]; CONWAYPOLDATA[102859]:=[ ,,,[19455676994,"JB"],]; CONWAYPOLDATA[102871]:=[ ,,,[41165579469,"JB"],]; CONWAYPOLDATA[102877]:=[ ,,,[72708525506,"JB"],]; CONWAYPOLDATA[102881]:=[ ,,,[40669990994,"JB"],]; CONWAYPOLDATA[102911]:=[ ,,,[114576373501,"JB"],]; CONWAYPOLDATA[102913]:=[ ,,,[111635905885,"JB"],]; CONWAYPOLDATA[102929]:=[ ,,,[6696354888,"JB"],]; CONWAYPOLDATA[102931]:=[ ,,,[30241436596,"JB"],]; CONWAYPOLDATA[102953]:=[ ,,,[5359218418,"JB"],]; CONWAYPOLDATA[102967]:=[ ,,,[137827507523,"JB"],]; CONWAYPOLDATA[102983]:=[ ,,,[42115515753,"JB"],]; CONWAYPOLDATA[103001]:=[ ,,,[136797688127,"JB"],]; CONWAYPOLDATA[103007]:=[ ,,,[112619716252,"JB"],]; CONWAYPOLDATA[103043]:=[ ,,,[31796287641,"JB"],]; CONWAYPOLDATA[103049]:=[ ,,,[31310717310,"JB"],]; CONWAYPOLDATA[103067]:=[ ,,,[30135760132,"JB"],]; CONWAYPOLDATA[103069]:=[ ,,,[135707241818,"JB"],]; CONWAYPOLDATA[103079]:=[ ,,,[27509001974,"JB"],]; CONWAYPOLDATA[103087]:=[ ,,,[125737378730,"JB"],]; CONWAYPOLDATA[103091]:=[ ,,,[60645961122,"JB"],]; CONWAYPOLDATA[103093]:=[ ,,,[71784686832,"JB"],]; CONWAYPOLDATA[103099]:=[ ,,,[8645366655,"JB"],]; CONWAYPOLDATA[103123]:=[ ,,,[42312810625,"JB"],]; CONWAYPOLDATA[103141]:=[ ,,,[138294031331,"JB"],]; CONWAYPOLDATA[103171]:=[ ,,,[84383251401,"JB"],]; CONWAYPOLDATA[103177]:=[ ,,,[5740974644,"JB"],]; CONWAYPOLDATA[103183]:=[ ,,,[40673706773,"JB"],]; CONWAYPOLDATA[103217]:=[ ,,,[103057013653,"JB"],]; CONWAYPOLDATA[103231]:=[ ,,,[41641527245,"JB"],]; CONWAYPOLDATA[103237]:=[ ,,,[16425935838,"JB"],]; CONWAYPOLDATA[103289]:=[ ,,,[10667378056,"JB"],]; CONWAYPOLDATA[103291]:=[ ,,,[31324338535,"JB"],]; CONWAYPOLDATA[103307]:=[ ,,,[48374949050,"JB"],]; CONWAYPOLDATA[103319]:=[ ,,,[70907003161,"JB"],]; CONWAYPOLDATA[103333]:=[ ,,,[39478372652,"JB"],]; CONWAYPOLDATA[103349]:=[ ,,,[41340943540,"JB"],]; CONWAYPOLDATA[103357]:=[ ,,,[93135612848,"JB"],]; CONWAYPOLDATA[103387]:=[ ,,,[61206344649,"JB"],]; CONWAYPOLDATA[103391]:=[ ,,,[127830357805,"JB"],]; CONWAYPOLDATA[103393]:=[ ,,,[70889652774,"JB"],]; CONWAYPOLDATA[103399]:=[ ,,,[53456352412,"JB"],]; CONWAYPOLDATA[103409]:=[ ,,,[29561324015,"JB"],]; CONWAYPOLDATA[103421]:=[ ,,,[92334165389,"JB"],]; CONWAYPOLDATA[103423]:=[ ,,,[179847322432,"JB"],]; CONWAYPOLDATA[103451]:=[ ,,,[38888058510,"JB"],]; CONWAYPOLDATA[103457]:=[ ,,,[138303697114,"JB"],]; CONWAYPOLDATA[103471]:=[ ,,,[74580655151,"JB"],]; CONWAYPOLDATA[103483]:=[ ,,,[92072033075,"JB"],]; CONWAYPOLDATA[103511]:=[ ,,,[32002288855,"JB"],]; CONWAYPOLDATA[103529]:=[ ,,,[10717011496,"JB"],]; CONWAYPOLDATA[103549]:=[ ,,,[38487920714,"JB"],]; CONWAYPOLDATA[103553]:=[ ,,,[81143716591,"JB"],]; CONWAYPOLDATA[103561]:=[ ,,,[96326746366,"JB"],]; CONWAYPOLDATA[103567]:=[ ,,,[114799876827,"JB"],]; CONWAYPOLDATA[103573]:=[ ,,,[16974993267,"JB"],]; CONWAYPOLDATA[103577]:=[ ,,,[9588951509,"JB"],]; CONWAYPOLDATA[103583]:=[ ,,,[30469250204,"JB"],]; CONWAYPOLDATA[103591]:=[ ,,,[40871518280,"JB"],]; CONWAYPOLDATA[103613]:=[ ,,,[19884370832,"JB"],]; CONWAYPOLDATA[103619]:=[ ,,,[26974616177,"JB"],]; CONWAYPOLDATA[103643]:=[ ,,,[95074211334,"JB"],]; CONWAYPOLDATA[103651]:=[ ,,,[94495403521,"JB"],]; CONWAYPOLDATA[103657]:=[ ,,,[128763865632,"JB"],]; CONWAYPOLDATA[103669]:=[ ,,,[29399077040,"JB"],]; CONWAYPOLDATA[103681]:=[ ,,,[255508449662,"JB"],]; CONWAYPOLDATA[103687]:=[ ,,,[70228034599,"JB"],]; CONWAYPOLDATA[103699]:=[ ,,,[95907990433,"JB"],]; CONWAYPOLDATA[103703]:=[ ,,,[94181612763,"JB"],]; CONWAYPOLDATA[103723]:=[ ,,,[62418323220,"JB"],]; CONWAYPOLDATA[103769]:=[ ,,,[10766760136,"JB"],]; CONWAYPOLDATA[103787]:=[ ,,,[31614661859,"JB"],]; CONWAYPOLDATA[103801]:=[ ,,,[138294798921,"JB"],]; CONWAYPOLDATA[103811]:=[ ,,,[83083265254,"JB"],]; CONWAYPOLDATA[103813]:=[ ,,,[180717255154,"JB"],]; CONWAYPOLDATA[103837]:=[ ,,,[41951186375,"JB"],]; CONWAYPOLDATA[103841]:=[ ,,,[10781707192,"JB"],]; CONWAYPOLDATA[103843]:=[ ,,,[128291588236,"JB"],]; CONWAYPOLDATA[103867]:=[ ,,,[94596662518,"JB"],]; CONWAYPOLDATA[103889]:=[ ,,,[29884398076,"JB"],]; CONWAYPOLDATA[103903]:=[ ,,,[27088655036,"JB"],]; CONWAYPOLDATA[103913]:=[ ,,,[19872114297,"JB"],]; CONWAYPOLDATA[103919]:=[ ,,,[53994857541,"JB"],]; CONWAYPOLDATA[103951]:=[ ,,,[40489330310,"JB"],]; CONWAYPOLDATA[103963]:=[ ,,,[84328963674,"JB"],]; CONWAYPOLDATA[103967]:=[ ,,,[52610836883,"JB"],]; CONWAYPOLDATA[103969]:=[ ,,,[7853922236,"JB"],]; CONWAYPOLDATA[103979]:=[ ,,,[82939161289,"JB"],]; CONWAYPOLDATA[103981]:=[ ,,,[82060557434,"JB"],]; CONWAYPOLDATA[103991]:=[ ,,,[29247780742,"JB"],]; CONWAYPOLDATA[103993]:=[ ,,,[162217016817,"JB"],]; CONWAYPOLDATA[103997]:=[ ,,,[72776788611,"JB"],]; CONWAYPOLDATA[104003]:=[ ,,,[92484979761,"JB"],]; CONWAYPOLDATA[104009]:=[ ,,,[10816623976,"JB"],]; CONWAYPOLDATA[104021]:=[ ,,,[179815901652,"JB"],]; CONWAYPOLDATA[104033]:=[ ,,,[7315288464,"JB"],]; CONWAYPOLDATA[104047]:=[ ,,,[41033535630,"JB"],]; CONWAYPOLDATA[104053]:=[ ,,,[10505086833,"JB"],]; CONWAYPOLDATA[104059]:=[ ,,,[94182031899,"JB"],]; CONWAYPOLDATA[104087]:=[ ,,,[19923604936,"JB"],]; CONWAYPOLDATA[104089]:=[ ,,,[6812937324,"JB"],]; CONWAYPOLDATA[104107]:=[ ,,,[32107535768,"JB"],]; CONWAYPOLDATA[104113]:=[ ,,,[126408486616,"JB"],]; CONWAYPOLDATA[104119]:=[ ,,,[32223685197,"JB"],]; CONWAYPOLDATA[104123]:=[ ,,,[29828948796,"JB"],]; CONWAYPOLDATA[104147]:=[ ,,,[39587107878,"JB"],]; CONWAYPOLDATA[104149]:=[ ,,,[86219749656,"JB"],]; CONWAYPOLDATA[104161]:=[ ,,,[160914058318,"JB"],]; CONWAYPOLDATA[104173]:=[ ,,,[74100234189,"JB"],]; CONWAYPOLDATA[104179]:=[ ,,,[28912381156,"JB"],]; CONWAYPOLDATA[104183]:=[ ,,,[157499692085,"JB"],]; CONWAYPOLDATA[104207]:=[ ,,,[43435978573,"JB"],]; CONWAYPOLDATA[104231]:=[ ,,,[71958372401,"JB"],]; CONWAYPOLDATA[104233]:=[ ,,,[115781182543,"JB"],]; CONWAYPOLDATA[104239]:=[ ,,,[115856645034,"JB"],]; CONWAYPOLDATA[104243]:=[ ,,,[29063782346,"JB"],]; CONWAYPOLDATA[104281]:=[ ,,,[162634562006,"JB"],]; CONWAYPOLDATA[104287]:=[ ,,,[61053155563,"JB"],]; CONWAYPOLDATA[104297]:=[ ,,,[82048572557,"JB"],]; CONWAYPOLDATA[104309]:=[ ,,,[73121443474,"JB"],]; CONWAYPOLDATA[104311]:=[ ,,,[61680241727,"JB"],]; CONWAYPOLDATA[104323]:=[ ,,,[59987498496,"JB"],]; CONWAYPOLDATA[104327]:=[ ,,,[43536074413,"JB"],]; CONWAYPOLDATA[104347]:=[ ,,,[32304996435,"JB"],]; CONWAYPOLDATA[104369]:=[ ,,,[31873666389,"JB"],]; CONWAYPOLDATA[104381]:=[ ,,,[7203019669,"JB"],]; CONWAYPOLDATA[104383]:=[ ,,,[43582825229,"JB"],]; CONWAYPOLDATA[104393]:=[ ,,,[126047866351,"JB"],]; CONWAYPOLDATA[104399]:=[ ,,,[32031283591,"JB"],]; CONWAYPOLDATA[104417]:=[ ,,,[86625387376,"JB"],]; CONWAYPOLDATA[104459]:=[ ,,,[87001080709,"JB"],]; CONWAYPOLDATA[104471]:=[ ,,,[62003851924,"JB"],]; CONWAYPOLDATA[104473]:=[ ,,,[193950676896,"JB"],]; CONWAYPOLDATA[104479]:=[ ,,,[7105721276,"JB"],]; CONWAYPOLDATA[104491]:=[ ,,,[74490902466,"JB"],]; CONWAYPOLDATA[104513]:=[ ,,,[50207418125,"JB"],]; CONWAYPOLDATA[104527]:=[ ,,,[39116512051,"JB"],]; CONWAYPOLDATA[104537]:=[ ,,,[106356466488,"JB"],]; CONWAYPOLDATA[104543]:=[ ,,,[161135053109,"JB"],]; CONWAYPOLDATA[104549]:=[ ,,,[17299827581,"JB"],]; CONWAYPOLDATA[104551]:=[ ,,,[29232668705,"JB"],]; CONWAYPOLDATA[104561]:=[ ,,,[6481527274,"JB"],]; CONWAYPOLDATA[104579]:=[ ,,,[30855197320,"JB"],]; CONWAYPOLDATA[104593]:=[ ,,,[140931536809,"JB"],]; CONWAYPOLDATA[104597]:=[ ,,,[226985531314,"JB"],]; CONWAYPOLDATA[104623]:=[ ,,,[62581293687,"JB"],]; CONWAYPOLDATA[104639]:=[ ,,,[41562506174,"JB"],]; CONWAYPOLDATA[104651]:=[ ,,,[5801956097,"JB"],]; CONWAYPOLDATA[104659]:=[ ,,,[98405624752,"JB"],]; CONWAYPOLDATA[104677]:=[ ,,,[75340747367,"JB"],]; CONWAYPOLDATA[104681]:=[ ,,,[9561248503,"JB"],]; CONWAYPOLDATA[104683]:=[ ,,,[128325446186,"JB"],]; CONWAYPOLDATA[104693]:=[ ,,,[173905123531,"JB"],]; CONWAYPOLDATA[104701]:=[ ,,,[119380813109,"JB"],]; CONWAYPOLDATA[104707]:=[ ,,,[96683930834,"JB"],]; CONWAYPOLDATA[104711]:=[ ,,,[42541775701,"JB"],]; CONWAYPOLDATA[104717]:=[ ,,,[76081822201,"JB"],]; CONWAYPOLDATA[104723]:=[ ,,,[32355322805,"JB"],]; CONWAYPOLDATA[104729]:=[ ,,,[9090581941,"JB"],]; CONWAYPOLDATA[104743]:=[ ,,,[41791409573,"JB"],]; CONWAYPOLDATA[104759]:=[ ,,,[32548830825,"JB"],]; CONWAYPOLDATA[104761]:=[ ,,,[10145683813,"JB"],]; CONWAYPOLDATA[104773]:=[ ,,,[142365133310,"JB"],]; CONWAYPOLDATA[104779]:=[ ,,,[60638017220,"JB"],]; CONWAYPOLDATA[104789]:=[ ,,,[19891152771,"JB"],]; CONWAYPOLDATA[104801]:=[ ,,,[65898240007,"JB"],]; CONWAYPOLDATA[104803]:=[ ,,,[60970507692,"JB"],]; CONWAYPOLDATA[104827]:=[ ,,,[63443921078,"JB"],]; CONWAYPOLDATA[104831]:=[ ,,,[54068475230,"JB"],]; CONWAYPOLDATA[104849]:=[ ,,,[87898481569,"JB"],]; CONWAYPOLDATA[104851]:=[ ,,,[28487911862,"JB"],]; CONWAYPOLDATA[104869]:=[ ,,,[140476430000,"JB"],]; CONWAYPOLDATA[104879]:=[ ,,,[62661951262,"JB"],]; CONWAYPOLDATA[104891]:=[ ,,,[99018362694,"JB"],]; CONWAYPOLDATA[104911]:=[ ,,,[50586615452,"JB"],]; CONWAYPOLDATA[104917]:=[ ,,,[138937491339,"JB"],]; CONWAYPOLDATA[104933]:=[ ,,,[75545044290,"JB"],]; CONWAYPOLDATA[104947]:=[ ,,,[86329402205,"JB"],]; CONWAYPOLDATA[104953]:=[ ,,,[206866980937,"JB"],]; CONWAYPOLDATA[104959]:=[ ,,,[29634019104,"JB"],]; CONWAYPOLDATA[104971]:=[ ,,,[32739510163,"JB"],]; CONWAYPOLDATA[104987]:=[ ,,,[82994638203,"JB"],]; CONWAYPOLDATA[104999]:=[ ,,,[85534915385,"JB"],]; CONWAYPOLDATA[105019]:=[ ,,,[20914953928,"JB"],]; CONWAYPOLDATA[105023]:=[ ,,,[63984842663,"JB"],]; CONWAYPOLDATA[105031]:=[ ,,,[40891089047,"JB"],]; CONWAYPOLDATA[105037]:=[ ,,,[119791232284,"JB"],]; CONWAYPOLDATA[105071]:=[ ,,,[84588564338,"JB"],]; CONWAYPOLDATA[105097]:=[ ,,,[149406210498,"JB"],]; CONWAYPOLDATA[105107]:=[ ,,,[98703671348,"JB"],]; CONWAYPOLDATA[105137]:=[ ,,,[88243586843,"JB"],]; CONWAYPOLDATA[105143]:=[ ,,,[98466419505,"JB"],]; CONWAYPOLDATA[105167]:=[ ,,,[132719912669,"JB"],]; CONWAYPOLDATA[105173]:=[ ,,,[41340245939,"JB"],]; CONWAYPOLDATA[105199]:=[ ,,,[44046190112,"JB"],]; CONWAYPOLDATA[105211]:=[ ,,,[94346596509,"JB"],]; CONWAYPOLDATA[105227]:=[ ,,,[61397849965,"JB"],]; CONWAYPOLDATA[105229]:=[ ,,,[99657545368,"JB"],]; CONWAYPOLDATA[105239]:=[ ,,,[31982553070,"JB"],]; CONWAYPOLDATA[105251]:=[ ,,,[30828754659,"JB"],]; CONWAYPOLDATA[105253]:=[ ,,,[72219451209,"JB"],]; CONWAYPOLDATA[105263]:=[ ,,,[44320775629,"JB"],]; CONWAYPOLDATA[105269]:=[ ,,,[106083992600,"JB"],]; CONWAYPOLDATA[105277]:=[ ,,,[119948402726,"JB"],]; CONWAYPOLDATA[105319]:=[ ,,,[39448600600,"JB"],]; CONWAYPOLDATA[105323]:=[ ,,,[98770750849,"JB"],]; CONWAYPOLDATA[105331]:=[ ,,,[154412507396,"JB"],]; CONWAYPOLDATA[105337]:=[ ,,,[74981404698,"JB"],]; CONWAYPOLDATA[105341]:=[ ,,,[50334352645,"JB"],]; CONWAYPOLDATA[105359]:=[ ,,,[97096431150,"JB"],]; CONWAYPOLDATA[105361]:=[ ,,,[320480346713,"JB"],]; CONWAYPOLDATA[105367]:=[ ,,,[44035714212,"JB"],]; CONWAYPOLDATA[105373]:=[ ,,,[108863796746,"JB"],]; CONWAYPOLDATA[105379]:=[ ,,,[85177424186,"JB"],]; CONWAYPOLDATA[105389]:=[ ,,,[77432459972,"JB"],]; CONWAYPOLDATA[105397]:=[ ,,,[86250897173,"JB"],]; CONWAYPOLDATA[105401]:=[ ,,,[50558857084,"JB"],]; CONWAYPOLDATA[105407]:=[ ,,,[108933602004,"JB"],]; CONWAYPOLDATA[105437]:=[ ,,,[40123312293,"JB"],]; CONWAYPOLDATA[105449]:=[ ,,,[50270596327,"JB"],]; CONWAYPOLDATA[105467]:=[ ,,,[55497790072,"JB"],]; CONWAYPOLDATA[105491]:=[ ,,,[86576358211,"JB"],]; CONWAYPOLDATA[105499]:=[ ,,,[41663454084,"JB"],]; CONWAYPOLDATA[105503]:=[ ,,,[95064216681,"JB"],]; CONWAYPOLDATA[105509]:=[ ,,,[42514429516,"JB"],]; CONWAYPOLDATA[105517]:=[ ,,,[106577656886,"JB"],]; CONWAYPOLDATA[105527]:=[ ,,,[96899218012,"JB"],]; CONWAYPOLDATA[105529]:=[ ,,,[252924836768,"JB"],]; CONWAYPOLDATA[105533]:=[ ,,,[96978917154,"JB"],]; CONWAYPOLDATA[105541]:=[ ,,,[72628355775,"JB"],]; CONWAYPOLDATA[105557]:=[ ,,,[64341002669,"JB"],]; CONWAYPOLDATA[105563]:=[ ,,,[163742675133,"JB"],]; CONWAYPOLDATA[105601]:=[ ,,,[229508144569,"JB"],]; CONWAYPOLDATA[105607]:=[ ,,,[30783806861,"JB"],]; CONWAYPOLDATA[105613]:=[ ,,,[120856757970,"JB"],]; CONWAYPOLDATA[105619]:=[ ,,,[85488335460,"JB"],]; CONWAYPOLDATA[105649]:=[ ,,,[11037890580,"JB"],]; CONWAYPOLDATA[105653]:=[ ,,,[144651212750,"JB"],]; CONWAYPOLDATA[105667]:=[ ,,,[31291802715,"JB"],]; CONWAYPOLDATA[105673]:=[ ,,,[76980984064,"JB"],]; CONWAYPOLDATA[105683]:=[ ,,,[150912047829,"JB"],]; CONWAYPOLDATA[105691]:=[ ,,,[33259266646,"JB"],]; CONWAYPOLDATA[105701]:=[ ,,,[40950364320,"JB"],]; CONWAYPOLDATA[105727]:=[ ,,,[39535871567,"JB"],]; CONWAYPOLDATA[105733]:=[ ,,,[8186166065,"JB"],]; CONWAYPOLDATA[105751]:=[ ,,,[8252279292,"JB"],]; CONWAYPOLDATA[105761]:=[ ,,,[87743556043,"JB"],]; CONWAYPOLDATA[105767]:=[ ,,,[40810725790,"JB"],]; CONWAYPOLDATA[105769]:=[ ,,,[257300861699,"JB"],]; CONWAYPOLDATA[105817]:=[ ,,,[266104993827,"JB"],]; CONWAYPOLDATA[105829]:=[ ,,,[100797254368,"JB"],]; CONWAYPOLDATA[105863]:=[ ,,,[31272141931,"JB"],]; CONWAYPOLDATA[105871]:=[ ,,,[40930469714,"JB"],]; CONWAYPOLDATA[105883]:=[ ,,,[95886797738,"JB"],]; CONWAYPOLDATA[105899]:=[ ,,,[28082085024,"JB"],]; CONWAYPOLDATA[105907]:=[ ,,,[10858115180,"JB"],]; CONWAYPOLDATA[105913]:=[ ,,,[74103830981,"JB"],]; CONWAYPOLDATA[105929]:=[ ,,,[11219681896,"JB"],]; CONWAYPOLDATA[105943]:=[ ,,,[66341718489,"JB"],]; CONWAYPOLDATA[105953]:=[ ,,,[7106903431,"JB"],]; CONWAYPOLDATA[105967]:=[ ,,,[75311700606,"JB"],]; CONWAYPOLDATA[105971]:=[ ,,,[101067933774,"JB"],]; CONWAYPOLDATA[105977]:=[ ,,,[51756517380,"JB"],]; CONWAYPOLDATA[105983]:=[ ,,,[77828722038,"JB"],]; CONWAYPOLDATA[105997]:=[ ,,,[76390659944,"JB"],]; CONWAYPOLDATA[106013]:=[ ,,,[39470442123,"JB"],]; CONWAYPOLDATA[106019]:=[ ,,,[98942337771,"JB"],]; CONWAYPOLDATA[106031]:=[ ,,,[43741816697,"JB"],]; CONWAYPOLDATA[106033]:=[ ,,,[134430121867,"JB"],]; CONWAYPOLDATA[106087]:=[ ,,,[56271833500,"JB"],]; CONWAYPOLDATA[106103]:=[ ,,,[45030962029,"JB"],]; CONWAYPOLDATA[106109]:=[ ,,,[20232545795,"JB"],]; CONWAYPOLDATA[106121]:=[ ,,,[28424722095,"JB"],]; CONWAYPOLDATA[106123]:=[ ,,,[88904649375,"JB"],]; CONWAYPOLDATA[106129]:=[ ,,,[254685296482,"JB"],]; CONWAYPOLDATA[106163]:=[ ,,,[88106584636,"JB"],]; CONWAYPOLDATA[106181]:=[ ,,,[54919255365,"JB"],]; CONWAYPOLDATA[106187]:=[ ,,,[167600145265,"JB"],]; CONWAYPOLDATA[106189]:=[ ,,,[85533009537,"JB"],]; CONWAYPOLDATA[106207]:=[ ,,,[56210054756,"JB"],]; CONWAYPOLDATA[106213]:=[ ,,,[75166409037,"JB"],]; CONWAYPOLDATA[106217]:=[ ,,,[6999169218,"JB"],]; CONWAYPOLDATA[106219]:=[ ,,,[56411954936,"JB"],]; CONWAYPOLDATA[106243]:=[ ,,,[44131217343,"JB"],]; CONWAYPOLDATA[106261]:=[ ,,,[89412787147,"JB"],]; CONWAYPOLDATA[106273]:=[ ,,,[187316045894,"JB"],]; CONWAYPOLDATA[106277]:=[ ,,,[39570540520,"JB"],]; CONWAYPOLDATA[106279]:=[ ,,,[29254570101,"JB"],]; CONWAYPOLDATA[106291]:=[ ,,,[76552372567,"JB"],]; CONWAYPOLDATA[106297]:=[ ,,,[179701031137,"JB"],]; CONWAYPOLDATA[106303]:=[ ,,,[74100313304,"JB"],]; CONWAYPOLDATA[106307]:=[ ,,,[30461420396,"JB"],]; CONWAYPOLDATA[106319]:=[ ,,,[77535576098,"JB"],]; CONWAYPOLDATA[106321]:=[ ,,,[179682171050,"JB"],]; CONWAYPOLDATA[106331]:=[ ,,,[30911485017,"JB"],]; CONWAYPOLDATA[106349]:=[ ,,,[20415817532,"JB"],]; CONWAYPOLDATA[106357]:=[ ,,,[75298203434,"JB"],]; CONWAYPOLDATA[106363]:=[ ,,,[120182638229,"JB"],]; CONWAYPOLDATA[106367]:=[ ,,,[74039409530,"JB"],]; CONWAYPOLDATA[106373]:=[ ,,,[88726357543,"JB"],]; CONWAYPOLDATA[106391]:=[ ,,,[54897649632,"JB"],]; CONWAYPOLDATA[106397]:=[ ,,,[113019574870,"JB"],]; CONWAYPOLDATA[106411]:=[ ,,,[101789463861,"JB"],]; CONWAYPOLDATA[106417]:=[ ,,,[201253169982,"JB"],]; CONWAYPOLDATA[106427]:=[ ,,,[32815062620,"JB"],]; CONWAYPOLDATA[106433]:=[ ,,,[56242496626,"JB"],]; CONWAYPOLDATA[106441]:=[ ,,,[200681519705,"JB"],]; CONWAYPOLDATA[106451]:=[ ,,,[89532849023,"JB"],]; CONWAYPOLDATA[106453]:=[ ,,,[99056964925,"JB"],]; CONWAYPOLDATA[106487]:=[ ,,,[45357498733,"JB"],]; CONWAYPOLDATA[106501]:=[ ,,,[102081421504,"JB"],]; CONWAYPOLDATA[106531]:=[ ,,,[75888210101,"JB"],]; CONWAYPOLDATA[106537]:=[ ,,,[212904073490,"JB"],]; CONWAYPOLDATA[106541]:=[ ,,,[43239451771,"JB"],]; CONWAYPOLDATA[106543]:=[ ,,,[30453718410,"JB"],]; CONWAYPOLDATA[106591]:=[ ,,,[77794268852,"JB"],]; CONWAYPOLDATA[106619]:=[ ,,,[86825928985,"JB"],]; CONWAYPOLDATA[106621]:=[ ,,,[226680297608,"JB"],]; CONWAYPOLDATA[106627]:=[ ,,,[166786699791,"JB"],]; CONWAYPOLDATA[106637]:=[ ,,,[21939709656,"JB"],]; CONWAYPOLDATA[106649]:=[ ,,,[11372729416,"JB"],]; CONWAYPOLDATA[106657]:=[ ,,,[74738932842,"JB"],]; CONWAYPOLDATA[106661]:=[ ,,,[74108276124,"JB"],]; CONWAYPOLDATA[106663]:=[ ,,,[45507555629,"JB"],]; CONWAYPOLDATA[106669]:=[ ,,,[159023745254,"JB"],]; CONWAYPOLDATA[106681]:=[ ,,,[247440498706,"JB"],]; CONWAYPOLDATA[106693]:=[ ,,,[22112017559,"JB"],]; CONWAYPOLDATA[106699]:=[ ,,,[88483026626,"JB"],]; CONWAYPOLDATA[106703]:=[ ,,,[41437363136,"JB"],]; CONWAYPOLDATA[106721]:=[ ,,,[52541309607,"JB"],]; CONWAYPOLDATA[106727]:=[ ,,,[42910444176,"JB"],]; CONWAYPOLDATA[106739]:=[ ,,,[21194843015,"JB"],]; CONWAYPOLDATA[106747]:=[ ,,,[121378170810,"JB"],]; CONWAYPOLDATA[106751]:=[ ,,,[77555989276,"JB"],]; CONWAYPOLDATA[106753]:=[ ,,,[146383449960,"JB"],]; CONWAYPOLDATA[106759]:=[ ,,,[102410065382,"JB"],]; CONWAYPOLDATA[106781]:=[ ,,,[56742889497,"JB"],]; CONWAYPOLDATA[106783]:=[ ,,,[147482272625,"JB"],]; CONWAYPOLDATA[106787]:=[ ,,,[8182981025,"JB"],]; CONWAYPOLDATA[106801]:=[ ,,,[167747204263,"JB"],]; CONWAYPOLDATA[106823]:=[ ,,,[45644186029,"JB"],]; CONWAYPOLDATA[106853]:=[ ,,,[17165400187,"JB"],]; CONWAYPOLDATA[106859]:=[ ,,,[86198880942,"JB"],]; CONWAYPOLDATA[106861]:=[ ,,,[55578512968,"JB"],]; CONWAYPOLDATA[106867]:=[ ,,,[34054986292,"JB"],]; CONWAYPOLDATA[106871]:=[ ,,,[30516479702,"JB"],]; CONWAYPOLDATA[106877]:=[ ,,,[20433493001,"JB"],]; CONWAYPOLDATA[106903]:=[ ,,,[45712578029,"JB"],]; CONWAYPOLDATA[106907]:=[ ,,,[134447098458,"JB"],]; CONWAYPOLDATA[106921]:=[ ,,,[122839077731,"JB"],]; CONWAYPOLDATA[106937]:=[ ,,,[76220309186,"JB"],]; CONWAYPOLDATA[106949]:=[ ,,,[21012270032,"JB"],]; CONWAYPOLDATA[106957]:=[ ,,,[239512981428,"JB"],]; CONWAYPOLDATA[106961]:=[ ,,,[86614985544,"JB"],]; CONWAYPOLDATA[106963]:=[ ,,,[63313538963,"JB"],]; CONWAYPOLDATA[106979]:=[ ,,,[77792133390,"JB"],]; CONWAYPOLDATA[106993]:=[ ,,,[213405028015,"JB"],]; CONWAYPOLDATA[107021]:=[ ,,,[109823665955,"JB"],]; CONWAYPOLDATA[107033]:=[ ,,,[112447692440,"JB"],]; CONWAYPOLDATA[107053]:=[ ,,,[227229520222,"JB"],]; CONWAYPOLDATA[107057]:=[ ,,,[6164235006,"JB"],]; CONWAYPOLDATA[107069]:=[ ,,,[22176131282,"JB"],]; CONWAYPOLDATA[107071]:=[ ,,,[43727689332,"JB"],]; CONWAYPOLDATA[107077]:=[ ,,,[103188605824,"JB"],]; CONWAYPOLDATA[107089]:=[ ,,,[10292109619,"JB"],]; CONWAYPOLDATA[107099]:=[ ,,,[112640302262,"JB"],]; CONWAYPOLDATA[107101]:=[ ,,,[149117257811,"JB"],]; CONWAYPOLDATA[107119]:=[ ,,,[79332224284,"JB"],]; CONWAYPOLDATA[107123]:=[ ,,,[54215164548,"JB"],]; CONWAYPOLDATA[107137]:=[ ,,,[178505455464,"JB"],]; CONWAYPOLDATA[107171]:=[ ,,,[33862499367,"JB"],]; CONWAYPOLDATA[107183]:=[ ,,,[53018606870,"JB"],]; CONWAYPOLDATA[107197]:=[ ,,,[181726571828,"JB"],]; CONWAYPOLDATA[107201]:=[ ,,,[88904254930,"JB"],]; CONWAYPOLDATA[107209]:=[ ,,,[168792958674,"JB"],]; CONWAYPOLDATA[107227]:=[ ,,,[64223075535,"JB"],]; CONWAYPOLDATA[107243]:=[ ,,,[156612100566,"JB"],]; CONWAYPOLDATA[107251]:=[ ,,,[31565041813,"JB"],]; CONWAYPOLDATA[107269]:=[ ,,,[89572082193,"JB"],]; CONWAYPOLDATA[107273]:=[ ,,,[20733403624,"JB"],]; CONWAYPOLDATA[107279]:=[ ,,,[41954027653,"JB"],]; CONWAYPOLDATA[107309]:=[ ,,,[77759427981,"JB"],]; CONWAYPOLDATA[107323]:=[ ,,,[31322324886,"JB"],]; CONWAYPOLDATA[107339]:=[ ,,,[51915580746,"JB"],]; CONWAYPOLDATA[107347]:=[ ,,,[99569924546,"JB"],]; CONWAYPOLDATA[107351]:=[ ,,,[66976074217,"JB"],]; CONWAYPOLDATA[107357]:=[ ,,,[44168065443,"JB"],]; CONWAYPOLDATA[107377]:=[ ,,,[102706959526,"JB"],]; CONWAYPOLDATA[107441]:=[ ,,,[11542279192,"JB"],]; CONWAYPOLDATA[107449]:=[ ,,,[9367833623,"JB"],]; CONWAYPOLDATA[107453]:=[ ,,,[114722625264,"JB"],]; CONWAYPOLDATA[107467]:=[ ,,,[34561172268,"JB"],]; CONWAYPOLDATA[107473]:=[ ,,,[183256081333,"JB"],]; CONWAYPOLDATA[107507]:=[ ,,,[103348199214,"JB"],]; CONWAYPOLDATA[107509]:=[ ,,,[80906865537,"JB"],]; CONWAYPOLDATA[107563]:=[ ,,,[125541725209,"JB"],]; CONWAYPOLDATA[107581]:=[ ,,,[87178048190,"JB"],]; CONWAYPOLDATA[107599]:=[ ,,,[43016573817,"JB"],]; CONWAYPOLDATA[107603]:=[ ,,,[137485967147,"JB"],]; CONWAYPOLDATA[107609]:=[ ,,,[54270662191,"JB"],]; CONWAYPOLDATA[107621]:=[ ,,,[180816409764,"JB"],]; CONWAYPOLDATA[107641]:=[ ,,,[148913250436,"JB"],]; CONWAYPOLDATA[107647]:=[ ,,,[67857547042,"JB"],]; CONWAYPOLDATA[107671]:=[ ,,,[125711276056,"JB"],]; CONWAYPOLDATA[107687]:=[ ,,,[87877222546,"JB"],]; CONWAYPOLDATA[107693]:=[ ,,,[29697960147,"JB"],]; CONWAYPOLDATA[107699]:=[ ,,,[102277216944,"JB"],]; CONWAYPOLDATA[107713]:=[ ,,,[242905740570,"JB"],]; CONWAYPOLDATA[107717]:=[ ,,,[79922674775,"JB"],]; CONWAYPOLDATA[107719]:=[ ,,,[33634396001,"JB"],]; CONWAYPOLDATA[107741]:=[ ,,,[58040184444,"JB"],]; CONWAYPOLDATA[107747]:=[ ,,,[104483989854,"JB"],]; CONWAYPOLDATA[107761]:=[ ,,,[11533336561,"JB"],]; CONWAYPOLDATA[107773]:=[ ,,,[80675203520,"JB"],]; CONWAYPOLDATA[107777]:=[ ,,,[91642028664,"JB"],]; CONWAYPOLDATA[107791]:=[ ,,,[42657964880,"JB"],]; CONWAYPOLDATA[107827]:=[ ,,,[41416135051,"JB"],]; CONWAYPOLDATA[107837]:=[ ,,,[76648059351,"JB"],]; CONWAYPOLDATA[107839]:=[ ,,,[66539898185,"JB"],]; CONWAYPOLDATA[107843]:=[ ,,,[10743319662,"JB"],]; CONWAYPOLDATA[107857]:=[ ,,,[149207324522,"JB"],]; CONWAYPOLDATA[107867]:=[ ,,,[215965590451,"JB"],]; CONWAYPOLDATA[107873]:=[ ,,,[205140142389,"JB"],]; CONWAYPOLDATA[107881]:=[ ,,,[174307107558,"JB"],]; CONWAYPOLDATA[107897]:=[ ,,,[29144058673,"JB"],]; CONWAYPOLDATA[107903]:=[ ,,,[112443881954,"JB"],]; CONWAYPOLDATA[107923]:=[ ,,,[104703548989,"JB"],]; CONWAYPOLDATA[107927]:=[ ,,,[46592517613,"JB"],]; CONWAYPOLDATA[107941]:=[ ,,,[123489145469,"JB"],]; CONWAYPOLDATA[107951]:=[ ,,,[46185108141,"JB"],]; CONWAYPOLDATA[107971]:=[ ,,,[80552304408,"JB"],]; CONWAYPOLDATA[107981]:=[ ,,,[57083183823,"JB"],]; CONWAYPOLDATA[107999]:=[ ,,,[76364148931,"JB"],]; CONWAYPOLDATA[108007]:=[ ,,,[32626538557,"JB"],]; CONWAYPOLDATA[108011]:=[ ,,,[17626315097,"JB"],]; CONWAYPOLDATA[108013]:=[ ,,,[101486530507,"JB"],]; CONWAYPOLDATA[108023]:=[ ,,,[90086753062,"JB"],]; CONWAYPOLDATA[108037]:=[ ,,,[265441831263,"JB"],]; CONWAYPOLDATA[108041]:=[ ,,,[127905526307,"JB"],]; CONWAYPOLDATA[108061]:=[ ,,,[124420030609,"JB"],]; CONWAYPOLDATA[108079]:=[ ,,,[58404918892,"JB"],]; CONWAYPOLDATA[108089]:=[ ,,,[31573661618,"JB"],]; CONWAYPOLDATA[108107]:=[ ,,,[151676283142,"JB"],]; CONWAYPOLDATA[108109]:=[ ,,,[76915769687,"JB"],]; CONWAYPOLDATA[108127]:=[ ,,,[91279515882,"JB"],]; CONWAYPOLDATA[108131]:=[ ,,,[6984397558,"JB"],]; CONWAYPOLDATA[108139]:=[ ,,,[78539301061,"JB"],]; CONWAYPOLDATA[108161]:=[ ,,,[11697503992,"JB"],]; CONWAYPOLDATA[108179]:=[ ,,,[104393708613,"JB"],]; CONWAYPOLDATA[108187]:=[ ,,,[101390909039,"JB"],]; CONWAYPOLDATA[108191]:=[ ,,,[46577199232,"JB"],]; CONWAYPOLDATA[108193]:=[ ,,,[77801802699,"JB"],]; CONWAYPOLDATA[108203]:=[ ,,,[100650863414,"JB"],]; CONWAYPOLDATA[108211]:=[ ,,,[64868057852,"JB"],]; CONWAYPOLDATA[108217]:=[ ,,,[148263241940,"JB"],]; CONWAYPOLDATA[108223]:=[ ,,,[42968535254,"JB"],]; CONWAYPOLDATA[108233]:=[ ,,,[18092769448,"JB"],]; CONWAYPOLDATA[108247]:=[ ,,,[34561643398,"JB"],]; CONWAYPOLDATA[108263]:=[ ,,,[103775065603,"JB"],]; CONWAYPOLDATA[108271]:=[ ,,,[77479377229,"JB"],]; CONWAYPOLDATA[108287]:=[ ,,,[115031980661,"JB"],]; CONWAYPOLDATA[108289]:=[ ,,,[207477825603,"JB"],]; CONWAYPOLDATA[108293]:=[ ,,,[58575142237,"JB"],]; CONWAYPOLDATA[108301]:=[ ,,,[93260373728,"JB"],]; CONWAYPOLDATA[108343]:=[ ,,,[81238181635,"JB"],]; CONWAYPOLDATA[108347]:=[ ,,,[10856802790,"JB"],]; CONWAYPOLDATA[108359]:=[ ,,,[93766076763,"JB"],]; CONWAYPOLDATA[108377]:=[ ,,,[93529025872,"JB"],]; CONWAYPOLDATA[108379]:=[ ,,,[30621294283,"JB"],]; CONWAYPOLDATA[108401]:=[ ,,,[54971556316,"JB"],]; CONWAYPOLDATA[108413]:=[ ,,,[30133284939,"JB"],]; CONWAYPOLDATA[108421]:=[ ,,,[20237863877,"JB"],]; CONWAYPOLDATA[108439]:=[ ,,,[79629468678,"JB"],]; CONWAYPOLDATA[108457]:=[ ,,,[195441357774,"JB"],]; CONWAYPOLDATA[108461]:=[ ,,,[53560102561,"JB"],]; CONWAYPOLDATA[108463]:=[ ,,,[47056455629,"JB"],]; CONWAYPOLDATA[108497]:=[ ,,,[150061115733,"JB"],]; CONWAYPOLDATA[108499]:=[ ,,,[33563080674,"JB"],]; CONWAYPOLDATA[108503]:=[ ,,,[30442361206,"JB"],]; CONWAYPOLDATA[108517]:=[ ,,,[80381146313,"JB"],]; CONWAYPOLDATA[108529]:=[ ,,,[173665935243,"JB"],]; CONWAYPOLDATA[108533]:=[ ,,,[45167744480,"JB"],]; CONWAYPOLDATA[108541]:=[ ,,,[124865892025,"JB"],]; CONWAYPOLDATA[108553]:=[ ,,,[304158992825,"JB"],]; CONWAYPOLDATA[108557]:=[ ,,,[81787820815,"JB"],]; CONWAYPOLDATA[108571]:=[ ,,,[45396249378,"JB"],]; CONWAYPOLDATA[108587]:=[ ,,,[8827688754,"JB"],]; CONWAYPOLDATA[108631]:=[ ,,,[45494662806,"JB"],]; CONWAYPOLDATA[108637]:=[ ,,,[183520701389,"JB"],]; CONWAYPOLDATA[108643]:=[ ,,,[82622241004,"JB"],]; CONWAYPOLDATA[108649]:=[ ,,,[269233851746,"JB"],]; CONWAYPOLDATA[108677]:=[ ,,,[150640776043,"JB"],]; CONWAYPOLDATA[108707]:=[ ,,,[8763523514,"JB"],]; CONWAYPOLDATA[108709]:=[ ,,,[103384324477,"JB"],]; CONWAYPOLDATA[108727]:=[ ,,,[59107367740,"JB"],]; CONWAYPOLDATA[108739]:=[ ,,,[101545153979,"JB"],]; CONWAYPOLDATA[108751]:=[ ,,,[44106034322,"JB"],]; CONWAYPOLDATA[108761]:=[ ,,,[11827649992,"JB"],]; CONWAYPOLDATA[108769]:=[ ,,,[197326653196,"JB"],]; CONWAYPOLDATA[108791]:=[ ,,,[30032190721,"JB"],]; CONWAYPOLDATA[108793]:=[ ,,,[102349734580,"JB"],]; CONWAYPOLDATA[108799]:=[ ,,,[69431713841,"JB"],]; CONWAYPOLDATA[108803]:=[ ,,,[101004871386,"JB"],]; CONWAYPOLDATA[108821]:=[ ,,,[7490802358,"JB"],]; CONWAYPOLDATA[108827]:=[ ,,,[129067516078,"JB"],]; CONWAYPOLDATA[108863]:=[ ,,,[41799799526,"JB"],]; CONWAYPOLDATA[108869]:=[ ,,,[47143434203,"JB"],]; CONWAYPOLDATA[108877]:=[ ,,,[46783249255,"JB"],]; CONWAYPOLDATA[108881]:=[ ,,,[31337040613,"JB"],]; CONWAYPOLDATA[108883]:=[ ,,,[33749374682,"JB"],]; CONWAYPOLDATA[108887]:=[ ,,,[66739455593,"JB"],]; CONWAYPOLDATA[108893]:=[ ,,,[93443587842,"JB"],]; CONWAYPOLDATA[108907]:=[ ,,,[6847200916,"JB"],]; CONWAYPOLDATA[108917]:=[ ,,,[341004205373,"JB"],]; CONWAYPOLDATA[108923]:=[ ,,,[89279717259,"JB"],]; CONWAYPOLDATA[108929]:=[ ,,,[31432116527,"JB"],]; CONWAYPOLDATA[108943]:=[ ,,,[65782833807,"JB"],]; CONWAYPOLDATA[108947]:=[ ,,,[32225977867,"JB"],]; CONWAYPOLDATA[108949]:=[ ,,,[127514563296,"JB"],]; CONWAYPOLDATA[108959]:=[ ,,,[90920292766,"JB"],]; CONWAYPOLDATA[108961]:=[ ,,,[176022899794,"JB"],]; CONWAYPOLDATA[108967]:=[ ,,,[44428679045,"JB"],]; CONWAYPOLDATA[108971]:=[ ,,,[53542464968,"JB"],]; CONWAYPOLDATA[108991]:=[ ,,,[31403140872,"JB"],]; CONWAYPOLDATA[109001]:=[ ,,,[11879909992,"JB"],]; CONWAYPOLDATA[109013]:=[ ,,,[94406021093,"JB"],]; CONWAYPOLDATA[109037]:=[ ,,,[23350600663,"JB"],]; CONWAYPOLDATA[109049]:=[ ,,,[11890375816,"JB"],]; CONWAYPOLDATA[109063]:=[ ,,,[43042149208,"JB"],]; CONWAYPOLDATA[109073]:=[ ,,,[20968411669,"JB"],]; CONWAYPOLDATA[109097]:=[ ,,,[81630302895,"JB"],]; CONWAYPOLDATA[109103]:=[ ,,,[92636520627,"JB"],]; CONWAYPOLDATA[109111]:=[ ,,,[77512563514,"JB"],]; CONWAYPOLDATA[109121]:=[ ,,,[11906083192,"JB"],]; CONWAYPOLDATA[109133]:=[ ,,,[113669113147,"JB"],]; CONWAYPOLDATA[109139]:=[ ,,,[101994542784,"JB"],]; CONWAYPOLDATA[109141]:=[ ,,,[151666808383,"JB"],]; CONWAYPOLDATA[109147]:=[ ,,,[34805122804,"JB"],]; CONWAYPOLDATA[109159]:=[ ,,,[58447112535,"JB"],]; CONWAYPOLDATA[109169]:=[ ,,,[106351893958,"JB"],]; CONWAYPOLDATA[109171]:=[ ,,,[44841005713,"JB"],]; CONWAYPOLDATA[109199]:=[ ,,,[70099970472,"JB"],]; CONWAYPOLDATA[109201]:=[ ,,,[459228206965,"JB"],]; CONWAYPOLDATA[109211]:=[ ,,,[54440482185,"JB"],]; CONWAYPOLDATA[109229]:=[ ,,,[21008450488,"JB"],]; CONWAYPOLDATA[109253]:=[ ,,,[282017500228,"JB"],]; CONWAYPOLDATA[109267]:=[ ,,,[106153218303,"JB"],]; CONWAYPOLDATA[109279]:=[ ,,,[42208139529,"JB"],]; CONWAYPOLDATA[109297]:=[ ,,,[213950079772,"JB"],]; CONWAYPOLDATA[109303]:=[ ,,,[105972537593,"JB"],]; CONWAYPOLDATA[109313]:=[ ,,,[82885489123,"JB"],]; CONWAYPOLDATA[109321]:=[ ,,,[246346346481,"JB"],]; CONWAYPOLDATA[109331]:=[ ,,,[56762359251,"JB"],]; CONWAYPOLDATA[109357]:=[ ,,,[42615985483,"JB"],]; CONWAYPOLDATA[109363]:=[ ,,,[11840294561,"JB"],]; CONWAYPOLDATA[109367]:=[ ,,,[45068062732,"JB"],]; CONWAYPOLDATA[109379]:=[ ,,,[68985444681,"JB"],]; CONWAYPOLDATA[109387]:=[ ,,,[78646955875,"JB"],]; CONWAYPOLDATA[109391]:=[ ,,,[59830969893,"JB"],]; CONWAYPOLDATA[109397]:=[ ,,,[211618213184,"JB"],]; CONWAYPOLDATA[109423]:=[ ,,,[179151712523,"JB"],]; CONWAYPOLDATA[109433]:=[ ,,,[117735025115,"JB"],]; CONWAYPOLDATA[109441]:=[ ,,,[102112940095,"JB"],]; CONWAYPOLDATA[109451]:=[ ,,,[31850350453,"JB"],]; CONWAYPOLDATA[109453]:=[ ,,,[80121018891,"JB"],]; CONWAYPOLDATA[109469]:=[ ,,,[42353884509,"JB"],]; CONWAYPOLDATA[109471]:=[ ,,,[34393817725,"JB"],]; CONWAYPOLDATA[109481]:=[ ,,,[34617454279,"JB"],]; CONWAYPOLDATA[109507]:=[ ,,,[31029575001,"JB"],]; CONWAYPOLDATA[109517]:=[ ,,,[8364798945,"JB"],]; CONWAYPOLDATA[109519]:=[ ,,,[46909835197,"JB"],]; CONWAYPOLDATA[109537]:=[ ,,,[179974110633,"JB"],]; CONWAYPOLDATA[109541]:=[ ,,,[114134273214,"JB"],]; CONWAYPOLDATA[109547]:=[ ,,,[91409631853,"JB"],]; CONWAYPOLDATA[109567]:=[ ,,,[35874317578,"JB"],]; CONWAYPOLDATA[109579]:=[ ,,,[104113856956,"JB"],]; CONWAYPOLDATA[109583]:=[ ,,,[33943005506,"JB"],]; CONWAYPOLDATA[109589]:=[ ,,,[11566899774,"JB"],]; CONWAYPOLDATA[109597]:=[ ,,,[90783469388,"JB"],]; CONWAYPOLDATA[109609]:=[ ,,,[200659442570,"JB"],]; CONWAYPOLDATA[109619]:=[ ,,,[92537728946,"JB"],]; CONWAYPOLDATA[109621]:=[ ,,,[92295291339,"JB"],]; CONWAYPOLDATA[109639]:=[ ,,,[60103113052,"JB"],]; CONWAYPOLDATA[109661]:=[ ,,,[60127235964,"JB"],]; CONWAYPOLDATA[109663]:=[ ,,,[71493147916,"JB"],]; CONWAYPOLDATA[109673]:=[ ,,,[7984523422,"JB"],]; CONWAYPOLDATA[109717]:=[ ,,,[126609797344,"JB"],]; CONWAYPOLDATA[109721]:=[ ,,,[94254288959,"JB"],]; CONWAYPOLDATA[109741]:=[ ,,,[83060768082,"JB"],]; CONWAYPOLDATA[109751]:=[ ,,,[84138848145,"JB"],]; CONWAYPOLDATA[109789]:=[ ,,,[150735905450,"JB"],]; CONWAYPOLDATA[109793]:=[ ,,,[8701424632,"JB"],]; CONWAYPOLDATA[109807]:=[ ,,,[48229869773,"JB"],]; CONWAYPOLDATA[109819]:=[ ,,,[46043372857,"JB"],]; CONWAYPOLDATA[109829]:=[ ,,,[47750573990,"JB"],]; CONWAYPOLDATA[109831]:=[ ,,,[47511682462,"JB"],]; CONWAYPOLDATA[109841]:=[ ,,,[57170043683,"JB"],]; CONWAYPOLDATA[109843]:=[ ,,,[93011427583,"JB"],]; CONWAYPOLDATA[109847]:=[ ,,,[176133952461,"JB"],]; CONWAYPOLDATA[109849]:=[ ,,,[299680924340,"JB"],]; CONWAYPOLDATA[109859]:=[ ,,,[46944069010,"JB"],]; CONWAYPOLDATA[109873]:=[ ,,,[6168599854,"JB"],]; CONWAYPOLDATA[109883]:=[ ,,,[108170363564,"JB"],]; CONWAYPOLDATA[109891]:=[ ,,,[81610880825,"JB"],]; CONWAYPOLDATA[109897]:=[ ,,,[153631939821,"JB"],]; CONWAYPOLDATA[109903]:=[ ,,,[33082781257,"JB"],]; CONWAYPOLDATA[109913]:=[ ,,,[35504756741,"JB"],]; CONWAYPOLDATA[109919]:=[ ,,,[48327866909,"JB"],]; CONWAYPOLDATA[109937]:=[ ,,,[71042938458,"JB"],]; CONWAYPOLDATA[109943]:=[ ,,,[48349413229,"JB"],]; CONWAYPOLDATA[109961]:=[ ,,,[12090101992,"JB"],]; CONWAYPOLDATA[109987]:=[ ,,,[47347863685,"JB"],]; CONWAYPOLYNOMIALSINFO.conwdat3 := true; gap-4r6p5/lib/padics.gi0000644000175000017500000011026112172557252013474 0ustar billbill############################################################################# ## #W padics.gi GAP Library Jens Hollmann ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the implementation part of the padic numbers. ## ############################################################################# ## #F PrintPadicExpansion( , , , ) ## ## PrintPadicsExpansion prints a pure p-adic number x, which is given as ## and such that x = ^* as the p-adic ## expansion in the pure p-adic numbers with "digits". ## may be divisible by . Each "digit" ranges from 0 to -1. ## If a "digit" has more than one decimal digit it is embraced in single ## quotes. ## ## For Example: ## 153.0(17) is 1*17^(-2) + 5*17^(-1) + 3*17^0 and ## '15'3.0(17) is 15*17^(-1) + 3*17^0 ## PrintPadicExpansion := function( ppower, int, prime, precision ) local pos, flag, z, k, r; if int = 0 then Print( "0" ); else # might be divisible by while int mod prime = 0 do int := int / prime; ppower := ppower + 1; od; if ppower > 0 then # leading zeros for pos in [0..ppower-1] do if pos = 1 then Print( "." ); fi; Print( "0" ); od; fi; pos := ppower; flag := false; # print the z := int; k := 1; r := z mod prime; while (pos < 1) or ((k<=precision) and (z<>0)) do if pos = 1 then Print( "." ); fi; if prime >= 10 then if flag then Print( r, "'" ); else Print( "'" , r, "'" ); fi; flag := true; else Print( r ); flag := false; fi; z := (z - r) / prime; r := z mod prime; k := k + 1; pos := pos + 1; od; fi; Print( "(", prime, ")" ); end; ############################################################################# ## #F PadicExpansionByRat( , , ) ## ## PadicExpansionByRat takes a rational and returns a list [ppart, erg], ## such that is ^ppart*erg in the pure p-adic numbers over ## with "digits". ## ## For Example: ## PadicExpansionByRat(5, 3, 4) -> [0, 5] = 12.00(3) ## PadicExpansionByRat(1/2, 3, 4) -> [0, 41] = 2.111(3) ## PadicExpansionByRat := function( a, prime, precision ) local c, flag, ppart, z, step, erg, ppot, l, digit; if a = 0 then c := [0,0]; else # extract the p-part (num and den of rationals are coprime) flag := false; ppart := 0; if NumeratorRat(a) mod prime = 0 then z := NumeratorRat(a) / prime; step := 1; flag := true; fi; if DenominatorRat(a) mod prime = 0 then z := DenominatorRat(a) / prime; step := -1; flag := true; fi; if flag then # extract the -part ppart := step; while z mod prime = 0 do z := z / prime; ppart := ppart + step; od; fi; a := a / prime^ppart; erg := 0; ppot := 1; l := 1; while( l<= precision) and (a <> 0) do digit := a mod prime; erg := erg + digit * ppot; a := (a - digit) / prime; ppot := ppot * prime; l := l + 1; od; c := [ppart, erg]; fi; return c; end; ############################################################################# ## #F MultMatrixPadicNumbersByCoefficientsList( ) ## ## MultMatrix...List takes the coeff.-list of a polynomial and ## returns a (n x 2*n-1)-matrix if n is the degree of the polynomial ## i.e. the length of minus 1. If you have an extension L of a field ## K by a given polynomial f (i.e. L = K[X]/(f(X))) with coeff.-list , ## than the i-th row of the returned matrix gives the coeff.-presentation of ## X^(i-1) in the basis {X^0, ..., X^n-1} of L. ## ## For example: ## Mult...List( [-1,5,-2,1] ) -> [1 ] ## so the polynomial is [ 1 ] ## X^3-2X^2+5X-1 [ 1] ## [1 -5 2] ## [2 -9 -1] ## ## So multiplying two elements of L (polynomials in X) is simply multiplying ## the polynomials and then multiplying the resulting coeff.-list with the ## matrix and get the coeff.-presentation of the result in the right basis ## of L. ## MultMatrixPadicNumbersByCoefficientsList := function ( list ) local n, F, zero, one, mat, i, j; n := Length(list) - 1; F := FamilyObj(list[1]); zero := Zero(F); one := One(F); if n <= 1 then return [[one]]; fi; # prepare a zero-matrix with ones on the main diagonale: mat := [ ]; for i in [1..2*n-1] do mat[i] := [ ]; for j in [1..n] do mat[i][j] := zero; od; od; for i in [1..n] do mat[i][i] := one; od; # the n+1-th row is simple: for j in [1..n] do mat[n+1][j] := - list[j]; od; # the rest is a little more complex. Regard the fact, that # x^i is x*x^(i-1) and the coeff.presentation of x^(i-1) is # already known. for i in [n+2..2*n-1] do mat[i] := ShiftedCoeffs(mat[i-1],1) + mat[i-1][n] * mat[n+1]; od; return mat; end; ############################################################################# ## #F StructureConstantsPadicNumbers( , ) ## ## An extended p-adic field is given by two polynomials. One for the ## ramified part g with degree and one for the unramified part h with ## degree . The extended p-adic field is then the extension of Q_p i.e. L ## = Q_p[x,y]/(g(y),h(x)). ## ## L has a basis in x^i*y^j. This basis is ordered as follows: ## {1, x, x^2, ..., y, x y, x^2 y, ..., y^2, x y^2, x^2 y^2, ...} ## ## Let B_i be the i-th basiselement. StructureConstantsPadicNumbers takes ## the two degrees and and returns a (n x n)-matrix (n = * ). ## In this matrix stands at position (i,j) the index of the row of the ## multiplication-matrix that gives the coeff.-presentation of B_i * B_j The ## mult.-matrix of an extended p-adic field is given as the ## Kronecker-product of the mult.-matrices of the two polynomials returned ## by MultMatrixPadicNumbersByCoefficientsList. (see in ## PadicExtensionNumberFamily) ## ## So I get the structure-constants m_ijk if ## B_i*B_j = SUM(k=1,...,n) m_ijk B_k ## simply by M[ B[i,j], k]. ## ## M is the mult.-matrix and B is the matrix returned by this function. ## StructureConstantsPadicNumbers := function( e, f ) local mat, i, j, a1, a2, b1, b2; # there are * basis-elements and according to the above ordering # B_i is simply x^((i-1) mod f)*y^((i-1) div f) mat := []; for i in [1..e*f] do mat[i] := []; for j in [1..e*f] do a1 := (i-1) mod f; a2 := (j-1) mod f; b1 := QuoInt(i-1, f); b2 := QuoInt(j-1, f); mat[i][j] := (a1+a2) + (b1+b2)*(2*f-1) + 1; od; od; return mat; end; ############################################################################# ## #M ShiftedPadicNumber( , ) ## ## ShiftedPadicNumber takes a p-adic number and an integer ## and returns the p-adic number c, that is * p^. The ## is just added to the p-part. ## InstallMethod( ShiftedPadicNumber, true, [ IsPadicNumber, IsInt ], 0, function( x, shift ) local fam, c; fam := FamilyObj(x); c := Immutable( [ x![1]+shift, x![2] ] ); return Objectify( fam!.defaultType, c ); end ); ############################################################################# ## #M * ## InstallMethod( \*, true, [ IsPadicNumber, IsRat ], 0, function( a, b ) local fam; fam := FamilyObj( a ); return a * PadicNumber( fam, b ); end ); ############################################################################# ## #M * ## InstallMethod( \*, true, [ IsRat, IsPadicNumber ], 0, function( a, b ) local fam; fam := FamilyObj( b ); return PadicNumber( fam, a ) * b; end ); ############################################################################# ## #M * ## InstallMethod( \*, true, [ IsPadicNumberList, IsRat ], 0, function( a, b ) b := PadicNumber( FamilyObj(a[1]), b ); return List( a, x -> x * b ); end ); ############################################################################# ## #M * ## InstallMethod( \*, true, [ IsRat, IsPadicNumberList ], 0, function( a, b ) a := PadicNumber( FamilyObj(b[1]), a ); return List( b, x -> a * x ); end ); ############################################################################# ## #M ZeroOp( ) ## InstallMethod( ZeroOp, "for a p-adic number", true, [ IsPadicNumber ], 0, function( padic ) return Zero( FamilyObj( padic ) ); end ); ############################################################################# ## #M OneOp( ) ## InstallMethod( OneOp, "for a p-adic number", true, [ IsPadicNumber ], 0, function( padic ) return One( FamilyObj( padic ) ); end ); ############################################################################# ## #M PurePadicNumberFamily(

, ) ## ## PurePadicNumberFamily returns the family of pure p-adic numbers over the ## prime

with "digits". For the representation of pure ## p-adic numbers see "PadicNumber" below. ## InstallValue(PADICS_FAMILIES,[]); InstallGlobalFunction( PurePadicNumberFamily, function( p, precision ) local str, fam; if not IsPrimeInt( p ) then Error( "

must be a prime" ); fi; if (not IsInt( precision )) or (precision < 0) then Error( " must be a positive integer" ); fi; if not IsBound(PADICS_FAMILIES[p]) then PADICS_FAMILIES[p] := []; fi; if not IsBound(PADICS_FAMILIES[p][precision]) then str := "PurePadicNumberFamily("; Append( str, String(p) ); Append( str, "," ); Append( str, String(precision) ); Append( str, ")" ); fam := NewFamily( str, IsPurePadicNumber ); fam!.prime:= p; fam!.precision:= precision; fam!.modulus:= p^precision; fam!.printPadicSeries:= true; fam!.defaultType := NewType( fam, IsPurePadicNumber ); PADICS_FAMILIES[p][precision] := fam; fi; return PADICS_FAMILIES[p][precision]; end ); ############################################################################# ## #M PadicNumber( , ) ## ## Make a pure p-adic number out of a list. A pure p-adic number is ## represented as a list of length 2 such that the number is p^list[1] * ## list[2]. It is easily guaranteed that list[2] is never divisible by the ## prime p. By that we have always maximum precision. ## InstallMethod( PadicNumber, "for a pure p-adic family and a list", true, [ IsPurePadicNumberFamily, IsCyclotomicCollection ], 0, function( fam, list ) if Length(list) <> 2 then Error( " must have length 2" ); elif not IsInt(list[1]) then Error( "[1] must be an integer" ); elif not IsInt(list[2]) or list[2] < 0 or list[2] >= fam!.modulus then Error( "[2] must be an integer in {0..p^precision}" ); fi; return Objectify( fam!.defaultType, Immutable(list) ); end ); ############################################################################# ## #M PadicNumber( , ) ## ## Make a pure p-adic number out of a rational. ## InstallMethod( PadicNumber, "for a pure p-adic family and a rational", true, [ IsPurePadicNumberFamily, IsRat ], 0, function( fam, rat ) local c; c := Immutable( PadicExpansionByRat( rat, fam!.prime, fam!.precision ) ); return Objectify( fam!.defaultType, c ); end ); ############################################################################# ## #M PrintObj( ) ## InstallMethod( PrintObj, true, [ IsPurePadicNumber ], 0, function ( x ) local fam; fam := FamilyObj(x); # printPadicSeries is just a boolean variable. Handy for checking # what REALLY happens if set to false. if fam!.printPadicSeries then PrintPadicExpansion( x![1], x![2], fam!.prime, fam!.precision ); else Print( fam!.prime, "^", x![1], "*", x![2], "(" , fam!.prime , ")" ); fi; end ); ############################################################################# ## #M Random( ) ## ## This is just something that actually returns a pure p-adic number. The ## range of the p-part is not totally covered as it is infinity. But you ## may get two pure p-adic numbers that have no "digit" in common, so by ## adding them, one of the two vanishes. ## InstallOtherMethod( Random, true, [ IsPurePadicNumberFamily ], 0, function ( fam ) local c; c := []; c[1] := Random( -fam!.precision, fam!.precision ); c[2] := Random( 0, fam!.modulus-1 ); while c[2] mod fam!.prime = 0 do c[1] := c[1] + 1; c[2] := c[2] / fam!.prime; od; return Objectify( fam!.defaultType, Immutable( c ) ); end ); ############################################################################# ## #M Zero( ) ## InstallOtherMethod( Zero, true, [ IsPurePadicNumberFamily ], 0, function ( fam ) return PadicNumber( fam, [0,0] ); end ); ############################################################################# ## #M IsZero( ) ## InstallMethod( IsZero, true, [ IsPurePadicNumber ], 0, function ( x ) return x![2] = 0; end ); ######################################################################## ## #M One( ) ## InstallOtherMethod( One, true, [ IsPurePadicNumberFamily ], 0, function ( fam ) return PadicNumber( fam, [0,1] ); end ); ############################################################################# ## #M Valuation( ## ## The Valuation is the p-part of the p-adic number. ## InstallMethod( Valuation, true, [ IsPurePadicNumber ], 0, function( x ) if IsZero(x) then return infinity; fi; return x![1]; end ); ############################################################################# ## #M AdditiveInverseOp( ) ## InstallMethod( AdditiveInverseOp, true, [ IsPurePadicNumber ], 0, function( a ) local fam, c; fam := FamilyObj( a ); c := [ a![1], -a![2] mod fam!.modulus]; return Objectify( fam!.defaultType, Immutable( c ) ); end ); ############################################################################# ## #M InverseOp( ) ## InstallMethod( InverseOp, true, [ IsPurePadicNumber ], 0, function( a ) local fam, c; if IsZero(a) then Error("division by zero"); fi; fam:= FamilyObj( a ); c:= [ -a![1] , 1/a![2] mod fam!.modulus ]; return Objectify( fam!.defaultType, Immutable( c ) ); end ); ############################################################################# ## #M + ## InstallMethod( \+, IsIdenticalObj, [ IsPurePadicNumber, IsPurePadicNumber ], 0, function( a, b ) local fam, c, r; # if or is zero, return the other one if IsZero(a) then return b; fi; if IsZero(b) then return a; fi; fam:= FamilyObj( a ); # different valuation: c[2] is NOT divisible by p! if a![1] < b![1] then c := [ a![1], (a![2]+fam!.prime^(b![1]-a![1])*b![2]) mod fam!.modulus ]; # equal valuation: c[2] MAY BE divisible by p! So check that. elif a![1] = b![1] then c := []; c[1] := a![1]; c[2] := (a![2] + b![2]) mod fam!.modulus; # c[2] might be divisible by p r := c[2] mod fam!.prime; while (r=0) and (c[2]>1) do c[1] := c[1] + 1; c[2] := c[2] / fam!.prime; r := c[2] mod fam!.prime; od; # different valuation: again c[2] is NOT divisible by p! else c:= [ b![1], (fam!.prime^(a![1]-b![1])*a![2]+b![2]) mod fam!.modulus ]; fi; return Objectify( fam!.defaultType, Immutable( c ) ); end ); ############################################################################# ## #M * ## InstallMethod( \*, IsIdenticalObj, [ IsPurePadicNumber, IsPurePadicNumber ], 0, function( a, b ) local fam, c; fam:= FamilyObj( a ); if IsZero(a) then c:= [0, 0]; elif IsZero(b) then c:= [0, 0]; else c:= [ a![1]+b![1] , a![2]*b![2] mod fam!.modulus ]; fi; return Objectify( fam!.defaultType, Immutable( c ) ); end ); ############################################################################# ## #M / ## InstallMethod( \/, IsIdenticalObj, [ IsPurePadicNumber, IsPurePadicNumber ], 0, function( a, b ) local fam, c; if IsZero(b) then Error("division by zero"); fi; fam:= FamilyObj( a ); c:= [ a![1]-b![1] , a![2]/b![2] mod fam!.modulus ]; return Objectify( fam!.defaultType, Immutable( c ) ); end ); ############################################################################# ## #M = ## InstallMethod( \=, IsIdenticalObj, [ IsPurePadicNumber, IsPurePadicNumber ], 0, function( a, b ) return (a![1] = b![1]) and (a![2] = b![2]); end ); ############################################################################# ## #M < ## ## This is just something to keep GAP quiet ## InstallMethod( \<, IsIdenticalObj, [ IsPurePadicNumber, IsPurePadicNumber ], 0, function( a, b ) if a![1] = b![1] then return a![2] < b![2]; else return a![1] < b![1]; fi; end ); ############################################################################# ## #M PadicExtensionNumberFamily(

, , , ) ## ## An extended p-adic field L is given by two polynomials h and g with ## coeff.-lists (for the unramified part) and (for the ## ramified part). Then L is Q_p[x,y]/(h(x),g(y)). This function takes the ## prime number

and the two coeff.-lists and for the two ## polynomials. It is not checked BUT should be a cyclotomic ## polynomial and should be an Eisenstein-polynomial or [1,1]. Every ## number out of L is represented as a coeff.-list for the basis ## {1,x,x^2,...,y,xy,x^2y,...} of L. is the number of "digits" ## that all the coeff. have. ## InstallGlobalFunction( PadicExtensionNumberFamily, function( p, precision, unram, ram ) local str, fam, yem1; if not IsPrimeInt( p ) then Error( "

must be a prime" ); fi; if (not IsInt( precision )) or (precision < 0) then Error( " must be a positive integer" ); fi; str := "PadicExtensionNumberFamily("; Append( str, String(p) ); Append( str, "," ); Append( str, String(precision) ); Append( str, ",...)" ); fam := NewFamily( str, IsPadicExtensionNumber ); fam!.defaultType := NewType( fam, IsPadicExtensionNumber ); fam!.prime := p; fam!.precision := precision; fam!.modulus := p^precision; fam!.unramified := unram; fam!.f := Length(unram)-1; fam!.ramified := ram; fam!.e := Length(ram)-1; fam!.n := fam!.e * fam!.f; fam!.M := KroneckerProduct( MultMatrixPadicNumbersByCoefficientsList(ram), MultMatrixPadicNumbersByCoefficientsList(unram) ); fam!.B := StructureConstantsPadicNumbers(fam!.e, fam!.f); yem1 := List( [1..fam!.n], i->0 ); yem1[ (fam!.e-1) * fam!.f + 1 ] := 1; fam!.yem1 := Objectify( fam!.defaultType, [0, yem1] ); fam!.printPadicSeries := true; return fam; end ); ############################################################################# ## ## General comment: In PadicExtensionNumberFamily you give the two ## polynomials, that define the extension of Q_p. You have to care for ## yourself, that these polynomials are really irreducible over Q_p! Try ## PadicExtensionNumberFamily(3, 4, [1,1,1], [1,1]) for example. You think ## this is ok? It is not, because x^2+x+1 is NOT irreducible over Q_p. The ## result being, that you get non-invertible extended p-adic numbers. So, ## if that happens, check your polynomials! ## ############################################################################# ## #M PadicNumber( , ) ## ## Make an extended p-adic number out of a list. An extended p-adic number ## is represented as a list L of length 2. ## ## L[2] is the list of coeff. for the Basis {1,..,x^(f-1)*y^(e-1)} of the ## extended p-adic field. ## ## L[1] is a common p-part of all the coeff. ## ## It is NOT guaranteed that all or at least one of the coeff. is not ## divisible by the prime p. ## ## For example: in PadicExtensionNumberFamily(3, 5, [1,1,1], [1,1]) ## the number (1.2000, 0.1210)(3) may be ## [ 0, [ 1.2000, 0.1210 ] ] or ## [-1, [ 12.000, 1.2100 ] ] here the coeff. have to be multiplied ## by p^(-1) ## ## so there may be a number (1.2, 2.2)(3) and you may ask: "Where are my 5 ## digits? There are only two! Where is the complain department!" But ## the number is intern: [-3, [ 0.0012, 0.0022 ] ] and so has in fact ## maximum precision. ## ## So watch it! ## InstallMethod( PadicNumber, "for a p-adic extension family and a list", true, [ IsPadicExtensionNumberFamily, IsList ], 0, function( fam, list ) local range; range := [ 0 .. fam!.modulus-1 ]; if not IsInt(list[1]) then Error( "[1] must be an integer" ); elif not IsList(list[2]) or Length(list[2]) <> fam!.n then Error( "[2] must be a list of length ", fam!.n ); elif not ForAll( list[2], x -> x in range ) then Error( "[2] must be a list of integers in ", range ); fi; return Objectify( fam!.defaultType, Immutable(list) ); end ); ############################################################################# ## #M PadicNumber( , ) ## ## Make an extended p-adic number out of a rational. That means take the ## result of PadicExpansionByRat and put it at the first position of the ## coeff.list. ## InstallMethod( PadicNumber, "for a p-adic extension family and a rational", true, [ IsPadicExtensionNumberFamily, IsRat ], 0, function( fam, rat ) local c, erg; c := PadicExpansionByRat( rat, fam!.prime, fam!.precision ); erg := List( [1..fam!.n], i->0 ); erg[1] := c[2]; c := [ c[1], erg ]; return Objectify( fam!.defaultType, Immutable( c ) ); end ); ############################################################################# ## #M PrintObj( ) ## InstallMethod( PrintObj, true, [ IsPadicExtensionNumber ], 0, function( x ) local fam, l; fam := FamilyObj(x); if fam!.printPadicSeries then Print( "padic(" ); for l in [1..fam!.n-1] do PrintPadicExpansion( x![1], x![2][l], fam!.prime, fam!.precision ); Print( "," ); od; PrintPadicExpansion( x![1], x![2][fam!.n], fam!.prime, fam!.precision ); Print( ")" ); else Print( "padic(", fam!.prime, "^", x![1], "*", x![2], ")" ); fi; end ); ############################################################################# ## #M Random( ## ## Again this is just something that returns an extended p-adic number. The ## p-part is not totally covered (just ranges from -precision to precision). ## InstallOtherMethod( Random, true, [ IsPadicExtensionNumberFamily ], 0, function ( fam ) local c, l; c := []; c[1] := Random( -fam!.precision, fam!.precision ); c[2] := []; for l in [ 1 .. fam!.n ] do c[2][l] := Random( 0, fam!.modulus-1 ); od; while ForAll( c[2], x-> x mod fam!.prime = 0 ) do c[1] := c[1] + 1; c[2] := c[2] / fam!.prime; od; return Objectify( fam!.defaultType, Immutable( c ) ); end ); ############################################################################# ## #M Zero( ) ## InstallOtherMethod( Zero, true, [ IsPadicExtensionNumberFamily ], 0, function( fam ) return Objectify( fam!.defaultType, [0, List( [1..fam!.n], i->0 )] ); end ); ######################################################################## ## #M IsZero( ) ## InstallMethod( IsZero, true, [ IsPadicExtensionNumber ], 0, function ( x ) if PositionNot( x![2], 0 ) > Length( x![2] ) then return true; fi; return false; end ); ############################################################################# ## #M One( ) ## InstallOtherMethod( One, true, [ IsPadicExtensionNumberFamily ], 0, function( fam ) local c; c := List( [ 1 .. fam!.n ], i -> 0 ); c[1] := 1; return Objectify( fam!.defaultType, [0, c] ); end ); ############################################################################# ## #M Valuation( ## ## In an extended p-adic field the prime p has valuation e (the degree of ## the totally ramified part) and y has valuation 1. y^e is p so this makes ## sense. ## ## The valuation of a sum is (in this case) the minimum of the valuations of ## the summands. As an extended p-adic number is ## ## SUM(i=0..(f-1)) SUM(j=0..(e-1)) a_ij x^i y^j ## ## the valuation nu of that number is the minimum over i and j of ## ## nu(a_ij x^i y^j) ## ## The valuation of a product is the sum of the single valuations, so ## ## nu(a_ij x^i y^j) = nu(a_ij) + nu(x^i) + nu(y^j) ## = nu(a_ij) + j ## InstallMethod( Valuation, true, [ IsPadicExtensionNumber ], 0, function ( x ) local fam, min, j, wert; fam := FamilyObj(x); min := Minimum( List([1..fam!.f], i -> Valuation(x![2][i],fam!.prime)) ); if min <> infinity then min := fam!.e * min; fi; for j in [1..fam!.e-1] do wert := Minimum( List( [1..fam!.f], i -> Valuation(x![2][i+j*fam!.f], fam!.prime) ) ); if wert <> infinity then wert := fam!.e * wert + j; fi; if wert < min then min := wert; fi; od; if min <> infinity then min := min + x![1] * fam!.e; fi; return min; end ); ############################################################################# ## #M AdditiveInverseOp( ) ## InstallMethod( AdditiveInverseOp, true, [ IsPadicExtensionNumber ], 0, function( a ) local fam, c; fam := FamilyObj( a ); c := [ a![1], List( a![2], x -> (-x) mod fam!.modulus ) ]; return Objectify( fam!.defaultType, Immutable( c ) ); end ); ############################################################################# ## #M InverseOp( ) ## InstallMethod( InverseOp, true, [ IsPadicExtensionNumber ], 0, function(x) local fam, val, coeffppart, coeffypart, ppart, z, L, k, j, Lp, E, Beta, ppot, Beta_k, c, addppart; if IsZero(x) then Error( " must be non-zero" ); fi; fam := FamilyObj(x); # need a copy of x later: z := Objectify( fam!.defaultType, [x![1], ShallowCopy(x![2])] ); # if x = [ppart, [x_1,...,x_n]] then # Valuation(x) = ppart*fam!.e + coeffppart*fam!.e + coeffypart val := Valuation(x); if fam!.e > 1 then coeffypart := val mod fam!.e; else coeffypart := 0; fi; ppart := x![1]; coeffppart := (val - ppart*fam!.e - coeffypart) / fam!.e; # so x = p^(ppart + coeffppart) * y^coeffypart * z # and z is divisable neither by y nor by p, so it has Valuation 0 # and can be inverted. # We don't have y^(-1) but y^(e-1) which is p*y^(-1) # so z = x * y^(e-1)^coeffypart * p^(-ppart-coeffppart-coeffypart). # at least there is the coeffppart in z![2]: if coeffppart > 0 then z![1] := z![1] + coeffppart; z![2] := z![2] / fam!.prime^coeffppart; fi; addppart := 0; if coeffypart > 0 then z := z * fam!.yem1^coeffypart; # BUT by multiplying with y^(e-1) one may get additional p-parts # in the coeffs while ForAll( z![2], y -> y mod fam!.prime = 0 ) do addppart := addppart + 1; z![1] := z![1] + 1; z![2] := z![2] / fam!.prime; od; fi; # z![1] := z![1] - ppart - coeffppart - coeffypart - addppart; # NOW z![2] has an entry that is not divisible by p and L should be # invertible L := []; for k in [1..fam!.n] do L[k] := []; for j in [1..fam!.n] do L[k][j]:=Sum(List([1..fam!.n], i -> z![2][i] * fam!.M[ fam!.B[i][j] ][ k ] )); od; od; Lp := InverseMatMod(L, fam!.prime); # E is the right side (1,0,...,0) and Beta is just (0,...,0) E := List([1..fam!.n], i->0); Beta := ShallowCopy(E); E[1] := 1; ppot := 1; # now solve L * Beta = E mod p: for k in [0..fam!.precision-1-coeffppart] do Beta_k := List( Lp * E, x -> x mod fam!.prime ); Beta := Beta + Beta_k * ppot; E := (E - L * Beta_k) / fam!.prime; ppot := ppot * fam!.prime; od; c := []; c[1] := -z![1]; c[2] := Beta; # as z^(-1) is now calculated, the formula above gives # x^(-1) = z^(-1) * y^(e-1)^m * p^(-ppart-coeffppart-coeffypart) c[1] := c[1] - coeffppart - addppart; c[2] := c[2] * fam!.prime^(coeffppart + addppart); c[2] := List( c[2], x -> x mod fam!.modulus ); Objectify( fam!.defaultType, c ); return ( c * fam!.yem1^coeffypart ); end ); ############################################################################# ## #M + ## InstallMethod( \+, IsIdenticalObj, [ IsPadicExtensionNumber, IsPadicExtensionNumber ], 0, function( x, y ) local fam, ppot, c; if IsZero(y) then return x; elif IsZero(x) then return y; fi; fam:= FamilyObj( x ); ppot := Minimum( x![1], y![1] ); c := []; c[1] := ppot; c[2] := fam!.prime^(x![1]-ppot)*x![2] + fam!.prime^(y![1]-ppot)*y![2]; c[2] := List( c[2], x -> x mod fam!.modulus ); return Objectify( fam!.defaultType, Immutable( c ) ); end ); ############################################################################# ## #M - ## InstallMethod( \-, IsIdenticalObj, [ IsPadicExtensionNumber, IsPadicExtensionNumber ], 0, function( x, y ) local fam, ppot, c; if IsZero(y) then return x; elif IsZero(x) then return y; fi; fam:= FamilyObj( x ); ppot := Minimum( x![1], y![1] ); c := []; c[1] := ppot; c[2] := fam!.prime^(x![1]-ppot)*x![2] - fam!.prime^(y![1]-ppot)*y![2]; c[2] := List( c[2], x -> x mod fam!.modulus ); return Objectify( fam!.defaultType, Immutable( c ) ); end ); ############################################################################# ## #M * ## InstallMethod( \*, true, [ IsPurePadicNumber, IsPadicExtensionNumber ], 0, function( a, x ) local Qpxy, Qp, c; Qpxy := FamilyObj(x); Qp := FamilyObj(a); if Qpxy!.prime <> Qp!.prime then Error( "different primes" ); fi; if Qpxy!.precision <> Qp!.precision then Error( "different precision" ); fi; c := [ a![1] + x![1] ]; c[2] := List( a![2] * x![2], x -> x mod Qpxy!.modulus ); return Objectify( Qpxy!.defaultType, Immutable( c ) ); end ); ############################################################################# ## #M * ## InstallMethod( \*, true, [ IsPadicExtensionNumber, IsPurePadicNumber ], 0, function( x, a ) local Qpxy, Qp, c; Qpxy := FamilyObj(x); Qp := FamilyObj(a); if Qpxy!.prime <> Qp!.prime then Error( "different primes" ); fi; if Qpxy!.precision <> Qp!.precision then Error( "different precision" ); fi; c := [ a![1] + x![1] ]; c[2] := List( x![2] * a![2], x -> x mod Qpxy!.modulus ); return Objectify( Qpxy!.defaultType, Immutable( c ) ); end ); ############################################################################# ## #M * ## InstallMethod( \*, IsIdenticalObj, [ IsPadicExtensionNumber, IsPadicExtensionNumber ], 0, function (a, b) local fam, vec, addvec, bj, bi, aj, ai, c; fam := FamilyObj( a ); ## zwei Nullvektoren der Laenge (2f-1)(2e-1): vec := List( [1..(2*fam!.f-1)*(2*fam!.e-1)], i->0 ); addvec := List( [1..(2*fam!.f-1)*(2*fam!.e-1)], i->0 ); ## Koeff. von b eintragen for bj in [1..fam!.e] do for bi in [1..fam!.f] do vec[ (bj-1)*(2*fam!.f-1) + bi ] := b![2][ (bj-1)*fam!.f + bi ]; od; od; ## Das eigentliche Multiplizieren: for aj in [1..fam!.e] do for ai in [1..fam!.f] do addvec := addvec + vec * a![2][ (aj-1)*fam!.f + ai ]; vec := ShiftedCoeffs( vec, 1 ); od; vec := ShiftedCoeffs( vec, fam!.f-1 ); od; c := [ a![1] + b![1], List(addvec * fam!.M, x -> x mod fam!.modulus) ]; return Objectify( fam!.defaultType, Immutable( c ) ); end ); ############################################################################# ## #M = ## InstallMethod( \=, IsIdenticalObj, [ IsPadicExtensionNumber, IsPadicExtensionNumber ], 0, function( a, b ) local fam; if IsZero(a) then return IsZero(b); elif IsZero(b) then return false; fi; # A little work is needed, because p^1 * 10 is equal to one fam := FamilyObj(a); a := [ a![1], ShallowCopy(a![2]) ]; b := [ b![1], ShallowCopy(b![2]) ]; while ForAll( a[2], z -> z mod fam!.prime = 0 ) do a[2] := a[2] / fam!.prime; a[1] := a[1] + 1; od; while ForAll( b[2], z -> z mod fam!.prime = 0 ) do b[2] := b[2] / fam!.prime; b[1] := b[1] + 1; od; return (a[1] = b[1]) and (a[2] = b[2]); end ); ############################################################################# ## #M < ## ## Again just something to have it. ## InstallMethod( \<, IsIdenticalObj, [ IsPadicExtensionNumber, IsPadicExtensionNumber ], 0, function( a, b ) local fam; if IsZero(a) then return not IsZero(b); elif IsZero(b) then return false; fi; fam := FamilyObj(a); a := [ a![1], ShallowCopy(a![2]) ]; b := [ b![1], ShallowCopy(b![2]) ]; while ForAll( a[2], z -> z mod fam!.prime = 0 ) do a[2] := a[2] / fam!.prime; a[1] := a[1] + 1; od; while ForAll( b[2], z -> z mod fam!.prime = 0 ) do b[2] := b[2] / fam!.prime; b[1] := b[1] + 1; od; if a[1] = b[1] then return a[2] < b[2]; else return a[1] < b[1]; fi; end ); ############################################################################# ## #E padics.gi . . . . . . . . . . . . . . . . . . . . . . . . . . . ends here ## gap-4r6p5/lib/ghomperm.gd0000644000175000017500000000677012172557252014053 0ustar billbill############################################################################# ## #W ghomperm.gd GAP library Heiko Theißen ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ############################################################################# ## #R IsPermGroupGeneralMapping() #R IsPermGroupGeneralMappingByImages() #R IsPermGroupHomomorphism() #R IsPermGroupHomomorphismByImages() ## ## <#GAPDoc Label="IsPermGroupGeneralMapping"> ## ## ## ## ## ## ## ## are the representations for mappings that map from a perm group ## ## ## <#/GAPDoc> ## DeclareRepresentation( "IsPermGroupGeneralMapping", IsGroupGeneralMapping,[]); DeclareRepresentation( "IsPermGroupGeneralMappingByImages", IsPermGroupGeneralMapping and IsGroupGeneralMappingByImages, [] ); DeclareSynonym( "IsPermGroupHomomorphism", IsPermGroupGeneralMapping and IsMapping ); DeclareSynonym( "IsPermGroupHomomorphismByImages", IsPermGroupGeneralMappingByImages and IsMapping ); ############################################################################# ## #R IsToPermGroupGeneralMappingByImages() #R IsToPermGroupHomomorphismByImages() ## ## <#GAPDoc Label="IsToPermGroupGeneralMappingByImages"> ## ## ## ## ## ## is the representation for mappings that map to a perm group ## ## ## <#/GAPDoc> ## DeclareRepresentation( "IsToPermGroupGeneralMappingByImages", IsGroupGeneralMappingByImages, [ "generators", "genimages" ] ); DeclareSynonym( "IsToPermGroupHomomorphismByImages", IsToPermGroupGeneralMappingByImages and IsMapping ); ############################################################################# ## #F RelatorsPermGroupHom(,) ## ## ## ## ## ## RelatorsPermGroupHom is an internal function which is called by the ## operation IsomorphismFpGroupByGeneratorsNC in case of a permutation group. ## It implements John Cannon's multi-stage relations finding algorithm as ## described in . ## ## ## DeclareGlobalFunction("RelatorsPermGroupHom"); ############################################################################# DeclareGlobalFunction( "AddGeneratorsGenimagesExtendSchreierTree" ); DeclareGlobalFunction( "ImageSiftedBaseImage" ); DeclareGlobalFunction( "CoKernelGensIterator" ); DeclareGlobalFunction( "CoKernelGensPermHom" ); DeclareGlobalFunction( "StabChainPermGroupToPermGroupGeneralMappingByImages" ); DeclareGlobalFunction( "MakeStabChainLong" ); DeclareGlobalFunction( "ImageKernelBlocksHomomorphism" ); DeclareGlobalFunction( "PreImageSetStabBlocksHomomorphism" ); ############################################################################# ## #E gap-4r6p5/lib/lierep.gd0000644000175000017500000010654612172557252013517 0ustar billbill############################################################################# ## #W lierep.gd GAP library Willem de Graaf #W and Craig A. Struble ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the declaration of attributes, properties, and ## operations for modules over Lie algebras. ## ############################################################################# ## ## <#GAPDoc Label="[1]{lierep}"> ## ## An s-cochain of a module V over a Lie algebra L ## is an s-linear map ## ## c: L \times \cdots \times L \rightarrow V , ## ## with s factors L, ## that is skew-symmetric (meaning that if any of the arguments are ## interchanged, c changes to -c). ##

## Let (x_1, \ldots, x_n) be a basis of L. ## Then any s-cochain is ## determined by the values c( x_{{i_1}}, \ldots, x_{{i_s}} ), ## where 1 \leq i_1 < i_2 < \cdots < i_s \leq \dim L. ## Now this value again is a linear combination of basis elements of V: ## c( x_{{i_1}}, \ldots, x_{{i_s}} ) = ## \sum \lambda^k_{{i_1,\ldots, i_s}} v_k. ## Denote the dimension of V by r. ## Then we represent an s-cocycle by a list of r lists. ## The j-th of those lists consists of entries of the form ## ## [ [ i_1, i_2, \ldots, i_s ], \lambda^j_{{i_1, \ldots, i_s}} ] ## ## where the coefficient on the second position is non-zero. ## (We only store those entries for which this coefficient is non-zero.) ## It follows that every s-tuple (i_1, \ldots, i_s) gives rise ## to r basis elements. ##

## So the zero cochain is represented by a list of the form ## [ [ ], [ ], \ldots, [ ] ]. Furthermore, if V is, e.g., ## 4-dimensional, then the 2-cochain represented by ##

## ##

## maps the pair (x_1, x_2) to 2v_1 + 1/2 v_3 ## (where v_1 is the first basis element of V, ## and v_3 the third), and all other pairs to zero. ##

## By definition, 0-cochains are constant maps ## c( x ) = v_c \in V for all x \in L. ## So 0-cochains have a different representation: they are just ## represented by the list [ v_c ]. ##

## Cochains are constructed using the function , ## if c is a cochain, then its corresponding list is returned by ## ExtRepOfObj( c ). ## <#/GAPDoc> ## ############################################################################## ## #C IsCochain( ) #C IsCochainCollection( ) ## ## <#GAPDoc Label="IsCochain"> ## ## ## ## ## ## Categories of cochains and of collections of cochains. ## ## ## <#/GAPDoc> ## DeclareCategory( "IsCochain", IsVector ); DeclareCategoryCollections( "IsCochain" ); ############################################################################# ## #O Cochain( , , ) ## ## <#GAPDoc Label="Cochain"> ## ## ## ## ## Constructs a s-cochain given by the data in obj, with ## respect to the Lie algebra module V. If s is non-zero, ## then obj must be a list. ## L:= SimpleLieAlgebra( "A", 1, Rationals );; ## gap> V:= AdjointModule( L ); ## <3-dimensional left-module over > ## gap> c1:= Cochain( V, 2, ## > [ [ [ [ 1, 3 ], -1 ] ], [ ], [ [ [ 2, 3 ], 1/2 ] ] ]); ## <2-cochain> ## gap> ExtRepOfObj( c1 ); ## [ [ [ [ 1, 3 ], -1 ] ], [ ], [ [ [ 2, 3 ], 1/2 ] ] ] ## gap> c2:= Cochain( V, 0, Basis( V )[1] ); ## <0-cochain> ## gap> ExtRepOfObj( c2 ); ## v.1 ## gap> IsCochain( c2 ); ## true ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "Cochain", [ IsLeftModule, IsInt, IsObject ] ); ############################################################################# ## #O CochainSpace( , ) ## ## <#GAPDoc Label="CochainSpace"> ## ## ## ## ## Returns the space of all s-cochains with respect to V. ## L:= SimpleLieAlgebra( "A", 1, Rationals );; ## gap> V:= AdjointModule( L );; ## gap> C:=CochainSpace( V, 2 ); ## ## gap> BasisVectors( Basis( C ) ); ## [ <2-cochain>, <2-cochain>, <2-cochain>, <2-cochain>, <2-cochain>, ## <2-cochain>, <2-cochain>, <2-cochain>, <2-cochain> ] ## gap> ExtRepOfObj( last[1] ); ## [ [ [ [ 1, 2 ], 1 ] ], [ ], [ ] ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "CochainSpace", [ IsAlgebraModule, IS_INT ] ); ############################################################################# ## #F ValueCochain( , , ,..., ) ## ## <#GAPDoc Label="ValueCochain"> ## ## ## ## ## Here c is an s-cochain. This function returns the value of ## c when applied to the s elements y1 to ys ## (that lie in the Lie algebra acting on the module corresponding to ## c). It is also possible to call this function with two arguments: ## first c and then the list containing y1,...,ys. ## L:= SimpleLieAlgebra( "A", 1, Rationals );; ## gap> V:= AdjointModule( L );; ## gap> C:= CochainSpace( V, 2 );; ## gap> c:= Basis( C )[1]; ## <2-cochain> ## gap> ValueCochain( c, Basis(L)[2], Basis(L)[1] ); ## (-1)*v.1 ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "ValueCochain" ); ############################################################################# ## #F LieCoboundaryOperator( ) ## ## <#GAPDoc Label="LieCoboundaryOperator"> ## ## ## ## ## This is a function that takes an s-cochain c, ## and returns an s+1-cochain. The coboundary operator is applied. ## L:= SimpleLieAlgebra( "A", 1, Rationals );; ## gap> V:= AdjointModule( L );; ## gap> C:= CochainSpace( V, 2 );; ## gap> c:= Basis( C )[1];; ## gap> c1:= LieCoboundaryOperator( c ); ## <3-cochain> ## gap> c2:= LieCoboundaryOperator( c1 ); ## <4-cochain> ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "LieCoboundaryOperator", "Lie coboundary operator" ); ############################################################################# ## #O Cocycles( , ) ## ## <#GAPDoc Label="Cocycles"> ## ## ## ## ## is the space of all s-cocycles with respect to the Lie algebra ## module V. That is the kernel of the coboundary operator when ## restricted to the space of s-cochains. ## ## ## <#/GAPDoc> ## DeclareOperation( "Cocycles", [ IsAlgebraModule, IS_INT ] ); ############################################################################# ## #O Coboundaries( , ) ## ## <#GAPDoc Label="Coboundaries"> ## ## ## ## ## is the space of all s-coboundaries with respect to the Lie algebra ## module V. That is the image of the coboundary operator, when applied ## to the space of s-1-cochains. By definition the space of all ## 0-coboundaries is zero. ## T:= EmptySCTable( 3, 0, "antisymmetric" );; ## gap> SetEntrySCTable( T, 1, 2, [ 1, 3 ] ); ## gap> L:= LieAlgebraByStructureConstants( Rationals, T );; ## gap> V:= FaithfulModule( L ); ## > ## gap> Cocycles( V, 2 ); ## ## gap> Coboundaries( V, 2 ); ## ## gap> Dimension( last ); ## 5 ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "Coboundaries", [ IsAlgebraModule, IS_INT ] ); ############################################################################ ## #P IsWeylGroup( ) ## ## <#GAPDoc Label="IsWeylGroup"> ## ## ## ## ## A Weyl group is a group generated by reflections, with the attribute ## set. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsWeylGroup", IsGroup ); ############################################################################ ## #A WeylGroup( ) ## ## <#GAPDoc Label="WeylGroup"> ## ## ## ## ## The Weyl group of the root system R. It is generated by the simple ## reflections. A simple reflection is represented by a matrix, and the ## result of letting a simple reflection m act on a weight w ## is obtained by w*m. ## L:= SimpleLieAlgebra( "F", 4, Rationals );; ## gap> R:= RootSystem( L );; ## gap> W:= WeylGroup( R ); ## ## gap> IsWeylGroup( W ); ## true ## gap> SparseCartanMatrix( W ); ## [ [ [ 1, 2 ], [ 3, -1 ] ], [ [ 2, 2 ], [ 4, -1 ] ], ## [ [ 1, -1 ], [ 3, 2 ], [ 4, -1 ] ], ## [ [ 2, -1 ], [ 3, -2 ], [ 4, 2 ] ] ] ## gap> g:= GeneratorsOfGroup( W );; ## gap> [ 1, 1, 1, 1 ]*g[2]; ## [ 1, -1, 1, 2 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "WeylGroup", IsRootSystem ); ############################################################################ ## #A SparseCartanMatrix( ) ## ## <#GAPDoc Label="SparseCartanMatrix"> ## ## ## ## ## This is a sparse form of the Cartan matrix of the corresponding root ## system. If we denote the Cartan matrix by C, then the sparse ## Cartan matrix of W is a list (of length equal to the length of ## the Cartan matrix), where the i-th entry is a list consisting ## of elements [ j, C[i][j] ], where j is such that ## C[i][j] is non-zero. ## ## ## <#/GAPDoc> ## DeclareAttribute( "SparseCartanMatrix", IsWeylGroup ); ############################################################################ ## #O ApplySimpleReflection( , , ) ## ## <#GAPDoc Label="ApplySimpleReflection"> ## ## ## ## ## Here SC is the sparse Cartan matrix of a Weyl group. This ## function applies the i-th simple reflection to the weight ## wt, thus changing wt. ## L:= SimpleLieAlgebra( "F", 4, Rationals );; ## gap> W:= WeylGroup( RootSystem( L ) );; ## gap> C:= SparseCartanMatrix( W );; ## gap> w:= [ 1, 1, 1, 1 ];; ## gap> ApplySimpleReflection( C, 2, w ); ## gap> w; ## [ 1, -1, 1, 2 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "ApplySimpleReflection", [ IsList, IS_INT, IsList ] ); ############################################################################ ## #A LongestWeylWordPerm( ) ## ## <#GAPDoc Label="LongestWeylWordPerm"> ## ## ## ## ## Let g_0 be the longest element in the Weyl group W, ## and let \{ \alpha_1, \ldots, \alpha_l \} be a simple system ## of the corresponding root system. ## Then g_0 maps \alpha_i to -\alpha_{{\sigma(i)}}, ## where \sigma is a permutation of (1, \ldots, l). ## This function returns that permutation. ## L:= SimpleLieAlgebra( "E", 6, Rationals );; ## gap> W:= WeylGroup( RootSystem( L ) );; ## gap> LongestWeylWordPerm( W ); ## (1,6)(3,5) ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "LongestWeylWordPerm", IsWeylGroup ); ############################################################################ ## #O ConjugateDominantWeight( , ) #O ConjugateDominantWeightWithWord( , ) ## ## <#GAPDoc Label="ConjugateDominantWeight"> ## ## ## ## ## ## Here W is a Weyl group and wt a weight (i.e., a list of ## integers). returns the unique ## dominant weight conjugate to wt under W. ##

## returns a list of two ## elements. The first of these is the dominant weight conjugate to wt. ## The second element is a list of indices of simple reflections that have to ## be applied to wt in order to get the dominant weight conjugate to it. ## L:= SimpleLieAlgebra( "E", 6, Rationals );; ## gap> W:= WeylGroup( RootSystem( L ) );; ## gap> C:= SparseCartanMatrix( W );; ## gap> w:= [ 1, -1, 2, -2, 3, -3 ];; ## gap> ConjugateDominantWeight( W, w ); ## [ 2, 1, 0, 0, 0, 0 ] ## gap> c:= ConjugateDominantWeightWithWord( W, w ); ## [ [ 2, 1, 0, 0, 0, 0 ], [ 2, 4, 2, 3, 6, 5, 4, 2, 3, 1 ] ] ## gap> for i in [1..Length(c[2])] do ## > ApplySimpleReflection( C, c[2][i], w ); ## > od; ## gap> w; ## [ 2, 1, 0, 0, 0, 0 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "ConjugateDominantWeight", [ IsWeylGroup, IsList ] ); DeclareOperation( "ConjugateDominantWeightWithWord", [ IsWeylGroup, IsList ]); ############################################################################ ## #O WeylOrbitIterator( , ) ## ## <#GAPDoc Label="WeylOrbitIterator"> ## ## ## ## ## Returns an iterator for the orbit of the weight wt under the ## action of the Weyl group W. ## L:= SimpleLieAlgebra( "E", 6, Rationals );; ## gap> W:= WeylGroup( RootSystem( L ) );; ## gap> orb:= WeylOrbitIterator( W, [ 1, 1, 1, 1, 1, 1 ] ); ## ## gap> NextIterator( orb ); ## [ 1, 1, 1, 1, 1, 1 ] ## gap> NextIterator( orb ); ## [ -1, -1, -1, -1, -1, -1 ] ## gap> orb:= WeylOrbitIterator( W, [ 1, 1, 1, 1, 1, 1 ] ); ## ## gap> k:= 0; ## 0 ## gap> while not IsDoneIterator( orb ) do ## > w:= NextIterator( orb ); k:= k+1; ## > od; ## gap> k; # this is the size of the Weyl group of E6 ## 51840 ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "WeylOrbitIterator", [ IsWeylGroup, IsList ] ); ############################################################################ ## #A PositiveRootsAsWeights( ) ## ## ## ## ## ## Returns the list of positive roots of R, represented in the basis ## of fundamental weights. ## ## ## DeclareAttribute( "PositiveRootsAsWeights", IsRootSystem ); ############################################################################ ## #O DominantWeights( , ) ## ## <#GAPDoc Label="DominantWeights"> ## ## ## ## ## Returns a list consisting of two lists. The first of these contains ## the dominant weights (written on the basis of fundamental weights) ## of the irreducible highest-weight module, with highest weight maxw, ## over the Lie algebra with the root system R. ## The i-th element of the second list is the level of the ## i-th dominant weight. ## (Where the level is defined as follows. ## For a weight \mu we write ## \mu = \lambda - \sum_i k_i \alpha_i, where ## the \alpha_i are the simple roots, ## and \lambda the highest weight. ## Then the level of \mu is \sum_i k_i.) ## ## ## <#/GAPDoc> ## DeclareOperation( "DominantWeights", [ IsRootSystem, IsList ] ); ############################################################################ ## #O DominantCharacter( , ) #O DominantCharacter( , ) ## ## <#GAPDoc Label="DominantCharacter"> ## ## ## ## ## ## For a highest weight maxw and a semisimple Lie algebra L, ## this returns the dominant weights of the highest-weight module over ## L, with highest weight maxw. ## The output is a list of two lists, ## the first list contains the dominant weights; ## the second list contains their multiplicities. ##

## The first argument can also be a root system, in which case ## the dominant character of the highest-weight module over the ## corresponding semisimple Lie algebra is returned. ## ## ## <#/GAPDoc> ## DeclareOperation( "DominantCharacter", [ IsRootSystem, IsList ] ); ############################################################################# ## #O DecomposeTensorProduct( , , ) ## ## <#GAPDoc Label="DecomposeTensorProduct"> ## ## ## ## ## Here L is a semisimple Lie algebra and w1, w2 are ## dominant weights. ## Let V_i be the irreducible highest-weight module over L ## with highest weight w_i for i = 1, 2. ## Let W = V_1 \otimes V_2. ## Then in general W is a reducible L-module. Now this function ## returns a list of two lists. The first of these is the list of highest ## weights of the irreducible modules occurring in the decomposition of ## W as a direct sum of irreducible modules. The second list contains ## the multiplicities of these weights (i.e., the number of copies of ## the irreducible module with the corresponding highest weight that occur ## in W). The algorithm uses Klimyk's formula ## (see  or ## for the original Russian version). ## ## ## <#/GAPDoc> ## DeclareOperation( "DecomposeTensorProduct", [ IsLieAlgebra, IsList, IsList ] ); ############################################################################# ## #O DimensionOfHighestWeightModule( , ) ## ## <#GAPDoc Label="DimensionOfHighestWeightModule"> ## ## ## ## ## Here L is a semisimple Lie algebra, and w a dominant weight. ## This function returns the dimension of the highest-weight module ## over L with highest weight w. The algorithm ## uses Weyl's dimension formula. ## L:= SimpleLieAlgebra( "F", 4, Rationals );; ## gap> R:= RootSystem( L );; ## gap> DominantWeights( R, [ 1, 1, 0, 0 ] ); ## [ [ [ 1, 1, 0, 0 ], [ 2, 0, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 1, 0, 0 ], ## [ 1, 0, 0, 0 ], [ 0, 0, 0, 0 ] ], [ 0, 3, 4, 8, 11, 19 ] ] ## gap> DominantCharacter( L, [ 1, 1, 0, 0 ] ); ## [ [ [ 1, 1, 0, 0 ], [ 2, 0, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 1, 0, 0 ], ## [ 1, 0, 0, 0 ], [ 0, 0, 0, 0 ] ], [ 1, 1, 4, 6, 14, 21 ] ] ## gap> DecomposeTensorProduct( L, [ 1, 0, 0, 0 ], [ 0, 0, 1, 0 ] ); ## [ [ [ 1, 0, 1, 0 ], [ 1, 0, 0, 0 ], [ 0, 0, 0, 1 ], [ 0, 1, 0, 0 ], ## [ 2, 0, 0, 0 ], [ 0, 0, 1, 0 ], [ 1, 1, 0, 0 ] ], ## [ 1, 1, 1, 1, 1, 1, 1 ] ] ## gap> DimensionOfHighestWeightModule( L, [ 1, 2, 3, 4 ] ); ## 79316832731136 ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "DimensionOfHighestWeightModule", [ IsLieAlgebra, IsList ] ); ############################################################################# ## ## <#GAPDoc Label="[2]{lierep}"> ## Let L be a semisimple Lie algebra over a field of characteristic ## 0, and let R be its root system. ## For a positive root \alpha we let x_{\alpha} and ## y_{\alpha} be positive and negative root vectors, ## respectively, both from a fixed Chevalley basis of L. Furthermore, ## h_1, \ldots, h_l are the Cartan elements from the same Chevalley ## basis. Also we set ## ## x_{\alpha}^{(n)} = {{x_{\alpha}^n \over n!}}, ## y_{\alpha}^{(n)} = {{y_{\alpha}^n \over n!}} . ## ## Furthermore, let \alpha_1, \ldots, \alpha_s denote the positive ## roots of R. ## For multi-indices N = (n_1, \ldots, n_s), ## M = (m_1, \ldots, m_s) ## and K = (k_1, \ldots, k_s) (where n_i, m_i, k_i \geq 0) set ## ## ## x^N ## = ## x_{{\alpha_1}}^{(n_1)} \cdots x_{{\alpha_s}}^{(n_s)}, ## ## ## y^M ## = ## y_{{\alpha_1}}^{(m_1)} \cdots y_{{\alpha_s}}^{(m_s)}, ## ## ## h^K ## = ## {{h_1 \choose k_1}} \cdots {{h_l \choose k_l}} ## ##
## Then by a theorem of Kostant, the x_{\alpha}^{(n)} and ## y_{\alpha}^{(n)} generate a subring of the universal enveloping algebra ## U(L) spanned (as a free Z-module) by the elements ## ## y^M h^K x^N ## ## (see, e.g., or ) ## So by the Poincare-Birkhoff-Witt theorem ## this subring is a lattice in U(L). Furthermore, this lattice is ## invariant under the x_{\alpha}^{(n)} and y_{\alpha}^{(n)}. ## Therefore, it is called an admissible lattice in U(L). ##

## The next functions enable us to construct the generators of such an ## admissible lattice. ## <#/GAPDoc> ## ############################################################################## ## #C IsUEALatticeElement( ) #C IsUEALatticeElementCollection( ) #C IsUEALatticeElementFamily( ) ## ## <#GAPDoc Label="IsUEALatticeElement"> ## ## ## ## ## ## ## is the category of elements of an admissible lattice in the universal ## enveloping algebra of a semisimple Lie algebra L. ## ## ## <#/GAPDoc> ## DeclareCategory( "IsUEALatticeElement", IsVector and IsRingElement and IsMultiplicativeElementWithOne ); DeclareCategoryCollections( "IsUEALatticeElement" ); DeclareCategoryFamily( "IsUEALatticeElement" ); ############################################################################## ## #A LatticeGeneratorsInUEA( ) ## ## <#GAPDoc Label="LatticeGeneratorsInUEA"> ## ## ## ## ## Here L must be a semisimple Lie algebra of characteristic 0. ## This function returns a list of generators of an admissible lattice ## in the universal enveloping algebra of L, relative to the ## Chevalley basis contained in ChevalleyBasis( L ) ## (see ). First are listed the negative ## root vectors (denoted by y_1, \ldots, y_s), ## then the positive root vectors (denoted by x_1, \ldots, x_s). ## At the end of the list there are the Cartan elements. They are printed as ## ( hi/1 ), which means ## ## {{h_i \choose 1}}. ## ## In general the printed form ( hi/ k ) means ## ## {{h_i \choose k}}. ## ##

## Also y_i^{(m)} is printed as yi^(m), which means that entering ## yi^m at the &GAP; prompt results in the output m!*yi^(m). ##

## Products of lattice generators are collected using the following order: ## first come the y_i^{(m_i)} ## (in the same order as the positive roots), ## then the {h_i \choose k_i}, ## and then the x_i^{(n_i)} ## (in the same order as the positive roots). ## ## ## <#/GAPDoc> ## DeclareAttribute( "LatticeGeneratorsInUEA", IsLieAlgebra ); ############################################################################## ## #F CollectUEALatticeElement( , , , , , , ## , ) ## ## ## ## ## ## ## ## DeclareGlobalFunction( "CollectUEALatticeElement" ); ############################################################################## ## #C IsWeightRepElement( ) #C IsWeightRepElementCollection( ) #C IsWeightRepElementFamily( ) ## ## <#GAPDoc Label="IsWeightRepElement"> ## ## ## ## ## ## ## Is a category of vectors, that is used to construct elements of ## highest-weight modules (by ). ##

## WeightRepElements are represented by a list of the form ## [ v1, c1, v2, c2, ....], where the vi are basis vectors, ## and the ci are coefficients. Furthermore a basis vector v ## is a weight vector. It is represented by a list of the form ## [ k, mon, wt ], where k is an integer (the basis vectors ## are numbered from 1 to \dim V, where V is the highest ## weight module), mon is an UEALatticeElement (which means ## that the result of applying mon to a highest weight vector is v; ## see ) and wt is the weight ## of v. A WeightRepElement is printed as mon*v0, ## where v0 denotes a fixed highest weight vector. ##

## If v is a WeightRepElement, then ExtRepOfObj( v ) ## returns the corresponding list, and if list is such a list and ## fam a WeightRepElementFamily, then ## ObjByExtRep( list, fam ) returns the corresponding ## WeightRepElement. ## ## ## <#/GAPDoc> ## DeclareCategory( "IsWeightRepElement", IsVector ); DeclareCategoryCollections( "IsWeightRepElement" ); DeclareCategoryFamily( "IsWeightRepElement" ); ############################################################################## ## #C IsBasisOfWeightRepElementSpace( ) ## ## ## ## ## ## A basis that lies in this category is a basis of a space of weight ## rep elements. If a basis B lies in this category, then it has the ## record components B!.echelonBasis (a list of basis vectors of ## the same module as where B is a basis of, but in echelon form), ## B!.heads (if B!.heads[i] = k, then the number of the first ## weight vector of B!.echelonBasis[i] is k; recall that all weight ## vectors carry a number), and B!.baseChange (if B!.baseChange[i]= ## [ [m1,c1],...,[ms,cs] ] then the i-th element of B!.echelonBasis ## is of the form c1 v_{m1}+\cdots +cs v_{ms}, where the v_j are the ## basis vectors of B. ## ## ## DeclareCategory( "IsBasisOfWeightRepElementSpace", IsBasis ); ############################################################################# ## #F HighestWeightModule( , ) ## ## <#GAPDoc Label="HighestWeightModule"> ## ## ## ## ## returns the highest weight module with highest weight wt of the ## semisimple Lie algebra L of characteristic 0. ##

## Note that the elements of such a module lie in the category ## (and in particular they do not ## lie in the category ). However, if ## v is an element of such a module, then ExtRepOfObj( v ) ## is a WeightRepElement. ##

## Note that for the following examples of this chapter we increase the line ## length limit from its default value 80 to 81 in order to make some long ## output expressions fit into the lines. ##

## K1:= SimpleLieAlgebra( "G", 2, Rationals );; ## gap> K2:= SimpleLieAlgebra( "B", 2, Rationals );; ## gap> L:= DirectSumOfAlgebras( K1, K2 ); ## ## gap> V:= HighestWeightModule( L, [ 0, 1, 1, 1 ] ); ## <224-dimensional left-module over > ## gap> vv:= GeneratorsOfLeftModule( V );; ## gap> vv[100]; ## y5*y7*y10*v0 ## gap> e:= ExtRepOfObj( vv[100] ); ## y5*y7*y10*v0 ## gap> ExtRepOfObj( e ); ## [ [ 100, y5*y7*y10, [ -3, 2, -1, 1 ] ], 1 ] ## gap> Basis(L)[17]^vv[100]; ## -1*y5*y7*y8*v0-1*y5*y9*v0 ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "HighestWeightModule", [ IsAlgebra, IsList ] ); ############################################################################# ## #F LeadingUEALatticeMonomial( , ) ## ## ## ## ## ## Here f is an UEALatticeElement, and novar the number of generators ## of the algebra containing f. This function returns a list of four ## elements. The first element is the leading monomial of f (as it ## occurs in the external representation of f). The second element is the ## leading monomial of f represented as a list of length novar. The ## i-th entry in this list is the exponent of the i-th generator in ## the leading monomial. The third and fourth elements are, respectively, ## the coefficient of the leading monomial and the index at which it ## occurs in f (so that f!.[1][ind] is equal to the first element of ## the output). ## ## ## DeclareOperation( "LeadingUEALatticeMonomial", [ IsInt, IsUEALatticeElement ] ); ############################################################################## ## #F LeftReduceUEALatticeElement( , , ,

) ## ## ## ## ## ## ## ## DeclareGlobalFunction( "LeftReduceUEALatticeElement" ); ############################################################################## ## #F ExtendRepresentation( , , , ) ## ## ## ## ## ## ## ## DeclareGlobalFunction( "ExtendRepresentation" ); ############################################################################# ## #F IsCochainsSpace( ) ## ## ## ## ## ## ... ## ## ## DeclareHandlingByNiceBasis( "IsCochainsSpace", "for free left modules of cochains" ); ############################################################################# ## #V InfoSearchTable ## ## ## ## ## ## is the info class for methods and functions applicable to search tables. ## (see ). ## ## ## DeclareInfoClass( "InfoSearchTable" ); ############################################################################# ## #C IsSearchTable( ) ## ## ## ## ## ## A search table stores elements and provides methods for efficient ## search of particular kinds of elements. ## ## ## DeclareCategory( "IsSearchTable", IsObject ); ############################################################################# ## #O Search( , ) ## ## ## ## ## ## is the operation for finding element labelled with key in table T. ## The return value depends on the specific implementation of the search ## table, but this will always return fail if an element in T does not ## satisfy the necessary criterion for key. ## ## ## DeclareOperation( "Search", [ IsSearchTable, IsObject ] ); ############################################################################# ## #O Insert( , , ) ## ## ## ## ## ## is the operation for inserting data into the search table. ## The data data is stored in the table under the key key. ## The operation returns true if the insertion occurs, and ## false otherwise. ## ## ## DeclareOperation( "Insert", [ IsSearchTable, IsObject, IsObject ] ); ############################################################################# ## #C IsVectorSearchTable( ) ## ## ## ## ## ## is a search table encoding integer vectors representing a ## variable/exponent pair for monomials in a commutative polynomial ring ## or in a semisimple Lie algebra given by a PBW basis. ## ## ## DeclareCategory( "IsVectorSearchTable", IsSearchTable ); ############################################################################# ## #F VectorSearchTable( ) #F VectorSearchTable( , ) ## ## ## ## ## ## ## construct an empty search table or a search table containing data ## keyed by keys. The list keys must contain integer lists which are ## interpreted as exponents for variables. ##

## The lists keys and data must be the same length as well. ## ## ## DeclareGlobalFunction( "VectorSearchTable" ); ############################################################################# ## #E gap-4r6p5/lib/filter1.g0000644000175000017500000001351612172557252013433 0ustar billbill############################################################################# ## #W filter1.g GAP library Steve Linton ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## Speed-critical code moved from filter.g so that it can be ## statically compiled ## ############################################################################# ## #F WITH_HIDDEN_IMPS_FLAGS( ) ## HIDDEN_IMPS := []; WITH_HIDDEN_IMPS_FLAGS_CACHE := []; WITH_HIDDEN_IMPS_FLAGS_COUNT := 0; WITH_HIDDEN_IMPS_FLAGS_CACHE_MISS := 0; WITH_HIDDEN_IMPS_FLAGS_CACHE_HIT := 0; Unbind( CLEAR_HIDDEN_IMP_CACHE); BIND_GLOBAL( "CLEAR_HIDDEN_IMP_CACHE", function( filter ) local i, flags; flags := FLAGS_FILTER(filter); for i in [ 1, 3 .. LEN_LIST(WITH_HIDDEN_IMPS_FLAGS_CACHE)-1 ] do if IsBound(WITH_HIDDEN_IMPS_FLAGS_CACHE[i]) then if IS_SUBSET_FLAGS(WITH_HIDDEN_IMPS_FLAGS_CACHE[i+1],flags) then Unbind(WITH_HIDDEN_IMPS_FLAGS_CACHE[i]); Unbind(WITH_HIDDEN_IMPS_FLAGS_CACHE[i+1]); fi; fi; od; end ); BIND_GLOBAL( "WITH_HIDDEN_IMPS_FLAGS", function ( flags ) local with, changed, imp, hash; hash := 2 * ( HASH_FLAGS(flags) mod 1009 ) + 1; if IsBound(WITH_HIDDEN_IMPS_FLAGS_CACHE[hash]) then if IS_IDENTICAL_OBJ(WITH_HIDDEN_IMPS_FLAGS_CACHE[hash],flags) then WITH_HIDDEN_IMPS_FLAGS_CACHE_HIT := WITH_HIDDEN_IMPS_FLAGS_CACHE_HIT + 1; return WITH_HIDDEN_IMPS_FLAGS_CACHE[hash+1]; fi; fi; WITH_HIDDEN_IMPS_FLAGS_CACHE_MISS := WITH_HIDDEN_IMPS_FLAGS_CACHE_MISS+1; with := flags; changed := true; while changed do changed := false; for imp in HIDDEN_IMPS do if IS_SUBSET_FLAGS( with, imp[2] ) and not IS_SUBSET_FLAGS( with, imp[1] ) then with := AND_FLAGS( with, imp[1] ); changed := true; fi; od; od; WITH_HIDDEN_IMPS_FLAGS_CACHE[hash ] := flags; WITH_HIDDEN_IMPS_FLAGS_CACHE[hash+1] := with; return with; end ); ############################################################################# ## #F WITH_IMPS_FLAGS( ) ## IMPLICATIONS := []; WITH_IMPS_FLAGS_CACHE := []; WITH_IMPS_FLAGS_COUNT := 0; WITH_IMPS_FLAGS_CACHE_HIT := 0; WITH_IMPS_FLAGS_CACHE_MISS := 0; Unbind(CLEAR_IMP_CACHE); BIND_GLOBAL( "CLEAR_IMP_CACHE", function() WITH_IMPS_FLAGS_CACHE := []; end ); BIND_GLOBAL( "WITH_IMPS_FLAGS", function ( flags ) local with, changed, imp, hash, hash2, i; hash := HASH_FLAGS(flags) mod 11001; for i in [ 0 .. 3 ] do hash2 := 2 * ((hash+31*i) mod 11001) + 1; if IsBound(WITH_IMPS_FLAGS_CACHE[hash2]) then if IS_IDENTICAL_OBJ(WITH_IMPS_FLAGS_CACHE[hash2],flags) then WITH_IMPS_FLAGS_CACHE_HIT := WITH_IMPS_FLAGS_CACHE_HIT + 1; return WITH_IMPS_FLAGS_CACHE[hash2+1]; fi; else break; fi; od; if i = 3 then WITH_IMPS_FLAGS_COUNT := ( WITH_IMPS_FLAGS_COUNT + 1 ) mod 4; i := WITH_IMPS_FLAGS_COUNT; hash2 := 2*((hash+31*i) mod 11001) + 1; fi; WITH_IMPS_FLAGS_CACHE_MISS := WITH_IMPS_FLAGS_CACHE_MISS + 1; with := flags; changed := true; while changed do changed := false; for imp in IMPLICATIONS do if IS_SUBSET_FLAGS( with, imp[2] ) and not IS_SUBSET_FLAGS( with, imp[1] ) then with := AND_FLAGS( with, imp[1] ); changed := true; fi; od; od; WITH_IMPS_FLAGS_CACHE[hash2 ] := flags; WITH_IMPS_FLAGS_CACHE[hash2+1] := with; return with; end ); ############################################################################# ## #F RankFilter( ) . . . . . . . . . . . . . . . . rank of a filter ## ## Compute the rank including the hidden implications. ## ## (When completion files are used, the precomputed ranks are used. ## Therefore, `RankFilter' is set in `init.g' to appropriate values; ## the function that really computes the rank is `RANK_FILTER'.) ## UNBIND_GLOBAL( "RANK_FILTER" ); BIND_GLOBAL( "RANK_FILTER", function( filter ) local rank, flags, i; rank := 0; if IS_FUNCTION(filter) then flags := FLAGS_FILTER(filter); else flags := filter; fi; for i in TRUES_FLAGS(WITH_HIDDEN_IMPS_FLAGS(flags)) do if IsBound(RANK_FILTERS[i]) then rank := rank + RANK_FILTERS[i]; else rank := rank + 1; fi; od; return rank; end ); RankFilter := RANK_FILTER; UNBIND_GLOBAL( "RANK_FILTER_STORE" ); BIND_GLOBAL( "RANK_FILTER_STORE", function( filter ) local hash, rank, flags; if IS_FUNCTION(filter) then flags := FLAGS_FILTER(filter); else flags := filter; fi; hash := HASH_FLAGS(flags); rank := RANK_FILTER(flags); ADD_LIST( RANK_FILTER_LIST_CURRENT, hash ); ADD_LIST( RANK_FILTER_LIST_CURRENT, rank ); return rank; end ); UNBIND_GLOBAL( "RANK_FILTER_COMPLETION" ); BIND_GLOBAL( "RANK_FILTER_COMPLETION", function( filter ) local hash, flags; if IS_FUNCTION(filter) then flags := FLAGS_FILTER(filter); else flags := filter; fi; hash := HASH_FLAGS(flags); if hash <> RANK_FILTER_LIST[RANK_FILTER_COUNT] then Error( "corrupted completion file" ); fi; RANK_FILTER_COUNT := RANK_FILTER_COUNT+2; return RANK_FILTER_LIST[RANK_FILTER_COUNT-1]; end ); ############################################################################# ## #E filter1.g . . . . . . . . . . . . . . . . . . . . . . . . . . . ends here ## gap-4r6p5/lib/helpview.gd0000644000175000017500000000300612172557252014045 0ustar billbill############################################################################# ## #W helpview.gd GAP Library Frank Lübeck ## ## #Y Copyright (C) 2001, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 2001 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## The files helpview.g{d,i} contain the configuration mechanism for the ## different help viewer. ## ## <#GAPDoc Label="HELP_VIEWER_INFO"> ## ## ## ## The record contains one component for each ## help viewer. Each such component is a record with two components: ## .type and .show. ##

## The component .type refers to one of the types recognized ## by the HelpData handler function explained in the previous ## section (currently one of "text", "url", "dvi", ## or "pdf"). ##

## The component .show is a function which gets as input the result ## of a corresponding HelpData handler call, if it was not fail. ## This function has to perform the actual display of the data. (E.g., by ## calling a function like or by starting up an external ## viewer program.) ## ## ## <#/GAPDoc> DeclareGlobalVariable("HELP_VIEWER_INFO"); DeclareGlobalFunction("FindWindowId"); DeclareGlobalFunction("SetHelpViewer"); gap-4r6p5/lib/algfp.gi0000644000175000017500000005707412172557252013336 0ustar billbill############################################################################# ## #W algfp.gi GAP library Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the methods for finitely presented algebras. ## So far, there are not many. ## ############################################################################# ## #M ElementOfFpAlgebra( , ) . . . . for family of f.p. alg.elms. ## InstallMethod(ElementOfFpAlgebra, "for family of fp. alg. elements and ring element", true, [ IsElementOfFpAlgebraFamily, IsRingElement ], 0, function( fam, elm ) return Objectify( fam!.defaultType, [ Immutable( elm ) ] ); end ); ############################################################################# ## #M ElementOfFpAlgebra( , ) . . for family with nice normal form ## InstallMethod( ElementOfFpAlgebra, "for fp. alg. elms. family with normal form, and ring element", true, [ IsElementOfFpAlgebraFamily and HasNiceNormalFormByExtRepFunction, IsRingElement ], 0, function( Fam, elm ) return NiceNormalFormByExtRepFunction( Fam )( Fam, ExtRepOfObj( elm ) ); end ); ############################################################################# ## #M ExtRepOfObj( ) . . . . . . . . . . . . . for f.p. algebra element ## ## The external representation of elements in an f.p. algebra is defined as ## a list of length 2, the first entry being the zero coefficient, ## the second being a zipped list containing the external representations ## of the monomials and their coefficients. ## InstallMethod( ExtRepOfObj, "for f.p. algebra element", true, [ IsElementOfFpAlgebra and IsPackedElementDefaultRep ], 0, elm -> ExtRepOfObj( elm![1] ) ); ############################################################################# ## #M ObjByExtRep( , ) . for f.p. alg. elms. fam. with normal form ## InstallMethod( ObjByExtRep, "for family of f.p. algebra elements with normal form", true, [ IsElementOfFpAlgebraFamily and HasNiceNormalFormByExtRepFunction, IsList ], 0, function( Fam, descr ) return NiceNormalFormByExtRepFunction( Fam )( Fam, descr ); end ); ############################################################################ ## #M MappedExpression( , , ) ## BindGlobal( "MappedExpressionForElementOfFreeAssociativeAlgebra", function( expr, gens1, gens2 ) local mapped, # the mapped expression, result gen, # one in `gens1' one, # 1 of the coefficients field MappedWord, # local function to map words i, # loop over summands pos; # position in a list expr:= ExtRepOfObj( expr )[2]; if IsEmpty( expr ) then return Zero( gens2[1] ); fi; # Get the numbers corresponding to the generators. gens1:= List( gens1, x -> ExtRepOfObj( x )[2] ); for i in [ 1 .. Length( gens1 ) ] do gen:= gens1[i]; if Length( gen ) = 2 and IsOne( gen[2] ) then gen:= gen[1]; if Length( gen ) = 0 then gens1[i]:= 0; elif Length( gen ) = 2 and gen[2] = 1 then gens1[i]:= gen[1]; else Error( " must be list of generators or identity" ); fi; else Error( " must be list of generators or identity" ); fi; od; #T This was quite expensive. #T Better introduce `MappedExpressions' to do this work not so often? one:= One( expr[2] ); MappedWord:= function( word ) local mapped, i; mapped:= gens2[ Position( gens1, word[1], 0 ) ] ^ word[2]; for i in [ 4, 6 .. Length( word ) ] do if word[i] = 1 then mapped:= mapped * gens2[ Position( gens1, word[i-1], 0 ) ]; else mapped:= mapped * gens2[ Position( gens1, word[i-1], 0 ) ] ^ word[i]; fi; od; return mapped; end; # The empty word can be at most at the first position. if IsEmpty( expr[1] ) then pos:= Position( gens1, 0, 0 ); if pos <> fail then mapped:= gens2[ pos ]; else mapped:= One( gens2[1] ); fi; else mapped:= MappedWord( expr[1] ); fi; # Avoid to multiply explicitly with 1 in order to avoid deep trees. if expr[2] <> one then mapped:= expr[2] * mapped; fi; for i in [ 4, 6 .. Length( expr ) ] do if expr[i] = one then mapped:= mapped + MappedWord( expr[ i-1 ] ); else mapped:= mapped + expr[i] * MappedWord( expr[ i-1 ] ); fi; od; return mapped; end ); #T special method for expression trees! (see GAP 3.5) InstallMethod( MappedExpression, "for element of f.p. algebra, and two lists of generators", IsElmsCollsX, [ IsElementOfFpAlgebra, IsHomogeneousList, IsHomogeneousList ], 0, #T install same method for free ass. algebra elements! MappedExpressionForElementOfFreeAssociativeAlgebra ); ############################################################################# ## #M \=( , ) . . . . . . . . for two normalized f.p. algebra elements ## InstallMethod( \=, "for two normalized f.p. algebra elements", IsIdenticalObj, [ IsElementOfFpAlgebra and IsNormalForm, IsElementOfFpAlgebra and IsNormalForm ], 0, function( x, y ) return ExtRepOfObj( x ) = ExtRepOfObj( y ); end ); #T missing: \= method to look for normal form in the family ############################################################################# ## #M \=( , ) . . . . . . . . . . . . . . for two f.p. algebra elements ## InstallMethod( \=, "for two f.p. algebra elements (try nice monomorphism)", IsIdenticalObj, [ IsElementOfFpAlgebra, IsElementOfFpAlgebra ], 0, function( x, y ) local hom; hom:= NiceAlgebraMonomorphism( FamilyObj( x )!.wholeAlgebra ); if hom = fail then TryNextMethod(); fi; return ImagesRepresentative( hom, x ) = ImagesRepresentative( hom, y ); end ); ############################################################################# ## #M \<( , ) . . . . . . . . for two normalized f.p. algebra elements ## ## The ordering is defined as follows. ## Expressions with less summands are shorter, ## and for expressions with the same number of summands, ## the words in algebra generators and the coefficients are compared ## according to the ordering in the external representation. ## InstallMethod( \<, "for two normalized f.p. algebra elements", IsIdenticalObj, [ IsElementOfFpAlgebra and IsNormalForm, IsElementOfFpAlgebra and IsNormalForm ], 0, function( x, y ) local lenx, leny, i; x:= ExtRepOfObj( x )[2]; y:= ExtRepOfObj( y )[2]; lenx:= Length( x ); leny:= Length( y ); # Compare the lengths. if lenx < leny then return true; elif leny < lenx then return false; fi; # For expressions of same length, compare the summands. for i in [ 1 .. lenx ] do if x[i] < y[i] then return true; elif y[i] < x[i] then return false; fi; od; # The operands are equal. return false; end ); ############################################################################# ## #M \<( , ) . . . . . . . . . . . . . . for two f.p. algebra elements ## InstallMethod( \<, "for two f.p. algebra elements (try nice monomorphism)", IsIdenticalObj, [ IsElementOfFpAlgebra, IsElementOfFpAlgebra ], 0, function( x, y ) local hom; hom:= NiceAlgebraMonomorphism( FamilyObj( x )!.wholeAlgebra ); if hom = fail then TryNextMethod(); fi; return ImagesRepresentative( hom, x ) < ImagesRepresentative( hom, y ); end ); ############################################################################# ## #M FactorFreeAlgebraByRelators( , ) . . . factor of free algebra ## InstallGlobalFunction( FactorFreeAlgebraByRelators, function( F, rels ) local A, fam; # Create a new family. fam := NewFamily( "FamilyElementsFpAlgebra", IsElementOfFpAlgebra ); # Create the default type for the elements. fam!.defaultType := NewType( fam, IsElementOfFpAlgebra and IsPackedElementDefaultRep ); fam!.freeAlgebra := F; fam!.relators := Immutable( rels ); fam!.familyRing := FamilyObj(LeftActingDomain(F)); # We do not set the characteristic since this depends on the fact # whether or not we are 0-dimensional. # Create the algebra. if IsAlgebraWithOne( F ) then A := Objectify( NewType( CollectionsFamily( fam ), IsSubalgebraFpAlgebra and IsAlgebraWithOne and IsWholeFamily and IsAttributeStoringRep ), rec() ); SetLeftActingDomain( A, LeftActingDomain( F ) ); SetGeneratorsOfAlgebraWithOne( A, List( GeneratorsOfAlgebraWithOne( F ), i -> ElementOfFpAlgebra( fam, i ) ) ); else A := Objectify( NewType( CollectionsFamily( fam ), IsSubalgebraFpAlgebra and IsWholeFamily and IsAttributeStoringRep ), rec() ); SetLeftActingDomain( A, LeftActingDomain( F ) ); SetGeneratorsOfAlgebra( A, List( GeneratorsOfAlgebra( F ), i -> ElementOfFpAlgebra( fam, i ) ) ); fi; SetZero( fam, ElementOfFpAlgebra( fam, Zero( F ) ) ); UseFactorRelation( F, rels, A ); SetIsFullFpAlgebra( A, true ); fam!.wholeAlgebra:= A; return A; end ); ############################################################################# ## #M Characteristic( ) #M Characteristic( ) #M Characteristic( ) ## ## (via delegations) ## InstallMethod( Characteristic, "for an elements family of an fp subalgebra", [ IsElementOfFpAlgebraFamily ], function( fam ) local A,n,one,x; A := fam!.wholeAlgebra; if IsAlgebraWithOne(A) then one := One(A); if Zero(A) = one then return 1; fi; else if Dimension(A) = 0 then return 1; fi; fi; if IsField(LeftActingDomain(A)) then return Characteristic(LeftActingDomain(A)); else if not IsAlgebraWithOne(A) then return fail; fi; # This might be horribly slow and might not terminate if the # characteristic is 0: n := 2; x := one+one; while not(IsZero(x)) do x := x + one; n := n + 1; od; return n; fi; end ); ############################################################################# ## #M FreeGeneratorsOfFpAlgebra( ) ## InstallMethod( FreeGeneratorsOfFpAlgebra, "for a full f.p. algebra", true, [ IsSubalgebraFpAlgebra and IsFullFpAlgebra ], 0, function( A ) A:= ElementsFamily( FamilyObj( A ) )!.freeAlgebra; if IsMagmaWithOne( A ) then return GeneratorsOfAlgebraWithOne( A ); else return GeneratorsOfAlgebra( A ); fi; end ); ############################################################################ ## #M RelatorsOfFpAlgebra( ) ## InstallMethod( RelatorsOfFpAlgebra, "for a full f.p. algebra", true, [ IsSubalgebraFpAlgebra and IsFullFpAlgebra ], 0, A -> ElementsFamily( FamilyObj( A ) )!.relators ); ############################################################################# ## #A FreeAlgebraOfFpAlgebra( ) ## InstallMethod( FreeAlgebraOfFpAlgebra, "for a full f.p. algebra", true, [ IsSubalgebraFpAlgebra and IsFullFpAlgebra ], 0, A -> ElementsFamily( FamilyObj( A ) )!.freeAlgebra ); ############################################################################# ## #M IsFullFpAlgebra( ) ## InstallOtherMethod( IsFullFpAlgebra, "for f. p. algebra", true, [ IsAlgebra and IsSubalgebraFpAlgebra ], 0, function( A ) local Fam; Fam:= ElementsFamily( FamilyObj( A ) ); return IsSubset( A, List( GeneratorsOfAlgebra( Fam!.freeAlgebra ), a -> ElementOfFpAlgebra( Fam, a ) ) ); end ); ############################################################################# ## #M NaturalHomomorphismByIdeal( , ) . . . . . for free alg. and ideal ## ## The algebra can be also a free magma ring. ## If it is finite dimensional then we prefer not to regard it as a ## f.p. algebra (modulo relations); ## there is a method for but to work with bases of and . ## InstallMethod( NaturalHomomorphismByIdeal, "for free algebra and ideal", IsIdenticalObj, [ IsMagmaRingModuloRelations, IsFLMLOR ], function( F, I ) local image, hom; if IsInt( Dimension( F ) ) then TryNextMethod(); fi; image:= FactorFreeAlgebraByRelators( F, GeneratorsOfIdeal( I ) ); if IsMagmaWithOne( F ) then hom:= AlgebraWithOneHomomorphismByImagesNC( F, image, GeneratorsOfAlgebraWithOne( F ), GeneratorsOfAlgebraWithOne( image ) ); else hom:= AlgebraHomomorphismByImagesNC( F, image, GeneratorsOfAlgebra( F ), GeneratorsOfAlgebra( image ) ); fi; SetIsSurjective( hom, true ); return hom; end ); ############################################################################# ## #M Print() ## InstallMethod(PrintObj, "fp algebra elements", true, [ IsElementOfFpAlgebra and IsPackedElementDefaultRep ], 0, function( e ) Print( "[", e![1], "]" ); end ); ############################################################################# ## #M \+( , ) ## InstallMethod( \+, "fp algebra elements", IsIdenticalObj, [ IsElementOfFpAlgebra and IsPackedElementDefaultRep, IsElementOfFpAlgebra and IsPackedElementDefaultRep ], 0, function( a, b ) return ElementOfFpAlgebra( FamilyObj( a ), a![1] + b![1] ); end ); ############################################################################# ## #M \-( , ) ## InstallMethod( \-, "fp algebra elements", IsIdenticalObj, [ IsElementOfFpAlgebra and IsPackedElementDefaultRep, IsElementOfFpAlgebra and IsPackedElementDefaultRep ], 0, function( a, b ) return ElementOfFpAlgebra( FamilyObj( a ), a![1] - b![1] ); end ); ############################################################################# ## #M AdditiveInverseOp( ) ## InstallMethod( AdditiveInverseOp, "fp algebra element", true, [ IsElementOfFpAlgebra and IsPackedElementDefaultRep ], 0, function( a ) return ElementOfFpAlgebra( FamilyObj( a ), AdditiveInverse( a![1] ) ); end ); ############################################################################# ## #M OneOp( ) ## InstallOtherMethod( OneOp, "for an f.p. algebra element", true, [ IsElementOfFpAlgebra and IsPackedElementDefaultRep ], 0, function( elm ) local one; one:= One( elm![1] ); if one <> fail then one:= ElementOfFpAlgebra( FamilyObj( elm ), one ); fi; return one; end ); ############################################################################# ## #M ZeroOp( ) ## InstallMethod( ZeroOp, "for an f.p. algebra element", true, [ IsElementOfFpAlgebra and IsPackedElementDefaultRep ], 0, elm -> ElementOfFpAlgebra( FamilyObj( elm ), Zero( elm![1] ) ) ); ############################################################################# ## #M \*( , ) ## InstallMethod( \*, "fp algebra elements", IsIdenticalObj, [ IsElementOfFpAlgebra and IsPackedElementDefaultRep, IsElementOfFpAlgebra and IsPackedElementDefaultRep ], 0, function( a, b ) return ElementOfFpAlgebra( FamilyObj( a ), a![1] * b![1] ); end); ############################################################################# ## #M \*( , ) ## InstallMethod( \*,"ring el *fp algebra el",IsRingsMagmaRings, [ IsRingElement, IsElementOfFpAlgebra and IsPackedElementDefaultRep ], 0, function( a, b ) return ElementOfFpAlgebra( FamilyObj( b ), a * b![1] ); end); ############################################################################# ## #M \*( , ) ## InstallMethod( \*,"fp algebra el*ring el",IsMagmaRingsRings, [ IsElementOfFpAlgebra and IsPackedElementDefaultRep, IsRingElement ], 0, function( a, b ) return ElementOfFpAlgebra( FamilyObj( a ), a![1] * b ); end); #AH Embedding can only be defined reasonably if a `One' different from #AH the zero is present #AH (The factor may collaps). #T The `One' of the factor may be equal to the `Zero', #T so the ``embedding'' can be defined as a mapping from the ring #T to the algebra, #T but it is injective only if the `One' is not the `Zero'. ############################################################################# ## #M IsomorphismMatrixFLMLOR( ) . . . . . . . . . . . . for a f.p. FLMLOR ## InstallMethod( IsomorphismMatrixFLMLOR, "for a f.p. FLMLOR", true, [ IsFLMLOR and IsSubalgebraFpAlgebra ], 0, A -> Error( "sorry, no method to compute a matrix algebra\n", "for a (not nec. associative) f.p. algebra" ) ); ############################################################################# ## #M IsomorphismMatrixFLMLOR( ) . . . . . . for a full f.p. assoc. FLMLOR ## ## We compute the operation homomorphism for acting on itself from the ## right. ## InstallMethod( IsomorphismMatrixFLMLOR, "for a full f.p. associative FLMLOR", true, [ IsFLMLORWithOne and IsSubalgebraFpAlgebra and IsAssociative and IsFullFpAlgebra ], 0, A -> OperationAlgebraHomomorphism( A, [ [ Zero( A ) ] ], OnRight ) ); #T change this: second argument should be the -module itself! ############################################################################# ## #M OperationAlgebraHomomorphism( , , ) ## InstallOtherMethod( OperationAlgebraHomomorphism, "for a full f.p. associative FLMLOR, a collection, and a function", true, [ IsFLMLORWithOne and IsSubalgebraFpAlgebra and IsAssociative and IsFullFpAlgebra, IsCollection, IsFunction ], 0, function( A, C, opr ) Error( "this case will eventually be handled by the Vector Enumerator\n", "which is not available yet" ); end ); ############################################################################# ## #M NiceAlgebraMonomorphism( ) . . . . . . for a full f.p. assoc. FLMLOR ## ## We delegate to `IsomorphismMatrixFLMLOR'. ## InstallMethod( NiceAlgebraMonomorphism, "for a full f.p. associative FLMLOR (call `IsomorphismMatrixFLMLOR')", true, [ IsFLMLORWithOne and IsSubalgebraFpAlgebra and IsAssociative and IsFullFpAlgebra ], 0, IsomorphismMatrixFLMLOR ); ############################################################################# ## #M IsFiniteDimensional( ) #M Dimension( ) ## #M NiceVector( , ) #M UglyVector( , ) ## ## Provided the f.~p. algebra knows its `NiceAlgebraMonomorphism' value, ## it is handled via nice bases. ## So we have to treat the case that this value is not (yet) known. ## Note that `Dimension' may ask whether is finite dimensional, ## so we must provide a (partial) method for it. ## ## The family of elements of stores its whole algebra, ## so it is reasonable to look whether this algebra knows already a ## nice monomorphism. ## InstallMethod( IsFiniteDimensional, "for f.p. algebra", true, [ IsSubalgebraFpAlgebra ], 0, function( A ) local iso; if HasNiceAlgebraMonomorphism( ElementsFamily( FamilyObj( A ) )!.wholeAlgebra ) then iso:= NiceAlgebraMonomorphism( ElementsFamily( FamilyObj( A ) )!.wholeAlgebra ); else iso:= IsomorphismMatrixFLMLOR( A ); fi; if iso <> fail then if IsAlgebraHomomorphismFromFpRep( iso ) then SetNiceAlgebraMonomorphism( A, iso ); fi; return true; fi; TryNextMethod(); end ); ############################################################################# ## #M NiceFreeLeftModuleInfo( ) #M NiceVector( , ) #M UglyVector( , ) ## InstallHandlingByNiceBasis( "IsFpAlgebraElementsSpace", rec( detect := function( F, gens, V, zero ) return IsElementOfFpAlgebraCollection( V ) and IsFreeLeftModule( V ); end, NiceFreeLeftModuleInfo := ReturnTrue, NiceVector := function( A, a ) local hom; hom:= NiceAlgebraMonomorphism( FamilyObj( a )!.wholeAlgebra ); if hom = fail then TryNextMethod(); fi; return ImagesRepresentative( hom, a ); end, UglyVector := function( A, r ) local hom; hom:= NiceAlgebraMonomorphism( ElementsFamily( FamilyObj( A ) )!.wholeAlgebra ); if hom = fail then TryNextMethod(); fi; return PreImagesRepresentative( hom, r ); end ) ); ############################################################################# ## #F FpAlgebraByGeneralizedCartanMatrix( , ) ## InstallGlobalFunction( FpAlgebraByGeneralizedCartanMatrix, function( F, A ) local n, # dimension of the matrix `A' i, j, k, # loop variables gensstrings, # names of algebra generators a, # algebra, result gens, # algebra generators e, h, f, # different portions of generators LieBracket, # function that computes the commutator rels, # list of relators rel; # one relator if not IsField( F ) then Error( " must be a field" ); elif not IsGeneralizedCartanMatrix( A ) then Error( " must be a generalized Cartan matrix" ); fi; n:= Length( A ); gensstrings:= []; for i in [ 1 .. n ] do gensstrings[ i ]:= Concatenation( "e", String(i) ); od; for i in [ 1 .. n ] do gensstrings[ n + i ]:= Concatenation( "h", String(i) ); od; for i in [ 1 .. n ] do gensstrings[ 2*n + i ]:= Concatenation( "f", String(i) ); od; a:= FreeAssociativeAlgebraWithOne( F, gensstrings ); gens:= GeneratorsOfAlgebraWithOne( a ); e:= gens{ [ 1 .. n ] }; h:= gens{ [ n + 1 .. 2*n ] }; f:= gens{ [ 2*n + 1 .. 3*n ] }; LieBracket:= function( A, B ) return A*B - B*A; end; rels:= []; for i in [ 1 .. n ] do for j in [ i+1 .. n ] do Add( rels, LieBracket( h[i], h[j] ) ); od; od; for i in [ 1 .. n ] do for j in [ 1 .. n ] do if i = j then Add( rels, LieBracket( e[i], f[i] ) - h[i] ); else Add( rels, LieBracket( e[i], f[j] ) ); fi; od; od; for i in [ 1 .. n ] do for j in [ 1 .. n ] do Add( rels, LieBracket( h[i], e[j] ) - A[i][j] * e[j] ); Add( rels, LieBracket( h[i], f[j] ) + A[i][j] * f[j] ); od; od; for i in [ 1 .. n ] do for j in [ i+1 .. n ] do if A[i][j] = 0 then Add( rels, LieBracket( e[i], e[j] ) ); Add( rels, LieBracket( f[i], f[j] ) ); fi; od; od; for i in [ 1 .. n ] do for j in [ 1 .. n ] do if i <> j then rel:= e[j]; for k in [ 1 .. 1 - A[i][j] ] do rel:= LieBracket( e[i], rel ); od; Add( rels, rel ); rel:= f[j]; for k in [ 1 .. 1 - A[i][j] ] do rel:= LieBracket( f[i], rel ); od; Add( rels, rel ); fi; od; od; # Return the algebra. return a / rels; end ); ############################################################################# ## #E gap-4r6p5/lib/grpmat.gi0000644000175000017500000010107112172557252013522 0ustar billbill############################################################################# ## #W grpmat.gi GAP Library Frank Celler ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the methods for matrix groups. ## ############################################################################# ## #M KnowsHowToDecompose( ) ## InstallMethod( KnowsHowToDecompose, "matrix groups", [ IsMatrixGroup, IsList ], ReturnFalse ); ############################################################################# ## #M DefaultFieldOfMatrixGroup( ) ## InstallMethod(DefaultFieldOfMatrixGroup,"for a matrix group",[IsMatrixGroup], function( grp ) local gens,R; gens:= GeneratorsOfGroup( grp ); if IsEmpty( gens ) then return Field( One( grp )[1][1] ); else R:=DefaultScalarDomainOfMatrixList(gens); if not IsField(R) then R:=FieldOfMatrixList(gens); fi; fi; return R; end ); InstallMethod( DefaultFieldOfMatrixGroup, "for matrix group over the cyclotomics", [ IsCyclotomicMatrixGroup ], grp -> Cyclotomics ); InstallMethod( DefaultFieldOfMatrixGroup, "for a matrix group over an s.c. algebra", [ IsMatrixGroup and IsSCAlgebraObjCollCollColl ], grp -> ElementsFamily( ElementsFamily( ElementsFamily( FamilyObj( grp ) ) ) )!.fullSCAlgebra ); # InstallOtherMethod( DefaultFieldOfMatrixGroup, # "from source of nice monomorphism", # [ IsMatrixGroup and HasNiceMonomorphism ], # grp -> DefaultFieldOfMatrixGroup( Source( NiceMonomorphism( grp ) ) ) ); #T this was illegal, #T since it assumes that the source is a different object than the #T original group; if this fails then we run into an infinite recursion! ############################################################################# ## #M FieldOfMatrixGroup( ) ## InstallMethod( FieldOfMatrixGroup, "for a matrix group", [ IsMatrixGroup ], function( grp ) local gens; gens:= GeneratorsOfGroup( grp ); if IsEmpty( gens ) then return Field( One( grp )[1][1] ); else return FieldOfMatrixList(gens); fi; end ); ############################################################################# ## #M DimensionOfMatrixGroup( ) ## InstallMethod( DimensionOfMatrixGroup, "from generators", [ IsMatrixGroup and HasGeneratorsOfGroup ], function( grp ) if not IsEmpty( GeneratorsOfGroup( grp ) ) then return Length( GeneratorsOfGroup( grp )[ 1 ] ); else TryNextMethod(); fi; end ); InstallMethod( DimensionOfMatrixGroup, "from one", [ IsMatrixGroup and HasOne ], 1, grp -> Length( One( grp ) ) ); # InstallOtherMethod( DimensionOfMatrixGroup, # "from source of nice monomorphism", # [ IsMatrixGroup and HasNiceMonomorphism ], # grp -> DimensionOfMatrixGroup( Source( NiceMonomorphism( grp ) ) ) ); #T this was illegal, #T since it assumes that the source is a different object than the #T original group; if this fails then we run into an infinite recursion! #T why not delegate to `Representative' instead of installing #T different methods? ############################################################################# ## #M One( ) ## InstallOtherMethod( One, "for matrix group, call `IdentityMat'", [ IsMatrixGroup ], grp -> ImmutableMatrix(DefaultFieldOfMatrixGroup(grp), IdentityMat( DimensionOfMatrixGroup( grp ), DefaultFieldOfMatrixGroup( grp ) ) )); ############################################################################# ## #M TransposedMatrixGroup( ) . . . . . . . . .transpose of a matrix group ## InstallMethod( TransposedMatrixGroup, [ IsMatrixGroup ], function( G ) local T; T := GroupByGenerators( List( GeneratorsOfGroup( G ), TransposedMat ), One( G ) ); #T avoid calling `One'! UseIsomorphismRelation( G, T ); SetTransposedMatrixGroup( T, G ); return T; end ); ############################################################################# ## #F NaturalActedSpace( [,], ) ## InstallGlobalFunction(NaturalActedSpace,function(arg) local f,i,j,veclist,acts; veclist:=arg[Length(arg)]; acts:=arg[Length(arg)-1]; if Length(arg)=3 and IsGroup(arg[1]) and acts=GeneratorsOfGroup(arg[1]) then f:=DefaultFieldOfMatrixGroup(arg[1]); else f:=FieldOfMatrixList(acts); fi; for i in veclist do for j in i do if not j in f then f:=ClosureField(f,j); fi; od; od; return f^Length(veclist[1]); end); InstallGlobalFunction(BasisVectorsForMatrixAction,function(G) local F, gens, evals, espaces, is, ise, gen, i, j,module,list,ind,vecs,mins; F := DefaultFieldOfMatrixGroup(G); # `Cyclotomics', the default field for rational matrix groups causes # problems with a subsequent factorization if IsIdenticalObj(F,Cyclotomics) then # cyclotomics really is too large here F:=FieldOfMatrixGroup(G); fi; list:=[]; if false and ValueOption("nosubmodules")=fail and IsFinite(F) then module:=GModuleByMats(GeneratorsOfGroup(G),F); if not MTX.IsIrreducible(module) then mins:=Filtered(MTX.BasesCompositionSeries(module),x->Length(x)>0); if Length(mins)<=5 then mins:=MTX.BasesMinimalSubmodules(module); else if Length(mins)>7 then mins:=mins{Set(List([1..7],x->Random([1..Length(mins)])))}; fi; fi; # now get potential basis vectors from submodules for i in mins do ind:=MTX.InducedActionSubmodule(module,i); vecs:=BasisVectorsForMatrixAction(Group(ind.generators):nosubmodules); Append(list,vecs*i); od; fi; fi; # use Murray/OBrien method gens := ShallowCopy( GeneratorsOfGroup( G ) ); # Need copy for mutability while Length( gens ) < 10 do Add( gens, PseudoRandom( G ) ); od; evals := []; espaces := []; for gen in gens do evals := Concatenation( evals, GeneralisedEigenvalues(F,gen) ); espaces := Concatenation( espaces, GeneralisedEigenspaces(F,gen) ); od; is:=[]; # the `AddSet' wil automatically put small spaces first for i in [1..Length(espaces)] do for j in [i+1..Length(espaces)] do ise:=Intersection(espaces[i],espaces[j]); if Dimension(ise)>0 and not ise in is then Add(is,ise); fi; od; od; Append(list,Concatenation(List(is,i->BasisVectors(Basis(i))))); return list; end); ############################################################################# ## #F DoSparseLinearActionOnFaithfulSubset( ,, ) ## ## computes a linear action of the matrix group on the span of the ## standard basis. The action must be `OnRight', or ## `OnLines'. The calculation of further orbits stops, once a basis for the ## underlying space has been reached, often giving a smaller degree ## permutation representation. ## The boolean indicates, whether the domain will be sorted. BindGlobal("DoSparseLinearActionOnFaithfulSubset", function(G,act,sort) local field, dict, acts, start, j, zerov, zero, dim, base, partbas, heads, orb, delay, permimg, maxlim, starti, ll, ltwa, img, v, en, p, kill, i, lo, imgs, xset, hom, R; field:=DefaultFieldOfMatrixGroup(G); #dict := NewDictionary( One(G)[1], true , field ^ Length( One( G ) ) ); acts:=GeneratorsOfGroup(G); if Length(acts)=0 then start:=One(G); elif act=OnRight then start:=Concatenation(BasisVectorsForMatrixAction(G),One(G)); elif act=OnLines then j:=One(G); start:=Concatenation(List(BasisVectorsForMatrixAction(G), x->OnLines(x,j)),j); else Error("illegal action"); fi; zerov:=Zero(start[1]); zero:=zerov[1]; dim:=Length(zerov); base:=[]; # elements of start which are a base in the permgrp sense partbas:=[]; # la basis of space spanned so far heads:=[]; orb:=[]; delay:=[]; # Vectors we delay later, because they are potentially very # expensive. permimg:=List(acts,i->[]); maxlim:=200000; starti:=1; while Length(partbas)Length(start) then Sort(delay); for i in delay do Add(start,i[2]); od; maxlim:=maxlim*100; Info(InfoGroup,2, "original pool exhausted, use delayed. maxlim=",maxlim); delay:=[]; fi; ll:=Length(orb); ltwa:=Maximum(maxlim,(ll+1)*20); img:=start[starti]; v:=ShallowCopy(img); for j in [ 1 .. Length( heads ) ] do en:=v[heads[j]]; if en <> zero then AddRowVector( v, partbas[j], - en ); fi; od; fi; if not IsZero(v) then dict := NewDictionary( v, true , field ^ Length( One( G ) ) ); # force `img' over field if (Size(field)=2 and not IsGF2VectorRep(img)) or (Size(field)>2 and Size(field)<=256 and not (Is8BitVectorRep(img) and Q_VEC8BIT(img)=Size(field))) then img:=ShallowCopy(img); ConvertToVectorRep(img,Size(field)); fi; Add(orb,img); p:=Length(orb); AddDictionary(dict,img,Length(orb)); kill:=false; # orbit algorithm with image keeper while p<=Length(orb) do i:=1; while i<=Length(acts) do img := act(orb[p],acts[i]); v:=LookupDictionary(dict,img); if v=fail then if Length(orb)>ltwa then Info(InfoGroup,2,"Very long orbit, delay"); Add(delay,[Length(orb)-ll,orb[ll+1]]); kill:=true; for p in [ll+1..Length(orb)] do Unbind(orb[p]); for i in [1..Length(acts)] do Unbind(permimg[i][p]); od; od; i:=Length(acts)+1; p:=Length(orb)+1; else Add(orb,img); AddDictionary(dict,img,Length(orb)); permimg[i][p]:=Length(orb); fi; else permimg[i][p]:=v; fi; i:=i+1; od; p:=p+1; od; fi; starti:=starti+1; if not kill then # break criterion: do we actually *want* more points? i:=ll+1; lo:=Length(orb); while i<=lo do v:=ShallowCopy(orb[i]); for j in [ 1 .. Length( heads ) ] do en:=v[heads[j]]; if en <> zero then AddRowVector( v, partbas[j], - en ); fi; od; if v<>zerov then Add(base,orb[i]); Add(partbas,ShallowCopy(orb[i])); TriangulizeMat(partbas); heads:=List(partbas,PositionNonZero); if Length(partbas)>=dim then # full dimension reached i:=lo; fi; fi; i:=i+1; od; fi; od; # Das Dictionary hat seine Schuldigkeit getan Unbind(dict); Info(InfoGroup,1,"found degree=",Length(orb)); # any asymptotic argument is pointless here: In practice sorting is much # quicker than image computation. if sort then imgs:=Sortex(orb); # permutation we must apply to the points to be sorted. # was: permimg:=List(permimg,i->OnTuples(Permuted(i,imgs),imgs)); # run in loop to save memory for i in [1..Length(permimg)] do permimg[i]:=Permuted(permimg[i],imgs); permimg[i]:=OnTuples(permimg[i],imgs); od; fi; #check routine # Print("check!\n"); # for p in [1..Length(orb)] do # for i in [1..Length(acts)] do # img:=act(orb[p],acts[i]); # v:=LookupDictionary(dict,img); # if v<>permimg[i][p] then # Error("wrong!"); # fi; # od; # od; # Error("hier"); for i in [1..Length(permimg)] do permimg[i]:=PermList(permimg[i]); od; if fail in permimg then Error("not permutations"); fi; xset:=ExternalSet( G, orb, acts, acts, act); # when acting projectively the sum of the base vectors must be part of the # base -- that will guarantee that we can distinguish diagonal from scalar # matrices. if act=OnLines then if Length(base)<=dim then Add(base,OnLines(Sum(base),One(G))); fi; fi; # We know that the points corresponding to `start' give a base of the # vector space. We can use # this to get images quickly, using a stabilizer chain in the permutation # group SetBaseOfGroup( xset, base ); xset!.basePermImage:=List(base,b->PositionCanonical(orb,b)); hom := ActionHomomorphism( xset,"surjective" ); if act <> OnLines then SetIsInjective(hom, true); # we know by construction that it is injective. fi; R:=Group(permimg,()); # `permimg' arose from `PermList' SetBaseOfGroup(R,xset!.basePermImage); if HasSize(G) and act=OnRight then SetSize(R,Size(G)); # faithful action fi; SetRange(hom,R); SetImagesSource(hom,R); SetMappingGeneratorsImages(hom,[acts,permimg]); # p:=RUN_IN_GGMBI; # no niceomorphism translation here # RUN_IN_GGMBI:=true; # SetAsGroupGeneralMappingByImages ( hom, GroupHomomorphismByImagesNC # ( G, R, acts, permimg ) ); # # SetFilterObj( hom, IsActionHomomorphismByBase ); # RUN_IN_GGMBI:=p; base:=ImmutableMatrix(field,base); SetLinearActionBasis(hom,base); return hom; end); ############################################################################# ## #M IsomorphismPermGroup( ) ## BindGlobal( "NicomorphismOfGeneralMatrixGroup", function( grp,canon,sort ) local nice,img,module,b; b:=SeedFaithfulAction(grp); if canon=false and b<>fail then Info(InfoGroup,1,"using predefined action seed"); # the user (or code) gave a seed for a faithful action nice:=MultiActionsHomomorphism(grp,b.points,b.ops); # don't be too clever if it is a matrix over a non-field domain elif not IsField(DefaultFieldOfMatrixGroup(grp)) then Info(InfoGroup,1,"over nonfield"); #nice:=ActionHomomorphism( grp,AsSSortedList(grp),OnRight,"surjective"); if canon then nice:=SortedSparseActionHomomorphism( grp, One( grp ) ); SetIsCanonicalNiceMonomorphism(nice,true); else nice:=SparseActionHomomorphism( grp, One( grp ) ); nice:=nice*SmallerDegreePermutationRepresentation(Image(nice)); fi; elif IsFinite(grp) and ( (HasIsNaturalGL(grp) and IsNaturalGL(grp)) or (HasIsNaturalSL(grp) and IsNaturalSL(grp)) ) then # for full GL/SL we get never better than the full vector space as domain Info(InfoGroup,1,"is GL/SL"); return NicomorphismFFMatGroupOnFullSpace(grp); elif canon then Info(InfoGroup,1,"canonical niceo"); nice:=SortedSparseActionHomomorphism( grp, One( grp ) ); SetIsCanonicalNiceMonomorphism(nice,true); else Info(InfoGroup,1,"act to find base"); nice:=DoSparseLinearActionOnFaithfulSubset( grp, OnRight, sort); SetIsSurjective( nice, true ); img:=Image(nice); if not IsFinite(DefaultFieldOfMatrixGroup(grp)) or Length(GeneratorsOfGroup(grp))=0 then module:=fail; else module:=GModuleByMats(GeneratorsOfGroup(grp),DefaultFieldOfMatrixGroup(grp)); fi; #improve, # try hard, unless absirr and orbit lengths at least 1/q^2 of domain -- #then we expect improvements to be of little help if module<>fail and not (NrMovedPoints(img)>= Size(DefaultFieldOfMatrixGroup(grp))^(Length(One(grp))-2) and MTX.IsAbsolutelyIrreducible(module)) then nice:=nice*SmallerDegreePermutationRepresentation(img); else nice:=nice*SmallerDegreePermutationRepresentation(img:cheap:=true); fi; fi; SetIsInjective( nice, true ); return nice; end ); InstallMethod( IsomorphismPermGroup,"matrix group", true, [ IsMatrixGroup ], 10, function(G) local map; if HasNiceMonomorphism(G) and IsPermGroup(Range(NiceMonomorphism(G))) then map:=NiceMonomorphism(G); if IsIdenticalObj(Source(map),G) then return map; fi; return GeneralRestrictedMapping(map,G,Image(map,G)); else if not HasIsFinite(G) then Info(InfoWarning,1, "IsomorphismPermGroup: The group is not known to be finite"); fi; map:=NicomorphismOfGeneralMatrixGroup(G,false,false); SetNiceMonomorphism(G,map); return map; fi; end); ############################################################################# ## #M NiceMonomorphism( ) ## InstallMethod( NiceMonomorphism,"use NicomorphismOfGeneralMatrixGroup", [ IsMatrixGroup and IsFinite ], G->NicomorphismOfGeneralMatrixGroup(G,false,false)); ############################################################################# ## #M CanonicalNiceMonomorphism( ) ## InstallMethod( CanonicalNiceMonomorphism, [ IsMatrixGroup and IsFinite ], G->NicomorphismOfGeneralMatrixGroup(G,true,true)); ############################################################################# ## #F ProjectiveActionHomomorphismMatrixGroup() ## InstallGlobalFunction(ProjectiveActionHomomorphismMatrixGroup, G->DoSparseLinearActionOnFaithfulSubset(G,OnLines,true)); ############################################################################# ## #M GeneratorsSmallest() ## ## This algorithm takes :=the points corresponding to the standard basis ## and then computes a minimal generating system for the permutation group ## wrt. this base . As lexicographical comparison of matrices is ## compatible with comparison of base images wrt. the standard base this ## also is the smallest (irredundant) generating set of the matrix group! InstallMethod(GeneratorsSmallest,"matrix group via niceo", [IsMatrixGroup and IsFinite], function(G) local gens,s,dom,mon,no; mon:=CanonicalNiceMonomorphism(G); no:=Image(mon,G); dom:=UnderlyingExternalSet(mon); s:=StabChainOp(no,rec(base:=List(BaseOfGroup(dom), i->Position(HomeEnumerator(dom),i)))); # call the recursive function to do the work gens:= SCMinSmaGens( no, s, [], One( no ), true ).gens; SetMinimalStabChain(G,s); return List(gens,i->PreImagesRepresentative(mon,i)); end); ############################################################################# ## #M MinimalStabChain() ## ## used for cosets where we probably won't need the smallest generators InstallOtherMethod(MinimalStabChain,"matrix group via niceo", [IsMatrixGroup and IsFinite], function(G) local s,dom,mon,no; mon:=CanonicalNiceMonomorphism(G); no:=Image(mon,G); dom:=UnderlyingExternalSet(mon); s:=StabChainOp(no,rec(base:=List(BaseOfGroup(dom), i->Position(HomeEnumerator(dom),i)))); # call the recursive function to do the work SCMinSmaGens( no, s, [], One( no ), false ); return s; end); ############################################################################# ## #M LargestElementGroup() ## InstallOtherMethod(LargestElementGroup,"matrix group via niceo", [IsMatrixGroup and IsFinite], function(G) local s,dom,mon, img; mon:=CanonicalNiceMonomorphism(G); dom:=UnderlyingExternalSet(mon); img:= Image( mon, G ); s:=StabChainOp( img, rec(base:=List(BaseOfGroup(dom), i->Position(HomeEnumerator(dom),i)))); # call the recursive function to do the work s:= LargestElementStabChain( s, One( img ) ); return PreImagesRepresentative(mon,s); end); ############################################################################# ## #M CanonicalRightCosetElement(,) ## InstallMethod(CanonicalRightCosetElement,"finite matric group",IsCollsElms, [IsMatrixGroup and IsFinite,IsMatrix], function(U,e) local mon,dom,S,o,oimgs,p,i,g; mon:=CanonicalNiceMonomorphism(U); dom:=UnderlyingExternalSet(mon); S:=StabChainOp(Image(mon,U),rec(base:=List(BaseOfGroup(dom), i->Position(HomeEnumerator(dom),i)))); dom:=HomeEnumerator(dom); while not IsEmpty(S.generators) do o:=dom{S.orbit}; # the relevant vectors oimgs:=List(o,i->i*e); #their images # find the smallest image p:=1; for i in [2..Length(oimgs)] do if oimgs[i]p do g:=LeftQuotient(S.transversal[p/g],g); od; # change by corresponding matrix element e:=PreImagesRepresentative(mon,g)*e; S:=S.stabilizer; od; return e; end); ############################################################################# ## #M ViewObj( ) ## InstallMethod( ViewObj, "for a matrix group with stored generators", [ IsMatrixGroup and HasGeneratorsOfGroup ], function(G) local gens; gens:=GeneratorsOfGroup(G); if Length(gens)>0 and Length(gens)* Length(gens[1])^2 / GAPInfo.ViewLength > 8 then Print(""); else Print("Group("); ViewObj(GeneratorsOfGroup(G)); Print(")"); fi; end); ############################################################################# ## #M ViewObj( ) ## InstallMethod( ViewObj,"for a matrix group", [ IsMatrixGroup ], function(G) local d; d:=DimensionOfMatrixGroup(G); Print(""); elif HasDefaultFieldOfMatrixGroup(G) then Print(" over ",DefaultFieldOfMatrixGroup(G),">"); else Print(" in characteristic ",Characteristic(One(G)),">"); fi; end); ############################################################################# ## #M PrintObj( ) ## InstallMethod( PrintObj,"for a matrix group", [ IsMatrixGroup ], function(G) local l; l:=GeneratorsOfGroup(G); if Length(l)=0 then Print("Group([],",One(G),")"); else Print("Group(",l,")"); fi; end); ############################################################################# ## #M IsGeneralLinearGroup() ## InstallMethod(IsGeneralLinearGroup,"try natural",[IsMatrixGroup], function(G) if HasIsNaturalGL(G) and IsNaturalGL(G) then return true; else TryNextMethod(); fi; end); ############################################################################# ## #M IsSubgroupSL ## InstallMethod(IsSubgroupSL,"determinant test for generators", [IsMatrixGroup and HasGeneratorsOfGroup], G -> ForAll(GeneratorsOfGroup(G),i->IsOne(DeterminantMat(i))) ); ############################################################################# ## #M in . . . . . . . . . . . . . . . . . . . . is form invariant? ## InstallMethod( \in, "respecting bilinear form", IsElmsColls, [ IsMatrix, IsFullSubgroupGLorSLRespectingBilinearForm ], NICE_FLAGS, # this method is better than the one using a nice monom. function( mat, G ) local inv; if not IsSubset( FieldOfMatrixGroup( G ), FieldOfMatrixList( [ mat ] ) ) or ( IsSubgroupSL( G ) and not IsOne( DeterminantMat( mat ) ) ) then return false; fi; inv:= InvariantBilinearForm(G).matrix; return mat * inv * TransposedMat( mat ) = inv; end ); InstallMethod( \in, "respecting sesquilinear form", IsElmsColls, [ IsMatrix, IsFullSubgroupGLorSLRespectingSesquilinearForm ], NICE_FLAGS, # this method is better than the one using a nice monom. function( mat, G ) local pow, inv; if not IsSubset( FieldOfMatrixGroup( G ), FieldOfMatrixList( [ mat ] ) ) or ( IsSubgroupSL( G ) and not IsOne( DeterminantMat( mat ) ) ) then return false; fi; pow:= RootInt( Size( FieldOfMatrixGroup( G ) ) ); inv:= InvariantSesquilinearForm(G).matrix; return mat * inv * List( TransposedMat( mat ), row -> List( row, x -> x^pow ) ) = inv; end ); ############################################################################# ## #M IsGeneratorsOfMagmaWithInverses( ) ## ## Check that all entries are matrices of the same dimension, and that they ## are all invertible. ## InstallMethod( IsGeneratorsOfMagmaWithInverses, "for a list of matrices", [ IsRingElementCollCollColl ], function( matlist ) local dims; if ForAll( matlist, IsMatrix ) then dims:= DimensionsMat( matlist[1] ); return dims[1] = dims[2] and ForAll( matlist, mat -> DimensionsMat( mat ) = dims ) and ForAll( matlist, mat -> Inverse( mat ) <> fail ); fi; return false; end ); ############################################################################# ## #M GroupWithGenerators( ) #M GroupWithGenerators( , ) ## InstallMethod( GroupWithGenerators, "list of matrices", [ IsFFECollCollColl ], #T ??? function( gens ) local G,fam,typ,f; fam:=FamilyObj(gens); if IsFinite(gens) then if not IsBound(fam!.defaultFinitelyGeneratedGroupType) then fam!.defaultFinitelyGeneratedGroupType:= NewType(fam,IsGroup and IsAttributeStoringRep and HasGeneratorsOfMagmaWithInverses and IsFinitelyGeneratedGroup); fi; typ:=fam!.defaultFinitelyGeneratedGroupType; else TryNextMethod(); fi; f:=DefaultScalarDomainOfMatrixList(gens); gens:=List(Immutable(gens),i->ImmutableMatrix(f,i)); G:=rec(); ObjectifyWithAttributes(G,typ,GeneratorsOfMagmaWithInverses,AsList(gens)); if IsField(f) then SetDefaultFieldOfMatrixGroup(G,f);fi; return G; end ); InstallMethod( GroupWithGenerators, "list of matrices with identity", IsCollsElms, [ IsFFECollCollColl,IsMultiplicativeElementWithInverse and IsFFECollColl], function( gens, id ) local G,fam,typ,f; fam:=FamilyObj(gens); if IsFinite(gens) then if not IsBound(fam!.defaultFinitelyGeneratedGroupWithOneType) then fam!.defaultFinitelyGeneratedGroupWithOneType:= NewType(fam,IsGroup and IsAttributeStoringRep and HasGeneratorsOfMagmaWithInverses and IsFinitelyGeneratedGroup and HasOne); fi; typ:=fam!.defaultFinitelyGeneratedGroupWithOneType; else TryNextMethod(); fi; f:=DefaultScalarDomainOfMatrixList(gens); gens:=List(Immutable(gens),i->ImmutableMatrix(f,i)); id:=ImmutableMatrix(f,id); G:=rec(); ObjectifyWithAttributes(G,typ,GeneratorsOfMagmaWithInverses,AsList(gens), One,id); if IsField(f) then SetDefaultFieldOfMatrixGroup(G,f);fi; return G; end ); ############################################################################# ## #M IsConjugatorIsomorphism( ) ## InstallMethod( IsConjugatorIsomorphism, "for a matrix group general mapping", [ IsGroupGeneralMapping ], 1, # There is no filter to test whether source and range of a homomorphism # are matrix groups. # So we have to test explicitly and make this method # higher ranking than the default one in `ghom.gi'. function( hom ) local s, r, dim, Fs, Fr, F, genss, rep; s:= Source( hom ); if not IsMatrixGroup( s ) then TryNextMethod(); elif not ( IsGroupHomomorphism( hom ) and IsBijective( hom ) ) then return false; elif IsEndoGeneralMapping( hom ) and IsInnerAutomorphism( hom ) then return true; fi; r:= Range( hom ); # Check whether dimensions and fields of matrix entries are compatible. dim:= DimensionOfMatrixGroup( s ); if dim <> DimensionOfMatrixGroup( r ) then return false; fi; Fs:= DefaultFieldOfMatrixGroup( s ); Fr:= DefaultFieldOfMatrixGroup( r ); if FamilyObj( Fs ) <> FamilyObj( Fr ) then return false; fi; if not ( IsField( Fs ) and IsField( Fr ) ) then TryNextMethod(); fi; F:= ClosureField( Fs, Fr ); if not IsFinite( F ) then TryNextMethod(); fi; # Compute a conjugator in the full linear group. genss:= GeneratorsOfGroup( s ); rep:= RepresentativeAction( GL( dim, Size( F ) ), genss, List( genss, i -> ImagesRepresentative( hom, i ) ), OnTuples ); # Return the result. if rep <> fail then Assert( 1, ForAll( genss, i -> Image( hom, i ) = i^rep ) ); SetConjugatorOfConjugatorIsomorphism( hom, rep ); return true; else return false; fi; end ); ############################################################################# ## #F AffineActionByMatrixGroup( ) ## InstallGlobalFunction( AffineActionByMatrixGroup, function(M) local gens,V, G, A; # build the vector space V := DefaultFieldOfMatrixGroup( M ) ^ DimensionOfMatrixGroup( M ); # the linear part G := Action( M, V ); # the translation part gens:=List( Basis( V ), b -> Permutation( b, V, \+ ) ); # construct the affine group A := GroupByGenerators(Concatenation(gens,GeneratorsOfGroup( G ))); SetSize( A, Size( M ) * Size( V ) ); if HasName( M ) then SetName( A, Concatenation( String( Size( DefaultFieldOfMatrixGroup( M ) ) ), "^", String( DimensionOfMatrixGroup( M ) ), ":", Name( M ) ) ); fi; # the !.matrixGroup component is not documented! A!.matrixGroup := M; #T what the hell shall this misuse be good for? return A; end ); ############################################################################# ## ## n. Code needed for ``blow up isomorphisms'' of matrix groups ## ############################################################################# ## #F IsBlowUpIsomorphism ## ## We define this filter for additive as well as for multiplicative ## general mappings, ## so the ``respectings'' of the mappings must be set explicitly. ## DeclareFilter( "IsBlowUpIsomorphism", IsSPGeneralMapping and IsBijective ); ############################################################################# ## #M ImagesRepresentative( , ) . . . . . for a blow up isomorphism ## InstallMethod( ImagesRepresentative, "for a blow up isomorphism, and a matrix in the source", FamSourceEqFamElm, [ IsBlowUpIsomorphism, IsMatrix ], function( iso, mat ) return BlownUpMat( Basis( iso ), mat ); end ); ############################################################################# ## #M PreImagesRepresentative( , ) . . . for a blow up isomorphism ## InstallMethod( PreImagesRepresentative, "for a blow up isomorphism, and a matrix in the range", FamRangeEqFamElm, [ IsBlowUpIsomorphism, IsMatrix ], function( iso, mat ) local B, d, n, Binv, preim, i, row, j, submat, elm, k; B:= Basis( iso ); d:= Length( B ); n:= Length( mat ) / d; if not IsInt( n ) then return fail; fi; Binv:= List( B, Inverse ); preim:= []; for i in [ 1 .. n ] do row:= []; for j in [ 1 .. n ] do # Compute the entry in the `i'-th row in the `j'-th column. submat:= mat{ [ 1 .. d ] + (i-1)*d }{ [ 1 .. d ] + (j-1)*d }; elm:= Binv[1] * LinearCombination( B, submat[1] ); # Check that the matrix is in the image of the isomorphism. for k in [ 2 .. d ] do if B[k] * elm <> LinearCombination( B, submat[k] ) then return fail; fi; od; row[j]:= elm; od; preim[i]:= row; od; return preim; end ); ############################################################################# ## #F BlowUpIsomorphism( , ) ## InstallGlobalFunction( "BlowUpIsomorphism", function( matgrp, B ) local gens, preimgs, imgs, range, iso; gens:= GeneratorsOfGroup( matgrp ); if IsEmpty( gens ) then preimgs:= [ One( matgrp ) ]; imgs:= [ IdentityMat( Length( preimgs[1] ) * Length( B ), LeftActingDomain( UnderlyingLeftModule( B ) ) ) ]; range:= GroupByGenerators( [], imgs[1] ); else preimgs:= gens; imgs:= List( gens, mat -> BlownUpMat( B, mat ) ); range:= GroupByGenerators( imgs ); fi; iso:= rec(); ObjectifyWithAttributes( iso, NewType( GeneralMappingsFamily( FamilyObj( preimgs[1] ), FamilyObj( imgs[1] ) ), IsBlowUpIsomorphism and IsGroupGeneralMapping and IsAttributeStoringRep ), Source, matgrp, Range, range, Basis, B ); return iso; end ); ############################################################################# ## ## stuff concerning invariant forms of matrix groups #T add code for computing invariant forms, #T and transforming matrices for normalizing the forms #T (which is useful, e.g., for embedding the groups from AtlasRep into #T the unitary, symplectic, or orthogonal groups in question) ## ############################################################################# ## #M InvariantBilinearForm( ) ## InstallMethod( InvariantBilinearForm, "for a matrix group with known `InvariantQuadraticForm'", [ IsMatrixGroup and HasInvariantQuadraticForm ], function( matgrp ) local Q; Q:= InvariantQuadraticForm( matgrp ).matrix; return rec( matrix:= ( Q + TransposedMat( Q ) ) ); end ); ############################################################################# ## #E gap-4r6p5/lib/ctblfuns.gi0000644000175000017500000050310212172557252014051 0ustar billbill############################################################################# ## #W ctblfuns.gi GAP library Thomas Breuer ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains generic methods for class functions. ## ## 2. Basic Operations for Class Functions ## 3. Comparison of Class Functions ## 4. Arithmetic Operations for Class Functions ## 5. Printing Class Functions ## 6. Creating Class Functions from Values Lists ## 7. Creating Class Functions using Groups ## 8. Operations for Class Functions ## 9. Restricted and Induced Class Functions ## 10. Reducing Virtual Characters ## 11. Symmetrizations of Class Functions ## 12. Operations for Brauer Characters ## 13. Domains Generated by Class Functions ## 14. Auxiliary operations ## ############################################################################# ## #F CharacterString( , ) . . . . . character information string ## InstallGlobalFunction( CharacterString, function( char, str ) str:= Concatenation( str, " of degree ", String( char[1] ) ); ConvertToStringRep( str ); return str; end ); ############################################################################# ## ## 2. Basic Operations for Class Functions ## ############################################################################# ## #M ValuesOfClassFunction( ) ## ## In order to treat lists as class functions where this makes sense, ## we define that `ValuesOfClassFunction' returns the list itself. ## InstallOtherMethod( ValuesOfClassFunction, "for a dense list", [ IsDenseList ], function( list ) if IsClassFunction( list ) and not HasValuesOfClassFunction( list ) then Error( "class function must store its values list" ); else return list; fi; end ); ############################################################################# ## #M \[\]( , ) #M Length( ) #M IsBound\[\]( , ) #M Position( , , 0 ) ## ## Class functions shall behave as immutable lists, ## we install methods for `\[\]', `Length', `IsBound\[\]', `Position', ## and `ShallowCopy'. ## InstallMethod( \[\], "for class function and positive integer", [ IsClassFunction, IsPosInt ], function( chi, i ) return ValuesOfClassFunction( chi )[i]; end ); InstallMethod( Length, "for class function", [ IsClassFunction ], chi -> Length( ValuesOfClassFunction( chi ) ) ); InstallMethod( IsBound\[\], "for class function and positive integer", [ IsClassFunction, IsPosInt ], function( chi, i ) return IsBound( ValuesOfClassFunction( chi )[i] ); end ); InstallMethod( Position, "for class function, cyclotomic, and nonnegative integer", [ IsClassFunction, IsCyc, IsInt ], function( chi, obj, pos ) return Position( ValuesOfClassFunction( chi ), obj, pos ); end ); InstallMethod( ShallowCopy, "for class function", [ IsClassFunction ], chi -> ShallowCopy( ValuesOfClassFunction( chi ) ) ); ############################################################################# ## #M UnderlyingGroup( ) ## InstallOtherMethod( UnderlyingGroup, "for a class function", [ IsClassFunction ], chi -> UnderlyingGroup( UnderlyingCharacterTable( chi ) ) ); ############################################################################# ## ## 3. Comparison of Class Functions ## ############################################################################# ## #M \=( , ) . . . . . . . . . . . . . equality of class functions ## InstallMethod( \=, "for two class functions", [ IsClassFunction, IsClassFunction ], function( chi, psi ) return ValuesOfClassFunction( chi ) = ValuesOfClassFunction( psi ); end ); InstallMethod( \=, "for a class function and a list", [ IsClassFunction, IsList ], function( chi, list ) if IsClassFunction( list ) then return ValuesOfClassFunction( chi ) = ValuesOfClassFunction( list ); else return ValuesOfClassFunction( chi ) = list; fi; end ); InstallMethod( \=, "for a list and a class function", [ IsList, IsClassFunction ], function( list, chi ) if IsClassFunction( list ) then return ValuesOfClassFunction( list ) = ValuesOfClassFunction( chi ); else return list = ValuesOfClassFunction( chi ); fi; end ); ############################################################################# ## #M \<( , ) . . . . . . . . . . . . comparison of class functions ## InstallMethod( \<, "for two class functions", [ IsClassFunction, IsClassFunction ], function( chi, psi ) return ValuesOfClassFunction( chi ) < ValuesOfClassFunction( psi ); end ); InstallMethod( \<, "for a class function and a list", [ IsClassFunction, IsList ], function( chi, list ) if IsClassFunction( list ) then return ValuesOfClassFunction( chi ) < ValuesOfClassFunction( list ); else return ValuesOfClassFunction( chi ) < list; fi; end ); InstallMethod( \<, "for a list and a class function", [ IsClassFunction, IsList ], function( list, chi ) if IsClassFunction( list ) then return ValuesOfClassFunction( list ) < ValuesOfClassFunction( chi ); else return list < ValuesOfClassFunction( chi ); fi; end ); ############################################################################# ## ## 4. Arithmetic Operations for Class Functions ## ############################################################################# ## #M \+( , ) . . . . . . . . . . sum of class function and object #M \+( , ) . . . . . . . . . . sum of object and class function #M \+( , ) . . . . . . . . . . . . . . sum of virtual characters #M \+( , ) . . . . . . . . . . . . . . . . . . sum of characters ## ## The sum of two class functions (virtual characters, characters) of the ## same character table is again a class function (virtual character, ## character) of this table. ## In all other cases, the addition is delegated to the list of values of ## the class function(s). ## InstallOtherMethod( \+, "for class function, and object", [ IsClassFunction, IsObject ], function( chi, obj ) local tbl, sum; tbl:= UnderlyingCharacterTable( chi ); if IsClassFunction( obj ) and IsIdenticalObj( tbl, UnderlyingCharacterTable( obj ) ) then sum:= ClassFunction( tbl, ValuesOfClassFunction( chi ) + ValuesOfClassFunction( obj ) ); else sum:= ValuesOfClassFunction( chi ) + obj; fi; return sum; end ); InstallOtherMethod( \+, "for object, and class function", [ IsObject, IsClassFunction ], function( obj, chi ) local tbl, sum; tbl:= UnderlyingCharacterTable( chi ); if IsClassFunction( obj ) and IsIdenticalObj( tbl, UnderlyingCharacterTable( obj ) ) then sum:= ClassFunction( tbl, ValuesOfClassFunction( obj ) + ValuesOfClassFunction( chi ) ); else sum:= obj + ValuesOfClassFunction( chi ); fi; return sum; end ); InstallMethod( \+, "for two virtual characters", IsIdenticalObj, [ IsClassFunction and IsVirtualCharacter, IsClassFunction and IsVirtualCharacter ], function( chi, psi ) local tbl, sum; tbl:= UnderlyingCharacterTable( chi ); sum:= ValuesOfClassFunction( chi ) + ValuesOfClassFunction( psi ); if IsIdenticalObj( tbl, UnderlyingCharacterTable( psi ) ) then sum:= VirtualCharacter( tbl, sum ); fi; return sum; end ); InstallMethod( \+, "for two characters", IsIdenticalObj, [ IsClassFunction and IsCharacter, IsClassFunction and IsCharacter ], function( chi, psi ) local tbl, sum; tbl:= UnderlyingCharacterTable( chi ); sum:= ValuesOfClassFunction( chi ) + ValuesOfClassFunction( psi ); if IsIdenticalObj( tbl, UnderlyingCharacterTable( psi ) ) then sum:= Character( tbl, sum ); fi; return sum; end ); ############################################################################# ## #M AdditiveInverseOp( ) . . . . . . . . . . . . for a class function ## ## The additive inverse of a virtual character is again a virtual character, ## but the additive inverse of a character is not a character, ## so we cannot use `ClassFunctionSameType'. ## InstallMethod( AdditiveInverseOp, "for a class function", [ IsClassFunction ], psi -> ClassFunction( UnderlyingCharacterTable( psi ), AdditiveInverse( ValuesOfClassFunction( psi ) ) ) ); InstallMethod( AdditiveInverseOp, "for a virtual character", [ IsClassFunction and IsVirtualCharacter ], psi -> VirtualCharacter( UnderlyingCharacterTable( psi ), AdditiveInverse( ValuesOfClassFunction( psi ) ) ) ); ############################################################################# ## #M ZeroOp( ) . . . . . . . . . . . . . . . . . . for a class function ## InstallMethod( ZeroOp, "for a class function", [ IsClassFunction ], psi -> VirtualCharacter( UnderlyingCharacterTable( psi ), Zero( ValuesOfClassFunction( psi ) ) ) ); ############################################################################# ## #M \*( , ) . . . . . . . . . scalar multiple of a class function #M \*( , ) . . . . . . . . . scalar multiple of a class function ## ## We define a multiplication only for two class functions (being the tensor ## product), for scalar multiplication with cyclotomics, ## and for default list times class function (where the class function acts ## as a scalar). ## Note that more is not needed, since class functions are not in ## `IsMultiplicativeGeneralizedRowVector'. ## InstallMethod( \*, "for cyclotomic, and class function", [ IsCyc, IsClassFunction ], function( cyc, chi ) return ClassFunction( UnderlyingCharacterTable( chi ), cyc * ValuesOfClassFunction( chi ) ); end ); InstallMethod( \*, "for integer, and virtual character", [ IsInt, IsVirtualCharacter ], function( cyc, chi ) return VirtualCharacter( UnderlyingCharacterTable( chi ), cyc * ValuesOfClassFunction( chi ) ); end ); InstallMethod( \*, "for positive integer, and character", [ IsPosInt, IsCharacter ], function( cyc, chi ) return Character( UnderlyingCharacterTable( chi ), cyc * ValuesOfClassFunction( chi ) ); end ); InstallMethod( \*, "for class function, and cyclotomic", [ IsClassFunction, IsCyc ], function( chi, cyc ) return ClassFunction( UnderlyingCharacterTable( chi ), ValuesOfClassFunction( chi ) * cyc ); end ); InstallMethod( \*, "for virtual character, and integer", [ IsVirtualCharacter, IsInt ], function( chi, cyc ) return VirtualCharacter( UnderlyingCharacterTable( chi ), ValuesOfClassFunction( chi ) * cyc ); end ); InstallMethod( \*, "for character, and positive integer", [ IsCharacter, IsPosInt ], function( chi, cyc ) return Character( UnderlyingCharacterTable( chi ), ValuesOfClassFunction( chi ) * cyc ); end ); ############################################################################# ## #M OneOp( ) . . . . . . . . . . . . . . . . . . for a class function ## InstallMethod( OneOp, "for class function", [ IsClassFunction ], psi -> TrivialCharacter( UnderlyingCharacterTable( psi ) ) ); ############################################################################# ## #M \*( , ) . . . . . . . . . . tensor product of class functions ## InstallMethod( \*, "for two class functions", [ IsClassFunction, IsClassFunction ], function( chi, psi ) local tbl, valschi, valspsi; tbl:= UnderlyingCharacterTable( chi ); if not IsIdenticalObj( tbl, UnderlyingCharacterTable( psi ) ) then Error( "no product of class functions of different tables" ); fi; valschi:= ValuesOfClassFunction( chi ); valspsi:= ValuesOfClassFunction( psi ); return ClassFunction( tbl, List( [ 1 .. Length( valschi ) ], x -> valschi[x] * valspsi[x] ) ); end ); InstallMethod( \*, "for two virtual characters", IsIdenticalObj, [ IsVirtualCharacter, IsVirtualCharacter ], function( chi, psi ) local tbl, valschi, valspsi; tbl:= UnderlyingCharacterTable( chi ); if not IsIdenticalObj( tbl, UnderlyingCharacterTable( psi ) ) then Error( "no product of class functions of different tables" ); fi; valschi:= ValuesOfClassFunction( chi ); valspsi:= ValuesOfClassFunction( psi ); return VirtualCharacter( tbl, List( [ 1 .. Length( valschi ) ], x -> valschi[x] * valspsi[x] ) ); end ); InstallMethod( \*, "for two characters", IsIdenticalObj, [ IsCharacter, IsCharacter ], function( chi, psi ) local tbl, valschi, valspsi; tbl:= UnderlyingCharacterTable( chi ); if not IsIdenticalObj( tbl, UnderlyingCharacterTable( psi ) ) then Error( "no product of class functions of different tables" ); fi; valschi:= ValuesOfClassFunction( chi ); valspsi:= ValuesOfClassFunction( psi ); return Character( tbl, List( [ 1 .. Length( valschi ) ], x -> valschi[x] * valspsi[x] ) ); end ); ############################################################################# ## #M \*( , ) . . . . . . . . . . class function times default list #M \*( , ) . . . . . . . . . . default list times class function ## InstallOtherMethod( \*, "for class function, and list in `IsListDefault'", [ IsClassFunction, IsListDefault ], function( chi, list ) return List( list, entry -> chi * entry ); end ); InstallOtherMethod( \*, "for list in `IsListDefault', and class function", [ IsListDefault, IsClassFunction ], function( list, chi ) return List( list, entry -> entry * chi ); end ); ############################################################################# ## #M Order( ) . . . . . . . . . . . . . . . . order of a class function ## ## Note that we are not allowed to regard the determinantal order of an ## arbitrary (virtual) character as its order, ## since nonlinear characters do not have an order as mult. elements. ## InstallMethod( Order, "for a class function", [ IsClassFunction ], function( chi ) local order, values; values:= ValuesOfClassFunction( chi ); if 0 in values then Error( " is not invertible" ); elif ForAny( values, cyc -> not IsIntegralCyclotomic( cyc ) or cyc * GaloisCyc( cyc, -1 ) <> 1 ) then return infinity; fi; order:= Conductor( values ); if order mod 2 = 1 and ForAny( values, i -> i^order <> 1 ) then order:= 2*order; fi; return order; end ); ############################################################################# ## #M InverseOp( ) . . . . . . . . . . . . . . . . for a class function ## InstallMethod( InverseOp, "for a class function", [ IsClassFunction ], function( chi ) local values; values:= List( ValuesOfClassFunction( chi ), Inverse ); if fail in values then return fail; elif HasIsCharacter( chi ) and IsCharacter( chi ) and values[1] = 1 then return Character( UnderlyingCharacterTable( chi ), values ); else return ClassFunction( UnderlyingCharacterTable( chi ), values ); fi; end ); ############################################################################# ## #M \^( , ) . . . . . . . . . . for class function and pos. integer ## InstallOtherMethod( \^, "for class function and positive integer (pointwise powering)", [ IsClassFunction, IsPosInt ], function( chi, n ) return ClassFunctionSameType( UnderlyingCharacterTable( chi ), chi, List( ValuesOfClassFunction( chi ), x -> x^n ) ); end ); ############################################################################# ## #M \^( , ) . . . . . conjugate class function under action of ## InstallMethod( \^, "for class function and group element", [ IsClassFunction, IsMultiplicativeElementWithInverse ], function( chi, g ) local tbl, G; tbl:= UnderlyingCharacterTable( chi ); if HasUnderlyingGroup( tbl ) then G:= UnderlyingGroup( tbl ); if IsElmsColls( FamilyObj( g ), FamilyObj( G ) ) then return ClassFunctionSameType( tbl, chi, Permuted( ValuesOfClassFunction( chi ), CorrespondingPermutations( tbl, chi, [ g ] )[1] ) ); fi; fi; TryNextMethod(); end ); ############################################################################# ## #M \^( , ) . . . Galois automorphism applied to ## InstallOtherMethod( \^, "for class function and Galois automorphism", [ IsClassFunction, IsGeneralMapping ], function( chi, galaut ) if IsANFAutomorphismRep( galaut ) then galaut:= galaut!.galois; return ClassFunctionSameType( UnderlyingCharacterTable( chi ), chi, List( ValuesOfClassFunction( chi ), x -> GaloisCyc( x, galaut ) ) ); elif IsOne( galaut ) then return chi; else TryNextMethod(); fi; end ); ############################################################################# ## #M \^( , ) . . . . . . . . . . . . . . . . induced class function #M \^( , ) . . . . . . . . . . . . . . . induced class function ## InstallOtherMethod( \^, "for class function and group", [ IsClassFunction, IsGroup ], InducedClassFunction ); InstallOtherMethod( \^, "for class function and nearly character table", [ IsClassFunction, IsNearlyCharacterTable ], InducedClassFunction ); ############################################################################# ## #M \^( , ) . . . . . . . . . . value of on group element ## InstallOtherMethod( \^, [ IsMultiplicativeElementWithInverse, IsClassFunction ], function( g, chi ) local tbl, ccl, i; tbl:= UnderlyingCharacterTable( chi ); if not HasUnderlyingGroup( tbl ) then Error( "table of does not store its group" ); elif g in UnderlyingGroup( tbl ) then ccl:= ConjugacyClasses( tbl ); for i in [ 1 .. Length( ccl ) ] do if g in ccl[i] then return ValuesOfClassFunction( chi )[i]; fi; od; else Error( " must lie in the underlying group of " ); fi; end ); ############################################################################# ## #M \^( , ) . . . . . . . . . . conjugation of linear characters ## InstallOtherMethod( \^, "for two class functions (conjugation, trivial action)", [ IsClassFunction, IsClassFunction ], function( chi, psi ) return chi; end ); ############################################################################# ## #M GlobalPartitionOfClasses( ) ## InstallMethod( GlobalPartitionOfClasses, "for an ordinary character table", [ IsOrdinaryTable ], function( tbl ) local part, # partition that has to be respected list, # list of all maps to be respected map, # one map in 'list' inv, # contains number of root classes newpart, # values, # j, # loop over 'orb' pt; # one point to map if HasAutomorphismsOfTable( tbl ) then # The orbits define the finest possible global partition. part:= OrbitsDomain( AutomorphismsOfTable( tbl ), [ 1 .. Length( NrConjugacyClasses( tbl ) ) ] ); else # Conjugate classes must have same representative order and # same centralizer order. list:= [ OrdersClassRepresentatives( tbl ), SizesCentralizers( tbl ) ]; # The number of root classes is by definition invariant under # table automorphisms. for map in Compacted( ComputedPowerMaps( tbl ) ) do inv:= 0 * map; for j in map do inv[j]:= inv[j] + 1; od; Add( list, inv ); od; # All elements in `list' must be respected. # Transform each of them into a partition, # and form the intersection of these partitions. part:= Partition( [ [ 1 .. Length( list[1] ) ] ] ); for map in list do newpart := []; values := []; for j in [ 1 .. Length( map ) ] do pt:= Position( values, map[j] ); if pt = fail then Add( values, map[j] ); Add( newpart, [ j ] ); else Add( newpart[ pt ], j ); fi; od; StratMeetPartition( part, Partition( newpart ) ); od; part:= List( Cells( part ), Set ); #T unfortunately `Set' necessary ... fi; return part; end ); ############################################################################# ## #M CorrespondingPermutations( , ) . action on the conj. classes ## InstallMethod( CorrespondingPermutations, "for character table and list of group elements", [ IsOrdinaryTable, IsHomogeneousList ], function( tbl, elms ) local classes, # list of conjugacy classes perms, # list of permutations, result part, # partition that has to be respected base, # base of aut. group g, # loop over `elms' images, # list of images pt, # one point to map im, # actual image class orb, # possible image points len, # length of 'orb' found, # image point found? (boolean value) j, # loop over 'orb' list, # one list in 'part' first, # first point in orbit of 'g' min; # minimal length of nontrivial orbit of 'g' classes:= ConjugacyClasses( tbl ); perms:= []; # If the table automorphisms are known then we only must determine # the images of a base of this group. if HasAutomorphismsOfTable( tbl ) then part:= AutomorphismsOfTable( tbl ); if IsTrivial( part ) then return ListWithIdenticalEntries( Length( elms ), () ); fi; # Compute the images of the base points of this group. base:= BaseOfGroup( part ); for g in elms do if IsOne( g ) then # If `g' is the identity then nothing is to do. Add( perms, () ); else images:= []; for pt in base do im:= Representative( classes[ pt ] ) ^ g; found:= false; for j in Orbit( part, pt ) do #T better CanonicalClassElement ?? if im in classes[j] then Add( images, j ); found:= true; break; fi; od; od; # Compute a group element. Add( perms, RepresentativeAction( part, base, images, OnTuples ) ); fi; od; else # We can use only a partition into unions of orbits. part:= GlobalPartitionOfClasses( tbl ); if Length( part ) = Length( classes ) then return ListWithIdenticalEntries( Length( elms ), () ); fi; for g in elms do #T It would be more natural to write #T Permutation( g, ConjugacyClasses( tbl ), OnPoints ), #T *BUT* the `Permutation' method in question first asks whether #T the list of classes is sorted, #T and there is no method to compare the classes! if IsOne( g ) then # If `g' is the identity then nothing is to do. Add( perms, () ); else # Compute orbits of `g' on the lists in `part', store the images. # Note that if we have taken away a union of orbits such that the # number of remaining points is smaller than the smallest prime # divisor of the order of `g' then all these points must be fixed. min:= FactorsInt( Order( g ) )[1]; images:= []; for list in part do if Length( list ) = 1 then #T why not `min' ? # necessarily fixed point images[ list[1] ]:= list[1]; else orb:= ShallowCopy( list ); while min <= Length( orb ) do # There may be nontrivial orbits. pt:= orb[1]; first:= pt; j:= 1; while j <= Length( orb ) do im:= Representative( classes[ pt ] ) ^ g; found:= false; while j <= Length( orb ) and not found do #T better CanonicalClassElement ?? if im in classes[ orb[j] ] then images[pt]:= orb[j]; found:= true; fi; j:= j+1; od; RemoveSet( orb, pt ); if found and pt <> images[ pt ] then pt:= images[ pt ]; j:= 1; fi; od; # The image must be the first point of the orbit under `g'. images[pt]:= first; od; # The remaining points of the orbit must be fixed. for pt in orb do images[pt]:= pt; od; fi; od; # Compute a group element. Add( perms, PermList( images ) ); fi; od; fi; return perms; end ); ############################################################################# ## #M CorrespondingPermutations( , , ) ## InstallOtherMethod( CorrespondingPermutations, "for a char. table, a hom. list, and a list of group elements", [ IsOrdinaryTable, IsHomogeneousList, IsHomogeneousList ], function( tbl, values, elms ) local G, # underlying group classes, # list of conjugacy classes perms, # list of permutations, result part, # partition that has to be respected base, # base of aut. group g, # loop over `elms' images, # list of images pt, # one point to map im, # actual image class orb, # possible image points len, # length of 'orb' found, # image point found? (boolean value) j, # loop over 'orb' list, # one list in 'part' first, # first point in orbit of 'g' min; # minimal length of nontrivial orbit of 'g' classes:= ConjugacyClasses( tbl ); perms:= []; # If the table automorphisms are known then we only must determine # the images of a base of this group. if HasAutomorphismsOfTable( tbl ) then part:= AutomorphismsOfTable( tbl ); if IsTrivial( part ) then return ListWithIdenticalEntries( Length( elms ), () ); fi; # Compute the images of the base points of this group. base:= BaseOfGroup( part ); for g in elms do if IsOne( g ) then # If `g' is the identity then nothing is to do. Add( perms, () ); else images:= []; for pt in base do im:= Representative( classes[ pt ] ) ^ g; found:= false; for j in Orbit( part, pt ) do #T better CanonicalClassElement ?? if im in classes[j] then Add( images, j ); found:= true; break; fi; j:= j+1; od; od; # Compute a group element (if possible). Add( perms, RepresentativeAction( part, base, images, OnTuples ) ); fi; od; else # We can use only a partition into unions of orbits. part:= GlobalPartitionOfClasses( tbl ); if Length( part ) = Length( classes ) then return ListWithIdenticalEntries( Length( elms ), () ); fi; for g in elms do if IsOne( g ) then # If `g' is the identity then nothing is to do. Add( perms, () ); else # Compute orbits of `g' on the lists in `part', store the images. # Note that if we have taken away a union of orbits such that the # number of remaining points is smaller than the smallest prime # divisor of the order of `g' then all these points must be fixed. min:= FactorsInt( Order( g ) )[1]; images:= []; for list in part do if Length( list ) = 1 then #T why not `min' ? # necessarily fixed point images[ list[1] ]:= list[1]; elif Length( Set( values{ list } ) ) = 1 then # We may take any permutation of the orbit. for j in list do images[j]:= j; od; else orb:= ShallowCopy( list ); while Length( orb ) >= min do #T fishy for S4 acting on V4 !! # There may be nontrivial orbits. pt:= orb[1]; first:= pt; j:= 1; while j <= Length( orb ) do im:= Representative( classes[ pt ] ) ^ g; found:= false; while j <= Length( orb ) and not found do #T better CanonicalClassElement ?? if im in classes[ orb[j] ] then images[pt]:= orb[j]; found:= true; fi; j:= j+1; od; RemoveSet( orb, pt ); if found then j:= 1; pt:= images[pt]; fi; od; # The image must be the first point of the orbit under `g'. images[pt]:= first; od; # The remaining points of the orbit must be fixed. for pt in orb do images[pt]:= pt; od; fi; od; # Compute a group element. Add( perms, PermList( images ) ); fi; od; fi; return perms; end ); ############################################################################# ## #M ComplexConjugate( ) ## ## We use `InstallOtherMethod' because class functions are both scalars and ## lists, so the method matches two declarations of the operation. ## InstallOtherMethod( ComplexConjugate, "for a class function", [ IsClassFunction and IsCyclotomicCollection ], chi -> GaloisCyc( chi, -1 ) ); ############################################################################# ## #M GaloisCyc( , ) ## InstallMethod( GaloisCyc, "for a class function, and an integer", [ IsClassFunction and IsCyclotomicCollection, IsInt ], function( chi, k ) local tbl, char, n, g; tbl:= UnderlyingCharacterTable( chi ); char:= UnderlyingCharacteristic( tbl ); n:= Conductor( chi ); g:= Gcd( k, n ); if k = -1 or ( char = 0 and g = 1 ) then return ClassFunctionSameType( tbl, chi, GaloisCyc( ValuesOfClassFunction( chi ), k ) ); #T also if k acts as some *(p^d) for char = p #T (reduce k mod n, and then what?) else return ClassFunction( tbl, GaloisCyc( ValuesOfClassFunction( chi ), k ) ); fi; end ); ############################################################################# ## #M Permuted( , ) ## InstallMethod( Permuted, "for a class function, and a permutation", [ IsClassFunction, IsPerm ], function( chi, perm ) return ClassFunction( UnderlyingCharacterTable( chi ), Permuted( ValuesOfClassFunction( chi ), perm ) ); end ); ############################################################################# ## ## 5. Printing Class Functions ## ############################################################################# ## #M ViewObj( ) . . . . . . . . . . . . . . . . . view a class function ## ## Note that class functions are finite lists, so the default `ViewObj' ## method for finite lists should be avoided. ## InstallMethod( ViewObj, "for a class function", [ IsClassFunction ], function( psi ) Print( "ClassFunction( " ); View( UnderlyingCharacterTable( psi ) ); Print( ", " ); View( ValuesOfClassFunction( psi ) ); Print( " )" ); end ); InstallMethod( ViewObj, "for a virtual character", [ IsClassFunction and IsVirtualCharacter ], function( psi ) Print( "VirtualCharacter( " ); View( UnderlyingCharacterTable( psi ) ); Print( ", " ); View( ValuesOfClassFunction( psi ) ); Print( " )" ); end ); InstallMethod( ViewObj, "for a character", [ IsClassFunction and IsCharacter ], function( psi ) Print( "Character( " ); View( UnderlyingCharacterTable( psi ) ); Print( ", " ); View( ValuesOfClassFunction( psi ) ); Print( " )" ); end ); ############################################################################# ## #M PrintObj( ) . . . . . . . . . . . . . . . . print a class function ## InstallMethod( PrintObj, "for a class function", [ IsClassFunction ], function( psi ) Print( "ClassFunction( ", UnderlyingCharacterTable( psi ), ", ", ValuesOfClassFunction( psi ), " )" ); end ); InstallMethod( PrintObj, "for a virtual character", [ IsClassFunction and IsVirtualCharacter ], function( psi ) Print( "VirtualCharacter( ", UnderlyingCharacterTable( psi ), ", ", ValuesOfClassFunction( psi ), " )" ); end ); InstallMethod( PrintObj, "for a character", [ IsClassFunction and IsCharacter ], function( psi ) Print( "Character( ", UnderlyingCharacterTable( psi ), ", ", ValuesOfClassFunction( psi ), " )" ); end ); ############################################################################# ## #M Display( ) . . . . . . . . . . . . . . . display a class function #M Display( , ) ## InstallMethod( Display, "for a class function", [ IsClassFunction ], function( chi ) Display( UnderlyingCharacterTable( chi ), rec( chars:= [ chi ] ) ); end ); InstallOtherMethod( Display, "for a class function, and a record", [ IsClassFunction, IsRecord ], function( chi, arec ) arec:= ShallowCopy( arec ); arec.chars:= [ chi ]; Display( UnderlyingCharacterTable( chi ), arec ); end ); ############################################################################# ## ## 6. Creating Class Functions from Values Lists ## ############################################################################# ## #M ClassFunction( , ) ## InstallMethod( ClassFunction, "for nearly character table, and dense list", [ IsNearlyCharacterTable, IsDenseList ], function( tbl, values ) local chi; # Check the no. of classes. if NrConjugacyClasses( tbl ) <> Length( values ) then Error( "no. of classes in and must be equal" ); fi; # Create the object. chi:= Objectify( NewType( FamilyObj( values ), IsClassFunction and IsAttributeStoringRep ), rec() ); # Store the defining attribute values. SetValuesOfClassFunction( chi, ValuesOfClassFunction( values ) ); SetUnderlyingCharacterTable( chi, tbl ); # Store useful information. if IsSmallList( values ) then SetIsSmallList( chi, true ); fi; return chi; end ); ############################################################################# ## #M ClassFunction( , ) ## InstallMethod( ClassFunction, "for a group, and a dense list", [ IsGroup, IsDenseList ], function( G, values ) return ClassFunction( OrdinaryCharacterTable( G ), values ); end ); ############################################################################# ## #M VirtualCharacter( , ) ## InstallMethod( VirtualCharacter, "for nearly character table, and dense list", [ IsNearlyCharacterTable, IsDenseList ], function( tbl, values ) values:= ClassFunction( tbl, values ); SetIsVirtualCharacter( values, true ); return values; end ); ############################################################################# ## #M VirtualCharacter( , ) ## InstallMethod( VirtualCharacter, "for a group, and a dense list", [ IsGroup, IsDenseList ], function( G, values ) return VirtualCharacter( OrdinaryCharacterTable( G ), values ); end ); ############################################################################# ## #M Character( , ) ## InstallMethod( Character, "for nearly character table, and dense list", [ IsNearlyCharacterTable, IsDenseList ], function( tbl, values ) values:= ClassFunction( tbl, values ); SetIsCharacter( values, true ); return values; end ); ############################################################################# ## #M Character( , ) ## InstallMethod( Character, "for a group, and a dense list", [ IsGroup, IsDenseList ], function( G, values ) return Character( OrdinaryCharacterTable( G ), values ); end ); ############################################################################# ## #F ClassFunctionSameType( , , ) ## InstallGlobalFunction( ClassFunctionSameType, function( tbl, chi, values ) if not IsClassFunction( chi ) then return values; elif HasIsCharacter( chi ) and IsCharacter( chi ) then return Character( tbl, values ); elif HasIsVirtualCharacter( chi ) and IsVirtualCharacter( chi ) then return VirtualCharacter( tbl, values ); else return ClassFunction( tbl, values ); fi; end ); ############################################################################# ## ## 7. Creating Class Functions using Groups ## ############################################################################# ## #M TrivialCharacter( ) . . . . . . . . . . . . . for a character table ## InstallMethod( TrivialCharacter, "for a character table", [ IsNearlyCharacterTable ], tbl -> Character( tbl, ListWithIdenticalEntries( NrConjugacyClasses( tbl ), 1 ) ) ); ############################################################################# ## #M TrivialCharacter( ) . . . . . . . . . . . . . . . . . . . for a group ## InstallMethod( TrivialCharacter, "for a group (delegate to the table)", [ IsGroup ], G -> TrivialCharacter( OrdinaryCharacterTable( G ) ) ); ############################################################################# ## #M NaturalCharacter( ) . . . . . . . . . . . . . for a permutation group ## InstallMethod( NaturalCharacter, "for a permutation group", [ IsGroup and IsPermCollection ], function( G ) local deg, tbl; deg:= NrMovedPoints( G ); tbl:= OrdinaryCharacterTable( G ); return Character( tbl, List( ConjugacyClasses( tbl ), C -> deg - NrMovedPoints( Representative( C ) ) ) ); end ); ############################################################################# ## #M NaturalCharacter( ) . . . . for a matrix group in characteristic zero ## InstallMethod( NaturalCharacter, "for a matrix group in characteristic zero", [ IsGroup and IsRingElementCollCollColl ], function( G ) local tbl; if Characteristic( G ) = 0 then tbl:= OrdinaryCharacterTable( G ); return Character( tbl, List( ConjugacyClasses( tbl ), C -> TraceMat( Representative( C ) ) ) ); else TryNextMethod(); fi; end ); ############################################################################# ## #M NaturalCharacter( ) . . . . . . . . . . . for a group homomorphism ## ## We use shortcuts for homomorphisms onto permutation groups and matrix ## groups in characteristic zero, ## since the meaning of `NaturalCharacter' is clear for these cases and ## we can avoid explicit conjugacy tests in the image. ## For other cases, we use a generic way. ## InstallMethod( NaturalCharacter, "for a group general mapping", [ IsGeneralMapping ], function( hom ) local G, R, deg, tbl, chi; G:= Source( hom ); R:= Range( hom ); tbl:= OrdinaryCharacterTable( G ); if IsPermGroup( R ) then deg:= NrMovedPoints( R ); return Character( tbl, List( ConjugacyClasses( tbl ), C -> deg - NrMovedPoints( ImagesRepresentative( hom, Representative( C ) ) ) ) ); elif IsMatrixGroup( R ) and Characteristic( R ) = 0 then return Character( tbl, List( ConjugacyClasses( tbl ), C -> TraceMat( ImagesRepresentative( hom, Representative( C ) ) ) ) ); else chi:= NaturalCharacter( Image( hom ) ); return Character( tbl, List( ConjugacyClasses( tbl ), C -> ImagesRepresentative( hom, Representative( C ) ) ^ chi ) ); fi; end ); ############################################################################# ## #M PermutationCharacter( , , ) . . . . . . . . for group action ## InstallMethod( PermutationCharacter, "group action on domain", [ IsGroup, IsCollection, IsFunction ], function( G, dom, opr ) local tbl; tbl:= OrdinaryCharacterTable( G ); return Character( tbl, List( ConjugacyClasses( tbl ), i -> Number( dom, j -> j = opr( j, Representative(i) ) ) ) ); end); ############################################################################# ## #M PermutationCharacter( , ) . . . . . . . . . . . . for two groups ## InstallMethod( PermutationCharacter, "for two groups (use double cosets)", IsIdenticalObj, [ IsGroup, IsGroup ], function( G, U ) local tbl, C, c, s, i; tbl:= OrdinaryCharacterTable( G ); C := ConjugacyClasses( tbl ); c := [ Index( G, U ) ]; s := Size( U ); for i in [ 2 .. Length(C) ] do c[i]:= Number( DoubleCosets( G, U, SubgroupNC( G, [ Representative( C[i] ) ] ) ), x -> Size( x ) = s ); od; # Return the character. return Character( tbl, c ); end ); #T ############################################################################# #T ## #T #M PermutationCharacter( , ) . . . . . . . . . for two small groups #T ## #T InstallMethod( PermutationCharacter, #T "for two small groups", #T IsIdenticalObj, #T [ IsGroup and IsSmallGroup, IsGroup and IsSmallGroup ], #T function( G, U ) #T local E, I, tbl; #T #T E := AsList( U ); #T I := Size( G ) / Length( E ); #T tbl:= OrdinaryCharacterTable( G ); #T return Character( tbl, #T List( ConjugacyClasses( tbl ), #T C -> I * Length( Intersection2( AsList( C ), E ) ) / Size( C ) ) ); #T end ); ############################################################################# ## ## 8. Operations for Class Functions ## ############################################################################# ## #M IsCharacter( ) . . . . . . . . . . . . . . for a virtual character ## InstallMethod( IsCharacter, "for a virtual character", [ IsClassFunction and IsVirtualCharacter ], obj -> IsCharacter( UnderlyingCharacterTable( obj ), ValuesOfClassFunction( obj ) ) ); InstallMethod( IsCharacter, "for a class function", [ IsClassFunction ], function( obj ) if HasIsVirtualCharacter( obj ) and not IsVirtualCharacter( obj ) then #T can disappear when inverse implications are supported! return false; fi; return IsCharacter( UnderlyingCharacterTable( obj ), ValuesOfClassFunction( obj ) ); end ); InstallMethod( IsCharacter, "for an ordinary character table, and a homogeneous list", [ IsOrdinaryTable, IsHomogeneousList ], function( tbl, list ) local chi, scpr; # Proper characters have positive degree. if list[1] <= 0 then return false; fi; # Check the scalar products with all irreducibles. for chi in Irr( tbl ) do scpr:= ScalarProduct( tbl, chi, list ); if not IsInt( scpr ) or scpr < 0 then return false; fi; od; return true; end ); InstallMethod( IsCharacter, "for a Brauer table, and a homogeneous list", [ IsBrauerTable, IsHomogeneousList ], function( tbl, list ) local chi, scpr; # Proper characters have positive degree. if list[1] <= 0 then return false; fi; # Check the decomposition. return Decomposition( Irr( tbl ), [ list ], "nonnegative" )[1] <> fail; end ); ############################################################################# ## #M IsVirtualCharacter( ) . . . . . . . . . . . . for a class function ## InstallMethod( IsVirtualCharacter, "for a class function", [ IsClassFunction ], chi -> IsVirtualCharacter( UnderlyingCharacterTable( chi ), ValuesOfClassFunction( chi ) ) ); InstallMethod( IsVirtualCharacter, "for an ordinary character table, and a homogeneous list", [ IsOrdinaryTable, IsHomogeneousList ], function( tbl, list ) local chi; # Check the scalar products with all irreducibles. for chi in Irr( tbl ) do if not IsInt( ScalarProduct( tbl, chi, list ) ) then return false; fi; od; return true; end ); # InstallMethod( IsVirtualCharacter, # "for a Brauer table, and a homogeneous list", # [ IsBrauerTable, IsHomogeneousList ], # function( tbl, list ) # ??? # end ); ############################################################################# ## #M IsIrreducibleCharacter( ) . . . . . . . . . for a class function ## InstallMethod( IsIrreducibleCharacter, "for a class function", [ IsClassFunction ], chi -> IsIrreducibleCharacter( UnderlyingCharacterTable( chi ), ValuesOfClassFunction( chi ) ) ); InstallMethod( IsIrreducibleCharacter, "for an ordinary character table, and a homogeneous list", [ IsOrdinaryTable, IsHomogeneousList ], function( tbl, list ) return IsVirtualCharacter( tbl, list ) and ScalarProduct( tbl, list, list) = 1 and list[1] > 0; end ); InstallMethod( IsIrreducibleCharacter, "for a Brauer table, and a homogeneous list", [ IsBrauerTable, IsHomogeneousList ], function( tbl, list ) local i, found; list:= Decomposition( Irr( tbl ), [ list ], "nonnegative" )[1]; if list = fail then return false; fi; found:= false; for i in list do if i <> 0 then if found or i <> 1 then return false; else found:= true; fi; fi; od; return found; end ); ############################################################################# ## #M ScalarProduct( , ) . . . . . . . . . . for two class functions ## InstallMethod( ScalarProduct, "for two class functions", [ IsClassFunction, IsClassFunction ], function( chi, psi ) local tbl, i, size, weights, scalarproduct; tbl:= UnderlyingCharacterTable( chi ); if tbl <> UnderlyingCharacterTable( psi ) then Error( " and have different character tables" ); fi; return ScalarProduct( tbl, ValuesOfClassFunction( chi ), ValuesOfClassFunction( psi ) ); end ); ############################################################################# ## #M ScalarProduct( , , ) . scalar product of class functions ## InstallMethod( ScalarProduct, "for character table and two homogeneous lists", [ IsCharacterTable, IsRowVector, IsRowVector ], function( tbl, x1, x2 ) local i, # loop variable scpr, # scalar product, result weight; # lengths of conjugacy classes weight:= SizesConjugacyClasses( tbl ); x1:= ValuesOfClassFunction( x1 ); x2:= ValuesOfClassFunction( x2 ); scpr:= 0; for i in [ 1 .. Length( x1 ) ] do scpr:= scpr + x1[i] * GaloisCyc( x2[i], -1 ) * weight[i]; od; return scpr / Size( tbl ); end ); ############################################################################# ## #F MatScalarProducts( [, ], ) #F MatScalarProducts( [, ] ) ## InstallMethod( MatScalarProducts, "for two homogeneous lists", [ IsHomogeneousList, IsHomogeneousList ], function( list1, list2 ) if IsEmpty( list1 ) then return []; elif not IsClassFunction( list1[1] ) then Error( " must consist of class functions" ); else return MatScalarProducts( UnderlyingCharacterTable( list1[1] ), list1, list2 ); fi; end ); InstallMethod( MatScalarProducts, "for a homogeneous list", [ IsHomogeneousList ], function( list ) if IsEmpty( list ) then return []; elif not IsClassFunction( list[1] ) then Error( " must consist of class functions" ); else return MatScalarProducts( UnderlyingCharacterTable( list[1] ), list ); fi; end ); InstallMethod( MatScalarProducts, "for an ordinary table, and two homogeneous lists", [ IsOrdinaryTable, IsHomogeneousList, IsHomogeneousList ], function( tbl, list1, list2 ) local i, j, chi, nccl, weight, scprmatrix, order, scpr; if IsEmpty( list1 ) then return []; fi; list1:= List( list1, ValuesOfClassFunction ); nccl:= NrConjugacyClasses( tbl ); weight:= SizesConjugacyClasses( tbl ); order:= Size( tbl ); scprmatrix:= []; for i in [ 1 .. Length( list2 ) ] do scprmatrix[i]:= []; chi:= List( ValuesOfClassFunction( list2[i] ), x -> GaloisCyc(x,-1) ); for j in [ 1 .. nccl ] do chi[j]:= chi[j] * weight[j]; od; for j in list1 do scpr:= ( chi * j ) / order; Add( scprmatrix[i], scpr ); if not IsInt( scpr ) then if IsRat( scpr ) then Info( InfoCharacterTable, 2, "MatScalarProducts: sum not divisible by group order" ); elif IsCyc( scpr ) then Info( InfoCharacterTable, 2, "MatScalarProducts: summation not integer valued"); fi; fi; od; od; return scprmatrix; end ); InstallMethod( MatScalarProducts, "for an ordinary table, and a homogeneous list", [ IsOrdinaryTable, IsHomogeneousList ], function( tbl, list ) local i, j, chi, nccl, weight, scprmatrix, order, scpr; if IsEmpty( list ) then return []; fi; list:= List( list, ValuesOfClassFunction ); nccl:= NrConjugacyClasses( tbl ); weight:= SizesConjugacyClasses( tbl ); order:= Size( tbl ); scprmatrix:= []; for i in [ 1 .. Length( list ) ] do scprmatrix[i]:= []; chi:= List( list[i], x -> GaloisCyc( x, -1 ) ); for j in [ 1 .. nccl ] do chi[j]:= chi[j] * weight[j]; od; for j in [ 1 .. i ] do scpr:= ( chi * list[j] ) / order; Add( scprmatrix[i], scpr ); if not IsInt( scpr ) then if IsRat( scpr ) then Info( InfoCharacterTable, 2, "MatScalarProducts: sum not divisible by group order" ); elif IsCyc( scpr ) then Info( InfoCharacterTable, 2, "MatScalarProducts: summation not integer valued"); fi; fi; od; od; return scprmatrix; end ); ############################################################################# ## #M Norm( [, ] ) . . . . . . . . . . . . . . norm of class function ## InstallOtherMethod( Norm, "for a class function", [ IsClassFunction ], chi -> ScalarProduct( chi, chi ) ); InstallOtherMethod( Norm, "for an ordinary character table and a homogeneous list", [ IsOrdinaryTable, IsHomogeneousList ], function( tbl, chi ) return ScalarProduct( tbl, chi, chi ); end ); ############################################################################# ## #M CentreOfCharacter( [, ] ) . . . . . . . . centre of a character ## InstallMethod( CentreOfCharacter, "for a class function", [ IsClassFunction ], chi -> CentreOfCharacter( UnderlyingCharacterTable( chi ), ValuesOfClassFunction( chi ) ) ); InstallMethod( CentreOfCharacter, "for an ordinary table, and a homogeneous list ", [ IsOrdinaryTable, IsHomogeneousList ], function( tbl, list ) if not HasUnderlyingGroup( tbl ) then Error( " does not store its group" ); fi; return NormalSubgroupClasses( tbl, ClassPositionsOfCentre( list ) ); end ); ############################################################################# ## #M ClassPositionsOfCentre( ) . . classes in the centre of a character ## ## We know that an algebraic integer $\alpha$ is a root of unity ## if and only if all conjugates of $\alpha$ have absolute value at most 1. ## Since $\alpha^{\ast} \overline{\alpha^{\ast}} = 1$ holds for a Galois ## automorphism $\ast$ if and only if $\alpha \overline{\alpha} = 1$ holds, ## a cyclotomic integer is a root of unity iff its absolute value is $1$. ## ## Cf. the comment about the `Order' method for cyclotomics in the file ## `lib/cyclotom.g'. ## ## The `IsCyc' test is necessary to avoid errors in the case that ## contains unknowns. ## InstallMethod( ClassPositionsOfCentre, "for a homogeneous list", [ IsHomogeneousList ], function( chi ) local deg, mdeg, degsquare; deg:= chi[1]; mdeg:= - deg; degsquare:= deg^2; return PositionsProperty( chi, x -> x = deg or x = mdeg or ( ( not IsInt( x ) ) and IsCyc( x ) and IsCycInt( x ) and x * GaloisCyc( x, -1 ) = degsquare ) ); end ); ############################################################################# ## #M ConstituentsOfCharacter( [, ] ) . irred. constituents of ## InstallMethod( ConstituentsOfCharacter, [ IsClassFunction ], chi -> ConstituentsOfCharacter( UnderlyingCharacterTable( chi ), chi ) ); InstallMethod( ConstituentsOfCharacter, "for a character", [ IsClassFunction and IsCharacter ], function( chi ) local tbl, # underlying table of `chi' irr, # irreducible characters of `tbl' values, # character values deg, # degree of `chi' const, # list of constituents, result i, # loop over `irr' irrdeg, # degree of an irred. character scpr; # one scalar product tbl:= UnderlyingCharacterTable( chi ); irr:= Irr( tbl ); values:= ValuesOfClassFunction( chi ); deg:= values[1]; const:= []; i:= 1; while 0 < deg and i <= Length( irr ) do irrdeg:= DegreeOfCharacter( irr[i] ); if irrdeg <= deg then scpr:= ScalarProduct( tbl, chi, irr[i] ); if scpr <> 0 then deg:= deg - scpr * irrdeg; Add( const, irr[i] ); fi; fi; i:= i+1; od; return Set( const ); end ); InstallMethod( ConstituentsOfCharacter, "for an ordinary table, and a homogeneous list", [ IsOrdinaryTable, IsHomogeneousList ], function( tbl, chi ) local irr, # irreducible characters of `tbl' const, # list of constituents, result proper, # is `chi' a proper character i, # loop over `irr' scpr; # one scalar product const:= []; proper:= true; for i in Irr( tbl ) do scpr:= ScalarProduct( tbl, chi, i ); if scpr <> 0 then Add( const, i ); proper:= proper and IsInt( scpr ) and ( 0 < scpr ); fi; od; # In the case `proper = true' we know that `chi' is a character. if proper then SetIsCharacter( chi, true ); fi; return Set( const ); end ); InstallMethod( ConstituentsOfCharacter, "for a Brauer table, and a homogeneous list", [ IsBrauerTable, IsHomogeneousList ], function( tbl, chi ) local irr, # irreducible characters of `tbl' dec; irr:= Irr( tbl ); dec:= Decomposition( irr, [ chi ], "nonnegative" )[1]; if dec = fail then TryNextMethod(); fi; return irr{ Filtered( [ 1 .. Length( dec ) ], i -> dec[i] <> 0 ) }; end ); ############################################################################# ## #M DegreeOfCharacter( ) . . . . . . . . . . . . for a class function ## InstallMethod( DegreeOfCharacter, "for a class function", [ IsClassFunction ], chi -> ValuesOfClassFunction( chi )[1] ); ############################################################################# ## #M InertiaSubgroup( [, ], ) . inertia subgroup of a character ## InstallMethod( InertiaSubgroup, "for a group, and a class function", [ IsGroup, IsClassFunction ], function( G, chi ) return InertiaSubgroup( UnderlyingCharacterTable( chi ), G, ValuesOfClassFunction( chi ) ); end ); InstallMethod( InertiaSubgroup, "for an ordinary table, a group, and a homogeneous list", [ IsOrdinaryTable, IsGroup, IsHomogeneousList ], function( tbl, G, chi ) local H, # group of `chi' index, # index of `H' in `G' induced, # induced of `chi' from `H' to `G' global, # global partition of classes part, # refined partition p, # one set in `global' and `part' val, # one value in `p' values, # list of character values on `p' new, # list of refinements of `p' i, # loop over stored partitions pos, # position where to store new partition later perms, # permutations corresp. to generators of `G' permgrp, # group generated by `perms' stab; # the inertia subgroup, result # `G' must normalize the group of `chi'. H:= UnderlyingGroup( tbl ); if not ( IsSubset( G, H ) and IsNormal( G, H ) ) then Error( " must be a normal subgroup in " ); fi; # For prime index, check the norm of the induced character. # (We get a decision if `chi' is irreducible.) index:= Index( G, H ); if IsPrimeInt( index ) then induced:= InducedClassFunction( tbl, chi, G ); if ScalarProduct( CharacterTable( G ), induced, induced ) = 1 then return H; elif ScalarProduct( tbl, chi, chi ) = 1 then return G; fi; fi; # Compute the partition that must be stabilized. #T Why is `StabilizerPartition' no longer available? #T In GAP 3.5, there was such a function. # (We need only those cells where `chi' really yields a refinement.) global:= GlobalPartitionOfClasses( tbl ); part:= []; for p in global do #T only if `p' has length > 1 ! val:= chi[ p[1] ]; if ForAny( p, x -> chi[x] <> val ) then # proper refinement will yield a condition. values:= []; new:= []; for i in p do pos:= Position( values, chi[i] ); if pos = fail then Add( values, chi[i] ); Add( new, [ i ] ); else Add( new[ pos ], i ); fi; od; Append( part, new ); fi; od; # If no refinement occurs, the character is necessarily invariant in . if IsEmpty( part ) then return G; fi; # Compute the permutations corresponding to the generators of `G'. perms:= CorrespondingPermutations( tbl, chi, GeneratorsOfGroup( G ) ); permgrp:= GroupByGenerators( perms ); # `G' acts on the set of conjugacy classes given by each cell of `part'. stab:= permgrp; for p in part do stab:= Stabilizer( stab, p, OnSets ); #T Better one step (partition stabilizer) ?? od; # Construct and return the result. if stab = permgrp then return G; else return PreImagesSet( GroupHomomorphismByImages( G, permgrp, GeneratorsOfGroup( G ), perms ), stab ); fi; end ); ############################################################################# ## #M KernelOfCharacter( [, ] ) . . . . . . . . for a class function ## InstallMethod( KernelOfCharacter, "for a class function", [ IsClassFunction ], chi -> KernelOfCharacter( UnderlyingCharacterTable( chi ), ValuesOfClassFunction( chi ) ) ); InstallMethod( KernelOfCharacter, "for an ordinary table, and a homogeneous list", [ IsOrdinaryTable, IsHomogeneousList ], function( tbl, chi ) return NormalSubgroupClasses( tbl, ClassPositionsOfKernel( chi ) ); end ); ############################################################################# ## #M ClassPositionsOfKernel( ) . the set of classes forming the kernel ## InstallMethod( ClassPositionsOfKernel, "for a homogeneous list", [ IsHomogeneousList ], function( char ) local degree; degree:= char[1]; return Filtered( [ 1 .. Length( char ) ], x -> char[x] = degree ); end ); ############################################################################# ## #M CycleStructureClass( [, ], ) ## ## For a permutation character $\pi$ and an element $g$ of $G$, the number ## of $n$-cycles in the underlying permutation representation is equal to ## $\frac{1}{n} \sum_{r|n} \mu(\frac{n}{r}) \pi(g^r)$. ## InstallMethod( CycleStructureClass, "for a class function, and a class position", [ IsClassFunction, IsPosInt ], function( permchar, class ) return CycleStructureClass( UnderlyingCharacterTable( permchar ), ValuesOfClassFunction( permchar ), class ); end ); InstallMethod( CycleStructureClass, "for an ordinary table, a list, and a class position", [ IsOrdinaryTable, IsHomogeneousList, IsPosInt ], function( tbl, permchar, class ) local n, # element order of `class' divs, # divisors of `n' i, d, j, # loop over `divs' fixed, # numbers of fixed points cycstruct; # cycle structure, result # Compute the numbers of fixed points of powers. n:= OrdersClassRepresentatives( tbl )[ class ]; divs:= DivisorsInt( n ); fixed:= []; for i in [ 1 .. Length( divs ) ] do # Compute the number of cycles of the element of order `n / d'. d:= divs[i]; fixed[d]:= permchar[ PowerMap( tbl, d, class ) ]; for j in [ 1 .. i-1 ] do if d mod divs[j] = 0 then # Subtract the number of fixed points with stabilizer exactly # of order `n / divs[j]'. fixed[d]:= fixed[d] - fixed[ divs[j] ]; fi; od; od; # Convert these numbers into numbers of cycles. cycstruct:= []; for i in divs do if fixed[i] <> 0 and 1 < i then cycstruct[ i-1 ]:= fixed[i] / i; fi; od; # Return the cycle structure. return cycstruct; end ); ############################################################################# ## #M IsTransitive( [, ] ) ## InstallMethod( IsTransitive, "for a class function", [ IsClassFunction ], function( permchar ) local tbl; tbl:= UnderlyingCharacterTable( permchar ); return ValuesOfClassFunction( permchar ) * SizesConjugacyClasses( tbl ) = Size( tbl ); end ); InstallMethod( IsTransitive, "for an ordinary table and a homogeneous list", [ IsOrdinaryTable, IsHomogeneousList ], function( tbl, permchar ) return permchar * SizesConjugacyClasses( tbl ) = Size( tbl ); end ); ############################################################################# ## #M Transitivity( [, ] ) ## ## The transitivity of a permutation character $\pi$ corresponding to the ## action on the $G$-set $\Omega$ is computed as follows ## (cf.~\cite{Hup98}, Theorem~11.8). ## Let $\Omega_k = \{ (\omega_1, \omega_2, \ldots, \omega_k) \mid ## \omega_i \in \Omega, \omega_i {\rm\ pairwise distinct} \}$. ## Then $\Omega_k$ is a $G$-set w.r.t.~componentwise action, ## and the permutation character $\pi_k$ is given by ## $\pi_k(g) = \pi(g) (\pi(g)-1) (\pi(g)-2) \cdots (\pi(g)-k+1)$. ## $\Omega$ is $k$-transitive if and only if $\Omega_k$ is transitive. ## InstallMethod( Transitivity, "for a class function", [ IsClassFunction ], pi -> Transitivity( UnderlyingCharacterTable( pi ), ValuesOfClassFunction( pi ) ) ); InstallMethod( Transitivity, "for an ordinary table, and a homogeneous list", [ IsOrdinaryTable, IsHomogeneousList ], function( tbl, values ) local order, classes, n, k, pik; # Check the argument. if not ForAll( values, IsInt ) then Error( " is not integral" ); fi; order:= Size( tbl ); classes:= SizesConjugacyClasses( tbl ); n:= Length( classes ); k:= 1; pik:= values; while pik * classes = order do k:= k + 1; pik:= List( [ 1 .. n ], x -> pik[x] * ( values[x] - k + 1 ) ); od; return k - 1; end ); ############################################################################# ## #M CentralCharacter( [, ] ) . . . . . . . . . . . for a character ## InstallMethod( CentralCharacter, "for a class function", [ IsClassFunction ], chi -> CentralCharacter( UnderlyingCharacterTable( chi ), ValuesOfClassFunction( chi ) ) ); InstallMethod( CentralCharacter, "for an ordinary table, and a homogeneous list", [ IsOrdinaryTable, IsHomogeneousList ], function( tbl, char ) local classes; classes:= SizesConjugacyClasses( tbl ); if Length( classes ) <> Length( char ) then Error( " and must have same length" ); fi; return ClassFunction( tbl, List( [ 1 .. Length( char ) ], x -> classes[x] * char[x] / char[1] ) ); end ); ############################################################################## ## #M DeterminantOfCharacter( [, ] ) ## ## The determinant is computed as follows. ## Diagonalize the matrix; the determinant is the product of the diagonal ## entries, which can be computed by `Eigenvalues'. ## ## Note that the determinant of a virtual character $\chi - \psi$ is ## well-defined as the quotient of the determinants of the characters $\chi$ ## and $\psi$, since the determinant of a sum of characters is the product ## of the determinants of the summands. ## InstallMethod( DeterminantOfCharacter, "for a class function", [ IsClassFunction ], function( chi ) local det; if chi[1] = 1 then return chi; fi; det:= DeterminantOfCharacter( UnderlyingCharacterTable( chi ), ValuesOfClassFunction( chi ) ); if HasIsVirtualCharacter( chi ) and IsVirtualCharacter( chi ) then SetIsCharacter( det, true ); fi; return det; end ); InstallMethod( DeterminantOfCharacter, "for a nearly character table, and a class function", [ IsCharacterTable, IsHomogeneousList ], function( tbl, chi ) local det, # result list ev, # eigenvalues ord, # one element order i; # loop over classes if chi[1] = 1 then return ClassFunction( tbl, chi ); fi; det:= []; for i in [ 1 .. Length( chi ) ] do ev:= EigenvaluesChar( tbl, chi, i ); ord:= Length( ev ); # The determinant is 'E(ord)' to the 'exp'-th power, # where $'exp' = \sum_{j=1}^{ord} j 'ev'[j]$. # (Note that the $j$-th entry in 'ev' is the multiplicity of # 'E(ord)^j' as eigenvalue.) det[i]:= E(ord) ^ ( [ 1 .. ord ] * ev ); od; return ClassFunction( tbl, det ); end ); ############################################################################# ## #M EigenvaluesChar( [, ], ) ## ## The eigenvalues can be computed from the values of the character ## together with the power maps up to the order of elements in the ## -th class of , see page~231 in~\cite{NPP84}; ## note that the multiplicity of a given $n$-th root of unity $\zeta$ ## as an eigenvalue of $M$ is equal to the multiplicity of the irreducible ## character of the cyclic group spanned by $g$ that maps $g$ to $\zeta$, ## and this can be computed from the restriction of to this cyclic ## subgroup or, equivalently, by the power maps of . ## #T > I would like to know if there is a quickier way to compute the #T > characteristic polynomial f=f(G) of a representative G #T > of a conjugacy class mentioned #T > above, than using Eigenvalues(). #T > (The latter function involves using algebraic numbers, #T > whereas it might happen #T > that f has rational or integer coefficients , #T > i.e. all the irrationalies cancel) #T #T For example, if the character values in question are rational #T one can use Galois sums of the irreducible characters of the cyclic #T subgroup instead of the irreducible characters when computing #T scalar products, #T because the multiplicities of Galois conjugate eigenvalues are equal #T in such a case. #T This avoids computations with non-rational numbers. ## InstallMethod( EigenvaluesChar, "for a class function and a positive integer", [ IsClassFunction, IsPosInt ], function( chi, class ) return EigenvaluesChar( UnderlyingCharacterTable( chi ), ValuesOfClassFunction( chi ), class ); end ); InstallMethod( EigenvaluesChar, "for a character table and a hom. list, and a pos.", [ IsCharacterTable, IsHomogeneousList, IsPosInt ], function( tbl, char, class ) local i, j, n, powers, eigen, e, val; n:= OrdersClassRepresentatives( tbl )[ class ]; if n = 1 then return [ char[ class ] ]; fi; # Compute necessary power maps and the restricted character. powers:= []; powers[n]:= char[1]; for i in [ 1 .. n-1 ] do if not IsBound( powers[i] ) then # necessarily 'i' divides 'n', since 'i/Gcd(n,i)' is invertible # mod 'n', and thus powering with 'i' is Galois conjugate to # powering with 'Gcd(n,i)' powers[i]:= char[ PowerMap( tbl, i, class ) ]; #T better approach: #T only write down values for one representative of each #T Galois family, and compute traces; #T for rational characters, this avoids computation with #T non-rational values at all. #T (how much does this help?) for j in PrimeResidues( n/i ) do # Note that the position cannot be 0. powers[ ( i*j ) mod n ]:= GaloisCyc( powers[i], j ); od; fi; od; # compute the scalar products of the characters given by 'E(n)->E(n)^i' # with the restriction of to the cyclic group generated by # eigen:= []; for i in [ 1 .. n ] do e:= E(n)^(-i); val:= 0; for j in [ 1 .. n ] do val:= val + e^j * powers[j]; od; eigen[i]:= val / n; od; return eigen; end ); ############################################################################# ## #M Tensored( , ) . . . . for two lists of class functions ## InstallMethod( Tensored, "method for two homogeneous lists", [ IsHomogeneousList, IsHomogeneousList ], function( chars1, chars2 ) local i, j, k, nccl, tensored, single; if IsEmpty( chars1 ) or IsEmpty( chars2 ) then return []; fi; nccl:= Length( chars1[1] ); tensored:= []; for i in chars1 do for j in chars2 do single:= []; for k in [ 1 .. nccl ] do single[k]:= i[k] * j[k]; od; if HasIsCharacter( i ) and IsCharacter( i ) and HasIsCharacter( j ) and IsCharacter( j ) and UnderlyingCharacterTable( i ) = UnderlyingCharacterTable( j ) then single:= Character( UnderlyingCharacterTable( i ), single ); elif HasIsVirtualCharacter( i ) and IsVirtualCharacter( i ) and HasIsVirtualCharacter( j ) and IsVirtualCharacter( j ) and UnderlyingCharacterTable( i ) = UnderlyingCharacterTable( j ) then single:= VirtualCharacter( UnderlyingCharacterTable( i ), single ); elif IsClassFunction( i ) and IsClassFunction( j ) and UnderlyingCharacterTable( i ) = UnderlyingCharacterTable( j ) then single:= ClassFunction( UnderlyingCharacterTable( i ), single ); fi; Add( tensored, single ); od; od; return tensored; end ); ############################################################################# ## ## 9. Restricted and Induced Class Functions ## ############################################################################# ## #M RestrictedClassFunction( [, ], ) #M RestrictedClassFunction( [, ], ) #M RestrictedClassFunction( [, ], ) ## InstallMethod( RestrictedClassFunction, "for a class function, and a group", [ IsClassFunction, IsGroup ], function( chi, H ) local subtbl, tbl, fus; subtbl:= OrdinaryCharacterTable( H ); tbl:= UnderlyingCharacterTable( chi ); if UnderlyingCharacteristic( tbl ) <> 0 then subtbl:= subtbl mod UnderlyingCharacteristic( tbl ); fi; fus:= FusionConjugacyClasses( subtbl, tbl ); if fus = fail then Error( "no fusion from to " ); fi; return ClassFunctionSameType( subtbl, chi, chi{ fus } ); end ); InstallMethod( RestrictedClassFunction, "for a character table, a homogeneous list, and a group", [ IsNearlyCharacterTable, IsHomogeneousList, IsGroup ], function( tbl, chi, H ) local subtbl, fus; subtbl:= OrdinaryCharacterTable( H ); if UnderlyingCharacteristic( tbl ) <> 0 then subtbl:= subtbl mod UnderlyingCharacteristic( tbl ); fi; fus:= FusionConjugacyClasses( subtbl, tbl ); if fus = fail then Error( "no fusion from to " ); fi; return ClassFunction( subtbl, chi{ fus } ); end ); InstallMethod( RestrictedClassFunction, "for a class function and a group homomorphism", [ IsClassFunction, IsGeneralMapping ], function( chi, hom ) local tbl, subtbl, fus; subtbl:= CharacterTable( PreImage( hom ) ); tbl:= UnderlyingCharacterTable( chi ); if UnderlyingCharacteristic( tbl ) <> 0 then subtbl:= subtbl mod UnderlyingCharacteristic( tbl ); fi; fus:= FusionConjugacyClasses( hom, subtbl, tbl ); if fus = fail then Error( "no fusion from to " ); fi; return ClassFunctionSameType( subtbl, chi, ValuesOfClassFunction( chi ){ fus } ); end ); InstallMethod( RestrictedClassFunction, "for a character table, a homogeneous list, and a group homomorphism", [ IsNearlyCharacterTable, IsHomogeneousList, IsGeneralMapping ], function( tbl, chi, hom ) local subtbl, fus; subtbl:= CharacterTable( PreImage( hom ) ); if UnderlyingCharacteristic( tbl ) <> 0 then subtbl:= subtbl mod UnderlyingCharacteristic( tbl ); fi; fus:= FusionConjugacyClasses( hom, subtbl, tbl ); if fus = fail then Error( "no fusion from to " ); fi; return ClassFunction( subtbl, chi{ fus } ); end ); InstallMethod( RestrictedClassFunction, "for class function and nearly character table", [ IsClassFunction, IsNearlyCharacterTable ], function( chi, subtbl ) local fus; fus:= FusionConjugacyClasses( subtbl, UnderlyingCharacterTable( chi ) ); if fus = fail then Error( "class fusion not available" ); fi; return ClassFunctionSameType( subtbl, chi, ValuesOfClassFunction( chi ){ fus } ); end ); InstallMethod( RestrictedClassFunction, "for a character table, a homogeneous list, and a character table", [ IsNearlyCharacterTable, IsHomogeneousList, IsNearlyCharacterTable ], function( tbl, chi, subtbl ) local fus; fus:= FusionConjugacyClasses( subtbl, tbl ); if fus = fail then Error( "class fusion not available" ); fi; return ClassFunction( subtbl, chi{ fus } ); end ); ############################################################################# ## #M RestrictedClassFunctions( [, ], ) #M RestrictedClassFunctions( [, ], ) #M RestrictedClassFunctions( [, ], ) ## InstallMethod( RestrictedClassFunctions, "for list and group", [ IsList, IsGroup ], function( chars, H ) return List( chars, chi -> RestrictedClassFunction( chi, H ) ); end ); InstallMethod( RestrictedClassFunctions, "for list and group homomorphism", [ IsList, IsGeneralMapping ], function( chars, hom ) return List( chars, chi -> RestrictedClassFunction( chi, hom ) ); end ); InstallMethod( RestrictedClassFunctions, "for list and character table", [ IsList, IsCharacterTable ], function( chars, subtbl ) return List( chars, chi -> RestrictedClassFunction( chi, subtbl ) ); end ); InstallMethod( RestrictedClassFunctions, "for a character table, a list, and a group", [ IsCharacterTable, IsList, IsGroup ], function( tbl, chars, H ) local subtbl, fus; subtbl:= OrdinaryCharacterTable( H ); if UnderlyingCharacteristic( tbl ) <> 0 then subtbl:= subtbl mod UnderlyingCharacteristic( tbl ); fi; fus:= FusionConjugacyClasses( subtbl, tbl ); if fus = fail then Error( "no fusion from to " ); fi; return List( chars, chi -> ClassFunctionSameType( subtbl, chi, ValuesOfClassFunction( chi ){ fus } ) ); end ); InstallMethod( RestrictedClassFunctions, "for a character table, a list, and a group homomorphism", [ IsCharacterTable, IsList, IsGeneralMapping ], function( tbl, chars, hom ) local subtbl, fus; subtbl:= CharacterTable( PreImage( hom ) ); if UnderlyingCharacteristic( tbl ) <> 0 then subtbl:= subtbl mod UnderlyingCharacteristic( tbl ); fi; fus:= FusionConjugacyClasses( hom, subtbl, tbl ); if fus = fail then Error( "class fusion not available" ); fi; return List( chars, chi -> ClassFunctionSameType( subtbl, chi, ValuesOfClassFunction( chi ){ fus } ) ); end ); InstallMethod( RestrictedClassFunctions, "for a character table, a list, and a character table", [ IsCharacterTable, IsList, IsCharacterTable ], function( tbl, chars, subtbl ) local fus; fus:= FusionConjugacyClasses( subtbl, tbl ); if fus = fail then Error( "class fusion not available" ); fi; return List( chars, chi -> ClassFunctionSameType( subtbl, chi, ValuesOfClassFunction( chi ){ fus } ) ); end ); ############################################################################# ## #M Restricted( , , ) #M Restricted( , , , ) #M Restricted( , ) ## ## These methods are installed just for compatibility with {\GAP}~3. ## InstallMethod( Restricted, [ IsNearlyCharacterTable, IsNearlyCharacterTable, IsHomogeneousList ], function( tbl, subtbl, chars ) local fus; fus:= FusionConjugacyClasses( subtbl, tbl ); if fus = fail then Error( "class fusion not available" ); fi; return List( chars, row -> ClassFunction( subtbl, row{ fus } ) ); end ); InstallMethod( Restricted, [ IsNearlyCharacterTable, IsNearlyCharacterTable, IsMatrix, IsObject ], function( tbl, subtbl, chars, specification ) local fus; fus:= GetFusionMap( subtbl, tbl, specification ); if fus = fail then Error( "class fusion not available" ); fi; return List( chars, row -> ClassFunction( subtbl, row{ fus } ) ); end ); InstallMethod( Restricted, [ IsList, IsList and IsCyclotomicCollection ], function( mat, fus ) if ForAll( mat, IsList ) then return List( mat, row -> row{ fus } ); fi; Error( " must be a matrix" ); end ); ############################################################################# ## #M Restricted( [, ], ) #M Restricted( [, ], ) #M Restricted( [, ], ) #M Restricted( [, ], ) #M Restricted( [, ], ) #M Restricted( [, ], ) ## InstallMethod( Restricted, [ IsClassFunction, IsGroup ], RestrictedClassFunction ); InstallMethod( Restricted, [ IsCharacterTable, IsHomogeneousList, IsGroup ], function( tbl, list, H ) if IsMatrix( list ) then return RestrictedClassFunctions( tbl, list, H ); else return RestrictedClassFunction( tbl, list, H ); fi; end ); InstallMethod( Restricted, [ IsClassFunction, IsGroupHomomorphism ], RestrictedClassFunction ); InstallMethod( Restricted, [ IsCharacterTable, IsClassFunction, IsGroupHomomorphism ], function( tbl, list, hom ) if IsMatrix( list ) then return RestrictedClassFunctions( tbl, list, hom ); else return RestrictedClassFunction( tbl, list, hom ); fi; end ); InstallMethod( Restricted, [ IsClassFunction, IsNearlyCharacterTable ], RestrictedClassFunction ); InstallMethod( Restricted, [ IsCharacterTable, IsClassFunction, IsNearlyCharacterTable ], function( tbl, list, subtbl ) if IsMatrix( list ) then return RestrictedClassFunctions( tbl, list, subtbl ); else return RestrictedClassFunction( tbl, list, subtbl ); fi; end ); InstallMethod( Restricted, [ IsHomogeneousList, IsGroup ], function( list, H ) if ForAll( list, IsClassFunction ) then return RestrictedClassFunctions( list, H ); else TryNextMethod(); fi; end ); InstallMethod( Restricted, [ IsHomogeneousList, IsGroupHomomorphism ], function( list, hom ) if ForAll( list, IsClassFunction ) then return RestrictedClassFunctions( list, hom ); else TryNextMethod(); fi; end ); InstallMethod( Restricted, [ IsHomogeneousList, IsNearlyCharacterTable ], function( list, subtbl ) if ForAll( list, IsClassFunction ) then return RestrictedClassFunctions( list, subtbl ); else TryNextMethod(); fi; end ); ############################################################################# ## #F InducedClassFunctionsByFusionMap( , , , ) ## InstallGlobalFunction( InducedClassFunctionsByFusionMap, function( subtbl, tbl, chars, fusion ) local j, im, # loop variables centralizers, # centralizer orders in hte supergroup nccl, # number of conjugacy classes of the group subnccl, # number of conjugacy classes of the subgroup suborder, # order of the subgroup subclasses, # class lengths in the subgroup induced, # list of induced characters, result singleinduced, # one induced character char; # one character to be induced if fusion = fail then return fail; fi; centralizers:= SizesCentralizers( tbl ); nccl:= Length( centralizers ); suborder:= Size( subtbl ); subclasses:= SizesConjugacyClasses( subtbl ); subnccl:= Length( subclasses ); induced:= []; for char in chars do # Preset the character with zeros. singleinduced:= ListWithIdenticalEntries( nccl, 0 ); # Add the contribution of each class of the subgroup. for j in [ 1 .. subnccl ] do if char[j] <> 0 then if IsInt( fusion[j] ) then singleinduced[ fusion[j] ]:= singleinduced[ fusion[j] ] + char[j] * subclasses[j]; else for im in fusion[j] do singleinduced[ im ]:= Unknown(); od; #T only for TableInProgress! fi; fi; od; # Adjust the values by multiplication. for j in [ 1 .. nccl ] do singleinduced[j]:= singleinduced[j] * centralizers[j] / suborder; if not IsCycInt( singleinduced[j] ) then singleinduced[j]:= Unknown(); Info( InfoCharacterTable, 1, "Induced: subgroup order not dividing sum in character ", Length( induced ) + 1, " at class ", j ); fi; od; # Create the class function object. if IsClassFunction( char ) then singleinduced:= ClassFunctionSameType( tbl, char, singleinduced ); else singleinduced:= ClassFunction( tbl, singleinduced ); fi; Add( induced, singleinduced ); od; # Return the list of induced characters. return induced; end ); ############################################################################# ## #M InducedClassFunction( [, ], ) #M InducedClassFunction( [, ], ) #M InducedClassFunction( [, ], ) ## InstallMethod( InducedClassFunction, "for a class function and a group", [ IsClassFunction, IsGroup ], function( chi, G ) local tbl, suptbl, fus; tbl:= UnderlyingCharacterTable( chi ); suptbl:= OrdinaryCharacterTable( G ); if UnderlyingCharacteristic( tbl ) <> 0 then suptbl:= suptbl mod UnderlyingCharacteristic( tbl ); fi; fus:= FusionConjugacyClasses( tbl, suptbl ); return InducedClassFunctionsByFusionMap( tbl, suptbl, [ chi ], fus )[1]; end ); InstallMethod( InducedClassFunction, "for a character table, a homogeneous list, and a group", [ IsCharacterTable, IsHomogeneousList, IsGroup ], function( tbl, chi, G ) local suptbl, fus; suptbl:= OrdinaryCharacterTable( G ); if UnderlyingCharacteristic( tbl ) <> 0 then suptbl:= suptbl mod UnderlyingCharacteristic( tbl ); fi; fus:= FusionConjugacyClasses( tbl, suptbl ); return InducedClassFunctionsByFusionMap( tbl, suptbl, [ chi ], fus )[1]; end ); InstallMethod( InducedClassFunction, "for class function and nearly character table", [ IsClassFunction, IsNearlyCharacterTable ], function( chi, suptbl ) local tbl, fus; tbl:= UnderlyingCharacterTable( chi ); fus:= FusionConjugacyClasses( tbl, suptbl ); return InducedClassFunctionsByFusionMap( tbl, suptbl, [ chi ], fus )[1]; end ); InstallMethod( InducedClassFunction, "for character table, homogeneous list, and nearly character table", [ IsCharacterTable, IsHomogeneousList, IsNearlyCharacterTable ], function( tbl, chi, suptbl ) local fus; fus:= FusionConjugacyClasses( tbl, suptbl ); return InducedClassFunctionsByFusionMap( tbl, suptbl, [ chi ], fus )[1]; end ); InstallMethod( InducedClassFunction, "for a class function and a group homomorphism", [ IsClassFunction, IsGeneralMapping ], function( chi, hom ) local tbl, suptbl, fus; tbl:= UnderlyingCharacterTable( chi ); suptbl:= OrdinaryCharacterTable(Image( hom )); if UnderlyingCharacteristic( tbl ) <> 0 then suptbl:= suptbl mod UnderlyingCharacteristic( tbl ); fi; fus:= FusionConjugacyClasses( hom, tbl, suptbl ); return InducedClassFunctionsByFusionMap( tbl, suptbl, [ chi ], fus )[1]; end ); InstallMethod( InducedClassFunction, "for a character table, a homogeneous list, and a group homomorphism", [ IsCharacterTable, IsHomogeneousList, IsGeneralMapping ], function( tbl, chi, hom ) local suptbl, fus; suptbl:= OrdinaryCharacterTable(Image( hom )); if UnderlyingCharacteristic( tbl ) <> 0 then suptbl:= suptbl mod UnderlyingCharacteristic( tbl ); fi; fus:= FusionConjugacyClasses( hom, tbl, suptbl ); return InducedClassFunctionsByFusionMap( tbl, suptbl, [ chi ], fus )[1]; end ); ############################################################################# ## #M InducedClassFunctions( [, ], ) #M InducedClassFunctions( [, ], ) #M InducedClassFunctions( [, ], ) ## InstallMethod( InducedClassFunctions, "for list, and group", [ IsList, IsGroup ], function( chars, H ) return List( chars, chi -> InducedClassFunction( chi, H ) ); end ); InstallMethod( InducedClassFunctions, "for list, and group homomorphism", [ IsList, IsGeneralMapping ], function( chars, hom ) return List( chars, chi -> InducedClassFunction( chi, hom ) ); end ); InstallMethod( InducedClassFunctions, "for list, and group homomorphism", [ IsList, IsCharacterTable ], function( chars, suptbl ) return List( chars, chi -> InducedClassFunction( chi, suptbl ) ); end ); InstallMethod( InducedClassFunctions, "for a character table, a homogeneous list, and a group", [ IsCharacterTable, IsHomogeneousList, IsGroup ], function( tbl, chars, G ) local suptbl, fus; suptbl:= OrdinaryCharacterTable( G ); if UnderlyingCharacteristic( tbl ) <> 0 then suptbl:= suptbl mod UnderlyingCharacteristic( tbl ); fi; fus:= FusionConjugacyClasses( tbl, suptbl ); return InducedClassFunctionsByFusionMap( tbl, suptbl, chars, fus ); end ); InstallMethod( InducedClassFunctions, "for character table, homogeneous list, and nearly character table", [ IsCharacterTable, IsHomogeneousList, IsNearlyCharacterTable ], function( tbl, chars, suptbl ) local fus; fus:= FusionConjugacyClasses( tbl, suptbl ); return InducedClassFunctionsByFusionMap( tbl, suptbl, chars, fus ); end ); InstallMethod( InducedClassFunctions, "for a character table, a homogeneous list, and a group homomorphism", [ IsCharacterTable, IsHomogeneousList, IsGeneralMapping ], function( tbl, chars, hom ) local suptbl, fus; suptbl:= Image( hom ); if UnderlyingCharacteristic( tbl ) <> 0 then suptbl:= suptbl mod UnderlyingCharacteristic( tbl ); fi; fus:= FusionConjugacyClasses( hom, tbl, suptbl ); return InducedClassFunctionsByFusionMap( tbl, suptbl, chars, fus ); end ); ############################################################################# ## #M Induced( [, ], ) #M Induced( [, ], ) #M Induced( [, ], ) #M Induced( [, ], ) #M Induced( [, ], ) #M Induced( [, ], ) ## InstallMethod( Induced, [ IsClassFunction, IsGroup ], InducedClassFunction ); InstallMethod( Induced, [ IsCharacterTable, IsHomogeneousList, IsGroup ], function( tbl, list, H ) if IsMatrix( list ) then return InducedClassFunctions( tbl, list, H ); else return InducedClassFunction( tbl, list, H ); fi; end ); InstallMethod( Induced, [ IsClassFunction, IsGroupHomomorphism ], InducedClassFunction ); InstallMethod( Induced, [ IsCharacterTable, IsHomogeneousList, IsGroupHomomorphism ], function( tbl, list, hom ) if IsMatrix( list ) then return InducedClassFunctions( tbl, list, hom ); else return InducedClassFunction( tbl, list, hom ); fi; end ); InstallMethod( Induced, [ IsClassFunction, IsNearlyCharacterTable ], InducedClassFunction ); InstallMethod( Induced, [ IsCharacterTable, IsHomogeneousList, IsNearlyCharacterTable ], function( tbl, list, suptbl ) if IsMatrix( list ) then return InducedClassFunctions( tbl, list, suptbl ); else return InducedClassFunction( tbl, list, suptbl ); fi; end ); InstallMethod( Induced, [ IsHomogeneousList, IsGroup ], function( list, H ) if ForAll( list, IsClassFunction ) then return InducedClassFunctions( list, H ); else TryNextMethod(); fi; end ); InstallMethod( Induced, [ IsHomogeneousList, IsGeneralMapping ], function( list, hom ) if ForAll( list, IsClassFunction ) then return InducedClassFunctions( list, hom ); else TryNextMethod(); fi; end ); InstallMethod( Induced, [ IsHomogeneousList, IsCharacterTable ], function( list, suptbl ) if ForAll( list, IsClassFunction ) then return InducedClassFunctions( list, suptbl ); else TryNextMethod(); fi; end ); ############################################################################# ## #M Induced( , , ) #M Induced( , , , ) #M Induced( , , , ) ## ## These methods are installed just for compatibility with {\GAP}~3. ## InstallMethod( Induced, "for two nearly character tables, and homog list", [ IsNearlyCharacterTable, IsNearlyCharacterTable, IsHomogeneousList ], function( subtbl, tbl, chars ) return InducedClassFunctionsByFusionMap( subtbl, tbl, chars, FusionConjugacyClasses( subtbl, tbl ) ); end ); InstallMethod( Induced, "for two nearly character tables, homog list, and string", [ IsNearlyCharacterTable, IsNearlyCharacterTable, IsHomogeneousList, IsString ], function( subtbl, tbl, chars, specification ) return InducedClassFunctionsByFusionMap( subtbl, tbl, chars, FusionConjugacyClasses( subtbl, tbl, specification ) ); end ); InstallMethod( Induced, "for two nearly character tables and two homog. lists", [ IsNearlyCharacterTable, IsNearlyCharacterTable, IsHomogeneousList, IsHomogeneousList and IsCyclotomicCollection ], InducedClassFunctionsByFusionMap ); ############################################################################# ## #M InducedCyclic( ) #M InducedCyclic( , \"all\" ) #M InducedCyclic( , ) #M InducedCyclic( , , \"all\" ) ## InstallMethod( InducedCyclic, "for a character table", [ IsOrdinaryTable ], tbl -> InducedCyclic( tbl, [ 1 .. NrConjugacyClasses( tbl ) ] ) ); InstallMethod( InducedCyclic, "for a character table and a string", [ IsOrdinaryTable, IsString ], # The `string' should overrule over the `homogeneous list' installed in # the next method 1, function( tbl, all ) return InducedCyclic( tbl, [ 1 .. NrConjugacyClasses( tbl ) ], all ); end ); InstallMethod( InducedCyclic, "for a character table and a hom. list", [ IsOrdinaryTable, IsHomogeneousList ], function( tbl, classes ) local centralizers, orders, independent, inducedcyclic, i, fusion, j, single; centralizers:= SizesCentralizers( tbl ); orders:= OrdersClassRepresentatives( tbl ); independent:= List( orders, x -> true ); inducedcyclic:= []; for i in classes do # induce from i-th class if independent[i] then fusion:= [ i ]; for j in [ 2 .. orders[i] ] do fusion[j]:= PowerMap( tbl, j, i ); # j-th powermap at class i od; single:= ListWithIdenticalEntries(Length(orders),0); for j in fusion do if orders[j] = orders[i] then # position is Galois conjugate to 'i' independent[j]:= false; fi; single[j]:= single[j] + 1; od; for j in [ 1 .. Length( orders ) ] do single[j]:= single[j] * centralizers[j] / orders[i]; if not IsInt( single[j] ) then single[j]:= Unknown(); Info( InfoCharacterTable, 1, "InducedCyclic: subgroup order not dividing sum", " (induce from class ", i, ")" ); fi; od; AddSet( inducedcyclic, Character( tbl, single ) ); fi; od; return inducedcyclic; end ); InstallMethod( InducedCyclic, "for a character table, a hom. list, and a string", [ IsOrdinaryTable, IsHomogeneousList, IsString ], function( tbl, classes, all ) local centralizers, orders, independent, inducedcyclic, i, fusion, j, k, single; centralizers:= SizesCentralizers( tbl ); orders:= OrdersClassRepresentatives( tbl ); independent:= List( orders, x -> true ); inducedcyclic:= []; for i in classes do # induce from i-th class if independent[i] then fusion:= [ i ]; for j in [ 2 .. orders[i] ] do fusion[j]:= PowerMap( tbl, j, i ); # j-th powermap at class i od; for k in [ 0 .. orders[i] - 1 ] do # induce k-th character single:= ListWithIdenticalEntries(Length(orders),0); single[i]:= E( orders[i] ) ^ ( k ); for j in [ 2 .. orders[i] ] do if orders[ fusion[j] ] = orders[i] then # position is Galois conjugate independent[ fusion[j] ]:= false; fi; single[ fusion[j] ]:= single[ fusion[j] ] + E( orders[i] )^( k*j mod orders[i] ); od; for j in [ 1 .. Length( orders ) ] do single[j]:= single[j] * centralizers[j] / orders[i]; if not IsCycInt( single[j] ) then single[j]:= Unknown(); Info( InfoCharacterTable, 1, "InducedCyclic: subgroup order not dividing sum", " (induce from class ", i, ")" ); fi; od; AddSet( inducedcyclic, Character( tbl, single ) ); od; fi; od; return inducedcyclic; end ); ############################################################################# ## ## 10. Reducing Virtual Characters ## ############################################################################# ## #M ReducedClassFunctions( [, ], ) #M ReducedClassFunctions( [, ] ) ## InstallMethod( ReducedClassFunctions, "for two lists (of class functions)", [ IsHomogeneousList, IsHomogeneousList ], function( constituents, reducibles ) if IsEmpty( constituents ) then return rec( irreducibles:= [], remainders:= ShallowCopy( reducibles ) ); elif IsClassFunction( constituents[1] ) then return ReducedClassFunctions( UnderlyingCharacterTable( constituents[1] ), constituents, reducibles ); else TryNextMethod(); fi; end ); InstallMethod( ReducedClassFunctions, "for a list (of class functions)", [ IsHomogeneousList ], function( reducibles ) if IsEmpty( reducibles ) then return rec( irreducibles:= [], remainders:= [] ); elif IsClassFunction( reducibles[1] ) then return ReducedClassFunctions( UnderlyingCharacterTable( reducibles[1] ), reducibles ); else TryNextMethod(); fi; end ); InstallMethod( ReducedClassFunctions, "for ordinary character table, and two lists (of class functions)", [ IsOrdinaryTable, IsHomogeneousList , IsHomogeneousList ], function( ordtbl, constituents, reducibles ) local i, j, normsquare, upper, found, # list of found irreducible characters remainders, # list of reducible remainders after reduction single, reduced, scpr; upper:= Length( constituents ); upper:= List( reducibles, x -> upper ); normsquare:= List( constituents, x -> ScalarProduct( ordtbl, x, x ) ); found:= []; remainders:= []; for i in [ 1 .. Length( reducibles ) ] do single:= reducibles[i]; for j in [ 1 .. upper[i] ] do scpr:= ScalarProduct( ordtbl, single, constituents[j] ); if IsInt( scpr ) then scpr:= Int( scpr / normsquare[j] ); if scpr <> 0 then single:= single - scpr * constituents[j]; fi; else Info( InfoCharacterTable, 1, "ReducedClassFunctions: scalar product of X[", j, "] with Y[", i, "] not integral (ignore)" ); fi; od; if ForAny( single, x -> x <> 0 ) then if single[1] < 0 then single:= - single; fi; if ScalarProduct( ordtbl, single, single ) = 1 then if not single in found and not single in constituents then Info( InfoCharacterTable, 2, "ReducedClassFunctions: irreducible character of degree ", single[1], " found" ); if IsClassFunction( single ) then SetIsCharacter( single, true ); fi; AddSet( found, single ); fi; else AddSet( remainders, single ); fi; fi; od; # If no irreducibles were found, return the remainders. if IsEmpty( found ) then return rec( remainders:= remainders, irreducibles:= [] ); fi; # Try to find new irreducibles by recursively calling the reduction. reduced:= ReducedClassFunctions( ordtbl, found, remainders ); # Return the result. return rec( remainders:= reduced.remainders, irreducibles:= Union( found, reduced.irreducibles ) ); end ); InstallMethod( ReducedClassFunctions, "for ordinary character table, and list of class functions", [ IsOrdinaryTable, IsHomogeneousList ], function( ordtbl, reducibles ) local upper, normsquare, found, # list of found irreducible characters remainders, # list of reducible remainders after reduction i, j, single, reduced, scpr; upper:= [ 0 .. Length( reducibles ) - 1 ]; normsquare:= List( reducibles, x -> ScalarProduct( ordtbl, x, x ) ); found:= []; remainders:= []; for i in [ 1 .. Length( reducibles ) ] do if normsquare[i] = 1 then if 0 < reducibles[i][1] then AddSet( found, reducibles[i] ); else AddSet( found, - reducibles[i] ); fi; fi; od; for i in [ 1 .. Length( reducibles ) ] do single:= reducibles[i]; for j in [ 1 .. upper[i] ] do scpr:= ScalarProduct( ordtbl, single, reducibles[j] ); if IsInt( scpr ) then scpr:= Int( scpr / normsquare[j] ); if scpr <> 0 then single:= single - scpr * reducibles[j]; fi; else Info( InfoCharacterTable, 1, "ReducedClassFunctions: scalar product of X[", j, "] with Y[", i, "] not integral (ignore)" ); fi; od; if ForAny( single, x -> x <> 0 ) then if single[1] < 0 then single:= - single; fi; if ScalarProduct( ordtbl, single, single ) = 1 then if not single in found and not single in reducibles then Info( InfoCharacterTable, 2, "ReducedClassFunctions: irreducible character of degree ", single[1], " found" ); if IsClassFunction( single ) then SetIsCharacter( single, true ); fi; AddSet( found, single ); fi; else AddSet( remainders, single ); fi; fi; od; # If no irreducibles were found, return the remainders. if IsEmpty( found ) then return rec( remainders:= remainders, irreducibles:= [] ); fi; # Try to find new irreducibles by recursively calling the reduction. reduced:= ReducedClassFunctions( ordtbl, found, remainders ); # Return the result. return rec( remainders:= reduced.remainders, irreducibles:= Union( found, reduced.irreducibles ) ); end ); ############################################################################# ## #M ReducedCharacters( [, ], ) ## InstallMethod( ReducedCharacters, "for two lists (of characters)", [ IsHomogeneousList , IsHomogeneousList ], function( constituents, reducibles ) if IsEmpty( constituents ) then return rec( irreducibles:= [], remainders:= ShallowCopy( reducibles ) ); elif IsClassFunction( constituents[1] ) then return ReducedCharacters( UnderlyingCharacterTable( constituents[1] ), constituents, reducibles ); else TryNextMethod(); fi; end ); InstallMethod( ReducedCharacters, "for ordinary character table, and two lists of characters", [ IsOrdinaryTable, IsHomogeneousList , IsHomogeneousList ], function( ordtbl, constituents, reducibles ) local normsquare, found, remainders, single, i, j, nchars, reduced, scpr; normsquare:= List( constituents, x -> ScalarProduct( ordtbl, x, x ) ); found:= []; remainders:= []; nchars:= Length( constituents ); for i in [ 1 .. Length( reducibles ) ] do single:= reducibles[i]; for j in [ 1 .. nchars ] do if constituents[j][1] <= single[1] then scpr:= ScalarProduct( ordtbl, single, constituents[j] ); if IsInt( scpr ) then scpr:= Int( scpr / normsquare[j] ); if scpr <> 0 then single:= single - scpr * constituents[j]; fi; else Info( InfoCharacterTable, 1, "ReducedCharacters: scalar product of X[", j, "] with Y[", i, "] not integral (ignore)" ); fi; fi; od; if ForAny( single, x -> x <> 0 ) then if ScalarProduct( ordtbl, single, single ) = 1 then if single[1] < 0 then single:= - single; fi; if not single in found and not single in constituents then Info( InfoCharacterTable, 2, "ReducedCharacters: irreducible character of", " degree ", single[1], " found" ); if IsClassFunction( single ) then SetIsCharacter( single, true ); fi; AddSet( found, single ); fi; else AddSet( remainders, single ); fi; fi; od; # If no irreducibles were found, return the remainders. if IsEmpty( found ) then return rec( remainders:= remainders, irreducibles:= [] ); fi; # Try to find new irreducibles by recursively calling the reduction. reduced:= ReducedCharacters( ordtbl, found, remainders ); # Return the result. return rec( remainders:= reduced.remainders, irreducibles:= Union( found, reduced.irreducibles ) ); end ); ############################################################################# ## #F IrreducibleDifferences( , , ) #F IrreducibleDifferences( , , , ) #F IrreducibleDifferences( , , \"triangle\" ) #F IrreducibleDifferences( , , \"triangle\", ) ## #T compute/consider scalar product of i-th and j-th character only if the #T norms have different parity! ## InstallGlobalFunction( IrreducibleDifferences, function( arg ) local tbl, reducibles, irreducibledifferences, scprmatrix, i, j, diff, reducibles2, norms, norms2; if not ( Length( arg ) in [ 3, 4 ] and IsOrdinaryTable( arg[1] ) and IsList( arg[2] ) and ( IsList( arg[3] ) or IsString( arg[3] ) ) ) or ( Length( arg ) = 4 and not IsList( arg[4] ) ) then Error( "usage: IrreducibleDifferences(tbl,reducibles,\"triangle\")\n", "resp. IrreducibleDifferences(tbl,reducibles,\"triangle\",scprmat)", "\n resp. IrreducibleDifferences(tbl,reducibles,reducibles2)\nresp.", " IrreducibleDifferences(tbl,reducibles,reducibles2,scprmat)" ); fi; tbl:= arg[1]; reducibles:= arg[2]; irreducibledifferences:= []; if IsString( arg[3] ) then # "triangle" if Length( arg ) = 3 then scprmatrix:= MatScalarProducts( tbl, reducibles ); else scprmatrix:= arg[4]; fi; for i in [ 1 .. Length( scprmatrix ) ] do for j in [ 1 .. i-1 ] do if scprmatrix[i][i] + scprmatrix[j][j] - 2*scprmatrix[i][j] = 1 then if reducibles[i][1] > reducibles[j][1] then diff:= reducibles[i] - reducibles[j]; Info( InfoCharacterTable, 2, "IrreducibleDifferences: X[",i, "] - X[",j, "] found" ); else diff:= reducibles[j] - reducibles[i]; Info( InfoCharacterTable, 2, "IrreducibleDifferences: X[",j, "] - X[",i, "] found" ); fi; if IsClassFunction( diff ) then SetIsCharacter( diff, true ); fi; AddSet( irreducibledifferences, diff ); fi; od; od; else # not "triangle" reducibles2:= arg[3]; if Length( arg ) = 3 then scprmatrix:= MatScalarProducts( tbl, reducibles, reducibles2 ); else scprmatrix:= arg[4]; fi; norms := List( reducibles , x -> ScalarProduct(tbl,x,x) ); norms2:= List( reducibles2, x -> ScalarProduct(tbl,x,x) ); for i in [ 1 .. Length( norms ) ] do for j in [ 1 .. Length( norms2 ) ] do if norms[i] + norms2[j] - 2 * scprmatrix[i][j] = 1 then if reducibles[j][1] > reducibles2[i][1] then diff:= reducibles[j] - reducibles2[i]; Info( InfoCharacterTable, 2, "IrreducibleDifferences: X[",j, "] - Y[",i, "] found" ); else diff:= reducibles2[i] - reducibles[j]; Info( InfoCharacterTable, 2, "IrreducibleDifferences: Y[",i, "] - X[",j, "] found" ); fi; if IsClassFunction( diff ) then SetIsCharacter( diff, true ); fi; AddSet( irreducibledifferences, diff ); fi; od; od; fi; return irreducibledifferences; end ); ############################################################################# ## ## 11. Symmetrizations of Class Functions ## ############################################################################# ## #F Symmetrizations( [, ], ) #F Symmetrizations( [, ], ) #F Symmetrizations( , , ) ## InstallMethod( Symmetrizations, "for homogeneous list (of class functions) and positive integer", [ IsHomogeneousList, IsPosInt ], function( list, n ) if IsEmpty( list ) then return []; elif IsClassFunction( list[1] ) then return Symmetrizations( UnderlyingCharacterTable( list[1] ), list, n ); else TryNextMethod(); fi; end ); InstallMethod( Symmetrizations, "for homogeneous list (of class functions) and character table", [ IsHomogeneousList, IsOrdinaryTable ], function( list, Sn ) if IsEmpty( list ) then return []; elif IsClassFunction( list[1] ) then return Symmetrizations( UnderlyingCharacterTable( list[1] ), list, Sn ); else TryNextMethod(); fi; end ); InstallMethod( Symmetrizations, "for char. table, homog. list (of class functions), and pos. integer", [ IsCharacterTable, IsHomogeneousList, IsPosInt ], function( tbl, characters, n ) local gensymm, classparam, siz, classes; gensymm:= CharTableSymmetric; classparam:= gensymm.classparam[1]( n ); siz:= gensymm.size( n ); classes:= List( classparam, p -> siz / gensymm.centralizers[1]( n, p ) ); return Symmetrizations( tbl, characters, rec( classparam := List( classparam, x -> [ 1, x ] ), symmirreds := gensymm.matrix( n ), symmclasses := classes, symmorder := siz ) ); end ); InstallMethod( Symmetrizations, "for char. table, homog. list (of class functions), and table of Sn", [ IsCharacterTable, IsHomogeneousList, IsOrdinaryTable ], function( tbl, characters, Sn ) if not HasClassParameters( Sn ) then Error( "partitions corresponding to classes must be stored", " as `ClassParameters( )'" ); fi; return Symmetrizations( tbl, characters, rec( classparam := ClassParameters( Sn ), symmirreds := List( Irr( Sn ), ValuesOfClassFunction ), symmclasses := SizesConjugacyClasses( Sn ), symmorder := Size( Sn ) ) ); end ); InstallOtherMethod( Symmetrizations, "for char. table, homog. list (of class functions), and record", [ IsCharacterTable, IsHomogeneousList, IsRecord ], function( tbl, characters, arec ) local i, j, l, n, tbl_powermap, # computed power maps of 'tbl' cyclestruct, classparam, symmirreds, symmclasses, symmorder, cycl, symmetrizations, chi, psi, powermap, prodmatrix, single, value, val; classparam := arec.classparam; symmirreds := arec.symmirreds; symmclasses := arec.symmclasses; symmorder := arec.symmorder; cyclestruct:= []; for i in [ 1 .. Length( classparam ) ] do if Length( classparam[i][2] ) = 1 then n:= classparam[i][2][1]; fi; cyclestruct[i]:= []; for j in [ 1 .. Maximum( classparam[i][2] ) ] do cyclestruct[i][j]:= 0; od; for j in classparam[i][2] do cyclestruct[i][j]:= cyclestruct[i][j] + 1; od; od; tbl_powermap:= ShallowCopy( ComputedPowerMaps( tbl ) ); #T better do the computation of necessary power maps only once! # Compute necessary power maps. for i in [ 1 .. n ] do if not IsBound( tbl_powermap[i] ) then tbl_powermap[i]:= PowerMap( tbl, i ); fi; od; powermap:= tbl_powermap; symmetrizations:= []; for chi in characters do # Symmetrize the character `chi' of `tbl' ... prodmatrix:= []; for i in [ 1 .. Length( characters[1] ) ] do prodmatrix[i]:= []; for j in [ 1 .. Length( symmclasses ) ] do value:= symmclasses[j]; cycl:= cyclestruct[j]; for l in [ 1 .. Length( cycl ) ] do if cycl[l] <> 0 then if IsInt( powermap[l][i] ) then value:= value * ( chi[ powermap[l][i] ] ^ cycl[l] ); else val:= CompositionMaps( chi, powermap[l][i] ); if IsInt( val ) then value:= value * ( val ^ cycl[l] ); else value:= Unknown(); fi; fi; fi; od; prodmatrix[i][j]:= value; od; od; # ... with the character `psi' ... for psi in symmirreds do single:= []; for i in [ 1 .. Length( chi ) ] do # ... at class `i' single[i]:= psi * prodmatrix[i] / symmorder; if not ( IsCycInt( single[i] ) or IsUnknown( single[i] ) ) then single[i]:= Unknown(); Print( "#E Symmetrizations: value not dividing group order,", " set to ", single[i], "\n" ); fi; od; if IsClassFunction( chi ) and single[1] > 0 then single:= ClassFunctionSameType( tbl, chi, single ); elif HasIsVirtualCharacter( chi ) and IsVirtualCharacter( chi ) then single:= VirtualCharacter( tbl, single ); fi; Add( symmetrizations, single ); od; od; # Return the symmetrizations. return symmetrizations; end ); ############################################################################# ## #F SymmetricParts( , , ) ## InstallGlobalFunction( SymmetricParts, function( tbl, characters, n ) local i, j, k, nccl, exponents, symcentralizers, # list of symmetrizations, result symmetricparts, chi, # loop over 'characters' sym, exp, factor, powermap; # list of computed power maps of 'tbl' if IsEmpty( characters ) then return []; fi; nccl:= NrConjugacyClasses( tbl ); exponents:= Partitions( n ); symcentralizers:= CharTableSymmetric.centralizers[1]; symcentralizers:= List( exponents, x -> symcentralizers( n, x ) ); for i in [ 1 .. Length( exponents ) ] do # Transform partitions to exponent vectors. # At position $i$ we store the number of cycles of length $i$. exp:= []; for j in [ 1 .. Maximum( exponents[i] ) ] do exp[j]:= 0; od; for j in exponents[i] do exp[j]:= exp[j] + 1; od; exponents[i]:= exp; od; # Compute necessary power maps. powermap:= ComputedPowerMaps( tbl ); for i in [ 1 .. n ] do if not IsBound( powermap[i] ) then powermap[i]:= PowerMap( tbl, i ); fi; od; symmetricparts:= []; for chi in characters do Info( InfoCharacterTable, 2, "SymmetricParts: chi[.]" ); sym:= List( chi, x -> 0 ); # Loop over the conjugacy classes of the symmetric group. for j in [ 1 .. Length( symcentralizers ) ] do exp:= exponents[j]; for k in [ 1 .. nccl ] do factor:= 1; for i in [ 1 .. Length( exp ) ] do if IsBound( exp[i] ) then factor:= factor * chi[ powermap[i][k] ]^exp[i]; fi; od; sym[k]:= sym[k] + factor / symcentralizers[j]; od; od; if IsClassFunction( chi ) then sym:= ClassFunctionSameType( tbl, chi, sym ); fi; Add( symmetricparts, sym ); od; # Return the symmetrizations. return symmetricparts; end ); ############################################################################# ## #F AntiSymmetricParts( , , ) ## InstallGlobalFunction( AntiSymmetricParts, function( tbl, characters, n ) local i, j, k, nccl, exponents, symcentralizers, antisymmetricparts, chi, sym, exp, factor, powermap; if IsEmpty( characters ) then return []; fi; nccl:= NrConjugacyClasses( tbl ); exponents:= Partitions( n ); symcentralizers:= CharTableSymmetric.centralizers[1]; symcentralizers:= List( exponents, x -> symcentralizers( n, x ) ); for i in [ 1 .. Length( exponents ) ] do # Transform partitions to exponent vectors. # At position $i$ we store the number of cycles of length $i$. exp:= []; for j in [ 1 .. Maximum( exponents[i] ) ] do exp[j]:= 0; od; for j in exponents[i] do exp[j]:= exp[j] + 1; od; exponents[i]:= exp; od; # Compute necessary power maps. powermap:= ComputedPowerMaps( tbl ); for i in [ 1 .. n ] do if not IsBound( powermap[i] ) then powermap[i]:= PowerMap( tbl, i ); fi; od; # Compute the symmetrizations. antisymmetricparts:= []; for chi in characters do Info( InfoCharacterTable, 2, "AntiSymmetricParts: chi[.]" ); sym:= List( chi, x -> 0 ); for j in [ 1 .. Length( exponents ) ] do exp:= exponents[j]; for k in [ 1 .. nccl ] do factor:= 1; for i in [ 1 .. Length( exp ) ] do if IsBound( exp[i] ) then if i mod 2 = 0 and exp[i] mod 2 = 1 then factor:= -factor * chi[ powermap[i][k] ]^exp[i]; else factor:= factor * chi[ powermap[i][k] ]^exp[i]; fi; fi; od; sym[k]:= sym[k] + factor / symcentralizers[j]; od; od; if IsClassFunction( chi ) and sym[1] > 0 then sym:= ClassFunctionSameType( tbl, chi, sym ); elif HasIsVirtualCharacter( chi ) and IsVirtualCharacter( chi ) then sym:= VirtualCharacter( tbl, sym ); fi; Add( antisymmetricparts, sym ); od; # Return the symmetrizations. return antisymmetricparts; end ); ############################################################################# ## #F RefinedSymmetrizations( , , , ) ## ## (Note: It suffices to change `F2' and `F4' in order to get the ## symplectic components from the orthogonal ones.) ## ## We have (see J.S. Frame, Recursive computation of tensor power ## components, Bayreuther Mathematische Schriften 10, 153--159) ## ## \begintt ## component orthogonal symplectic ## M0 = L0 L0 ( = 1 ) ## M1 = L1 L1 ## M11 = L11 L11-L0 ## M2 = L2-L0 L2 ## M111 = L111 L111-L1 ## M21 = L21-L1 L21-L1 ## M3 = L3-L1 L3 ## M1111 = L1111 L1111-L11 ## M211 = L211-L11 L211-L11-L2+L0 ## M22 = L22-L2 L22-L11 ## M31 = L31-L2-L11+L0 L31-L2 ## M4 = L4-L2 L4 ## M11111 = L11111 L11111-L111 ## M2111 = L2111-L111 L2111-L111-L21+L1 ## M221 = L221-L21 L221-L111-L21+L1 ## M311 = L311-L21-L111+L1 L311-L21-L3+L1 ## M32 = L32-L3-L21+L1 L32-L21 ## M41 = L41-L3-L21+L1 L41-L3 ## M5 = L5-L3 L5 ## M111111 = L111111 L111111-L1111 ## M21111 = L21111-L1111 L21111-L1111-L211+L11 ## M2211 = L2211-L211 L2211-L1111-L211-L22+L11+L2 ## M3111 = L3111-L211-L1111+L11 L3111-L211-L31+L11+L2-L0 ## M222 = L222-L22 L222-L211+L11-L0 ## M321 = L321-L31-L22-L211+L2+L11 L321-L31-L22-L211+L2+L11 ## M33 = L33-L31+L2-L0 L33-L22 ## M411 = L411-L31-L211+L2+L11-L0 L411-L31-L4+L2 ## M42 = L42-L4-L31-L22+L2+L11 L42-L31 ## M51 = L51-L4-L31+L2 L51-L4 ## M6 = L6-L4 L6 ## \endtt ## InstallGlobalFunction( RefinedSymmetrizations, function( tbl, chars, m, func ) local i, classes, components, F2, F3, F4, F5, F6, M1, M2, M11, M3, M21, M111, M4, M31, M22, M211, M1111, M5, M41, M32, M311, M221, M2111, M11111, M6, M51, M42, M411, M33, M321, M3111, M222, M2211, M21111, M111111; # Linear characters are not allowed since their symmetrizations need not # to be proper characters. chars:= Filtered( chars, x -> 1 < x[1] ); components:= []; classes:= [ 1 .. NrConjugacyClasses( tbl ) ]; for M1 in chars do F2 := MinusCharacter( M1, PowerMap( tbl, 2 ), 2 ); # orthogonal case: 'M11 = F2' # symplectic case: 'M11 = F2 - 1' M11:= func( F2, 1 ); M2 := List( classes, x -> M1[x]^2 - M11[x] - 1 ); Add( components, M11 ); Add( components, M2 ); if m > 2 then F3:= MinusCharacter( M1, PowerMap( tbl, 3 ), 3 ); M21:= F3 - M1; M111:= List( classes, x -> M1[x] * M11[x] - F3[x] ); M3:= List( classes, x -> M1[x] * M2[x] - F3[x] ); Append( components, [ M21, M111, M3 ] ); if m > 3 then F4:= MinusCharacter( F2, PowerMap( tbl, 2 ), 2 ); # orthogonal case: 'F4 := F4' # symplectic case: 'F4 := F4 - M2' F4:= func( F4, M2 ); M211:= F4 - M11; M31:= List( classes, x -> M11[x]*M2[x]-F4[x]-M2[x]); M22:= List( classes, x -> M1[x]*M21[x]-F4[x]-M2[x]-M31[x] ); M1111:= List( classes, x -> M1[x]*M111[x]-F4[x] ); M4:= List( classes, x -> M1[x]*M3[x]-M31[x]-M2[x] ); Append( components, [ M211, M31, M22, M1111, M4 ] ); if m > 4 then F5:= MinusCharacter( M1, PowerMap( tbl, 5 ), 5 ); M2111:= List( classes, x-> F5[x]-M2[x]*F3[x]-M1[x]*M11[x] ); M311:= List( classes, x-> M2[x]*M111[x]-M2111[x]-M21[x] -M111[x] ); M221:= List( classes, x-> M1[x]*M211[x]-M2[x]*M111[x] ); M11111:= List( classes, x-> M1[x]*M1111[x]-M2111[x]-M111[x]); M32:= List( classes, x-> M1[x]*M22[x]-M221[x]-M21[x] ); M41:= List( classes, x-> M11[x]*M3[x]-M311[x]-M21[x] -M3[x] ); M5:= List( classes, x-> M1[x]*M4[x]-M41[x]-M3[x] ); Append( components, [ M2111, M311, M221, M11111, M32, M41, M5 ]); if m = 6 then F6:= MinusCharacter( F2, PowerMap( tbl, 3 ), 3 ); M3111:= List( classes, x-> M21[x]*M111[x]-F6[x]+F2[x] ); M411:= List( classes, x-> M3[x]*M111[x]-M3111[x]-M31[x] -M211[x] ); M21111:= List( classes, x-> M2[x]*M1111[x]-M3111[x] -M211[x]-M1111[x] ); M111111:= List( classes, x-> M1[x]*M11111[x]-M21111[x] -M1111[x] ); M2211:= List( classes, x-> M1[x]*M2111[x]-M3111[x] -M21111[x]-M211[x]-M1111[x] ); M321:= List( classes, x-> M1[x]*M311[x]-M3111[x] -M411[x]-M31[x]-M211[x] ); M33:= List( classes, x-> F2[x]*M22[x]-M321[x]-M2211[x] -M31[x]-M22[x]-M211[x]-F2[x] ); M51:= List( classes, x-> F2[x]*M4[x]-M411[x]-M31[x] -M4[x] ); M42:= List( classes, x-> M1[x]*M41[x]-M411[x]-M51[x] -M31[x]-M4[x] ); M222:= List( classes, x-> M2[x]*M22[x]-M321[x]-M42[x] -M31[x]-M22[x]-M211[x]-M2[x] ); M6:= List( classes, x-> M1[x]*M5[x]-M51[x]-M4[x] ); Append( components, [ M3111, M411, M21111, M111111, M2211, M321, M33, M51, M42, M222, M6 ] ); fi; fi; fi; fi; od; return List( components, chi -> ClassFunction( tbl, chi ) ); end ); ############################################################################# ## #F OrthogonalComponents( , , ) ## InstallGlobalFunction( OrthogonalComponents, function( tbl, chars, m ) if IsCharacterTable( tbl ) and IsList( chars ) and IsInt( m ) and 1 < m and m < 7 then return RefinedSymmetrizations( tbl, chars, m, function( x, y ) return x; end ); else Error( "usage: OrthogonalComponents( , , ) with ", "integer 2 <= m <= 6" ); fi; end ); ############################################################################# ## #F SymplecticComponents( , , ) ## InstallGlobalFunction( SymplecticComponents, function( tbl, chars, m ) if IsCharacterTable( tbl ) and IsList( chars ) and IsInt( m ) and 1 < m and m < 6 then return RefinedSymmetrizations( tbl, chars, m, function( x, y ) return x-y; end ); else Error( "usage: SymplecticComponents( , , ) with ", "integer 2 <= m <= 5" ); fi; end ); ############################################################################# ## ## 12. Operations for Brauer Characters ## ############################################################################### ## #F FrobeniusCharacterValue( ,

) ## ## Let $n$ be the conductor of $v$. ## Let $k$ be the order of $p$ modulo $n$, that is, $\F_{p^k}$ is the ## smallest field of characteristic $p$ containing $n$-th roots of unity. ## Let $m$ be minimal with $v^{\ast p^m} = v$, that is, $\F_{p^m}$ is a ## (not necessarily minimal) field containing the Frobenius character value ## $\overline{v}$. ## ## Let $C_k$ and $C_m$ be the Conway polynomials of degrees $k$ and $m$, ## and $z = X + (C_k)$ in $\F_{p^k} = \F_p[X] / (C_k)$. ## Then $\hat{y} = z^{\frac{p^k-1}{p^m-1}}$ may be identified with ## $y = X + (C_m)$ in $\F_{p^m} = \F_p[X] / (C_m)$. ## ## For $v = \sum_{i=1}^n a_i E(n)^i$, a representation of $\overline{v}$ in ## $\F_{p^k}$ is $\sum_{i=1}^n \overline{a_i} z^{\frac{p^k-1}{n} i}$ where ## $\overline{a_i}$ is the reduction of $a_i$ modulo $p$, viewed as ## element of $\F_p$. ## ## A representation of $\overline{v}$ in $\F_{p^m}$ can be found by ## solving the linear equation system ## $\overline{v} = \sum_{i=0}^{m-1} c_i \hat{y}^i$ over $\F_p$, which ## gives us $\overline{v} = \sum{i=0}^{m-1} c_i y^i$ in $\F_{p^m}$. ## InstallGlobalFunction( FrobeniusCharacterValue, function( value, p ) local n, # conductor of `value' k, # degree of smallest field containing `n'-th roots size, # `p^k' power, # `( size - 1 ) / n' ffe, # primitive `n'-th root in `GF( size )' cf, # canonical basis of `CF(n)' m, # degree of some field containing the result image, # image of `value' under Galois conjugation primefield, # `GF(p)' zero, # zero of `primefield' one, # identity of `primefield' conwaypol, # coeffs. of the `k'-th Conway pol. in char. `p' x, # coeffs. of an indeterminate y, lastvalue, fieldbase, i; # If belongs to a

-singular element then return `fail'. n:= Conductor( value ); if n mod p = 0 then return fail; elif n = 1 then if DenominatorRat( value ) mod p = 0 then return fail; else return value * One( GF(p) ); fi; elif IsCycInt( value / p ) then return Zero( GF(p) ); fi; # Compute the size $p^k$ of the smallest finite field of characteristic # `p' that contains 'n'-th roots of unity. k:= OrderMod( p, n ); size:= p^k; # The root `E(n)' is identified with the smallest primitive `n'-th # root in the finite field, that is, the `(size-1) / n'-th power of # the primitive root of the field # (which is given by the Conway polynomial). power:= ( size - 1 ) / n; if size <= MAXSIZE_GF_INTERNAL then # Use GAP's internal finite fields. # (Express the Brauer character value in terms of the Zumbroich basis # of the underlying cyclotomic field.) ffe:= PrimitiveRoot( GF( size ) ) ^ power; cf:= CanonicalBasis( CF( n ) ); value:= Coefficients( cf, value ) * List( ZumbroichBase( n, 1 ), exp -> ffe ^ exp ); elif not IsCheapConwayPolynomial( p, k ) then # Give up if the required Conway polynomial is hard to compute. Info( InfoWarning, 1, "the Conway polynomial of degree ", k, " for p = ", p, " is not known" ); return fail; else # Compute a finite field that contains the Frobenius character value. # An upper bound is given by the field of order $p^m$ # where $m$ is the smallest number such that is fixed # by the Galois automorphism that raises roots of unity # to the $p^m$-th power. m:= 1; image:= GaloisCyc( value, p ); while image <> value do m:= m+1; image:= GaloisCyc( image, p ); od; # Compute the representation of the Frobenius character value # in the field $\F_{p^k}$. primefield:= GF(p); zero:= Zero( primefield ); one:= One( primefield ); conwaypol:= ConwayPol( p, k ) * one; x:= [ zero, one ]; value:= COEFFS_CYC( value ) * one; ConvertToVectorRepNC( conwaypol, p ); ConvertToVectorRepNC( x, p ); ConvertToVectorRepNC( value, p ); value:= PowerModEvalPol( conwaypol, value, PowerModCoeffs( x, 2, power, conwaypol, k+1 ) ); if IsEmpty( value ) then return zero; fi; PadCoeffs( value, k, zero ); # Compute a $\F_p$-basis $(\hat{y}^i; 0\leq i\leq m-1)$ of # the subfield of $\F_{p^k}$ isomorphic with $\F_{p^m}$. y:= PowerModCoeffs( x, 2, (size - 1) / (p^m - 1), conwaypol, k+1 ); lastvalue:= [ one ]; fieldbase:= [ [ one ] ]; PadCoeffs( fieldbase[1], k, zero ); ConvertToVectorRepNC( fieldbase[1], p ); for i in [ 2 .. m ] do lastvalue:= ProductCoeffs( y, lastvalue ); ReduceCoeffs( lastvalue, conwaypol ); #T bad that ReduceCoeffs does not predict how it deals with trailing zeros PadCoeffs( lastvalue, k, zero ); fieldbase[i]:= lastvalue; ConvertToVectorRepNC( fieldbase[i], p ); od; value:= ValuePol( SolutionMatDestructive( fieldbase, value ), Z( p, m ) ); fi; # Return the Frobenius character value. return value; end ); ############################################################################## ## #F ReductionToFiniteField( ,

) ## InstallGlobalFunction( ReductionToFiniteField, function( value, p ) local n, primefield, one, zero, k, size, power, ffe, cf, frob, d, conwaypol, x, m, primes, sol, l, mc, y, leny, lastvalue, fieldbase, i, redsol; # If belongs to a

-singular element then return `fail'. n:= Conductor( value ); if n mod p = 0 then return fail; fi; primefield:= GF(p); # Catch the case where the reduction trivially lies in the prime field. if n = 1 then if DenominatorRat( value ) mod p = 0 then return fail; else return [ value * One( Indeterminate( primefield ) ), 1 ]; fi; elif IsCycInt( value / p ) then return [ Zero( Indeterminate( primefield ) ), 1 ]; fi; one:= One( primefield ); zero:= Zero( primefield ); # Compute the size $p^k$ of the smallest finite field of characteristic # `p' that contains `n'-th roots of unity. k:= OrderMod( p, n ); size:= p^k; # The root `E(n)' is identified with the smallest primitive `n'-th # root in the finite field, that is, the `(size-1) / n'-th power of # the primitive root of the field # (which is given by the Conway polynomial). power:= ( size - 1 ) / n; if size <= MAXSIZE_GF_INTERNAL then # Use GAP's internal finite fields. # (Compute the Frobenius character value and the corresponding pol.) ffe:= PrimitiveRoot( GF( size ) ) ^ power; cf:= CanonicalBasis( CF( n ) ); frob:= Coefficients( cf, value ) * List( ZumbroichBase( n, 1 ), exp -> ffe ^ exp ); if IsZero( frob ) then return [ Zero( Indeterminate( primefield ) ), 1 ]; fi; d:= DegreeFFE( frob ); if d = 1 then return [ frob * One( Indeterminate( primefield ) ), 1 ]; fi; # Note that `LogFFE' returns a nonzero value. conwaypol:= ConwayPol( p, d ) * one; x:= [ zero, one ]; ConvertToVectorRepNC( conwaypol, p ); ConvertToVectorRepNC( x, p ); frob:= PowerModCoeffs( x, 2, LogFFE( frob, Z( p, d ) ), conwaypol, d+1 ); return [ UnivariatePolynomialByCoefficients( FamilyObj( one ), frob, 1 ), d ]; elif not IsCheapConwayPolynomial( p, k ) then # Give up if the required Conway polynomial is hard to compute. Info( InfoWarning, 1, "the Conway polynomial of degree ", k, " for p = ", p, " is not known" ); return fail; fi; conwaypol:= ConwayPol( p, k ) * one; x:= [ zero, one ]; value:= COEFFS_CYC( value ) * one; ConvertToVectorRepNC( conwaypol, p ); ConvertToVectorRepNC( x, p ); ConvertToVectorRepNC( value, p ); value:= PowerModEvalPol( conwaypol, value, PowerModCoeffs( x, 2, power, conwaypol, k+1 ) ); if IsEmpty( value ) then return [ Zero( Indeterminate( primefield ) ), 1 ]; fi; PadCoeffs( value, k, zero ); # Reduce the representation into the smallest finite field. # The currently known field has size `p^k'. m:= k; if k <> 1 then primes:= Set( Factors( m ) ); sol:= fail; while not IsEmpty( primes ) do for l in ShallowCopy( primes ) do # `p^(m/l)' is the candidate for next smaller field. mc:= m / l; # Compute a $\F_p$-basis $(\hat{y}^i; 0 \leq i \leq m/l - 1)$ of # the subfield of $\F_{p^k}$ isomorphic with $\F_{p^{(m/l)}}$. y:= PowerModCoeffs( x, 2, (size - 1) / (p^mc - 1), conwaypol, k+1 ); leny:= Length( y ); lastvalue:= [ one ]; PadCoeffs( lastvalue, k, zero ); fieldbase:= [ [ one ] ]; PadCoeffs( fieldbase[1], k, zero ); ConvertToVectorRepNC( lastvalue, p ); ConvertToVectorRepNC( fieldbase[1], p ); for i in [ 2 .. mc ] do lastvalue:= ProductCoeffs( y, leny, lastvalue, k ); ReduceCoeffs( lastvalue, conwaypol ); PadCoeffs( lastvalue, k, zero ); ConvertToVectorRepNC( lastvalue, p ); #T needed? fieldbase[i]:= lastvalue; od; # Check whether `value' is a linear combination of this basis. redsol:= SolutionMatDestructive( fieldbase, ShallowCopy( value ) ); if redsol = fail then RemoveSet( primes, l ); else sol:= redsol; m:= mc; fi; od; IntersectSet( primes, Factors( m ) ); od; if sol <> fail then # We have found a smaller field. value:= sol; fi; fi; # Return the reduction into the minimal field. return [ UnivariatePolynomialByCoefficients( FamilyObj( one ), value, 1 ), m ]; end ); # # alternative implementation # ReductionToFiniteField2:= function( value, p ) # local frob, d, z, one, zero, conwaypol, x; # # frob:= FrobeniusCharacterValue( value, p ); # if frob = fail then # return fail; # elif IsZero( frob ) then # return [ Zero( Indeterminate( GF(p) ) ), 1 ]; # fi; # # d:= DegreeFFE( frob ); # # if d = 1 then # return [ frob * One( Indeterminate( GF(p) ) ), 1 ]; # elif p^d <= MAXSIZE_GF_INTERNAL then # z:= Z( p, d ); # one:= One( z ); # zero:= Zero( z ); # conwaypol:= ConwayPol( p, d ) * one; # x:= [ zero, one ]; # ConvertToVectorRepNC( conwaypol, p ); # ConvertToVectorRepNC( x, p ); # # # Note that `LogFFE' returns a nonzero value. # frob:= PowerModCoeffs( x, 2, LogFFE( frob, z ), conwaypol, d+1 ); # frob:= UnivariatePolynomialByCoefficients( FamilyObj( one ), # frob, 1 ); # elif IsCoeffsModConwayPolRep( frob ) then # frob:= UnivariatePolynomialByCoefficients( FamilyObj( Z(p) ), # frob![1], 1 ); # else # # This should never happen, since `FrobeniusCharacterValue' worked. # Info( InfoWarning, 1, # "no coefficients w.r.t. the Conway polynomial available" ); # return fail; # fi; # return [ frob, d ]; # end; ############################################################################## ## #F SizeOfFieldOfDefinition( ,

) ## ## If the coefficients of the Zumbroich basis representation of the ## difference $\alpha^{\ast p} - \alpha$ are divisible by $p$ ## then $\alpha$ is mapped to an element of the prime field under ## the reduction modulo any maximal ideal. ## (This covers the special cases that $\alpha$ is fixed under the ## automorphism $\ast p$ or that all coefficients of $\alpha$ ## are divisible by $p$.) ## ## Otherwise, I do not know a better way to compute the size than explicitly ## computing the reductions. ## InstallGlobalFunction( SizeOfFieldOfDefinition, function( val, p ) local values, entry; # The first argument may be a cyclotomic or a list of cyclotomics. if IsInt( val ) then return p; elif IsCyc( val ) then if DenominatorCyc( val ) mod p = 0 then return fail; fi; values:= [ val ]; elif IsList( val ) and IsCyclotomicCollection( val ) then values:= []; for entry in val do if not IsRat( entry ) then Add( values, entry ); elif DenominatorCyc( entry ) mod p = 0 then return fail; fi; od; else Error( " must be a cyclotomic or a list of cyclotomics" ); fi; if ForAll( values, x -> IsCycInt( ( GaloisCyc( x, p ) - x ) / p ) ) then return p; fi; values:= List( values, x -> FrobeniusCharacterValue( x, p ) ); if fail in values then return fail; fi; return p ^ DegreeFFE( values ); end ); ############################################################################# ## #M BrauerCharacterValue( ) ## ## Let $M$ be a matrix of order $n$, with entries in the finite field $F$, ## and suppose that $M$ is diagonalizable over the extension field $K$ with ## $p^d$ elements. ## ## It could in principle be computed by determining the diagonal form, ## identifying the entries in the diagonal with $(p^d -1)$-th complex roots ## of unity, ## and then summing up these roots. ## ## But one can do better. ## (This is the approach used by the C-{\MeatAxe}.) ## For each irreducible factor $f$ of $X^n - 1$ over $F$, the multiplicities ## of its roots over $K$ as eigenvalues of $M$ are equal, ## hence one needs to compute these multiplicities and the corresponding ## sums of roots of unity. ## The former means to solve an equation system over $F$, ## and the latter depends only on $n$ and $F$, but not on $M$; ## so one can use a database for speeding up the computations. ## This database is implemented by the global variable `ZEV_DATA' and the ## functions `ZevData' and `ZevDataValue'. ## InstallMethod( BrauerCharacterValue, "for a matrix", [ IsMatrix ], function( mat ) local n, # order of `mat' p, # characteristic of `mat' info, # list of pairs returned by `ZevData' value, # Brauer character value, result pair, # loop over `info' f, # polynomial part of `pair' nullity; # dimension of a nullspace n:= Order( mat ); # Handle the trivial cases first. if n = 1 then return Length( mat ); fi; p:= Characteristic( mat ); if n mod p = 0 then return fail; fi; # Get the complex values corresponding to the irreducible # factors of $X^n - 1$ over $F$. info:= ZevData( p^DegreeFFE( mat ), n ); # Compute the coefficients of the complex summands, # as quotients of nullities and degrees. value:= 0; for pair in info do f:= pair[1]; nullity:= Length( NullspaceMat( ValuePol( f, mat ) ) ); if nullity <> 0 then nullity:= nullity / ( Length( f ) - 1 ); Assert( 1, IsInt( nullity ), "degree of must divide " ); value:= value + nullity * pair[2]; fi; od; return value; end ); ############################################################################# ## #V ZEV_DATA ## InstallFlushableValue( ZEV_DATA, [ [], [] ] ); ############################################################################# ## #F ZevDataValue( , ) ## InstallGlobalFunction( ZevDataValue, function( q, n ) local F, dimext, extfieldsize, Ee, value, K, z, quot, R, f, y, fac, p, one, conw, conwlen, x, zpol, zpollen, zeta, zetalen, coeffs, l, power, powerlen, i, exp, res, reslen, j; # Compute the field $F$ of matrix entries and the smallest field $K # over which a matrix of order `n' is diagonalizable. F:= GF( q ); dimext:= DegreeOverPrimeField( F ) * OrderMod( q, n ); extfieldsize:= Characteristic( F ) ^ dimext; Ee:= E( n ); value:= []; if extfieldsize <= MAXSIZE_GF_INTERNAL then # The splitting field is supported in {\GAP}, # and the stored primitive root is given by the Conway polynomial. K:= GF( extfieldsize ); z:= PrimitiveRoot( K ); quot:= ( extfieldsize - 1 ) / n; R:= PolynomialRing( K ); for f in Factors( PolynomialRing( F ), Indeterminate(F)^n - 1 ) do y:= 0; for fac in Factors( R, f ) do # The factors are all linear, i.e., of the form $X - \alpha$. # Sum up the lifts of the numbers $\alpha$. y:= y + Ee^ ( LogFFE( -CoefficientsOfLaurentPolynomial( fac )[1][1], z ) / quot ); od; Add( value, [ CoefficientsOfLaurentPolynomial( f )[1], y ] ); od; else # The splitting field is not available in {\GAP}, # use computations with polynomials. p:= Characteristic( F ); z:= PrimitiveRoot( F ); one:= One( F ); conw:= ConwayPol( p, dimext ) * one; conwlen:= dimext + 1; x:= [ Zero( F ), one ]; # polynomial corresponding to the primitive root of `F' zpol:= PowerModCoeffs( x, 2, ( extfieldsize-1 ) / ( Size(F)-1 ), conw, conwlen ); zpollen:= Length( zpol ); # polynomial corresponding to a primitive `n'-th root $\zeta$ zeta:= PowerModCoeffs( x, 2, ( extfieldsize-1 ) / n, conw, conwlen ); zetalen:= Length( zeta ); for f in Factors( PolynomialRing( F ), Indeterminate(F)^n - 1 ) do y:= 0; coeffs:= CoefficientsOfUnivariatePolynomial( f ); l:= Length( coeffs ); power:= [ one ]; powerlen:= 1; for i in [ 0 .. n-1 ] do # Compute $\sum_{j=0}^{l-1} c_j \zeta^{i j}$, # where `f' has the form $\sum_{j=0}^{l-1} c_j X^j$. exp:= LogFFE( coeffs[l], z ); if exp = 0 then res:= [ one ]; else res:= PowerModCoeffs( zpol, zpollen, exp, conw, conwlen ); fi; reslen:= Length( res ); for j in [ 1 .. l-1 ] do reslen:= MultCoeffs( res, res, reslen, power, powerlen ); if not IsZero( coeffs[l-j] ) then exp:= LogFFE( coeffs[l-j], z ); if exp = 0 then res:= res + [ one ]; else res:= res + PowerModCoeffs( zpol, zpollen, exp, conw, conwlen ); fi; fi; reslen:= ReduceCoeffs( res, Length( res ), conw, conwlen ); ShrinkRowVector( res ); # needed? reslen:= Length( res ); # needed? od; # If $\zeta^i$ is a root of `f' then take the corresponding # complex root of unity. if reslen = 0 then y:= y + Ee^i; fi; powerlen:= MultCoeffs( power, power, powerlen, zeta, zetalen ); powerlen:= ReduceCoeffs( power, powerlen, conw, conwlen ); od; Add( value, [ coeffs, y ] ); od; fi; return value; end ); ############################################################################# ## #F ZevData( , ) #F ZevData( , , ) ## InstallGlobalFunction( ZevData, function( arg ) local q, n, pos, pos2; q:= arg[1]; n:= arg[2]; pos:= Position( ZEV_DATA[1], q ); if pos = fail then Add( ZEV_DATA[1], q ); Add( ZEV_DATA[2], [ [], [] ] ); pos:= Length( ZEV_DATA[1] ); fi; pos2:= Position( ZEV_DATA[2][ pos ][1], n ); if pos2 = fail then Add( ZEV_DATA[2][ pos ][1], n ); pos2:= Length( ZEV_DATA[2][ pos ][1] ); fi; if Length( arg ) = 3 then # Store the third argument at this position. if IsBound( ZEV_DATA[2][ pos ][2][ pos2 ] ) then if ZEV_DATA[2][ pos ][2][ pos2 ] = arg[3] then Info( InfoWarning, 1, "ZevData( ", q, ", ", n, " ) was already stored" ); else Error( "incompatible ZevData( ", q, ", ", n, " )" ); fi; fi; ZEV_DATA[2][ pos ][2][ pos2 ]:= Immutable( arg[3] ); return arg[3]; else # Get the entry. if not IsBound( ZEV_DATA[2][ pos ][2][ pos2 ] ) then ZEV_DATA[2][ pos ][2][ pos2 ]:= ZevDataValue( q, n ); fi; return ZEV_DATA[2][ pos ][2][ pos2 ]; fi; end ); ############################################################################## ## #F RealizableBrauerCharacters( , ) ## InstallGlobalFunction( RealizableBrauerCharacters, function( matrix, q ) local result, factors, p, m, done, row, d, g, qq, image, newrow, i; result:= []; factors:= Factors( q ); p:= factors[1]; m:= Length( factors ); done:= []; for row in matrix do if not row in done then d:= SizeOfFieldOfDefinition( row, p ); if d = fail then return fail; fi; d:= Length( Factors( d ) ); g:= Gcd( d, m ); qq:= p^g; image:= row; newrow:= row; Add( done, row ); for i in [ 1 .. d/g-1 ] do image:= GaloisCyc( image, qq ); newrow:= newrow + image; Add( done, image ); od; if not newrow in result then Add( result, newrow ); fi; fi; od; return result; end ); ############################################################################# ## ## 13. Domains Generated by Class Functions ## ############################################################################# ## #M GroupWithGenerators( [, ] ) ## InstallOtherMethod( GroupWithGenerators, "for a homogeneous list (of class functions)", [ IsHomogeneousList ], function( gens ) local filter, G; # Check that the list consists of invertible class functions. if IsEmpty( gens ) or not ForAll( gens, IsClassFunction ) then TryNextMethod(); elif ForAny( gens, psi -> Inverse( psi ) = fail ) then Error( "class functions in must be invertible" ); #T move to `IsGeneratorsOfGroup' fi; filter:= IsGroup and IsAttributeStoringRep; if IsFinite( gens ) then filter:= filter and IsFinitelyGeneratedGroup; fi; # Construct the group. G:= Objectify( NewType( FamilyObj( gens ), filter ), rec() ); SetGeneratorsOfMagmaWithInverses( G, AsList( gens ) ); return G; end ); InstallOtherMethod( GroupWithGenerators, "for list (of class functions) and class function", IsCollsElms, [ IsHomogeneousList, IsClassFunction ], function( gens, id ) local filter, G; # Check that the class functions are invertible. if not ForAll( gens, IsClassFunction ) then TryNextMethod(); elif ForAny( gens, psi -> Inverse( psi ) = fail ) then Error( "class functions in must be invertible" ); #T move to `IsGeneratorsOfGroup' elif not IsOne( id ) then Error( " must be an identity" ); fi; filter:= IsGroup and IsAttributeStoringRep; if IsFinite( gens ) then filter:= filter and IsFinitelyGeneratedGroup; fi; # Construct the group. G:= Objectify( NewType( FamilyObj( gens ), filter), rec() ); SetGeneratorsOfMagmaWithInverses( G, AsList( gens ) ); SetOne( G, id ); return G; end ); InstallOtherMethod( GroupWithGenerators, "for empty list and trivial character", [ IsList and IsEmpty, IsClassFunction ], function( empty, id ) local G; if not IsOne( id ) then Error( " must be an identity" ); fi; # Construct the group. G:= Objectify( NewType( CollectionsFamily( FamilyObj( id ) ), IsGroup and IsAttributeStoringRep and IsFinitelyGeneratedGroup and IsTrivial ), rec() ); SetGeneratorsOfMagmaWithInverses( G, empty ); SetOne( G, id ); return G; end ); ############################################################################# ## ## 5. vector spaces of class functions ## ## Free left modules and algebras of class functions are handled by nice ## bases, ## for admitting the default procedure of closure under multiplication. ## In order to apply `NiceVector' and `UglyVector', algebras of class ## functions are in the filter `IsClassFunctionsSpace'. ## InstallHandlingByNiceBasis( "IsClassFunctionsSpace", rec( detect:= function( R, gens, V, zero ) local tbl; if not ForAll( gens, IsClassFunction ) then return false; elif zero = false then tbl:= UnderlyingCharacterTable( gens[1] ); elif not IsClassFunction( zero ) then return false; else tbl:= UnderlyingCharacterTable( zero ); fi; if ForAny( gens, chi -> UnderlyingCharacterTable( chi ) <> tbl ) then return false; fi; return true; end, NiceFreeLeftModuleInfo := function( V ) return UnderlyingCharacterTable( Zero( V ) ); end, NiceVector := function( V, v ) if UnderlyingCharacterTable( v ) = NiceFreeLeftModuleInfo( V ) then return ValuesOfClassFunction( v ); else return fail; fi; end, UglyVector := function( V, r ) return ClassFunction( NiceFreeLeftModuleInfo( V ), r ); end ) ); ############################################################################# ## #M ScalarProduct( , , ) . . . . for module of class functions ## ## Left modules of class functions carry the usual bilinear form. ## InstallOtherMethod( ScalarProduct, "for left module of class functions, and two class functions", IsCollsElmsElms, [ IsFreeLeftModule, IsClassFunction, IsClassFunction ], function( V, x1, x2 ) local tbl; tbl:= UnderlyingCharacterTable( x1 ); if tbl = UnderlyingCharacterTable( x2 ) then return ScalarProduct( tbl, x1, x2 ); else TryNextMethod(); fi; end ); ############################################################################# ## #M ScalarProduct( , , ) . . for module of class funs. ## ## Left modules of class functions carry the usual bilinear form. ## InstallOtherMethod( ScalarProduct, "for module of class functions, and two values lists", [ IsFreeLeftModule and IsClassFunctionsSpace, IsHomogeneousList, IsHomogeneousList ], function( V, x1, x2 ) return ScalarProduct( NiceFreeLeftModuleInfo( V ), x1, x2 ); end ); ############################################################################# ## ## 14. Auxiliary operations ## ############################################################################## ## #F OrbitChar( , ) ## InstallGlobalFunction( OrbitChar, function( chi, linear ) local classes, # range of positions in `chi' nofcyc, # describes the conductor of values of `chi' gens, # generators of Galois automorphism group orb, # the orbit, result gen, # loop over `gens' image; # one image of `chi' under operation classes:= [ 1 .. Length( chi ) ]; nofcyc:= Conductor( chi ); # Apply Galois automorphisms if necessary. orb:= [ chi ]; if 1 < nofcyc then gens:= Flat( GeneratorsPrimeResidues( nofcyc ).generators ); for chi in orb do for gen in gens do image:= List( chi, x -> GaloisCyc( x, gen ) ); if not image in orb then Add( orb, image ); fi; od; od; fi; # Apply multiplication with linear characters. for chi in orb do for gen in linear do image:= List( classes, x -> gen[x] * chi[x] ); if not image in orb then Add( orb, image ); fi; od; od; # Return the orbit. return orb; end ); ############################################################################## ## #F OrbitsCharacters( ) ## InstallGlobalFunction( OrbitsCharacters, function( irr ) local irrvals, # list of value lists oldirrvals, # store original succession tbl, # underlying character table linear, # linear characters of `tbl' orbits, # list of orbits, result indices, # from 1 to number of conjugacy classes of `tbl' orb, # one orbit gens, # generators of the acting group chi, # one irreducible character gen, # one generator of the acting group image, # image of a character i, # loop over one orbit pos; # position of value list in `oldirrvals' orbits:= []; if not IsEmpty( irr ) then if IsClassFunction( irr[1] ) then # Replace group characters by their value lists. # Store the succession in the original list. irrvals:= List( irr, ValuesOfClassFunction ); oldirrvals:= ShallowCopy( irrvals ); irrvals:= Set( irrvals ); else irrvals:= Set( irr ); fi; indices:= [ 1 .. Length( irrvals[1] ) ]; # Compute the orbit of linear characters if there are any. linear:= Filtered( irrvals, x -> x[1] = 1 ); if 0 < Length( linear ) then # The linear characters form an orbit. # We remove them from the other characters, # and remove the trivial character from `linear'. orb:= ShallowCopy( linear ); SubtractSet( irrvals, linear ); RemoveSet( linear, List( linear[1], x -> 1 ) ); # Make `linear' closed under Galois automorphisms. gens:= Flat( GeneratorsPrimeResidues( Conductor( Flat( linear ) ) ).generators ); for chi in orb do for gen in gens do image:= List( chi, x -> GaloisCyc( x, gen ) ); if not image in orb then Add( orb, image ); fi; od; od; # Make `linear' closed under multiplication with linear characters. for chi in orb do for gen in linear do image:= List( indices, x -> gen[x] * chi[x] ); if not image in orb then Add( orb, image ); fi; od; od; orbits[1]:= orb; fi; # Compute the other orbits. while Length( irrvals ) > 0 do orb:= OrbitChar( irrvals[1], linear ); Add( orbits, orb ); SubtractSet( irrvals, orb ); od; # Replace the value lists by the group characters # if the input was a list of characters. # Be careful not to copy characters if not necessary. if IsCharacter( irr[1] ) then tbl:= UnderlyingCharacterTable( irr[1] ); for orb in orbits do for i in [ 1 .. Length( orb ) ] do pos:= Position( oldirrvals, orb[i] ); if pos = fail then orb[i]:= Character( tbl, orb[i] ); else orb[i]:= irr[ pos ]; fi; od; od; fi; fi; return orbits; end ); ############################################################################## ## #F OrbitRepresentativesCharacters( ) ## InstallGlobalFunction( OrbitRepresentativesCharacters, function( irr ) local irrvals, # list of value lists oldirrvals, # store original succession chi, # loop over `irrvals' linear, # linear characters in `irr' nonlin, # nonlinear characters in `irr' repres, # list of representatives, result orb; # one orbit repres:= []; if not IsEmpty( irr ) then if IsCharacter( irr[1] ) then # Replace group characters by their value lists. # Store the succession in the original list. irrvals:= List( irr, ValuesOfClassFunction ); oldirrvals:= ShallowCopy( irrvals ); irrvals:= Set( irrvals ); else irrvals:= Set( irr ); fi; # Get the linear characters. linear := []; nonlin := []; for chi in irrvals do if chi[1] = 1 then Add( linear, chi ); else Add( nonlin, chi ); fi; od; if Length( linear ) > 0 then repres[1]:= linear[1]; fi; # Compute orbits and remove them until the set is empty. while Length( nonlin ) > 0 do Add( repres, nonlin[1] ); orb:= OrbitChar( nonlin[1], linear ); SubtractSet( nonlin, orb ); od; # Replace the value lists by the group characters # if the input was a list of characters. # Do not copy characters! if IsCharacter( irr[1] ) then repres:= List( repres, x -> irr[ Position( oldirrvals, x ) ] ); fi; fi; # Return the representatives. return repres; end ); ############################################################################# ## #F CharacterTableQuaternionic( <4n> ) ## InstallGlobalFunction( CharacterTableQuaternionic, function( 4n ) local quaternionic; if 4n mod 4 <> 0 then Error( "argument must be a multiple of 4" ); elif 4n = 4 then quaternionic:= CharacterTable( "Cyclic", 4 ); else quaternionic:= CharacterTableIsoclinic( CharacterTable( "Dihedral", 4n ), [ 1 .. 4n / 4 + 1 ] ); fi; ResetFilterObj( quaternionic, HasIdentifier ); SetIdentifier( quaternionic, Concatenation( "Q", String( 4n ) ) ); return quaternionic; end ); ############################################################################# ## #F CollapsedMat( , ) ## InstallGlobalFunction( CollapsedMat, function( mat, maps ) local i, j, k, nontrivblock, nontrivblocks, row, newblocks, values, blocks, pos, minima, fusion; # Compute successivly the partition of column families defined by # the rows already processed. nontrivblocks:= [ [ 1 .. Length( mat[1] ) ] ]; for row in Concatenation( maps, mat ) do newblocks:= []; for nontrivblock in nontrivblocks do values:= []; blocks:= []; for k in nontrivblock do pos:= 1; while pos <= Length( values ) and values[ pos ] <> row[k] do pos:= pos + 1; od; if Length( values ) < pos then values[ pos ]:= row[k]; blocks[ pos ]:= [ k ]; else AddSet( blocks[ pos ], k ); fi; od; for k in blocks do if 1 < Length( k ) then Add( newblocks, k ); fi; od; od; nontrivblocks:= newblocks; od; minima:= List( nontrivblocks, Minimum ); nontrivblocks:= Permuted( nontrivblocks, Sortex( minima ) ); minima:= Concatenation( [ 0 ], minima ); fusion:= []; pos:= 1; for i in [ 1 .. Length( minima ) - 1 ] do for j in [ minima[i] + 1 .. minima[i+1] - 1 ] do if not IsBound( fusion[j] ) then fusion[j]:= pos; pos:= pos + 1; fi; od; for j in nontrivblocks[i] do fusion[j]:= pos; od; pos:= pos + 1; od; for i in [ minima[ Length( minima ) ] + 1 .. Length( mat[1] ) ] do if not IsBound( fusion[i] ) then fusion[i]:= pos; pos:= pos + 1; fi; od; values:= ProjectionMap( fusion ); return rec( mat:= List( mat, x -> x{ values } ), #T do I really need the component 'mat'? fusion:= fusion ); end ); ############################################################################# ## #E gap-4r6p5/lib/ctblgrp.gd0000644000175000017500000004066412172557252013672 0ustar billbill############################################################################# ## #W ctblgrp.gd GAP library Alexander Hulpke ## ## #Y Copyright (C) 1997 #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the declarations for the Dixon-Schneider algorithm ## ############################################################################# ## ## <#GAPDoc Label="[1]{ctblgrp}"> ## Dixon-Schneider algorithm ## The &GAP; library implementation of the Dixon-Schneider algorithm ## first computes the linear characters, using the commutator factor group. ## If irreducible characters are missing afterwards, ## they are computed using the techniques described in , ## and . ##

## Called with a group G, the function ## returns a character ## table object that stores already information such as class lengths, ## but not the irreducible characters. ## The routines that compute the irreducibles may use the information that ## is already contained in this table object. ## In particular the ordering of classes in the computed characters ## coincides with the ordering of classes in the character table of G ## (see ). ## Thus it is possible to combine computations using the group ## with character theoretic computations ## (see  ## for details), ## for example one can enter known characters. ## Note that the user is responsible for the correctness of the characters. ## (There is little use in providing the trivial character to the routine.) ##

## The computation of irreducible characters from the group needs to ## identify the classes of group elements very often, ## so it can be helpful to store a class list of all group elements. ## Since this is obviously limited by the group order, ## it is controlled by the global function . ##

## The routines compute in a prime field of size p, ## such that the exponent of the group divides (p-1) and such that ## 2 \sqrt{{|G|}} < p. ## Currently prime fields of size smaller than 65\,536 are handled more ## efficiently than larger prime fields, ## so the runtime of the character calculation depends on how large the ## chosen prime is. ##

## The routine stores a Dixon record (see ) ## in the group that helps routines that identify classes, ## for example , ## to work much faster. ## Note that interrupting Dixon-Schneider calculations will prevent &GAP; ## from cleaning up the Dixon record; ## when the computation by is complete, ## the possibly large record is shrunk to an acceptable size. ## <#/GAPDoc> ## ############################################################################# ## #F IsDxLargeGroup( ) ## ## <#GAPDoc Label="IsDxLargeGroup"> ## ## ## ## ## returns true if the order of the group G is smaller than ## the current value of the global variable DXLARGEGROUPORDER, ## and false otherwise. ## In Dixon-Schneider calculations, for small groups in the above sense a ## class map is stored, whereas for large groups, ## each occurring element is identified individually. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "IsDxLargeGroup" ); ############################################################################# ## #F DxModularValuePol #F DxDegreeCandidates ## ## ## ## ## ## ## ## ## DeclareGlobalFunction("DxModularValuePol"); DeclareGlobalFunction("DxDegreeCandidates"); ############################################################################# ## #A DixonRecord( ) ## ## <#GAPDoc Label="DixonRecord"> ## ## ## ## ## The of a group contains information used by the ## routines to compute the irreducible characters and related information ## via the Dixon-Schneider algorithm such as class arrangement and character ## spaces split obtained so far. ## Usually this record is passed as argument to all subfunctions to avoid a ## long argument list. ## It has a component conjugacyClasses which contains the classes of ## G ordered as the algorithm needs them. ## ## ## <#/GAPDoc> ## DeclareAttribute("DixonRecord",IsGroup,"mutable"); ############################################################################# ## #O DxPreparation(,) ## ## ## ## ## ## Creates enttries in the dixon record D of the group G ## which are representation dependent, ## like functions to identify the class of elements. ## ## ## DeclareOperation("DxPreparation",[IsGroup,IsRecord]); ############################################################################# ## #F ClassComparison(,) . . . . . . . . . . . . compare classes c and d ## ## ## ## ## ## Comparison function for conjugacy classes, ## used by . ## Comparison is based first on the size of the class and then on the ## order of the representatives. ## Thus the class containing the identity element is in the first position, ## as required. Since sorting is primary by the class sizes,smaller ## classes are in earlier positions, making the active columns those to ## smaller classes, thus reducing the work for calculating class matrices. ## Additionally, galois conjugated classes are kept together, thus increasing ## the chance,that with one columns of them active to be several active, ## again reducing computation time. ## ## ## DeclareGlobalFunction( "ClassComparison"); ############################################################################# ## #F DxIncludeIrreducibles( , [, ] ) ## ## <#GAPDoc Label="DxIncludeIrreducibles"> ## ## ## ## ## This function takes a list of irreducible characters new, ## each given as a list of values (corresponding to the class arrangement in ## D), and adds these to a partial computed list of irreducibles as ## maintained by the Dixon record D. ## This permits one to add characters in interactive use obtained from other ## sources and to continue the Dixon-Schneider calculation afterwards. ## If the optional argument newmod is given, it must be a ## list of reduced characters, corresponding to new. ## (Otherwise the function has to reduce the characters itself.) ##

## The function closes the new characters under the action of Galois ## automorphisms and tensor products with linear characters. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "DxIncludeIrreducibles" ); ############################################################################# ## #F SplitCharacters( , ) split characters according to the spaces ## ## <#GAPDoc Label="SplitCharacters"> ## ## ## ## ## This routine decomposes the characters given in list according to ## the character spaces found up to this point. By applying this routine to ## tensor products etc., it may result in characters with smaller norm, ## even irreducible ones. Since the recalculation of characters is only ## possible if the degree is small enough, the splitting process is ## applied only to characters of sufficiently small degree. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "SplitCharacters" ); ############################################################################# ## #F OrbitSplit() . . . . . . . . . . . . . . try to split two-orbit-spaces ## ## ## ## ## ## Tries to split two-orbit character spaces. ## ## ## DeclareGlobalFunction("OrbitSplit"); ############################################################################# ## #F DxSplitDegree(,,) local ## ## ## ## ## ## estimates the number of parts obtained when splitting the character space ## space with matrix number r. ## This estimate is obtained using charcter morphisms. ## ## ## DeclareGlobalFunction("DxSplitDegree"); ############################################################################# ## #F BestSplittingMatrix() ## ## <#GAPDoc Label="BestSplittingMatrix"> ## ## ## ## ## returns the number of the class sum matrix that is assumed to yield the ## best (cost/earning ration) split. This matrix then will be the next one ## computed and used. ##

## The global option maxclasslen ## (defaulting to ) is recognized ## by : ## Only classes whose length is limited by the value of this option will be ## considered for splitting. If no usable class remains, ## fail is returned. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("BestSplittingMatrix"); ############################################################################# ## #F DixonInit( ) . . . . . . . . . . initialize Dixon-Schneider algorithm ## ## <#GAPDoc Label="DixonInit"> ## ## ## ## ## This function does all the initializations for the Dixon-Schneider ## algorithm. This includes calculation of conjugacy classes, power maps, ## linear characters and character morphisms. ## It returns a record (see  and ## Section ) ## that can be used when calculating the irreducible characters of G ## interactively. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "DixonInit" ); ############################################################################# ## #F DixonSplit( ) . calculate matrix, split spaces and obtain characters ## ## <#GAPDoc Label="DixonSplit"> ## ## ## ## ## This function performs one splitting step in the Dixon-Schneider ## algorithm. It selects a class, computes the (partial) class sum matrix, ## uses it to split character spaces and stores all the irreducible ## characters obtained that way. ##

## The class to use for splitting is chosen via ## and the options described for this ## function apply here. ##

## returns true if a split was performed, ## and fail otherwise. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "DixonSplit" ); DeclareGlobalFunction( "SplitStep" ); ############################################################################# ## #F DixontinI( ) . . . . . . . . . . . . . . . . reverse initialisation ## ## <#GAPDoc Label="DixontinI"> ## ## ## ## ## This function ends a Dixon-Schneider calculation. ## It sorts the characters according to the degree and ## unbinds components in the Dixon record that are not of use any longer. ## It returns a list of irreducible characters. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "DixontinI" ); ############################################################################# ## #A IrrDixonSchneider( ) . . . . irreducible characters of finite group G ## ## <#GAPDoc Label="IrrDixonSchneider"> ## ## ## ## ## computes the irreducible characters of the finite group G, ## using the Dixon-Schneider method ## (see ). ## It calls and , ## ## and finally returns the list returned by . ## See also the sections ## and ## . ## ## ## <#/GAPDoc> ## DeclareAttribute( "IrrDixonSchneider", IsGroup ); DeclareOperation( "IrrDixonSchneider", [ IsGroup, IsRecord ] ); ############################################################################# ## #F IrreducibleRepresentationsDixon( [,] ) ## ## <#GAPDoc Label="IrreducibleRepresentationsDixon"> ## ## ## ## ## Called with one argument, a group G, ## ## computes (representatives of) all irreducible complex representations for ## the finite group G, using the method of , ## which computes the character table and computes the representation ## as constituent of an induced monomial representation of a subgroup. ##

## This method can be quite expensive for larger groups, for example it ## might involve calculation of the subgroup lattice of G. ##

## A character chi of G can be given as the second argument, ## in this case only a representation affording chi is returned. ##

## The second argument can also be a list of characters of G, ## in this case only representations for characters in this list are ## computed. ##

## Note that this method might fail if for an irreducible representation ## there is no subgroup in which its reduction has a linear constituent ## with multiplicity one. ##

## a5:= AlternatingGroup( 5 ); ## Alt( [ 1 .. 5 ] ) ## gap> char:= First( Irr( a5 ), x -> x[1] = 4 ); ## Character( CharacterTable( Alt( [ 1 .. 5 ] ) ), [ 4, 0, 1, -1, -1 ] ) ## gap> hom:=IrreducibleRepresentationsDixon( a5, char );; ## gap> Order( a5.1*a5.2 ) = Order( Image( hom, a5.1 )*Image( hom, a5.2 ) ); ## true ## gap> reps:= List( ConjugacyClasses( a5 ), Representative );; ## gap> List( reps, g -> TraceMat( Image( hom, g ) ) ); ## [ 4, 0, 1, -1, -1 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("IrreducibleRepresentationsDixon"); ############################################################################# ## #F RepresentationsPermutationIrreducibleCharacters(,,) ## ## ## ## ## ## Given a group G and a list of characters and representations of ## G, this function returns a permutation of the representations ## (via ), ## that will ensure characters and representations are ordered compatibly. ## ## ## DeclareGlobalFunction("RepresentationsPermutationIrreducibleCharacters"); # the following function is in this file only for dependency reasons. ############################################################################# ## #F NthRootsInGroup( , , ) ## ## <#GAPDoc Label="NthRootsInGroup"> ## ## ## ## ## Let e be an element in the group G. ## This function returns a list of all those elements in G ## whose n-th power is e. ##

## NthRootsInGroup(g,(1,2)(3,4),2); ## [ (1,3,2,4), (1,4,2,3) ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("NthRootsInGroup"); ############################################################################# ## #E gap-4r6p5/lib/word.gi0000644000175000017500000001564612172557254013221 0ustar billbill############################################################################# ## #W word.gi GAP library Thomas Breuer ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## ## This file contains generic methods for nonassociative words. ## ############################################################################# ## #M \=( , ) . . . . . . . . . . . . . . . . . . . . . . . for words ## InstallMethod( \=, "for two words", IsIdenticalObj, [ IsWord, IsWord ], 0, function( x, y ) return ExtRepOfObj( x ) = ExtRepOfObj( y ); end ); ############################################################################# ## #M \<( , ) . . . . . . . . . . . . . . . . . . . . . . . for words ## ## Words are ordered by the lexicographical order of their external ## representation. ## InstallMethod( \<, "nonassoc words", IsIdenticalObj, [ IsWord, IsWord ], 0, function( x, y ) local n; # thsi method does not work for assoc words! if IsAssocWord(x) and IsAssocWord(y) then TryNextMethod(); fi; x:= ExtRepOfObj( x ); y:= ExtRepOfObj( y ); if IsInt( x ) then return IsList( y ) or x < y; elif IsInt( y ) then return false; fi; for n in [ 1 .. Minimum( Length( x ), Length( y ) ) ] do if x[n] < y[n] then return true; elif y[n] < x[n] then return false; fi; od; return Length( x ) < Length( y ); end ); ############################################################################# ## #M \*( , ) . . . . . . . . . . . . . . . for nonassociative words ## ## Multiplication of nonassociative words is done by putting the two factors ## into a bracket. ## InstallMethod( \*, "for two nonassoc. words", IsIdenticalObj, [ IsNonassocWord, IsNonassocWord ], 0, function( x, y ) local xx, # external representation of `x' yy; # external representation of `y' # Treat the special cases that one argument is trivial. xx:= ExtRepOfObj( x ); if xx = 0 then return y; fi; yy:= ExtRepOfObj( y ); if yy = 0 then return x; fi; # Form the product. return ObjByExtRep( FamilyObj( x ), [ xx, yy ] ); end ); ############################################################################# ## #M Length( ) . . . . . . . . . . . . . . . . . . . for a nonassoc. word ## InstallOtherMethod( Length, "for a nonassoc. word", true, [ IsNonassocWord ], 0, function( w ) local len; len:= function( obj ) if obj = 0 then return 0; elif IsInt( obj ) then return 1; else return len( obj[1] ) + len( obj[2] ); fi; end; return len( ExtRepOfObj( w ) ); end ); ############################################################################# ## #M MappedWord( , , ) ## InstallMethod( MappedWord, "for a nonassoc. word, a homogeneous list, and a list", IsElmsCollsX, [ IsNonassocWord, IsNonassocWordCollection, IsList ], 0, function( x, gens1, gens2 ) local mapped; gens1:= List( gens1, ExtRepOfObj ); mapped:= function( word ) if word = 0 then return One( gens2[1] ); elif IsInt( word ) then return gens2[ Position( gens1, word ) ]; else return mapped( word[1] ) * mapped( word[2] ); fi; end; return mapped( ExtRepOfObj( x ) ); end ); ############################################################################# ## #M MappedWord( , , ) ## InstallOtherMethod( MappedWord, "empty generators list", true, [ IsObject, IsEmpty, IsList ], 0, function( x, gens1, gens2 ) return x; end); ############################################################################# ## #R IsBracketRep( ) ## ## This representation is equal to the external representation. ## DeclareRepresentation( "IsBracketRep", IsPositionalObjectRep, [] ); ############################################################################# ## #M Print( ) . . . . . . . . . . . . . . . . . . . for a nonassoc. word ## InstallMethod( PrintObj, "for a nonassociative word", true, [ IsNonassocWord ], 0, function( elm ) local names, print; names:= FamilyObj( elm )!.names; print:= function( expr ) if expr = 0 then Print( "" ); elif IsInt( expr ) then Print( names[ expr ] ); else Print( "(" ); print( expr[1] ); Print( "*" ); print( expr[2] ); Print( ")" ); fi; end; print( ExtRepOfObj( elm ) ); end ); ############################################################################# ## #M String( ) . . . . . . . . . . . . . . . . . . . for a nonassoc. word ## InstallMethod( String, "for a nonassociative word", true, [ IsNonassocWord ], 0, function( elm ) local names, string; names:= FamilyObj( elm )!.names; string:= function( expr ) if expr = 0 then return "" ; elif IsInt( expr ) then return names[ expr ]; else return Concatenation( "(", string( expr[1] ), "*", string( expr[2] ), ")" ); fi; end; elm:= string( ExtRepOfObj( elm ) ); ConvertToStringRep( elm ); return elm; end ); ############################################################################# ## #M ObjByExtRep( , ) . . . . . . for a nonassociative word family ## ## We have to distinguish the cases that the second argument is an integer ## (external representation of generators) and that it is a nested list of ## integers. ## InstallMethod( ObjByExtRep, "for a family of nonassociative words, and an integer", true, [ IsNonassocWordFamily, IsInt ], 0, function( F, pos ) return Objectify( F!.defaultType, [ pos ] ); end ); InstallMethod( ObjByExtRep, "for a family of nonassociative words, and a list", true, [ IsNonassocWordFamily, IsList ], 0, function( F, list ) return Objectify( F!.defaultType, [ list ] ); end ); ############################################################################# ## #M ExtRepOfObj( ) . . . . . . . . . . . . . . for a nonassociative word ## InstallMethod( ExtRepOfObj, "for a nonassoc. word", true, [ IsNonassocWord and IsBracketRep ], 0, elm -> elm![1] ); ############################################################################# ## #M OneOp( ) . . . . . . . . . . . . . . . . for a nonass. word-with-one ## InstallMethod( OneOp, "for a nonassoc. word-with-one", true, [ IsNonassocWordWithOne ], 0, x -> ObjByExtRep( FamilyObj( x ), 0 ) ); ############################################################################# ## #E ## gap-4r6p5/lib/grppcaut.gi0000644000175000017500000011150712172557252014062 0ustar billbill############################################################################# ## #W grppcaut.gi GAP library Bettina Eick ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ############################################################################# ## #F CheckAuto( auto ) ## CheckAuto := function( auto ) local new,mapi; mapi:=MappingGeneratorsImages(auto); new := GroupGeneralMappingByImagesNC( Source(auto), Range(auto), mapi[1], mapi[2] ); if Source( auto ) <> Range( auto ) then Print("source and range differ \n"); return false; fi; if not IsGroupHomomorphism( new ) then Print("no group hom \n"); return false; fi; if not IsBijective( new ) then Print("no bijection \n"); return false; fi; return true; end; ############################################################################# ## #F InducedActionFactor( mats, fac, low ) # this function is used only in a package. ## InducedActionFactor := function( mats, fac, low ) local sml, upp, d, i, b, t; sml := List( mats, x -> [] ); upp := Concatenation( fac, low ); d := Length( fac ); for i in [1..Length(mats)] do for b in fac do t := SolutionMat( upp, b*mats[i] ){[1..d]}; Add( sml[i], t ); od; od; return sml; end; VectorStabilizerByFactors:=function(group,gens,mats,shadows,vec) local PrunedBasis, f, lim, mo, dim, bas, newbas, dims, q, bp, ind, affine, acts, nv, stb, idx, idxh, incstb, incperm, notinc, free, freegens, stabp, stabm, dict, orb, tp, tm, p, img, sch, incpermstop, sz, sel, nbas, offset, i; PrunedBasis:=function(p) local b,q,i; # prune too small factors b:=[p[1]]; q:=0; for i in [2..Length(p)] do if i=Length(p) or Length(p[i+1])-q>lim then Add(b,p[i]); q:=Length(p[i]); fi; od; return b; end; f:=DefaultScalarDomainOfMatrixList(mats); lim:=LogInt(1000,Size(f)); lim:=2; mo:=GModuleByMats(mats,f); dim:=mo.dimension; bas:=PrunedBasis(MTX.BasesCompositionSeries(mo)); # form new basis of space newbas:=ShallowCopy(bas[2]); dims:=[0,Length(newbas)]; for i in [3..Length(bas)] do q:=BaseSteinitzVectors(bas[i],newbas); Append(newbas,q.factorspace); Add(dims,Length(newbas)); od; #base change newbas is matrix new -> old q:=newbas^-1; mats:=List(mats,i->newbas*i*q); #bas:=List(bas{[2..Length(bas)]},i->i*q); #bas:=Concatenation([[]],bas); vec:=vec*q; bp:=Length(dims)-1; while bp>=1 do ind:=[dims[bp]+1..dims[bp+1]]; q:=[dims[bp+1]+1..dim]; if bp+1=Length(dims) then affine:=false; ind:=[dims[bp]+1..dim]; else affine:=List(mats,i->vec{q}*(i{q}{ind})); fi; Info(InfoMatOrb,2,"Acting dimension ",ind); acts:=List(mats,x->ImmutableMatrix(f,x{ind}{ind})); nv:=vec{ind}; if (affine=false and ForAny([1..Length(acts)],i->nv*acts[i]<>nv)) or (affine<>false and ForAny([1..Length(acts)],i->nv*acts[i]+affine[i]<>nv)) then # orbit/stabilizer algorithm. We need to carry (pre)images through #os:=OrbitStabilizer(group,nv,hocos,ind[2].generators,OnRight); stb:=TrivialSubgroup(group); idx:=Size(group);idxh:=idx/Factors(idx)[1]; incstb:=true; incperm:=true; notinc:=0; free:=FreeGroup(Length(gens)); freegens:=GeneratorsOfGroup(free); stabp:=[]; stabm:=[]; dict:=NewDictionary(nv,true,f^Length(nv)); orb:=[nv]; AddDictionary(dict,nv,1); tp:=[One(group)]; tm:=[One(free)]; p:=1; while incstb and p<=Length(orb) do for i in [1..Length(gens)] do if affine=false then img:=orb[p]*acts[i]; else img:=orb[p]*acts[i]+affine[i]; fi; q:=LookupDictionary(dict,img); if q=fail then Add(orb,img); if incstb and idxhfalse and not sch in stb then #Print("new schreiergen",Length(orb),"\n"); stb:=ClosureSubgroupNC(stb,sch); idx:=Size(group)/Size(stb);idxh:=idx/Factors(idx)[1]; if idxhidxh and notinc>10000 then Info(InfoMatOrb,3, Length(orb), " -- not incrementing perms again:",Size(group)/Size(stb)); incperm:=false; incpermstop:=p; fi; #Print("old schreiergen",Length(orb),"\n"); fi; fi; od; p:=p+1; od; #sz:=Maximum(Difference(DivisorsInt(sz),[sz])); if Length(orb)<=idxh then Info(InfoWarning,1,"too small stabilizer"); p:=incpermstop; sz:=Size(group)/Length(orb); while Size(stb)MappedWord(i,freegens,mats)); shadows:=List(stabm,i->MappedWord(i,freegens,shadows)); if AssertionLevel()>0 then ind:=[dims[bp]+1..dim]; acts:=List(mats,x->ImmutableMatrix(f,x{ind}{ind})); nv:=vec{ind}; Assert(1,ForAll(acts,i->nv*i=nv)); fi; # should we try to refine the next step? if Length(mats)>0 and sz>1 and bp>1 and ForAny([2..bp],q->dims[q]-dims[q-1]>lim) then mo:=GModuleByMats(mats,f); ind:=[1..dims[bp]]; acts:=List(mats,x->ImmutableMatrix(f,x{ind}{ind})); mo:=GModuleByMats(acts,f); #if not MTX.IsIrreducible(mo) then nbas:=PrunedBasis(MTX.BasesCompositionSeries(mo)); offset:=Length(nbas)-bp; if offset>0 then #nbas:=nbas{[2..Length(nbas)]}; q:=IdentityMat(dim,f){ind}; nbas:=List(nbas,i->List(i,j->j*q)); Info(InfoMatOrb,2,"Reduction ",List(nbas,Length)); newbas:=[]; for i in nbas do q:=BaseSteinitzVectors(i,newbas); Append(newbas,q.factorspace); od; Append(newbas,IdentityMat(dim,f){[dims[bp]+1..dim]}); newbas:=ImmutableMatrix(f,newbas); dims:=Concatenation(List(nbas{[1..Length(nbas)]},Length), dims{[bp+1..Length(dims)]}); #Error("further reduction!"); #base change newbas is matrix new -> old q:=newbas^-1; mats:=List(mats,i->newbas*i*q); vec:=vec*q; bp:=bp+offset; fi; if AssertionLevel()>0 then ind:=[dims[bp]+1..dim]; acts:=List(mats,x->ImmutableMatrix(f,x{ind}{ind})); nv:=vec{ind}; Assert(1,ForAll(acts,i->nv*i=nv)); fi; fi; fi; bp:=bp-1; od; Assert(1,ForAll(mats,i->vec*i=vec)); return rec(stabilizer:=group, gens:=gens, mats:=mats, shadows:=shadows); end; ############################################################################# ## #F StabilizerByMatrixOperation( C, v, cohom ) ## StabilizerByMatrixOperation := function( C, v, cohom ) local translate, gens, oper, fac, ind, vec, tmp; # the trivial case if Size( C ) = 1 then return C; fi; # can we get a permrep? if IsBound(C!.permrep) then translate:=C!.permrep; else translate:=EXPermutationActionPairs(C); fi; # choose gens if translate<>false then Unbind(translate.isomorphism); EXReducePermutationActionPairs(translate); gens:=translate.pairgens; elif HasPcgs( C ) then gens := Pcgs( C ); else gens := GeneratorsOfGroup( C ); fi; # compute matrix operation oper := MatrixOperationOfCPGroup( cohom, gens ); if translate<>false then tmp:=VectorStabilizerByFactors(translate.permgroup,translate.permgens, oper,translate.pairgens,v); translate:=rec(permgroup:=tmp.stabilizer, permgens:=tmp.gens, pairgens:=tmp.shadows); C:=GroupByGenerators(translate.pairgens,One(C)); SetSize(C,Size(tmp.stabilizer)); else tmp := OrbitStabilizer( C, v, gens, oper, OnRight ); Info( InfoMatOrb, 1, " MO: found orbit of length ",Length(tmp.orbit) ); SetSize( tmp.stabilizer, Size( C ) / Length( tmp.orbit ) ); C := tmp.stabilizer; fi; if translate<>false then C!.permrep:=translate; fi; return C; end; ############################################################################# ## #F TransferPcgsInfo( A, pcsA, rels ) ## TransferPcgsInfo := function( A, pcsA, rels ) local pcgsA; pcgsA := PcgsByPcSequenceNC( ElementsFamily( FamilyObj( A ) ), pcsA ); SetRelativeOrders( pcgsA, rels ); SetOneOfPcgs( pcgsA, One(A) ); SetPcgs( A, pcgsA ); SetFilterObj( A, CanEasilyComputePcgs ); end; ############################################################################# ## #F BlockStabilizer( G, bl ) ## BlockStabilizer := function( G, bl ) local sub, sortbl, f, len, pos, L, new; # the trivial blocksys is useless if ForAll( bl, x -> Length(x) = 1 ) then return G; fi; if Length( bl ) = 1 then return G; fi; sub := Filtered( bl, x -> Length(x) > 1 ); len := Set( List( sub, x -> Length(x) ) ); pos := List( len, x -> Filtered(sub, y -> Length(y) = x ) ); L := ShallowCopy( G ); Sort( pos, function( x, y ) return Length(x) < Length( y ); end); sortbl := function( sys ) local i; for i in [1..Length(sys)] do Sort( sys[i] ); od; Sort( sys, function( x, y ) return x[1] < y[1]; end); end; sortbl( sub ); f := function( pt, perm ) local new; new := List( pt, x -> List( x, y -> y^perm) ); sortbl( new ); return new; end; # now loop for new in pos do if Length( new ) = 1 then L := Stabilizer( L, new[1], OnSets ); else L := Stabilizer( L, new, f ); fi; od; return L; end; ############################################################################# ## #F InducedActionAutGroup( epi, weights, s, n, A ) ## InducedActionAutGroup := function( epi, weights, s, n, A ) local M, H, F, pcgsM, indices, pcsN, N, d, gensN, G, free, words, comp, aut, imgs, mat, w, m, exp, tup, gensG, field, D, gensA; M := KernelOfMultiplicativeGeneralMapping( epi ); H := Source( epi ); F := Image( epi ); pcgsM := Pcgs( M ); field := GF( weights[s][3] ); # construct p-subgroup of H indices := Filtered( [1..s-1], x -> weights[x][1] = weights[s][1] and weights[x][3] = weights[s][3] ); pcsN := Pcgs( H ){indices}; N := SubgroupNC( H, pcsN ); d := Length( indices ); gensN := pcsN{[1..d]}; # construct words for pcgsM in gensN G := FreeGroup( d ); gensG := GeneratorsOfGroup( G ); free := GroupHomomorphismByImagesNC( G, N, gensG, gensN ); words := List( pcgsM, x -> PreImagesRepresentative( free, x ) ); # compute images of words comp := []; if CanEasilyComputePcgs( A ) then gensA := Pcgs( A ); else gensA := GeneratorsOfGroup( A ); fi; for aut in gensA do imgs := List( gensN, x -> Image( aut, Image( epi, x ) ) ); imgs := List( imgs, x -> PreImagesRepresentative( epi, x ) ); mat := []; for w in words do m := MappedWord( w, gensG, imgs ); exp := ExponentsOfPcElement( pcgsM, m ) * One( field ); Add( mat, exp ); od; tup := DirectProductElement( [aut, mat] ); Add( comp, tup ); od; # add size and check solubility D := GroupByGenerators( comp, DirectProductElement( [ One( A ), Immutable( IdentityMat(Length(pcgsM), field) )])); SetSize( D, Size( A ) ); if CanEasilyComputePcgs( A ) then TransferPcgsInfo( D, comp, RelativeOrders( gensA ) ); fi; return D; end; ############################################################################# ## #F Fingerprint( G, U ) ## if not IsBound( MyFingerprint ) then MyFingerprint := false; fi; FingerprintSmall := function( G, U ) return [IdGroup( U ), Size( CommutatorSubgroup(G,U) )]; end; FingerprintMedium := function( G, U ) local w, cl, id; # some general stuff w := LGWeights( SpecialPcgs( U ) ); id := [w, Size( CommutatorSubgroup( G, U ) )]; # about conjugacy classes cl := OrbitsDomain( U, AsList( U ), OnPoints ); cl := List( cl, x -> [Length(x), Order( x[1] ) ] ); Sort( cl ); Add( id, cl ); return id; end; FingerprintLarge := function( G, U ) return [Size(U), Size( DerivedSubgroup( U ) ), Size( CommutatorSubgroup( G, U ) )]; end; Fingerprint := function ( G, U ) if not IsBool( MyFingerprint ) then return MyFingerprint( G, U ); fi; if ID_AVAILABLE( Size( U ) ) <> fail then return FingerprintSmall( G, U ); elif Size( U ) <= 1000 then return FingerprintMedium( G, U ); else return FingerprintLarge( G, U ); fi; end; ############################################################################# ## #F NormalizingReducedGL( spec, s, n, M ) ## NormalizingReducedGL := function( spec, s, n, M ) local G, p, d, field, B, U, hom, pcgs, pcs, rels, w, S, L, f, P, norm, pcgsN, pcgsM, pcgsF, orb, part, par, done, i, elm, elms, pcgsH, H, tup, pos, perms, V; G := GroupOfPcgs( spec ); d := M.dimension; field := M.field; p := Characteristic( field ); B := GL( d, p ); U := SubgroupNC( B, M.generators ); # the trivial case if d = 1 then hom := IsomorphismPermGroup( B ); pcgs := Pcgs( Image( hom ) ); pcs := List( pcgs, x -> PreImagesRepresentative( hom, x ) ); TransferPcgsInfo( B, pcs, RelativeOrders( pcgs ) ); return B; fi; # first find out, whether there are characteristic subspaces # -> compute socle series and chain stabilising mat group S := B; # in case that we cannot compute a perm rep of pgl if p^d > 10000 then return S; fi; # otherwise use a perm rep of pgl and find a small admissible subgroup norm := NormedRowVectors( field^d ); f := function( pt, op ) return NormedRowVector( pt * op ); end; hom := ActionHomomorphism( S, norm, f ); P := Image( hom ); L := ShallowCopy(P); # compute corresponding subgroups to mins pcgsN := InducedPcgsByPcSequenceNC( spec, spec{[s..Length(spec)]} ); pcgsM := InducedPcgsByPcSequenceNC( spec, spec{[n..Length(spec)]} ); pcgsF := pcgsN mod pcgsM; # use fingerprints done := []; part := []; for i in [1..Length(norm)] do elm := PcElementByExponentsNC( pcgsF, norm[i] ); elms := Concatenation( [elm], pcgsM ); pcgsH := InducedPcgsByPcSequenceNC( spec, elms ); H := SubgroupByPcgs( G, pcgsH ); tup := Fingerprint( G, H ); pos := Position( done, tup ); if IsBool( pos ) then Add( part, [i] ); Add( done, tup ); else Add( part[pos], i ); fi; od; Sort( part, function( x, y ) return Length(x) < Length(y); end ); # compute partition stabilizer if Length(part) > 1 then for par in part do if Length( part ) = 1 then L := Stabilizer( L, par[1], OnPoints ); else L := Stabilizer( L, par, OnSets ); fi; od; fi; Info( InfoOverGr, 1, "found partition ",part ); # use operation of G on norm orb := OrbitsDomain( U, norm, f ); part := List( orb, x -> List( x, y -> Position( norm, y ) ) ); # was: L := BlockStabilizer( L, part ); part:=List(part,Set); L:=PartitionStabilizerPermGroup(L,part); Info( InfoOverGr, 1, "found blocksystem ",part ); # compute normalizer of module perms := List( M.generators, x -> Image( hom, x ) ); V := SubgroupNC( P, perms ); L := Normalizer( L, V ); Info( InfoOverGr, 1, "computed normalizer of size ", Size(L)); # go back to mat group B := List( GeneratorsOfGroup(L), x -> PreImagesRepresentative(hom,x) ); w := PrimitiveRoot(field)* Immutable( IdentityMat( d, field ) ); B := SubgroupNC( S, Concatenation( B, [w] ) ); if IsSolvableGroup( L ) then pcgs := List( Pcgs(L), x -> PreImagesRepresentative( hom, x ) ); Add( pcgs, w ); rels := ShallowCopy( RelativeOrders( Pcgs(L) ) ); Add( rels, p-1 ); TransferPcgsInfo( B, pcgs, rels ); fi; SetSize( B, Size( L )*(p-1) ); return B; end; ############################################################################# ## #F CocycleSQ( epi, field ) ## CocycleSQ := function( epi, field ) local H, F, N, pcsH, pcsN, pcgsH, o, n, d, z, c, i, j, h, exp, p, k; # set up H := Source( epi ); F := Image( epi ); N := KernelOfMultiplicativeGeneralMapping( epi ); pcsH := List( Pcgs( F ), x -> PreImagesRepresentative( epi, x ) ); pcsN := Pcgs( N ); pcgsH := PcgsByPcSequence( ElementsFamily( FamilyObj( H ) ), Concatenation( pcsH, pcsN ) ); o := RelativeOrders( pcgsH ); n := Length( pcsH ); d := Length( pcsN ); z := One( field ); # initialize cocycle c := List( [1..d*(n^2 + n)/2], x -> Zero( field ) ); # add relators for i in [1..n] do for j in [1..i] do if i = j then h := pcgsH[i]^o[i]; else h := pcgsH[i]^pcgsH[j]; fi; exp := ExponentsOfPcElement( pcgsH, h ){[n+1..n+d]} * z; p := (i^2 - i)/2 + j - 1; for k in [1..d] do c[p*d+k] := exp[k]; od; od; od; # check if c = 0 * c then return 0; fi; return c; end; ############################################################################# ## #F InduciblePairs( C, epi, M ) ## InduciblePairs := function( C, epi, M ) local F, cc, c, stab, b; if HasSize( C ) and Size( C ) = 1 then return C; fi; # get groups F := Image( epi ); # get cohomology cc := TwoCohomology( F, M ); Info( InfoAutGrp, 2, "computed cohomology with dim ", Dimension(Image(cc.cohom))); # get cocycle c := CocycleSQ( epi, M.field ); b := Image( cc.cohom, c ); # compute stabilizer of b stab := StabilizerByMatrixOperation( C, b, cc ); return stab; end; MatricesOfRelator := function( rel, gens, inv, mats, field, d ) local n, m, L, s, i, mat; # compute left hand side n := Length( mats ); m := Length( rel ); L := ListWithIdenticalEntries( n, Immutable( NullMat( d, d, field ) ) ); while m > 0 do s := Subword( rel, 1, 1 ); i := Position( gens, s ); if not IsBool( i ) and m > 1 then mat := MappedWord(Subword( rel, 2, m ), gens, mats); L[i] := L[i] + mat; elif not IsBool( i ) then L[i] := L[i] + IdentityMat( d, field ); else i := Position( inv, s ); mat := MappedWord( rel, gens, mats ); L[i] := L[i] - mat; fi; if m > 1 then rel := Subword( rel, 2, m ); fi; m := m - 1; od; return L; end; VectorOfRelator := function( rel, gens, imgsF, pcsH, pcsN, nu, field ) local w, s, r; # compute right hand side w := MappedWord( rel, gens, imgsF )^-1; s := MappedWord( rel, gens, pcsH ); r := ExponentsOfPcElement( pcsN, w * Image( nu, s ) ) * One(field); return r; end; ############################################################################# ## #F LiftInduciblePair( epi, ind, M, weight ) ## LiftInduciblePair := function( epi, ind, M, weight ) local H, F, N, pcgsF, pcsH, pcsN, pcgsH, n, d, imgsF, imgsN, nu, P, gensP, invP, relsP, l, E, v, k, rel, u, vec, L, r, i, elm, auto, imgsH, j, h, opmats; # set up H := Source( epi ); F := Image( epi ); N := KernelOfMultiplicativeGeneralMapping( epi ); pcgsF := Pcgs( F ); pcsH := List( pcgsF, x -> PreImagesRepresentative( epi, x ) ); pcsN := Pcgs( N ); pcgsH := PcgsByPcSequence( ElementsFamily( FamilyObj( H ) ), Concatenation( pcsH, pcsN ) ); n := Length( pcsH ); d := Length( pcsN ); # use automorphism of F imgsF := List( pcgsF, x -> Image( ind[1], x ) ); opmats := List( imgsF, x -> MappedPcElement( x, pcgsF, M.generators ) ); imgsF := List( imgsF, x -> PreImagesRepresentative( epi, x ) ); # use automorphism of N imgsN := List( pcsN, x -> ExponentsOfPcElement( pcsN, x ) ); imgsN := List( imgsN, x -> x * ind[2] ); imgsN := List( imgsN, x -> PcElementByExponentsNC( pcsN, x ) ); # in the split case this is all to do if weight[2] = 1 then imgsH := Concatenation( imgsF, imgsN ); auto := GroupHomomorphismByImagesNC( H, H, AsList(pcgsH), imgsH ); SetIsBijective( auto, true ); SetKernelOfMultiplicativeGeneralMapping( auto, TrivialSubgroup( H ) ); return auto; fi; # add correction nu := GroupHomomorphismByImagesNC( N, N, AsList( pcsN ), imgsN ); P := Range( IsomorphismFpGroupByPcgs( pcgsF, "g" ) ); gensP := GeneratorsOfGroup( FreeGroupOfFpGroup( P ) ); invP := List( gensP, x -> x^-1 ); relsP := RelatorsOfFpGroup( P ); l := Length( relsP ); E := List( [1..n*d], x -> List( [1..l*d], y -> true ) ); v := []; for k in [1..l] do rel := relsP[k]; L := MatricesOfRelator( rel, gensP, invP, opmats, M.field, d ); r := VectorOfRelator( rel, gensP, imgsF, pcsH, pcsN, nu, M.field ); # add to big system Append( v, r ); for i in [1..n] do for j in [1..d] do for h in [1..d] do E[d*(i-1)+j][d*(k-1)+h] := L[i][j][h]; od; od; od; od; # solve system u := SolutionMat( E, v ); if u = fail then Error("no lifting found"); fi; # correct images for i in [1..n] do vec := u{[d*(i-1)+1..d*i]}; elm := PcElementByExponentsNC( pcsN, vec ); imgsF[i] := imgsF[i] * elm; od; # set up automorphisms imgsH := Concatenation( imgsF, imgsN ); auto := GroupHomomorphismByImagesNC( H, H, AsList( pcgsH ), imgsH ); SetIsBijective( auto, true ); SetKernelOfMultiplicativeGeneralMapping( auto, TrivialSubgroup( H ) ); return auto; end; ############################################################################# ## #F AutomorphismGroupElAbGroup( G, B ) ## AutomorphismGroupElAbGroup := function( G, B ) local pcgs, p, d, mats, autos, mat, imgs, auto, A; # create matrices pcgs := Pcgs( G ); p := RelativeOrders( pcgs )[1]; d := Length( pcgs ); if CanEasilyComputePcgs( B ) then mats := Pcgs( B ); else mats := GeneratorsOfGroup( B ); fi; autos := []; for mat in mats do imgs := List( pcgs, x -> PcElementByExponentsNC( pcgs, ExponentsOfPcElement( pcgs, x ) * mat ) ); auto := GroupHomomorphismByImagesNC( G, G, AsList( pcgs ), imgs ); SetIsBijective( auto, true ); SetKernelOfMultiplicativeGeneralMapping( auto, TrivialSubgroup( G ) ); Add( autos, auto ); od; A := GroupByGenerators( autos, IdentityMapping( G ) ); SetSize( A, Size( B ) ); if IsPcgs( mats ) then TransferPcgsInfo( A, autos, RelativeOrders( mats ) ); fi; return A; end; ############################################################################# ## #F AutomorphismGroupSolvableGroup( G ) ## InstallGlobalFunction(AutomorphismGroupSolvableGroup,function( G ) local spec, weights, first, m, pcgsU, F, pcgsF, A, i, s, n, p, H, pcgsH, pcgsN, N, epi, mats, M, autos, ocr, elms, e, list, imgs, auto, tmp, hom, gens, P, C, B, D, pcsA, rels, iso, xset, gensA, new,as; # get LG series spec := SpecialPcgs(G); weights := LGWeights( spec ); first := LGFirst( spec ); m := Length( spec ); # set up with GL Info( InfoAutGrp, 2, "set up computation for grp with weights ", weights); pcgsU := InducedPcgsByPcSequenceNC( spec, spec{[first[2]..m]} ); pcgsF := spec mod pcgsU; F := PcGroupWithPcgs( pcgsF ); M := rec( field := GF( weights[1][3] ), dimension := first[2]-1, generators := [] ); B := NormalizingReducedGL( spec, 1, first[2], M ); A := AutomorphismGroupElAbGroup( F, B ); SetIsGroupOfAutomorphismsFiniteGroup(A,true); # run down series for i in [2..Length(first)-1] do # get factor s := first[i]; n := first[i+1]; p := weights[s][3]; Info( InfoAutGrp, 2, "start ",i,"th layer, weight ",weights[s], "^", n-s, ", aut.grp. size ",Size(A)); # set up pcgsU := InducedPcgsByPcSequenceNC( spec, spec{[n..m]} ); H := PcGroupWithPcgs( spec mod pcgsU ); pcgsH := Pcgs( H ); ocr := rec( group := H, generators := pcgsH ); # we will modify the generators later! pcgsN := InducedPcgsByPcSequenceNC( pcgsH, pcgsH{[s..n-1]} ); ocr.modulePcgs := pcgsN; ocr.generators:=ocr.generators mod NumeratorOfModuloPcgs(pcgsN); N := SubgroupByPcgs( H, pcgsN ); epi := GroupHomomorphismByImagesNC( H, F, AsList( pcgsH ), Concatenation( Pcgs(F), List( [s..n-1], x -> One(F) ) ) ); SetKernelOfMultiplicativeGeneralMapping( epi, N ); # get module mats := LinearOperationLayer( H, pcgsH{[1..s-1]}, pcgsN ); M := GModuleByMats( mats, GF( p ) ); # compatible / inducible pairs if weights[s][2] = 1 then Info( InfoAutGrp, 2,"compute reduced gl "); B := NormalizingReducedGL( spec, s, n, M ); # A and B will not be used later, so it is no problem to # replace them by other groups with fewer generators B:=SubgroupNC(B,SmallGeneratingSet(B)); if HasPcgs(A) and Length(Pcgs(A)) 1 then Info( InfoAutGrp, 2, "compute compatible pairs in group of size ", Size(A), " x ",Size(B),", ", Length(GeneratorsOfGroup(D))," generators"); D := CompatiblePairs( F, M, D ); fi; Info( InfoAutGrp,2, "compute inducible pairs in a group of size ", Size( D )); C := InduciblePairs( D, epi, M ); fi; Unbind(A);Unbind(B);Unbind(D); # lift Info( InfoAutGrp, 2, "lift back "); if Size( C ) = 1 then gens := []; elif CanEasilyComputePcgs( C ) then gens := Pcgs( C ); else gens := GeneratorsOfGroup( C ); fi; autos := List( gens, x -> LiftInduciblePair( epi, x, M, weights[s] ) ); # add H^1 Info( InfoAutGrp, 2, "add derivations "); elms := BasisVectors( Basis( OCOneCocycles( ocr, false ) ) ); for e in elms do list := ocr.cocycleToList( e ); imgs := List( [1..s-1], x -> pcgsH[x] * list[x] ); Append( imgs, pcgsH{[s..n-1]} ); auto := GroupHomomorphismByImagesNC( H, H, AsList( pcgsH ), imgs ); SetIsBijective( auto, true ); SetKernelOfMultiplicativeGeneralMapping(auto, TrivialSubgroup(H)); Add( autos, auto ); od; Info( InfoAutGrp, 2, Length(autos)," generating automorphisms"); # set up for iteration F := ShallowCopy( H ); A := GroupByGenerators( autos ); SetIsGroupOfAutomorphismsFiniteGroup(A,true); SetSize( A, Size( C ) * p^Length(elms) ); if Size(C) = 1 then rels := List( [1..Length(elms)], x-> p ); TransferPcgsInfo( A, autos, rels ); elif CanEasilyComputePcgs( C ) then rels := Concatenation( RelativeOrders(gens), List( [1..Length(elms)], x-> p ) ); TransferPcgsInfo( A, autos, rels ); fi; Unbind(C); Unbind(gens); # if possible reduce the number of generators of A if Size( F ) <= 1000 and not CanEasilyComputePcgs( A ) then Info( InfoAutGrp, 2, "nice the gen set of A "); xset := ExternalSet( A, AsList( F ) ); hom := ActionHomomorphism( xset, "surjective"); P := Image( hom ); if IsSolvableGroup( P ) then pcsA := List( Pcgs(P), x -> PreImagesRepresentative( hom, x )); TransferPcgsInfo( A, pcsA, RelativeOrders( Pcgs(P) ) ); else imgs := SmallGeneratingSet( P ); gens := List( imgs, x -> PreImagesRepresentative( hom, x ) ); tmp := Size( A ); A := GroupByGenerators( gens, One( A ) ); SetSize( A, tmp ); fi; fi; od; # the last step gensA := GeneratorsOfGroup( A ); # try to reduce the generator set if HasPcgs(A) and Length(Pcgs(A)) Image( iso, Image( auto, x ) ) ); new := GroupHomomorphismByImagesNC( G, G, spec, imgs ); SetIsBijective( new, true ); SetKernelOfMultiplicativeGeneralMapping(new, TrivialSubgroup(F)); Add( autos, new ); od; B := GroupByGenerators( autos ); SetSize( B, Size(A) ); return B; end); ############################################################################# ## #F AutomorphismGroupFrattFreeGroup( G ) ## InstallGlobalFunction(AutomorphismGroupFrattFreeGroup,function( G ) local F, K, gensF, gensK, gensG, A, iso, P, gensU, k, aut, U, hom, N, gensN, full, n, imgs, i, m, a, l, new, size, pr, p, S, pcgsS, T, ocr, elms, e, list, B; # create fitting subgroup if HasSocle( G ) and HasSocleComplement( G ) then F := Socle( G ); K := SocleComplement( G ); else F := FittingSubgroup( G ); K := ComplementClassesRepresentatives( G, F )[1]; fi; gensF := Pcgs( F ); gensK := Pcgs( K ); gensG := Concatenation( gensK, gensF ); # create automorhisms Info( InfoAutGrp, 2, "get aut grp of socle "); A := AutomorphismGroupAbelianGroup( F ); # go over to perm rep Info( InfoAutGrp, 2, "compute perm rep "); iso := IsomorphismPermGroup( A ); P := Image( iso ); # compute subgroup Info( InfoAutGrp, 2, "compute subgroup "); gensU := []; for k in gensK do imgs := List( gensF, y -> y ^ k ); aut := GroupHomomorphismByImagesNC( F, F, gensF, imgs ); # CheckAuto( aut ); Add( gensU, Image( iso, aut ) ); od; U := SubgroupNC( P, gensU ); hom := GroupHomomorphismByImagesNC( K, U, gensK, gensU ); # get normalizer Info( InfoAutGrp, 2, "compute normalizer "); N := Normalizer( P, U ); gensN := GeneratorsOfGroup( N ); # create automorphisms of G Info( InfoAutGrp, 2, "compute preimages "); full := []; for n in gensN do imgs := []; for i in [1..Length(gensK)] do m := gensU[i]^n; a := PreImagesRepresentative( hom, m ); Add( imgs, a ); od; l := PreImagesRepresentative( iso, n ); Append( imgs, List( gensF, x -> Image( l, x ) ) ); new := GroupHomomorphismByImagesNC( G, G, gensG, imgs ); SetIsBijective( new, true ); SetKernelOfMultiplicativeGeneralMapping(new, TrivialSubgroup(G)); Add( full, new ); od; size := Size(N); # add derivations Info( InfoAutGrp, 2, "add derivations "); pr := Set( FactorsInt( Size( F ) ) ); for p in pr do # create subgroup S := SylowSubgroup( F, p ); pcgsS := InducedPcgs( gensF, S ); T := SubgroupNC( G, Concatenation( gensK, pcgsS ) ); ocr := rec( group := T, generators := gensK, modulePcgs := pcgsS ); # compute 1-cocycles elms := BasisVectors( Basis( OCOneCocycles( ocr, false ) ) ); for e in elms do list := ocr.cocycleToList( e ); imgs := List( [1..Length(gensK)], x -> gensK[x] * list[x] ); Append( imgs, gensF ); new := GroupHomomorphismByImagesNC( G, G, gensG, imgs ); SetIsBijective( new, true ); SetKernelOfMultiplicativeGeneralMapping(new, TrivialSubgroup(G)); Add( full, new ); od; size := size * ocr.char^Length(elms); od; # create automorphism group B := GroupByGenerators( full, IdentityMapping( G ) ); SetSize( B, size ); return B; end); # The following computes the automorphism group of # a nilpotent group which is NOT a p-group. It computes # the automorphism groups of each Sylow subgroup of G # and then glues these together. # For p-groups, either the standard GAP functionality, or # that from the autpgrp package is used. InstallGlobalFunction(AutomorphismGroupNilpotentGroup,function(G) local S, autS, gens, imgs, i, j, x, off, gensAutG, pcgsSi, autG; if IsAbelian(G) then return AutomorphismGroupAbelianGroup(G); fi; if not IsNilpotentGroup(G) or not IsFinite(G) then return fail; fi; if IsPGroup(G) then return fail; # p-groups should be handled elsewhere fi; # Compute the Sylow subgroups of G; G is the direct product of # these, and Aut(G) is the direct product of the automorphism # groups of the Sylow subgroups. S := SylowSystem(G); # Compute the automorphism group of each of the p-groups autS := List(S, AutomorphismGroup); # Compute automorphism group for G from this gens := Concatenation(List(S, P->Pcgs(P))); off := 0; gensAutG := []; for i in [1..Length(S)] do # Convert the automorphisms of S[i] into automorphisms of G. pcgsSi := Pcgs(S[i]); for x in GeneratorsOfGroup(autS[i]) do imgs := ShallowCopy( gens ); for j in [1..Length(pcgsSi)] do imgs[off + j] := Image(x, pcgsSi[j]); od; Add(gensAutG, GroupHomomorphismByImages(G, G, gens, imgs)); od; off := off + Length(pcgsSi); od; # Now construct autG as "inner" direct product of all the autS autG := Group( gensAutG, IdentityMapping(G) ); SetIsAutomorphismGroup(autG, true); SetIsGroupOfAutomorphismsFiniteGroup(autG, true); SetIsFinite(autG,true); return autG; end ); gap-4r6p5/lib/kbsemi.gi0000644000175000017500000006044112172557252013507 0ustar billbill############################################################################# ## #W kbsemi.gi GAP library Isabel Araújo and Andrew Solomon ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains code for the Knuth-Bendix rewriting system for semigroups ## and monoids. ## ############################################################################ ## #R IsKnuthBendixRewritingSystemRep() ## ## reduced - is the system known to be reduced ## fam - the family of elements of the fp smg/monoid ## DeclareRepresentation("IsKnuthBendixRewritingSystemRep", IsComponentObjectRep, ["family", "tzrules","pairs2check", "reduced", "ordering"]); ############################################################################# ## #F CreateKnuthBendixRewritingSystem(, ) ## ## is a reduction ordering ## (compatible with left and right multiplication). ## ## A Knuth Bendix rewriting system consists of a list of relations, ## which we call rules, and a list of pairs of numbers (pairs2check). ## Each lhs of a rule has to be greater than its rhs ## (so when we apply a rule to a word, we are effectively reducing it - ## according to the ordering considered) ## Each number in a pair of the list pairs2check ## refers to one of the rules. A pair corresponds to a pair ## of rules where confluence was not yet checked (according to ## the Knuth Bendix algorithm). ## ## Note that at this stage the kb rws obtained might not be reduced ## (the same relation might even appear several times). ## InstallGlobalFunction(CreateKnuthBendixRewritingSystem, function(fam, wordord) local r,kbrws,rwsfam,relations_with_correct_order,CantorList,relwco, w,freefam; #changes the set of relations so that lhs is greater then rhs # and removes trivial rules (like u=u) relations_with_correct_order:=function(r,wordord) local i,q; q:=ShallowCopy(r); for i in [1..Length(q)] do if q[i][1]=q[i][2] then Unbind(q[i]); elif IsLessThanUnder(wordord,q[i][1],q[i][2]) then q[i]:=[q[i][2],q[i][1]]; fi; od; return Set(q); end; # generates the list of all pairs (x,y) # where x,y are distinct elements of the set [1..n] CantorList:=function(n) local i,j,l; l:=[]; for i in [1..n] do Add(l,[i,i]); for j in [1..i-1] do Append(l,[[i,j],[j,i]]); od; od; return(l); end; # check that fam is a family of elements of an fp smg or monoid if not (IsElementOfFpMonoidFamily(fam) or IsElementOfFpSemigroupFamily(fam)) then Error( "Can only create a KB rewriting system for an fp semigroup or monoid"); fi; # check the second argument is a reduction ordering if not (IsOrdering(wordord) and IsReductionOrdering(wordord)) then Error("Second argument must be a reduction ordering"); fi; if IsElementOfFpMonoidFamily(fam) then w:=CollectionsFamily(fam)!.wholeMonoid; r:=RelationsOfFpMonoid(w); freefam:=ElementsFamily(FamilyObj(FreeMonoidOfFpMonoid(w))); else w:=CollectionsFamily(fam)!.wholeSemigroup; r:=RelationsOfFpSemigroup(w); freefam:=ElementsFamily(FamilyObj(FreeSemigroupOfFpSemigroup(w))); fi; rwsfam := NewFamily("Family of Knuth-Bendix Rewriting systems", IsKnuthBendixRewritingSystem); relwco:=relations_with_correct_order(r,wordord); kbrws := Objectify(NewType(rwsfam, IsMutable and IsKnuthBendixRewritingSystem and IsKnuthBendixRewritingSystemRep), rec(family:= fam, reduced:=false, tzrules:=List(relwco,i-> [LetterRepAssocWord(i[1]),LetterRepAssocWord(i[2])]), pairs2check:=CantorList(Length(r)), ordering:=wordord, freefam:=freefam)); if HasLetterRepWordsLessFunc(wordord) then kbrws!.tzordering:=LetterRepWordsLessFunc(wordord); else kbrws!.tzordering:=false; fi; if IsElementOfFpMonoidFamily(fam) then SetIsBuiltFromMonoid(kbrws,true); else SetIsBuiltFromSemigroup(kbrws,true); fi; return kbrws; end); ############################################################################# ## #A ReduceRules() ## ## Reduces the set of rules of a Knuth Bendix Rewriting System ## InstallMethod(ReduceRules, "for a Knuth Bendix rewriting system", true, [ IsKnuthBendixRewritingSystem and IsKnuthBendixRewritingSystemRep and IsMutable ], 0, function(rws) local r, # local copy of the rules v; # a rule r := ShallowCopy(rws!.tzrules); rws!.tzrules:=[]; rws!.pairs2check:=[]; rws!.reduced := true; for v in r do AddRuleReduced(rws, v); od; end); ############################################################################# ## #O AddRuleReduced(, ) ## ## Add a rule to a rewriting system and, if the system is already ## reduced it will remain reduced. Note, this also changes the pairs ## of rules to check. ## ## given a pair v of words that have to be equal it checks whether that ## happens or not and adjoin new rules if necessary. Then checks that we ## still have something reduced and keep removing and adding rules, until ## we have a reduced system where the given equality holds and everything ## that was equal before is still equal. It returns the resulting rws ## ## See Sims: "Computation with finitely presented groups". ## InstallOtherMethod(AddRuleReduced, "for a Knuth Bendix rewriting system and a rule", true, [ IsKnuthBendixRewritingSystem and IsMutable and IsKnuthBendixRewritingSystemRep, IsList ], 0, function(kbrws,v) local u,a,b,c,k,n,s,add_rule,remove_rule,fam; #given a Knuth Bendix Rewriting System, kbrws, #removes rule i of the set of rules of kbrws and #modifies the list pairs2check in such a way that the previous indexes #are modified so they correspond to same pairs as before remove_rule:=function(i,kbrws) local j,q,a,k,l; #first remove rule from the set of rules q:=kbrws!.tzrules{[1..i-1]}; Append(q,kbrws!.tzrules{[i+1..Length(kbrws!.tzrules)]}); kbrws!.tzrules:=q; #delete pairs pairs of indexes that include i #and change ocurrences of indexes k greater than i in the #list of pairs and change them to k-1 #So we'll construct a new list with the right pairs l:=[]; for j in [1..Length(kbrws!.pairs2check)] do if kbrws!.pairs2check[j][1]<>i and kbrws!.pairs2check[j][2]<>i then a:=kbrws!.pairs2check[j]; for k in [1..2] do if kbrws!.pairs2check[j][k]>i then a[k]:=kbrws!.pairs2check[j][k]-1; fi; od; Add(l,a); fi; od; kbrws!.pairs2check:=l; end; #given a Knuth Bendix Rewriting System this function returns it #with the given extra rule adjoined to the set of rules #and the necessary pairs adjoined to pairs2check #(the pairs that we have to put in pairs2check correspond to the #new rule together with all the ones that were in the set of rules #previously) add_rule:=function(u,kbrws) local q,l,i,n; #insert rule Add(kbrws!.tzrules,u); #insert new pairs l:=kbrws!.pairs2check; n:=Length(kbrws!.tzrules); Add(l,[n,n]); for i in [1..n-1] do Append(l,[[i,n],[n,i]]); od; kbrws!.pairs2check:=l; end; #the stack is a list of pairs of words such that if two words form a pair #they have to be equivalent, that is, they have to reduce to same word #TODO fam:=kbrws!.freefam; #we put the pair v in the stack s:=[v]; #while the stack is non empty while not(IsEmpty(s)) do #pop the first rule from the stack #use rules available to reduce both sides of rule u:=s[1]; s:=s{[2..Length(s)]}; a:=ReduceLetterRepWordsRewSys(kbrws!.tzrules,u[1]); b:=ReduceLetterRepWordsRewSys(kbrws!.tzrules,u[2]); #if both sides reduce to different words #have to adjoin a new rule to the set of rules if not(a=b) then #TODO if kbrws!.tzordering=false then c:=IsLessThanUnder(kbrws!.ordering, AssocWordByLetterRep(fam,a),AssocWordByLetterRep(fam,b)); else c:=kbrws!.tzordering(a,b); fi; if c then c:=a; a:=b; b:=c; fi; add_rule([a,b],kbrws); kbrws!.reduced := false; #Now we have to check if by adjoining this rule #any of the other active ones become redudant k:=1; n:=Length(kbrws!.tzrules)-1; while k in [1..n] do #if lhs of rule k contains lhs of new rule #as a subword then we delete rule k #but add it to the stack, since it has to still hold if PositionSublist(kbrws!.tzrules[k][1],a,0)<>fail then #if PositionWord(kbrws!.rules[k][1],a,1)<>fail then Add(s,kbrws!.tzrules[k]); remove_rule(k,kbrws); n:=Length(kbrws!.tzrules)-1; k:=k-1; #else if rhs of rule k contains the new rule #as a subword then we use the new rule #to irreduce that rhs elif PositionSublist(kbrws!.tzrules[k][2],a,0)<>fail then #elif PositionWord(kbrws!.rules[k][2],a,1)<>fail then kbrws!.tzrules[k][2]:= ReduceLetterRepWordsRewSys(kbrws!.tzrules, kbrws!.tzrules[k][2]); fi; k:=k+1; od; fi; od; kbrws!.reduced := true; end); ############################################################################# ## #M MakeKnuthBendixRewritingSystemConfluent () ## ## RWS is a Knuth Bendix Rewriting System ## This function takes a Knuth Bendix Rws (ie a set of rules ## and a set of pairs which indicate the rules that ## still have to be checked for confluence) and ## applies the Knuth Bendix algorithm for strigs to it to get a reduced ## confluent rewriting system. ## ## Confluence means the following: if w is a word which can be reduced ## using two different rules, say w->u and w->v, then the irreducible forms ## of u and v are the same word. ## ## To construct a rws from a set of rules consists of adjoining new ## rules if necessary to be sure the confluence property holds ## ## This implementation of Knuth-bendix also guarantees that we will ## obtain a reduced rws, meaning that there are not redundant rules ## ## Note (see Sims, `Computation with finitely presented groups', 1994) ## a reduced confluent rewriting system for a semigroup with a given set of ## generators is unique, under a given ordering. InstallGlobalFunction( MakeKnuthBendixRewritingSystemConfluent, function ( rws ) Info( InfoKnuthBendix, 1, "MakeKnuthBendixRewritingSystemConfluent called" ); # call the KB plugin KB_REW.MakeKnuthBendixRewritingSystemConfluent(rws); Info( InfoKnuthBendix, 1, "KB terminates with ",Length(rws!.tzrules), " rules" ); end); #u and v are pairs of rules, kbrws is a kb RWS #look for proper overlaps of lhs (lhs of u ends as lhs of v starts) #Check confluence does not fail here, adjoining extra rules if necessary BindGlobal("KBOverlaps",function(ui,vi,kbrws,p) local u,v,m,k,a,c,lsu,lsv,lu,eq,i,j; u:=kbrws!.tzrules[ui]; v:=kbrws!.tzrules[vi]; lsu:=u[1]; lu:=Length(lsu); lsv:=v[1]; #we are only going to consider proper overlaps #m:=Minimum(lu,Length(lsv))-1; m:=Length(lsv)-1; if lu<=m then m:=lu-1; fi; #any overlap will have length less than m k:=1; while k<=m do #if the last k letters of u[1] are the same as the 1st k letters of v[1] #they overlap #if Subword(u[1],Length(u[1])-k+1,Length(u[1]))=Subword(v[1],1,k) then eq:=true; i:=lu-k+1; j:=1; while eq and j<=k do eq:=lsu[i]=lsv[j]; i:=i+1; j:=j+1; od; if eq then #a:=Subword(u[1],1,Length(u[1])-k)*v[2]; #c:=u[2]*Subword(v[1],k+1,Length(v[1])); # we can't have cancellation a:=Concatenation(lsu{[1..lu-k]},v[2]); c:=Concatenation(u[2],lsv{[j..Length(lsv)]}); #for guarantee confluence a=c has to hold #we change rws, if necessary, so a=c is verified if a <> c then # `AddRuleReduced' might affect the pairs. So first throw away the # `old' pairs kbrws!.pairs2check:= kbrws!.pairs2check{[p+1..Length(kbrws!.pairs2check)]}; p:=0; # no remaining pair was looked at AddRuleReduced(kbrws,[a,c]); fi; fi; k:=k+1; od; return p; end); ############################################################ # # Function proper # ########################################################### BindGlobal("GKB_MakeKnuthBendixRewritingSystemConfluent", function(kbrws) local pn,lp,rl,p,i; #loop variables # kbrws!.reduced is true than it means that the system know it is # reduced. If it is false it might be reduced or not. if not kbrws!.reduced then ReduceRules(kbrws); fi; # we check all pairs of relations for overlaps. In most cases there will # be no overlaps. Therefore cally an inde xp in the pairs list and reduce # this list, only if `AddRules' gets called. This avoids creating a lot of # garbage lists. p:=1; rl:=50; pn:=Length(kbrws!.pairs2check); lp:=Length(kbrws!.pairs2check); while lp>=p do i:=kbrws!.pairs2check[p]; p:=KBOverlaps(i[1],i[2],kbrws,p)+1; lp:=Length(kbrws!.pairs2check); if Length(kbrws!.tzrules)>rl or AbsInt(lp-pn)>10000 then Info(InfoKnuthBendix,1,Length(kbrws!.tzrules)," rules, ", lp," pairs"); rl:=Length(kbrws!.tzrules)+50; pn:=lp; fi; od; kbrws!.pairs2check:=[]; end); GAPKB_REW.MakeKnuthBendixRewritingSystemConfluent := GKB_MakeKnuthBendixRewritingSystemConfluent; ############################################################################# ## #M MakeConfluent () ## InstallMethod(MakeConfluent, "for Knuth Bendix Rewriting System", true, [IsKnuthBendixRewritingSystem and IsKnuthBendixRewritingSystemRep and IsMutable and IsBuiltFromSemigroup],0, function(kbrws) local rws; MakeKnuthBendixRewritingSystemConfluent(kbrws); # if the semigroup of the kbrws does not have a # ReducedConfluentRws build one from kbrws and then store it in # the semigroup if not HasReducedConfluentRewritingSystem( SemigroupOfRewritingSystem(kbrws)) then rws := ReducedConfluentRwsFromKbrwsNC(kbrws); SetReducedConfluentRewritingSystem(SemigroupOfRewritingSystem(kbrws), rws); fi; end); InstallMethod(MakeConfluent, "for Knuth Bendix Rewriting System", true, [IsKnuthBendixRewritingSystem and IsKnuthBendixRewritingSystemRep and IsMutable and IsBuiltFromMonoid],0, function(kbrws) local rws; MakeKnuthBendixRewritingSystemConfluent(kbrws); # if the monoid of the kbrws does not have a # ReducedConfluentRws build one from kbrws and then store it in # the monoid if not HasReducedConfluentRewritingSystem( MonoidOfRewritingSystem(kbrws)) then rws := ReducedConfluentRwsFromKbrwsNC(kbrws); SetReducedConfluentRewritingSystem(MonoidOfRewritingSystem(kbrws), rws); fi; end); ############################################################################# ## #P IsReduced( ) ## ## True iff the rws is reduced ## A rws is reduced if for each (u,v) in rws both u and v are ## irreducible with respect to rws-{(u,v)} ## InstallMethod(IsReduced, "for a Knuth Bendix rewriting system", true, [IsKnuthBendixRewritingSystem and IsKnuthBendixRewritingSystemRep and IsMutable], 0, function(kbrws) local i,copy_of_kbrws,u; # if the rws already knows it is reduced return true if kbrws!.reduced then return true; fi; for i in [1..Length(Rules(kbrws))] do u := Rules(kbrws)[i]; #TODO copy_of_kbrws := ShallowCopy(kbrws); copy_of_kbrws!.tzrules := []; Append(copy_of_kbrws!.tzrules,kbrws!.tzrules{[1..i-1]}); Append(copy_of_kbrws!.tzrules,kbrws!.tzrules {[i+1..Length(kbrws!.tzrules)]}); if ReduceLetterRepWordsRewSys(copy_of_kbrws!.tzrules,u[1])<>u[1] then return false; fi; if ReduceLetterRepWordsRewSys(copy_of_kbrws!.tzrules,u[2])<>u[2] then return false; fi; od; return true; end); ############################################################################# ## #M KnuthBendixRewritingSystem() #M KnuthBendixRewritingSystem(,) #M KnuthBendixRewritingSystem() #M KnuthBendixRewritingSystem(,) #M KnuthBendixRewritingSystem() #M KnuthBendixRewritingSystem(,) ## ## creates the Knuth Bendix rewriting system for a family of ## word of an fp monoid or semigroup ## using a supplied reduction ordering. ## ## We also allow using a function giving the ordering ## to assure compatability with gap4.2 ## In that case the function should be the less than or equal ## function of a reduction ordering (no checking is performed) ## InstallMethod(KnuthBendixRewritingSystem, "for a family of words of an fp semigroup and on ordering on that family", true, [IsElementOfFpSemigroupFamily, IsOrdering], 0, function(fam,wordord) local freefam,kbrws; freefam := ElementsFamily(FamilyObj(fam!.freeSemigroup)); # the ordering has to be an ordering on the family freefam if not freefam=FamilyForOrdering(wordord) then Error("family and ordering are not compatible"); fi; kbrws := CreateKnuthBendixRewritingSystem(fam,wordord); return kbrws; end); InstallMethod(KnuthBendixRewritingSystem, "for a family of words of an fp monoid and on ordering on that family", true, [IsElementOfFpMonoidFamily, IsOrdering], 0, function(fam,wordord) local freefam,kbrws; freefam := ElementsFamily(FamilyObj(fam!.freeMonoid)); # the ordering has to be an ordering on the family fam if not freefam=FamilyForOrdering(wordord) then Error("family and ordering are not compatible"); fi; kbrws := CreateKnuthBendixRewritingSystem(fam,wordord); return kbrws; end); InstallOtherMethod(KnuthBendixRewritingSystem, "for an fp semigroup and an order on the family of words of the underlying free semigroup", true, [IsFpSemigroup, IsOrdering], 0, function(s,wordord) local kbrws,fam; fam := ElementsFamily(FamilyObj(s)); return KnuthBendixRewritingSystem(fam,wordord); end); InstallOtherMethod(KnuthBendixRewritingSystem, "for an fp monoid and an order on the family of words of the underlying free monoid", true, [IsFpMonoid, IsOrdering], 0, function(m,wordord) local kbrws,fam; fam := ElementsFamily(FamilyObj(m)); return KnuthBendixRewritingSystem(fam,wordord); end); InstallOtherMethod(KnuthBendixRewritingSystem, "for an fp semigroup and a function", true, [IsFpSemigroup, IsFunction], 0, function(s,lt) local wordord,fam; wordord := OrderingByLessThanOrEqualFunctionNC(ElementsFamily (FamilyObj(FreeSemigroupOfFpSemigroup(s))),lt,[IsReductionOrdering]); fam := ElementsFamily(FamilyObj(s)); return KnuthBendixRewritingSystem(fam,wordord); end); InstallOtherMethod(KnuthBendixRewritingSystem, "for an fp monoid and a function", true, [IsFpMonoid, IsFunction], 0, function(m,lt) local wordord,fam; wordord := OrderingByLessThanOrEqualFunctionNC(ElementsFamily (FamilyObj(FreeMonoidOfFpMonoid(m))),lt,[IsReductionOrdering]); fam := ElementsFamily(FamilyObj(m)); return KnuthBendixRewritingSystem(fam,wordord); end); ############################################################################# ## #M KnuthBendixRewritingSystem() ## ## Create the a KB rewriting system for the fp monoid using the ## shortlex order. ## InstallOtherMethod(KnuthBendixRewritingSystem, "for an fp monoid", true, [IsFpMonoid], 0, function(m) return KnuthBendixRewritingSystem(m, ShortLexOrdering(ElementsFamily(FamilyObj( FreeMonoidOfFpMonoid(m))))); end); InstallOtherMethod(KnuthBendixRewritingSystem, "for an fp semigroup", true, [IsFpSemigroup], 0, function(s) return KnuthBendixRewritingSystem(s, ShortLexOrdering(ElementsFamily(FamilyObj( FreeSemigroupOfFpSemigroup(s))))); end); ############################################################################# ## #M MonoidOfRewritingSystem() ## ## for a Knuth Bendix Rewriting System ## returns the monoid of the rewriting system ## InstallMethod(MonoidOfRewritingSystem, "for a Knuth Bendix rewriting system", true, [IsRewritingSystem and IsBuiltFromMonoid], 0, function(kbrws) local fam; fam := FamilyForRewritingSystem(kbrws); return CollectionsFamily(fam)!.wholeMonoid; end); ############################################################################# ## #M SemigroupOfRewritingSystem() ## ## for a Knuth Bendix Rewriting System ## returns the semigroup of the rewriting system ## InstallMethod(SemigroupOfRewritingSystem, "for a Knuth Bendix rewriting system", true, [IsRewritingSystem and IsBuiltFromSemigroup], 0, function(kbrws) local fam; fam := FamilyForRewritingSystem(kbrws); return CollectionsFamily(fam)!.wholeSemigroup; end); ############################################################################# ## #M Rules() ## ## for a Knuth Bendix Rewriting System ## returns the set of rules of the rewriting system ## InstallMethod(Rules, "for a Knuth Bendix rewriting system", true, [IsKnuthBendixRewritingSystem and IsKnuthBendixRewritingSystemRep], 0, function(kbrws) local fam; fam:=kbrws!.freefam; return List(kbrws!.tzrules, i->[AssocWordByLetterRep(fam,i[1]),AssocWordByLetterRep(fam,i[2])]); end); ############################################################################# ## #M TzRules() ## ## for a Knuth Bendix Rewriting System ## returns the set of rules of the rewriting system in compact form ## InstallMethod(TzRules,"for a Knuth Bendix rewriting system", true, [IsKnuthBendixRewritingSystem and IsKnuthBendixRewritingSystemRep], 0, function(kbrws) local fam; return List(kbrws!.tzrules,i->[ShallowCopy(i[1]),ShallowCopy(i[2])]); end); ############################################################################# ## #A OrderingOfRewritingSystem() ## ## for a rewriting system rws ## returns the order used by the rewriting system ## InstallMethod(OrderingOfRewritingSystem, "for a Knuth Bendix rewriting system", true, [IsKnuthBendixRewritingSystem and IsKnuthBendixRewritingSystemRep], 0, function(kbrws) return kbrws!.ordering; end); ############################################################################# ## #A FamilyForRewritingSystem() ## ## for a rewriting system rws ## InstallMethod(FamilyForRewritingSystem, "for a Knuth Bendix rewriting system", true, [IsKnuthBendixRewritingSystem and IsKnuthBendixRewritingSystemRep], 0, function(kbrws) return kbrws!.family; end); ############################################################################ ## #A ViewObj() ## ## InstallMethod(ViewObj, "for a Knuth Bendix rewriting system", true, [IsKnuthBendixRewritingSystem and IsBuiltFromMonoid], 0, function(kbrws) Print("Knuth Bendix Rewriting System for "); Print(MonoidOfRewritingSystem(kbrws)); Print(" with rules \n"); Print(Rules(kbrws)); end); InstallMethod(ViewObj, "for a Knuth Bendix rewriting system", true, [IsKnuthBendixRewritingSystem and IsBuiltFromSemigroup], 0, function(kbrws) Print("Knuth Bendix Rewriting System for "); Print(SemigroupOfRewritingSystem(kbrws)); Print(" with rules \n"); Print(Rules(kbrws)); end); ############################################################################### ## #M ShallowCopy ## InstallMethod( ShallowCopy, "for a Knuth Bendix rewriting system", true, [IsKnuthBendixRewritingSystem and IsKnuthBendixRewritingSystemRep], 0, kbrws -> Objectify( Subtype( TypeObj(kbrws), IsMutable ), rec( family := kbrws!.family, reduced := false, tzrules:= StructuralCopy(kbrws!.tzrules), pairs2check:= [], ordering :=kbrws!.ordering))); ############################################################################### ## #M \= ## InstallMethod( \=, "for two Knuth-Bendix rewriting systems", IsIdenticalObj, [IsKnuthBendixRewritingSystem and IsKnuthBendixRewritingSystemRep, IsKnuthBendixRewritingSystem and IsKnuthBendixRewritingSystemRep],0, function(rws1,rws2) return rws1!.family=rws2!.family and IsSubset(rws1!.tzrules,rws2!.tzrules) and IsSubset(rws2!.tzrules,rws1!.tzrules) and rws1!.ordering=rws2!.ordering; end); ############################################################################# ## #E gap-4r6p5/lib/field.gi0000644000175000017500000011076012172557252013320 0ustar billbill############################################################################# ## #W field.gi GAP library Martin Schönert ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains generic methods for division rings. ## ############################################################################# ## #M DivisionRingByGenerators( ) . . . . . . . . . . for a collection #M DivisionRingByGenerators( , ) . . for div.ring and collection ## InstallOtherMethod( DivisionRingByGenerators, "for a collection", [ IsCollection ], coll -> DivisionRingByGenerators( FieldOverItselfByGenerators( [ One( Representative( coll ) ) ] ), coll ) ); InstallMethod( DivisionRingByGenerators, "for a division ring, and a collection", IsIdenticalObj, [ IsDivisionRing, IsCollection ], function( F, gens ) local D; D:= Objectify( NewType( FamilyObj( gens ), IsField and IsAttributeStoringRep ), rec() ); SetLeftActingDomain( D, F ); SetGeneratorsOfDivisionRing( D, AsList( gens ) ); return D; end ); ############################################################################# ## #M FieldOverItselfByGenerators( ) ## InstallMethod( FieldOverItselfByGenerators, "for a collection", [ IsCollection ], function( gens ) local F; if IsEmpty( gens ) then Error( "need at least one element" ); fi; F:= Objectify( NewType( FamilyObj( gens ), IsField and IsAttributeStoringRep ), rec() ); SetLeftActingDomain( F, F ); SetGeneratorsOfDivisionRing( F, gens ); return F; end ); ############################################################################# ## #M DefaultFieldByGenerators( ) . . . . . . . . . . for a collection ## InstallMethod( DefaultFieldByGenerators, "for a collection", [ IsCollection ], DivisionRingByGenerators ); ############################################################################# ## #F Field( , ... ) . . . . . . . . . field generated by a list of elements #F Field( [ , ... ] ) #F Field( , [ , ... ] ) ## InstallGlobalFunction( Field, function ( arg ) local F; # field containing the elements of , result # special case for one square matrix if Length(arg) = 1 and IsMatrix( arg[1] ) and Length( arg[1] ) = Length( arg[1][1] ) then F := FieldByGenerators( arg ); # special case for list of elements elif Length(arg) = 1 and IsList(arg[1]) then F := FieldByGenerators( arg[1] ); # special case for subfield and generators elif Length(arg) = 2 and IsField(arg[1]) then F := FieldByGenerators( arg[1], arg[2] ); # other cases else F := FieldByGenerators( arg ); fi; # return the field return F; end ); ############################################################################# ## #F DefaultField( , ... ) . . . . . default field containing a collection ## InstallGlobalFunction( DefaultField, function ( arg ) local F; # field containing the elements of , result # special case for one square matrix if Length(arg) = 1 and IsMatrix( arg[1] ) and Length( arg[1] ) = Length( arg[1][1] ) then F := DefaultFieldByGenerators( arg ); # special case for list of elements elif Length(arg) = 1 and IsList(arg[1]) then F := DefaultFieldByGenerators( arg[1] ); # other cases else F := DefaultFieldByGenerators( arg ); fi; # return the default field return F; end ); ############################################################################# ## #F Subfield( , ) . . . . . . . subfield of generated by #F SubfieldNC( , ) ## InstallGlobalFunction( Subfield, function( F, gens ) local S; if IsEmpty( gens ) then return PrimeField( F ); elif IsHomogeneousList( gens ) and IsIdenticalObj( FamilyObj( F ), FamilyObj( gens ) ) and ForAll( gens, g -> g in F ) then S:= FieldByGenerators( LeftActingDomain( F ), gens ); SetParent( S, F ); return S; fi; Error( " must be a list of elements in " ); end ); InstallGlobalFunction( SubfieldNC, function( F, gens ) local S; if IsEmpty( gens ) then S:= Objectify( NewType( FamilyObj( F ), IsDivisionRing and IsAttributeStoringRep ), rec() ); SetLeftActingDomain( S, F ); SetGeneratorsOfDivisionRing( S, AsList( gens ) ); else S:= DivisionRingByGenerators( LeftActingDomain( F ), gens ); fi; SetParent( S, F ); return S; end ); ############################################################################# ## #M ClosureDivisionRing( , ) . . . . . . . . . closure with an element ## InstallMethod( ClosureDivisionRing, "for a division ring and a scalar", IsCollsElms, [ IsDivisionRing, IsScalar ], function( D, d ) # if possible test if the element lies in the division ring already, if HasGeneratorsOfDivisionRing( D ) and d in GeneratorsOfDivisionRing( D ) then return D; # otherwise make a new division ring else return DivisionRingByGenerators( LeftActingDomain( D ), Concatenation( GeneratorsOfDivisionRing( D ), [ d ] ) ); fi; end ); InstallMethod( ClosureDivisionRing, "for a division ring containing the whole family, and a scalar", IsCollsElms, [ IsDivisionRing and IsWholeFamily, IsScalar ], SUM_FLAGS, # we can't be better than this function( D, d ) return D; end ); ############################################################################# ## #M ClosureDivisionRing( , ) . . . . . . . . closure of division ring ## InstallMethod( ClosureDivisionRing, "for division ring and collection of elements", IsIdenticalObj, [ IsDivisionRing, IsCollection ], function( D, C ) local d; # one generator if IsDivisionRing( C ) then if not IsSubset( LeftActingDomain( D ), LeftActingDomain( C ) ) then C:= AsDivisionRing( Intersection( LeftActingDomain( C ), LeftActingDomain( D ) ), C ); fi; C:= GeneratorsOfDivisionRing( C ); elif not IsList( C ) then TryNextMethod(); fi; for d in C do D:= ClosureDivisionRing( D, d ); od; return D; end ); InstallMethod( ClosureDivisionRing, "for division ring and empty list", [ IsDivisionRing, IsList and IsEmpty ], function( D, empty ) return D; end ); ############################################################################# ## #M ViewString( ) . . . . . . . . . . . . . . . . . . . . . . view a field ## InstallMethod( ViewString, "for a field", [ IsField ], function( F ) if HasSize( F ) and IsInt( Size( F ) ) then return Concatenation("" ); else return Concatenation( "" ); fi; end ); ############################################################################# ## #M PrintObj( ) . . . . . . . . . . . . . . . . . . . . . . print a field ## InstallMethod( PrintObj, "for a field with known generators", [ IsField and HasGeneratorsOfField ], function( F ) if IsIdenticalObj(F,LeftActingDomain(F)) or IsPrimeField( LeftActingDomain( F ) ) then Print( "Field( ", GeneratorsOfField( F ), " )" ); elif F = LeftActingDomain( F ) then Print( "FieldOverItselfByGenerators( ", GeneratorsOfField( F ), " )" ); else Print( "AsField( ", LeftActingDomain( F ), ", Field( ", GeneratorsOfField( F ), " ) )" ); fi; end ); InstallMethod( PrintObj, "for a field", [ IsField ], function( F ) if IsPrimeField( LeftActingDomain( F ) ) then Print( "Field( ... )" ); elif F = LeftActingDomain( F ) then Print( "AsField( ~, ... )" ); else Print( "AsField( ", LeftActingDomain( F ), ", ... )" ); fi; end ); ############################################################################# ## #M IsTrivial( ) . . . . . . . . . . . . . . . . . . for a division ring ## InstallMethod( IsTrivial, "for a division ring", [ IsDivisionRing ], ReturnFalse ); ############################################################################# ## #M PrimeField( ) . . . . . . . . . . . . . . . . . . for a division ring ## InstallMethod( PrimeField, "for a division ring", [ IsDivisionRing ], function( F ) local P; P:= Field( One( F ) ); UseSubsetRelation( F, P ); SetIsPrimeField( P, true ); return P; end ); InstallMethod( PrimeField, "for a prime field", [ IsField and IsPrimeField ], IdFunc ); ############################################################################# ## #M IsPrimeField( ) . . . . . . . . . . . . . . . . . for a division ring ## InstallMethod( IsPrimeField, "for a division ring", [ IsDivisionRing ], F -> DegreeOverPrimeField( F ) = 1 ); ############################################################################# ## #M IsNumberField( ) . . . . . . . . . . . . . . . . . . . . for a field ## InstallMethod( IsNumberField, "for a field", [ IsField ], F -> Characteristic( F ) = 0 and IsInt( DegreeOverPrimeField( F ) ) ); ############################################################################# ## #M IsAbelianNumberField( ) . . . . . . . . . . . . . . . . . for a field ## InstallMethod( IsAbelianNumberField, "for a field", [ IsField ], F -> IsNumberField( F ) and IsCommutative( GaloisGroup( AsField( PrimeField( F ), F ) ) ) ); ############################################################################# ## #M IsCyclotomicField( ) . . . . . . . . . . . . . . . . . . for a field ## InstallMethod( IsCyclotomicField, "for a field", [ IsField ], F -> IsAbelianNumberField( F ) and Conductor( F ) = DegreeOverPrimeField( F ) ); ############################################################################# ## #M IsNormalBasis( ) . . . . . . . . . . . . . for a basis (of a field) ## InstallMethod( IsNormalBasis, "for a basis of a field", [ IsBasis ], function( B ) local vectors; if not IsField( UnderlyingLeftModule( B ) ) then Error( " must be a basis of a field" ); fi; vectors:= BasisVectors( B ); return Set( vectors ) = Set( Conjugates( UnderlyingLeftModule( B ), vectors[1] ) ); end ); ############################################################################# ## #M GeneratorsOfDivisionRing( ) . . . . . . . . . . . . for a prime field ## InstallMethod( GeneratorsOfDivisionRing, "for a prime field", [ IsField and IsPrimeField ], F -> [ One( F ) ] ); ############################################################################# ## #M DegreeOverPrimeField( ) . . . . . . . . . . . . . . for a prime field ## InstallImmediateMethod( DegreeOverPrimeField, IsPrimeField, 20, F -> 1 ); ############################################################################# ## #M NormalBase( ) . . . . . . . . . . for a field in characteristic zero #M NormalBase( , ) . . . . . . for a field in characteristic zero ## ## For fields in characteristic zero, a normal basis is computed ## as described on p.~65~f.~in~\cite{Art68}. ## Let $\Phi$ denote the polynomial of the field extension $L/L^{\prime}$, ## $\Phi^{\prime}$ its derivative and $\alpha$ one of its roots; ## then for all except finitely many elements $z \in L^{\prime}$, ## the conjugates of $\frac{\Phi(z)}{(z-\alpha)\cdot\Phi^{\prime}(\alpha)}$ ## form a normal basis of $L/L^{\prime}$. ## ## When `NormalBase' is called for a field in characteristic zero and ## an element , ## $z$ is chosen as , $ + 1$, $ + 2$, \ldots, ## until a normal basis is found. ## The default of is the identity of . ## InstallMethod( NormalBase, "for a field (in characteristic zero)", [ IsField ], F -> NormalBase( F, One( F ) ) ); InstallMethod( NormalBase, "for a field (in characteristic zero), and a scalar", [ IsField, IsScalar ], function( F, z ) local alpha, poly, i, val, normal; # Check the arguments. if Characteristic( F ) <> 0 then TryNextMethod(); elif not z in F then Error( " must be an element in " ); fi; # Get a primitive element `alpha'. alpha:= PrimitiveElement( F ); # Construct the polynomial # $\prod_{\sigma\in `Gal( alpha )'\setminus \{1\} } (x-\sigma(`alpha') ) # for the primitive element `alpha'. poly:= [ 1 ]; for i in Difference( Conjugates( F, alpha ), [ alpha ] ) do poly:= ProductCoeffs( poly, [ -i, 1 ] ); #T ? od; # For the denominator, evaluate `poly' at `a'. val:= Inverse( ValuePol( poly, alpha ) ); # There are only finitely many values `x' in the subfield # for which `poly(x) * val' is not an element of a normal basis. repeat normal:= Conjugates( F, ValuePol( poly, z ) * val ); z:= z + 1; until RankMat( List( normal, COEFFS_CYC ) ) = Dimension( F ); # Return the result. return normal; end ); ############################################################################# ## #M PrimitiveElement( ) . . . . . . . . . . . . . . . for a division ring ## InstallMethod( PrimitiveElement, "for a division ring", [ IsDivisionRing ], function( D ) D:= GeneratorsOfDivisionRing( D ); if Length( D ) = 1 then return D[1]; else TryNextMethod(); fi; end ); ############################################################################# ## #M Representative( ) . . . . . for a division ring with known generators ## InstallMethod( Representative, "for a division ring with known generators", [ IsDivisionRing and HasGeneratorsOfDivisionRing ], RepresentativeFromGenerators( GeneratorsOfDivisionRing ) ); ############################################################################# ## #M Enumerator( ) . . . . . . . . . . elements of a (finite) prime field #M EnumeratorSorted( ) . . . . . . . elements of a (finite) prime field ## ## We install a special method only for (finite) prime fields, ## since the other cases are handled by the vector space methods. ## EnumeratorOfPrimeField := function( F ) local one; one:= One( F ); if Size( F ) <= MAXSIZE_GF_INTERNAL then return AsSSortedListList( List( [ 0 .. Size( F ) - 1 ], i -> i * one ) ); elif IsZmodnZObj( one ) then return EnumeratorOfZmodnZ( F ); fi; TryNextMethod(); end; InstallMethod( Enumerator, "for a finite prime field", [ IsField and IsPrimeField and IsFinite ], EnumeratorOfPrimeField ); InstallMethod( EnumeratorSorted, "for a finite prime field", [ IsField and IsPrimeField and IsFinite ], EnumeratorOfPrimeField ); InstallMethod( AsList, "for a finite prime field", [ IsField and IsPrimeField and IsFinite ], F -> AsList( Enumerator( F ) ) ); ############################################################################# ## #M IsSubset( , ) . . . . . . . . . . . . . . for two division rings ## ## We have to be careful not to run into an infinite recursion in the case ## that is equal to its left acting domain. ## Also we must be aware of situations where the left acting domains are ## in a family different from that of the fields themselves, ## for example could be given as a field over a field that is really ## a subset of , whereas the left acting domain of is not a subset ## of . ## BindGlobal( "DivisionRing_IsSubset", function( D, F ) local CF; # Special case for when F equals the cyclotomics (and hence is infinite # dimensional over its left acting domain). if IsIdenticalObj(F, Cyclotomics) then return IsIdenticalObj(D, Cyclotomics); fi; CF:= LeftActingDomain( F ); if not IsSubset( D, GeneratorsOfDivisionRing( F ) ) then return false; elif IsSubset( LeftActingDomain( D ), CF ) or IsPrimeField( CF ) then return true; elif FamilyObj( F ) = FamilyObj( CF ) then return IsSubset( D, CF ); else CF:= AsDivisionRing( PrimeField( CF ), CF ); return IsSubset( D, List( GeneratorsOfDivisionRing( CF ), x -> x * One( F ) ) ); fi; end ); InstallMethod( IsSubset, "for two division rings", IsIdenticalObj, [ IsDivisionRing, IsDivisionRing ], DivisionRing_IsSubset ); ############################################################################# ## #M \=( , ) . . . . . . . . . . . . . . . . . for two division rings ## InstallMethod( \=, "for two division rings", IsIdenticalObj, [ IsDivisionRing, IsDivisionRing ], function( D, F ) return DivisionRing_IsSubset( D, F ) and DivisionRing_IsSubset( F, D ); end ); ############################################################################# ## #M AsDivisionRing( ) . . . . . . . . . . . . . . . . . for a collection ## InstallMethod( AsDivisionRing, "for a collection", [ IsCollection ], function( C ) local one, F; # A division ring contains at least two elements. if IsEmpty( C ) or IsTrivial( C ) then return fail; fi; # Construct the prime field. one:= One( Representative( C ) ); if one = fail then return fail; fi; F:= FieldOverItselfByGenerators( [ one ] ); # Delegate to the two-argument version. return AsDivisionRing( F, C ); end ); ############################################################################# ## #M AsDivisionRing( , ) . . . . for a division ring, and a collection ## InstallMethod( AsDivisionRing, "for a division ring, and a collection", IsIdenticalObj, [ IsDivisionRing, IsCollection ], function( F, C ) local D; if not IsSubset( C, F ) then return fail; fi; D:= DivisionRingByGenerators( F, C ); if D <> C then return fail; fi; return D; end ); ############################################################################# ## #M AsDivisionRing( , ) . . . . . . . . . . . for two division rings ## InstallMethod( AsDivisionRing, "for two division rings", IsIdenticalObj, [ IsDivisionRing, IsDivisionRing ], function( F, D ) local E; if F = LeftActingDomain( D ) then return D; elif not IsSubset( D, F ) then return fail; fi; E:= DivisionRingByGenerators( F, GeneratorsOfDivisionRing( D ) ); UseIsomorphismRelation( D, E ); UseSubsetRelation( D, E ); return E; end ); ############################################################################# ## #M AsLeftModule( , ) . . . . . . . . . . . for two division rings ## ## View the division ring as vector space over the division ring . ## InstallMethod( AsLeftModule, "for two division rings", IsIdenticalObj, [ IsDivisionRing, IsDivisionRing ], AsDivisionRing ); ############################################################################# ## #M Conjugates( , ) . . . . . . . . . . conjugates of a field element #M Conjugates( ) . . . . . . . . . . . . . conjugates of a field element ## InstallMethod( Conjugates, "for a scalar (delegate to version with default field)", [ IsScalar ], z -> Conjugates( DefaultField( z ), z ) ); InstallMethod( Conjugates, "for a field and a scalar (delegate to version with two fields)", IsCollsElms, [ IsField, IsScalar ], function( F, z ) return Conjugates( F, LeftActingDomain( F ), z ); end ); ############################################################################# ## #M Conjugates( , , ) . . for a field elm. (use `TracePolynomial') ## InstallMethod( Conjugates, "for two fields and a scalar (call `TracePolynomial')", IsCollsXElms, [ IsField, IsField, IsScalar ], function( L, K, z ) local pol, lin, conj, mult, i; # Check whether `Conjugates' is allowed to call `MinimalPolynomial'. if IsFieldControlledByGaloisGroup( L ) then TryNextMethod(); fi; # Compute the roots in `L' of the minimal polynomial of `z' over `K'. pol:= MinimalPolynomial( K, z ); lin:= List( Filtered( Factors( L, pol ), x -> DegreeOfLaurentPolynomial( x ) = 1 ), CoefficientsOfUnivariatePolynomial ); lin:= List( lin, x -> AdditiveInverse( lin[1] / lin[2] ) ); # Take the roots with the appropriate multiplicity. conj:= []; mult:= DegreeOverPrimeField( L ) / DegreeOverPrimeField( K ); mult:= mult / DegreeOfLaurentPolynomial( pol ); for i in [ 1 .. mult ] do Append( conj, lin ); od; return conj; end ); ############################################################################# ## #M Conjugates( , , ) . . . for a field element (use `GaloisGroup') ## InstallMethod( Conjugates, "for two fields and a scalar (call `GaloisGroup')", IsCollsXElms, [ IsFieldControlledByGaloisGroup, IsField, IsScalar ], function( L, K, z ) local cnjs, # conjugates of in , result aut; # automorphism of # Check the arguments. if not z in L then Error( " must lie in " ); fi; # Compute the conjugates simply by applying all the automorphisms. cnjs:= []; for aut in GaloisGroup( AsField( L, K ) ) do Add( cnjs, z ^ aut ); od; # Return the conjugates. return cnjs; end ); ############################################################################# ## #M Norm( , ) . . . . . . . . . . . . . . . . norm of a field element #M Norm( ) . . . . . . . . . . . . . . . . . . . norm of a field element ## InstallMethod( Norm, "for a scalar (delegate to version with default field)", [ IsScalar ], z -> Norm( DefaultField( z ), z ) ); InstallMethod( Norm, "for a field and a scalar (delegate to version with two fields)", IsCollsElms, [ IsField, IsScalar ], function( F, z ) return Norm( F, LeftActingDomain( F ), z ); end ); ############################################################################# ## #M Norm( , , ) . . . . norm of a field element (use `Conjugates') ## InstallMethod( Norm, "for two fields and a scalar (use `Conjugates')", IsCollsXElms, [ IsFieldControlledByGaloisGroup, IsField, IsScalar ], function( L, K, z ) return Product( Conjugates( L, K, z ) ); end ); ############################################################################# ## #M Norm( , , ) . . . norm of a field element (use the trace pol.) ## InstallMethod( Norm, "for two fields and a scalar (use the trace pol.)", IsCollsXElms, [ IsField, IsField, IsScalar ], function( L, K, z ) local coeffs; coeffs:= CoefficientsOfUnivariatePolynomial( TracePolynomial( L, K, z, 1 ) ); return (-1)^(Length( coeffs )-1) * coeffs[1]; end ); ############################################################################# ## #M Trace( ) . . . . . . . . . . . . . . . . . trace of a field element #M Trace( , ) . . . . . . . . . . . . . . . trace of a field element ## InstallMethod( Trace, "for a scalar (delegate to version with default field)", [ IsScalar ], z -> Trace( DefaultField( z ), z ) ); InstallMethod( Trace, "for a field and a scalar (delegate to version with two fields)", IsCollsElms, [ IsField, IsScalar ], function( F, z ) return Trace( F, LeftActingDomain( F ), z ); end ); ############################################################################# ## #M Trace( , , ) . . . trace of a field element (use `Conjugates') ## InstallMethod( Trace, "for two fields and a scalar (use `Conjugates')", IsCollsXElms, [ IsFieldControlledByGaloisGroup, IsField, IsScalar ], function( L, K, z ) return Sum( Conjugates( L, K, z ) ); end ); ############################################################################# ## #M Trace( , , ) . . trace of a field element (use the trace pol.) ## InstallMethod( Trace, "for two fields and a scalar (use the trace pol.)", IsCollsXElms, [ IsField, IsField, IsScalar ], function( L, K, z ) local coeffs; coeffs:= CoefficientsOfUnivariatePolynomial( TracePolynomial( L, K, z, 1 ) ); return AdditiveInverse( coeffs[ Length( coeffs ) - 1 ] ); end ); ############################################################################# ## #M MinimalPolynomial( , , ) ## ## If the default field of knows how to get the Galois group then ## we compute the conjugates and from them the minimal polynomial. ## Otherwise we solve an equation system. ## ## Note that the family predicate `IsCollsElmsX' expresses that may lie ## in an extension field of ; ## this guarantees that the method is *not* applicable for the case that ## is a matrix. ## InstallMethod( MinimalPolynomial, "for field, scalar, and indet. number", IsCollsElmsX, [ IsField, IsScalar,IsPosInt ], function( F, z, ind ) local L, coe, deg, zero, con, i, B, pow, mat, MB; # Construct a basis of a field in which the computations happen. # (This need not be the smallest such field.) L:= DefaultField( z ); if IsFieldControlledByGaloisGroup( L ) then # We may call `Conjugates'. coe:= [ One( F ) ]; deg:= 0; zero:= Zero( F ); for con in Conjugates( Field( F, [ z ] ), z ) do coe[deg+2]:= coe[deg+1]; for i in [ deg+1, deg .. 2 ] do coe[i]:= coe[i-1] - con * coe[i]; od; coe[1]:= zero - con * coe[1]; deg:= deg + 1; od; else # Solve an equation system. B:= Basis( L ); # Compute coefficients of the powers of `z' until # the rows are linearly dependent. pow:= One( F ); coe:= Coefficients( B, pow ); mat:= [ coe ]; MB:= MutableBasis( F, [ coe ] ); repeat CloseMutableBasis( MB, coe ); pow:= pow * z; coe:= Coefficients( B, pow ); Add( mat, coe ); until IsContainedInSpan( MB, coe ); # The coefficients of the minimal polynomial # are given by the linear relation. coe:= NullspaceMat( mat )[1]; coe:= Inverse( coe[ Length( coe ) ] ) * coe; fi; # Construct the polynomial. return UnivariatePolynomial( F, coe, ind ); end ); ############################################################################# ## #M TracePolynomial( , , ) #M TracePolynomial( , , , ) ## InstallMethod( TracePolynomial, "using minimal polynomial", IsCollsXElmsX, [ IsField, IsField, IsScalar, IsPosInt ], function( L, K, z, ind ) local minpol, mult; minpol:= MinimalPolynomial( K, z, ind ); mult:= DegreeOverPrimeField( L ) / DegreeOverPrimeField( K ); mult:= mult / DegreeOfLaurentPolynomial( minpol ); return minpol ^ mult; end ); InstallMethod( TracePolynomial, "add default indet. 1", IsCollsXElms, [ IsField, IsField, IsScalar ], function( L, K, z ) return TracePolynomial( L, K, z, 1 ); end ); ############################################################################# ## #M CharacteristicPolynomial( , , ) #M CharacteristicPolynomial( , , , ) ## InstallOtherMethod( CharacteristicPolynomial, "call `TracePolynomial'", IsCollsXElms, [ IsField, IsField, IsScalar ], function( L, K, z ) return TracePolynomial( L, K, z, 1 ); end ); InstallOtherMethod( CharacteristicPolynomial, "call `TracePolynomial'", IsCollsXElmsX, [ IsField, IsField, IsScalar, IsPosInt ], TracePolynomial ); ############################################################################# ## #M NiceFreeLeftModuleInfo( ) #M NiceVector( , ) #M UglyVector( , ) ## InstallHandlingByNiceBasis( "IsFieldElementsSpace", rec( detect := function( F, gens, V, zero ) return IsScalarCollection( V ) and IsIdenticalObj( FamilyObj( F ), FamilyObj( V ) ) and IsDivisionRing( F ); end, NiceFreeLeftModuleInfo := function( V ) local lad, gens; # Compute the default field of the vector space generators, # and a basis of this field (over the left acting domain of `V'). lad:= LeftActingDomain( V ); if not IsIdenticalObj( FamilyObj( V ), FamilyObj( lad ) ) then TryNextMethod(); fi; return Basis( AsField( lad, ClosureField( lad, GeneratorsOfLeftModule( V ) ) ) ); end, NiceVector := function( V, v ) return Coefficients( NiceFreeLeftModuleInfo( V ), v ); end, UglyVector := function( V, r ) local B; B:= NiceFreeLeftModuleInfo( V ); if Length( r ) <> Length( B ) then return fail; fi; return LinearCombination( B, r ); end ) ); ############################################################################# ## #M Quotient( , , ) . . . . . . . . quotient of elements in a field ## InstallMethod( Quotient, "for a division ring, and two ring elements", IsCollsElmsElms, [ IsDivisionRing, IsRingElement, IsRingElement ], function ( F, r, s ) return r/s; end ); ############################################################################# ## #M IsUnit( , ) . . . . . . . . . . check for being a unit in a field ## InstallMethod( IsUnit, "for a division ring, and a ring element", IsCollsElms, [ IsDivisionRing, IsRingElement ], function ( F, r ) return not IsZero( r ) and r in F; end ); ############################################################################# ## #M Units( ) ## InstallMethod( Units, "for a division ring", [ IsDivisionRing ], function( D ) if IsFinite( D ) then return Difference( AsList( D ), [ Zero( D ) ] ); else TryNextMethod(); fi; end ); ############################################################################# ## #M PrimitiveRoot( ) . . . . . . . . . . . . for finite prime field ## ## For a fields of prime order $p$, the multiplicative group corresponds to ## the group of residues modulo $p$, via `Int'. ## A primitive root is obtained as `PrimitiveRootMod( $p$ )' times the ## identity of . ## InstallMethod( PrimitiveRoot, "for a finite prime field", [ IsField and IsFinite ], function( F ) if not IsPrimeField( F ) then TryNextMethod(); fi; return PrimitiveRootMod( Size( F ) ) * One( F ); end ); ############################################################################# ## #M IsAssociated( , , ) . . . . . . check associatedness in a field ## InstallMethod( IsAssociated, "for a division ring, and two ring elements", IsCollsElmsElms, [ IsDivisionRing, IsRingElement, IsRingElement ], function ( F, r, s ) return (r = Zero( F ) ) = (s = Zero( F ) ); end ); ############################################################################# ## #M StandardAssociate( , ) . . . . . . . standard associate in a field ## InstallMethod( StandardAssociate, "for a division ring and a ring element", IsCollsElms, [ IsDivisionRing, IsScalar ], function ( R, r ) if r = Zero( R ) then return Zero( R ); else return One( R ); fi; end ); ############################################################################# ## #M StandardAssociateUnit( , ) ## InstallMethod( StandardAssociateUnit, "for a division ring and a ring element", IsCollsElms, [ IsDivisionRing, IsScalar ], function ( R, r ) if r = Zero( R ) then return One( R ); else return r^-1; fi; end ); ############################################################################# ## #M IsIrreducibleRingElement( , ) ## InstallMethod(IsIrreducibleRingElement,"for field and ring element", IsCollsElms, [ IsDivisionRing, IsScalar ],0, function ( F, r ) if not r in F then TryNextMethod(); fi; # field elements are either zero or a unit return false; end ); ############################################################################# ## ## Field homomorphisms ## ############################################################################# ## #M IsFieldHomomorphism( ) ## InstallMethod( IsFieldHomomorphism, [ IsGeneralMapping ], map -> IsRingHomomorphism( map ) and IsField( Source( map ) ) ); ############################################################################# ## #M KernelOfAdditiveGeneralMapping( ) . . for a field homomorphism ## InstallMethod( KernelOfAdditiveGeneralMapping, "for a field homomorphism", [ IsFieldHomomorphism ], #T higher rank? #T (is this method ever used?) function ( hom ) if ForAll( GeneratorsOfDivisionRing( Source( hom ) ), x -> IsZero( ImagesRepresentative( hom, x ) ) ) then return Source( hom ); else return TrivialSubadditiveMagmaWithZero( Source( hom ) ); fi; end ); ############################################################################# ## #M IsInjective( ) . . . . . . . . . . . . for a field homomorphism ## InstallMethod( IsInjective, "for a field homomorphism", [ IsFieldHomomorphism ], hom -> Size( KernelOfAdditiveGeneralMapping( hom ) ) = 1 ); ############################################################################# ## #M IsSurjective( ) . . . . . . . . . . . for a field homomorphism ## InstallMethod( IsSurjective, "for a field homomorphism", [ IsFieldHomomorphism ], function ( hom ) if IsFinite( Range( hom ) ) then return Size( Range( hom ) ) = Size( Image( hom ) ); else TryNextMethod(); fi; end ); ############################################################################# ## #M \=( , ) . . . . . . . . . comparison of field homomorphisms ## InstallMethod( \=, "for two field homomorphisms", IsIdenticalObj, [ IsFieldHomomorphism, IsFieldHomomorphism ], function ( hom1, hom2 ) # maybe the properties we already know determine the result if ( HasIsInjective( hom1 ) and HasIsInjective( hom2 ) and IsInjective( hom1 ) <> IsInjective( hom2 ) ) or ( HasIsSurjective( hom1 ) and HasIsSurjective( hom2 ) and IsSurjective( hom1 ) <> IsSurjective( hom2 ) ) then return false; # otherwise we must really test the equality else return Source( hom1 ) = Source( hom2 ) and Range( hom1 ) = Range( hom2 ) and ForAll( GeneratorsOfField( Source( hom1 ) ), elm -> Image(hom1,elm) = Image(hom2,elm) ); fi; end ); ############################################################################# ## #M ImagesSet( , ) . . images of a set under a field homomorphism ## InstallMethod( ImagesSet, "for field homomorphism and field", CollFamSourceEqFamElms, [ IsFieldHomomorphism, IsField ], function ( hom, elms ) elms:= FieldByGenerators( List( GeneratorsOfField( elms ), gen -> ImagesRepresentative( hom, gen ) ) ); UseSubsetRelation( Range( hom ), elms ); return elms; end ); ############################################################################# ## #M PreImagesElm( , ) . . . . . . . . . . . . preimage of an elm ## InstallMethod( PreImagesElm, "for field homomorphism and element", FamRangeEqFamElm, [ IsFieldHomomorphism, IsObject ], function ( hom, elm ) if IsInjective( hom ) = 1 then return [ PreImagesRepresentative( hom, elm ) ]; elif IsZero( elm ) then return Source( hom ); else return []; fi; end ); ############################################################################# ## #M PreImagesSet( , ) . . . . . . . . . . . . . preimage of a set ## InstallMethod( PreImagesSet, "for field homomorphism and field", CollFamRangeEqFamElms, [ IsFieldHomomorphism, IsField ], function ( hom, elms ) elms:= FieldByGenerators( List( GeneratorsOfField( elms ), gen -> PreImagesRepresentative( hom, gen ) ) ); UseSubsetRelation( Source( hom ), elms ); return elms; end ); ############################################################################# ## #E gap-4r6p5/lib/grpnames.gd0000644000175000017500000005676012172557252014055 0ustar billbill############################################################################# ## #W grpnames.gd Stefan Kohl ## Markus Püschel ## Sebastian Egner ## ## #Y Copyright (C) 2004 The GAP Group ## ## This file contains declarations of attributes, operations and functions ## related to the determination of structure descriptions for finite groups. ## ## It also includes comments from corresponding GAP3 code written by ## Markus Püschel and Sebastian Egner. ## ############################################################################# ## #A DirectFactorsOfGroup( ) . . . . . decomposition into a direct product ## ## ## ## ## ## A sorted list of factors [G1, .., Gr] such that ## G = G1 x .. x Gr and none of the Gi ## is a direct product. ## ## ## ## The following hold: ## ## (1) is a normal subgroup of . ## (2) <= ==> Size() <= Size(). ## (3) Size() > 1 unless = 1 and = 1. ## (4) = * .. * as the complex product. ## (5) $Gi \cap (G1 * .. * G_{i-1} * G_{i+1} * .. * Gr) = 1$. ## ## Factorization of a permutation group into a direct product ## ========================================================== ## ## Def.: Seien G1, .., Gr endliche Gruppen, dann ist ## G := (G1 x .. x Gr, *) eine Gruppe mit der Operation ## (g1, .., gr)*(h1, .., hr) := (g1 h1, .., gr hr). ## Wir sagen dann G ist das ("au"sere) direkte Produkt ## der Gruppen G1, .., Gr und schreiben G = G1 x .. x Gr. ## ## Lemma: Seien G1, .., Gr Normalteiler der endlichen Gruppe G ## mit den Eigenschaften ## (1) |G| = |G1| * .. * |Gr| ## (2) |Gi meet (Gi+1 * .. * Gr)| = 1 ## Dann ist G = G1 x .. x Gr. ## Bew.: M. Hall, Th. 2.5.2. ## ## Lemma: Seien G = G1 x .. x Gr = H1 x .. x Hs zwei Zerlegungen ## von G in direkt unzerlegbare Faktoren. Dann gilt ## (1) r = s ## (2) Es gibt ein Permutation p der Faktoren, so ## da"s G[i] ~= H[p(i)] f"ur alle i. ## Bew.: Satz von Krull-Remak-Schmidt, Huppert I. ## ## Statements needed for DirectFactorsGroup ## ======================================== ## ## Lemma: ## If G1, G2 are normal subgroups in G and (G1 meet G2) = 1 ## then G = G1 x G2 <==> |G| = |G1|*|G2|. ## Proof: ## "==>": trivial. ## "<==": Use G1*G2/G1 ~= G2/(G1 meet G2) = G2/1 ==> ## |G1*G2|/|G1| = |G2|/|1|. q.e.d. ## ## Remark: ## The normal subgroup lattice of G does not contain ## all the information needed for the normal subgroup lattice ## of G2 for a decomposition G = G1 x G2. However let ## G = G1 x .. x Gr be finest direct product decomposition ## then all Gi are normal subgroups in G. Thus all Gi occur in ## the set NormalSubgroups(G) and we may split G recursively ## without recomputing normal subgroup lattices for factors. ## ## Method to enumerate factorizations given the divisors: ## Consider a strictly increasing chain ## 1 < a1 < a2 < .. < a_n < A ## of positive divisors of an integer A. ## The task is to enumerate all pairs 1 <= i <= j <= n ## such that a_i*a_j = A. This is done by ## ## i := 1; ## j := n; ## while i <= j do ## while j > i and a_i*a_j > A do ## j := j-1; ## end while; ## if a_i*a_j = A then ## "found i <= j with a_i*a_j = A" ## end if; ## i := i+1; ## end while; ## ## which is based on the following fact: ## Lemma: ## Let i1 <= j1, i2 <= j2 be such that ## a_i1*a_j1 = a_i2*a_j2 = A, then ## i2 > i1 ==> j2 < j1. ## Proof: ## i2 > i1 ## ==> a_i2 > a_i1 by strictly increasing a's ## ==> a_i1*a_j1 = A = a_i2*a_j2 > a_i1*a_j2 by *a_j2 ## ==> a_j1 > a_j2 by /a_i1 ## ==> j1 > j2. q.e.d ## ## Now consider two strictly increasing chains ## 1 <= a1 < a2 < .. < a_n <= A ## 1 <= b1 < b2 < .. < b_m <= A ## of positive divisors of an integer A. ## The task is to enumerate all pairs i, j with ## 1 <= i <= n, 1 <= j <= m such that a_i*b_j = A. ## This is done by merging the two sequences into ## a single increasing sequence of pairs ## where which_i indicates where c_i is in the a-sequence ## and where it is in the b-sequence if any. The the ## linear algorithm above may be used. ## DeclareAttribute( "DirectFactorsOfGroup", IsGroup ); ############################################################################# ## #A SemidirectFactorsOfGroup( ) . decomposition into a semidirect product ## ## ## ## ## ## A list [[H1, N1], .., [Hr, Nr]] of all ## direct or semidirect decompositions with minimal H: ## G = Hi semidirect Ni and |Hi| = |Hj| ## is minimal with respect to all semidirect products. ## Note that this function also recognizes direct products. ## ## ## ## Literatur: ## [1] Huppert Bd. I, Springer 1983. ## [2] M. Hall: Theory of Groups. 2nd ed., ## Chelsea Publ. Co., 1979 NY. ## ## Zerlegung eines semidirekten Produkts, Grundlagen ## ================================================= ## ## Def.: Seien H, N Gruppen und f: H -> Aut(N) ein Gr.-Hom. ## Dann wird G := (H x N, *) eine Gruppe mit der Operation ## (h1, n1)*(h2, n2) := (h1 h2, f(h2)(n1)*n2). ## Wir nennen G das ("au"sere) semidirekte Produkt von H und N ## und schreiben G = H semidirect[f] N. ## ## Lemma1: ## Sei G eine endliche Gruppe, N ein Normalteiler und H eine ## Untergruppe von G mit den Eigenschaften ## (1) |H| * |N| = |G| und ## (2) |H meet N| = 1. ## Dann gibt es ein f mit G = H semidirect[f] N. ## Bew.: [2], Th. 6.5.3. ## ## Lemma2: ## Sei G = H semidirect[phi] N und h in H, n in N, dann ist auch ## G = H^(h n) semidirect[psi] N mit ## psi = inn_n o phi o inn_h^-1 o inn_n^-1. ## Bew.: ## 1. |H^(h n)| = |H| ==> |H^(h n)|*|N| = |G| und ## |H^(h n) meet N| = 1 <==> |H meet N| = 1, weil N normal ist. ## Daher ist G = H^(h n) semidirect[psi] N mit einem ## psi : H^(h n) -> Aut(N). ## 2. Das psi ist durch H und N eindeutig bestimmt. ## 3. Die Form von psi wie oben angegeben kann durch berechnen ## von psi(h)(n) nachgepr"uft werden. ## DeclareAttribute( "SemidirectFactorsOfGroup", IsGroup ); ############################################################################# ## #A DecompositionTypesOfGroup( ) . . descriptions of decomposition types #A DecompositionTypes( ) ## ## ## ## ## ## ## A list of all possible decomposition types of the group ## into direct/semidirect products of non-splitting factors.

## ## A decomposition type type is denoted by a specification ## of the form ## ::= ## ; cyclic group of prime power order ## | ["non-split", ] ; non-split extension; size annotated ## | ["x", , .., ] ; non-trivial direct product (ass., comm.) ## | [":", , ] ; non-direct, non-trivial split extension ## ]]> ## ## ## DeclareAttribute( "DecompositionTypesOfGroup", IsGroup ); DeclareSynonym( "DecompositionTypes", DecompositionTypesOfGroup ); ############################################################################# ## #P IsDihedralGroup( ) #A DihedralGenerators( ) ## ## ## ## ## ## ## Indicates whether the group G is a dihedral group. ## If it is, methods may set the attribute DihedralGenerators to ## [t,s], where t and s are two elements such ## that G = t, s | t^2 = s^n = 1, s^t = s^-1. ## ## ## DeclareProperty( "IsDihedralGroup", IsGroup ); DeclareAttribute( "DihedralGenerators", IsGroup ); ############################################################################# ## #P IsQuaternionGroup( ) #A QuaternionGenerators( ) ## ## ## ## ## ## ## Indicates whether the group G is a generalized quaternion group ## of size N = 2^(k+1), k >= 2. If it is, methods may set ## the attribute QuaternionGenerators to [t,s], ## where t and s are two elements such that G = ## t, s | s^(2^k) = 1, t^2 = s^(2^k-1), s^t = s^-1. ## ## ## DeclareProperty( "IsQuaternionGroup", IsGroup ); DeclareAttribute( "QuaternionGenerators", IsGroup ); ############################################################################# ## #P IsQuasiDihedralGroup( ) #A QuasiDihedralGenerators( ) ## ## ## ## ## ## ## Indicates whether the group G is a quasidihedral group ## of size N = 2^(k+1), k >= 2. If it is, methods may set ## the attribute QuasiDihedralGenerators to [t,s], ## where t and s are two elements such that G = ## t, s | s^(2^k) = t^2 = 1, s^t = s^(-1 + 2^(k-1)). ## ## ## DeclareProperty( "IsQuasiDihedralGroup", IsGroup ); DeclareAttribute( "QuasiDihedralGenerators", IsGroup ); ############################################################################# ## #P IsPSL( ) ## ## ## ## ## ## Indicates whether the group G is isomorphic to the projective ## special linear group PSL(n,q) for some integer n ## and some prime power q. If it is, methods may set the attribute ## ParametersOfGroupViewedAsPSL. ## ## ## DeclareProperty( "IsPSL", IsGroup ); ############################################################################# ## #A ParametersOfGroupViewedAsPSL #A ParametersOfGroupViewedAsSL #A ParametersOfGroupViewedAsGL ## ## triples (n,p,e) such that the group is isomorphic to PSL(n,p^e), SL(n,p^e) ## and GL(n,p^e) respectively ## ## ## ## ## ## ## ## ## ## DeclareAttribute( "ParametersOfGroupViewedAsPSL", IsGroup ); DeclareAttribute( "ParametersOfGroupViewedAsSL", IsGroup ); DeclareAttribute( "ParametersOfGroupViewedAsGL", IsGroup ); ############################################################################# ## #A AlternatingDegree . . . . degree of isomorphic natural alternating group #A SymmetricDegree . . . . . . degree of isomorphic natural symmetric group #A PSLDegree . . . . . . (one possible) degree of an isomorphic natural PSL #A PSLUnderlyingField . . (one possible) underlying field " " " #A SLDegree . . . . . . (one possible) degree of an isomorphic natural SL #A SLUnderlyingField . . (one possible) underlying field " " " #A GLDegree . . . . . . (one possible) degree of an isomorphic natural GL #A GLUnderlyingField . . (one possible) underlying field " " " ## ## ## ## ## ## ## ## ## ## ## ## ## ## DeclareAttribute( "AlternatingDegree", IsGroup ); DeclareAttribute( "SymmetricDegree", IsGroup ); DeclareAttribute( "PSLDegree", IsGroup ); DeclareAttribute( "PSLUnderlyingField", IsGroup ); DeclareAttribute( "SLDegree", IsGroup ); DeclareAttribute( "SLUnderlyingField", IsGroup ); DeclareAttribute( "GLDegree", IsGroup ); DeclareAttribute( "GLUnderlyingField", IsGroup ); ############################################################################# ## #F SizeGL( , ) #F SizeSL( , ) #F SizePSL( , ) ## ## ## ## ## ## ## ## Computes the size of the group GL(n,p^e), ## SL(n,p^e) or PSL(n,p^e), ## respectively. ## ## ## ## The following formulas are used: ## ## |GL(n, p, e)| = Product(p^(e n) - p^(e k) : k in [0..n-1]) ## |SL(n, p, e)| = |GL(n, p, e)| / (p^e - 1) ## |PSL(n, p, e)| = |SL(n, p, e)| / gcd(p^e - 1, n) ## DeclareGlobalFunction( "SizeGL" ); DeclareGlobalFunction( "SizeSL" ); DeclareGlobalFunction( "SizePSL" ); ############################################################################# ## #F LinearGroupParameters( ) ## ## ## ## ## ## Determines all parameters n >= 2, p prime, e >= 1, ## such that the given number is the size of one of the linear groups ## GL(n,p^e), SL(n,p^e) or ## PSL(n,p^e).

## A record with the fields npeGL, npeSL, npePSL is ## returned, which contains the lists of possible triples ## [n,p,e]. ## ## ## ## Lemma (o.B.): ## Es bezeichne ## ## gl(n, p, e) = Product(p^(e n) - p^(e k) : k in [0..n-1]) ## sl(n, p, e) = gl(n, p, e) / (p^e - 1) ## psl(n, p, e) = sl(n, p, e) / gcd(p^e - 1, n) ## ## die Gr"o"sen der Gruppen GL, SL, PSL mit den Parametern ## n, p, e. Dann gilt ## ## gl(n, p, e) = sl(n, p, e) <==> p^e = 2 ## sl(n, p, e) = psl(n, p, e) <==> gcd(p^e - 1, n) = 1 ## psl(n, p, e) = gl(n, p, e) <==> p^e = 2 ## ## und in diesen F"allen sind die dazugeh"origen Gruppen auch ## isomorph. Dar"uberhinaus existieren genau die folgenden ## sporadischen "Ubereinstimmungen ## ## psl(2, 2, 2) = psl(2, 5, 1) = 60 ; PSL(2, 4) ~= PSL(2, 5) ~= A5 ## psl(2, 7, 1) = psl(3, 2, 1) = 168 ; PSL(2, 7) ~= PSL(3, 2) ## psl(4, 2, 1) = psl(3, 2, 2) = 20160 ; PSL(4, 2) not~= PSL(3, 4) ## ## wobei in den ersten beiden F"allen die dazugeh"origen Gruppen ## isomorph sind, im letzten Fall aber nicht! Die Gruppen PSL(4, 2) ## und PSL(3, 4) sind "uber das Zentrum ihrer 2-Sylowgruppen ## unterscheidbar (Huppert: S.185). ## Es bezeichne Z1, Z2 die Zentren der 2-Sylowgruppen von PSL(4, 2) ## bzw. PSL(3, 4). Dann ist |Z1| = 2 und |Z2| = 4. ## ## Die Aussage des Lemmas wurde rechnerisch bis zur Gruppenordnung 10^100 ## getestet. ## DeclareGlobalFunction( "LinearGroupParameters" ); ############################################################################# ## #A StructureDescription( ) ## ## <#GAPDoc Label="StructureDescription"> ## ## ## ## ## The method for exhibits a structure ## of the given group G to some extent, using the strategy outlined ## below. The idea is to return a possibly short string which gives some ## insight in the structure of the considered group. It is intended ## primarily for small groups (order less than 100) or groups with few normal ## subgroups, in other cases, in particular large p-groups, it can ## be very costly. Furthermore, the string returned is -- as the action on ## chief factors is not described -- often not the most useful way to describe ## a group.

## ## The string returned by is ## not an isomorphism invariant: non-isomorphic groups can have the ## same string value, and two isomorphic groups in different representations ## can produce different strings. ## ## The value returned by is a string of ## the following form:

##

) ::= ## 1 ; trivial group ## | C ; cyclic group ## | A ; alternating group ## | S ; symmetric group ## | D ; dihedral group ## | Q ; quaternion group ## | QD ; quasidihedral group ## | PSL(,) ; projective special linear group ## | SL(,) ; special linear group ## | GL(,) ; general linear group ## | PSU(,) ; proj. special unitary group ## | O(2+1,) ; orthogonal group, type B ## | O+(2,) ; orthogonal group, type D ## | O-(2,) ; orthogonal group, type 2D ## | PSp(2,) ; proj. special symplectic group ## | Sz() ; Suzuki group ## | Ree() ; Ree group (type 2F or 2G) ## | E(6,) | E(7,) | E(8,) ; Lie group of exceptional type ## | 2E(6,) | F(4,) | G(2,) ## | 3D(4,) ; Steinberg triality group ## | M11 | M12 | M22 | M23 | M24 ## | J1 | J2 | J3 | J4 | Co1 | Co2 ## | Co3 | Fi22 | Fi23 | Fi24' | Suz ## | HS | McL | He | HN | Th | B ## | M | ON | Ly | Ru ; sporadic simple group ## | 2F(4,2)' ; Tits group ## | PerfectGroup(,) ; the indicated group from the ## ; library of perfect groups ## | A x B ; direct product ## | N : H ; semidirect product ## | C(G) . G/C(G) = G' . G/G' ; non-split extension ## ; (equal alternatives and ## ; trivial extensions omitted) ## | Phi(G) . G/Phi(G) ; non-split extension: ## ; Frattini subgroup and ## ; Frattini factor group ## ]]> ##

## Note that the is only one ## possible way of building up the given group from smaller pieces.

## ## The option short is recognized - if this option is set, an ## abbreviated output format is used (e.g. "6x3" instead of ## "C6 x C3").

## ## If the attribute is not bound, but ## is, prints the ## value of the attribute . ## The ed representation of a group is not affected ## by computing a .

## ## The strategy used to compute a is ## as follows: ##

## ## 1. ## ## Lookup in a precomputed list, if the order of G is not ## larger than 100 and not equal to 64. ## ## 2. ## ## If G is abelian, then decompose it into cyclic factors ## in elementary divisors style. For example, ## "C2 x C3 x C3" is "C6 x C3". ## ## 3. ## ## Recognize alternating groups, symmetric groups, ## dihedral groups, quasidihedral groups, quaternion groups, ## PSL's, SL's, GL's and simple groups not listed so far ## as basic building blocks. ## ## 4. ## ## Decompose G into a direct product of irreducible factors. ## ## 5. ## ## Recognize semidirect products G=N:H, ## where N is normal. ## Select a pair N, H with the following preferences: ## ## 1. ## ## H is abelian ## ## 2. ## ## N is abelian ## ## 2a. ## ## N has many abelian invariants ## ## 3. ## ## N is a direct product ## ## 3a. ## ## N has many direct factors ## ## 4. ## ## \phi: H \rightarrow Aut(N), ## h \mapsto (n \mapsto n^h) is injective. ## ## ## ## 6. ## ## Fall back to non-splitting extensions: ## If the centre or the commutator factor group is non-trivial, ## write G as Z(G).G/Z(G) or ## G'.G/G', respectively. ## Otherwise if the Frattini subgroup is non-trivial, write G ## as \Phi(G).G/\Phi(G). ## ## 7. ## ## If no decomposition is found (maybe this is not the case for ## any finite group), try to identify G in the perfect groups ## library. If this fails also, then return a string describing this ## situation. ## ## ## Note that is not intended ## to be a research tool, but rather an educational tool. The reasons for ## this are as follows: ## ## 1. ## ## Most groups do not have nice decompositions. ## This is in some contrast to what is often taught in elementary ## courses on group theory, where it is sometimes suggested that ## basically every group can be written as iterated direct or ## semidirect product of cyclic groups and nonabelian simple groups. ## ## 2. ## ## In particular many p-groups have very similar ## structure, and can only ## exhibit a little of it. Changing this would likely make the ## output not essentially easier to read than a pc presentation. ## ## ## l := AllSmallGroups(12);; ## gap> List(l,StructureDescription);; l; ## [ C3 : C4, C12, A4, D12, C6 x C2 ] ## gap> List(AllSmallGroups(40),G->StructureDescription(G:short)); ## [ "5:8", "40", "5:8", "5:Q8", "4xD10", "D40", "2x(5:4)", "(10x2):2", ## "20x2", "5xD8", "5xQ8", "2x(5:4)", "2^2xD10", "10x2^2" ] ## gap> List(AllTransitiveGroups(DegreeAction,6), ## > G->StructureDescription(G:short)); ## [ "6", "S3", "D12", "A4", "3xS3", "2xA4", "S4", "S4", "S3xS3", ## "(3^2):4", "2xS4", "A5", "(S3xS3):2", "S5", "A6", "S6" ] ## gap> StructureDescription(PSL(4,2)); ## "A8" ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "StructureDescription", IsGroup ); ############################################################################# ## #E gap-4r6p5/lib/wpobj.g0000644000175000017500000000146412172557254013207 0ustar billbill############################################################################# ## #W wpobj.g GAP library Steve Linton ## ## #Y Copyright (C) 1997, #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the weak pointer type that might have to be known very ## early in the bootstrap stage (therefore they are not in wpobj.gi) ## ############################################################################# ## #V TYPE_WPOBJ . . . . . . . . . . . . . . . . . . . . type of all wp object ## TYPE_WPOBJ := NewType( ListsFamily, IsWeakPointerObject and IsInternalRep and IsSmallList and IsMutable ); ############################################################################# ## #E ## gap-4r6p5/lib/pcgspcg.gd0000644000175000017500000000312712172557254013656 0ustar billbill############################################################################# ## #W pcgspcg.gd GAP Library Frank Celler ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the operations for polycylic generating systems of pc ## groups. ## ############################################################################# ## #P IsFamilyPcgs( ) ## ## <#GAPDoc Label="IsFamilyPcgs"> ## ## ## ## ## specifies whether the pcgs is a of a pc group. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsFamilyPcgs", IsPcgs, 30 #familyPcgs is stronger than prime orders and some other properties # (cf. rank for `IsParentPcgsFamilyPcgs' in pcgsind.gd) ); InstallTrueMethod(IsCanonicalPcgs,IsFamilyPcgs); InstallTrueMethod(IsParentPcgsFamilyPcgs,IsFamilyPcgs); ############################################################################# ## #F DoExponentsConjLayerFampcgs(

,,, ) ## ## ## ## ## ## this algorithm does not compute any conjugates but only looks them up and ## adds vectors mod p. ## ## ## DeclareGlobalFunction("DoExponentsConjLayerFampcgs"); ############################################################################# ## #E gap-4r6p5/lib/arith.gd0000644000175000017500000023172712172557252013346 0ustar billbill############################################################################# ## #W arith.gd GAP library Thomas Breuer ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the declarations of the arithmetic operations, and the ## declarations of the categories for elements that allow those operations. ## ## This file contains the definitions of categories for elements in families ## that allow certain arithmetical operations, ## and the definition of properties, attributes, and operations for these ## elements. ## ## Note that the arithmetical operations are usually only partial functions. ## This means that a multiplicative element is simply an element whose ## family allows a multiplication of *some* of its elements. It does *not* ## mean that the the product of *any* two elements in the family is defined, ## ############################################################################# ## #C IsExtAElement( ) ## ## <#GAPDoc Label="IsExtAElement"> ## ## ## ## ## An external additive element is an object that can be added via ## + with other elements ## (not necessarily in the same family, see ). ## ## ## <#/GAPDoc> ## DeclareCategory( "IsExtAElement", IsObject ); DeclareCategoryCollections( "IsExtAElement" ); DeclareCategoryCollections( "IsExtAElementCollection" ); DeclareSynonym( "IsExtAElementList", IsExtAElementCollection and IsList ); DeclareSynonym( "IsExtAElementTable", IsExtAElementCollColl and IsTable ); InstallTrueMethod( IsExtAElement, IsExtAElementCollection ); ############################################################################# ## #C IsNearAdditiveElement( ) ## ## <#GAPDoc Label="IsNearAdditiveElement"> ## ## ## ## ## A near-additive element is an object that can be added via ## + with elements in its family (see ); ## this addition is not necessarily commutative. ## ## ## <#/GAPDoc> ## DeclareCategory( "IsNearAdditiveElement", IsExtAElement ); DeclareCategoryCollections( "IsNearAdditiveElement" ); DeclareCategoryCollections( "IsNearAdditiveElementCollection" ); DeclareCategoryCollections( "IsNearAdditiveElementCollColl" ); DeclareSynonym( "IsNearAdditiveElementList", IsNearAdditiveElementCollection and IsList ); DeclareSynonym( "IsNearAdditiveElementTable", IsNearAdditiveElementCollColl and IsTable ); InstallTrueMethod( IsNearAdditiveElement, IsNearAdditiveElementList ); InstallTrueMethod( IsNearAdditiveElementList, IsNearAdditiveElementTable ); ############################################################################# ## #C IsNearAdditiveElementWithZero( ) ## ## <#GAPDoc Label="IsNearAdditiveElementWithZero"> ## ## ## ## ## A near-additive element-with-zero is an object that can be added ## via + with elements in its family ## (see ), ## and that is an admissible argument for the operation ; ## this addition is not necessarily commutative. ## ## ## <#/GAPDoc> ## DeclareCategory( "IsNearAdditiveElementWithZero", IsNearAdditiveElement ); DeclareCategoryCollections( "IsNearAdditiveElementWithZero" ); DeclareCategoryCollections( "IsNearAdditiveElementWithZeroCollection" ); DeclareCategoryCollections( "IsNearAdditiveElementWithZeroCollColl" ); DeclareSynonym( "IsNearAdditiveElementWithZeroList", IsNearAdditiveElementWithZeroCollection and IsList ); DeclareSynonym( "IsNearAdditiveElementWithZeroTable", IsNearAdditiveElementWithZeroCollColl and IsTable ); InstallTrueMethod( IsNearAdditiveElementWithZero, IsNearAdditiveElementWithZeroList ); InstallTrueMethod( IsNearAdditiveElementWithZeroList, IsNearAdditiveElementWithZeroTable ); ############################################################################# ## #C IsNearAdditiveElementWithInverse( ) ## ## <#GAPDoc Label="IsNearAdditiveElementWithInverse"> ## ## ## ## ## A near-additive element-with-inverse is an object that can be ## added via + with elements in its family ## (see ), ## and that is an admissible argument for the operations ## and ; ## this addition is not necessarily commutative. ## ## ## <#/GAPDoc> ## DeclareCategory( "IsNearAdditiveElementWithInverse", IsNearAdditiveElementWithZero ); DeclareCategoryCollections( "IsNearAdditiveElementWithInverse" ); DeclareCategoryCollections( "IsNearAdditiveElementWithInverseCollection" ); DeclareCategoryCollections( "IsNearAdditiveElementWithInverseCollColl" ); DeclareSynonym( "IsNearAdditiveElementWithInverseList", IsNearAdditiveElementWithInverseCollection and IsList ); DeclareSynonym( "IsNearAdditiveElementWithInverseTable", IsNearAdditiveElementWithInverseCollColl and IsTable ); InstallTrueMethod( IsNearAdditiveElementWithInverse, IsNearAdditiveElementWithInverseList ); InstallTrueMethod( IsNearAdditiveElementWithInverseList, IsNearAdditiveElementWithInverseTable ); ############################################################################# ## #C IsAdditiveElement( ) ## ## <#GAPDoc Label="IsAdditiveElement"> ## ## ## ## ## An additive element is an object that can be added via + ## with elements in its family (see ); ## this addition is commutative. ## ## ## <#/GAPDoc> ## DeclareCategory( "IsAdditiveElement", IsNearAdditiveElement ); DeclareCategoryCollections( "IsAdditiveElement" ); DeclareCategoryCollections( "IsAdditiveElementCollection" ); DeclareCategoryCollections( "IsAdditiveElementCollColl" ); DeclareSynonym( "IsAdditiveElementList", IsAdditiveElementCollection and IsList ); DeclareSynonym( "IsAdditiveElementTable", IsAdditiveElementCollColl and IsTable ); InstallTrueMethod( IsAdditiveElement, IsAdditiveElementList ); InstallTrueMethod( IsAdditiveElementList, IsAdditiveElementTable ); ############################################################################# ## #C IsAdditiveElementWithZero( ) ## ## <#GAPDoc Label="IsAdditiveElementWithZero"> ## ## ## ## ## An additive element-with-zero is an object that can be added ## via + with elements in its family ## (see ), ## and that is an admissible argument for the operation ; ## this addition is commutative. ## ## ## <#/GAPDoc> ## DeclareSynonym( "IsAdditiveElementWithZero", IsNearAdditiveElementWithZero and IsAdditiveElement ); DeclareSynonym( "IsAdditiveElementWithZeroCollection", IsNearAdditiveElementWithZeroCollection and IsAdditiveElementCollection ); DeclareSynonym( "IsAdditiveElementWithZeroCollColl", IsNearAdditiveElementWithZeroCollColl and IsAdditiveElementCollColl ); DeclareSynonym( "IsAdditiveElementWithZeroCollCollColl", IsNearAdditiveElementWithZeroCollCollColl and IsAdditiveElementCollCollColl ); DeclareSynonym( "IsAdditiveElementWithZeroList", IsAdditiveElementWithZeroCollection and IsList ); DeclareSynonym( "IsAdditiveElementWithZeroTable", IsAdditiveElementWithZeroCollColl and IsTable ); InstallTrueMethod( IsAdditiveElementWithZero, IsAdditiveElementWithZeroList ); InstallTrueMethod( IsAdditiveElementWithZeroList, IsAdditiveElementWithZeroTable ); ############################################################################# ## #C IsAdditiveElementWithInverse( ) ## ## <#GAPDoc Label="IsAdditiveElementWithInverse"> ## ## ## ## ## An additive element-with-inverse is an object that can be ## added via + with elements in its family ## (see ), ## and that is an admissible argument for the operations ## and ; ## this addition is commutative. ## ## ## <#/GAPDoc> ## DeclareSynonym( "IsAdditiveElementWithInverse", IsNearAdditiveElementWithInverse and IsAdditiveElement ); DeclareSynonym( "IsAdditiveElementWithInverseCollection", IsNearAdditiveElementWithInverseCollection and IsAdditiveElementCollection ); DeclareSynonym( "IsAdditiveElementWithInverseCollColl", IsNearAdditiveElementWithInverseCollColl and IsAdditiveElementCollColl ); DeclareSynonym( "IsAdditiveElementWithInverseCollCollColl", IsNearAdditiveElementWithInverseCollCollColl and IsAdditiveElementCollCollColl ); DeclareSynonym( "IsAdditiveElementWithInverseList", IsAdditiveElementWithInverseCollection and IsList ); DeclareSynonym( "IsAdditiveElementWithInverseTable", IsAdditiveElementWithInverseCollColl and IsTable ); InstallTrueMethod( IsAdditiveElementWithInverse, IsAdditiveElementWithInverseList ); InstallTrueMethod( IsAdditiveElementWithInverseList, IsAdditiveElementWithInverseTable ); ############################################################################# ## #C IsExtLElement( ) ## ## <#GAPDoc Label="IsExtLElement"> ## ## ## ## ## An external left element is an object that can be multiplied ## from the left, via *, with other elements ## (not necessarily in the same family, see ). ## ## ## <#/GAPDoc> ## DeclareCategory( "IsExtLElement", IsObject ); DeclareCategoryCollections( "IsExtLElement" ); DeclareCategoryCollections( "IsExtLElementCollection" ); DeclareSynonym( "IsExtLElementList", IsExtLElementCollection and IsList ); DeclareSynonym( "IsExtLElementTable", IsExtLElementCollColl and IsTable ); InstallTrueMethod( IsExtLElement, IsExtLElementCollection ); ############################################################################# ## #C IsExtRElement( ) ## ## <#GAPDoc Label="IsExtRElement"> ## ## ## ## ## An external right element is an object that can be multiplied ## from the right, via *, with other elements ## (not necessarily in the same family, see ). ## ## ## <#/GAPDoc> ## DeclareCategory( "IsExtRElement", IsObject ); DeclareCategoryCollections( "IsExtRElement" ); DeclareCategoryCollections( "IsExtRElementCollection" ); DeclareSynonym( "IsExtRElementList", IsExtRElementCollection and IsList ); DeclareSynonym( "IsExtRElementTable", IsExtRElementCollColl and IsTable ); InstallTrueMethod( IsExtRElement, IsExtRElementCollection ); ############################################################################# ## #C IsMultiplicativeElement( ) ## ## <#GAPDoc Label="IsMultiplicativeElement"> ## ## ## ## ## A multiplicative element is an object that can be multiplied via ## * with elements in its family (see ). ## ## ## <#/GAPDoc> ## DeclareCategory( "IsMultiplicativeElement", IsExtLElement and IsExtRElement ); DeclareCategoryCollections( "IsMultiplicativeElement" ); DeclareCategoryCollections( "IsMultiplicativeElementCollection" ); DeclareCategoryCollections( "IsMultiplicativeElementCollColl" ); DeclareSynonym( "IsMultiplicativeElementList", IsMultiplicativeElementCollection and IsList ); DeclareSynonym( "IsMultiplicativeElementTable", IsMultiplicativeElementCollColl and IsTable ); ############################################################################# ## #C IsMultiplicativeElementWithOne( ) ## ## <#GAPDoc Label="IsMultiplicativeElementWithOne"> ## ## ## ## ## A multiplicative element-with-one is an object that can be ## multiplied via * with elements in its family ## (see ), ## and that is an admissible argument for the operation . ## ## ## <#/GAPDoc> ## DeclareCategory( "IsMultiplicativeElementWithOne", IsMultiplicativeElement ); DeclareCategoryCollections( "IsMultiplicativeElementWithOne" ); DeclareCategoryCollections( "IsMultiplicativeElementWithOneCollection" ); DeclareCategoryCollections( "IsMultiplicativeElementWithOneCollColl" ); DeclareSynonym( "IsMultiplicativeElementWithOneList", IsMultiplicativeElementWithOneCollection and IsList ); DeclareSynonym( "IsMultiplicativeElementWithOneTable", IsMultiplicativeElementWithOneCollColl and IsTable ); ############################################################################# ## #C IsMultiplicativeElementWithInverse( ) ## ## <#GAPDoc Label="IsMultiplicativeElementWithInverse"> ## ## ## ## ## A multiplicative element-with-inverse is an object that can be ## multiplied via * with elements in its family ## (see ), ## and that is an admissible argument for the operations ## and . (Note the word admissible: an ## object in this category does not necessarily have an inverse, ## may return fail.) ## ## ## <#/GAPDoc> ## DeclareCategory( "IsMultiplicativeElementWithInverse", IsMultiplicativeElementWithOne ); DeclareCategoryCollections( "IsMultiplicativeElementWithInverse" ); DeclareCategoryCollections( "IsMultiplicativeElementWithInverseCollection" ); DeclareCategoryCollections( "IsMultiplicativeElementWithInverseCollColl" ); DeclareSynonym( "IsMultiplicativeElementWithInverseList", IsMultiplicativeElementWithInverseCollection and IsList ); DeclareSynonym( "IsMultiplicativeElementWithInverseTable", IsMultiplicativeElementWithInverseCollColl and IsTable ); ############################################################################# ## #C IsVector( ) ## ## <#GAPDoc Label="IsVector"> ## ## ## ## ## A vector is an additive-element-with-inverse that can be ## multiplied from the left and right with other objects ## (not necessarily of the same type). ## Examples are cyclotomics, finite field elements, ## and of course row vectors (see below). ##

## Note that not all lists of ring elements are regarded as vectors, ## for example lists of matrices are not vectors. ## This is because although the category ## is ## implied by the meet of its collections category and , ## the family of a list entry may not imply ## for all its elements. ## ## ## <#/GAPDoc> ## DeclareSynonym( "IsVector", IsAdditiveElementWithInverse and IsExtLElement and IsExtRElement ); DeclareSynonym( "IsVectorCollection", IsAdditiveElementWithInverseCollection and IsExtLElementCollection and IsExtRElementCollection ); DeclareSynonym( "IsVectorCollColl", IsAdditiveElementWithInverseCollColl and IsExtLElementCollColl and IsExtRElementCollColl ); DeclareSynonym( "IsVectorList", IsAdditiveElementWithInverseList and IsExtLElementList and IsExtRElementList ); DeclareSynonym( "IsVectorTable", IsAdditiveElementWithInverseTable and IsExtLElementTable and IsExtRElementTable ); ############################################################################# ## #F IsOddAdditiveNestingDepthFamily( ) #F IsOddAdditiveNestingDepthObject( ) ## ## ## ## ## ## ## ## ## DeclareFilter( "IsOddAdditiveNestingDepthFamily" ); DeclareFilter( "IsOddAdditiveNestingDepthObject" ); ############################################################################# ## #C IsRowVector( ) ## ## <#GAPDoc Label="IsRowVector"> ## ## ## ## ## A row vector is a vector (see ) ## that is also a homogeneous list of odd additive nesting depth ## (see ). ## Typical examples are lists of integers and rationals, ## lists of finite field elements of the same characteristic, ## and lists of polynomials from a common polynomial ring. ## Note that matrices are not regarded as row vectors, because they have ## even additive nesting depth. ##

## The additive operations of the vector must thus be compatible with ## that for lists, implying that the list entries are the ## coefficients of the vector with respect to some basis. ##

## Note that not all row vectors admit a multiplication via * ## (which is to be understood as a scalar product); ## for example, class functions are row vectors but the product of two ## class functions is defined in a different way. ## For the installation of a scalar product of row vectors, the entries of ## the vector must be ring elements; note that the default method expects ## the row vectors to lie in IsRingElementList, ## and this category may not be implied by ## for all entries of the row vector ## (see the comment in ). ##

## Note that methods for special types of row vectors really must be ## installed with the requirement , ## since may lead to a rank of the method below ## that of the default method for row vectors (see file lib/vecmat.gi). ##

## IsRowVector([1,2,3]); ## true ## ]]> ##

## Because row vectors are just a special case of lists, all operations ## and functions for lists are applicable to row vectors as well (see ## Chapter ). ## This especially includes accessing elements of a row vector ## (see ), changing elements of a mutable row ## vector (see ), ## and comparing row vectors (see ). ##

## Note that, unless your algorithms specifically require you to be able ## to change entries of your vectors, it is generally better and faster ## to work with immutable row vectors. ## See Section  for more ## details. ## ## ## <#/GAPDoc> ## DeclareSynonym( "IsRowVector", IsVector and IsHomogeneousList and IsOddAdditiveNestingDepthObject ); ############################################################################# ## ## Filters Controlling the Arithmetic Behaviour of Lists ## <#GAPDoc Label="[1]{arith}"> ## The arithmetic behaviour of lists is controlled by their types. ## The following categories and attributes are used for that. ##

## Note that we distinguish additive and multiplicative behaviour. ## For example, Lie matrices have the usual additive behaviour but not the ## usual multiplicative behaviour. ## <#/GAPDoc> ## ############################################################################# ## #C IsGeneralizedRowVector( ) . . . objects that comply with new list ## addition rules ## ## <#GAPDoc Label="IsGeneralizedRowVector"> ## ## ## ## ## For a list list, the value true for ## ## indicates that the additive arithmetic behaviour of list is ## as defined in , ## and that the attribute ## will return a nonzero value when called with list. ##

## IsList( "abc" ); IsGeneralizedRowVector( "abc" ); ## true ## false ## gap> liemat:= LieObject( [ [ 1, 2 ], [ 3, 4 ] ] ); ## LieObject( [ [ 1, 2 ], [ 3, 4 ] ] ) ## gap> IsGeneralizedRowVector( liemat ); ## true ## ]]> ## ## ## <#/GAPDoc> ## DeclareCategory( "IsGeneralizedRowVector", IsList and IsAdditiveElementWithInverse ); ############################################################################# ## #C IsMultiplicativeGeneralizedRowVector( ) . . . . ## objects that comply with new list multiplication rules ## ## <#GAPDoc Label="IsMultiplicativeGeneralizedRowVector"> ## ## ## ## ## For a list list, the value true for ## indicates that the ## multiplicative arithmetic behaviour of list is as defined ## in , ## and that the attribute ## will return a nonzero value when called with list. ##

## IsMultiplicativeGeneralizedRowVector( liemat ); ## false ## gap> bas:= CanonicalBasis( FullRowSpace( Rationals, 3 ) ); ## CanonicalBasis( ( Rationals^3 ) ) ## gap> IsMultiplicativeGeneralizedRowVector( bas ); ## true ## ]]> ##

## Note that the filters , ## ## do not enable default methods for addition or multiplication ## (cf. ). ## ## ## <#/GAPDoc> ## DeclareCategory( "IsMultiplicativeGeneralizedRowVector", IsGeneralizedRowVector ); ############################################################################# ## #A NestingDepthA( ) ## ## <#GAPDoc Label="NestingDepthA"> ## ## ## ## ## For a &GAP; object obj, ## returns the additive nesting depth ## of obj. ## This is defined recursively ## as the integer 0 if obj is not in ## , ## as the integer 1 if obj is an empty list in ## , ## and as 1 plus the additive nesting depth of the first bound entry ## in obj otherwise. ## ## ## <#/GAPDoc> ## DeclareAttribute( "NestingDepthA", IsObject ); ############################################################################# ## #A NestingDepthM( ) ## ## <#GAPDoc Label="NestingDepthM"> ## ## ## ## ## For a &GAP; object obj, ## returns the ## multiplicative nesting depth of obj. ## This is defined recursively as the ## integer 0 if obj is not in ## , ## as the integer 1 if obj is an empty list in ## , ## and as 1 plus the multiplicative nesting depth of the first bound ## entry in obj otherwise. ## NestingDepthA( v ); NestingDepthM( v ); ## 1 ## 1 ## gap> NestingDepthA( m ); NestingDepthM( m ); ## 2 ## 2 ## gap> NestingDepthA( liemat ); NestingDepthM( liemat ); ## 2 ## 0 ## gap> l1:= [ [ 1, 2 ], 3 ];; l2:= [ 1, [ 2, 3 ] ];; ## gap> NestingDepthA( l1 ); NestingDepthM( l1 ); ## 2 ## 2 ## gap> NestingDepthA( l2 ); NestingDepthM( l2 ); ## 1 ## 1 ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "NestingDepthM", IsObject ); ############################################################################# ## #C IsNearRingElement( ) ## ## <#GAPDoc Label="IsNearRingElement"> ## ## ## ## ## is just a synonym for the meet of ## and ## . ## ## ## <#/GAPDoc> ## DeclareSynonym( "IsNearRingElement", IsNearAdditiveElementWithInverse and IsMultiplicativeElement ); DeclareSynonym( "IsNearRingElementCollection", IsNearAdditiveElementWithInverseCollection and IsMultiplicativeElementCollection ); DeclareSynonym( "IsNearRingElementCollColl", IsNearAdditiveElementWithInverseCollColl and IsMultiplicativeElementCollColl ); DeclareSynonym( "IsNearRingElementCollCollColl", IsNearAdditiveElementWithInverseCollCollColl and IsMultiplicativeElementCollCollColl ); DeclareSynonym( "IsNearRingElementList", IsNearAdditiveElementWithInverseList and IsMultiplicativeElementList ); DeclareSynonym( "IsNearRingElementTable", IsNearAdditiveElementWithInverseTable and IsMultiplicativeElementTable ); InstallTrueMethod( IsNearRingElement, IsNearRingElementTable ); DeclareCategoryFamily( "IsNearRingElement" ); ############################################################################# ## #C IsNearRingElementWithOne( ) ## ## <#GAPDoc Label="IsNearRingElementWithOne"> ## ## ## ## ## is just a synonym for the meet of ## and ## . ## ## ## <#/GAPDoc> ## DeclareSynonym( "IsNearRingElementWithOne", IsNearAdditiveElementWithInverse and IsMultiplicativeElementWithOne ); DeclareSynonym( "IsNearRingElementWithOneCollection", IsNearAdditiveElementWithInverseCollection and IsMultiplicativeElementWithOneCollection ); DeclareSynonym( "IsNearRingElementWithOneCollColl", IsNearAdditiveElementWithInverseCollColl and IsMultiplicativeElementWithOneCollColl ); DeclareSynonym( "IsNearRingElementWithOneCollCollColl", IsNearAdditiveElementWithInverseCollCollColl and IsMultiplicativeElementWithOneCollCollColl ); DeclareSynonym( "IsNearRingElementWithOneList", IsNearAdditiveElementWithInverseList and IsMultiplicativeElementWithOneList ); DeclareSynonym( "IsNearRingElementWithOneTable", IsNearAdditiveElementWithInverseTable and IsMultiplicativeElementWithOneTable ); InstallTrueMethod( IsNearRingElementWithOne, IsNearRingElementWithOneTable ); ############################################################################# ## #C IsNearRingElementWithInverse( ) ## ## <#GAPDoc Label="IsNearRingElementWithInverse"> ## ## ## ## ## is just a synonym for the meet of ## and ## . ## ## ## <#/GAPDoc> ## DeclareSynonym( "IsNearRingElementWithInverse", IsNearAdditiveElementWithInverse and IsMultiplicativeElementWithInverse ); DeclareSynonym( "IsNearRingElementWithInverseCollection", IsNearAdditiveElementWithInverseCollection and IsMultiplicativeElementWithInverseCollection ); DeclareSynonym( "IsNearRingElementWithInverseCollColl", IsNearAdditiveElementWithInverseCollColl and IsMultiplicativeElementWithInverseCollColl ); DeclareSynonym( "IsNearRingElementWithInverseCollCollColl", IsNearAdditiveElementWithInverseCollCollColl and IsMultiplicativeElementWithInverseCollCollColl ); DeclareSynonym( "IsNearRingElementWithInverseList", IsNearAdditiveElementWithInverseList and IsMultiplicativeElementWithInverseList ); DeclareSynonym( "IsNearRingElementWithInverseTable", IsNearAdditiveElementWithInverseTable and IsMultiplicativeElementWithInverseTable ); InstallTrueMethod( IsNearRingElementWithInverse, IsNearRingElementWithInverseTable ); ############################################################################# ## #C IsRingElement( ) ## ## <#GAPDoc Label="IsRingElement"> ## ## ## ## ## is just a synonym for the meet of ## and ## . ## ## ## <#/GAPDoc> ## DeclareSynonym( "IsRingElement", IsAdditiveElementWithInverse and IsMultiplicativeElement ); DeclareSynonym( "IsRingElementCollection", IsAdditiveElementWithInverseCollection and IsMultiplicativeElementCollection ); DeclareSynonym( "IsRingElementCollColl", IsAdditiveElementWithInverseCollColl and IsMultiplicativeElementCollColl ); DeclareSynonym( "IsRingElementCollCollColl", IsAdditiveElementWithInverseCollCollColl and IsMultiplicativeElementCollCollColl ); DeclareSynonym( "IsRingElementList", IsAdditiveElementWithInverseList and IsMultiplicativeElementList ); DeclareSynonym( "IsRingElementTable", IsAdditiveElementWithInverseTable and IsMultiplicativeElementTable ); InstallTrueMethod( IsRingElement, IsRingElementTable ); DeclareCategoryFamily( "IsRingElement" ); ############################################################################# ## #C IsRingElementWithOne( ) ## ## <#GAPDoc Label="IsRingElementWithOne"> ## ## ## ## ## is just a synonym for the meet of ## and ## . ## ## ## <#/GAPDoc> ## DeclareSynonym( "IsRingElementWithOne", IsAdditiveElementWithInverse and IsMultiplicativeElementWithOne ); DeclareSynonym( "IsRingElementWithOneCollection", IsAdditiveElementWithInverseCollection and IsMultiplicativeElementWithOneCollection ); DeclareSynonym( "IsRingElementWithOneCollColl", IsAdditiveElementWithInverseCollColl and IsMultiplicativeElementWithOneCollColl ); DeclareSynonym( "IsRingElementWithOneCollCollColl", IsAdditiveElementWithInverseCollCollColl and IsMultiplicativeElementWithOneCollCollColl ); DeclareSynonym( "IsRingElementWithOneList", IsAdditiveElementWithInverseList and IsMultiplicativeElementWithOneList ); DeclareSynonym( "IsRingElementWithOneTable", IsAdditiveElementWithInverseTable and IsMultiplicativeElementWithOneTable ); InstallTrueMethod( IsRingElementWithOne, IsRingElementWithOneTable ); ############################################################################# ## #C IsRingElementWithInverse( ) #C IsScalar( ) ## ## <#GAPDoc Label="IsRingElementWithInverse"> ## ## ## ## ## ## and ## are just synonyms for the meet of ## and ## . ## ## ## <#/GAPDoc> ## DeclareSynonym( "IsRingElementWithInverse", IsAdditiveElementWithInverse and IsMultiplicativeElementWithInverse ); DeclareSynonym( "IsRingElementWithInverseCollection", IsAdditiveElementWithInverseCollection and IsMultiplicativeElementWithInverseCollection ); DeclareSynonym( "IsRingElementWithInverseCollColl", IsAdditiveElementWithInverseCollColl and IsMultiplicativeElementWithInverseCollColl ); DeclareSynonym( "IsRingElementWithInverseCollCollColl", IsAdditiveElementWithInverseCollCollColl and IsMultiplicativeElementWithInverseCollCollColl ); DeclareSynonym( "IsRingElementWithInverseList", IsAdditiveElementWithInverseList and IsMultiplicativeElementWithInverseList ); DeclareSynonym( "IsRingElementWithInverseTable", IsAdditiveElementWithInverseTable and IsMultiplicativeElementWithInverseTable ); InstallTrueMethod( IsRingElementWithInverse, IsRingElementWithInverseTable ); DeclareSynonym( "IsScalar", IsRingElementWithInverse ); DeclareSynonym( "IsScalarCollection", IsRingElementWithInverseCollection ); DeclareSynonym( "IsScalarCollColl", IsRingElementWithInverseCollColl ); DeclareSynonym( "IsScalarList", IsRingElementWithInverseList ); DeclareSynonym( "IsScalarTable", IsRingElementWithInverseTable ); ############################################################################# ## #C IsZDFRE( ) ## ## ## ## ## ## This category (is zero divisor free ring element) indicates elements ## from a ring which contains no zero divisors. For matrix operations over ## this ring, a standard Gauss algorithm can be used. ## ## ## DeclareCategory("IsZDFRE",IsRingElementWithInverse); DeclareCategoryCollections("IsZDFRE"); DeclareCategoryCollections("IsZDFRECollection"); ############################################################################# ## #C IsMatrix( ) ## ## <#GAPDoc Label="IsMatrix"> ## ## ## ## ## A matrix is a list of lists of equal length whose entries lie in a ## common ring. ##

## Note that matrices may have different multiplications, ## besides the usual matrix product there is for example the Lie product. ## So there are categories such as ## and ## that describe the matrix multiplication. ## One can form the product of two matrices only if they support the same ## multiplication. ##

## mat:=[[1,2,3],[4,5,6],[7,8,9]]; ## [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ] ## gap> IsMatrix(mat); ## true ## ]]> ##

## Note also the filter ## which may be more appropriate than ## for some purposes. ##

## Note that the empty list [] and more complex ## empty structures such as [[]] are not matrices, ## although special methods allow them be used in place of matrices in some ## situations. See below. ##

## [[0]]*[[]]; ## [ [ ] ] ## gap> IsMatrix([[]]); ## false ## ]]> ## ## ## <#/GAPDoc> #T #T In order to avoid that a matrix supports more than one multiplication, #T appropriate immediate methods are installed (see~arith.gi). ## DeclareSynonym( "IsMatrix", IsRingElementTable ); DeclareCategoryCollections( "IsMatrix" ); ############################################################################# ## #C IsOrdinaryMatrix( ) ## ## <#GAPDoc Label="IsOrdinaryMatrix"> ## ## ## ## ## An ordinary matrix is a matrix whose multiplication is the ordinary ## matrix multiplication. ##

## Each matrix in internal representation is in the category ## , ## and arithmetic operations with objects in ## produce again matrices in . ##

## Note that we want that Lie matrices shall be matrices that behave in the ## same way as ordinary matrices, except that they have a different ## multiplication. ## So we must distinguish the different matrix multiplications, ## in order to be able to describe the applicability of multiplication, ## and also in order to form a matrix of the appropriate type as the ## sum, difference etc. of two matrices ## which have the same multiplication. ## ## ## <#/GAPDoc> ## DeclareCategory( "IsOrdinaryMatrix", IsMatrix ); DeclareCategoryCollections( "IsOrdinaryMatrix" ); #T get rid of this filter!! InstallTrueMethod( IsOrdinaryMatrix, IsMatrix and IsInternalRep ); InstallTrueMethod( IsGeneralizedRowVector, IsMatrix ); #T get rid of that hack! InstallTrueMethod( IsMultiplicativeGeneralizedRowVector, IsOrdinaryMatrix ); ############################################################################# ## #C IsLieMatrix( ) ## ## <#GAPDoc Label="IsLieMatrix"> ## ## ## ## ## A Lie matrix is a matrix whose multiplication is given by the ## Lie bracket. ## (Note that a matrix with ordinary matrix multiplication is in the ## category .) ##

## Each matrix created by is in the category ## , ## and arithmetic operations with objects in ## produce again matrices in . ## ## ## ## <#/GAPDoc> ## DeclareCategory( "IsLieMatrix", IsGeneralizedRowVector and IsMatrix ); ############################################################################# ## #C IsAssociativeElement( ) . . . elements belonging to assoc. families #C IsAssociativeElementCollection( ) #C IsAssociativeElementCollColl( ) ## ## <#GAPDoc Label="IsAssociativeElement"> ## ## ## ## ## ## ## An element obj in the category ## knows that the multiplication of any elements in the family of obj ## is associative. ## For example, all permutations lie in this category, as well as those ## ordinary matrices (see ) ## whose entries are also in . ## ## ## <#/GAPDoc> ## DeclareCategory( "IsAssociativeElement", IsMultiplicativeElement ); DeclareCategoryCollections( "IsAssociativeElement" ); DeclareCategoryCollections( "IsAssociativeElementCollection" ); ############################################################################# ## #M IsAssociativeElement( ) . . . . . . . for certain ordinary matrices ## ## Matrices with associative multiplication ## and with entries in an associative family ## are themselves associative elements. ## InstallTrueMethod( IsAssociativeElement, IsOrdinaryMatrix and IsAssociativeElementCollColl ); ############################################################################# ## #C IsAdditivelyCommutativeElement( ) #C IsAdditivelyCommutativeElementCollection( ) #C IsAdditivelyCommutativeElementCollColl( ) #C IsAdditivelyCommutativeElementFamily( ) ## ## <#GAPDoc Label="IsAdditivelyCommutativeElement"> ## ## ## ## ## ## ## ## An element obj in the category ## knows ## that the addition of any elements in the family of obj ## is commutative. ## For example, each finite field element and each rational number lies in ## this category. ## ## ## <#/GAPDoc> ## DeclareCategory( "IsAdditivelyCommutativeElement", IsAdditiveElement ); DeclareCategoryCollections( "IsAdditivelyCommutativeElement" ); DeclareCategoryCollections( "IsAdditivelyCommutativeElementCollection" ); DeclareCategoryFamily( "IsAdditivelyCommutativeElement" ); ############################################################################# ## #M IsAdditivelyCommutativeElement( ) . . . . . . for certain matrices ## ## Matrices with entries in an additively commutative family ## are themselves additively commutative elements. ## InstallTrueMethod( IsAdditivelyCommutativeElement, IsMatrix and IsAdditivelyCommutativeElementCollColl ); ############################################################################# ## #M IsAdditivelyCommutativeElement( ) . . . . . for certain row vectors ## ## Row vectors with entries in an additively commutative family ## are themselves additively commutative elements. ## InstallTrueMethod( IsAdditivelyCommutativeElement, IsRowVector and IsAdditivelyCommutativeElementCollection ); ############################################################################# ## #C IsCommutativeElement( ) . . . elements belonging to comm. families #C IsCommutativeElementCollection( ) #C IsCommutativeElementCollColl( ) ## ## <#GAPDoc Label="IsCommutativeElement"> ## ## ## ## ## ## ## An element obj in the category ## knows that the multiplication of any elements in the family of obj ## is commutative. ## For example, each finite field element and each rational number lies in ## this category. ## ## ## <#/GAPDoc> ## DeclareCategory( "IsCommutativeElement", IsMultiplicativeElement ); DeclareCategoryCollections( "IsCommutativeElement" ); DeclareCategoryCollections( "IsCommutativeElementCollection" ); ############################################################################# ## #C IsFiniteOrderElement( ) #C IsFiniteOrderElementCollection( ) #C IsFiniteOrderElementCollColl( ) ## ## <#GAPDoc Label="IsFiniteOrderElement"> ## ## ## ## ## ## ## An element obj in the category ## knows that it has finite multiplicative order. ## For example, each finite field element and each permutation lies in ## this category. ## However the value may be false even if obj has finite ## order, but if this was not known when obj was constructed. ##

## Although it is legal to set this filter for any object with finite order, ## this is really useful only in the case that all elements of a family are ## known to have finite order. ## ## ## <#/GAPDoc> ## DeclareCategory( "IsFiniteOrderElement", IsMultiplicativeElementWithInverse ); DeclareCategoryCollections( "IsFiniteOrderElement" ); DeclareCategoryCollections( "IsFiniteOrderElementCollection" ); ############################################################################# ## #C IsJacobianElement( ) . elements belong. to fam. with Jacobi ident. #C IsJacobianElementCollection( ) #C IsJacobianElementCollColl( ) ## ## <#GAPDoc Label="IsJacobianElement"> ## ## ## ## ## ## ## ## ## ## An element obj in the category ## knows that the multiplication of any elements in the family F ## of obj satisfies the Jacobi identity, that is, ## x * y * z + z * x * y + y * z * x is zero ## for all x, y, z in F. ##

## For example, each Lie matrix (see ) ## lies in this category. ## ## ## <#/GAPDoc> ## DeclareCategory( "IsJacobianElement", IsRingElement ); DeclareCategoryCollections( "IsJacobianElement" ); DeclareCategoryCollections( "IsJacobianElementCollection" ); DeclareCategory( "IsRestrictedJacobianElement", IsJacobianElement ); DeclareCategoryCollections( "IsRestrictedJacobianElement" ); DeclareCategoryCollections( "IsRestrictedJacobianElementCollection" ); ############################################################################# ## #C IsZeroSquaredElement( ) . . . elements belong. to zero squared fam. #C IsZeroSquaredElementCollection( ) #C IsZeroSquaredElementCollColl( ) ## ## <#GAPDoc Label="IsZeroSquaredElement"> ## ## ## ## ## ## ## An element obj in the category ## knows that obj^2 = Zero( obj ). ## For example, each Lie matrix (see ) ## lies in this category. ##

## Although it is legal to set this filter for any zero squared object, ## this is really useful only in the case that all elements of a family are ## known to have square zero. ## ## ## <#/GAPDoc> ## DeclareCategory( "IsZeroSquaredElement", IsRingElement ); DeclareCategoryCollections( "IsZeroSquaredElement" ); DeclareCategoryCollections( "IsZeroSquaredElementCollection" ); ############################################################################# ## #P IsZero( ) . . . . . . . . . . . . . . . . . . test for zero element ## ## <#GAPDoc Label="IsZero"> ## ## ## ## ## is true if elm = Zero( elm ), ## and false otherwise. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsZero", IsAdditiveElementWithZero ); ############################################################################# ## #P IsOne( ) . . . . . . . . . . . . . . . . test for identity element ## ## <#GAPDoc Label="IsOne"> ## ## ## ## ## is true if elm = One( elm ), ## and false otherwise. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsOne", IsMultiplicativeElementWithOne ); ############################################################################# ## #A ZeroImmutable( ) . . additive neutral of an element/domain/family #A ZeroAttr( ) synonym of ZeroImmutable #A Zero( ) synonym of ZeroImmutable #O ZeroMutable( ) . . . . . . mutable additive neutral of an element #O ZeroOp( ) synonym of ZeroMutable #O ZeroSameMutability( ) mutability preserving zero (0*) #O ZeroSM( ) synonym of ZeroSameMutability ## ## <#GAPDoc Label="ZeroImmutable"> ## ## ## ## ## ## ## ## ## ## ## , , ## and all ## return the additive neutral element of the additive element obj. ##

## They differ only w.r.t. the mutability of the result. ## is an attribute and hence returns an ## immutable result. ## is guaranteed to return a new mutable ## object whenever a mutable version of the required element exists in &GAP; ## (see ). ## returns a result that is mutable if ## obj is mutable and if a mutable version of the required element ## exists in &GAP;; ## for lists, it returns a result of the same immutability level as ## the argument. For instance, if the argument is a mutable matrix ## with immutable rows, it returns a similar object. ##

## ZeroSameMutability( obj ) is equivalent to ## 0 * obj. ##

## and are synonyms of ## . ## is a synonym of . ## is a synonym of . ##

## If obj is a domain or a family then is defined ## as the zero element of all elements in obj, ## provided that all these elements have the same zero. ## For example, the family of all cyclotomics has the zero element 0, ## but a collections family (see ) may ## contain matrices of all dimensions and then it cannot have a unique ## zero element. ## Note that is applicable to a domain only if it is an ## additive magma-with-zero ## (see ); ## use otherwise. ##

## The default method of for additive elements calls ## ## (note that methods for must not delegate ## to ); ## so other methods to compute zero elements need to be installed only for ## and (in the case of copyable objects) ## . ##

## For domains, may call , ## but is allowed to fetch the zero of a domain ## D only if HasZero( D ) is true. ## ## ## <#/GAPDoc> ## DeclareAttribute( "ZeroImmutable", IsAdditiveElementWithZero ); DeclareAttribute( "ZeroImmutable", IsFamily ); DeclareSynonymAttr( "ZeroAttr", ZeroImmutable ); DeclareSynonymAttr( "Zero", ZeroImmutable ); DeclareOperationKernel( "ZeroMutable", [ IsAdditiveElementWithZero ], ZERO_MUT ); DeclareSynonym( "ZeroOp", ZeroMutable ); DeclareOperationKernel( "ZeroSameMutability", [ IsAdditiveElementWithZero ], ZERO ); DeclareSynonym( "ZeroSM", ZeroSameMutability ); ############################################################################# ## #O `+' . . . . . . . . . . . . . . . . . . . sum of two elements ## DeclareOperationKernel( "+", [ IsExtAElement, IsExtAElement ], SUM ); ############################################################################# ## #A AdditiveInverseImmutable( ) . . . . additive inverse of an element #A AdditiveInverseAttr( ) . . . . additive inverse of an element #A AdditiveInverse( ) . . . . additive inverse of an element #O AdditiveInverseMutable( ) . mutable additive inverse of an element #O AdditiveInverseOp( ) . mutable additive inverse of an element #O AdditiveInverseSameMutability( ) . additive inverse of an element #O AdditiveInverseSM( ) . additive inverse of an element ## ## <#GAPDoc Label="AdditiveInverseImmutable"> ## ## ## ## ## ## ## ## ## ## ## , ## , and ## all return the ## additive inverse of elm. ##

## They differ only w.r.t. the mutability of the result. ## is an attribute and hence returns ## an immutable result. ## is guaranteed to return a new ## mutable object whenever a mutable version of the required element ## exists in &GAP; (see ). ## returns a result that is ## mutable if elm is mutable and if a mutable version of the required ## element exists in &GAP;; ## for lists, it returns a result of the same immutability level as ## the argument. For instance, if the argument is a mutable matrix ## with immutable rows, it returns a similar object. ##

## AdditiveInverseSameMutability( elm ) is equivalent to ## -elm. ##

## and are ## synonyms of . ## is a synonym of ## . ## is a synonym of ## . ##

## The default method of calls ## ## (note that methods for ## must not delegate to ); ## so other methods to compute additive inverses need to be installed only ## for and (in the case of copyable ## objects) . ## ## ## <#/GAPDoc> ## DeclareAttribute( "AdditiveInverseImmutable", IsAdditiveElementWithInverse ); DeclareSynonymAttr( "AdditiveInverseAttr", AdditiveInverseImmutable ); DeclareSynonymAttr( "AdditiveInverse", AdditiveInverseImmutable ); DeclareOperationKernel( "AdditiveInverseMutable", [ IsAdditiveElementWithInverse ], AINV_MUT); DeclareSynonym( "AdditiveInverseOp", AdditiveInverseMutable); DeclareOperationKernel( "AdditiveInverseSameMutability", [ IsAdditiveElementWithInverse ], AINV ); DeclareSynonym( "AdditiveInverseSM", AdditiveInverseSameMutability); ############################################################################# ## #O `-' . . . . . . . . . . . . . . . difference of two elements ## DeclareOperationKernel( "-", [ IsExtAElement, IsNearAdditiveElementWithInverse ], DIFF ); ############################################################################# ## #O `*' . . . . . . . . . . . . . . . . . product of two elements ## DeclareOperationKernel( "*", [ IsExtRElement, IsExtLElement ], PROD ); ############################################################################# ## #A OneImmutable( ) multiplicative neutral of an element/domain/family #A OneAttr( ) #A One( ) #A Identity( ) #O OneMutable( ) . . . . . . . . multiplicative neutral of an element #O OneOp( ) #O OneSameMutability( ) #O OneSM( ) ## ## <#GAPDoc Label="OneImmutable"> ## ## ## ## ## ## ## ## ## ## ## ## , , ## and return the multiplicative neutral ## element of the multiplicative element obj. ##

## They differ only w.r.t. the mutability of the result. ## is an attribute and hence returns an immutable ## result. ## is guaranteed to return a new mutable ## object whenever a mutable version of the required element exists in &GAP; ## (see ). ## returns a result that is mutable if ## obj is mutable ## and if a mutable version of the required element exists in &GAP;; ## for lists, it returns a result of the same immutability level as ## the argument. For instance, if the argument is a mutable matrix ## with immutable rows, it returns a similar object. ##

## If obj is a multiplicative element then ## OneSameMutability( obj ) ## is equivalent to obj^0. ##

## , and are ## synonyms of OneImmutable. ## is a synonym of . ## is a synonym of . ##

## If obj is a domain or a family then is defined ## as the identity element of all elements in obj, ## provided that all these elements have the same identity. ## For example, the family of all cyclotomics has the identity element ## 1, ## but a collections family (see ) ## may contain matrices of all dimensions and then it cannot have a unique ## identity element. ## Note that is applicable to a domain only if it is a ## magma-with-one (see ); ## use otherwise. ##

## The identity of an object need not be distinct from its zero, ## so for example a ring consisting of a single element can be regarded as a ## ring-with-one (see ). ## This is particularly useful in the case of finitely presented algebras, ## where any factor of a free algebra-with-one is again an algebra-with-one, ## no matter whether or not it is a zero algebra. ##

## The default method of for multiplicative elements calls ## (note that methods for ## must not delegate to ); ## so other methods to compute identity elements need to be installed only ## for and (in the case of copyable objects) ## . ##

## For domains, may call , ## but is allowed to fetch the identity of a ## domain D only if HasOne( D ) is true. ## ## ## <#/GAPDoc> ## DeclareAttribute( "OneImmutable", IsMultiplicativeElementWithOne ); DeclareAttribute( "OneImmutable", IsFamily ); DeclareSynonymAttr( "OneAttr", OneImmutable ); DeclareSynonymAttr( "One", OneImmutable ); DeclareSynonymAttr( "Identity", OneImmutable ); DeclareOperationKernel( "OneMutable", [ IsMultiplicativeElementWithOne ], ONE ); DeclareSynonym( "OneOp", OneMutable); DeclareOperationKernel( "OneSameMutability", [ IsMultiplicativeElementWithOne ], ONE_MUT ); DeclareSynonym( "OneSM", OneSameMutability); ############################################################################# ## #A InverseImmutable( ) . . . . multiplicative inverse of an element #A InverseAttr( ) #A Inverse( ) #O InverseMutable( ) #O InverseOp( ) #O InverseSameMutability( ) . . multiplicative inverse of an element #O InverseSM( ) ## ## <#GAPDoc Label="InverseImmutable"> ## ## ## ## ## ## ## ## ## ## ## , , and ## ## all return the multiplicative inverse of an element elm, ## that is, an element inv such that ## elm * inv = inv * elm ## = One( elm ) holds; ## if elm is not invertible then fail ## (see ) is returned. ##

## Note that the above definition implies that a (general) mapping ## is invertible in the sense of only if its source ## equals its range ## (see ). ## For a bijective mapping f whose source and range differ, ## can be used ## to construct a mapping g with the property ## that f * g is the identity mapping on the source of ## f and g * f is the identity mapping on the ## range of f. ##

## The operations differ only w.r.t. the mutability of the result. ## is an attribute and hence returns an ## immutable result. ## is guaranteed to return a new mutable ## object whenever a mutable version of the required element exists in &GAP;. ## returns a result that is mutable if ## elm is mutable and if a mutable version of the required element ## exists in &GAP;; ## for lists, it returns a result of the same immutability level as ## the argument. For instance, if the argument is a mutable matrix ## with immutable rows, it returns a similar object. ##

## InverseSameMutability( elm ) is equivalent to ## elm^-1. ##

## and are synonyms of ## . ## is a synonym of ## . ## is a synonym of . ##

## The default method of calls ## (note that methods ## for must not delegate to ## ); ## other methods to compute inverses need to be installed only for ## and (in the case of copyable objects) ## . ## ## ## <#/GAPDoc> ## DeclareAttribute( "InverseImmutable", IsMultiplicativeElementWithInverse ); DeclareSynonymAttr( "InverseAttr", InverseImmutable ); DeclareSynonymAttr( "Inverse", InverseImmutable ); DeclareOperationKernel( "InverseMutable", [ IsMultiplicativeElementWithInverse ], INV ); DeclareSynonym( "InverseOp", InverseMutable ); DeclareOperationKernel( "InverseSameMutability", [ IsMultiplicativeElementWithInverse ], INV_MUT ); DeclareSynonym( "InverseSM", InverseSameMutability ); ############################################################################# ## #O `/' . . . . . . . . . . . . . . . . quotient of two elements ## DeclareOperationKernel( "/", [ IsExtRElement, IsMultiplicativeElementWithInverse ], QUO ); ############################################################################# ## #O LeftQuotient( , ) . . . . . . left quotient of two elements ## ## <#GAPDoc Label="LeftQuotient"> ## ## ## ## ## returns the product elm1^(-1) * elm2. ## For some types of objects (for example permutations) this product can be ## evaluated more efficiently than by first inverting elm1 ## and then forming the product with elm2. ## ## ## <#/GAPDoc> ## DeclareOperationKernel( "LeftQuotient", [ IsMultiplicativeElementWithInverse, IsExtLElement ], LQUO ); ############################################################################# ## #O `^' . . . . . . . . . . . . . . . . . power of two elements ## DeclareOperationKernel( "^", [ IsMultiplicativeElement, IsMultiplicativeElement ], POW ); #T How is powering defined for nonassociative multiplication ?? ############################################################################# ## #O Comm( , ) . . . . . . . . . . . commutator of two elements ## ## <#GAPDoc Label="Comm"> ## ## ## ## ## returns the commutator of elm1 and elm2. ## The commutator is defined as the product ## elm1^{{-1}} * elm2^{{-1}} * elm1 * elm2. ##

## a:= (1,3)(4,6);; b:= (1,6,5,4,3,2);; ## gap> Comm( a, b ); ## (1,5,3)(2,6,4) ## gap> LeftQuotient( a, b ); ## (1,2)(3,6)(4,5) ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperationKernel( "Comm", [ IsMultiplicativeElementWithInverse, IsMultiplicativeElementWithInverse ], COMM ); ############################################################################# ## #O LieBracket( , ) . . . . . . . . Lie bracket of two elements ## ## <#GAPDoc Label="LieBracket"> ## ## ## ## ## returns the element ## elm1 * elm2 - elm2 * elm1. ##

## The addition is assumed to be associative ## but not assumed to be commutative ## (see ). ## The multiplication is not assumed to be ## commutative or associative ## (see , ). ## ## ## <#/GAPDoc> ## DeclareOperation( "LieBracket", [ IsRingElement, IsRingElement ] ); ############################################################################# ## #O ` mod ' . . . . . . . . . . . . . . . modulus of two elements ## DeclareOperationKernel( "mod", [ IsObject, IsObject ], MOD ); ############################################################################# ## #A Int( ) . . . . . . . . . . . . . . . . . . integer value of ## ## <#GAPDoc Label="Int"> ## ## ## ## ## returns an integer int whose meaning depends ## on the type of elm. ##

## If elm is a rational number ## (see Chapter ) then int is the ## integer part of the quotient of numerator and denominator of elm ## (see ). ##

## If elm is an element of a finite prime field ## (see Chapter ) then int is the ## smallest nonnegative integer such that ## elm = int * One( elm ). ##

## If elm is a string ## (see Chapter ) consisting of ## digits '0', '1', \ldots, '9' ## and '-' (at the first position) then int is the integer ## described by this string. ## The operation can be used to compute a string for ## rational integers, in fact for all cyclotomics. ##

## Int( 4/3 ); Int( -2/3 ); ## 1 ## 0 ## gap> int:= Int( Z(5) ); int * One( Z(5) ); ## 2 ## Z(5) ## gap> Int( "12345" ); Int( "-27" ); Int( "-27/3" ); ## 12345 ## -27 ## fail ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "Int", IsObject ); ############################################################################# ## #A Rat( ) . . . . . . . . . . . . . . . . . . rational value of ## ## <#GAPDoc Label="Rat"> ## ## ## ## ## returns a rational number rat whose meaning ## depends on the type of elm. ##

## If elm is a string consisting of digits '0', '1', ## \ldots, '9' and '-' (at the first position), ## '/' and the decimal dot '.' then rat is the rational ## described by this string. ## The operation can be used to compute a string for ## rational numbers, in fact for all cyclotomics. ##

## Rat( "1/2" ); Rat( "35/14" ); Rat( "35/-27" ); Rat( "3.14159" ); ## 1/2 ## 5/2 ## -35/27 ## 314159/100000 ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "Rat", IsObject ); ############################################################################# ## #O Sqrt( ) ## ## <#GAPDoc Label="Sqrt"> ## ## ## ## ## returns a square root of obj, that is, ## an object x with the property that x \cdot x = obj ## holds. ## If such an x is not unique then the choice of x depends ## on the type of obj. ## For example, is the method for ## rationals (see ). ## ## ## <#/GAPDoc> ## DeclareOperation( "Sqrt", [ IsMultiplicativeElement ] ); ############################################################################# ## #O Root( , ) #O Root( ) ## ## ## ## ## ## ## ## ## DeclareOperation( "Root", [ IsMultiplicativeElement, IS_INT ] ); ############################################################################# ## #O Log( , ) ## ## ## ## ## ## ## ## DeclareOperation( "Log", [ IsMultiplicativeElement, IsMultiplicativeElement ] ); ############################################################################# ## #A Characteristic( ) . . . characteristic of an element/domain/family ## ## <#GAPDoc Label="Characteristic"> ## ## ## ## ## returns the characteristic of ## obj. ##

## If obj is a family, all of whose elements lie in ## then its characteristic ## is the least positive integer n, if any, such that ## IsZero(n*x) is true for all x in the ## family obj, otherwise it is 0. ##

## If obj is a collections family of a family g which ## has a characteristic, then the characteristic of obj is ## the same as the characteristic of g. ##

## For other families obj the characteristic is not defined ## and fail will be returned. ##

## For any object obj which is in the filter ## or in the filter ## the characteristic of ## obj is the same as the characteristic of its family ## if that is defined and undefined otherwise. ##

## For all other objects obj the characteristic is undefined ## and may return fail or a no method found error. ## ## ## <#/GAPDoc> ## DeclareAttribute( "Characteristic", IsObject ); ############################################################################# ## #A Order( ) ## ## <#GAPDoc Label="Order"> ## ## ## ## ## is the multiplicative order of elm. ## This is the smallest positive integer n such that ## elm ^ n = One( elm ) ## if such an integer exists. If the order is ## infinite, may return the value , ## but it also might run into an infinite loop trying to test the order. ## ## ## <#/GAPDoc> ## DeclareAttribute( "Order", IsMultiplicativeElementWithOne ); ############################################################################# ## #A NormedRowVector( ) ## ## <#GAPDoc Label="NormedRowVector"> ## ## ## ## ## returns a scalar multiple w = c * v ## of the row vector v ## with the property that the first nonzero entry of w is an identity ## element in the sense of . ##

## NormedRowVector( [ 5, 2, 3 ] ); ## [ 1, 2/5, 3/5 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "NormedRowVector", IsRowVector and IsScalarCollection ); ############################################################################# ## #P IsCommutativeFamily ## DeclareProperty( "IsCommutativeFamily", IsFamily ); ############################################################################# ## #P IsSkewFieldFamily ## ## ## ## ## ## ## ## DeclareProperty( "IsSkewFieldFamily", IsFamily ); ############################################################################# ## #P IsUFDFamily( ) ## ## ## ## ## ## the family family is at least a commutative ring-with-one, ## without zero divisors, and the factorisation of each element into ## elements of family is unique (up to units and ordering). ## ## ## DeclareProperty( "IsUFDFamily", IsFamily ); ############################################################################# ## #R IsAdditiveElementAsMultiplicativeElementRep( ) ## ## ## ## ## ## ## ## DeclareRepresentation("IsAdditiveElementAsMultiplicativeElementRep", IsPositionalObjectRep and IsMultiplicativeElement,[]); ############################################################################# ## #A AdditiveElementsAsMultiplicativeElementsFamily( ) ## ## ## ## ## ## ## ## DeclareAttribute("AdditiveElementsAsMultiplicativeElementsFamily", IsFamily); ############################################################################# ## #A AdditiveElementAsMultiplicativeElement( ) ## ## ## ## ## ## for an additive element obj, this attribute returns a multiplicative ## element, for which multiplication is done via addition of the original ## element. The original element of such a wrapped multiplicative ## element can be obtained as the UnderlyingElement. ## ## ## DeclareAttribute("AdditiveElementAsMultiplicativeElement", IsAdditiveElement ); ############################################################################# ## #O UnderlyingElement( ) ## ## ## ## ## ## Let elm be an object which builds on elements of another domain and ## just wraps these up to provide another arithmetic. ## ## ## DeclareOperation( "UnderlyingElement", [ IsObject ] ); ############################################################################# ## #P IsIdempotent( ) ## ## <#GAPDoc Label="IsIdempotent"> ## ## ## ## ## returns true iff elt is its own square. ## (Even if returns true for elt.) ## ## ## <#/GAPDoc> ## DeclareProperty("IsIdempotent", IsMultiplicativeElement); ############################################################################# ## #E gap-4r6p5/lib/csetpc.gi0000644000175000017500000002120012172557252013504 0ustar billbill############################################################################# ## #W csetpc.gi GAP library Alexander Hulpke ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the operations for cosets of pc groups ## ############################################################################# ## #M CanonicalRightCosetElement( , ) . . . . . . . . cce for pcgroups ## ## Main part of the computation of a canonical coset representative in a ## PcGroup. This is done by factoring with the canonical generators of the ## subgroup to set the appropriate exponents to zero. Since the ## representation as an PcWord is "from left to right", we can multiply with ## subgroup elements from _right_, without changing exponents of the ## generators with lower depth (that are supposedly in canonical form yet). ## Since we want _right_ cosets, everything is done with the _inverse_ ## elements, which are representatives for the left cosets. The routine ## supposes, that an Cgs has been set up and the relative orders of the ## generators have been computed by the calling routine. ## InstallMethod(CanonicalRightCosetElement,"Pc",IsCollsElms, [IsPcGroup,IsObject],0, function(U,g) local p,ro,a,d1,d,u,e; p:=HomePcgs(U); ro:=RelativeOrders(p); a:=g^(-1); d1:=DepthOfPcElement(p,a); for u in CanonicalPcgsWrtHomePcgs(U) do d:=DepthOfPcElement(p,u); if d>=d1 then e:=ExponentOfPcElement(p,a,d); a:=a*u^(ro[d]-e); d1:=DepthOfPcElement(p,a); fi; od; return a^(-1); end); ############################################################################# ## #F DoubleCosetsPcGroup( , , ) .. . . . double cosets for Pcgroups ## ## Double Coset calculation for PcGroups, inductive scheme, according to ## Mike Slattery ## BindGlobal("DoubleCosetsPcGroup",function(G,A,B) local r,st,nr,nst,ind,sff,f,m,i,j,ao,Npcgs,v,isi, wbase,neubas,wproj,wg,W,x,mats,U,flip,dr,en,sf,u, Hpcgs,Upcgs,prime,dim,one,zero,affsp, wgr,sp,lgf,ll,Aind; Info(InfoCoset,1,"Affine version"); # if a is small and b large, compute cosets b\G/a and take inverses of the # representatives: Since we compute stabilizers in B and a chain down to # A, this is remarkable faster if 3*Size(A)<2*Size(B) then m:=B; B:=A; A:=m; flip:=true; Info(InfoCoset,1,"DoubleCosetFlip"); else flip:=false; fi; # force elementary abelian Series sp:=PcgsElementaryAbelianSeries(G); lgf:=IndicesEANormalSteps(sp); ll:=Length(lgf); #eas:=[]; #for i in [1..Length(lgf)] do # Add(eas,Subgroup(G,sp{[lgf[i]..Length(sp)]})); #od; r:=[One(G)]; st:=[B]; Aind:=InducedPcgs(sp,A); for ind in [2..ll] do Info(InfoCoset,2,"step ",ind); #kpcgs:=InducedPcgsByPcSequenceNC(sp,sp{[lgf[ind]..Length(sp)]}); #Npcgs:=InducedPcgsByPcSequenceNC(sp,sp{[lgf[ind-1]..Length(sp)]}) mod kpcgs; Npcgs:=ModuloTailPcgsByList(sp,sp{[lgf[ind-1]..lgf[ind]-1]}, [lgf[ind]..Length(sp)]); #Hpcgs:=InducedPcgsByGenerators(sp,Concatenation(GeneratorsOfGroup(A), # kpcgs)); #Hpcgs:=CanonicalPcgs(Hpcgs) mod kpcgs; Hpcgs:=Filtered(Aind,i->DepthOfPcElement(sp,i)ExponentsOfPcElement(Npcgs,i)*one); wbase:=BaseSteinitzVectors(v,isi).factorspace; fi; if Length(wbase)>0 then dr:=[1..Length(wbase)]; # 3 for stripping the affine 1 neubas:=Concatenation(wbase, isi ); wproj:=List(neubas^(-1), i -> i{[1..Length(wbase)]} ); wg:=[]; for i in wbase do Add(wg,PcElementByExponentsNC(Npcgs,i)); od; W:=false; nr:=[]; nst:=[]; for i in [1..Length(r)] do x:=r[i];#FactorAgWord(r[i],fgi); U:=ConjugateGroup(st[i],x^(-1)); # build matrices mats:=[]; Upcgs:=InducedPcgs(sp,U); for u in Upcgs do m:=[]; for j in wg do Add(m,Concatenation((ExponentsConjugateLayer(Npcgs,j,u)*one)*wproj, [zero])); od; Add(m,Concatenation((ExponentsOfPcElement(Npcgs, sff.factorization(u).n)*one)*wproj,[one])); m:=ImmutableMatrix(prime,m); Add(mats,m); od; # modify later: if U trivial if Length(mats)>0 then affsp:=ExtendedVectors(FullRowSpace(f,Length(wg))); ao:=ExternalSet(U,affsp,Upcgs,mats); ao:=ExternalOrbits(ao); ao:=rec(representatives:=List(ao,i-> PcElementByExponentsNC(Npcgs,(Representative(i){dr})*wbase)), stabilizers:=List(ao,StabilizerOfExternalSet)); else if W=false then if Length(wg)=0 then W:=[One(G)]; else en:=Enumerator(FullRowSpace(f,Length(wg))); W:=[]; wgr:=[1..Length(wg)]; for u in en do Add(W,Product(wgr,j->wg[j]^IntFFE(u[j]))); od; fi; fi; ao:=rec( representatives:=W, stabilizers:=List(W,i->U) ); fi; for j in [1..Length(ao.representatives)] do Add(nr,ao.representatives[j]*x); # we will finally just need the stabilizers size and not the # stabilizer if ind, ) . . . . . . . . . for pc groups ## DoRightTransversalPc:=function( G, U ) local elements, g, u, e, i,t,depths,gens,p; t := Objectify( NewType( FamilyObj( G ), IsList and IsDuplicateFreeList and IsRightTransversalPcGroupRep ), rec( group :=G, subgroup :=U, canonReps:=[])); elements := [One(G)]; p := Pcgs( G ); depths:=List( InducedPcgs( p, U ), i->DepthOfPcElement(p,i)); gens:=Filtered(p, i->not DepthOfPcElement(p,i) in depths); for g in Reversed(gens ) do u := One(G); e := ShallowCopy( elements ); for i in [1..RelativeOrderOfPcElement(p,g)-1] do u := u * g; UniteSet( elements, e * u ); od; od; Assert(1,Length(elements)=Index(G,U)); t!.transversal:=elements; return t; end; InstallMethod(RightTransversalOp,"pc groups",IsIdenticalObj, [ IsPcGroup, IsGroup ],0,DoRightTransversalPc); InstallMethod(RightTransversalOp,"pc groups",IsIdenticalObj, [ CanEasilyComputePcgs and HasPcgs, IsGroup ],0,DoRightTransversalPc); InstallMethod(\[\],"for Pc transversals",true, [ IsList and IsRightTransversalPcGroupRep, IsPosInt ],0, function(t,num) return t!.transversal[num]; end ); InstallMethod(AsList,"for Pc transversals",true, [ IsList and IsRightTransversalPcGroupRep ],0, function(t) return t!.transversal; end ); InstallMethod(PositionCanonical,"RT",IsCollsElms, [ IsList and IsRightTransversalPcGroupRep, IsMultiplicativeElementWithInverse ],0, function(t,elm) local i; elm:=CanonicalRightCosetElement(t!.subgroup,elm); i:=1; while i<=Length(t) do if not IsBound(t!.canonReps[i]) then t!.canonReps[i]:= CanonicalRightCosetElement(t!.subgroup,t!.transversal[i]); fi; if elm=t!.canonReps[i] then return i; fi; i:=i+1; od; return fail; end); ############################################################################# ## #E csetpc.gi . . . . . . . . . . . . . . . . . . . . . . . . . . . ends here ## gap-4r6p5/lib/extrset.gd0000644000175000017500000000761312172557252013730 0ustar billbill############################################################################# ## #W extrset.gd GAP library Thomas Breuer ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file declares the operations for external right sets. ## ############################################################################# ## #C IsExtRSet( ) ## ## An external right set is a domain with an action of a domain ## from the right. ## DeclareCategory( "IsExtRSet", IsDomain ); ############################################################################# ## #C IsAssociativeROpDProd( ) ## ## is `true' iff $( x \* y ) \* a = x \* ( y \* a )$ ## for $a \in E$ and $x, y \in D$. ## DeclareCategory( "IsAssociativeROpDProd", IsExtRSet ); ############################################################################# ## #C IsAssociativeROpEProd( ) ## ## is `true' iff $( x \* a ) \* b = x \* ( a \* b )$ ## for $a, b \in E$ and $x \in D$. ## DeclareCategory( "IsAssociativeROpEProd", IsExtRSet ); ############################################################################# ## #C IsDistributiveROpDProd( ) ## ## is `true' iff $( x \* y ) \* a = ( x \* a ) \* ( y \* a )$ ## for $a \in E$ and $x, y \in D$. ## DeclareCategory( "IsDistributiveROpDProd", IsExtRSet ); ############################################################################# ## #C IsDistributiveROpDSum( ) ## ## is `true' iff $( x + y ) \* a = ( x \* a ) + ( y \* a )$ ## for $a \in E$ and $x, y \in D$. ## DeclareCategory( "IsDistributiveROpDSum", IsExtRSet ); ############################################################################# ## #C IsDistributiveROpEProd( ) ## ## is `true' iff $x \* ( a \* b ) = ( x \* a ) \* ( x \* b )$ ## for $a, b \in E$ and $x \in D$. ## DeclareCategory( "IsDistributiveROpEProd", IsExtRSet ); ############################################################################# ## #C IsDistributiveROpESum( ) ## ## is `true' iff $x \* ( a + b ) = ( x \* a ) + ( x \* b )$ ## for $a, b \in E$ and $x \in D$. ## DeclareCategory( "IsDistributiveROpESum", IsExtRSet ); ############################################################################# ## #C IsTrivialROpEOne( ) ## ## is `true' iff the identity element $e \in E$ acts trivially on $D$, ## that is, $x \* e = x$ for $x \in D$. #T necessary? ## DeclareCategory( "IsTrivialROpEOne", IsExtRSet ); ############################################################################# ## #C IsTrivialROpEZero( ) ## ## is `true' iff the zero element $z \in E$ acts trivially on $D$, ## that is, $x \* z = Z$ for $x \in D$ and the zero element $Z$ of $D$. #T necessary? ## DeclareCategory( "IsTrivialROpEZero", IsExtRSet ); ############################################################################# ## #C IsRightActedOnByRing( ) ## DeclareCategory( "IsRightActedOnByRing", IsExtRSet ); ############################################################################# ## #C IsRightActedOnByDivisionRing( ) ## DeclareCategory( "IsRightActedOnByDivisionRing", IsRightActedOnByRing ); ############################################################################# ## #C IsRightActedOnBySuperset( ) ## DeclareCategory( "IsRightActedOnBySuperset", IsExtRSet ); ############################################################################# ## #A GeneratorsOfExtRSet( ) ## DeclareAttribute( "GeneratorsOfExtRSet", IsExtRSet ); ############################################################################# ## #A RightActingDomain( ) ## DeclareAttribute( "RightActingDomain", IsExtRSet ); ############################################################################# ## #E extrset.gd . . . . . . . . . . . . . . . . . . . . . . . . . . ends here gap-4r6p5/lib/wpobj.gd0000644000175000017500000000356312172557254013355 0ustar billbill############################################################################# ## #W wpobj.gd GAP library Steve Linton ## ## #Y Copyright (C) 1997, #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the definition of operations and functions for ## weak pointers. ## ## WP objects behave in most respects like mutable plain lists, except that ## they do not keep their subobjects alive, so that one sees things like. ## ## gap> w := WeakPointerObj([[1,2]]);; ## gap> IsBound(w[1]); ## true ## gap> GASMAN("collect"); ## gap> w; ## WeakPointerObj([ [ ] ]); ## ## for this reason the common idiom ## ## if IsBound(w[i]) then ## DoSomethigWith(w[i]); ## fi; ## ## is not really safe. ## ## A solution is provided by the kernel function ElmWPObj (weakptr.c), which ## returns fail if the entry is (1) unbound or (2) bound to the value fail. ## Since fail will never be collected as garbage, a subsequent call to IsBound ## can safely be used to distinguish these two cases, as in: ## ## x := ElmWPObj(w,i); ## if x <> fail or IsBound(w[i]) then ## DoSomethingWith(x); ## else ## DoSomethingElse(); ## fi; ## ############################################################################# ## ## #C IsWeakPointerObject( ) . . . . . . . . . . category of WP objects ## ## All WP objects have to be mutable (a stronger term like volatile would ## be appropriate), ## but this cannot be expressed via an explicit implication; ## note that `Immutable' is handled by the kernel. ## DeclareCategoryKernel( "IsWeakPointerObject", IsList and IsSmallList, IsWPObj ); ############################################################################# ## #E wpobj.gd . . . . . . . . . . . . . . . . . . . . . . . . . . . ends here ## gap-4r6p5/lib/hash.gd0000644000175000017500000002045212172557252013151 0ustar billbill############################################################################# ## #W hash.gd GAP library Steve Linton ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## Hash tables module, declarations part. ## ## The basic idea of the hash tables module is that hash tables are a ## representation of general mappings. Unlike many representations of ## mappings they are often mutable (and, indeed only likely to be a sensible ## choice of representation when mutability is needed) ## ############################################################################# ## #C IsExtensibleGeneralMapping(obj) category of general mappings (relations) ## to which new (source, image) pairs can ## be added using AddImage ## ## We cannot imply IsMutable because Immutable may take it away at any time ## DeclareCategory("IsExtensibleGeneralMapping", IsNonSPGeneralMapping and IsFinite and IsCopyable); ############################################################################# ## #C IsFlexibleGeneralMapping(obj) category of general mappings (relations) ## to which new (source, image) pairs can ## be added using AddImage and from which ## they can be deleted using DeleteImage ## DeclareCategory("IsFlexibleGeneralMapping", IsExtensibleGeneralMapping); ############################################################################# ## #C IsExtensiblePartialMapping single-valued mutable mappings #C IsFlexiblePartialMapping ## ## AddImage may signal an error for these mappings if an image is already ## present. SetImage will over-ride an existing image ## IsExtensiblePartialMapping := IsExtensibleGeneralMapping and IsSingleValued; IsFlexiblePartialMapping := IsFlexibleGeneralMapping and IsSingleValued; ############################################################################# ## #O AddImage( , , ) add a new pair to an extensible ## general mapping ## ## This should signal an error if the mapping is single-valued ## by representation and has an image already ## DeclareOperation("AddImage", [ IsExtensibleGeneralMapping and IsMutable, IsObject, IsObject ]); ############################################################################# ## #O AddImageNC( , , ) add a new pair to an extensible ## general mapping without checks ## ## This makes two assumptions. ## Firstly that and are in the ## source and range of the map, and secondly that if is required to ## be single-valued then currently has no images under . ## DeclareOperation("AddImageNC", [ IsExtensibleGeneralMapping and IsMutable, IsObject, IsObject ]); ############################################################################# ## #O SetImage( , , ) set the image of under the ## extensible single-valued mapping ## ## This assumes that and are in the source and range ## respectively DeclareOperation("SetImage", [ IsExtensiblePartialMapping and IsMutable, IsObject, IsObject ]); ############################################################################# ## #O DeleteImage( , , ) remove a pair from a flexible ## general mapping ## ## Raises an error if the pair is not present ## DeclareOperation("DeleteImage", [ IsFlexibleGeneralMapping and IsMutable, IsObject, IsObject ]); ############################################################################# ## #O UnSetImage( , ) unbind the image of under a ## flexible single-values mapping ## DeclareOperation("UnSetImage", [IsFlexiblePartialMapping and IsMutable, IsObject]); ############################################################################# ## #O HashTable( , , ) create a hash table ## ## These hash tables are extensible, but not necessarily flexible general ## mappings. See the other constructors for other possibilities ## ## They are created empty. ## ## The hash function must be a one argument function that takes an object of ## the family of the elements of and returns either fail, implying that ## the argument was not in source, or an integer which will be used for hashing. ## ## It is the decision of the supplier of ## whether to test for membership in ## in , to hash every element of the family, or to ## take care never to pass a point not in ## ## Methods for AddImage will normally test for membership in the . ## Those for AddImageNC will not. The user may additionally wish to enlarge ## the range to a domain with a faster membership test. ## #T Supply a selection of general-purpose hash functions ## DeclareOperation("HashTable", [IsCollection, IsCollection, IsFunction]); ############################################################################# ## #O ShrinkableHashTable( , , ) ## create a shrinkable hash table ## ## These hash tables are flexible general ## mappings. See the other constructors for other possibilities ## ## See HashTable for the specification of the arguments ## DeclareOperation("ShrinkableHashTable", [IsCollection, IsCollection, IsFunction]); ############################################################################# ## #O SingleValuesHashTable( , , ) ## create a single-valued hash table ## ## These hash tables are extensible partial ## mappings. See the other constructors for other possibilities ## ## See HashTable for the specification of the arguments ## DeclareOperation("SingleValuedHashTable", [IsCollection, IsCollection, IsFunction]); ############################################################################# ## #O ShrinkableSingleValuesHashTable( , , ) ## create a shrinkable single-valued hash table ## ## These hash tables are flexible partial ## mappings. See the other constructors for other possibilities ## ## See HashTable for the specification of the arguments ## DeclareOperation("ShrinkableSingleValuedHashTable", [IsCollection, IsCollection, IsFunction]); ############################################################################# ## #F HashKeyBag(,,,) ## ## returns a hash key which is given by the bytes in the bag storing ## in -adic representation. The result is reduced modulo $2^{28}$ ## to obtain a small integer. ## As some objects carry excess data in their bag, the first bytes ## will be skipped and bytes (a value of -1 represents infinity) ## will be read at most. (The proper values for these numbers might depend on ## the internal representation used as well as on the word length of the ## machine on which {\GAP} is running and care has to be taken when using ## `HashKeyBag' to ensure identical key values for equal objects.) ## ## The values returned by `HashKeyBag' are not guaranteed to be portable ## between different runs of {\GAP} and no reference to their absolute ## values ought to be made. ## BindGlobal("HashKeyBag",HASHKEY_BAG); ############################################################################# ## #E hash.gd . . . . . . . . . . . . . . . . . . . . . . . . . . . . ends here gap-4r6p5/lib/record.g0000644000175000017500000003073012172557254013342 0ustar billbill############################################################################# ## #W record.g GAP library Thomas Breuer #W & Frank Celler ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains methods for records. ## Compared to &GAP; 3, where records were used to represent domains and ## all kinds of external arithmetic objects, in &GAP; 4 there is no ## important role for records. ## So the standard library provides only methods for `PrintObj', `String', ## `=', and `<', and the latter two are not installed to compare records ## with objects in other families. ## ## In order to achieve a special behaviour of records as in &GAP; 3 such ## that a record can be regarded as equal to objects in other families ## or such that a record can be compared via `<' with objects in other ## families, one can load the file `compat3c.g'. ## ############################################################################# ## #C IsRecord( ) #C IsRecordCollection( ) #C IsRecordCollColl( ) ## ## <#GAPDoc Label="IsRecord"> ## ## ## ## ## ## ## test ## IsRecord( rec( a := 1, b := 2 ) ); ## true ## gap> IsRecord( IsRecord ); ## false ## ]]> ## ## ## <#/GAPDoc> ## DeclareCategoryKernel( "IsRecord", IsObject, IS_REC ); DeclareCategoryCollections( "IsRecord" ); DeclareCategoryCollections( "IsRecordCollection" ); ############################################################################# ## #V RecordsFamily . . . . . . . . . . . . . . . . . . . . . family of records ## ## ## ## ## ## ## ## BIND_GLOBAL( "RecordsFamily", NewFamily( "RecordsFamily", IS_REC ) ); ############################################################################# ## #V TYPE_PREC_MUTABLE . . . . . . . . . . . type of a mutable internal record ## ## ## ## ## ## ## ## BIND_GLOBAL( "TYPE_PREC_MUTABLE", NewType( RecordsFamily, IS_MUTABLE_OBJ and IS_REC and IsInternalRep ) ); ############################################################################# ## #V TYPE_PREC_IMMUTABLE . . . . . . . . type of an immutable internal record ## ## ## ## ## ## ## ## BIND_GLOBAL( "TYPE_PREC_IMMUTABLE", NewType( RecordsFamily, IS_REC and IsInternalRep ) ); ############################################################################# ## #o \.( , ) . . . . . . . . . . . . . . . . get a component value ## DeclareOperationKernel( ".", [ IsObject, IsObject ], ELM_REC ); ############################################################################# ## #o IsBound\.( , ) . . . . . . . . . . . . . . test a component ## DeclareOperationKernel( "IsBound.", [ IsObject, IsObject ], ISB_REC ); ############################################################################# ## #o \.\:\=( , , ) . . . . . . . . . . . . . assign a value ## DeclareOperationKernel( ".:=", [ IsObject, IsObject, IsObject ], ASS_REC ); ############################################################################# ## #o Unbind\.( , ) . . . . . . . . . . . . . . . unbind component ## DeclareOperationKernel( "Unbind.", [ IsObject, IsObject ], UNB_REC ); ############################################################################# ## #A RecNames( ) ## ## <#GAPDoc Label="RecNames"> ## ## ## ## ## returns a list of strings corresponding to the names of the record ## components of the record record. ##

## r := rec( a := 1, b := 2 );; ## gap> Set(RecNames( r )); # 'Set' because ordering depends on GAP session ## [ "a", "b" ] ## ]]> ##

## Note that you cannot use the string result in the ordinary way to access ## or change a record component. ## You can use the record.(name) construct for that, ## see and ## . ## ## ## <#/GAPDoc> ## DeclareAttribute( "RecNames", IsRecord ); DeclareSynonym( "RecFields", RecNames ); ############################################################################# ## #M RecNames( ) . . . . . . . . . . . . . . . . names of components ## InstallMethod( RecNames, "for a record in internal representation", [ IsRecord and IsInternalRep ], REC_NAMES ); ############################################################################# ## #F NamesOfComponents( ) ## ## <#GAPDoc Label="NamesOfComponents"> ## ## ## ## ## For a component object comobj, ## returns a list of strings, ## which are the names of components currently bound in comobj. ##

## For a record comobj, ## returns the result of ## . ## ## ## <#/GAPDoc> ## BIND_GLOBAL( "NamesOfComponents", function( obj ) if IsComponentObjectRep( obj ) then return REC_NAMES_COMOBJ( obj ); elif IsRecord( obj ) then return RecNames( obj ); else Error( " must be a component object or a record" ); fi; end ); ############################################################################# ## #m PrintObj( ) ## ## The record is printed by printing all its components. ## InstallMethod( PrintObj, "record", [ IsRecord ], ## Changed to use sorted component names to make printing nicer to read and ## independent of session (i.e., the ordering in which component names were ## first used). Except for the sorting of components this does the same as ## the former (now removed) kernel function FuncPRINT_PREC_DEFAULT. function( record ) local okchars, com, i, snam, nam; okchars := "0123456789@ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"; Print("\>\>rec(\n\>\>"); com := false; i := 1; for nam in Set(RecNames( record )) do if com then Print("\<\<,\n\>\>"); else com := true; fi; SET_PRINT_OBJ_INDEX(i); i := i+1; # easy if nam is integer or valid identifier: if ForAll(nam, x-> x in okchars) then Print(nam, "\< := \>"); else # otherwise we use (...) syntax: snam := String(nam); Print("("); View(snam); Print(")\< := \>"); fi; PrintObj(record.(nam)); od; Print(" \<\<\<\<)"); end); ############################################################################# ## #m String( ) . . . . . . . . . . . . . . . . . . . . for a record ## InstallMethod( String, "record", [ IsRecord ], function( record ) local str, nam, com; str := "rec( "; com := false; for nam in Set(RecNames( record )) do if com then Append( str, ", " ); else com := true; fi; Append( str, nam ); Append( str, " := " ); if IsStringRep( record.( nam ) ) or ( IsString( record.( nam ) ) and not IsEmpty( record.( nam ) ) ) then Append( str, "\"" ); Append( str, String( record.(nam) ) ); Append( str, "\"" ); else Append( str, String( record.(nam) ) ); fi; od; Append( str, " )" ); # should not be necessary if all methods for components are alright ConvertToStringRep( str ); return str; end ); ############################################################################# ## #m ViewObj( ) . . . . . . . . . . . . . . . for a record (default) ## InstallMethod( ViewObj, "record", [ IsRecord ], function( record ) local nam, com, i, snam, okchars; okchars := "0123456789@ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"; Print("\>\>rec( \>\>"); com := false; i := 1; for nam in Set(RecNames( record )) do if com then Print("\<,\< \>\>"); else com := true; fi; SET_PRINT_OBJ_INDEX(i); i := i+1; # easy if nam is integer or valid identifier: if ForAll(nam, x-> x in okchars) then Print(nam, " := "); else # otherwise we use (...) syntax: snam := String(nam); Print("("); View(snam); Print(") := "); fi; ViewObj(record.(nam)); od; Print(" \<\<\<\<)"); end); ############################################################################# ## #m = ## InstallMethod( \=, "record = record", IsIdenticalObj, [ IsRecord, IsRecord ], EQ_PREC ); ############################################################################# ## #m < ## InstallMethod( \<, "record < record", IsIdenticalObj, [ IsRecord, IsRecord ], LT_PREC ); # methods to catch error cases ############################################################################# ## #m \. ## InstallMethod(\.,"catch error",true,[IsObject,IsObject],0, function(obj,nr) local msg; msg:=Concatenation("illegal access to record component `obj.", NameRNam(nr),"'\n", "of the object . (Objects by default do not have record components.\n", "The error might be a relic from translated GAP3 code.) "); Error(msg); end); ############################################################################# ## #m IsBound\. ## InstallMethod(IsBound\.,"catch error",true,[IsObject,IsObject],0, function(obj,nr) local msg; msg:=Concatenation("illegal access to record component `IsBound(obj.", NameRNam(nr),")'\n", "of the object . (Objects by default do not have record components.\n", "The error might be a relic from translated GAP3 code.) "); Error(msg); end); ############################################################################# ## #m Unbind\. ## InstallMethod(Unbind\.,"catch error",true,[IsObject,IsObject],0, function(obj,nr) local msg; msg:=Concatenation("illegal access to record component `Unbind(obj.", NameRNam(nr),")'\n", "of the object . (Objects by default do not have record components.\n", "The error might be a relic from translated GAP3 code.) "); Error(msg); end); ############################################################################# ## #m \.\:\= ## InstallMethod(\.\:\=,"catch error",true,[IsObject,IsObject,IsObject],0, function(obj,nr,elm) local msg; msg:=Concatenation("illegal assignement to record component `obj.", NameRNam(nr),"'\n", "of the object . (Objects by default cannot have record components.\n", "The error might be a relic from translated GAP3 code.) "); Error(msg); end); ############################################################################# ## #F SetNamesForFunctionsInRecord( [, ][, ]) ## ## set the names of functions bound to components of a record. ## BIND_GLOBAL("SetNamesForFunctionsInRecord", function( arg ) local recname, next, record, fields, field; if LENGTH(arg) = 0 or not IS_STRING(arg[1]) then Error("SetNamesForFunctionsInRecord: you must give a record name"); fi; recname := arg[1]; next := 2; if LENGTH(arg) >= next and IS_REC(arg[next]) then record := arg[2]; next := 3; else record := VALUE_GLOBAL(recname); fi; if LENGTH(arg) >= next and IS_LIST(arg[next]) then fields := arg[next]; else fields := REC_NAMES(record); fi; for field in fields do if IS_STRING(field) then if IsFunction(record.(field)) then SetNameFunction(record.(field), Concatenation(recname,".",field)); fi; fi; od; end); ############################################################################# ## #E gap-4r6p5/lib/grpffmat.gi0000644000175000017500000005062212172557252014043 0ustar billbill############################################################################# ## #W grpffmat.gi GAP Library Frank Celler #W Frank Lübeck #W Stefan Kohl ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the operations for matrix groups over finite field. ## ############################################################################# ## #M FieldOfMatrixGroup( ) ## InstallMethod( FieldOfMatrixGroup, true, [ IsFFEMatrixGroup ], 0, function( grp ) local gens; gens := GeneratorsOfGroup(grp); if Length(gens)=0 then return FieldOfMatrixList([One(grp)]); else return FieldOfMatrixList(gens); fi; end ); ############################################################################# ## #M FieldOfMatrixList ## InstallMethod(FieldOfMatrixList,"finite field matrices",true, [IsListOrCollection and IsFFECollCollColl],0, function(l) local deg, i, j, char; if Length(l)=0 then Error("list must be nonempty");fi; deg := 1; for i in l do for j in i do deg := LcmInt( deg, DegreeFFE(j) ); od; od; char := Characteristic(l[1][1]); return GF(char^deg); end); ############################################################################# ## #M DefaultScalarDomainOfMatrixList ## InstallMethod(DefaultScalarDomainOfMatrixList,"finite field matrices",true, [IsListOrCollection and IsFFECollCollColl],0, function(l) local deg, i, j, char,m; if Length(l)=0 then Error("list must be nonempty");fi; deg := 1; for i in l do # treat compact matrices quickly if IsGF2MatrixRep(i) then deg:=deg; # always in elif Is8BitMatrixRep(i) then j:=Q_VEC8BIT(i![2]); deg:=LcmInt( deg, Length(Factors(j))); else for j in i do deg := LcmInt( deg, DegreeFFE(j) ); od; fi; od; char := Characteristic(l[1][1]); return GF(char^deg); end); ############################################################################# ## #M IsNaturalGL( ) ## InstallMethod( IsNaturalGL, "size comparison", true, [ IsFFEMatrixGroup and IsFinite ], 0, function( grp ) return Size( grp ) = Size( GL( DimensionOfMatrixGroup( grp ), Size( FieldOfMatrixGroup( grp ) ) ) ); end ); InstallMethod( IsNaturalSL, "size comparison", true, [ IsFFEMatrixGroup and IsFinite ], 0, function( grp ) local gen, d, f; f := FieldOfMatrixGroup( grp ); d := DimensionOfMatrixGroup( grp ); gen := GeneratorsOfGroup( grp ); return ForAll(gen, x-> DeterminantMat(x) = One(f)) and Size(grp) = Size(SL(d, Size(f))); end ); ############################################################################# ## #M NiceMonomorphism( ) ## InstallGlobalFunction( NicomorphismFFMatGroupOnFullSpace, function( grp ) local field, dim, V, xset, nice; field := FieldOfMatrixGroup( grp ); dim := DimensionOfMatrixGroup( grp ); V := field ^ dim; xset := ExternalSet( grp, V ); # STILL: reverse the base to get point sorting compatible with lexicographic # vector arrangement SetBaseOfGroup( xset, One( grp )); nice := ActionHomomorphism( xset,"surjective" ); if not HasNiceMonomorphism(grp) then SetNiceMonomorphism(grp,nice); fi; SetIsInjective( nice, true ); SetFilterObj(nice,IsNiceMonomorphism); # because we act on the full space we are canonical. SetIsCanonicalNiceMonomorphism(nice,true); return nice; end ); InstallMethod( NiceMonomorphism, "falling back on GL", true, [ IsFFEMatrixGroup and IsFinite ], 0, function( grp ) # is it GL? if (HasIsNaturalGL( grp ) and IsNaturalGL( grp )) or (HasIsNaturalSL( grp ) and IsNaturalSL( grp )) then return NicomorphismFFMatGroupOnFullSpace(grp); fi; # is the GL domain small enough to simply use it? if IsTrivial(grp) or Size(FieldOfMatrixGroup(Parent(grp)))^DimensionOfMatrixGroup(grp) >2000 then # if the permutation image would be too large, compute the orbit. TryNextMethod(); fi; return NicomorphismFFMatGroupOnFullSpace( GL( DimensionOfMatrixGroup( grp ), Size( FieldOfMatrixGroup( Parent(grp) ) ) ) ); end ); ############################################################################# ## #M ProjectiveActionOnFullSpace(,,) ## InstallGlobalFunction(ProjectiveActionOnFullSpace,function(g,f,n) local o,i,s; # as the groups are large, we can take all normed vectors o:=NormedRowVectors(f^n); s:=Size(f); for i in o do ConvertToVectorRep(i,s); MakeImmutable(i); od; o:=Set(o); return Action(g,o,OnLines); end); ############################################################################# ## #M Size( ) ## InstallMethod( Size, "general linear group", true, [ IsFFEMatrixGroup and IsFinite and IsNaturalGL ], 0, function( G ) local n, q, size, qi, i; n := DimensionOfMatrixGroup(G); q := Size( FieldOfMatrixGroup(G) ); size := q-1; qi := q; for i in [ 2 .. n ] do qi := qi * q; size := size * (qi-1); od; return q^(n*(n-1)/2) * size; end ); InstallMethod(Size,"natural SL",true, [IsFFEMatrixGroup and IsNaturalSL and IsFinite],0, function(G) local q,n,size,i,qi; n:=DimensionOfMatrixGroup(G); q:=Size(FieldOfMatrixGroup(G)); size := 1; qi := q; for i in [ 2 .. n ] do qi := qi * q; size := size * (qi-1); od; return q^(n*(n-1)/2) * size; end); InstallMethod( \in, "general linear group", IsElmsColls, [ IsMatrix, IsFFEMatrixGroup and IsFinite and IsNaturalGL ], 0, function( mat, G ) return Length( mat ) = Length( mat[ 1 ] ) and Length( mat ) = DimensionOfMatrixGroup( G ) and ForAll( mat, row -> IsSubset( FieldOfMatrixGroup( G ), row ) ) and Length( mat ) = RankMat( mat ); end ); InstallMethod( \in, "special linear group", IsElmsColls, [ IsMatrix, IsFFEMatrixGroup and IsFinite and IsNaturalSL ], 0, function( mat, G ) return Length( mat ) = Length( mat[ 1 ] ) and Length( mat ) = DimensionOfMatrixGroup( G ) and ForAll( mat, row -> IsSubset( FieldOfMatrixGroup( G ), row ) ) and Length( mat ) = RankMat( mat ) and DeterminantMat(mat)=One(FieldOfMatrixGroup( G )); end ); ############################################################################# ## #F SizePolynomialUnipotentClassGL( ) . . . . . . centralizer order of #F unipotent elements in GL_n( q ) ## ## must be a partition of, say, n. ## ## This function returns a pair [coefficient list, valuation] defining a ## polynomial over the integers, having the following property: The order ## of the centralizer of a unipotent element in GL_n(q), q a prime power, ## with Jordan block sizes given by , is the value of this polynomial ## at q. ## SizePolynomialUnipotentClassGL := function(la) local lad, n, nla, ri, tmp, phila, i, a; lad := AssociatedPartition(la); n := Sum(la); nla := Sum(lad, i->i*(i-1)/2); ri := List([1..Maximum(la)], i-> Number(la, x-> x=i)); ## the following should be ## T := Indeterminate(Rationals); ## phila := Product(Concatenation(List(ri, ## r-> List([1..r], j-> (1-T^j))))); ## return T^(n+2*nla)*Value(phila,1/T); ## but for now (or ever?) we avoid polynomials tmp := Concatenation(List(ri, r-> [1..r])); phila := [1]; for i in tmp do a := 0*[1..i+1]; a[1] := 1; a[i+1] := -1; phila := ProductCoeffs(phila, a); od; return [Reversed(phila), n+2*nla-Length(phila)+1]; end; ############################################################################# ## #M ConjugacyClassesOfNaturalGroup( ) ## InstallGlobalFunction( ConjugacyClassesOfNaturalGroup, function( G, flag ) local mycartesian, fill, myval, pols, nrpols, pairs, types, a, a2, pos, i, tup, arr, mat, cen, b, c, cl, powerpol, one, n, q, cls, new, o, m, rep, gcd; # to handle single argument mycartesian := function(arg) if Length(arg[1]) = 1 then return List(arg[1][1], x-> [x]); else return Cartesian(arg[1]); fi; end; # small helper fill := function(l, pos, val) l := ShallowCopy(l); l{pos} := val; return l; end; # since polynomials are just lists of coefficients powerpol := function(c, r) local pr, i; if r=1 then return c; else pr := c; for i in [2..r] do pr := ProductCoeffs(pr, c); od; return pr; fi; end; # Value for polynomials as [coeffs,val] myval := function(p, x) local r, c; r := 0*x; for c in Reversed(p[1]) do r := x*r+c; od; return r*x^p[2]; end; # set up n := DimensionOfMatrixGroup( G ); q := Size( FieldOfMatrixGroup( G ) ); o := Size( G ); cls := []; # irreducible polynomials up to degree n pols := List([1..n], i-> AllIrreducibleMonicPolynomialCoeffsOfDegree(i, q)); # remove minimal polynomial of 0 pols[1] := Difference(pols[1],[[0,1]*Z(q)^0]); nrpols := List(pols, Length); # parameters for semisimple class types # typ in types is of form [[m1,n1],...,[mr,nr]] standing for a centralizer # of type GL_m1(q^n1) x ... x GL_mr(q^nr) pairs := List([1..n], i->List(DivisorsInt(i), j-> [j,i/j])); types := Concatenation(List(Partitions(n), a-> mycartesian(pairs{a}))); for a in types do Sort(a); od; # 'Reversed' to get central elements first types := Reversed(Set(types)); for a in types do a2 := List(a,x->x[2]); pos := []; for i in Set(a2) do pos[i] := []; od; for i in [1..Length(a2)] do Add(pos[a2[i]], i); od; # find representatives of semisimple classes corresponding to type tup := [[]]; for i in Set(a2) do arr := Arrangements([1..nrpols[i]], Length(pos[i])); tup := Concatenation(List(tup, b-> List(arr, c-> fill(b, pos[i], c)))); od; # merge with 'a' to remove duplicates tup := List(tup, b-> List([1..Length(a)], i-> Concatenation(a[i],[b[i]]))); tup := Set(List(tup,Set)); # now append partitions for distinguishing the unipotent parts tup := Concatenation(List(tup, a-> Cartesian(List(a,x->List(Partitions(x[1]),b-> Concatenation(x,[b])))))); Append(cls, tup); od; # in the sl-case if flag then rep := List([1..Gcd(q-1, n)-1], i-> IdentityMat(n, GF(q))); for i in [1..Gcd(q-1, n)-1] do rep[i][n][n] := Z(q)^i; od; fi; # now convert into actual matrices and compute centralizer order cl := []; one := One(GF(q)); for a in cls do mat := []; cen := 1; for b in a do for c in b[4] do Add(mat, powerpol(pols[b[2]][b[3]], c)); od; cen := cen * myval(SizePolynomialUnipotentClassGL(b[4]), q^b[2]); od; mat := one * DirectSumMat(List(mat, CompanionMat)); # in the sl-case we have to split this class if flag then if DeterminantMat(mat)=Z(q)^0 then gcd := Gcd(Concatenation(List(a, b-> b[4]))); gcd := Gcd(gcd, q-1); mat := [mat]; for i in [1..gcd-1] do Add(mat, mat[1]^rep[i]); od; for m in mat do new := ConjugacyClass( G, m ); SetSize( new, (o*(q-1))/(cen*gcd) ); Add( cl, new ); od; fi; else new := ConjugacyClass( G, mat ); SetSize( new, o/cen ); Add(cl, new ); fi; od; # obey general rule in GAP to put class of identity first i := First([1..Length(cl)], c-> Representative(cl[c]) = One(G)); if i <> 1 then a := cl[i]; cl[i] := cl[1]; cl[1] := a; fi; return cl; end ); ############################################################################# ## #M ConjugacyClasses( ) . . . . . . . . . . . . . . . . . for natural GL ## InstallMethod( ConjugacyClasses, "for natural gl", true, [IsFFEMatrixGroup and IsFinite and IsNaturalGL], 0, G -> ConjugacyClassesOfNaturalGroup( G, false ) ); ############################################################################# ## #M ConjugacyClasses( ) . . . . . . . . . . . . . . . . . for natural SL ## InstallMethod( ConjugacyClasses, "for natural sl", true, [IsFFEMatrixGroup and IsFinite and IsNaturalSL], 0, G -> ConjugacyClassesOfNaturalGroup( G, true ) ); ############################################################################# ## #M Random( ) . . . . . . . . . . . . . . . . . . . . . . for natural GL ## InstallMethod( Random, "for natural GL", true, [ IsFFEMatrixGroup and IsFinite and IsNaturalGL ], 0, function(G) local m; m := RandomInvertibleMat( DimensionOfMatrixGroup( G ), FieldOfMatrixGroup( G ) ); MakeImmutable(m); ConvertToMatrixRep(m, FieldOfMatrixGroup(G)); return m; end ); ############################################################################# ## #M Random( ) . . . . . . . . . . . . . . . . . . . . . . for natural SL ## ## We use that the matrices obtained from the identity matrix by setting the ## entry in the upper left corner to arbitrary nonzero values in the field ## $F$ form a set of coset representatives of $SL(n,F)$ in $GL(n,F)$. ## InstallMethod( Random, "for natural SL", true, [ IsFFEMatrixGroup and IsFinite and IsNaturalSL ], 0, function( G ) local m; m:= RandomInvertibleMat( DimensionOfMatrixGroup( G ), FieldOfMatrixGroup( G ) ); MultRowVector(m[1], DeterminantMat(m)^-1); MakeImmutable(m); ConvertToMatrixRep(m, FieldOfMatrixGroup(G)); return m; end ); ############################################################################# ## #F Phi2( ) . . . . . . . . . . . . Modification of Euler's Phi function ## ## This is needed for the computation of the class numbers of SL(n,q), ## PSL(n,q), SU(n,q) and PSU(n,q) ## InstallGlobalFunction(Phi2, n -> n^2 * Product(Set(Filtered(FactorsInt(n), m -> m <> 1)), p -> (1 - 1/p^2))); ############################################################################# ## #F NrConjugacyClassesGL( , ) . . . . . . . . Class number for GL(n,q) ## ## This is also needed for the computation of the class numbers of PGL(n,q), ## SL(n,q) and PSL(n,q) ## InstallGlobalFunction(NrConjugacyClassesGL, function(n,q) return Sum(Partitions(n), v -> Product(List(Set(v), i -> Number(v, j -> j = i)), n_i -> q^n_i - q^(n_i - 1))); end); ############################################################################# ## #F NrConjugacyClassesSLIsogeneous( , , ) ## ## Class number for group isogeneous to SL(n,q) ## InstallGlobalFunction(NrConjugacyClassesSLIsogeneous, function(n,q,f) return Sum(Cartesian(DivisorsInt(Gcd( f,q - 1)), DivisorsInt(Gcd(n/f,q - 1))), d -> Phi(d[1]) * Phi2(d[2]) * NrConjugacyClassesGL(n/Product(d),q))/(q - 1); end); ############################################################################# ## #F NrConjugacyClassesSL( , ) . . . . . . . Class number for SL(n,q) ## InstallGlobalFunction(NrConjugacyClassesSL, function(n,q) return NrConjugacyClassesSLIsogeneous(n,q,1); end); ############################################################################# ## #F NrConjugacyClassesPGL( , ) . . . . . . . Class number for PGL(n,q) ## InstallGlobalFunction(NrConjugacyClassesPGL, function(n,q) return NrConjugacyClassesSLIsogeneous(n,q,n); end); ############################################################################# ## #F NrConjugacyClassesPSL( , ) . . . . . . . Class number for PSL(n,q) ## InstallGlobalFunction(NrConjugacyClassesPSL, function(n,q) return Sum(Filtered(Cartesian(DivisorsInt(q - 1),DivisorsInt(q - 1)), d -> n mod Product(d) = 0), d -> Phi(d[1]) * Phi2(d[2]) * NrConjugacyClassesGL(n/Product(d),q)/(q - 1))/Gcd(n,q - 1); end); ############################################################################# ## #F NrConjugacyClassesGU( , ) . . . . . . . . Class number for GU(n,q) ## ## This is also needed for the computation of the class numbers of PGU(n,q), ## SU(n,q) and PSU(n,q) ## InstallGlobalFunction(NrConjugacyClassesGU, function(n,q) return Sum(Partitions(n), v -> Product(List(Set(v), i -> Number(v, j -> j = i)), n_i -> q^n_i + q^(n_i - 1))); end); ############################################################################# ## #F NrConjugacyClassesSUIsogeneous( , , ) ## ## Class number for group isogeneous to SU(n,q) ## InstallGlobalFunction(NrConjugacyClassesSUIsogeneous, function(n,q,f) return Sum(Cartesian(DivisorsInt(Gcd( f,q + 1)), DivisorsInt(Gcd(n/f,q + 1))), d -> Phi(d[1]) * Phi2(d[2]) * NrConjugacyClassesGU(n/Product(d),q))/(q + 1); end); ############################################################################# ## #F NrConjugacyClassesSU( , ) . . . . . . . Class number for SU(n,q) ## InstallGlobalFunction(NrConjugacyClassesSU, function(n,q) return NrConjugacyClassesSUIsogeneous(n,q,1); end); ############################################################################# ## #F NrConjugacyClassesPGU( , ) . . . . . . . Class number for PGU(n,q) ## InstallGlobalFunction(NrConjugacyClassesPGU, function(n,q) return NrConjugacyClassesSUIsogeneous(n,q,n); end); ############################################################################# ## #F NrConjugacyClassesPSU( , ) . . . . . . . Class number for PSU(n,q) ## InstallGlobalFunction(NrConjugacyClassesPSU, function(n,q) return Sum(Filtered(Cartesian(DivisorsInt(q + 1),DivisorsInt(q + 1)), d -> n mod Product(d) = 0), d -> Phi(d[1]) * Phi2(d[2]) * NrConjugacyClassesGU(n/Product(d),q)/(q + 1))/Gcd(n,q + 1); end); ############################################################################# ## #M NrConjugacyClasses( ) . . . . . . . . . . Method for natural GL(n,q) ## InstallMethod( NrConjugacyClasses, "for natural GL", true, [ IsFFEMatrixGroup and IsFinite and IsNaturalGL ], 0, function ( G ) local n,q; n := DimensionOfMatrixGroup(G); q := Size(FieldOfMatrixGroup(G)); return NrConjugacyClassesGL(n,q); end ); ############################################################################# ## #M NrConjugacyClasses( ) . . . . . . . . . . Method for natural SL(n,q) ## InstallMethod( NrConjugacyClasses, "for natural SL", true, [ IsFFEMatrixGroup and IsFinite and IsNaturalSL ], 0, function ( G ) local n,q; n := DimensionOfMatrixGroup(G); q := Size(FieldOfMatrixGroup(G)); return NrConjugacyClassesSL(n,q); end ); ############################################################################# ## #M NrConjugacyClasses( ) . . . . . . . . . . . . . . Method for GU(n,q) ## InstallMethod( NrConjugacyClasses, "for GU(n,q)", true, [ IsFFEMatrixGroup and IsFinite and IsFullSubgroupGLorSLRespectingSesquilinearForm ], 0, function ( G ) local n,q; if IsSubgroupSL(G) then TryNextMethod(); fi; n := DimensionOfMatrixGroup(G); q := RootInt(Size(FieldOfMatrixGroup(G))); return NrConjugacyClassesGU(n,q); end ); ############################################################################# ## #M NrConjugacyClasses( ) . . . . . . . . . . Method for natural SU(n,q) ## InstallMethod( NrConjugacyClasses, "for natural SU", true, [ IsFFEMatrixGroup and IsFinite and IsFullSubgroupGLorSLRespectingSesquilinearForm and IsSubgroupSL ], 0, function ( G ) local n,q; n := DimensionOfMatrixGroup(G); q := RootInt(Size(FieldOfMatrixGroup(G))); return NrConjugacyClassesSU(n,q); end ); ############################################################################# ## #E gap-4r6p5/lib/integer.gi0000644000175000017500000020040012172557252013661 0ustar billbill############################################################################# ## #W integer.gi GAP library Thomas Breuer #W & Frank Celler #W & Stefan Kohl #W & Werner Nickel #W & Alice Niemeyer #W & Martin Schönert #W & Alex Wegner ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ############################################################################# ## #V Integers . . . . . . . . . . . . . . . . . . . . . ring of the integers ## InstallValue( Integers, Objectify( NewType( CollectionsFamily( CyclotomicsFamily ), IsIntegers and IsAttributeStoringRep ), rec() ) ); SetName( Integers, "Integers" ); SetString( Integers, "Integers" ); SetIsLeftActedOnByDivisionRing( Integers, false ); SetSize( Integers, infinity ); SetLeftActingDomain( Integers, Integers ); SetGeneratorsOfRing( Integers, [ 1 ] ); SetGeneratorsOfLeftModule( Integers, [ 1 ] ); SetIsFiniteDimensional( Integers, true ); SetUnits( Integers, [ -1, 1 ] ); SetIsWholeFamily( Integers, false ); ############################################################################# ## #V NonnegativeIntegers . . . . . . . . . . semiring of nonnegative integers ## InstallValue( NonnegativeIntegers, Objectify( NewType( CollectionsFamily( CyclotomicsFamily ), IsNonnegativeIntegers and IsAttributeStoringRep ), rec() ) ); SetName( NonnegativeIntegers, "NonnegativeIntegers" ); SetString( NonnegativeIntegers, "NonnegativeIntegers" ); SetSize( NonnegativeIntegers, infinity ); SetGeneratorsOfSemiringWithZero( NonnegativeIntegers, [ 1 ] ); SetGeneratorsOfAdditiveMagmaWithZero( NonnegativeIntegers, [ 1 ] ); SetIsWholeFamily( NonnegativeIntegers, false ); ############################################################################# ## #V PositiveIntegers . . . . . . . . . . . . . semiring of positive integers ## InstallValue( PositiveIntegers, Objectify( NewType( CollectionsFamily( CyclotomicsFamily ), IsPositiveIntegers and IsAttributeStoringRep ), rec() ) ); SetName( PositiveIntegers, "PositiveIntegers" ); SetString( PositiveIntegers, "PositiveIntegers" ); SetSize( PositiveIntegers, infinity ); SetGeneratorsOfSemiring( PositiveIntegers, [ 1 ] ); SetGeneratorsOfAdditiveMagma( PositiveIntegers, [ 1 ] ); SetIsWholeFamily( PositiveIntegers, false ); ############################################################################# ## #V GaussianIntegers . . . . . . . . . . . . . . . ring of Gaussian integers ## InstallValue( GaussianIntegers, Objectify( NewType( CollectionsFamily(CyclotomicsFamily), IsGaussianIntegers and IsAttributeStoringRep ), rec() ) ); SetLeftActingDomain( GaussianIntegers, Integers ); SetName( GaussianIntegers, "GaussianIntegers" ); SetString( GaussianIntegers, "GaussianIntegers" ); SetIsLeftActedOnByDivisionRing( GaussianIntegers, false ); SetSize( GaussianIntegers, infinity ); SetGeneratorsOfRing( GaussianIntegers, [ E(4) ] ); SetGeneratorsOfLeftModule( GaussianIntegers, [ 1, E(4) ] ); SetUnits( GaussianIntegers, [ -1, 1, -E(4), E(4) ] ); SetIsWholeFamily( GaussianIntegers, false ); ############################################################################# ## #R IsCanonicalBasisIntegersRep ## DeclareRepresentation( "IsCanonicalBasisIntegersRep", IsAttributeStoringRep, [] ); #T is this needed at all? ############################################################################# ## #M Basis( Integers ) ## InstallMethod( Basis, "for integers (delegate to `CanonicalBasis')", [ IsIntegers ], CANONICAL_BASIS_FLAGS, CanonicalBasis ); ############################################################################# ## #M CanonicalBasis( Integers ) ## InstallMethod( CanonicalBasis, "for Integers", true, [ IsIntegers ], 0, function( Integers ) local B; B:= Objectify( NewType( FamilyObj( Integers ), IsFiniteBasisDefault and IsCanonicalBasis and IsCanonicalBasisIntegersRep ), rec() ); SetUnderlyingLeftModule( B, Integers ); SetBasisVectors( B, [ 1 ] ); return B; end ); InstallMethod( Coefficients, "for the canonical basis of Integers", IsCollsElms, [ IsBasis and IsCanonicalBasis and IsCanonicalBasisIntegersRep, IsCyc ], 0, function( B, v ) if IsInt( v ) then return [ v ]; else return fail; fi; end ); ############################################################################# ## #V Primes . . . . . . . . . . . . . . . . . . . . . . list of small primes ## InstallValue( Primes, [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97,101,103,107,109,113,127,131,137,139,149,151, 157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251, 257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359, 367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463, 467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593, 599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701, 709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827, 829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953, 967,971,977,983,991,997 ] ); MakeImmutable( Primes ); ############################################################################# ## #V Primes2 . . . . . . . . . . . . . . . . . . . . . . additional prime list #V ProbablePrimes2 . . . . . . . . . . . . . . . . . . additional prime list ## ## Some primes in `Primes2' are taken from the tables of Richard Brent, ## which are available at ## ftp://ftp.comlab.ox.ac.uk/pub/Documents/techpapers/Richard.Brent/factors/ ## ## More factors of cyclotomic numbers are now available via the FactInt ## package. This should be cleaned up. ## InstallFlushableValue( Primes2, [ 10047871, 10567201, 10746341, 12112549, 12128131, 12207031, 12323587, 12553493, 12865927, 13097927, 13264529, 13473433, 13821503, 13960201, 14092193, 14597959, 15216601, 15790321, 16018507, 18837001, 20381027, 20394401, 20515111, 20515909, 21207101, 21523361, 22253377, 22366891, 22996651, 23850061, 25781083, 26295457, 28325071, 28878847, 29010221, 29247661, 29423041, 29866451, 32234893, 32508061, 36855109, 41540861, 42521761, 43249589, 44975113, 47392381, 47763361, 48544121, 48912491, 49105547, 49892851, 51457561, 55527473, 56409643, 56737873, 59302051, 59361349, 59583967, 60816001, 62020897, 63512437, 65628751, 69566521, 75068993, 76066181, 85280581, 93507247, 96656723, 97685839, 106431697, 107367629, 109688713, 110211473, 112901153, 119782433, 127540261, 134818753, 134927809, 136151713, 147300841, 155072369, 160465489, 164511353, 177237331, 183794551, 184481113, 190295821, 190771747, 193707721, 195019441, 202029703, 206244761, 212601841, 212885833, 228511817, 231769777, 234750601, 272010961, 280314943, 283763713, 297315901, 305175781, 308761441, 319020217, 359390389, 407865361, 420778751, 424256201, 432853009, 457315063, 466344409, 510810301, 515717329, 527093491, 529510939, 536903681, 540701761, 550413361, 603926681, 616318177, 632133361, 715827883, 724487149, 745988807, 763539787, 815702161, 834019001, 852133201, 857643277, 879399649, 909139159, 1001523179, 1036745531, 1065264019, 1106131489, 1169382127, 1390636259, 1503418321, 1527007411, 1636258751, 1644512641, 1743831169, 1824179209, 1824726041, 1826934301, 1866013003, 1990415149, 2127357527, 2127431041, 2147483647, 2238236249, 2316281689, 2413941289, 2481791513, 2550183799, 2576743207, 2664097031, 2767631689, 2903110321, 2931542417, 3021012311, 3158528101, 3173389601, 3357897971, 3652120847, 4011586307, 4058036683, 4278255361, 4375578271, 4562284561, 4649919401, 4698932281, 4795973261, 4885168129, 5960555749, 6622733113, 6630274723, 6809710909, 6860024417, 7068569257, 7151459701, 7484047069, 7685542369, 7830118297, 7866608083, 8209475377, 8831418697, 9598959833, 10879733611, 11368765063, 11898664849, 12447002677, 13455809771, 13564461457, 13841169553, 13971969971, 14425532687, 15085812853, 15768033143, 15888756269, 16055056483, 16148168401, 17056050293, 17154094481, 17189128703, 19707683773, 22434744889, 23140471537, 23535794707, 24127552321, 25194773531, 25480398173, 25829691707, 25994736109, 27669118297, 27989941729, 28086211607, 30327152671, 32952799801, 33057806959, 35532364099, 39940132241, 43872038849, 45076044553, 47072139617, 50150933101, 54410972897, 56625998353, 56770350869, 60726444167, 61070817601, 62983048367, 65247271367, 69238518539, 70845409351, 76831835389, 77158673929, 77192844961, 78009515593, 83960385389, 86950696619, 87423871753, 88959882481, 99810171997, 115868130379, 125096112091, 127522693159, 128011456717, 128653413121, 129924628343, 131105292137, 152587500001, 158822951431, 159248456569, 164504919713, 165768537521, 168749965921, 213657222007, 229890275929, 241931001601, 269089806001, 282429005041, 301077652751, 332207361361, 368592716837, 374857981681, 386478495679, 392038110671, 402011881627, 441019876741, 447600088289, 461587317509, 487824887233, 531968664833, 555915824341, 593554036769, 598761682261, 641625222857, 654652168021, 761838257287, 810221830361, 840139875599, 918585913061, 1030330938209, 1047623475541, 1113491139767, 1133836730401, 1273880539247, 1284297400723, 1408429185797, 1534179947851, 1628744948329, 1654058017289, 1759217765581, 1856458657451, 2098303812601, 2454335007529, 2481357870461, 2549755542947, 2663568851051, 2738039191709, 2879347902817, 2932031007403, 3138426605161, 3203431780337, 3421169496361, 3740221981231, 4363953127297, 4432676798593, 4446437759531, 4534166740403, 4981857697937, 5625767248687, 6090817323763, 6493405343627, 6713103182899, 6740339310641, 7432339208719, 8090594434231, 8157179360521, 8737481256739, 8868050880709, 9361973132609, 9468940004449, 9857737155463, 10052678938039, 10979607179423, 13952598148481, 15798461357509, 15919793462773, 17175865789597, 18158209813151, 22125996444329, 22542470482159, 22735632934561, 23161037562937, 23792163643711, 24517014940753, 24587411156281, 28059810762433, 29078814248401, 31280679788951, 31479823396757, 32688470798197, 33232924804801, 42272797713043, 44479210368001, 45920153384867, 49971617830801, 57583418699431, 62911130477521, 67280421310721, 70601370627701, 71316922984999, 83181652304609, 89620825374601, 94404837727799, 95052547721497, 110133112994711, 140737471578113, 145295143558111, 150224123975857, 160026187716961, 204064664440913, 205367807127911, 242099935645987, 270547105429567, 303567967057423, 332584516519201, 434502978835771, 475384700124973, 500805747488153, 520518327319589, 560088668384411, 608459012088799, 637265428480297, 643170158708221, 707179356161321, 866802946161469, 926510094425921, 990643452963163, 1034150930241911, 1066818132868207, 1120648576818041, 1357105535093947, 1416258521793067, 1587855697992791, 1611479891519807, 1628413557556843, 1900857799450121, 1958423494433591, 2134387368610417, 2646507710984041, 2649263870814793, 2752135920929651, 2864226125209369, 3208002856867129, 4557772677741827, 4889988840047743, 5420506947192709, 6957533874046531, 9460375336977361, 9472026608675509, 11264087821629961, 12557612956332313, 13722816749522711, 14436295738510501, 18584774046020617, 18624275418445601, 20986207825565581, 21180247636732981, 22666879066355177, 27145365052629449, 32233368385529653, 39392783590192547, 46329453543600481, 50544702849929377, 59509429687890001, 60081451169922001, 70084436712553223, 76394148218203559, 77001139434480073, 79787519018560501, 96076791871613611, 133088039373662309, 144542918285300809, 145171177264407947, 153560376376050799, 166003607842448777, 177722253954175633, 196915704073465747, 316825425410373433, 341117531003194129, 380808546861411923, 489769993189671059, 538953023961943033, 581283643249112959, 617886851384381281, 625552508473588471, 645654335737185721, 646675035253258729, 658812288653553079, 768614336404564651, 862970652262943171, 909456847814334401, 1100876018364883721, 1195857367853217109, 1245576402371959291, 1795918038741070627, 2192537062271178641, 2305843009213693951, 2312581841562813841, 2461243576713869557, 2615418118891695851, 2691614274040036601, 3011347479614249131, 3358335487319458201, 3421093417510114543, 3602372010909260861, 3747607031112307667, 3999088279399464409, 4710883168879506001, 5079304643216687969, 5559917315850179173, 5782172113400990737, 6106505825833677713, 6115909044841454629, 9213624084535989031, 9520972806333758431, 10527743181888260981, 14808607715315782481, 18446744069414584321, 26831423036065352611, 32032215596496435569, 34563155350221618511, 36230454570129675721, 58523123221688392679, 60912916512835721519, 82064241848634269407, 86656268566282183151, 87274497124602996457, 105668621839502584913, 157571957584602258799, 162715052426691233701, 172827552198815888791, 195489390796456327201, 240031591394168814433, 266834785363181152127, 344120456368919234899, 358475907408445923469, 846041103974872866961, 2519545342349331183143, 3658524738455131951223, 3793685967117002179453, 3976656429941438590393, 5439042183600204290159, 8198241112969626815581, 11600321878916922053491, 12812432238302009985937, 17551032119981679046729, 18489605314740987765913, 27665283091695977275201, 42437717969530394595211, 57912614113275649087721, 61654440233248340616559, 63681511996418550459487, 105293313660391861035901, 155285743288572277679887, 201487636602438195784363, 231669654363683130095909, 235169662395069356312233, 402488219476647465854701, 535347624791488552837151, 604088623657497125653141, 870035986098720987332873, 950996059627210897943351, 1412900479108654932024439, 1431185706701868962383741, 2047572230657338751575051, 2048568835297380486760231, 2741672362528725535068727, 3042645634792541312037847, 3745603812007166116831643, 4362139336229068656094783, 4805345109492315767981401, 5042939439565996049162197, 7289088383388253664437433, 8235109336690846723986161, 9680647790568589086355559, 9768997162071483134919121, 9842332430037465033595921, 11053036065049294753459639, 11735415506748076408140121, 13842607235828485645766393, 17499733663152976533452519, 26273701844015319144827917, 75582488424179347083438319, 88040095945103834627376781, 100641220283951395639601683, 140194179307171898833699259, 207617485544258392970753527, 291280009243618888211558641, 303309617049998388989376043, 354639323684545612988577649, 618970019642690137449562111, 913242407367610843676812931, 7222605228105536202757606969, 7248808599285760001152755641, 8170509011431363408568150369, 8206973609150536446402438593, 9080418348371887359375390001, 14732265321145317331353282383, 15403468930064931175264655869, 15572244900182528777225808449, 18806327041824690595747113889, 21283620033217629539178799361, 37201708625305146303973352041, 42534656091583268045915654719, 48845962828028421155731228333, 123876132205208335762278423601, 134304196845099262572814573351, 172974812463239310024750410929, 217648180992721729506406538251, 227376585863531112677002031251, 1786393878363164227858270210279, 2598696228942460402343442913969, 2643999917660728787808396988849, 3340762283952395329506327023033, 5465713352000770660547109750601, 28870194250662203210437116612769, 70722308812401674174993533367023, 78958087694609321439660131899631, 88262612316754526107621113329689, 162259276829213363391578010288127, 163537220852725398851434325720959, 177635683940025046467781066894531, 2679895157783862814690027494144991, 3754733257489862401973357979128773, 5283012903770196631383821046101707, 5457586804596062091175455674392801, 10052011757370829033540932021825161, 11419697846380955982026777206637491, 38904276017035188056372051839841219, 1914662449813727660680530326064591907, 7923871097285295625344647665764672671, 9519524151770349914726200576714027279, 10350794431055162386718619237468234569, 170141183460469231731687303715884105727, 1056836588644853738704557482552056406147, 6918082374901313855125397665325977135579, 235335702141939072378977155172505285655211, 360426336941693434048414944508078750920763, 1032670816743843860998850056278950666491537, 1461808298382111034194027645506019619578037, 79638304766856507377778616296087448490695649, 169002145064468556765676975247413756542145739, 8166146875847876762859119015147004762656450569, 18607929421228039083223253529869111644362732899, 33083146850190391025301565142735000331370209599, 138497973518827432485604572537024087153816681041, 673267426712748387612994804392183645147042355211, 1489459109360039866456940197095433721664951999121, 4884164093883941177660049098586324302977543600799, 466345922275629775763320748688970211803553256223529, 26828803997912886929710867041891989490486893845712448833, 153159805660301568024613754993807288151489686913246436306439, 1051153199500053598403188407217590190707671147285551702341089650185945215953 ] ); IsSSortedList( Primes2 ); # for 41^41-1 ADD_SET(Primes2, 5926187589691497537793497756719); # for 89^89-1 ADD_SET(Primes2, 4330075309599657322634371042967428373533799534566765522517); # for 97^97-1 ADD_SET(Primes2, 549180361199324724418373466271912931710271534073773); ADD_SET(Primes2, 85411410016592864938535742262164288660754818699519364051241927961077872028620787589587608357877); InstallFlushableValue(ProbablePrimes2, []); IsSSortedList( ProbablePrimes2 ); ############################################################################# ## #F BestQuoInt( , ) ## ## `BestQuoInt' returns the best quotient of the integers and . ## This is the quotient such that `-\*' has minimal absolute value. ## If there are two quotients whose remainders have the same absolute value, ## then the quotient with the smaller absolute value is choosen. ## InstallGlobalFunction(BestQuoInt,function ( n, m ) if 0 <= m and 0 <= n then return QuoInt( n + QuoInt( m - 1, 2 ), m ); elif 0 <= m then return QuoInt( n - QuoInt( m - 1, 2 ), m ); elif 0 <= n then return QuoInt( n - QuoInt( m + 1, 2 ), m ); else return QuoInt( n + QuoInt( m + 1, 2 ), m ); fi; end); ############################################################################# ## #F ChineseRem( , ) . . . . . . . . . . chinese remainder ## InstallGlobalFunction(ChineseRem,function ( moduli, residues ) local i, c, l, g; # combine the residues modulo the moduli i := 1; c := residues[1]; l := moduli[1]; while i < Length(moduli) do i := i + 1; g := Gcdex( l, moduli[i] ); if g.gcd <> 1 and (residues[i]-c) mod g.gcd <> 0 then Error("the residues must be equal modulo ",g.gcd); fi; c := l * (((residues[i]-c) / g.gcd * g.coeff1) mod moduli[i]) + c; l := moduli[i] / g.gcd * l; od; # reduce c into the range [0..l-1] c := c mod l; return c; end); ############################################################################# ## #F CoefficientsQadic( , ) . . . . . . -adic representation of ## InstallMethod( CoefficientsQadic, "for two integers", true, [ IsInt, IsInt ], 0, function( i, q ) local v; if q <= 1 then Error("2nd argument of CoefficientsQadic should be greater than 1\n"); fi; if i < 0 then # if FR package is loaded and supplies an implementation # to return a periodic list for negative i TryNextMethod(); fi; # represent the integer as -adic number v := []; while i > 0 do Add( v, RemInt( i, q ) ); i := QuoInt( i, q ); od; return v; end); ############################################################################# ## #F CoefficientsMultiadic( ints, int ) ## InstallGlobalFunction(CoefficientsMultiadic, function( ints, int ) local vec, i; vec := List( ints, x -> 0 ); for i in Reversed( [1..Length(ints)] ) do vec[i] := RemInt( int, ints[i] ); int := QuoInt( int, ints[i] ); od; return vec; end); ############################################################################# ## #F DivisorsInt( ) . . . . . . . . . . . . . . . divisors of an integer ## BindGlobal("DivisorsIntCache", List([[1],[1,2],[1,3],[1,2,4],[1,5],[1,2,3,6],[1,7]], Immutable)); InstallGlobalFunction(DivisorsInt,function ( n ) local divisors, factors, divs; # make it nonnegative, handle trivial cases, and get prime factors if n < 0 then n := -n; fi; if n = 0 then Error("DivisorsInt: must not be 0"); fi; if n <= Length(DivisorsIntCache) then return DivisorsIntCache[n]; fi; factors := FactorsInt( n ); # recursive function to compute the divisors divs := function ( i, m ) if Length(factors) < i then return [ m ]; elif m mod factors[i] = 0 then return divs(i+1,m*factors[i]); else return Concatenation( divs(i+1,m), divs(i+1,m*factors[i]) ); fi; end; divisors := divs( 1, 1 ); Sort( divisors ); return Immutable(divisors); end); ############################################################################# ## #F FactorsRho( , , , ) Pollards rho factorization ## ## `FactorsInt' does trial divisions by the primes less than 1000 to detect ## all composites with a factor less than 1000 and primes less than 1000000. ## After that it calls `FactorsRho(,1,16,8192)' to do the hard work. ## ## `FactorsRho' will return a list of factors and a list of composite ## number. Usually `FactorsInt' factors integers with prime factors ## $\<1000$ faster. However for integers with no factor $\<1000$ ## `FactorsRho' will be faster. ## ## `FactorsRho' uses Pollards $\rho$ method to factor the integer $n = p q$. ## For a small simple example lets assume we want to factor $667 = 23 * 29$. ## `FactorsRho' first calls `IsPrimeInt' to avoid trying to factor a prime. ## ## Then it uses the sequence defined by $x_0=1, x_{i+1}=(x_i^2+1)$ mod $n$. ## In our example this is $1, 2, 5, 26, 10, 101, 197, 124, 36, 630, .. $. ## ## Modulo $p$ it takes on at most $p-1$ different values, thus it eventually ## becomes recurrent, usually this happens after roughly $2 \sqrt{p}$ steps. ## In our example modulo 23 we get $1, 2, 5, 3, 10, 9, 13, 9, 13, 9, .. $. ## ## Thus there exist pairs $i, j$ such that $x_i = x_j$ mod $p$, i.e., such ## that $p$ divides $Gcd( n, x_j-x_i )$. With a bit of luck no other factor ## of $n$ divides $x_j - x_i$ so we find $p$ if we know such a pair. In our ## example $5, 7$ is the first pair, $x_7-x_5=23$, and $Gcd(667,23) = 23$. ## ## Now it is too expensive to check all pairs, but there also must be pairs ## of the form $2^i-1, j$ with $3*2^{i-1} <= j < 4*2^{i-1}$. In our example ## $7, 13$ is the first such pair, $x_13-x_7=506$, and $Gcd(667,506) = 23$. ## ## Thus by taking the gcds of $n$ and $x_j-x_i$ for such pairs, we will find ## the factor $p$ after approximately $2 \sqrt{p} \<= 2 \sqrt^4{n}$ steps. ## ## If $Gcd( n, x_j - x_i )$ is not a prime `FactorsRho' will call itself ## recursivly with a different value for , i.e., it will try to factor ## the gcd using a different sequence $x_{i+1} = (x_i^2 + inc)$ mod $n$. ## ## Since the gcd computations are by far the most time consuming part of the ## algorithm one can save time by clustering differences and computing the ## gcd only every iteration. This slightly increases the chance ## that a gcd is composite, but reduces the runtime by a large amount. ## ## Finally `FactorsRho' accepts an argument which is the number of ## iterations performed by `FactorsRho' before giving up. The default value ## is 8192 which corresponds to a few minutes while guaranteing that all ## prime factors less than $10^6$ and most less than $10^9$ are found. ## ## Better descriptions of the algorithm and related topics can be found in: ## J. Pollard, A Monte Carlo Method for Factorization, BIT 15, 1975, 331-334 ## R. Brent, An Improved Monte Carlo Method for Fact., BIT 20, 1980, 176-184 ## D. Knuth, Seminumerical Algorithms (TACP II), AddiWesl, 1973, 369-371 ## FactorsRho := function ( n, inc, cluster, limit ) local i, sign, factors, composite, x, y, k, z, g, tmp, IsPrimeOrProbablyPrimeInt; # make $n$ positive and handle trivial cases sign := 1; if n < 0 then sign := -sign; n := -n; fi; if n < 4 then return [ [ sign * n ], [] ]; fi; factors := []; composite := []; while n mod 2 = 0 do Add( factors, 2 ); n := n / 2; od; while n mod 3 = 0 do Add( factors, 3 ); n := n / 3; od; if ValueOption("UseProbabilisticPrimalityTest") = true then IsPrimeOrProbablyPrimeInt := IsProbablyPrimeInt; else IsPrimeOrProbablyPrimeInt := IsPrimeInt; fi; if IsPrimeOrProbablyPrimeInt(n) then Add( factors, n ); n := 1; fi; # initialize $x_0$ x := 1; z := 1; i := 0; # loop until we have factored $n$ completely or run out of patience while 1 < n and 2^i <= limit do # $y = x_{2^i-1}$ y := x; i := i + 1; # $x_{2^i}, .., x_{3*2^{i-1}-1}$ need not be compared to $x_{2^i-1}$ for k in [1..2^(i-1)] do x := (x^2 + inc) mod n; od; # compare $x_{3*2^{i-1}}, .., x_{4*2^{i-1}-1}$ with $x_{2^i-1}$ for k in [1..2^(i-1)] do x := (x^2 + inc) mod n; z := z * (x - y) mod n; # from time to time compute the gcd if k mod cluster = 0 then g := GcdInt( n, z ); # if it is > 1 we have found a factor which need not be prime if g > 1 then tmp := FactorsRho(g,inc+1,QuoInt(cluster+1,2),limit); factors := Concatenation( factors, tmp[1] ); composite := Concatenation( composite, tmp[2] ); n := n / g; if IsPrimeOrProbablyPrimeInt(n) then Add( factors, n ); n := 1; fi; fi; fi; od; od; # add to the list of composite numbers if 1 < n then Add( composite, n ); fi; # sort the list of factors and composite numbers and return it Sort(factors); Sort(composite); if 0 < Length(factors) then factors[1] := sign * factors[1]; else composite[1] := sign * composite[1]; fi; return [ factors, composite ]; end; MakeReadOnlyGlobal( "FactorsRho" ); ############################################################################# ## #F FactorsInt( ) . . . . . . . . . . . . . . prime factors of an integer #F FactorsInt( : RhoTrials := ) #F FactorsInt( : quiet) ## ## In the second form, FactorsRho is called with a limit of ## on the number of trials is performs. The default is 8192. ## ## The option `quiet' makes the function return even if the `rho' ## factorization failed and return the factorization found so far. ## InstallGlobalFunction(FactorsInt,function ( n ) local sign, factors, p, tmp, n_orig, len, rt, tmp2; n_orig := n; # make $n$ positive and handle trivial cases sign := 1; if n < 0 then sign := -sign; n := -n; fi; if n < 4 then return [ sign * n ]; fi; factors := []; # do trial divisions by the primes less than 1000 # faster than anything fancier because $n$ mod is very fast for p in Primes do while n mod p = 0 do Add( factors, p ); n := n / p; od; if n < (p+1)^2 and 1 < n then Add(factors,n); n := 1; fi; if n = 1 then factors[1] := sign*factors[1]; return factors; fi; od; # do trial divisions by known primes for p in Primes2 do while n mod p = 0 do Add( factors, p ); n := n / p; od; if p^2 > n then break; fi; if n = 1 then factors[1] := sign*factors[1]; return factors; fi; od; # do trial divisions by known probable primes (and issue warning, if found) tmp := []; for p in ProbablePrimes2 do while n mod p = 0 do AddSet(tmp, p); Add( factors, p ); n := n / p; od; if n = 1 then break; fi; od; if Length(tmp) > 0 then Info(InfoPrimeInt, 1 , "FactorsInt: used the following factor(s) which are probably primes:"); for p in tmp do Info(InfoPrimeInt, 1, " ", p); od; fi; if n = 1 then factors[1] := sign*factors[1]; return factors; fi; # handle perfect powers p := SmallestRootInt( n ); if p < n then while 1 < n do Append( factors, FactorsInt(p) ); n := n / p; od; Sort( factors ); factors[1] := sign * factors[1]; return factors; fi; # let `FactorsRho' do the work if ValueOption("RhoTrials") <> fail then tmp := FactorsRho( n, 1, 16, ValueOption("RhoTrials") ); else tmp := FactorsRho( n, 1, 16, 8192 ); fi; if 0 < Length(tmp[2]) then if ValueOption("quiet")<>true then len := Length(tmp[2]); if LoadPackage("FactInt") = true then ## # in general cases we should proceed with the found factors: ## while len > 0 do ## Append(tmp[1], Factors(tmp[2][len])); ## Unbind(tmp[2][len]); ## len := len-1; ## od; # but this way we miss that FactInt can detect certain numbers of # special shape for which it uses lookup tables, therefore for the # moment: return Factors(n_orig); else Error( "sorry, cannot factor ", tmp[2], "\ntype 'return;' to try again with a larger number of trials in\n", "FactorsRho (or use option 'RhoTrials')\n"); if ValueOption("RhoTrials") <> fail then rt := 5 * ValueOption("RhoTrials"); else rt := 5 * 8192; fi; while len > 0 do tmp2 := FactorsInt(tmp[2][len]: RhoTrials := rt); Append(tmp[1], tmp2); Unbind(tmp[2][len]); len := len-1; od; fi; else factors := Concatenation( factors, tmp[2] ); fi; fi; factors := Concatenation( factors, tmp[1] ); Sort( factors ); factors[1] := sign * factors[1]; return factors; end); ############################################################################# ## #F PrimeDivisors( ) . . . . . . . . . . . . . . list of prime divisors ## ## delegating to FactorsInt ## InstallMethod( PrimeDivisors, "for integer", [ IsInt ], function(n) if n = 0 then Error("PrimeDivisors: 0 has an infinite number of prime divisors."); return; fi; if n < 0 then n := -n; fi; if n = 1 then return []; fi; return Set(FactorsInt(n)); end); ############################################################################# ## #M PartialFactorization( , ) . . . . . . . . . . generic method ## InstallMethod( PartialFactorization, "generic method", true, [ IsInt, IsInt ], 0, function ( n, effort ) local N, sign, factors, p, k, root, rootfactors, rhotrials, tmp, CheckAndSortFactors; CheckAndSortFactors := function ( ) factors := SortedList(factors); factors[1] := sign*factors[1]; if Product(factors) <> N then Error("PartialFactorization: Internal error, wrong result!"); fi; end; N := n; if effort < 0 then effort := 5; fi; # make $n$ positive and handle trivial cases sign := 1; if n < 0 then sign := -sign; n := -n; fi; if n < 4 then return [ sign * n ]; fi; factors := []; # least effort: do trial divisions by the primes less than 100 if effort = 0 then for p in Primes{[1..25]} do while n mod p = 0 do Add( factors, p ); n := n / p; od; if n < (p+1)^2 and 1 < n then Add(factors,n); n := 1; fi; if n = 1 then CheckAndSortFactors(); return factors; fi; od; Add(factors,n); CheckAndSortFactors(); return factors; fi; # do trial divisions by the primes less than 1000 # faster than anything fancier because $n$ mod is very fast for p in Primes do while n mod p = 0 do Add( factors, p ); n := n / p; od; if n < (p+1)^2 and 1 < n then Add(factors,n); n := 1; fi; if n = 1 then CheckAndSortFactors(); return factors; fi; od; if effort <= 1 then Add(factors,n); CheckAndSortFactors(); return factors; fi; # do trial divisions by known primes for p in Primes2 do while n mod p = 0 do Add( factors, p ); n := n / p; od; if n = 1 then CheckAndSortFactors(); return factors; fi; od; # do trial divisions by known probable primes tmp := []; for p in ProbablePrimes2 do while n mod p = 0 do AddSet(tmp, p); Add( factors, p ); n := n / p; od; if n = 1 then break; fi; od; if n = 1 then CheckAndSortFactors(); return factors; fi; # handle perfect powers root := SmallestRootInt( n ); if root < n then rootfactors := PartialFactorization(root,effort); k := LogInt(n,root); rootfactors := Concatenation(List([1..k],i->rootfactors)); factors := SortedList(Concatenation(factors,rootfactors)); CheckAndSortFactors(); return factors; fi; if effort = 2 or IsProbablyPrimeInt(n) then Add(factors,n); CheckAndSortFactors(); return factors; fi; # if effort >= 3, use `FactorsRho' if ValueOption("RhoTrials") <> fail then tmp := FactorsRho(n,1,16,ValueOption("RhoTrials"): UseProbabilisticPrimalityTest); else if effort = 3 then rhotrials := 256; elif effort = 4 then rhotrials := 2048; elif effort >= 5 then rhotrials := 8192; fi; tmp := FactorsRho(n,1,16,rhotrials:UseProbabilisticPrimalityTest); fi; factors := SortedList(Concatenation(factors,tmp[1],tmp[2])); CheckAndSortFactors(); return factors; end ); ############################################################################# ## #M PartialFactorization( ) . . . . . partial factorization of an integer ## InstallOtherMethod( PartialFactorization, "for integers", true, [ IsInt ], 0, n -> PartialFactorization(n,5) ); ############################################################################# ## #F Gcdex( , ) . . . . . . . . . . greatest common divisor of integers ## InstallGlobalFunction(Gcdex,function ( m, n ) local f, g, h, fm, gm, hm, q; if 0 <= m then f:=m; fm:=1; else f:=-m; fm:=-1; fi; if 0 <= n then g:=n; gm:=0; else g:=-n; gm:=0; fi; while g <> 0 do q := QuoInt( f, g ); h := g; hm := gm; g := f - q * g; gm := fm - q * gm; f := h; fm := hm; od; if n = 0 then return rec( gcd := f, coeff1 := fm, coeff2 := 0, coeff3 := gm, coeff4 := 1 ); else return rec( gcd := f, coeff1 := fm, coeff2 := (f - fm * m) / n, coeff3 := gm, coeff4 := (0 - gm * m) / n ); fi; end); ############################################################################# ## #F IsEvenInt( ) . . . . . . . . . . . . . . . . . . test if is even ## InstallGlobalFunction( IsEvenInt, n -> n mod 2 = 0 ); ############################################################################# ## #F IsOddInt( ) . . . . . . . . . . . . . . . . . . . test if is odd ## InstallGlobalFunction( IsOddInt, n -> n mod 2 = 1 ); ############################################################################# ## #F IsPrimeInt( ) . . . . . . . . . . . . . . . . . . . test for a prime ## ## `IsPrimeInt' does trial divisions by the primes less than 1000 to detect ## composites with a factor less than 1000 and primes less than 1000000. ## ## `IsPrimeInt' then checks that $n$ is a strong pseudoprime to the base 2. ## This uses Fermats theorem which says $2^{n-1}=1$ mod $n$ for a prime $n$. ## If $2^{n-1}\<>1$ mod $n$, $n$ is composite, `IsPrimeInt' returns `false'. ## There are composite numbers for which $2^{n-1}=1$, but they are seldom. ## ## Then `IsPrimeInt' checks that $n$ is a Lucas pseudoprime for $p$, choosen ## so that the discriminant $d=p^2/4-1$ is an quadratic nonresidue mod $n$. ## I.e., `IsPrimeInt' takes the root $a = p/2+\sqrt{d}$ of $x^2 - px + 1$ in ## the ring $Z_n[\sqrt{d}] and computes the traces of $a^n$ and $a^{n+1}$. ## If $n$ is a prime, this ring is the field of order $n^2$ and raising to ## the $n$th power is conjugation, so $trace(a^n)=p$ and $trace(a^{n+1})=2$. ## However, these identities hold only for extremly few composite numbers. ## ## Note that this test for $trace(a^n) = p$ and $trace(a^{n+1}) = 2$ is ## usually formulated using the Lucas sequences $U_k = (a^k-b^k)/(a-b)$ and ## $V_k = (a^k+b^k)=trace(a^k)$, where one tests $U_{n+1} = 0, V_{n+1} = 2$. ## However, the trace test is equivalent and requires fewer multiplications. ## Thanks to Daniel R. Grayson (dan@symcom.math.uiuc.edu) for telling me. ## ## `IsPrimeInt' can be shown to return the correct answer for $n < 10^{13}$, ## by testing against R.G.E. Pinch's list of all pseudoprimes to base 2 less ## than $10^{13}$ ('ftp://dpmms.cam.ac.uk/pub/rgep/PSP/psp13.gz'). ## ## Better descriptions of the algorithm and related topics can be found in: ## G. Miller, cf. Algorithms and Complexity ed. Traub, AcademPr, 1976, 35-36 ## C. Pomerance et.al., Pseudoprimes to 25*10^9, MathComp 35 1980, 1003-1026 ## D. Knuth, Seminumerical Algorithms (TACP II), AddiWesl, 1973, 378-380 ## G. Gonnet, Heuristic Primality Testing, Maple Newsletter 4, 1989, 36-38 ## R. Baillie, S. Wagstaff, Lucas Pseudoprimes, MathComp 35 1980, 1391-1417 ## R. Pinch, Some Primality Testing Algorithms, Notic. AMS 9 1993, 1203-1210 ## # a non-recursive version, nowadays the algorithm can be applied to # numbers with many thousand digits InstallGlobalFunction(TraceModQF, function ( p, k, n ) local kb, trc, i; kb := []; while k <> 1 do if k mod 2 = 0 then k := k/2; Add(kb, 0); else k := (k+1)/2; Add(kb, 1); fi; od; trc := [p, 2]; i := Length(kb); while i >= 1 do if kb[i] = 0 then trc := [ (trc[1]^2 - 2) mod n, (trc[1]*trc[2] - p) mod n ]; else trc := [ (trc[1]*trc[2] - p) mod n, (trc[2]^2 - 2) mod n ]; fi; i := i-1; od; return trc; end); ## returns `false' for proven composite, `true' for proven prime and ## `fail' for probable prime. BindGlobal( "IsProbablyPrimeIntWithFail", function( n ) local p, e, o, x, i; # make $n$ positive and handle trivial cases if n < 0 then n := -n; fi; if n in Primes then return true; fi; if n in Primes2 then return true; fi; if n in ProbablePrimes2 then return fail; fi; if n <= 1000 then return false; fi; # do trial divisions by the primes less than 1000 # faster than anything fancier because $n$ mod is very fast for p in Primes do if n mod p = 0 then return false; fi; if n < (p+1)^2 then AddSet( Primes2, n ); return true; fi; od; # do trial division by the other known primes for p in Primes2 do if n mod p = 0 then return false; fi; od; # do trial division by the other known probable primes for p in ProbablePrimes2 do if n mod p = 0 then return false; fi; od; # find $e$ and $o$ odd such that $n-1 = 2^e * o$ e := 0; o := n-1; while o mod 2 = 0 do e := e+1; o := o/2; od; # look at the seq $2^o, 2^{2 o}, 2^{4 o}, .., 2^{2^e o}=2^{n-1}$ x := PowerModInt( 2, o, n ); i := 0; while i < e and x <> 1 and x <> n-1 do x := x * x mod n; i := i + 1; od; # if it is not of the form $.., -1, 1, 1, ..$ then $n$ is composite if not (x = n-1 or (i = 0 and x = 1)) then return false; fi; ## # there are no strong pseudo-primes to base 2 smaller than 2047 ## FL: never used ## if n < 2047 then ## AddSet( Primes2, n ); ## return true; ## fi; # make sure that $n$ is not a perfect power (especially not a square) if SmallestRootInt(n) < n then return false; fi; # find a quadratic nonresidue $d = p^2/4-1$ mod $n$ p := 2; while Jacobi( p^2-4, n ) <> -1 do p := p+1; od; # for a prime $n$ the trace of $(p/2+\sqrt{d})^n$ must be $p$ # and the trace of $(p/2+\sqrt{d})^{n+1}$ must be 2 if TraceModQF( p, n+1, n ) = [ 2, p ] then # n < 10^13 fulfilling the tests so far are prime if n < 10^13 then return true; else return fail; fi; fi; # $n$ is not a prime return false; end); InstallGlobalFunction(IsPrimeIntOld,function ( n ) local res; res := IsProbablyPrimeIntWithFail(n); if res = false then return false; else if res = fail then Info(InfoPrimeInt, 1, "IsPrimeInt: probably prime, but not proven: ", n); AddSet( ProbablePrimes2, n ); else AddSet( Primes2, n ); fi; return true; fi; end); ############################################################################# ## #F IsPrimePowerInt( ) . . . . . . . . . . . test for a power of a prime ## InstallGlobalFunction( IsPrimePowerInt, n -> IsPrimeInt( SmallestRootInt( n ) ) ); ############################################################################# ## #F LcmInt( , ) . . . . . . . . . . least common multiple of integers ## InstallGlobalFunction(LcmInt,function ( n, m ) if m = 0 and n = 0 then return 0; else return AbsInt( m / GcdInt( m, n ) * n ); fi; end); ############################################################################# ## #F LogInt( , ) . . . . . . . . . . . . . . logarithm of an integer ## InstallGlobalFunction(LogInt,function ( n, base ) local log, p; # check arguments if not IsInt(n) or n <= 0 then Error(" must be a positive integer"); fi; if not IsInt(base) or base <= 1 then Error(" must be an integer greater than 1"); fi; # `log(b)' returns $log_b(n)$ and divides `n' by `b^log(b)' ## log := function ( b ) ## local i; ## if b > n then return 0; fi; ## i := log( b^2 ); ## if b > n then return 2 * i; ## else n := QuoInt( n, b ); return 2 * i + 1; fi; ## end; ## ## return log( base ); if n < base then return 0; elif base = 2 then return Log2Int(n); elif base = 8 then return QuoInt(Log2Int(n), 3); elif base = 16 then return QuoInt(Log2Int(n), 4); elif IsSmallIntRep(n) then log := 1; p := base * base; while p <= n do log := log + 1; p := p * base; od; return log; elif base = 10 then log := QuoInt(Log2Int(n) * 10^6 , 3321929); return log + LogInt(QuoInt(n, 10^log), 10); else log := QuoInt(Log2Int(n), Log2Int(base)+1); if log = 0 then log := 1; fi; return log + LogInt(QuoInt(n, base^log), base); fi; end); ############################################################################# ## #F NextPrimeInt( ) . . . . . . . . . . . . . . . . . . next larger prime ## InstallGlobalFunction(NextPrimeInt,function ( n ) if -3 = n then n := -2; elif -3 < n and n < 2 then n := 2; elif n mod 2 = 0 then n := n+1; else n := n+2; fi; while not IsPrimeInt(n) do if n mod 6 = 1 then n := n+4; else n := n+2; fi; od; return n; end); ############################################################################# ## #F PowerModInt(,,) . . . . . . power of one integer modulo another ## InstallGlobalFunction(PowerModInt,function ( r, e, m ) local pow, f; # handle special cases if m = 1 then return 0; elif e = 0 then return 1; fi; # reduce `r' initially r := r mod m; # if `e' is negative then invert `r' modulo `m' with Euclids algorithm if e < 0 then r := 1/r mod m; e := -e; fi; # now use the repeated squaring method (right-to-left) pow := 1; f := 2 ^ (LogInt( e, 2 ) + 1); while 1 < f do pow := (pow * pow) mod m; f := QuoInt( f, 2 ); if f <= e then pow := (pow * r) mod m; e := e - f; fi; od; # return the power return pow; end); ############################################################################# ## #F PrevPrimeInt( ) . . . . . . . . . . . . . . . previous smaller prime ## ## `PrevPrimeInt' returns the largest prime which is strictly smaller than ## the integer . ## InstallGlobalFunction(PrevPrimeInt,function ( n ) if 3 = n then n := 2; elif -2 < n and n < 3 then n := -2; elif n mod 2 = 0 then n := n-1; else n := n-2; fi; while not IsPrimeInt(n) do if n mod 6 = 5 then n := n-4; else n := n-2; fi; od; return n; end); ############################################################################# ## #F PrimePowerInt( ) . . . . . . . . . . . . . . . . prime powers of ## InstallGlobalFunction(PrimePowersInt,function( n ) local p, pows, lst; if n = 1 then return []; elif n = 0 then Error( " must be non zero" ); elif n < 0 then n := -1 * n; fi; lst := Factors( Integers, n ); pows := []; for p in Set( lst ) do Add( pows, p ); Add( pows, Number( lst, x -> x = p ) ); od; return pows; end); ############################################################################# ## #F RootInt( ) . . . . . . . . . . . . . . . . . . . root of an integer #F RootInt( , ) ## InstallGlobalFunction(RootInt,function ( arg ) local n, k, r, s, t; # get the arguments if Length(arg) = 1 then n := arg[1]; k := 2; elif Length(arg) = 2 then n := arg[1]; k := arg[2]; else Error("usage: `Root( )' or `Root( , )'"); fi; # check the arguments and handle trivial cases if k <= 0 then Error(" must be positive"); elif k = 1 then return n; elif n < 0 and k mod 2 = 0 then Error(" must be positive"); elif n < 0 and k mod 2 = 1 then return -RootInt( -n, k ); elif n = 0 then return 0; elif n <= k then return 1; fi; # r is the first approximation, s the second, we need: root <= s < r r := n; s := 2^( QuoInt( LogInt(n,2), k ) + 1 ) - 1; # do Newton iterations until the approximations stop decreasing while s < r do r := s; t := r^(k-1); s := QuoInt( n + (k-1)*r*t, k*t ); od; # and thats the integer part of the root return r; end); ############################################################################# ## #F AbsInt( ) . . . . . . . . . . . . . . . absolute value of an integer ## InstallGlobalFunction( AbsInt, function( n ) if 0 <= n then return n; else return -n; fi; end ); ############################################################################# ## #F AbsoluteValue( ) ## # uses the particular form of AbsInt InstallMethod(AbsoluteValue,"rationals",true,[IsRat],0,AbsInt); ############################################################################# ## #F SignInt( ) . . . . . . . . . . . . . . . . . . . sign of an integer ## InstallGlobalFunction( SignInt, function( n ) if 0 = n then return 0; elif 0 <= n then return 1; else return -1; fi; end ); ############################################################################# ## #F SmallestRootInt( ) . . . . . . . . . . . smallest root of an integer ## InstallGlobalFunction(SmallestRootInt,function ( n ) local k, r, s, p, l, q; # check the argument if n > 0 then k := 2; s := 1; elif n < 0 then k := 3; s := -1; n := -n; else return 0; fi; # exclude small divisors, and thereby large exponents if n mod 2 = 0 then p := 2; else p := 3; while p < 100 and n mod p <> 0 do p := p+2; od; fi; l := LogInt( n, p ); # loop over the possible prime divisors of exponents # use Euler's criterion to cast out impossible ones while k <= l do q := 2*k+1; while not IsPrimeInt(q) do q := q+2*k; od; if PowerModInt( n, (q-1)/k, q ) <= 1 then r := RootInt( n, k ); if r ^ k = n then n := r; l := QuoInt( l, k ); else k := NextPrimeInt( k ); fi; else k := NextPrimeInt( k ); fi; od; return s * n; end); ############################################################################# ## #M RingByGenerators( ) . . . . . . . ring generated by some integers ## InstallMethod( RingByGenerators, "method that catches the cases of `Integers' and subrings of `Integers'", [ IsCyclotomicCollection ], SUM_FLAGS, # test this before doing anything else function( elms ) if ForAll( elms, IsInt ) then # check that the number of generators is bigger than one # to avoid infinite recursion if Length( elms ) > 1 then return RingByGenerators( [ Gcd(elms) ] ); elif elms[1] = 1 then return Integers; else TryNextMethod(); fi; else TryNextMethod(); fi; end ); ############################################################################# ## #M RingWithOneByGenerators( ) . . . . ring generated by some integers ## InstallMethod( RingWithOneByGenerators, "method that catches the cases of `Integers'", [ IsCyclotomicCollection ], SUM_FLAGS, # test this before doing anything else function( elms ) if ForAll( elms, IsInt ) then return Integers; else TryNextMethod(); fi; end ); ############################################################################# ## #M DefaultRingByGenerators( ) default ring generated by some integers ## InstallMethod( DefaultRingByGenerators, "method that catches the cases of `(Gaussian)Integers' and cycl. fields", [ IsCyclotomicCollection ], SUM_FLAGS, # test this before doing anything else function( elms ) if ForAll( elms, IsInt ) then return Integers; elif ForAll( elms, IsGaussInt ) then return GaussianIntegers; else return DefaultField( elms ); fi; end ); ############################################################################# ## #M DefaultRingByGenerators( ) . for a list of n x n integer matrices ## InstallMethod( DefaultRingByGenerators, "for lists of n x n integer matrices", true, [ IsCyclotomicCollCollColl and IsFinite ], function ( mats ) local d; if IsEmpty(mats) or not ForAll(mats,IsRectangularTable and IsMatrix) then TryNextMethod(); fi; d := Length( mats[1] ); if d=0 then TryNextMethod(); fi; if not ForAll( mats, m -> Length(m)=d and Length(m[1])=d ) then TryNextMethod(); fi; if not ForAll( mats, m -> ForAll( m, r -> ForAll(r,IsInt))) then TryNextMethod(); fi; return FullMatrixAlgebra(Integers,d); end ); ############################################################################# ## #M Enumerator( Integers ) ## ## $a_n = \frac{n}{2}$ if $n$ is even, and ## $a_n = \frac{1-n}{2}$ otherwise. ## InstallMethod( Enumerator, "for integers", [ IsIntegers ], Integers -> EnumeratorByFunctions( Integers, rec( ElementNumber := function( e, n ) if n mod 2 = 0 then return n / 2; else return ( 1 - n ) / 2; fi; end, NumberElement := function( e, x ) local pos; if not IsInt( x ) then return fail; elif 0 < x then pos:= 2 * x; else pos:= -2 * x + 1; fi; return pos; end ) ) ); ############################################################################# ## #M EuclideanDegree( Integers, ) . . . . . . . . . . . . . absolut value ## InstallMethod( EuclideanDegree, "for integers", true, [ IsIntegers, IsInt ], 0, function ( Integers, n ) if n < 0 then return -n; else return n; fi; end ); ############################################################################# ## #M EuclideanQuotient( Integers, , ) . . . . . . Euclidean quotient ## InstallMethod( EuclideanQuotient, "for integers", true, [ IsIntegers, IsInt, IsInt ], 0, function ( Integers, n, m ) return QuoInt( n, m ); end ); ############################################################################# ## #M EuclideanRemainder( Integers, , ) . . . . . . Euclidean remainder ## InstallMethod( EuclideanRemainder, "for integers", true, [ IsIntegers, IsInt, IsInt ], 0, function ( Integers, n, m ) return RemInt( n, m ); end ); ############################################################################# ## #M Factors( Integers, ) . . . . . . . . . . factorization of an integer ## InstallMethod( Factors, "for integers", true, [ IsIntegers, IsInt ], 0, function ( Integers, n ) return FactorsInt( n ); end ); ############################################################################# ## #M GcdOp( Integers, , ) . . . . . . . . . . . . . gcd of two integers ## InstallMethod( GcdOp, "for integers", true, [ IsIntegers, IsInt, IsInt ], 0, function ( Integers, n, m ) return GcdInt( n, m ); end ); ############################################################################# ## #M IsIrreducibleRingElement( Integers, ) ## InstallMethod( IsIrreducibleRingElement, "for integers", true, [ IsIntegers, IsInt ], 0, function ( Integers, n ) return IsPrimeInt( n ); end ); ############################################################################# ## #M IsPrime( Integers, ) . . . . . . test whether an integer is a prime ## InstallMethod( IsPrime, "for integers", true, [ IsIntegers, IsInt ], 0, function ( Integers, n ) return IsPrimeInt( n ); end ); ############################################################################# ## #M Iterator( Integers ) ## ## uses the succession $0, 1, -1, 2, -2, 3, -3, \ldots$, that is, ## $a_n = \frac{n}{2}$ if $n$ is even, and $a_n = \frac{1-n}{2}$ ## otherwise. ## InstallMethod( Iterator, "for `Integers'", [ IsIntegers ], Integers -> IteratorByFunctions( rec( NextIterator := function( iter ) iter!.counter:= iter!.counter + 1; if iter!.counter mod 2 = 0 then return iter!.counter / 2; else return ( 1 - iter!.counter ) / 2; fi; end, IsDoneIterator := ReturnFalse, ShallowCopy := iter -> rec( counter:= iter!.counter ), counter := 0 ) ) ); ############################################################################# ## #M Iterator( PositiveIntegers ) ## InstallMethod( Iterator, "for `PositiveIntegers'", [ IsPositiveIntegers ], IsPositiveIntegers -> IteratorByFunctions( rec( NextIterator := function( iter ) iter!.counter:= iter!.counter + 1; return iter!.counter; end, IsDoneIterator := ReturnFalse, ShallowCopy := iter -> rec( counter:= iter!.counter ), counter := 0 ) ) ); # 0, since we first increment then return ############################################################################# ## #M LcmOp( Integers, , ) . . . . . . least common multiple of integers ## InstallMethod( LcmOp, "for integers", true, [ IsIntegers, IsInt, IsInt ], 0, function ( Integers, n, m ) return LcmInt( n, m ); end ); ############################################################################# ## #M Log( , ) ## InstallMethod( Log, "for two integers", true, [ IsInt, IsInt ], 0, LogInt ); ############################################################################# ## #M PowerMod( Integers, , , ) . . . power of an integer mod another ## InstallMethod( PowerMod, "for integers", true, [ IsIntegers, IsInt, IsInt, IsInt ], 0, function ( Integers, r, e, m ) return PowerModInt( r, e, m ); end ); ############################################################################# ## #M Quotient( , , ) . . . . . . . quotient of two integers ## InstallMethod( Quotient, "for integers", true, [ IsIntegers, IsInt, IsInt ], 0, function ( Integers, n, m ) local q; q := QuoInt( n, m ); if n <> q * m then q := fail; fi; return q; end ); ############################################################################# ## #M QuotientMod( Integers , , , ) . . . . . . . quotient modulo ## InstallMethod( QuotientMod, "for integers", true, [ IsIntegers, IsInt, IsInt, IsInt ], 0, function ( Integers, r, s, m ) if s>m then s:=s mod m;fi; if m = 1 then return 0; elif r mod GcdInt( s, m ) = 0 then return r/s mod m; else return fail; fi; end ); ############################################################################# ## #M QuotientRemainder( Integers, , ) . . . . . . . . . . . quo and rem ## InstallMethod( QuotientRemainder, "for integers", true, [ IsIntegers, IsInt, IsInt ], 0, function ( Integers, n, m ) local q; q := QuoInt(n,m); #T kernel function should compute remainder at same time return [ q, n - q * m ]; end ); ############################################################################# ## #M Random( Integers ) . . . . . . . . . . . . . . . . . . . random integer ## ## returns pseudo random integers between $-10$ and $10$ ## distributed according to a binomial distribution. ## ## \begintt ## gap> Random( Integers ); ## 1 ## gap> Random( Integers ); ## -4 ## \endtt ## ## To generate uniformly distributed integers from a range, use the ## construct `Random( [ .. ] )'. ## NrBitsInt := function ( n ) local nr, nr64; nr64:=[0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5, 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6]; nr := 0; while 0 < n do nr := nr + nr64[ n mod 64 + 1 ]; n := QuoInt( n, 64 ); od; return nr; end; InstallMethod( Random, "for `Integers'", true, [ IsIntegers ], 0, function( Integers ) return NrBitsInt( Random( [0..2^20-1] ) ) - 10; end ); ############################################################################# ## #M Root( , ) ## InstallMethod( Root, "for two integers", true, [ IsInt, IsInt ], 0, RootInt ); ############################################################################# ## #M RoundCyc( ) . . . . . . . . . . cyclotomic integer near to ## InstallMethod( RoundCyc, "Integer", true, [ IsInt ], 0, x->x ); ############################################################################# ## #M RoundCycDown( ) . . . . . . . . . . cyclotomic integer near to ## InstallMethod( RoundCycDown, "Integer", true, [ IsInt ], 0, x->x ); ############################################################################# ## #M StandardAssociate( Integers, ) . . . . . . . . . . . absolute value ## InstallMethod( StandardAssociate, "for integers", true, [ IsIntegers, IsInt ], 0, function ( Integers, n ) if n < 0 then return -n; else return n; fi; end ); ############################################################################# ## #M StandardAssociateUnit( Integers, ) ## InstallMethod( StandardAssociateUnit, "for integers", true, [ IsIntegers, IsInt ], 0, function ( Integers, n ) if n < 0 then return -1; else return 1; fi; end ); ############################################################################# ## #M Valuation( , ) ## InstallOtherMethod( Valuation, "for two integers", IsIdenticalObj, [ IsInt, IsInt ], 0, function( n, m ) local val; if n = 0 then val := infinity; else val := 0; while n mod m = 0 do val := val + 1; n := n / m; od; fi; return val; end ); ############################################################################# ## #M \in( , ) . . . . . . . . . . membership test for integers ## InstallMethod( \in, "for integers", IsElmsColls, [ IsCyclotomic, IsIntegers ], 0, function( n, Integers ) return IsInt( n ); end ); ############################################################################# ## #M \in( , ) ## InstallMethod( \in, "for positive integers", IsElmsColls, [ IsCyclotomic, IsPositiveIntegers ], 0, function( n, PositiveIntegers ) return IsPosInt( n ); end ); ############################################################################# ## #M \in( , ) ## InstallMethod( \in, "for nonnegative integers", IsElmsColls, [ IsCyclotomic, IsNonnegativeIntegers ], 0, function( n, NonnegativeIntegers ) return IsPosInt( n ) or IsZeroCyc( n ); end ); ############################################################################# ## #F PrintFactorsInt( ) . . . . . . . . print factorization of an integer ## InstallGlobalFunction(PrintFactorsInt,function ( n ) local decomp, i; if -4 < n and n < 4 then Print( n ); else decomp := Collected( Factors( AbsInt( n ) ) ); if n > 0 then Print( decomp[1][1] ); else Print( -decomp[1][1] ); fi; if decomp[1][2] > 1 then Print( "^", decomp[1][2] ); fi; for i in [ 2 .. Length( decomp ) ] do Print( "*", decomp[i][1] ); if decomp[i][2] > 1 then Print( "^", decomp[i][2] ); fi; od; fi; end); ############################################################################# ## #M Iterator( ) . . . . . . . . . . . . .give more informative error ## ## This method is mainly there to trap the "natural" error ## for i in 3 do ... od; ## InstallOtherMethod(Iterator, "more helpful error for integers", true, [IsPosInt], 0, function(n) Error("You cannot loop over the integer ",n, " did you mean the range [1..",n,"]"); end); InstallGlobalFunction(PowerDecompositions,function(n) local d,i,r; i:=2; d:=[]; repeat r:=RootInt(n,i); if n=r^i then Add(d,[r,i]); fi; i:=i+1; until r<2; return d; end); ## The behaviour of View(String) for large integers can be configured via a ## user preference. DeclareUserPreference( rec( name:= "MaxBitsIntView", description:= [ "Maximal bit length of integers to 'view' unabbreviated. \ Default is about 30 lines of a 80 character wide terminal. \ Set this to '0' to avoid abbreviated ints." ], default:= 8000, check:= val -> IsInt( val ) and 0 <= val, ) ); ## give only a short info if |n| is larger than 2^GAPInfo.MaxBitsIntView InstallMethod(ViewString, "for integer", [IsInt], function(n) local mb, l, start, trail; mb := UserPreference("MaxBitsIntView"); if not IsSmallIntRep(n) and mb <> fail and mb > 64 and Log2Int(n) > mb then if n < 0 then l := LogInt(-n, 10); trail := String(-n mod 1000); else l := LogInt(n, 10); trail := String(n mod 1000); fi; start := String(QuoInt(n, 10^(l-2))); while Length(trail) < 3 do trail := Concatenation("0", trail); od; return Concatenation(""); else return String(n); fi; end); ############################################################################# ## #E gap-4r6p5/lib/vec8bit.gd0000644000175000017500000000606112172557254013574 0ustar billbill############################################################################# ## #W vec8bit.gd GAP Library Steve Linton ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file should possibly be called vec8bit.g (see also vecmat.gd) ## It provides some things that the kernel needs from the library ## ############################################################################# ## #V PRIMES_COMPACT_FIELDS primes for which a compact representation exists ## BIND_GLOBAL("PRIMES_COMPACT_FIELDS",SSortedList( [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97, 101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191, 193,197,199,211,223,227,229,233,239,241,251] )); ############################################################################# ## #R Is8BitVectorRep( ) . . . compressed vector over GFQ (3 <= q <= 256) ## DeclareRepresentation( "Is8BitVectorRep", IsDataObjectRep and IsRowVectorObj,[], IsRowVector and IsSmallList ); ############################################################################# ## #v TYPES_VEC8BIT . . . . . . . . prepared types for compressed GF(q) vectors ## ## A length 3 list of length 257 lists. TYPES_VEC8BIT[1][q] will be the type ## of mutable vectors over GF(q), TYPES_VEC8BIT[2][q] is the type of ## immutable vectors. TYPES_VEc8BIT[3][q] is the type of locked vectors. ## The 257th position is bound to 1 to stop the lists ## shrinking. ## ## It is accessed directly by the kernel, so the format cannot be changed ## without changing the kernel. ## DeclareGlobalVariable( "TYPES_VEC8BIT" ); ############################################################################# ## #F TYPE_VEC8BIT( , ) . . computes type of compressed GF(q) vectors ## ## Normally called by the kernel, caches results in TYPES_VEC8BIT ## DeclareGlobalFunction( "TYPE_VEC8BIT" ); DeclareGlobalFunction( "TYPE_VEC8BIT_LOCKED" ); ############################################################################# ## #V TYPE_FIELDINFO_8BIT . . . . . . . . . . . . . type of the fieldinfo bags ## ## These bags are created by the kernel and accessed by the kernel. The type ## doesn't really say anything, because there are no applicable operations. ## DeclareGlobalVariable( "TYPE_FIELDINFO_8BIT" ); ############################################################################# ## #M IsConstantTimeAccessList( ) #M IsSmallList( ) #M IsListDefault( ) ## ## All compressed GF(q) vectors are small and constant-time access, ## and support the default list arithmetic (multiplication and addition). ## InstallTrueMethod( IsConstantTimeAccessList, IsList and Is8BitVectorRep ); InstallTrueMethod( IsSmallList, IsList and Is8BitVectorRep ); InstallTrueMethod( IsListDefault, IsList and Is8BitVectorRep ); ############################################################################# ## #E gap-4r6p5/lib/mapprep.gi0000644000175000017500000016414612172557252013710 0ustar billbill############################################################################# ## #W mapprep.gi GAP library Thomas Breuer #W & Martin Schönert #W & Frank Celler ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains (representation dependent) ## ## 1. methods for general mappings in 'IsDefaultMappingRep' ## 2. methods for composition mappings, ## 3. methods for mappings by function, ## 4. methods for inverse mappings ## 5. methods for identity mappings ## 6. methods for zero mappings ## ############################################################################# ## ## 1. methods for general mappings in 'IsDefaultMappingRep' ## ############################################################################# ## #R IsDefaultGeneralMappingRep( ) ## ## Source and range of such a general mapping are stored in its type, as ## 'DataType( TypeObj( ) )[1]' resp. ## 'DataType( TypeObj( ) )[2]'. ## ## Note that this representation does *not* decide whether is ## a positional or a component object. ## DeclareRepresentation( "IsDefaultGeneralMappingRep", IsGeneralMapping and HasSource and HasRange, [] ); #T methods to handle attributes 'One', 'Inverse', and 'InverseGeneralMapping', #T 'ImagesSource', 'PreImagesRange'? ############################################################################# ## #F TypeOfDefaultGeneralMapping( , , ) ## InstallGlobalFunction( TypeOfDefaultGeneralMapping, function( source, range, filter ) local Type; # Do a cheap test whether the general mapping has equal source and range. if IsIdenticalObj( source, range ) then filter:= filter and IsEndoGeneralMapping; fi; # Construct the type. Type:= NewType( GeneralMappingsFamily( ElementsFamily( FamilyObj( source ) ), ElementsFamily( FamilyObj( range ) ) ), IsDefaultGeneralMappingRep and filter ); # Store source and range. SetDataType( Type, [ source, range ] ); # Return the type. return Type; end ); ############################################################################# ## #M Range( ) ## InstallMethod( Range, "for default general mapping", true, [ IsGeneralMapping and IsDefaultGeneralMappingRep ], GETTER_FLAGS + 1, # higher than the system getter! map -> DataType( TypeObj( map ) )[2] ); ############################################################################# ## #M Source( ) ## InstallMethod( Source, "for default general mapping", true, [ IsGeneralMapping and IsDefaultGeneralMappingRep ], GETTER_FLAGS + 1, # higher than the system getter! map -> DataType( TypeObj( map ) )[1] ); ############################################################################# ## ## 2. methods for composition mappings, ## ############################################################################# ## #F ConstituentsCompositionMapping( ) ## InstallGlobalFunction(ConstituentsCompositionMapping,function(map) if not IsCompositionMappingRep(map) then Error(" must be `IsCompositionMappingRep'"); fi; return [map!.map1,map!.map2]; end); ############################################################################# ## #M CompositionMapping2( , ) . . . . . for two general mappings ## InstallGlobalFunction(CompositionMapping2General, function( map2, map1 ) local com; # composition of and , result # Make the general mapping. if IsSPGeneralMapping( map1 ) and IsSPGeneralMapping( map2 ) then com:= Objectify( TypeOfDefaultGeneralMapping( Source( map1 ), Range( map2 ), IsCompositionMappingRep and IsSPGeneralMapping ), rec() ); else com:= Objectify( TypeOfDefaultGeneralMapping( Source( map1 ), Range( map2 ), IsCompositionMappingRep and IsNonSPGeneralMapping ), rec() ); fi; # Enter the identifying information. # (Maintenance of useful information is dealt with by the # wrapper function `CompositionMapping'.) com!.map1:= map1; com!.map2:= map2; # Return the composition. return com; end ); InstallMethod( CompositionMapping2, "for two general mappings", FamSource1EqFamRange2, [ IsGeneralMapping, IsGeneralMapping ], 0, CompositionMapping2General); ############################################################################# ## #M IsInjective( ) . . . . . . . . . . . . . . for composition mapping ## InstallMethod( IsInjective, "for a composition mapping", true, [ IsCompositionMappingRep ], 0, function( com ) if IsInjective( com!.map1 ) and IsInjective( com!.map2 ) then return true; fi; if not IsInjective( com!.map1 ) and IsTotal( com!.map2 ) then return false; fi; if IsSurjective( com!.map1 ) and IsSingleValued( com!.map1 ) and not IsInjective( com!.map2 ) then return false; fi; TryNextMethod(); end ); ############################################################################# ## #M IsSingleValued( ) . . . . . . . . . . . . for composition mapping ## InstallMethod( IsSingleValued, "for a composition mapping", true, [ IsCompositionMappingRep ], 0, function( com ) if IsSingleValued( com!.map1 ) and IsSingleValued( com!.map2 ) then return true; fi; if not IsSingleValued( com!.map1 ) and IsInjective( com!.map2 ) and IsTotal( com!.map2 ) then return false; fi; if IsSurjective( com!.map1 ) and not IsSingleValued( com!.map2 ) then return false; fi; TryNextMethod(); end ); ############################################################################# ## #M IsSurjective( ) . . . . . . . . . . . . . . for composition mapping ## InstallMethod( IsSurjective, "for a composition mapping", true, [ IsCompositionMappingRep ], 0, function( com ) if not IsSurjective( com!.map2 ) then return false; elif IsSurjective( com!.map1 ) and IsSubset( Range( com!.map1 ), PreImagesRange( com!.map2 ) ) then return true; fi; TryNextMethod(); end ); ############################################################################# ## #M IsTotal( ) . . . . . . . . . . . . . . . . for composition mapping ## InstallMethod( IsTotal, "for a composition mapping", true, [ IsCompositionMappingRep ], 0, function( com ) if not IsTotal( com!.map1 ) then return false; elif IsTotal( com!.map2 ) and IsSubset( Source( com!.map2 ), ImagesSource( com!.map1 ) ) then return true; fi; TryNextMethod(); end ); ############################################################################# ## #M ImagesElm( , ) . . . . . . . . . . . . for composition mapping ## InstallMethod( ImagesElm, "for a composition mapping, and an element", FamSourceEqFamElm, [ IsCompositionMappingRep, IsObject ], 0, function( com, elm ) local im; im:= ImagesElm( com!.map1, elm ); if not IsEmpty( im ) then return ImagesSet( com!.map2, im ); else return []; fi; end ); ############################################################################# ## #M ImagesSet( , ) . . . . . . . . . . . for composition mapping ## InstallMethod( ImagesSet, "for a composition mapping, and an collection", CollFamSourceEqFamElms, [ IsCompositionMappingRep, IsCollection ], 0, function ( com, elms ) local im; im:= ImagesSet( com!.map1, elms ); if not IsEmpty( im ) then return ImagesSet( com!.map2, im ); else return []; fi; end ); ############################################################################# ## #M ImagesRepresentative( , ) . . . . . . for composition mapping ## InstallMethod( ImagesRepresentative, "for a composition mapping, and an element", FamSourceEqFamElm, [ IsCompositionMappingRep, IsObject ], 0, function( com, elm ) local im, rep; im:= ImagesRepresentative( com!.map1, elm ); if im = fail then # 'elm' has no images under 'com!.map1', so it has none under 'com'. return fail; else im:= ImagesRepresentative( com!.map2, im ); if im <> fail then return im; fi; # It may happen that only the chosen representative has no images. for im in Enumerator( ImagesElm( com!.map1, elm ) ) do rep:= ImagesRepresentative( com!.map2, im ); if rep <> fail then return rep; fi; od; return fail; fi; end ); ############################################################################# ## #M PreImagesElm( , ) . . . . . . . . . . for composition mapping ## InstallMethod( PreImagesElm, "for a composition mapping, and an element", FamRangeEqFamElm, [ IsCompositionMappingRep, IsObject ], 0, function( com, elm ) local im; im:= PreImagesElm( com!.map2, elm ); if not IsEmpty( im ) then return PreImagesSet( com!.map1, im ); else return []; fi; end ); ############################################################################# ## #M PreImagesSet( , ) . . . . . . . . . . for composition mapping ## InstallMethod( PreImagesSet, "for a composition mapping, and an collection", CollFamRangeEqFamElms, [ IsCompositionMappingRep, IsCollection ], 0, function( com, elms ) local im; im:= PreImagesSet( com!.map2, elms ); if not IsEmpty( im ) then return PreImagesSet( com!.map1, im ); else return []; fi; end ); ############################################################################# ## #M PreImagesRepresentative( , ) . . . . . for composition mapping ## InstallMethod( PreImagesRepresentative, "for a composition mapping, and an element", FamRangeEqFamElm, [ IsCompositionMappingRep, IsObject ], 0, function( com, elm ) local im, rep; im:= PreImagesRepresentative( com!.map2, elm ); if im = fail then # 'elm' has no preimages under 'com!.map2', so it has none under 'com'. return fail; else im:= PreImagesRepresentative( com!.map1, im ); if im <> fail then return im; fi; # It may happen that only the chosen representative has no preimages. for im in Enumerator( PreImagesElm( com!.map2, elm ) ) do rep:= PreImagesRepresentative( com!.map1, im ); if rep <> fail then return rep; fi; od; return fail; fi; end ); ############################################################################# ## #M KernelOfAdditiveGeneralMapping( ) . . . . . for composition mapping ## InstallMethod( KernelOfAdditiveGeneralMapping, "for a composition mapping that resp. add. and add.inv.", true, [ IsGeneralMapping and IsCompositionMappingRep and RespectsAddition and RespectsAdditiveInverses ], 0, function( com ) if IsInjective( com!.map2 ) then return KernelOfAdditiveGeneralMapping( com!.map1 ); else return PreImagesSet( com!.map1, KernelOfAdditiveGeneralMapping( com!.map2 ) ); fi; end ); ############################################################################# ## #M CoKernelOfAdditiveGeneralMapping( ) . . . . for composition mapping ## InstallMethod( CoKernelOfAdditiveGeneralMapping, "for a composition mapping that resp. add. and add.inv.", true, [ IsGeneralMapping and IsCompositionMappingRep and RespectsAddition and RespectsAdditiveInverses ], 0, function( com ) if IsSingleValued( com!.map1 ) then return CoKernelOfAdditiveGeneralMapping( com!.map2 ); else return ImagesSet( com!.map2, CoKernelOfAdditiveGeneralMapping( com!.map1 ) ); fi; end ); ############################################################################# ## #M KernelOfMultiplicativeGeneralMapping( ) . . for composition mapping ## InstallMethod( KernelOfMultiplicativeGeneralMapping, "for a composition mapping that resp. mult. and inv.", true, [ IsGeneralMapping and IsCompositionMappingRep and RespectsMultiplication and RespectsInverses ], 0, function( com ) if IsInjective( com!.map2 ) then return KernelOfMultiplicativeGeneralMapping( com!.map1 ); else return PreImagesSet( com!.map1, KernelOfMultiplicativeGeneralMapping( com!.map2 ) ); fi; end ); ############################################################################# ## #M CoKernelOfMultiplicativeGeneralMapping( ) . for composition mapping ## InstallMethod( CoKernelOfMultiplicativeGeneralMapping, "for a composition mapping that resp. mult. and inv.", true, [ IsGeneralMapping and IsCompositionMappingRep and RespectsMultiplication and RespectsInverses ], 0, function( com ) if IsSingleValued( com!.map1 ) then return CoKernelOfMultiplicativeGeneralMapping( com!.map2 ); else return ImagesSet( com!.map2, CoKernelOfMultiplicativeGeneralMapping( com!.map1 ) ); fi; end ); ############################################################################# ## #M ViewObj( ) . . . . . . . . . . . . . . . . for composition mapping #M PrintObj( ) . . . . . . . . . . . . . . . . for composition mapping ## InstallMethod( ViewObj, "for a composition mapping", true, [ IsCompositionMappingRep ], 100, function( com ) Print( "CompositionMapping( ", BHINT ); View( com!.map2 ); Print( ",", BHINT, " " ); View( com!.map1 ); Print( " )", BHINT ); end ); InstallMethod( PrintObj, "for a composition mapping", true, [ IsCompositionMappingRep ], 100, function( com ) Print( "CompositionMapping( ", com!.map2, ", ", com!.map1, " )" ); end ); ############################################################################# ## ## 3. methods for mappings by function, ## ############################################################################# ## #R IsMappingByFunctionRep( ) ## DeclareRepresentation( "IsMappingByFunctionRep", IsMapping and IsAttributeStoringRep, [ "fun" ] ); #T really attribute storing ?? ############################################################################# ## #R IsMappingByFunctionWithInverseRep( ) ## DeclareRepresentation( "IsMappingByFunctionWithInverseRep", IsMappingByFunctionRep and IsBijective, #T 1996/10/10 fceller where to put non-reps, 4th position? [ "fun", "invFun" ] ); ############################################################################# ## #R IsNonSPMappingByFunctionRep( ) ## DeclareRepresentation( "IsNonSPMappingByFunctionRep", IsNonSPGeneralMapping and IsMappingByFunctionRep, [] ); ############################################################################# ## #R IsNonSPMappingByFunctionWithInverseRep( ) ## DeclareRepresentation( "IsNonSPMappingByFunctionWithInverseRep", IsMappingByFunctionWithInverseRep and IsNonSPMappingByFunctionRep, [ "fun", "invFun" ] ); ############################################################################# ## #R IsSPMappingByFunctionRep( ) ## DeclareRepresentation( "IsSPMappingByFunctionRep", IsSPGeneralMapping and IsMappingByFunctionRep, [] ); ############################################################################# ## #R IsSPMappingByFunctionWithInverseRep( ) ## DeclareRepresentation( "IsSPMappingByFunctionWithInverseRep", IsMappingByFunctionWithInverseRep and IsSPMappingByFunctionRep, [ "fun", "invFun" ] ); ############################################################################# ## #F MappingByFunction( , , ) . . . . . create map from function #F MappingByFunction( , , , ) ## InstallGlobalFunction( MappingByFunction, function ( arg ) local map; # mapping , result if not Length(arg) in [3,4,5] then # signal an error Error( "usage: MappingByFunction( , , [, ] )" ); fi; # ensure that the source and range are domains if not (IsDomain(arg[1]) and IsDomain(arg[2])) then Error("MappingByFunction: Source and Range must be domains"); fi; # no inverse function given if Length(arg)<>4 then # make the general mapping map:= Objectify( TypeOfDefaultGeneralMapping( arg[1], arg[2], IsNonSPMappingByFunctionRep and IsSingleValued and IsTotal ), rec( fun:= arg[3] ) ); if Length(arg)=5 and IsFunction(arg[5]) then map!.prefun:=arg[5]; fi; # inverse function given elif Length(arg) = 4 then # make the mapping map:= Objectify( TypeOfDefaultGeneralMapping( arg[1], arg[2], IsNonSPMappingByFunctionWithInverseRep and IsBijective ), rec( fun := arg[3], invFun := arg[4], prefun := arg[4]) ); fi; # return the mapping return map; end ); ############################################################################# ## #M ImageElm( , ) . . . . . . . . . . . . for mapping by function ## InstallMethod( ImageElm, "for mapping by function", FamSourceEqFamElm, [ IsMappingByFunctionRep, IsObject ], 0, function ( map, elm ) return map!.fun( elm ); end ); ############################################################################# ## #M ImagesElm( , ) . . . . . . . . . . . . for mapping by function ## InstallMethod( ImagesElm, "for mapping by function", FamSourceEqFamElm, [ IsMappingByFunctionRep, IsObject ], 0, function ( map, elm ) return [ map!.fun( elm ) ]; end ); ############################################################################# ## #M ImagesRepresentative( , ) . . . . . . for mapping by function ## InstallMethod( ImagesRepresentative, "for mapping by function", FamSourceEqFamElm, [ IsMappingByFunctionRep, IsObject ], 0, function ( map, elm ) return map!.fun( elm ); end ); ############################################################################# ## #M KernelOfMultiplicativeGeneralMapping( ) . for mapping by function ## InstallMethod(KernelOfMultiplicativeGeneralMapping,"hom by function",true, [ IsMappingByFunctionRep and IsGroupHomomorphism ],0, function ( map ) return KernelOfMultiplicativeGeneralMapping(AsGroupGeneralMappingByImages(map)); end ); ############################################################################# ## #M PreImagesRepresentative( , ) . . . . . for mapping by function ## InstallMethod( PreImagesRepresentative, "for mapping by function", FamRangeEqFamElm, [ IsMappingByFunctionRep, IsObject ], 0, function ( map, elm ) if not IsBound(map!.prefun) then # no quick way known TryNextMethod(); fi; return map!.prefun( elm ); end ); ############################################################################# ## #M PreImageElm( , ) . . . . . . . . . . . for mapping by function ## InstallMethod( PreImageElm, "for mapping by function", FamRangeEqFamElm, [ IsMappingByFunctionWithInverseRep, IsObject ], 0, function ( map, elm ) return map!.invFun( elm ); end ); ############################################################################# ## #M PreImagesElm( , ) . . . . . . . . . . for mapping by function ## InstallMethod( PreImagesElm, "for mapping by function", FamRangeEqFamElm, [ IsMappingByFunctionWithInverseRep, IsObject ], 0, function ( map, elm ) return [ map!.invFun( elm ) ]; end ); ############################################################################# ## #M PreImagesRepresentative( , ) . . . . . for mapping by function ## InstallMethod( PreImagesRepresentative, "for mapping by function with inverse", FamRangeEqFamElm, [ IsMappingByFunctionWithInverseRep, IsObject ], 0, function ( map, elm ) return map!.invFun( elm ); end ); ############################################################################# ## ## Transfer information about the mapping map to its associated inverse ## mapping inv. For example, if map is total than inv is surjective and ## vice versa. ## BindGlobal( "TransferMappingPropertiesToInverse", function ( map, inv ) # If possible, enter preimage and image. if HasImagesSource( map ) then SetPreImagesRange( inv, ImagesSource( map ) ); fi; if HasPreImagesRange( map ) then SetImagesSource( inv, PreImagesRange( map ) ); fi; # Maintain important properties. if HasIsSingleValued( map ) then SetIsInjective( inv, IsSingleValued( map ) ); fi; if HasIsInjective( map ) then SetIsSingleValued( inv, IsInjective( map ) ); fi; if HasIsTotal( map ) then SetIsSurjective( inv, IsTotal( map ) ); fi; if HasIsSurjective( map ) then SetIsTotal( inv, IsSurjective( map ) ); fi; if HasIsEndoGeneralMapping( map ) then SetIsEndoGeneralMapping( inv, IsEndoGeneralMapping( map ) ); fi; # Maintain the maintainings w.r.t. multiplication. if HasRespectsMultiplication( map ) then SetRespectsMultiplication( inv, RespectsMultiplication( map ) ); fi; if HasRespectsInverses( map ) then SetRespectsInverses( inv, RespectsInverses( map ) ); elif HasRespectsOne( map ) then SetRespectsOne( inv, RespectsOne( map ) ); fi; # Maintain the maintainings w.r.t. addition. if HasRespectsAddition( map ) then SetRespectsAddition( inv, RespectsAddition( map ) ); fi; if HasRespectsAdditiveInverses( map ) then SetRespectsAdditiveInverses( inv, RespectsAdditiveInverses( map ) ); elif HasRespectsZero( map ) then SetRespectsZero( inv, RespectsZero( map ) ); fi; # Maintain respecting of scalar multiplication. # (Note the slight asymmetry, depending on the coefficient domains.) if HasRespectsScalarMultiplication( map ) and LeftActingDomain( Source( map ) ) = LeftActingDomain( Range( map ) ) then SetRespectsScalarMultiplication( inv, RespectsScalarMultiplication( map ) ); fi; # We know the inverse general mapping of the inverse general mapping ;-). SetInverseGeneralMapping( inv, map ); end ); ############################################################################# ## #M InverseGeneralMapping( ) . . . . . . . . . for mapping by function ## InstallMethod( InverseGeneralMapping, "for mapping by function", true, [ IsMappingByFunctionWithInverseRep ], 0, function ( map ) local inv; inv:= MappingByFunction( Range( map ), Source( map ), map!.invFun, map!.fun ); TransferMappingPropertiesToInverse( map, inv ); return inv; end ); ############################################################################# ## #M ViewObj( ) . . . . . . . . . . . . . . . . for mapping by function #M PrintObj( ) . . . . . . . . . . . . . . . . for mapping by function ## InstallMethod( ViewObj, "for mapping by function", true, [ IsMappingByFunctionRep ], 0, function ( map ) Print( "MappingByFunction( " ); View( Source( map ) ); Print( ", " ); View( Range( map ) ); Print( ", " ); View( map!.fun ); Print( " )" ); end ); InstallMethod( PrintObj, "for mapping by function", true, [ IsMappingByFunctionRep ], 0, function ( map ) Print( "MappingByFunction( ", Source( map ), ", ", Range( map ), ", ", map!.fun, " )" ); end ); ############################################################################# ## #M ViewObj( ) . . . . . . . . . for mapping by function with inverse #M PrintObj( ) . . . . . . . . . for mapping by function with inverse ## InstallMethod( ViewObj, "for mapping by function with inverse", true, [ IsMappingByFunctionWithInverseRep ], 0, function ( map ) Print( "MappingByFunction( " ); View( Source( map ) ); Print( ", " ); View( Range( map ) ); Print( ", " ); View( map!.fun ); Print( ", " ); View( map!.invFun ); Print( " )" ); end ); InstallMethod( PrintObj, "for mapping by function with inverse", true, [ IsMappingByFunctionWithInverseRep ], 0, function ( map ) Print( "MappingByFunction( ", Source( map ), ", ", Range( map ), ", ", map!.fun, ", ", map!.invFun, " )" ); end ); ############################################################################# ## ## 4. methods for inverse mappings ## ############################################################################# ## #R IsInverseGeneralMappingRep( ) ## ## Note that if a mapping knows its inverse mapping then also the inverse ## mapping knows its inverse mapping. ## So we need this flag to avoid infinite recursion when a question is ## delegated to the inverse of a mapping. ## DeclareRepresentation( "IsInverseGeneralMappingRep", IsNonSPGeneralMapping, [] ); ############################################################################# ## #M InverseGeneralMapping( ) . for a general mapping with known inverse ## InstallImmediateMethod( InverseGeneralMapping, IsGeneralMapping and HasInverse and IsAttributeStoringRep, 0, function( map ) if Inverse( map ) <> fail then return Inverse( map ); else TryNextMethod(); fi; end ); ############################################################################# ## #M InverseGeneralMapping( ) . . . . . . . . . . for a general mapping ## InstallMethod( InverseGeneralMapping, "for a general mapping", true, [ IsGeneralMapping ], 0, function ( map ) local inv; # Make the mapping. inv:= Objectify( TypeOfDefaultGeneralMapping( Range( map ), Source( map ), IsInverseGeneralMappingRep and IsAttributeStoringRep ), rec() ); TransferMappingPropertiesToInverse( map, inv ); # Return the inverse general mapping. return inv; end ); ############################################################################# ## #M IsSingleValued( ) . . . . . . . . . . . . . for an inverse mapping ## InstallMethod( IsSingleValued, "for an inverse mapping", true, [ IsGeneralMapping and IsInverseGeneralMappingRep ], 0, inv -> IsInjective( InverseGeneralMapping( inv ) ) ); ############################################################################# ## #M IsInjective( ) . . . . . . . . . . . . . . for an inverse mapping ## InstallMethod( IsInjective, "for an inverse mapping", true, [ IsGeneralMapping and IsInverseGeneralMappingRep ], 0, inv -> IsSingleValued( InverseGeneralMapping( inv ) ) ); ############################################################################# ## #M IsSurjective( ) . . . . . . . . . . . . . . for an inverse mapping ## InstallMethod( IsSurjective, "for an inverse mapping", true, [ IsGeneralMapping and IsInverseGeneralMappingRep ], 0, inv -> IsTotal( InverseGeneralMapping( inv ) ) ); ############################################################################# ## #M IsTotal( ) . . . . . . . . . . . . . . . . for an inverse mapping ## InstallMethod( IsTotal, "for an inverse mapping", true, [ IsGeneralMapping and IsInverseGeneralMappingRep ], 0, inv -> IsSurjective( InverseGeneralMapping( inv ) ) ); ############################################################################# ## #M CoKernelOfAdditiveGeneralMapping( ) . . . . for inverse mapping ## InstallMethod( CoKernelOfAdditiveGeneralMapping, "for an inverse mapping", true, [ IsGeneralMapping and IsInverseGeneralMappingRep ], 0, inv -> KernelOfAdditiveGeneralMapping( InverseGeneralMapping( inv ) ) ); ############################################################################# ## #M KernelOfAdditiveGeneralMapping( ) . . . . . for inverse mapping ## InstallMethod( KernelOfAdditiveGeneralMapping, "for an inverse mapping", true, [ IsGeneralMapping and IsInverseGeneralMappingRep ], 0, inv -> CoKernelOfAdditiveGeneralMapping( InverseGeneralMapping( inv ) ) ); ############################################################################# ## #M CoKernelOfMultiplicativeGeneralMapping( ) . for inverse mapping ## InstallMethod( CoKernelOfMultiplicativeGeneralMapping, "for an inverse mapping", true, [ IsGeneralMapping and IsInverseGeneralMappingRep ], 0, inv -> KernelOfMultiplicativeGeneralMapping( InverseGeneralMapping( inv ) ) ); ############################################################################# ## #M KernelOfMultiplicativeGeneralMapping( ) . . for inverse mapping ## InstallMethod( KernelOfMultiplicativeGeneralMapping, "for an inverse mapping", true, [ IsGeneralMapping and IsInverseGeneralMappingRep ], 0, inv -> CoKernelOfMultiplicativeGeneralMapping( InverseGeneralMapping( inv ) ) ); ############################################################################# ## #M ImageElm( , ) . . . . . . . for inverse mapping and element ## InstallMethod( ImageElm, "for an inverse mapping and an element", FamSourceEqFamElm, [ IsMapping and IsInverseGeneralMappingRep, IsObject ], 0, function ( inv, elm ) return PreImageElm( InverseGeneralMapping( inv ), elm ); end ); ############################################################################# ## #M ImagesElm( , ) . . . . . . for inverse mapping and element ## InstallMethod( ImagesElm, "for an inverse mapping and an element", FamSourceEqFamElm, [ IsGeneralMapping and IsInverseGeneralMappingRep, IsObject ], 0, function ( inv, elm ) return PreImagesElm( InverseGeneralMapping( inv ), elm ); end ); ############################################################################# ## #M ImagesSet( , ) . . . . for inverse mapping and collection ## InstallMethod( ImagesSet, "for an inverse mapping and a collection", CollFamSourceEqFamElms, [ IsGeneralMapping and IsInverseGeneralMappingRep, IsCollection ], 0, function ( inv, elms ) return PreImagesSet( InverseGeneralMapping( inv ), elms ); end ); ############################################################################# ## #M ImagesSet( , ) . . . . for inverse mapping and collection ## InstallMethod( ImagesRepresentative, "for an inverse mapping and an element", FamSourceEqFamElm, [ IsGeneralMapping and IsInverseGeneralMappingRep, IsObject ], 0, function ( inv, elm ) return PreImagesRepresentative( InverseGeneralMapping( inv ), elm ); end ); ############################################################################# ## #M PreImageElm( , ) . . . . . for inverse mapping and element ## InstallMethod( PreImageElm, "for an inj. & surj. inverse mapping, and an element", FamRangeEqFamElm, [ IsGeneralMapping and IsInverseGeneralMappingRep and IsInjective and IsSurjective, IsObject ], 0, function ( inv, elm ) return ImageElm( InverseGeneralMapping( inv ), elm ); end ); ############################################################################# ## #M PreImagesElm( , ) . . . . . for inverse mapping and element ## InstallMethod( PreImagesElm, "for an inverse mapping and an element", FamRangeEqFamElm, [ IsGeneralMapping and IsInverseGeneralMappingRep, IsObject ], 0, function ( inv, elm ) return ImagesElm( InverseGeneralMapping( inv ), elm ); end ); ############################################################################# ## #M PreImagesSet( , ) . . for inverse mapping and collection ## InstallMethod( PreImagesSet, "for an inverse mapping and a collection", CollFamRangeEqFamElms, [ IsGeneralMapping and IsInverseGeneralMappingRep, IsCollection ], 0, function ( inv, elms ) return ImagesSet( InverseGeneralMapping( inv ), elms ); end ); ############################################################################# ## #M PreImagesRepresentative( , ) . . for inv. mapping and elm. ## InstallMethod( PreImagesRepresentative, "for an inverse mapping and an element", FamRangeEqFamElm, [ IsInverseGeneralMappingRep, IsObject ], 0, function ( inv, elm ) return ImagesRepresentative( InverseGeneralMapping( inv ), elm ); end ); ############################################################################# ## #M ViewObj( ) . . . . . . . . . . . . . . . . . . for inv. mapping #M PrintObj( ) . . . . . . . . . . . . . . . . . for inv. mapping ## InstallMethod( ViewObj, "for an inverse mapping", true, [ IsGeneralMapping and IsInverseGeneralMappingRep ], 100, function ( inv ) Print( "InverseGeneralMapping( " ); View( InverseGeneralMapping( inv ) ); Print( " )" ); end ); InstallMethod( PrintObj, "for an inverse mapping", true, [ IsGeneralMapping and IsInverseGeneralMappingRep ], 100, function ( inv ) Print( "InverseGeneralMapping( ", InverseGeneralMapping( inv )," )" ); end ); ############################################################################# ## ## 5. methods for identity mappings ## ## For each domain we need to construct only one identity mapping. ## In order to allow this to interact with other mappings of this domain ## (for example, with automorphisms of a field in a special representation), ## one needs to install methods to compare these mappings with the identity ## mapping via '\=' and '\<'. ## ## Methods for identity mappings are all installed with rank 'SUM_FLAGS'. ## ############################################################################# ## ## An identity mapping whose source has a nice structure gets the properties ## to respect this structure. ## BindGlobal( "ImmediateImplicationsIdentityMapping", function( idmap ) local source; source:= Source( idmap ); # multiplicative structure if IsMagma( source ) then SetRespectsMultiplication( idmap, true ); if IsMagmaWithOne( source ) then SetRespectsOne( idmap, true ); if IsMagmaWithInverses( source ) then SetRespectsInverses( idmap, true ); fi; fi; fi; # additive structure if IsAdditiveMagma( source ) then SetRespectsAddition( idmap, true ); if IsAdditiveMagmaWithZero( source ) then SetRespectsZero( idmap, true ); if IsAdditiveGroup( source ) then SetRespectsAdditiveInverses( idmap, true ); # linear structure if IsLeftModule( source ) then SetRespectsScalarMultiplication( idmap, true ); fi; fi; fi; fi; end ); ############################################################################# ## #M IdentityMapping( ) . . . . . . . . identity mapping of a collection ## InstallMethod( IdentityMapping, "for a collection", true, [ IsCollection ], 0, function( D ) local id; # make the mapping id := Objectify( TypeOfDefaultGeneralMapping( D, D, IsSPGeneralMapping and IsAdditiveElementWithInverse and IsAttributeStoringRep and IsOne ), rec() ); # the identity mapping is self-inverse SetInverseGeneralMapping( id, id ); # set the respectings ImmediateImplicationsIdentityMapping( id ); # return the identity mapping return id; end ); ############################################################################# ## #M \^( , ) . . . . . . . . . . for identity mapping and integer ## InstallMethod( \^, "for identity mapping and integer", true, [ IsGeneralMapping and IsOne, IsInt ], SUM_FLAGS, # can't do better function ( id, n ) return id; end ); ############################################################################# ## #M ImageElm( , ) . . . . . . for identity mapping and element ## InstallMethod( ImageElm, "for identity mapping and object", FamSourceEqFamElm, [ IsGeneralMapping and IsOne, IsObject ], SUM_FLAGS, # can't do better function ( id, elm ) return elm; end ); ############################################################################# ## #M ImagesElm( , ) . . . . . . for identity mapping and element ## InstallMethod( ImagesElm, "for identity mapping and object", FamSourceEqFamElm, [ IsGeneralMapping and IsOne, IsObject ], SUM_FLAGS, # can't do better function ( id, elm ) return [ elm ]; end ); ############################################################################# ## #M ImagesSet( , ) . . . . for identity mapping and collection ## InstallMethod( ImagesSet, "for identity mapping and collection", CollFamSourceEqFamElms, [ IsGeneralMapping and IsOne, IsCollection ], SUM_FLAGS, # can't do better function ( id, elms ) return elms; end ); ############################################################################# ## #M ImagesSource( ) ## InstallMethod( ImagesSource,"for identity mapping",true, [ IsGeneralMapping and IsOne ], SUM_FLAGS, # can't do better function ( id ) return Source(id); end ); ############################################################################# ## #M ImagesRepresentative( , ) for identity mapping and element ## InstallMethod( ImagesRepresentative, "for identity mapping and object", FamSourceEqFamElm, [ IsGeneralMapping and IsOne, IsObject ], SUM_FLAGS, # can't do better function ( id, elm ) return elm; end ); ############################################################################# ## #M PreImageElm( , ) . . . . for identity mapping and element ## InstallMethod( PreImageElm, "for identity mapping and object", FamRangeEqFamElm, [ IsGeneralMapping and IsOne, IsObject ], SUM_FLAGS, # can't do better function ( id, elm ) return elm; end ); ############################################################################# ## #M PreImagesElm( , ) . . . . for identity mapping and element ## InstallMethod( PreImagesElm, "for identity mapping and object", FamRangeEqFamElm, [ IsGeneralMapping and IsOne, IsObject ], SUM_FLAGS, # can't do better function ( id, elm ) return [ elm ]; end ); ############################################################################# ## #M PreImagesSet( , ) . . . for identity mapping and collection ## InstallMethod( PreImagesSet, "for identity mapping and collection", CollFamRangeEqFamElms, [ IsGeneralMapping and IsOne, IsCollection ], SUM_FLAGS, # can't do better function ( id, elms ) return elms; end ); ############################################################################# ## #M PreImagesRepresentative( , ) ## InstallMethod( PreImagesRepresentative, "for identity mapping and object", FamRangeEqFamElm, [ IsGeneralMapping and IsOne, IsObject ], SUM_FLAGS, # can't do better function ( id, elm ) return elm; end ); ############################################################################# ## #M ViewObj( ) . . . . . . . . . . . . . . . . for identity mapping #M PrintObj( ) . . . . . . . . . . . . . . . . for identity mapping ## InstallMethod( ViewObj, "for identity mapping", true, [ IsGeneralMapping and IsOne ], SUM_FLAGS, function ( id ) Print( "IdentityMapping( " ); View( Source( id ) ); Print( " )" ); end ); InstallMethod( PrintObj, "for identity mapping", true, [ IsGeneralMapping and IsOne ], SUM_FLAGS, function ( id ) Print( "IdentityMapping( ", Source( id ), " )" ); end ); ############################################################################# ## #M CompositionMapping2( , ) . for gen. mapping and id. mapping ## InstallMethod( CompositionMapping2, "for general mapping and identity mapping", FamSource1EqFamRange2, [ IsGeneralMapping, IsGeneralMapping and IsOne ], SUM_FLAGS + 1, # should be higher than the rank for a zero mapping function ( map, id ) if not IsSubset(Range(id),Source(map)) then # if the identity is defined on something smaller, we need to take a # true `CompositionMapping'. TryNextMethod(); fi; return map; end ); ############################################################################# ## #M CompositionMapping2( , ) . for id. mapping and gen. mapping ## InstallMethod( CompositionMapping2, "for identity mapping and general mapping",FamSource1EqFamRange2, [ IsGeneralMapping and IsOne, IsGeneralMapping ], SUM_FLAGS + 1, # should be higher than the rank for a zero mapping function( id, map ) if not IsSubset(Source(id),Range(map)) and not IsSubset(Source(id),ImagesSource(map)) then # if the identity is defined on something smaller, we need to take a # true `CompositionMapping'. TryNextMethod(); fi; return map; end ); ############################################################################# ## ## 6. methods for zero mappings ## ## methods for zero mappings are all installed with rank 'SUM_FLAGS' ## #T (use 'IsZero' in '\+' method for mappings ...) ############################################################################# ## ## A zero mapping whose source has a nice structure gets the properties ## to respect this structure. ## BindGlobal( "ImmediateImplicationsZeroMapping", function( zeromap ) local source; source:= Source( zeromap ); # multiplicative structure if IsMagma( source ) then SetRespectsMultiplication( zeromap, true ); if IsMagmaWithOne( source ) then SetRespectsOne( zeromap, false ); if IsMagmaWithInverses( source ) then SetRespectsInverses( zeromap, false ); fi; fi; fi; # additive structure if IsAdditiveMagma( source ) then SetRespectsAddition( zeromap, true ); if IsAdditiveMagmaWithZero( source ) then SetRespectsZero( zeromap, true ); if IsAdditiveGroup( source ) then SetRespectsAdditiveInverses( zeromap, true ); fi; fi; fi; # linear structure if IsLeftModule( source ) then SetRespectsScalarMultiplication( zeromap, true ); fi; end ); ############################################################################# ## #F ZeroMapping( , ) ## ## maps every element of to 'Zero( )'. ## This is independent of the structure of and . ## InstallMethod( ZeroMapping, "for collection and additive-magma-with-zero", true, [ IsCollection, IsAdditiveMagmaWithZero ], 0, function( S, R ) local zero; # the zero mapping, result # make the mapping zero := Objectify( TypeOfDefaultGeneralMapping( S, R, IsSPGeneralMapping and IsAdditiveElementWithInverse and IsAttributeStoringRep and IsZero ), rec() ); # set the respectings ImmediateImplicationsZeroMapping( zero ); # return the zero mapping return zero; end ); ############################################################################# ## #M \^( , ) . . . . . . . for zero mapping and positive integer ## InstallMethod( \^, "for zero mapping and positive integer", true, [ IsGeneralMapping and IsZero, IsPosInt ], SUM_FLAGS, function( zero, n ) if Zero( Source( zero ) ) in Range( zero ) then return zero; else Error( "source and range of do not match" ); fi; end ); ############################################################################# ## #M ImagesSource( ) . . . . . . . . . . . . . . . for zero mapping ## InstallMethod( ImagesSource, "for zero mapping", true, [ IsGeneralMapping and IsZero ], SUM_FLAGS, function( zero ) if IsAdditiveMagmaWithZero( Range( zero ) ) then return TrivialSubadditiveMagmaWithZero( Range( zero ) ); else return [ Zero( Range( zero ) ) ]; fi; end ); ############################################################################# ## #M ImageElm( , ) . . . . . . . for zero mapping and element ## InstallMethod( ImageElm, "for zero mapping and object", FamSourceEqFamElm, [ IsGeneralMapping and IsZero, IsObject ], SUM_FLAGS, function( zero, elm ) return Zero( Range( zero ) ); end ); ############################################################################# ## #M ImagesElm( , ) . . . . . . . for zero mapping and element ## InstallMethod( ImagesElm, "for zero mapping and object", FamSourceEqFamElm, [ IsGeneralMapping and IsZero, IsObject ], SUM_FLAGS, function( zero, elm ) return [ Zero( Range( zero ) ) ]; end ); ############################################################################# ## #M ImagesSet( , ) . . . . . for zero mapping and collection ## InstallMethod( ImagesSet, "for zero mapping and collection", CollFamSourceEqFamElms, [ IsGeneralMapping and IsZero, IsCollection ], SUM_FLAGS, function( zero, elms ) return TrivialSubadditiveMagmaWithZero( Range( zero ) ); end ); ############################################################################# ## #M ImagesRepresentative( , ) . for zero mapping and element ## InstallMethod( ImagesRepresentative, "for zero mapping and object", FamSourceEqFamElm, [ IsGeneralMapping and IsZero, IsObject ], SUM_FLAGS, function( zero, elm ) return Zero( Range( zero ) ); end ); ############################################################################# ## #M PreImagesElm( , ) . . . . . for zero mapping and element ## InstallMethod( PreImagesElm, "for zero mapping and object", FamRangeEqFamElm, [ IsGeneralMapping and IsZero, IsObject ], SUM_FLAGS, function( zero, elm ) if elm = Zero( Range( zero ) ) then return Source( zero ); else return []; fi; end ); ############################################################################# ## #M PreImagesSet( , ) . . . . for zero mapping and collection ## InstallMethod( PreImagesSet, "for zero mapping and collection", CollFamRangeEqFamElms, [ IsGeneralMapping and IsZero, IsCollection ], SUM_FLAGS, function( zero, elms ) if Zero( Range( zero ) ) in elms then return Source( zero ); else return []; fi; end ); ############################################################################# ## #M PreImagesRepresentative( , ) ## InstallMethod( PreImagesRepresentative, "for zero mapping and object", FamRangeEqFamElm, [ IsGeneralMapping and IsZero, IsObject ], SUM_FLAGS, function( zero, elm ) if elm = Zero( Range( zero ) ) then return Zero( Source( zero ) ); else return fail; fi; end ); ############################################################################# ## #M ViewObj( ) . . . . . . . . . . . . . . . . . for zero mapping #M PrintObj( ) . . . . . . . . . . . . . . . . . for zero mapping ## InstallMethod( ViewObj, "for zero mapping", true, [ IsGeneralMapping and IsZero ], SUM_FLAGS, function( zero ) Print( "ZeroMapping( " ); View( Source( zero ) ); Print( ", " ); View( Range( zero ) ); Print( " )" ); end ); InstallMethod( PrintObj, "for zero mapping", true, [ IsGeneralMapping and IsZero ], SUM_FLAGS, function( zero ) Print( "ZeroMapping( ", Source( zero ), ", ", Range( zero ), " )" ); end ); ############################################################################# ## #M CompositionMapping2( , ) for gen. mapping and zero mapping ## InstallMethod( CompositionMapping2, "for general mapping and zero mapping", FamSource1EqFamRange2, [ IsGeneralMapping, IsGeneralMapping and IsZero ], SUM_FLAGS, function( map, zero ) return ZeroMapping( Source( map ), Range( zero ) ); end ); ############################################################################# ## #M CompositionMapping2( , ) for zero mapping and gen. mapping ## InstallMethod( CompositionMapping2, "for zero mapping and single-valued gen. mapping that resp. zero", FamSource1EqFamRange2, [ IsGeneralMapping and IsZero, IsGeneralMapping and IsSingleValued and RespectsZero ], SUM_FLAGS, function( zero, map ) return ZeroMapping( Source( zero ), Range( map ) ); end ); ############################################################################# ## #M IsInjective( ) . . . . . . . . . . . . . . . for zero mapping ## InstallMethod( IsInjective, "for zero mapping", true, [ IsGeneralMapping and IsZero ], 0, zero -> Size( Source( zero ) ) = 1 ); ############################################################################# ## #M IsSurjective( ) . . . . . . . . . . . . . . . for zero mapping ## InstallMethod( IsSurjective, "for zero mapping", true, [ IsGeneralMapping and IsZero ], 0, zero -> Size( Range( zero ) ) = 1 ); ############################################################################# ## ## 7. methods for general restricted mappings, ## ############################################################################# ## #M GeneralRestrictedMapping( , , ) ## InstallGlobalFunction(GeneralRestrictedMapping, function( map, s,r ) local res, prop; # Make the general mapping. if IsSPGeneralMapping( map ) then res:= Objectify( TypeOfDefaultGeneralMapping( s,r, IsGeneralRestrictedMappingRep and IsSPGeneralMapping ), rec() ); else res:= Objectify( TypeOfDefaultGeneralMapping( s,r, IsGeneralRestrictedMappingRep and IsNonSPGeneralMapping ), rec() ); fi; # Enter the identifying information. res!.map:= map; SetSource(res,s); SetRange(res,r); for prop in [IsSingleValued, IsTotal, IsInjective, RespectsMultiplication, , RespectsInverses, RespectsAddition, RespectsAdditiveInverses, RespectsScalarMultiplication] do if Tester(prop)(map) and prop(map) then Setter(prop)(res, true); fi; od; # Return the restriction. return res; end ); ############################################################################# ## #M ImagesElm( , ) . . . . . . . . . . . . for restricted mapping ## InstallMethod( ImagesElm, "for a restricted mapping, and an element", FamSourceEqFamElm, [ IsGeneralRestrictedMappingRep, IsObject ], 0, function( res, elm ) local im; im:= ImagesElm( res!.map, elm ); if not ( (HasIsSingleValued(res) and IsSingleValued(res)) or (HasIsSingleValued(res!.map) and IsSingleValued(res!.map)) ) then im:=Intersection(Range(res),im); fi; return im; end ); ############################################################################# ## #M ImagesSet( , ) . . . . . . . . . . . for restricted mapping ## InstallMethod( ImagesSet, "for a restricted mapping, and an collection", CollFamSourceEqFamElms, [ IsGeneralRestrictedMappingRep, IsCollection ], 0, function ( res, elms ) local im; im:= ImagesSet( res!.map, elms ); if not ( (HasIsSingleValued(res) and IsSingleValued(res)) or (HasIsSingleValued(res!.map) and IsSingleValued(res!.map)) ) then im:=Intersection(Range(res),im); fi; return im; end ); ############################################################################# ## #M ImagesRepresentative( , ) . . . . . . for restricted mapping ## InstallMethod( ImagesRepresentative, "for a restricted mapping, and an element", FamSourceEqFamElm, [ IsGeneralRestrictedMappingRep, IsObject ], 0, function( res, elm ) local im; im:= ImagesRepresentative( res!.map, elm ); if im = fail then # 'elm' has no images under 'res!.map', so it has none under 'res'. return fail; elif im in Range(res) then return im; elif HasIsSingleValued(res!.map) and IsSingleValued(res!.map) then return fail; # no other choice else # It may happen that only the chosen representative is not in im im:= ImagesElm( res!.map, elm ); return First(im,i->i in Range(res)); fi; end ); ############################################################################# ## #M PreImagesElm( , ) . . . . . . . . . . for restricted mapping ## InstallMethod( PreImagesElm, "for a restricted mapping, and an element", FamRangeEqFamElm, [ IsGeneralRestrictedMappingRep, IsObject ], 0, function( res, elm ) local preim; preim:= PreImagesElm( res!.map, elm ); if not ( (HasIsInjective(res) and IsInjective(res)) or (HasIsInjective(res!.map) and IsInjective(res!.map)) ) then preim:=Intersection(Source(res),preim); fi; return preim; end ); ############################################################################# ## #M PreImagesSet( , ) . . . . . . . . . . for restricted mapping ## InstallMethod( PreImagesSet, "for a restricted mapping, and an collection", CollFamRangeEqFamElms, [ IsGeneralRestrictedMappingRep, IsCollection ], 0, function( res, elms ) local preim; preim:= PreImagesSet( res!.map, elms ); if not ( (HasIsInjective(res) and IsInjective(res)) or (HasIsInjective(res!.map) and IsInjective(res!.map)) ) then preim:=Intersection(Source(res),preim); fi; return preim; end ); ############################################################################# ## #M PreImagesRepresentative( , ) . . . . . for restricted mapping ## InstallMethod( PreImagesRepresentative, "for a restricted mapping, and an element", FamRangeEqFamElm, [ IsGeneralRestrictedMappingRep, IsObject ], 0, function( res, elm ) local preim, rep; preim:= PreImagesRepresentative( res!.map, elm ); if preim = fail then # 'elm' has no preimages under 'res!.map', so it has none under 'res'. return fail; elif preim in Source(res) then return preim; elif HasIsInjective(res!.map) and IsInjective(res!.map) then return fail; # no other choice else preim:= PreImages( res!.map, elm ); return First(preim,x->x in Source(res)); fi; end ); ############################################################################# ## #M KernelOfAdditiveGeneralMapping( ) . . . . . for restricted mapping ## InstallMethod( KernelOfAdditiveGeneralMapping, "for a restricted mapping that resp. add. and add.inv.", true, [ IsGeneralMapping and IsGeneralRestrictedMappingRep and RespectsAddition and RespectsAdditiveInverses ], 0, function( res ) return Intersection(Source(res),KernelOfAdditiveGeneralMapping( res!.map )); end ); ############################################################################# ## #M CoKernelOfAdditiveGeneralMapping( ) . . . . for restricted mapping ## InstallMethod( CoKernelOfAdditiveGeneralMapping, "for a restricted mapping that resp. add. and add.inv.", true, [ IsGeneralMapping and IsGeneralRestrictedMappingRep and RespectsAddition and RespectsAdditiveInverses ], 0, function( res ) return Intersection(Range(res),CoKernelOfAdditiveGeneralMapping( res!.map )); end ); ############################################################################# ## #M KernelOfMultiplicativeGeneralMapping( ) . . for restricted mapping ## InstallMethod( KernelOfMultiplicativeGeneralMapping, "for a restricted mapping that resp. mult. and inv.", true, [ IsGeneralMapping and IsGeneralRestrictedMappingRep and RespectsMultiplication and RespectsInverses ], 0, function( res ) return Intersection(Source(res), KernelOfMultiplicativeGeneralMapping(res!.map)); end ); ############################################################################# ## #M CoKernelOfMultiplicativeGeneralMapping( ) . for restricted mapping ## InstallMethod( CoKernelOfMultiplicativeGeneralMapping, "for a restricted mapping that resp. mult. and inv.", true, [ IsGeneralMapping and IsGeneralRestrictedMappingRep and RespectsMultiplication and RespectsInverses ], 0, function( res ) return Intersection(Range(res), CoKernelOfMultiplicativeGeneralMapping(res!.map)); end ); ############################################################################# ## #M ViewObj( ) . . . . . . . . . . . . . . . . for restricted mapping #M PrintObj( ) . . . . . . . . . . . . . . . . for restricted mapping ## InstallMethod( ViewObj, "for a restricted mapping", true, [ IsGeneralRestrictedMappingRep ], 100, function( res ) Print( "GeneralRestrictedMapping( " ); View( res!.map ); Print( ", " ); View( Source(res) ); Print( ", " ); View( Range(res) ); Print( " )" ); end ); InstallMethod( PrintObj, "for a restricted mapping", true, [ IsGeneralRestrictedMappingRep ], 100, function( res ) Print( "GeneralRestrictedMapping( ", res!.map, ", ", Source(res), ",", Range(res)," )" ); end ); ############################################################################# ## #M RestrictedMapping(,) ## InstallMethod(RestrictedMapping,"for mapping that is already restricted", CollFamSourceEqFamElms, [IsGeneralMapping and IsGeneralRestrictedMappingRep, IsDomain], SUM_FLAGS, function(hom, U) return GeneralRestrictedMapping (hom!.map, U, Range(hom!.map)); end); ############################################################################# ## #M RestrictedMapping(,) ## InstallMethod(RestrictedMapping,"use GeneralRestrictedMapping", CollFamSourceEqFamElms,[IsGeneralMapping,IsDomain],0, function(hom, U) return GeneralRestrictedMapping (hom, U, Range(hom)); end); ############################################################################# ## #E gap-4r6p5/lib/schursym.gi0000644000175000017500000006062612172557254014121 0ustar billbill############################################################################# ## #W schursym.gi GAP library Lukas Maas #W & Jack Schmidt ## #Y Copyright (C) 2009, The GAP group ## ## This file contains the implementation for Schur covers of symmetric and ## alternating groups on Coxeter or standard generators. ## ############################################################################# ## ## Faithful, irreducible representations of minimal degree of the double ## covers of symmetric groups can be constructed inductively using the ## methods of http://arxiv.org/abs/0911.3794 ## ## The inductive formulation uses a number of helper routines which are ## wrapped inside a function call to keep from declaring a large number ## of (private) global variables. ## Perform( [1], function(x) local S, S1, coeffS2, S2, coeffS3, S3, bmat, spinsteps, SpinDimSym, BasicSpinRepSymPos, BasicSpinRepSymNeg, BasicSpinRepSym, SanityCheckPos, SanityCheckNeg, BasicSpinRepSymTest; ## let 2S+(n) = < t_1, ..., t_(n-1) > subject to the relations ## (t_i)^2 = z for 1 <= i <= n-1, ## z^2 = 1, ## ( t_i*t_(i+1) )^3 = z for 1 <= i <= n-2, ## t_i*t_j = z*t_j*t_i for 1 <= i, j <= n-1 with | i - j | > 1. ## ## The following functions allow the construction of basic spin ## representations of 2S+(n) over fields of any characteristic. ## SpinDimSym ## IN integers n >= 4, p >= 0 ## OUT the degree of a basic spin repr. of 2S(n) over a field of ## characteristic p SpinDimSym:= function( n, p ) local r; r:= n mod 2; if r = 0 then return 2^((n-2)/2); elif p = 0 then return 2^((n-1)/2); elif r = 1 and n mod p = 0 then return 2^((n-3)/2); else return 2^((n-1)/2); fi; end; ## SanityCheckPos ## IN A record containing the matrices in T, the degree of the symmetric ## group n, and the characteristic f the field p ## OUT true if the matrices in T are the right size, over the right field, and ## satisfy the presentation for 2S(n) given above. Also checks the ## components Sym and Alt if present. SanityCheckPos := function( input ) local i, j; if input.n <> Length( input.T ) + 1 then Print("#I SanityCheckPos: Wrong degree: ",input.n," vs. ",Length(input.T)+1,"\n"); return false; fi; if input.p <> Characteristic( input.T[1] ) then Print("#I SanityCheckPos: Wrong characteristic: ",input.p," vs. ",Characteristic(input.T[1]),"\n"); return false; fi; if SpinDimSym( input.n, input.p ) <> Length( input.T[1] ) then Print( "#I SanityCheckPos: Wrong degree: ",SpinDimSym( input.n, input.p )," vs. ",Length( input.T[1] ),"\n" ); return false; fi; if not ForAll( input.T, mat -> Size(mat) = Size(mat[1]) and Size(mat)=Size(input.T[1])) then Print("#I SanityCheckPos: Matrices not all same size\n"); return false; fi; for i in [ 1 .. input.n-1 ] do if not IsOne(-input.T[i]^2) then Print( "#I SanityCheckPos: Wrong order for T[",i,"]\n"); return false; fi; od; for i in [ 1 .. input.n-2 ] do if not IsOne( -( input.T[i]*input.T[i+1] )^3 ) then Print( "#I SanityCheckPos: Braid relation failed at position ", i, "\n" ); return false; fi; for j in [ i+2 .. input.n-1 ] do if not IsOne( - ( input.T[i]*input.T[j] )^2 ) then Print( "#I SanityCheckPos: Commutator relation failed for ( ", i, ", ", j ," )\n" ); return false; fi; od; od; if IsBound( input.Sym ) then if not input.Sym[1] = Product( Reversed( input.T ) ) then Print( "SanityCheckPos: Wrong Sym[1]\n" ); return false; fi; if not input.Sym[2] = input.T[1] then Print( "SanityCheckPos: Wrong Sym[2]\n" ); return false; fi; fi; if IsBound( input.Alt ) then if not input.Alt[1] = Product( Reversed( input.T{[1..2*Int((input.n-1)/2)]} ) ) then Print( "SanityCheckPos: Wrong Alt[1]\n" ); return false; fi; if not input.Alt[2] = input.T[input.n-1]*input.T[input.n-2] then Print( "SanityCheckPos: Wrong Alt[2]\n" ); return false; fi; fi; return true; end; ## SanityCheckNeg ## IN A record containing the matrices in T, the degree of the symmetric ## group n, and the characteristic f the field p ## OUT true if the matrices in T are the right size, over the right field, and ## satisfy the presentation for 2S-(n) given above. Also checks the ## components Sym and Alt if present. SanityCheckNeg := function( S, p ) local d, deg, z, t, i, j; d:= Length( S ); deg:= Length( S[1] ); if SpinDimSym( d+1, p ) <> deg then Print( "#I SanityCheckNeg: wrong degree!\n" ); return false; fi; #Print( "#I SanityCheckNeg: degree: ", deg , "\n" ); for i in [ 1 .. d ] do if not IsOne( S[i]^2 ) then Print( "#I SanityCheckNeg: order failed at position ", i, "\n" ); return false; fi; od; for i in [ 1 .. d-1 ] do if not IsOne( ( S[i]*S[i+1] )^3 ) then Print( "#I SanityCheckNeg: braid relation failed at position ", i, "\n" ); return false; fi; for j in [ i+2 .. d ] do if S[i]*S[j] <> -S[j]*S[i] then Print( "#I SanityCheckNeg: commuting relation failed for ( ", i, ", ", j ," )\n" ); return false; fi; od; od; #Print( "#I SanityCheckNeg: all relations satisfied\n" ); return true; end; ## bmat -- blck matrix maker ## IN the blocks a,b,c,d of the matrix [[a,b],[c,d]] ## OUT a normal matrix with the same entries as the corresponding block ## matrix. bmat := function(a,b,c,d) local mat; mat := DirectSumMat( a, d ); if b <> 0 then mat{[1..Length(a)]}{[1+Length(a[1])..Length(mat[1])]} := b; fi; if c <> 0 then mat{[1+Length(a)..Length(mat)]}{[1..Length(a[1])]} := c; fi; return mat; end; ## construction S of Definition 4 / Lemma 5 ## IN an input record with n,p,T and optionally Sym and/or Alt, ## where n,p satisfy the hypothesis of Def 4 / Lemma 5 ## OUT the same, but for 2S(n+1) S:= function( old ) local new, I, z, i; #Print("S from ",old.n," to ",new.n,"\n"); new := rec( n := old.n+1, p:=old.p, T:=[] ); for i in [ 1 .. new.n-3 ] do new.T[i] := DirectSumMat( old.T[i], -old.T[i] ); od; I := old.T[1]^0; z := 0*old.T[1]; new.T[new.n-2] := bmat( old.T[new.n-2], -I, 0, -old.T[new.n-2] ); new.T[new.n-1] := bmat( z, I, -I, z ); if IsBound( old.Sym ) then new.Sym := []; if new.n < 5 then new.Sym[1] := Product(Reversed(new.T)); else new.Sym[1] := bmat( 0*old.Sym[1], (-1)^new.n*old.Sym[1], -old.Sym[1], (-1)^new.n*old.T[new.n-2]*old.Sym[1] ); fi; new.Sym[2] := new.T[1]; fi; if IsBound( old.Alt ) then new.Alt := []; if IsOddInt(new.n) then new.Alt[1] := new.Sym[1]; else new.Alt[1] := -new.T[new.n-1]*new.Sym[1]; fi; new.Alt[2] := new.T[new.n-1]*new.T[new.n-2]; fi; Assert( 1, SanityCheckPos( new ) ); return new; end; ## construction S1 of Lemma 7 ## IN an input record with n,p,T and optionally Sym and/or Alt, ## where n,p satisfy the hypothesis of Lemma 7 ## OUT the same, but for 2S(n+1) S1:= function( old ) local new, J; #Print("S1 from ",old.n," to ",new.n,"\n"); new := rec( n := old.n + 1, p := old.p, T := ShallowCopy( old.T ) ); J := Sum( [1..new.n-2], k -> k*old.T[k] ); if new.p = 2 and 2 = new.n mod 4 then new.T[new.n-1] := J + J^0; else new.T[new.n-1] := J; fi; if IsBound( old.Sym ) then new.Sym := []; new.Sym[1] := new.T[new.n-1]*old.Sym[1]; new.Sym[2] := old.Sym[2]; fi; if IsBound( old.Alt ) then new.Alt := []; if IsOddInt(new.n) then new.Alt[1] := new.Sym[1]; else new.Alt[1] := old.Alt[1]; fi; new.Alt[2] := new.T[new.n-1]*new.T[new.n-2]; fi; Assert( 1, SanityCheckPos( new ) ); return new; end; ## return alpha ( = alpha^+ ) and beta as in Lemma 10 ## here n(n-1)(n-2) must not be divisible by p coeffS2:= function( n, p ) local one, a, b, c, alpha; if p = 0 then c:= n-2; alpha:= (n-1)^-1*( 1 + Sqrt( -n*c^-1 ) ); else one:= Z( p )^0; c:= (n-2) mod p; a:= -n*c^-1 mod p; a:= LogFFE( a*one, Z(p^2) ) / 2; b:= (n-1)^-1 mod p; alpha:= b*(one+Z(p^2)^a); fi; return rec( alpha:= alpha, beta:= alpha*c ); end; ## construction S2 of Lemma 10 ## IN an input record with n,p,T and optionally Sym and/or Alt, ## where n,p satisfy the hypothesis of Lemma 10 ## OUT the same, but for 2S(n+2) S2:= function( old ) local mid, new, coeffs, a, b, J, I; #Print("S2 from ",old.n," to ",old.n+2," via S\n"); mid := S( old ); new := rec( n := mid.n + 1, p := mid.p, T := ShallowCopy( mid.T ) ); coeffs:= coeffS2( new.n, new.p ); a := coeffs.alpha; b := coeffs.beta; J := Sum( [ 1 .. new.n-3 ], k-> k*old.T[k] ); I := old.T[1]^0; new.T[new.n-1] := bmat( -a*J, (b-1)*I, b*I, a*J ); if IsBound( old.Sym ) then new.Sym := []; new.Sym[1] := new.T[new.n-1]*mid.Sym[1]; new.Sym[2] := mid.Sym[2]; fi; if IsBound( old.Alt ) then new.Alt := []; if IsOddInt( new.n ) then new.Alt[1] := new.Sym[1]; else new.Alt[1] := mid.Sym[1]; fi; new.Alt[2] := new.T[new.n-1]*new.T[new.n-2]; fi; Assert( 1, SanityCheckPos( new ) ); return new; end; ## coeffS3 - a needed coefficient ## IN A prime p, or p = 0 ## OUT Sqrt(-1) in GF(p^2) or CF(4) coeffS3:= function( p ) if 0 = p then return E(4); elif 2 = p then return Z(2); elif 1 = p mod 4 then return Z(p)^((p-1)/4); else return Z(p^2)^((p^2-1)/4); fi; end; ## construction S3 of Lemma 11 ## IN an input record with n,p,T and optionally Sym and/or Alt, ## where n,p satisfy the hypothesis of Lemma 11 ## OUT the same, but for 2S(n+4) S3:= function( old ) local mid, new, a, J0, I, J; #Print("S3 from ",old.n," to ",old.n+4," via S,S1,S\n"); mid := S( S1( S( old ) ) ); # now at n-1 new := rec( n := mid.n + 1, p := mid.p, T := ShallowCopy( mid.T ) ); a := coeffS3( old.p ); J0:= Sum( [1..new.n-5], k-> k*old.T[k] ); I := old.T[1]^0; J := a*bmat(J0, 2*I, 2*I, -J0); new.T[new.n-1] := bmat( J, -J^0, 0, -J ); if IsBound( old.Sym ) then new.Sym := []; new.Sym[1] := new.T[new.n-1]*mid.Sym[1]; new.Sym[2] := mid.Sym[2]; fi; if IsBound( old.Alt ) then new.Alt := []; if IsOddInt( new.n ) then new.Alt[1] := new.Sym[1]; else new.Alt[1] := mid.Alt[1]; fi; new.Alt[2] := new.T[new.n-1]*new.T[new.n-2]; fi; Assert( 1, SanityCheckPos( new ) ); return new; end; ## spinsteps ## IN the degree n and characteristic p > 2 ## OUT a list which describes the steps of construction spinsteps:= function( n, p ) local d, k, kmodp, parity; d:= []; k:= n; while k > 4 do kmodp:= k mod p; parity:= k mod 2; if kmodp > 2 then if parity = 1 then Add( d, 0 ); k:= k-1; else Add( d, 2 ); k:= k-2; fi; elif kmodp = 0 then Add( d, 1 ); k:= k-1; elif kmodp = 1 then Add( d, 0 ); k:= k-1; else if parity = 1 then Add( d, 0 ); k:= k-1; else Add( d, 3 ); k:= k-4; fi; fi; od; return Reversed( d ); end; ## construction of a basic spin rep. of 2S+(n) in characteristic p BasicSpinRepSymPos := function( n, p ) local z, M, k, i, kmodp, steps; if not IsPosInt(n) or not IsInt(p) or n < 4 or not ( p = 0 or IsPrime( p ) ) then return fail; fi; ## get the spin reps for 2S(4) z := coeffS3(p); if p = 0 then M:= rec( n := 2, p := 0, T := [ [ [ z ] ] ], Sym := [~.T[1]], Alt :=[] ); M:= S2( M ); elif p = 2 then M:= rec( n := 2, p := 2, T := [ [ [ z ] ] ], Sym := [~.T[1]], Alt :=[] ); M:= S1( S( M ) ); elif p = 3 then M:= rec( n := 3, p := 3, T := [ [ [ z ] ], [ [ z ] ] ], Sym := [ [ [ z^2 ] ], ~.T[1] ], Alt:=[ ~.Sym[1] ] ); M:= S( M ); else # p>3 M:= rec( n := 2, p := p, T := [ [ [ z ] ] ], Sym := [ ~.T[1]], Alt:=[] ); M:= S2( M ); fi; if n = 4 then return M; fi; if ValueOption("Sym") <> true and ValueOption("Alt")<>true then Unbind(M.Sym); fi; if ValueOption("Alt") <> true then Unbind(M.Alt); fi; if p = 0 then if n mod 2 = 0 then k:= (n-4)/2; for i in [ 1 .. k ] do M:= S2( M ); od; else k:= (n-5)/2; for i in [ 1 .. k ] do M:= S2( M ); od; # now M is a b.s.r. of 2S( n-1 ) M:= S( M ); fi; elif p = 2 then k:= 5; while k <= n do if k mod 2 = 1 then M:= S( M ); else M:= S1( M ); fi; k:= k+1; od; else # p >= 3 steps:= spinsteps( n, p ); for k in steps do if k = 0 then M := S( M ); elif k = 1 then M := S1( M ); elif k = 2 then M := S2( M ); else M := S3( M ); fi; od; fi; Assert( 1, SanityCheckPos( M ) ); return M; end; BasicSpinRepSymNeg := function( n, p ) local T, S; T := BasicSpinRepSymPos( n, p ); S := rec( n := T.n, p := T.p, T := coeffS3( p ) * T.T ); if IsBound( T.Sym ) then S.Sym := [ coeffS3( p )^(n-1) * T.Sym[1], S.T[1] ]; fi; if IsBound( T.Alt ) then S.Alt := [ (-1)^Int((n-1)/2)*T.Alt[1], -T.Alt[2] ]; fi; Assert( 1, SanityCheckNeg( S.T, p ) ); return S; end; BasicSpinRepSym := function( n, p, sign ) if sign in [ 1, '+', "+", 4 ] then return BasicSpinRepSymPos(n,p); elif sign in [ -1, '-', "-", 2 ] then return BasicSpinRepSymNeg(n,p); else Error(" should be +1 or -1"); fi; end; ########################################################################## ## ## Method Installations ## InstallGlobalFunction( BasicSpinRepresentationOfSymmetricGroup, function(arg) local n, p, s, mats; if Length(arg) < 1 then Error("Usage: BasicSpinRepresentationOfSymmetricGroup( ,

, );"); fi; n := arg[1]; if Length(arg) < 2 then p := 3; else p := arg[2]; fi; if Length(arg) < 3 then s := 1; else s := arg[3]; fi; mats := BasicSpinRepSym(n,p,s).T; if p = 2 then return List( mats, mat -> ImmutableMatrix( GF(p), mat ) ); elif p > 0 then return List( mats, mat -> ImmutableMatrix( GF(p^2), mat ) ); fi; return mats; end ); InstallMethod( SchurCoverOfSymmetricGroup, "Use Lukas Maas's inductive construction of a basic spin rep", [ IsPosInt, IsInt, IsInt ], function( n, p, s ) local mats, grp; if p = 2 then return fail; fi; # need a faithful rep if n < 4 then TryNextMethod(); fi; mats := BasicSpinRepSym(n,p,s:Sym); mats.Z := -mats.T[1]^0; grp := Group( mats.Sym ); Assert( 3, Size( grp ) = 2*Factorial( n ) ); SetSize( grp, 2*Factorial(n) ); Assert( 3, Center( grp ) = Subgroup( grp, [ mats.Z ] ) ); SetCenter( grp, SubgroupNC( grp, [ mats.Z ] ) ); Assert( 3, IsAbelian( Center( grp ) ) ); SetIsAbelian( Center( grp ), true ); Assert( 3, Size( Center( grp ) ) = 2 ); SetSize( Center( grp ), 2 ); Assert( 3, AbelianInvariants( Center( grp ) ) = [ 2 ] ); SetAbelianInvariants( Center( grp ), [ 2 ] ); return grp; end ); InstallMethod( DoubleCoverOfAlternatingGroup, "Use Lukas Maas's inductive construction of a basic spin rep", [ IsPosInt, IsInt ], function( n, p ) local mats, grp; if p = 2 then return fail; fi; # need a faithful rep mats := BasicSpinRepSym(n,p,1:Alt); mats.Z := -mats.T[1]^0; grp := Group( mats.Alt ); Assert( 3, Size( grp ) = Factorial( n ) ); SetSize( grp, Factorial(n) ); Assert( 3, Center( grp ) = Subgroup( grp, [ mats.Z ] ) ); SetCenter( grp, SubgroupNC( grp, [ mats.Z ] ) ); Assert( 3, IsAbelian( Center( grp ) ) ); SetIsAbelian( Center( grp ), true ); Assert( 3, Size( Center( grp ) ) = 2 ); SetSize( Center( grp ), 2 ); Assert( 3, AbelianInvariants( Center( grp ) ) = [ 2 ] ); SetAbelianInvariants( Center( grp ), [ 2 ] ); if n >= 5 then Assert( 3, IsPerfectGroup( grp ) ); SetIsPerfectGroup( grp, true ); fi; return grp; end ); BasicSpinRepSymTest := function(n,p) local mats, smtx, grp, sign; for sign in [1,-1] do mats := BasicSpinRepSym(n,p,sign).T; if p > 0 then smtx := GModuleByMats( mats, Field(Flat(mats)) ); Assert( 0, SMTX.IsAbsolutelyIrreducible( smtx ) ); fi; grp := Group( mats.Sym ); if n > 4 or p <> 2 then Assert( 0, Size( grp ) = 2*Factorial(n)/GcdInt(p,2) ); Assert( 0, Size( Center( grp ) ) = 2/GcdInt(p,2) ); Assert( 0, Size( DerivedSubgroup( grp ) ) = Factorial(n)/GcdInt(p,2) ); Assert( 0, IsSubgroup( DerivedSubgroup( grp ), Center( grp ) ) ); Assert( 0, AbelianInvariants( grp ) = [ 2 ] ); if n > 4 then Assert( 0, IsSimpleGroup( DerivedSubgroup( grp ) / Center( grp ) ) ); fi; fi; grp := Group( mats.Alt ); if n > 4 or p <> 2 then Assert( 0, Size( grp ) = Factorial(n)/GcdInt(p,2) ); Assert( 0, Size( Center( grp ) ) = 2/GcdInt(p,2) ); Assert( 0, Size( DerivedSubgroup( grp ) ) = Factorial(n)/GcdInt(p,2) ); if n > 4 then Assert( 0, IsSimpleGroup( DerivedSubgroup( grp ) / Center( grp ) ) ); fi; fi; od; return true; end; end ); ############################################################################# ## ## Other method installations that do not require direct access to the ## inductive procedure. ## ############################################################################# ## ## Convenience routines that supply default values. ## InstallOtherMethod( SchurCoverOfSymmetricGroup, "Sign=+1 by default", [ IsPosInt, IsInt ], function( n, p ) return SchurCoverOfSymmetricGroup( n, p, 1 ); end ); InstallOtherMethod( SchurCoverOfSymmetricGroup, "P=3, Sign=+1 by default", [ IsPosInt ], function( n ) return SchurCoverOfSymmetricGroup( n, 3, 1 ); end ); InstallOtherMethod( DoubleCoverOfAlternatingGroup, "P=3 by default", [ IsPosInt ], function( n ) return DoubleCoverOfAlternatingGroup( n, 3 ); end ); ############################################################################# ## ## Quickly setup the standard epimorphisms ## InstallMethod( EpimorphismSchurCover, "Use library copy of double cover", [ IsNaturalSymmetricGroup ], function( sym ) local dom, deg, cox, chr, grp, hom, img; dom := MovedPoints( sym ); deg := Size( dom ); if deg < 4 then return IdentityMapping( sym ); fi; cox := List( [1..deg-1], i -> (dom[i],dom[i+1]) ); Assert( 1, ForAll( cox, gen -> gen in sym ) ); #chr := First( [3,5,7], p -> 0 = deg mod p ); #if chr = fail then chr := 3; fi; chr := 3; # appears to be the best choice regardless of deg grp := SchurCoverOfSymmetricGroup( deg, chr, 1 ); img := [ Product( Reversed( cox ) ), cox[1] ]; if AssertionLevel() > 2 then hom := GroupHomomorphismByImages( grp, sym, GeneratorsOfGroup( grp ), img ); Assert( 3, KernelOfMultiplicativeGeneralMapping( hom ) = Center( grp ) ); else dom := RUN_IN_GGMBI; RUN_IN_GGMBI := true; hom := GroupHomomorphismByImagesNC( grp, sym, GeneratorsOfGroup( grp ), img ); RUN_IN_GGMBI := dom; SetKernelOfMultiplicativeGeneralMapping( hom, Center( grp ) ); fi; return hom; end ); InstallMethod( EpimorphismSchurCover, "Use library copy of double cover", [ IsNaturalAlternatingGroup ], function( alt ) local dom, deg, cox, chr, grp, hom, img; dom := MovedPoints( alt ); deg := Size( dom ); if deg < 4 then return IdentityMapping( alt ); fi; if deg in [6,7] then TryNextMethod(); fi; cox := List( [1..deg-1], i -> (dom[i],dom[i+1]) ); Assert( 1, ForAll( [1..deg-2], i -> cox[i]*cox[i+1] in alt ) ); chr := 3; grp := DoubleCoverOfAlternatingGroup( deg, chr ); img := [ Product( Reversed( cox{[1..2*Int((deg-1)/2)]} ) ), cox[deg-1]*cox[deg-2] ]; if AssertionLevel() > 2 then hom := GroupHomomorphismByImages( grp, alt, GeneratorsOfGroup( grp ), img ); Assert( 3, KernelOfMultiplicativeGeneralMapping( hom ) = Center( grp ) ); else dom := RUN_IN_GGMBI; RUN_IN_GGMBI := true; hom := GroupHomomorphismByImagesNC( grp, alt, GeneratorsOfGroup( grp ), img ); RUN_IN_GGMBI := dom; SetKernelOfMultiplicativeGeneralMapping( hom, Center( grp ) ); fi; return hom; end ); ########################################################################### ## ## Special cases just handled explicitly ## InstallMethod( SchurCoverOfSymmetricGroup, "Use explicit matrix reps for degrees 1,2,3", [ IsPosInt, IsInt, IsInt ], 1, function( n, p, ignored ) local R; if p = 0 then R := Integers; else R:=GF(p); fi; if n = 1 then return TrivialSubgroup( GL(1,R) ); elif n = 2 and p<>2 then return Group( -One(GL(1,R)) ); elif n = 3 and p<>3 then return Group( [ [[0,1],[-1,-1]], [[0,1],[1,0]] ]*One(R) ); elif n = 2 and p = 2 then return Group( [[1,1],[0,1]]*One(R) ); # indecomposable, not irreducible elif n = 3 and p = 3 then return Group( [ [[0,1],[-1,-1]], [[0,1],[1,0]] ]*One(R) ); # indecomposable, not irreducible else TryNextMethod(); fi; end ); InstallMethod( EpimorphismSchurCover, "Use copy of AtlasRep's 6-fold cover", [ IsNaturalAlternatingGroup ], 1, function( alt ) local dom, deg, cox, img, z, gen, grp, cen, hom; dom := MovedPoints( alt ); deg := Size( dom ); if deg = 6 then z := Z(25); gen := [ [ [ z^ 0, z^16, z^22, z^ 8, z^ 8, z^13 ], [ z^ 0, z^22, z^ 0, z^ 7, z^11, z^16 ], [ z^11, z^ 7, z^ 0, z^ 6, z^10, z^ 7 ], [ z^ 2, z^ 0, z^ 3, z* 0, z^18, z^21 ], [ z^21, z^ 9, z^ 2, z^12, z^ 5, z^20 ], [ z , z^ 5, z^ 2, z^ 4, z^16, z^ 6 ] ], [ [ z^18, z^23, z^ 0, z^ 2, z^23, z^17 ], [ z^ 2, z^10, z^17, z* 0, z^ 0, z^18 ], [ z^17, z^ 4, z^12, z^23, z^22, z^ 4 ], [ z , z^12, z , z^18, z^11, z^ 2 ], [ z^21, z^ 4, z^15, z^ 8, z^19, z* 0 ], [ z^ 8, z^ 6, z^14, z^18, z^18, z^ 9 ] ] ]; grp := Group( gen ); Assert( 2, Size( grp ) = 6*5*4*3*2/2 * 6 ); SetSize( grp, 6*5*4*3*2/2 * 6 ); cen := SubgroupNC( grp, [ DiagonalMat( [ z^4, z^4, z^4, z^4, z^4, z^4 ] ) ] ); Assert( 1, Size( cen ) = 6 ); SetSize( cen, 6 ); Assert( 1, IsAbelian( cen ) ); SetIsAbelian( cen, true ); Assert( 1, AbelianInvariants( cen ) = [ 2, 3 ] ); SetAbelianInvariants( cen, [ 2, 3 ] ); Assert( 2, Center(grp) = cen ); SetCenter( grp, cen ); elif deg = 7 then z := Z(25); gen := [ [ [ z* 0, z^14, z^10, z^19, z^11, z^ 6 ], [ z^19, z^12, z^ 9, z , z^ 0, z ], [ z^ 8, z^18, z^10, z^ 2, z^20, z^15 ], [ z^ 2, z^ 0, z^23, z^ 0, z^12, z^ 5 ], [ z^20, z^ 8, z^20, z^23, z^16, z^ 0 ], [ z^10, z^ 2, z^13, z^ 5, z^20, z^11 ] ], [ [ z^ 7, z^ 6, z^10, z^23, z^ 6, z^ 0 ], [ z^14, z^19, z^ 9, z^22, z^ 2, z^ 0 ], [ z^10, z^16, z^17, z^15, z^17, z^14 ], [ z^ 0, z^17, z^10, z^13, z , z^ 6 ], [ z^13, z^ 9, z^ 2, z^12, z^ 8, z^ 7 ], [ z^ 8, z^ 8, z^16, z^23, z^ 4, z^19 ] ] ]; grp := Group( gen ); Assert( 2, Size( grp ) = 7*6*5*4*3*2/2 * 6 ); SetSize( grp, 7*6*5*4*3*2/2 * 6 ); cen := SubgroupNC( grp, [ DiagonalMat( [ z^4, z^4, z^4, z^4, z^4, z^4 ] ) ] ); Assert( 1, Size( cen ) = 6 ); SetSize( cen, 6 ); Assert( 1, IsAbelian( cen ) ); SetIsAbelian( cen, true ); Assert( 1, AbelianInvariants( cen ) = [ 2, 3 ] ); SetAbelianInvariants( cen, [ 2, 3 ] ); Assert( 2, Center(grp) = cen ); SetCenter( grp, cen ); else TryNextMethod(); fi; cox := List( [1..deg-1], i -> (dom[i],dom[i+1]) ); img := [ Product( Reversed( cox{[1..2*Int((deg-1)/2)]} ) ), cox[deg-1]*cox[deg-2] ]; Assert( 1, ForAll( img, i -> i in alt ) ); if AssertionLevel() > 1 then hom := GroupHomomorphismByImages( grp, alt, gen, img ); Assert( 2, KernelOfMultiplicativeGeneralMapping( hom ) = Center( grp ) ); else hom := GroupHomomorphismByImagesNC( grp, alt, gen, img ); SetKernelOfMultiplicativeGeneralMapping( hom, Center( grp ) ); fi; return hom; end ); ############################################################################# ## #E gap-4r6p5/lib/fastendo.gd0000644000175000017500000000226712172557252014035 0ustar billbill############################################################################# ## #W fastendo.gd GAP library Andrew Solomon ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## Contains the declarations for the transformation representation ## of endomorphisms. Computing with EndoGeneralMappings as transformations ## makes the arithmetic much faster. ## ############################################################################ ## #A TransformationRepresentation() ## ## This is the transformation representation of the endo general mapping ## . Note, it is still a general mapping, not a transformation, ## however, composition, equality and \< are all *much* faster. ## ## Finding the TransformationRepresentation requires a call to ## EnumeratorSorted for the Source of the mapping (the set on which ## it acts). This could be very expensive. ## DeclareAttribute("TransformationRepresentation", IsEndoMapping); ############################################################################ ## #E gap-4r6p5/lib/clashom.gd0000644000175000017500000000430012172557252013646 0ustar billbill############################################################################# ## #W clashom.gd GAP library Alexander Hulpke ## ## #Y (C) 1999 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains functions that compute the conjugacy classes of a ## finite group by homomorphic images. ## Literature: A.H: Conjugacy classes in finite permutation groups via ## homomorphic images, MathComp, to appear. ## ############################################################################# ## #V InfoHomClass ## ## the info class for the conjugacy class computation via homomorphic ## images. DeclareInfoClass("InfoHomClass"); ############################################################################# ## #F ConjugacyClassesSubwreath(,,,,,,,,) ## ## This function computes the classes of a subwreath groiup. The interface ## is quite technical because the subwreath decomposition is passed already ## with it: is the factor group, the normal subgroup in it (direct ## product of the groups isomorphic ). is one of these and ## the action of on the first component, the components are ## given in , and are embeddings and projectios for the ## direct product. DeclareGlobalFunction("ConjugacyClassesSubwreath"); ############################################################################# ## #F ConjugacyClassesFittingFreeGroup() ## ## computes the classes of a group which has no solvable normal ## subgroups. It returns a list whose entries are of the form ## [,]. DeclareGlobalFunction("ConjugacyClassesFittingFreeGroup"); ############################################################################# ## #F ConjugacyClassesViaRadical() ## ## computes the classes of a group by lifting the classes of G/Rad(G) ## using affine actions. It returns a list of conjugacy classes. DeclareGlobalFunction("ConjugacyClassesViaRadical"); ############################################################################# ## #E clashom.gd . . . . . . . . . . . . . . . . . . . . . . . . . . ends here gap-4r6p5/lib/lbutil.g0000644000175000017500000000775012172557252013363 0ustar billbill############################################################################ ## #W lbutil.g GAP Library Frank Lübeck ## ## #Y Copyright (C) 2004 The GAP Group ## ## This file contain a few simple tools for translating text files between ## different line break conventions for Unix, DOS/Windows, MacOS. ## ############################################################################ ## #F DosUnixLinebreaks( [, ] ) . . . . . . translate #F text file with Unix line breaks to a file with DOS/Windows line breaks ## #F UnixDosLinebreaks( [, ] ) . . . . . . translate #F text file with DOS/Windows line breaks to a file with Unix line breaks ## #F MacUnixLinebreaks( [, ] ) . . . . . . translate #F text file with Unix line breaks to a file with MacOS line breaks ## #F UnixMacLinebreaks( [, ] ) . . . . . . translate #F text file with MacOS line breaks to a file with Unix line breaks ## ## must be the name of an existing text file and the ## name of a file to which the result is (over-)written. ## If not given is the same as , so itself is ## overwritten by the result. ## ## DosUnix: ## This function first substitutes all substrings "\r\n" in infile to ## "\n" and then all "\n" to "\r\n". (So, existing "\r\n" are left alone ## and "\n" without a previous "\r" are changed to "\r\n".) The result is ## written to . ## ## UnixDos: ## This translates "\r\n" substrings to "\n". ## ## MacUnix: ## This translates "\n" to "\r". ## ## UnixMac: ## This translates "\r" to "\n". ## BindGlobal("DosUnixLinebreaks", function(arg) local infile, outfile, s; infile := arg[1]; if Length(arg) > 1 then outfile := arg[2]; else outfile := infile; fi; if not (IsString(infile) and IsString(outfile)) then Error("arguments must be strings describing the names of the input \n", "and output files."); fi; s := StringFile(infile); if s = fail then Error("cannot read input file."); fi; s := ReplacedString(s, "\r\n", "\n"); s := ReplacedString(s, "\n", "\r\n"); s := FileString(outfile, s); if s = fail then Error("cannot write output file."); fi; end); BindGlobal("UnixDosLinebreaks", function(arg) local infile, outfile, s; infile := arg[1]; if Length(arg) > 1 then outfile := arg[2]; else outfile := infile; fi; if not (IsString(infile) and IsString(outfile)) then Error("arguments must be strings describing the names of the input \n", "and output files."); fi; s := StringFile(infile); if s = fail then Error("cannot read input file."); fi; s := ReplacedString(s, "\r\n", "\n"); s := FileString(outfile, s); if s = fail then Error("cannot write output file."); fi; end); BindGlobal("UnixMacLinebreaks", function(arg) local infile, outfile, s; infile := arg[1]; if Length(arg) > 1 then outfile := arg[2]; else outfile := infile; fi; if not (IsString(infile) and IsString(outfile)) then Error("arguments must be strings describing the names of the input \n", "and output files."); fi; s := StringFile(infile); if s = fail then Error("cannot read input file."); fi; s := ReplacedString(s, "\r", "\n"); s := FileString(outfile, s); if s = fail then Error("cannot write output file."); fi; end); BindGlobal("MacUnixLinebreaks", function(arg) local infile, outfile, s; infile := arg[1]; if Length(arg) > 1 then outfile := arg[2]; else outfile := infile; fi; if not (IsString(infile) and IsString(outfile)) then Error("arguments must be strings describing the names of the input \n", "and output files."); fi; s := StringFile(infile); if s = fail then Error("cannot read input file."); fi; s := ReplacedString(s, "\n", "\r"); s := FileString(outfile, s); if s = fail then Error("cannot write output file."); fi; end); gap-4r6p5/lib/oldmatint.gi0000644000175000017500000011546412172557252014236 0ustar billbill############################################################################# ## #A oldmatint.gi GAP library Robert Wainwright ## ## #Y Copyright (C) 1997, St Andrews #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file is preserved to keep the old routines available. It is not ## read in by default. ## ## This file contains old methods for functions that compute Hermite and ## Smith normal forms of integer matrices, with or without the HNF/SNF ## expressed as the linear combination of the input. The code is based ## on (and in parts identical to) code written by Bohdan Majewski. ## ############################################################################## ## #F MatInt_BestRow( , , ) ......... an auxiliary function for NormHnf ## BindGlobal("MatInt_BestRow", function( A, i, h ) local j, # row index; goes between i and the last row A.m r, # index of the row with the minimum norm so far cn, # (c)urrent (n)orm; norm of the current vector mn; # (m)inimum (n)orm; minimum so far, naturally r := 0; mn := 0; for j in [i .. A.m] do if A.T[j][h] <> 0 then if r = 0 then mn := A.T[j]*A.T[j]; r := j; else cn := A.T[j]*A.T[j]; if cn < mn then mn := cn; r := j; fi; fi; fi; od; Info(InfoMatInt,4,"MatInt_BestRow returning ",r); return r; end); ############################################################################## ## #F NormHnf( [, ]) ... the Hermite NF of the first parameter ## BindGlobal("NormHnf", function( arg ) local A, # a record (number or rows, no of columns, int matrix) h, # head (first nonzero) of the pivot row i, j, k, # local indexes r, t, q,qq, # auxiliary variables enf_flag, # set to true if the user wishes Echelon form only frac; # off-diagonal reduction coefficient if not IsMatrix(arg[1]) then PrintTo("*errout*", "use: NormHnf( [, ]);\n"); return fail; fi; frac:=1; enf_flag := false; if Length(arg) = 2 then if arg[2] = true then enf_flag := true; elif IsRat(arg[2]) then frac:=arg[2]; fi; fi; A := rec( T :=arg[1], m := Length(arg[1]), n := Length(arg[1][1]) ); i := 1; while i <= A.m do Info(InfoMatInt,2,"NormHnf - i:= ",i); h := A.n; j := i; while j <= A.m and h > i do t := PositionNot(A.T[j],0); if t < h then h := t; fi; j := j + 1; od; k := MatInt_BestRow(A, i, h); repeat if k <> i then # swap row i and k t := A.T[i]; A.T[i] := A.T[k]; A.T[k] := t; fi; t := A.T[i][h]; # the pivot for j in [i+1 .. A.m] do q := RoundCycDown(A.T[j][h]/t); if q <> 0 then AddRowVector(A.T[j],A.T[i],-q); fi; od; # place empty rows of A at the end j := i + 1; while j <= A.m do if PositionNot(A.T[j],0) <= A.n then j := j + 1; else t := A.T[j]; # swap out an empty row A.T[j] := A.T[A.m]; A.T[A.m] := t; A.m := A.m - 1; fi; od; k := MatInt_BestRow(A, i + 1, h); until k = 0; i := i + 1; od; for i in [1 .. A.m] do j := PositionNot(A.T[i],0); if A.T[i][j] < 0 then A.T[i] := -A.T[i]; fi; od; if not enf_flag then for i in [A.m, A.m-1 .. 1] do for j in [i+1 .. A.m] do h := PositionNot(A.T[j],0); t := A.T[i][h]; r := A.T[j][h]; qq:=t mod r; q := (t - qq)/r; if qq>frac*r then q:=q+1; fi; AddRowVector(A.T[i],A.T[j],-q); od; od; fi; return A.T; #return same size as orig. If only want non-zero rows return A.T{[1 .. A.m]}; end); ############################################################################## ## #F CaCHnf( ) .................. the Hermite NF of the first parameter ## BindGlobal("CaCHnf",function( H ) local h, i, j, k, l, m, n, q, t, v, A; A:=MutableCopyMat(H); m := Length(A); n := Length(A[1]); # skip initial all zero rows i := 1; while i <= m and PositionNot(A[i],0) > n do i := i + 1; od; # if i > m there is nothing left; return a null vector if i > m then return []; fi; for t in [1..m] do if t<>i then Unbind(H[t]); fi; od; # H := [ A[i] ]; k := 1; while i <= m do # add row i of A to H v := MutableCopyMat(A[i]); h := PositionNot(v,0); for j in [1 .. k] do if PositionNot(H[j],0) = h then repeat q := RoundCycDown(v[h]/H[j][h]); if q <> 0 then AddRowVector(v,H[j],-q); fi; if v[h] <> 0 then q := RoundCycDown(H[j][h]/v[h]); AddRowVector(H[j],v,-q); if H[j][h] = 0 then if v[h] < 0 then t := -v; else t := v; fi; v := H[j]; H[j] := t; fi; fi; until v[h] = 0; h := PositionNot(v,0); elif PositionNot(H[j],0) > h then if v[h] < 0 then t := -v; else t := v; fi; v := H[j]; H[j] := t; h := PositionNot(v,0); fi; od; if h <= n then k := k + 1; if v[h] < 0 then H[k] := -v; else H[k] := v; fi; fi; if H[k][PositionNot(H[k],0)] < 0 then H[k] := -H[k]; fi; for j in [k-1,k-2 .. 1] do if H[j][PositionNot(H[j],0)] < 0 then H[j] := -H[j]; fi; for l in [j+1 .. k] do h := PositionNot(H[l],0); q := H[j][h]/H[l][h]; if not IsInt(q) and H[j][h] < 0 then q := q - SignInt(H[l][h]); fi; q := Int(q); AddRowVector(H[j],H[l],-q); od; od; i := i + 1; od; for i in [Length(H)+1..m] do Add(H,List([1..n],x->0)); od; return H; end); ############################################################################# ## #F LcNormHnf( [,< Bool/Rat >] ) . the HNF and the transforming matrix ## BindGlobal("LcNormHnf" , function( arg ) local A, # a record (number or rows, no of columns, int matrix) P, # unimodular matrix, such that A.T = P*arg[1] h, # head (first nonzero) of the pivot row i, j, k, # local indexes r, t, q,qq, # auxiliary variables enf_flag, # set to true if the user wishes Echelon form only frac; if not IsMatrix(arg[1]) then PrintTo("*errout*", "use: NormHnf( [, ]);\n"); return fail; fi; frac:=1; enf_flag := false; if Length(arg) = 2 then if arg[2] = true then enf_flag := true; elif IsRat(arg[2]) then frac:=arg[2]; fi; fi; A := rec( T := MutableCopyMat(arg[1]), m := Length(arg[1]), n := Length(arg[1][1]) ); P := IdentityMat(A.m); i := 1; while i <= A.m do Info(InfoMatInt,2,"LcNormHnf - i:= ",i); h := A.n; j := i; while j <= A.m and h > i do t := PositionNot(A.T[j],0); if t < h then h := t; fi; j := j + 1; od; k := MatInt_BestRow(A, i, h); repeat if k <> i then # swap row i and k t := A.T[i]; A.T[i] := A.T[k]; A.T[k] := t; t := P[i]; P[i] := P[k]; P[k] := t; fi; t := A.T[i][h]; # the pivot for j in [i+1 .. A.m] do q := RoundCycDown(A.T[j][h]/t); if q <> 0 then AddRowVector(A.T[j],A.T[i],-q); AddRowVector(P[j],P[i],-q); fi; od; # place empty rows of A at the end j := i + 1; while j <= A.m do if PositionNot(A.T[j],0) <= A.n then j := j + 1; else t := A.T[j]; # swap out an empty row A.T[j] := A.T[A.m]; A.T[A.m] := t; t := P[j]; P[j] := P[A.m]; P[A.m] := t; A.m := A.m - 1; fi; od; k := MatInt_BestRow(A, i + 1, h); until k = 0; i := i + 1; od; for i in [1 .. A.m] do j := PositionNot(A.T[i],0); if A.T[i][j] < 0 then A.T[i] := -A.T[i]; P[i] := -P[i]; fi; od; if not enf_flag then for i in [A.m, A.m-1 .. 1] do for j in [i+1 .. A.m] do h := PositionNot(A.T[j],0); t := A.T[i][h]; r := A.T[j][h]; qq:=t mod r; q := (t - qq)/r; if qq>frac*r then q:=q+1;fi; AddRowVector(A.T[i],A.T[j],-q); AddRowVector(P[i],P[j],-q); od; od; fi; return rec( normal := A.T, rowtrans := P ); end); ############################################################################# #F LcCaCHnf implements Chou & Collins strategy for computing the ## hermite normal form of an integer matrix with transforming matrix ## BindGlobal("LcCaCHnf", function( mat ) local A,h, i, j, k, l, m, n, q, t, v, H, P; A:=MutableCopyMat(mat); m := Length(A); n := Length(A[1]); P := IdentityMat(m); # skip initial all zero rows i := 1; while i <= m and PositionNot(A[i],0) > n do i := i + 1; od; # if i > m there is nothing left; return a null vector if i > m then return rec(normal := [], rowtrans := P); fi; if A[i][PositionNot(A[i],0)] < 0 then H := [ -A[i] ]; t := -P[i]; else H := [ A[i] ]; t := P[i]; fi; P[i] := P[1]; P[1] := t; k := 1; i := i + 1; while i <= m do # add row i of A to H v := MutableCopyMat(A[i]); h := PositionNot(v,0); for j in [1 .. k] do if PositionNot(H[j],0) = h then repeat q := RoundCycDown(v[h]/H[j][h]); if q <> 0 then AddRowVector(v,H[j],-q); AddRowVector(P[i],P[j],-q); fi; if v[h] <> 0 then q := RoundCycDown(H[j][h]/v[h]); AddRowVector(H[j],v,-q); AddRowVector(P[j],P[i],-q); if H[j][h] = 0 then if v[h] < 0 then t := -v; v := H[j]; H[j] := t; t := -P[i]; P[i] := P[j]; P[j] := t; else t := v; v := H[j]; H[j] := t; t := P[i]; P[i] := P[j]; P[j] := t; fi; fi; fi; until v[h] = 0; h := PositionNot(v,0); elif PositionNot(H[j],0) > h then if v[h] < 0 then t := -v; v := H[j]; H[j] := t; t := -P[i]; P[i] := P[j]; P[j] := t; else t := v; v := H[j]; H[j] := t; t := P[i]; P[i] := P[j]; P[j] := t; fi; h := PositionNot(v,0); fi; od; if h <= n then k := k + 1; if v[h] < 0 then v := -v; P[i] := -P[i]; fi; if k < i then t := P[i]; P[i] := P[k]; P[k] := t; fi; H[k] := v; fi; if H[k][PositionNot(H[k],0)] < 0 then H[k] := -H[k]; P[k] := -P[k]; fi; for j in [k-1,k-2 .. 1] do if H[j][PositionNot(H[j],0)] < 0 then H[j] := -H[j]; P[j] := -P[j]; fi; for l in [j+1 .. k] do h := PositionNot(H[l],0); q := H[j][h]/H[l][h]; if not IsInt(q) and H[j][h] < 0 then q := q - SignInt(H[l][h]); fi; q := Int(q); AddRowVector(P[j],P[l],-q); AddRowVector(H[j],H[l],-q); od; od; i := i + 1; od; for i in [Length(H)+1..m] do Add(H,List([1..n],x->0)); od; return rec(normal := H, rowtrans := P); end); ############################################################################## ## #F LcLLLHnf( [, ] ) .. the Hermite NF and the transforming matrix ## BindGlobal("LcLLLHnf", function(arg) local alpha, # LLL's sensitivity; 1/4 <= alpha <= 1 c, # current column i, j, # indicies k, kmax, # indicies of current row, and the last row with GS coeff's m, n, # the number of rows and columns in the matrix q, t, # temporary variables s, # counts the rows of the quotient space BB, mmu, # temporary variables for mu's and B's b, mu, B, # matrix being reduced, GS coefficients and the length vec RED, # reduction procedure P; # final matrix and the transforming matrix E = P*A RED := function( l ) if b[l][c] <> 0 then q := RoundCycDown(b[k][c]/b[l][c]); else q := RoundCycDown(mu[k][l]); fi; if q <> 0 then # \ldots and subtract $q b_l$ from $b_k$; AddRowVector(b[k],b[l],-q); AddRowVector(P[k],P[l],-q); # adjust 'mu', \ldots mu[k][l] := mu[k][l] - q; for i in [1 .. l-1 ] do if mu[l][i] <> 0 then mu[k][i] := mu[k][i] - q * mu[l][i]; fi; od; fi; end; if Length(arg) < 1 or Length(arg) > 2 then PrintTo("*errout*", "use: LLLHnf( [, ]);\n"); fi; b := MutableCopyMat( arg[1] ); m := Length(b); n := Length(b[1]); P := IdentityMat(m); if IsBound(arg[2]) and IsRat(arg[2]) then alpha := arg[2]; if alpha < 1/4 or alpha > 1 then PrintTo("*errout*", "Sensitivity error. Using the default\n"); alpha := 3/4; fi; else alpha := 3/4; fi; # sort rows according the the position of the leading nonzero SortParallel(b, P, function(x, y) return PositionNot(x,0) > PositionNot(y,0); end); s := 0; # counts the rows of quotient space # skip all rows that are already in the echelon normal form while PositionNot(b[m-s],0) < PositionNot(b[m-s-1],0) do s := s + 1; od; c := PositionNot(b[m-s],0); kmax := 1; B := [ b[1]*b[1] + P[1]*P[1] ]; mu := [ [ ] ]; while c <= n do # step 1, initialize k := 2; while k <= m - s do # step 2, incremental Gram-Schmidt if k > kmax then kmax := k; mu[k] := []; for j in [1 .. k-1] do mmu := b[k]*b[j] + P[k]*P[j]; for i in [1 .. j-1] do mmu := mmu - mu[j][i]*mu[k][i]; od; mu[k][j] := mmu; od; for j in [1 .. k-1] do mu[k][j] := mu[k][j]/B[j]; od; B[k] := b[k]*b[k] + P[k]*P[k]; for j in [1 .. k-1] do B[k] := B[k] - mu[k][j]^2*B[j]; od; fi; # step 3, test LLL condition # substep 3.1, RED(k, k-1) RED(k-1); while (AbsInt(b[k-1][c]) > AbsInt(b[k][c])) or (b[k-1][c] = b[k][c] and B[k] < (alpha - mu[k][k-1]^2 ) * B[k-1]) do # algorithm SWAP(k) t := b[k]; b[k] := b[k-1]; b[k-1] := t; t := P[k]; P[k] := P[k-1]; P[k-1] := t; for j in [1 .. k-2] do t := mu[k][j]; mu[k][j] := mu[k-1][j]; mu[k-1][j] := t; od; mmu := mu[k][k-1]; BB := B[k] + mmu*mmu*B[k-1]; q := B[k-1]/BB; mu[k][k-1] := mmu * q; B[k] := B[k] * q; B[k-1] := BB; for i in [k+1 .. kmax] do t := mu[i][k]; mu[i][k] := mu[i][k-1] - mmu*t; mu[i][k-1] := t + mu[k][k-1]*mu[i][k]; od; # k := max(2, k-1) if k > 2 then k := k - 1; fi; # execute subalgorithm RED(k, k-1) RED(k-1); od; # execute subalgorithm RED for i = k-2, k-3, ...1 for i in [k-2, k-3 .. 1] do RED(i); od; k := k + 1; # step 4, Finished? od; s := s + 1; kmax := kmax - 1; c := n+1; for i in [1 .. m - s] do c := Minimum(c, PositionNot(b[i],0)); od; od; s := m - s + 1; # rows s .. m form the quotient space # rows 1 .. s - 1 for the null space # use the remaining rows to create the Hermite normal form of b if b[s][PositionNot(b[s],0)] < 0 then b[s] := -b[s]; P[s] := -P[s]; fi; for i in [s + 1 .. m] do if b[i][PositionNot(b[i],0)] < 0 then b[i] := -b[i]; P[i] := -P[i]; fi; for j in [i-1, i-2 .. s] do k := PositionNot(b[j],0); q := b[i][k]/b[j][k]; if not IsInt(q) then if b[i][k] < 0 then q := Int(q) - SignInt(b[j][k]); else q := Int(q); fi; fi; AddRowVector(b[i],b[j],-q); AddRowVector(P[i],P[j],-q); od; od; # use the null space to reduce the quotient space # for each vector in the quotient space compute its Gram-Schmidt # orthogonalization and use procedure Proper (B.Vallee) to bring # it closer to the shortest vector for k in [s .. m] do # Gram Schmidt for the k-th vector mu[k] := [ ]; for j in [1 .. s-1] do mmu := P[k]*P[j]; for i in [1 .. j-1] do mmu := mmu - mu[j][i]*mu[k][i]; od; mu[k][j] := mmu; od; for j in [1 .. s-1] do mu[k][j] := mu[k][j]/B[j]; od; for j in [s-1, s-2 .. 1] do # RED(j), however we want to avoid testing column c q := RoundCycDown(mu[k][j]); if q <> 0 then AddRowVector(P[k],P[j],-q); for i in [1 .. j-1] do if mu[j][i] <> 0 then mu[k][i] := mu[k][i] - q*mu[j][i]; fi; od; fi; od; od; b:=Reversed(b{[s .. m]}); for k in [Length(b)+1..m] do Add(b,List([1..n],x->0)); od; return rec( normal := b, rowtrans := Reversed(P)); # return rec( normal := Reversed(b{[s .. m]}), rowtrans := Reversed(P)); end); ############################################################################# ## ## start of smith normal form code ## ############################################################################# ## #F MatMax ( ) . . . . . returns the value of the element with the ## largest absolute value in matrix A BindGlobal("MatMax", function(A, f) local i, j, e, x; x := 0; for i in [f .. Length(A)] do for e in A[i] do if e < 0 then e := -1*e; fi; if e > x then x := e; fi; od; od; return x; end); ############################################################################## ## #F NormDiagonalize( ) . . . . a norm driven integer matrix diagonalization algorithm ## BindGlobal("NormDiagonalize", function( S ) local t, # a temporary variable, for row swaps and such RNm, # row norms CNm, # column norms m, n, # the number or rows and columns of S i,j,k, # indices d, # the index of the current diagonal entry q, # quotient of two entries, most of the time RId, # index of the "best" row CId, # index of the "best" column CMn, # smallest so far column norm RMn, # smallest so far row norm done; # flag, set to true if the d-th diagonal element is computed m := Length(S); n := Length(S[1]); RNm := List(S, x -> x*x); CNm := [ ]; for k in [1 .. n] do CNm[k] := S{[1 .. m]}[k]*S{[1 .. m]}[k]; od; d := 1; repeat # pivot selection # first we sort rows d .. m. Zero rows are the heaviest # for other rows the standard Euclidean Length is used # this is a simple implementation that uses Insertion Sort for j in [d+1 .. m] do if RNm[j] <> 0 then t := S[j]; q := RNm[j]; k := j - 1; while k >= d and (RNm[k] = 0 or q < RNm[k]) do RNm[k+1] := RNm[k]; S[k+1] := S[k]; k := k-1; od; RNm[k+1] := q; S[k+1] := t; fi; od; # eliminate all zero rows, by decreasing m suitably while RNm[m] = 0 do m := m - 1; od; if d = m then S[d][d] := Gcd(S[d]{[d .. n]}); # clean out the last row. S[d]{[d+1..n]} := [d+1..n] * 0; return; elif d > m then return; fi; j := d; k := d; while S[j][k] = 0 do j := j + 1; if j > m then j := d; k := k + 1; fi; od; CMn := RNm[j]*CNm[k]; CId := k; RId := j; k := k + 1; while k <= n do j := d; while j <= m and S[j][k] = 0 do j := j + 1; od; if j <= m then RMn := RNm[j]*CNm[k]; if RMn < CMn then CId := k; RId := j; CMn := RMn; fi; fi; k := k + 1; od; # swap rows and columns so that pivot becomes the d-th,d-th element t := S[d]; S[d] := S[RId]; S[RId] := t; if CId <> d then for k in [d .. m] do t := S[k][d]; S[k][d] := S[k][CId]; S[k][CId] := t; od; fi; # pivot in place; proceed to zero the d-th row and column Info(InfoMatInt,3,"NormDiagonalize - working on column ",d); done := false; repeat # row operations first for k in [d+1 .. m] do q := RoundCycDown(S[k][d]/S[d][d]); if q <> 0 then AddRowVector(S[k],S[d],-q); fi; od; # column operations follow for k in [d+1 .. n] do q := RoundCycDown(S[d][k]/S[d][d]); if q <> 0 then # subtract column d from column k, q times for j in [d .. m] do S[j][k] := S[j][k] - q*S[j][d]; od; fi; od; # recompute norms, as we need to choose another pivot RNm{[d .. m]} := List(S{[d .. m]}, x -> x*x); for k in [d .. n] do CNm[k] := S{[d .. m]}[k]*S{[d .. m]}[k]; od; # find the best pivot in the d-th row CMn := 0; for k in [d+1 .. n] do if S[d][k] <> 0 then if CMn = 0 or CNm[k] < CMn then CId := k; CMn := CNm[k]; fi; fi; od; # find the best pivot in the d-th column RMn := 0; for k in [d+1 .. m] do if S[k][d] <> 0 then if RMn = 0 or RNm[k] < RMn then RId := k; RMn := RNm[k]; fi; fi; od; if CMn = 0 then if RMn = 0 then done := true; else # swap row RId and d t := S[d]; S[d] := S[RId]; S[RId] := t; fi; else if RMn = 0 then # swap column CId and d for k in [d .. m] do t := S[k][d]; S[k][d] := S[k][CId]; S[k][CId] := t; od; else if RNm[d]*CMn < CNm[d]*RMn then for k in [d .. m] do t := S[k][d]; S[k][d] := S[k][CId]; S[k][CId] := t; od; else t := S[d]; S[d] := S[RId]; S[RId] := t; fi; fi; fi; until done; if S[d][d] < 0 then S[d][d] := -S[d][d]; fi; d := d + 1; until d > m; end); ############################################################################## ## #F DiagToSNF( ) . . . . collects diagonal entries and ensures their ## divisibility cond for the diagonal matrix S BindGlobal("DiagToSNF", function( S ) local g, i, L, n,z; L := [ ];z:=0; for i in [1 .. Minimum(Length(S), Length(S[1])) ] do if S[i][i] <> 0 then Add(L, AbsInt(S[i][i])); else z:=z+1; fi; od; n := Length(L); i := 2; while i <= n do g := L[i]; while i > 1 and g < L[i-1] do L[i] := L[i-1]; i := i - 1; od; L[i] := g; Info(InfoMatInt,3,"DiagToSNF: ",i); Info(InfoMatInt,4,"DiagToSNF: ",L); if i = 1 then i := 2; fi; if L[i] mod L[i-1] <> 0 then g := Gcd(L[i], L[i-1]); L[i] := L[i]*L[i-1]/g; i := i - 1; while i > 1 and g < L[i-1] do L[i] := L[i-1]; i := i - 1; od; L[i] := g; Info(InfoMatInt,3,"DiagToSNF: ",i); Info(InfoMatInt,4,"DiagToSNF: ",L); fi; if i = 1 or L[i] mod L[i-1] = 0 then i := i + 1; fi; od; L{[n+1..n+z]}:=List([1..z],x->0); return L; end); ############################################################################## ## #F NormSnf( ) . . . . . . Computes the Smith Normal form of matrix A ## BindGlobal("NormSnf", function( S ) local M, # temp matrix n, # length of leading diagonal m; # counter if not IsMatrix(S) then PrintTo("*errout*", "Use: NormSnf( );\n"); return fail; fi; n := Minimum(Length(S), Length(S[1])); M:=NullMat(Length(S),Length(S[1])); NormDiagonalize( S ); M:=DiagToSNF(S); for m in [1..Length(M)] do S[m][m]:=M[m]; od; for m in [Length(M)+1..n] do S[m][m]:=0; od; return S; end); ############################################################################## ## #F CaCDiagonalize( ) . . . . . diagonalizes a matrix using Chou & Collins ## BindGlobal("CaCDiagonalize", function( S ) local h, # point to the first nonzero in the current row H, # heads of vectors, i.e., indices of the leading nonzeros i,j,k, # as usually, indices m, n, # the number of rows and columns in S q, # usually quotient for row operations t, # a temporary variable for all sorts of things modfd, # indicates whether the column phase is necessary dirty; # indicates whether any upward row operations took place m := Length(S); n := Length(S[1]); # it is generally recommended to sort matrix S before # executing Chou and Collins' algorithm. It is commented # out, as the sorting has rather bad effect if S is already # in partial hermite normal form (sorting jumbles things up) # however in general, if S hasn't been touched before, it # is highly beneficial to sort the matrix. (Maybe one could # sort it so that it resembles HNF as much as possible, and # only rows that have leading nonzeros in the same column # would be sorted according to their Euclidean length # Sort(S, function(x, y) return x*x < y*y; end); dirty := false; repeat H := [ ]; # clear Heads array # get rid of initial empty rows i := 1; while ForAll(S[i], e -> e = 0) do i := i + 1; od; if i > 1 then S := S{[i .. m]}; m := m - i + 1; fi; dirty := not dirty; i := 1; Add(H, PositionNot(S[1],0)); while i < m do i := i + 1; # introduce the i-th row of S to the partial SNF(S) h := PositionNot(S[i],0); modfd := false; # set to true if columns require modifications for j in [1 .. i-1] do if H[j] = h then repeat q := RoundCycDown(S[i][h]/S[j][h]); if q <> 0 then AddRowVector(S[i],S[j],-q); fi; if S[i][h] <> 0 then modfd := true; q := RoundCycDown(S[j][h]/S[i][h]); AddRowVector(S[j],S[i],-q); if S[j][h] = 0 then if S[i][h] < 0 then t := -S[i]; else t := S[i]; fi; S[i] := S[j]; S[j] := t; fi; fi; until S[i][h] = 0; h := PositionNot(S[i],0); elif PositionNot(S[j],0) > h then if S[i][h] < 0 then t := -S[i]; else t := S[i]; fi; S[i] := S[j]; S[j] := t; t := H[j]; H[j] := h; h := t; modfd:= true; fi; od; dirty := dirty or modfd; if h <= n then Add(H, h); modfd := true; else S{[i .. m-1]} := S{[i+1 .. m]}; Unbind(S[m]); m := m - 1; i := i - 1; fi; if modfd then if S[i][H[i]] < 0 then S[i] := -S[i]; fi; for j in [i-1,i-2 .. 1] do if S[j][H[j]] < 0 then S[j] := -S[j]; fi; for k in [j+1 .. i] do h := H[k]; q := S[j][h]/S[k][h]; if not IsInt(q) and S[j][h] < 0 then q := q - SignInt(S[k][h]); fi; q := Int(q); if q <> 0 then AddRowVector(S[j],S[k],-q); dirty := true; fi; od; od; fi; od; # transpose S and swap m and n S := MutableTransposedMat(S); t := m; m := n; n := t; until not dirty; return S; end); ############################################################################## ## #F CaCSnf( ) . . . . . . . Computes the Smith Normal form of matrix A ## BindGlobal("CaCSnf", function( S ) local m,M,N;# temporary variable if not IsMatrix(S) then PrintTo("*errout*", "Use: CaCSnf( );\n"); return fail; fi; N:=NullMat(Length(S),Length(S[1])); CaCDiagonalize(S); M:=DiagToSNF(S); for m in [1..Length(M)] do N[m][m]:=M[m]; S[m]:=N[m]; od; return S ; end); ############################################################################# ## #F IdTransReturn(mat) . . . . . . . return relevant identity record for mat ## IdTransReturn:=function(arg) local n,r; if Length(arg[1])>0 and IsList(arg[1][1]) then n:=Length(arg[1][1]);else n:=0;fi; r:=arg[1]; if (IsBound(arg[2]) and arg[2]) or (IsBound(arg[3]) and arg[3]) then r:= rec( normal:=arg[1] ); if arg[2] then r.rowtrans:=IdentityMat(Length(arg[1])); fi; if IsBound(arg[3]) and arg[3] then r.coltrans:=IdentityMat(n); fi; fi; return r; end; ############################################################################## ## #F LcNormSnf( ) . . . . . Computes the Smith Normal form of matrix A ## LcNormSnf := function( arg ) PrintTo("*errout*", "This function (LcNormSnf) is yet to be implemented. Sorry.\n"); return fail; end; ############################################################################## ## #F LcCaCSnf( ) . . . . . Computes the Smith Normal form of matrix A ## LcCaCSnf := function( arg ) PrintTo("*errout*", "This function (LcCaCSnf) is yet to be implemented. Sorry.\n"); return fail; end; ############################################################################## ## #F LcLLLSnf( ) . . . . . Computes the Smith Normal form of matrix A ## LcLLLSnf := function( arg ) PrintTo("*errout*", "This function (LcLLLSnf) is yet to be implemented. Sorry.\n"); return fail; end; ############################################################################# ## #F HNFNormDriven([,[,]]) #F HNFChouCollins([,[,]]) #F HNFLLLDriven([,[,]]) ## ## These operations have been superceded for most purposes by ## `NormalFormIntMat' (see~"NormalFormIntMat") ## which should in most cases be faster than any ## of them, and produce smaller transforming matrix entries. ## ## These operations compute the Hermite normal form of a matrix with ## integer entries, using the strategy specified in the name. If no optional ## argument is given must be a mutable matrix which will ## be changed by the algorithm. ## ## If the optional integer argument is given, it determines which ## transformation matrices will be computed. It is interpreted binary as ## for the Smith normal form (see "SNFNormDriven") but note that only ## row operations are performed. The function then returns a record with ## components as specified for the Smith normal form. ## ## If the further optional argument (a rational in the range ## `[0..1]') ## is given, it specifies which representatives ## are used for entries modulo $c$ when cleaning column entries to the top. ## Off-diagonal entries are reduced to the range ## \quad$\lfloor c(r-1)\rfloor\ldots \lfloor cr\rfloor$, ## where $r$ is the value of . ## If is not given, a value of 1 is assumed. ## Note, if is given the operation does not change . ## ## gap> m:=[ [ 14, 20 ], [ 6, 9 ] ];; ## gap> HNFNormDriven(m); ## [ [ 2, 2 ], [ 0, 3 ] ] ## gap> m; ## [ [ 2, 2 ], [ 0, 3 ] ] ## ## gap> m:=[[14,20],[6,9]];; ## gap> HNFNormDriven(m,1); ## rec( normal := [ [ 2, 2 ], [ 0, 3 ] ], rowtrans := [ [ 1, -2 ], [ -3, 7 ] ] ) ## gap> m; ## [ [ 14, 20 ], [ 6, 9 ] ] ## gap> last2.rowtrans*m; ## [ [ 2, 2 ], [ 0, 3 ] ] ## BindGlobal("HNFNormDriven", function(arg) if Flat(arg[1])=[] and ForAll(arg[1],x->Length(x)=Length(arg[1][1])) then return CallFuncList(IdTransReturn,[arg[1],IsBound(arg[2])]); fi; if not IsMatrix(arg[1]) then PrintTo("*errout*", "matrix required as argument\n"); return fail; fi; if ForAll( Flat(arg[1]) , x -> x = 0 ) then return CallFuncList(IdTransReturn,[arg[1],IsBound(arg[2])]); fi; if Length(arg)=1 then return CallFuncList(NormHnf,arg);fi; if Length(arg)=2 then if arg[2]=1 then return CallFuncList(LcNormHnf,arg) ; else PrintTo("*errout*", "Transformation matrix routine only implemented for trans=1 for this routine at present. Sorry.\n"); return fail; fi; fi; if Length(arg)>2 then if arg[2]=1 then return LcNormHnf(arg[1],arg[3]); elif arg[2]=0 then return NormHnf(arg[1],arg[3]); else PrintTo("*errout*", "Transformation matrix routine only implemented for trans=1 for this routine at present. Sorry.\n"); return fail; fi; fi; end); ############################################################################# ## #F HNFChouCollins([,[,]]) ## BindGlobal("HNFChouCollins", function(arg) if Flat(arg[1])=[] and ForAll(arg[1],x->Length(x)=Length(arg[1][1])) then return CallFuncList(IdTransReturn,[arg[1],IsBound(arg[2])]); fi; if not IsMatrix(arg[1]) then PrintTo("*errout*", "matrix required as argument\n"); return fail; fi; if ForAll( Flat(arg[1]) , x -> x = 0 ) then return CallFuncList(IdTransReturn,[arg[1],IsBound(arg[2])]); fi; if Length(arg)=1 then return CaCHnf(arg[1]);fi; if Length(arg)=2 then if arg[2]=1 then return LcCaCHnf(arg[1]); elif arg[2]=0 then return CaCHnf(arg[1]); else PrintTo("*errout*", "Transformation matrix routine only implemented for trans=1 for this routine at present. Sorry.\n"); return fail; fi; fi; if Length(arg)>2 then PrintTo("*errout*", "Different Reduction routines not yet implemented for this routine. Try the Norm driven routine.\n"); return fail;fi; end); ############################################################################# ## #F HNFLLLDriven([,[,]]) ## BindGlobal("HNFLLLDriven", function(arg) local i,t; if Flat(arg[1])=[] and ForAll(arg[1],x->Length(x)=Length(arg[1][1])) then return CallFuncList(IdTransReturn,[arg[1],IsBound(arg[2])]); fi; if not IsMatrix(arg[1]) then PrintTo("*errout*", "matrix required as argument\n"); return fail; fi; if ForAll( Flat(arg[1]) , x -> x = 0 ) then return CallFuncList(IdTransReturn,[arg[1],IsBound(arg[2])]); fi; if Length(arg)=1 then t:= LcLLLHnf(arg[1]).normal; for i in [1..Length(arg[1])] do arg[1][i]:=t[i]; od; return t; fi; if Length(arg)=2 then if arg[2]=1 then return LcLLLHnf(arg[1]); else PrintTo("*errout*", "Transformation matrix routine only implemented for trans=1 for this routine at present. Sorry.\n"); return fail; fi; fi; if Length(arg)>2 then PrintTo("*errout*", "Different Reduction routines not yet implemented for this routine. Try the Norm driven routine. Sorry.\n"); return fail; fi; end); ############################################################################# ## #O SNFNormDriven([,]) #O SNFChouCollins([,]) ## ## These operations have been superceded for most purposes by ## `NormalFormIntMat' (see~"NormalFormIntMat") which should in most cases ## be faster than any ## of them, and produce smaller transforming matrix entries. ## ## These operations compute the Smith normal form of a matrix with ## integer entries, using the strategy specified in the name. If no optional ## argument is given must be a mutable matrix which will ## be changed by the algorithm. ## ## If the optional integer argument is given, it determines which ## transformation matrices will be computed. It is interpreted binary as: ## \beginlist ## \item{1} Row transformations. ## ## \item{2} Inverse row transformations. ## ## \item{4} Column transformations. ## ## \item{8} Inverse column transformations. ## \endlist ## ## The operation then returns a record with the component `normal' containing ## the computed normal form and optional components `rowtrans', `rowinverse', ## `coltrans', and `invcoltrans' which hold the computed transformation ## matrices. Note, if is given the operation does not change . ## ## This functionality is still to be fully implemented for SNF with transforms. ## However, `NormalFormIntMat' performs this calculation. ## BindGlobal("SNFNormDriven", function(arg) if Flat(arg[1])=[] and ForAll(arg[1],x->Length(x)=Length(arg[1][1])) then return CallFuncList(IdTransReturn,[arg[1],IsBound(arg[2]),IsBound(arg[2])]); fi; if not IsMatrix(arg[1]) then PrintTo("*errout*", "matrix required as argument\n"); return fail; fi; if ForAll( Flat(arg[1]) , x -> x = 0 ) then return CallFuncList(IdTransReturn,[arg[1],IsBound(arg[2]),IsBound(arg[2])]); fi; if Length(arg)=1 then return NormSnf(arg[1]);fi; if Length(arg)=2 then return LcNormSnf(arg);fi; end); ############################################################################# ## #F SNFChouCollins([,]) ## BindGlobal("SNFChouCollins", function(arg) if Flat(arg[1])=[] and ForAll(arg[1],x->Length(x)=Length(arg[1][1])) then return CallFuncList(IdTransReturn,[arg[1],IsBound(arg[2]),IsBound(arg[2])]); fi; if not IsMatrix(arg[1]) then PrintTo("*errout*", "matrix required as argument\n"); return fail; fi; if ForAll( Flat(arg[1]) , x -> x = 0 ) then return CallFuncList(IdTransReturn,[arg[1],IsBound(arg[2]),IsBound(arg[2])]); fi; if Length(arg)=1 then return CallFuncList(CaCSnf,[arg[1]]);fi; if Length(arg)=2 then return LcCaCSnf(arg);fi; end); gap-4r6p5/lib/global.g0000644000175000017500000001051012172557252013314 0ustar billbill############################################################################# ## #W global.g GAP library Steve Linton ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## ## This file contains the first stage of the "public" interface to ## the global variable namespace, allowing globals to be accessed and ## set by name. ## ## This is defined in two stages. This file defines "capitalized" versions ## of the functions which do not use Info or other niceties and are not ## set up with InstallGlobalFunction. This can thus be read early, and ## the functions it defines can be used to define functions used to read ## more of the library. ## ## The global.gd and global.gi stages will install the really "public" ## functions and can be read later (once Info, DeclareGlobalFunction, ## etc are there) ## ############################################################################# ## #F VALUE_GLOBAL ( ) . . . . . . . . . . .access a global by its name ## ## VALUE_GLOBAL ( ) returns the value currently bound to the global ## variable named by the string . An error is raised if no value ## is currently bound ## VALUE_GLOBAL := VAL_GVAR; ############################################################################# ## #F ISBOUND_GLOBAL ( ) . . . . check if a global is bound by its name ## ## ISBOUND_GLOBAL ( ) returns true if a value currently bound ## to the global variable named by the string and false otherwise ## ISBOUND_GLOBAL := ISB_GVAR; ############################################################################# ## #F UNBIND_GLOBAL ( ) . . . . . . . . . .unbind a global by its name ## ## UNBIND_GLOBAL ( ) removes any value currently bound ## to the global variable named by the string . Nothing is returned. ## ## The global variable named by must be writable, ## otherwise an error is raised. ## UNBIND_GLOBAL := UNB_GVAR; ############################################################################# ## #F IS_READ_ONLY_GLOBAL ( ) determine if a global variable is read-only ## ## IS_READ_ONLY_GLOBAL ( ) returns true if the global variable ## named by the string is read-only and false otherwise (the default) ## IS_READ_ONLY_GLOBAL := IsReadOnlyGVar; ############################################################################# ## #F MAKE_READ_ONLY_GLOBAL ( ) . . . . make a global variable read-only ## ## MAKE_READ_ONLY_GLOBAL ( ) marks the global variable named ## by the string as read-only. ## MAKE_READ_ONLY_GLOBAL := MakeReadOnlyGVar; ############################################################################# ## #F MAKE_READ_WRITE_GLOBAL ( ) . . .make a global variable read-write ## ## MAKE_READ_WRITE_GLOBAL ( ) marks the global variable named ## by the string as read-write ## MAKE_READ_WRITE_GLOBAL := MakeReadWriteGVar; ############################################################################# ## #V REREADING set to true inside a Reread, changes much ## behaviour ## REREADING := false; MAKE_READ_ONLY_GLOBAL("REREADING"); ############################################################################# ## #F BIND_GLOBAL ( , ) . . . . . .sets a global variable 'safely' ## ## BIND_GLOBAL ( , ) sets the global variable named by ## the string to the value , provided it was previously ## unbound, and makes it read-only. This is intended to be the normal ## way to create and set "official" global variable (such as ## Operations and Categories) ## BIND_GLOBAL := function( name, val) if not REREADING and ISBOUND_GLOBAL( name ) then if (IS_READ_ONLY_GLOBAL(name)) then Error("BIND_GLOBAL: variable `", name, "' must be unbound"); else Print("#W BIND_GLOBAL: variable `", name,"' already has a value\n"); fi; fi; ASS_GVAR(name, val); MAKE_READ_ONLY_GLOBAL(name); return val; end; ############################################################################# ## #E global.g . . . . . . . . . . . . . . . . . . . . . . . . . . . ends here gap-4r6p5/lib/ffe.g0000644000175000017500000001573312172557252012630 0ustar billbill############################################################################# ## #W ffe.g GAP library Thomas Breuer #W & Frank Celler ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file deals with internal finite field elements. ## ############################################################################# ## #V MAXSIZE_GF_INTERNAL . . . . . . . . . . . . maximal size of internal ffes ## BIND_GLOBAL( "MAXSIZE_GF_INTERNAL", 2^16 ); ############################################################################# ## #V TYPES_FFE . . . . . . . . . . . . . list of known types of internal ffes ## #T TYPES_FFE := WeakPointerObj( [] ); BIND_GLOBAL( "TYPES_FFE", [] ); BIND_GLOBAL( "TYPES_FFE0", [] ); ############################################################################# ## #F TYPE_FFE(

) . . . . . . . . . . . type of a ffe in characteristic

## ##

must be a small prime integer ## (see also `ffe.gi'). ## ## Note that the `One' and `Zero' values of the family cannot be set ## in `TYPE_FFE' since this would need access to `One( Z(

) )' and ## `Zero( Z(

) )', respectively, ## which in turn would call `TYPE_FFE' and thus would lead to an infinite ## recursion. ## BIND_GLOBAL( "TYPE_FFE", function ( p ) local type, fam; if IsBound( TYPES_FFE[p] ) then return TYPES_FFE[p]; fi; #T if IsBoundElmWPObj( TYPES_FFE, p ) then #T type:= ElmWPObj( TYPES_FFE, p ); #T if type <> fail then #T return type; #T fi; #T fi; fam:= NewFamily( "FFEFamily", IS_FFE,CanEasilySortElements,CanEasilySortElements ); SetIsUFDFamily( fam, true ); SetCharacteristic( fam, p ); type:= NewType( fam, IS_FFE and IsInternalRep and HasDegreeFFE); TYPES_FFE[p]:= type; #T SetElmWPObj( TYPES_FFE, p, type ); return type; end ); ############################################################################# ## #F TYPE_FFE0(

) . . . . . . . . .type of zero ffe in characteristic

## ## see also "ffe.gi" ## BIND_GLOBAL( "TYPE_FFE0", function ( p ) local type, fam; if IsBound( TYPES_FFE0[p] ) then return TYPES_FFE0[p]; fi; #T if IsBoundElmWPObj( TYPES_FFE, p ) then #T type:= ElmWPObj( TYPES_FFE, p ); #T if type <> fail then #T return type; #T fi; #T fi; fam:= FamilyType(TYPE_FFE(p)); type:= NewType( fam, IS_FFE and IsInternalRep and IsZero and HasIsZero and HasDegreeFFE ); TYPES_FFE0[p]:= type; #T SetElmWPObj( TYPES_FFE, p, type ); return type; end ); ############################################################################# ## #m DegreeFEE( ) . . . . . . . . . . . . . . . . . . for internal ffe ## InstallMethod( DegreeFFE, "for internal FFE", true, [ IsFFE and IsInternalRep ], 0, DEGREE_FFE_DEFAULT ); ############################################################################# ## #m Characteristic( ) . . . . . . . . . . . . . . . for internal ffe ## InstallMethod( Characteristic, "for internal FFE", true, [ IsFFE and IsInternalRep ], 0, CHAR_FFE_DEFAULT ); ############################################################################# ## #M LogFFE( , ) . . . . . . . . . . . . . . . . for internal ffe ## InstallMethod( LogFFE, "for two internal FFEs", IsIdenticalObj, [ IsFFE and IsInternalRep, IsFFE and IsInternalRep ], 0, LOG_FFE_DEFAULT ); ############################################################################# ## #M IntFFE( ) . . . . . . . . . . . . . . . . . . . . for internal ffe ## InstallMethod( IntFFE, "for internal FFE", true, [ IsFFE and IsInternalRep ], 0, INT_FFE_DEFAULT ); ############################################################################# ## #m \*( , ) . . . . . . . . . . . . . for ffe and (large) integer ## ## Note that the multiplication of internally represented FFEs with small ## integers is handled by the kernel. ## InstallOtherMethod( \*, "internal ffe * (large) integer", true, [ IsFFE and IsInternalRep, IsInt ], 0, function( ffe, int ) local char; char:= Characteristic( ffe ); if IsSmallIntRep( char ) then return ffe * ( int mod char ); else return PROD_INT_OBJ( int, ffe ); fi; end ); ############################################################################# ## #O SUM_FFE_LARGE #O DIFF_FFE_LARGE #O PROD_FFE_LARGE #O QUO_FFE_LARGE #O LOG_FFE_LARGE ## ## If the {\GAP} kernel cannot handle the addition, multiplication etc. ## of internally represented FFEs then it delegates to the library without ## checking the characteristic; therefore this check must be done here. ## (Note that `LogFFE' is an operation for which the kernel does not know ## a table of methods, so the check for equal characteristic is done by ## the method selection. #T Note that `LogFFEHandler' would not need to call `LOG_FFE_DEFAULT'; #T if the two arguments , are represented w.r.t. incompatible fields #T then either can be represented in the field of or the logarithm #T does not exist. ## DeclareOperation("SUM_FFE_LARGE", [IsFFE and IsInternalRep, IsFFE and IsInternalRep]); InstallOtherMethod(SUM_FFE_LARGE, [IsFFE, IsFFE], function( x, y ) if Characteristic( x ) <> Characteristic( y ) then Error( " and have different characteristic" ); fi; TryNextMethod(); end); DeclareOperation("DIFF_FFE_LARGE", [IsFFE and IsInternalRep, IsFFE and IsInternalRep]); InstallOtherMethod(DIFF_FFE_LARGE, [IsFFE, IsFFE], function( x, y ) if Characteristic( x ) <> Characteristic( y ) then Error( " and have different characteristic" ); fi; TryNextMethod(); end); DeclareOperation("PROD_FFE_LARGE", [IsFFE and IsInternalRep, IsFFE and IsInternalRep]); InstallOtherMethod(PROD_FFE_LARGE, [IsFFE, IsFFE ], function( x, y ) if Characteristic( x ) <> Characteristic( y ) then Error( " and have different characteristic" ); fi; TryNextMethod(); end); DeclareOperation("QUO_FFE_LARGE", [IsFFE, IsFFE]); InstallOtherMethod(QUO_FFE_LARGE, [IsFFE and IsInternalRep, IsFFE and IsInternalRep], function( x, y ) if Characteristic( x ) <> Characteristic( y ) then Error( " and have different characteristic" ); fi; TryNextMethod(); end); BIND_GLOBAL( "LOG_FFE_LARGE", function( x, y ) Error( "not supported yet -- this should never happen" ); end ); ############################################################################# ## #O ZOp -- operation to compute Z for large values of q ## DeclareOperation("ZOp", [IsPosInt]); ############################################################################# ## #E gap-4r6p5/lib/schur.gd0000644000175000017500000002247112172557254013357 0ustar billbill############################################################################# ## #W schur.gd GAP library Werner Nickel #W Alexander Hulpke ## #Y (C) 2000 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ############################################################################# ## #V InfoSchur ## ## ## ## ## ## ## ## DeclareInfoClass( "InfoSchur" ); ############################################################################# ## #O SchurCover() ## ## <#GAPDoc Label="SchurCover"> ## ## ## ## ## returns one (of possibly several) Schur covers of the group G. ##

## At the moment this cover is represented as a finitely presented group ## and would be needed to convert it to a ## permutation group. ##

## If also the relation to G is needed, ## should be used. ## g:=Group((1,2,3,4),(1,2));; ## gap> epi:=EpimorphismSchurCover(g); ## [ f1, f2, f3 ] -> [ (3,4), (2,4,3), (1,3)(2,4) ] ## gap> Size(Source(epi)); ## 48 ## ]]> ##

## If the group becomes bigger, Schur Cover calculations might become ## unfeasible. ##

## There is another operation, , ## which only returns the structure of the Schur Multiplier, ## and which should work for larger groups as well. ## ## ## <#/GAPDoc> ## DeclareAttribute( "SchurCover", IsGroup ); ############################################################################## ## #O EpimorphismSchurCover([,]) ## ## <#GAPDoc Label="EpimorphismSchurCover"> ## ## ## ## ## returns an epimorphism epi from a group D onto G. ## The group D is one (of possibly several) Schur covers of G. ## The group D can be obtained as the value of ## epi. ## The kernel of epi is the Schur multiplier of G. ## If pl is given as a list of primes, ## only the multiplier part for these primes is realized. ## At the moment, D is represented as a finitely presented group. ## ## ## <#/GAPDoc> ## DeclareAttribute( "EpimorphismSchurCover", IsGroup ); ############################################################################## ## #A AbelianInvariantsMultiplier() ## ## <#GAPDoc Label="AbelianInvariantsMultiplier"> ## ## ## ## ## Multiplier ## Schur multiplier ## returns a list of the abelian invariants of the Schur multiplier of ## G. ##

## At the moment, this operation will not give any information about how to ## extend the multiplier to a Schur Cover. ## AbelianInvariantsMultiplier(g); ## [ 2 ] ## gap> AbelianInvariantsMultiplier(AlternatingGroup(6)); ## [ 2, 3 ] ## gap> AbelianInvariantsMultiplier(SL(2,3)); ## [ ] ## gap> AbelianInvariantsMultiplier(SL(3,2)); ## [ 2 ] ## gap> AbelianInvariantsMultiplier(PSU(4,2)); ## [ 2 ] ## ]]> ## (Note that the last command from the example will take some time.) ##

## The &GAP; 4.4.12 manual contained examples for larger groups e.g. ## M_{22}. However, some issues that may very rarely (and not ## easily reproducibly) lead to wrong results were discovered in the code ## capable of handling larger groups, and in &GAP; 4.5 it was replaced ## by a more reliable basic method. To deal with larger groups, one can use ## the function from the ## cohomolo package. Also, additional methods for ## are installed in the ## Polycyclic package for pcp-groups. ## ## ## <#/GAPDoc> ## DeclareAttribute( "AbelianInvariantsMultiplier", IsGroup ); ############################################################################## #### Derived functions. Robert F. Morse #### ############################################################################## ## #A Epicentre() #A ExteriorCentre() ## ## <#GAPDoc Label="Epicentre"> ## ## ## ## ## ## There are various ways of describing the epicentre of a group G. ## It is the smallest normal subgroup N of G such that ## G/N is a central quotient of a group. ## It is also equal to the Exterior Center of G, ## see . ## ## ## <#/GAPDoc> ## DeclareAttribute("Epicentre", IsGroup ); DeclareSynonymAttr("Epicenter", Epicentre); DeclareSynonymAttr("ExteriorCentre", Epicentre); DeclareSynonymAttr("ExteriorCenter", Epicentre); ############################################################################## ## #O NonabelianExteriorSquare() ## ## <#GAPDoc Label="NonabelianExteriorSquare"> ## ## ## ## ## Computes the nonabelian exterior square G \wedge G ## of the group G, which for a finitely presented group is the ## derived subgroup of any Schur cover of G ## (see ). ## ## ## <#/GAPDoc> ## DeclareOperation("NonabelianExteriorSquare", [IsGroup]); ############################################################################## ## #O EpimorphismNonabelianExteriorSquare() ## ## <#GAPDoc Label="EpimorphismNonabelianExteriorSquare"> ## ## ## ## ## Computes the mapping ## G \wedge G \rightarrow G. ## The kernel of this mapping is equal to the Schur multiplier of G. ## ## ## <#/GAPDoc> ## DeclareOperation("EpimorphismNonabelianExteriorSquare", [IsGroup]); ############################################################################## ## #P IsCentralFactor() ## ## <#GAPDoc Label="IsCentralFactor"> ## ## ## ## ## This function determines if there exists a group H such that ## G is isomorphic to the quotient H/Z(H). ## A group with this property is called in literature capable. ## A group being capable is ## equivalent to the epicentre of G being trivial, ## see . ## ## ## <#/GAPDoc> ## DeclareProperty("IsCentralFactor", IsGroup); ############################################################################## ###########################END RFM############################################ ############################################################################## ## #F SchuMu(,

) ## ## ## ## ## ## returns epimorphism from p-part of multiplier.p-Sylow (note: This ## extension is not necessarily isomorphic to a Sylow subgroup of a ## Darstellungsgruppe!) onto p-Sylow, the ## kernel is the p-part of the multiplier. ## The implemented algorithm is based on section 7 in Derek Holt's paper. ## However we use some of the general homomorphism setup to avoid having to ## remember certain relations. ## ## ## DeclareGlobalFunction("SchuMu"); ############################################################################## ## #F CorestEval(,) ## ## ## ## ## ## evaluate corestriction mapping. ## FH is an homomorphism from a finitely presented group onto a finite ## group G. s an epimorphism onto a p-Sylow subgroup of G as obtained ## from SchuMu. ## This function evaluates the relators of the source of FH in the ## extension M_p.G. It returns a list whose entries are of the form ## [rel,val], where rel is a relator of G and val its evaluation as ## an element of M_p. ## ## ## DeclareGlobalFunction("CorestEval"); ############################################################################## ## #F RelatorFixedMultiplier(,

) ## ## ## ## ## ## Let hom an epimorphism from an fp group onto a finite group G. This ## function returns an epimorphism onto the p-Sylow subgroup of G, ## whose kernel is the largest quotient of the multiplier, that can lift ## hom to a larger quotient. (The source of this map thus is M_R(B) ## of .) ## ## ## DeclareGlobalFunction("RelatorFixedMultiplier"); ############################################################################# ## #E gap-4r6p5/lib/galois.gd0000644000175000017500000000627412172557252013512 0ustar billbill############################################################################# ## #W galois.gd GAP library Alexander Hulpke ## ## #Y Copyright (C) 2002 The GAP Group ## ## This file contains the declarations for the computation of Galois Groups. ## ############################################################################# ## #V InfoGalois ## ## ## ## ## ## is the info class for the Galois group recognition functions. ## ## ## DeclareInfoClass("InfoGalois"); ############################################################################# ## #F GaloisType([,]) ## ## <#GAPDoc Label="GaloisType"> ## ## ## ## ## Let f be an irreducible polynomial with rational coefficients. This ## function returns the type of Gal(f) ## (considered as a transitive permutation group of the roots of f). It ## returns a number i if Gal(f) is permutation isomorphic to ## TransitiveGroup(n,i) where n is the degree of f. ##

## Identification is performed by factoring ## appropriate Galois resolvents as proposed in . This function ## is provided for rational polynomials of degree up to 15. However, in some ## cases the required calculations become unfeasibly large. ##

## For a few polynomials of degree 14, a complete discrimination is not yet ## possible, as it would require computations, that are not feasible with ## current factoring methods. ##

## This function requires the transitive groups library to be installed (see ## ). ## ## ## <#/GAPDoc> ## DeclareAttribute("GaloisType",IsRationalFunction); ############################################################################# ## #F ProbabilityShapes() ## ## <#GAPDoc Label="ProbabilityShapes"> ## ## ## ## ## Let f be an irreducible polynomial with rational coefficients. This ## function returns a list of the most likely type(s) of Gal(f) ## (see ), based ## on factorization modulo a set of primes. ## It is very fast, but the result is only probabilistic. ##

## This function requires the transitive groups library to be installed (see ## ). ## f:=x^9-9*x^7+27*x^5-39*x^3+36*x-8;; ## gap> GaloisType(f); ## 25 ## gap> TransitiveGroup(9,25); ## [1/2.S(3)^3]3 ## gap> ProbabilityShapes(f); ## [ 25 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("ProbabilityShapes"); DeclareGlobalFunction("SumRootsPol"); DeclareGlobalFunction("ProductRootsPol"); DeclareGlobalFunction("Tschirnhausen"); DeclareGlobalFunction("TwoSeqPol"); DeclareGlobalFunction("GaloisSetResolvent"); DeclareGlobalFunction("GaloisDiffResolvent"); DeclareGlobalFunction("ParityPol"); ############################################################################# ## #E gap-4r6p5/lib/permdeco.gd0000644000175000017500000001026712172557254014031 0ustar billbill############################################################################# ## #W permdeco.gd GAP library Alexander Hulpke ## ## #Y Copyright (C) 2004 The GAP Group ## ## This file contains functions that deal with action on chief factors or ## composition factors and the representation of such groups in a nice way ## as permutation groups. ## ############################################################################# ## #F AutomorphismRepresentingGroup( , ) ## ## Let $G$ be a permutation group and a set of automorphisms of ## . This function returns a permutation group $H$, isomorphic to $G$, ## such that all the automorphisms in can be represented by ## conjugation of $H$ with elements of the symmetric group. It returns a ## list $[H2,\phi,a]$ where $\phi is the isomorphism $G\to H$, and $a$ a ## list of permutations corresponding to that induce the same ## automorphisms of $H$. Finally $H2=\left\langle H,a\right\rangle$. ## The algorithm may fail if is not almost simple. DeclareGlobalFunction("AutomorphismRepresentingGroup"); ############################################################################# ## #F EmbedAutomorphisms(,,,[,]) ## ## Suposet that $GT$ and $HT$ are isomorphic simple groups and $GT\le ## G\le\Aut(GT)$ and $HT\le H\le \Aut(HT)$. This function returns a new ## group $P$ isomorphic to a subgroup of $\Aut(GT)$ and monomorphisms ## $\phi\colon G\to P$ and $\psi\colon H\to P$ in the form of a list ## $[P,\phi,\psi]$. ## The size of the outer automorphism group of $T$ may be given in ## and will speed up the calculation. DeclareGlobalFunction("EmbedAutomorphisms"); ############################################################################# ## #F WreathActionChiefFactor( , , ) ## ## Suppose that $M/N$ is a chief factor of and $M/N$ is isomorphic to ## $T^n$ where $T$ is simple. Then the action of $G$ on $M/N$ embeds in ## $\Aut(T)\wr S_n$. This function creates this embedding. It returns ## a list $[W,\phi,A,T,n]$, where $T$ is the simple group, $A\ge T$ the group of ## automorphisms of $T$ induced (not necessarily the full automorphism ## group), $W=A\wr S_n$ and $\phi\colon G\to W$ the map embedding $G$ into ## $W$. DeclareGlobalFunction("WreathActionChiefFactor"); ############################################################################# ## #F PermliftSeries( ) ## ## This function constructs a descending series of normal subgroups of , ## starting with the radical (the largest solvable normal subgroup) of , ## such that the factors of subsequent subgroups in the series are ## elementary abelian. ## It returns a list of length 2. The first argument is the series, the ## second argument is either a List of (induced) Pcgs for the subgroups in ## the series (if such pcgs can be obtained cheaply as a byproduct of the ## way the series was obtained) or `false'. ## The option `limit' can be used to limit the orders of the solvable ## factors (if possible). ## ## This is considered an old function that will be superceded by ## FittingFreeLiftSetup DeclareGlobalFunction("PermliftSeries"); DeclareAttribute("StoredPermliftSeries",IsGroup); ############################################################################# ## #F EmbeddingWreathInWreath( ,,, ) ## ## Let $W=A\wr B$ and $W2=C\wr D$ be two wreath products with $B\le D$ ## (considering $B$ and $D$ as permutation groups) and ## $\colon A\to C$. This function returns a monomorphism from $W$ into ## $W2$, involving the copies of $C$ at position and at the following ## indices. DeclareGlobalFunction("EmbeddingWreathInWreath"); ############################################################################# ## #F EmbedFullAutomorphismWreath(,,,) ## ## Suppose that $T\le G\le A\le\Aut(T)$ and that $W=G\wr S$ with $S\le ## S_n$. This function calculates the wreath product $W2=\Aut(T)\wr S$ and ## the embedding. DeclareGlobalFunction("EmbedFullAutomorphismWreath"); ############################################################################# ## #E permdeco.gd . . . . . . . . . . . . . . . . . . . . . . . . . . ends here gap-4r6p5/lib/fitfree.gd0000644000175000017500000001330512172557252013651 0ustar billbill############################################################################# ## #W fitfree.gd GAP library Alexander Hulpke ## ## #Y Copyright (C) 2012 The GAP Group ## ## This file contains functions using the trivial-fitting paradigm. ## ############################################################################# ## #F CanComputeFittingFree( ) . . . . . TF approach is possible ## ## <#GAPDoc Label="CanComputeFittingFree"> ## ## ## ## ## This filter indicates whether algorithms using the TF-paradigm (Trivial ## Fitting) can be used for a group, that is whether a method for ## is available for grp. ## Note that this filter may change its value from false to ## true. ## ## ## <#/GAPDoc> ## DeclareFilter( "CanComputeFittingFree" ); # to satisfy method installation requirements InstallTrueMethod(IsFinite,CanComputeFittingFree); InstallTrueMethod(IsGroup,CanComputeFittingFree); InstallTrueMethod(CanComputeFittingFree, IsPermGroup); ############################################################################# ## #A FittingFreeLiftSetup( ) ## ## <#GAPDoc Label="FittingFreeLiftSetup"> ## ## ## ## ## for a finite group G, this returns a record with the following ## components: ## radical The solvable radical Rad(G). ## pcgs A pcgs for Rad(G) that refines a ## G-normal series ## with elementary abelian factors. ## depths ## A list of indices in the pcgs, indicating the G-normal subgroups in ## the series for the pcgs, including an entry for the trivial subgroup. ## pcisom An effective isomorphism from Rad(G) to a pc group ## factorhom A epimorphism from G onto G/Rad(G), ## the image group being ## represented in a way that decomposition into generators will work ## efficiently. In particular, it is possible to use ## to take the pre-image of elements ## in the image. For a subgroup U\le G, it is possible to apply ## to the homomorphism to obtain a ## corresponding homomorphism for U. ## ## The redundancy amongst the components is deliberate, as the redundant ## objects can be created at minimal extra cost and not doing so risks the ## creation of duplicate objects by user code later on. ## The record may hold other components that are germane to the recognition ## setup. These components may not be modified by user code. DeclareAttribute("FittingFreeLiftSetup",IsGroup); ############################################################################# ## #F FittingFreeSubgroupSetup( , ) ## ## <#GAPDoc Label="FittingFreeSubgroupSetup"> ## ## ## ## ## for a subgroup U of a finite group G, for which ## has been computed, this function ## computes a compatible setup for U. (This information is cached in ## U ## for further calculation later.) ## It returns a record with the following ## components: ## parentffs The record returned by ## for . ## rest A restriction of ## the factorhom for G to U, defined on generators of ## U. ## ker The kernel of this map. ## pcgs A pcgs for this kernel. ## serdepths ## For each depth step in the pcgs for the radical of , as stored in ## parentffs, this indicates the index in pcgs for U, ## at which this depth is achieved. ## ## The record may hold other components that are germane to the recognition ## setup. These components may not be modified by user code. DeclareGlobalFunction("FittingFreeSubgroupSetup"); # This attribute is used for groups treated by constructive recognition and # a composition tree. It is declared in the library such that the function # FittingFreeSubgroupSetup can maintain it. DeclareAttribute("RecogDecompinfoHomomorphism",IsMapping); ############################################################################# ## #F SubgroupByFittingFreeData( , , , ) ## ## <#GAPDoc Label="SubgroupByFittingFreeData"> ## ## ## ## ## For a finite group G, for which ## ffs has been computed, ## this function returns a subgroup U build from data compatible with ## ffs: U is the subgroup generated by gens and ## ipcgs. ## ipcgs is an induced Pcgs for U\cap Rad(G), with respect to ## the Pcgs stored in ffs. imgs are images of gens ## under ffs.factorhom. DeclareGlobalFunction("SubgroupByFittingFreeData"); ############################################################################# ## #A DirectFactorsFittingFreeSocle( ) ## ## <#GAPDoc Label="DirectFactorsFittingFreeSocle"> ## ## ## ## ## for a finite fitting-free group G, this function retuns a list of ## the direct factors of the socle of G. If G is not ## fitting-free then fail is returned. DeclareAttribute("DirectFactorsFittingFreeSocle",IsGroup); ############################################################################# ## #F HallViaRadical( , ) ## DeclareGlobalFunction("HallViaRadical"); gap-4r6p5/lib/grpchain.gi0000644000175000017500000007221112172557252014026 0ustar billbill############################################################################# ## #W grpchain.gi GAP Library Gene Cooperman #W and Scott Murray ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1999 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## Requires: transversal, rss (for ChainSubgroup only) ## Exports: Group _mutable_ attribute ChainSubgroup. This stores the ## next group down in the chain (ie. the structure is recursive) ## The ChainSubgroup should have an attribute Transversal, as ## described in transversal.[gd,gi] ## StrongGens(grp), returns in format: ## rec(level:=LEVEL, gens:=GENS, gensinv:=GENSINV, Group:=GROUP, ## lastOldGens:=OLD) ## and GENS and GENSINV are lists of lists of generators, ## and LEVEL is index of list for this level. ## OLD is a list recording the last generator that had been ## applied to all old points. ## Defines: Size, Random, IN, Enumerator, Iterator for ChainSubgroup ## Exports: TransversalOfChainSubgroup, CompleteChain, ExtendedSubgroup, ## Sift, SiftOneLevel, ChainSubgroupByXXX ## ## Note on strong generators: The data type for strong generators ## (currently a record) should be considered a work in progress. ## The current data type makes gptransv dependent on grpchain, ## which should not be the case. Also the current data type is inductive ## while all our other structures are recursive -- this is necessary for ## efficiency, although it should probably be hidden from the user to ## retain the desired level of flexibility in the code. In particular, ## this means that creating mixed chains (with different kinds of ## transversal), may have unpredictable results. ## ## ## For debugging only: ## NthChainSubgroup := function(G,n) if n = 0 then return G; elif HasChainSubgroup(G) then return NthChainSubgroup(ChainSubgroup(G),n-1); else Error("no chain subgroup"); fi; end; NthSchreierTransversalOfChainSubgroup := function(G,n) return TransversalOfChainSubgroup(NthChainSubgroup(G,n-1)); end; NthFundamentalOrbit := function(arg) local G, n; G := arg[1]; if Length(arg)>1 then n := arg[2]; else n := 1; fi; return TransversalOfChainSubgroup(NthChainSubgroup(G,n-1))!.HashTable!.KeyArray; end; NthSiftOneLevel := function(G,g,n) if n = 1 then return SiftOneLevel(G,g); elif HasChainSubgroup(G) then return NthSiftOneLevel(ChainSubgroup(G),SiftOneLevel(G,g),n-1); else Error("no chain subgroup"); fi; end; ## Returns list of pairs [transvsersalElt, groupInChain] ## where elt is in group SiftedWord := function(grp, elt) local word, elt2; word := []; while HasChainSubgroup(grp) do elt2 := TransversalElt(Transversal(ChainSubgroup(grp)),elt); if elt*elt2^(-1) <> SiftOneLevel(grp,elt) then Error("bad sift"); fi; Add( word, [ elt2, grp ] ); grp := ChainSubgroup(grp); elt := elt * elt2^(-1); od; Add(word,[elt,grp]); return word; end ; ## gdc - this is slow for something like NiceObj(GL(10,2)) ## and it still doesn't complete everything. ## BECAUSE IT DOES Extending complete stabilizer chain subgroup CompleteChain := function( G ) local size, oldSize, origG; origG := G; size := SizeOfChainOfGroup(G); repeat G := origG; oldSize := size; while HasChainSubgroup(G) do if IsTransvBySchreierTree(TransversalOfChainSubgroup(G)) then SetGeneratingSetIsComplete(G, true); CompleteSchreierTransversal(TransversalOfChainSubgroup( G ) ); fi; G := ChainSubgroup(G); od; size := SizeOfChainOfGroup(origG); Info( InfoChain, 2, "Completing chain from size ", oldSize, " to size ", size); until oldSize = size; end; ############################################################################# ############################################################################# ## ## General group utilities done via chains ## ############################################################################# ############################################################################# ############################################################################# ## #M ChainSubgroup( ) ## InstallMethod( ChainSubgroup, "for chain type groups", true, [ IsGroup and IsChainTypeGroup and HasChainSubgroup ], NICE_FLAGS, G -> G!.ChainSubgroup ); InstallMethod( ChainSubgroup, "for chain type groups", true, [ IsGroup and IsChainTypeGroup ], NICE_FLAGS, function( G ) if IsTrivial( G ) then SetIsTrivial( G, true ); Error( "Cannot compute chain subgroup of trivial group" ); # Else test IsAbelian(). It's cheap. elif IsFFEMatrixGroup(G) and (IsAbelian(G) or (HasIsNilpotentGroup(G) and IsNilpotentGroup(G)) or HasNilpotentClassTwoElement(G)) then MakeHomChain(G); else # Print("Warning: Monte-Carlo algorithm; chain may be incomplete\n"); RandomSchreierSims( G ); fi; return G!.ChainSubgroup; end ); InstallMethod( ChainSubgroup, "for chain type groups", true, [ IsGroup and IsFFEMatrixGroup and IsChainTypeGroup ], NICE_FLAGS+1, function(G) if IsTrivial(G) then SetIsTrivial(G,true); SetSize(G,1); Error("Group is trivial. It has no ChainSubgroup."); fi; if HasIsCyclic(G) and IsCyclic(G) and not HasSize(G) and Length(GeneratorsOfGroup(G)) = 1 then # GAP can leave this out. We need this info. SetIsCyclicWithSize( G, GeneratorsOfGroup(G)[1], Order(GeneratorsOfGroup(G)[1]) ); MakeHomChain(G); fi; if IsAbelian(G) then MakeHomChain(G); CompleteChain(G); # These are the two base cases: if not HasChainSubgroup(G) # and maybe we're in base case and ( (IsCyclic(G) and IsPGroup(G)) or IsQuotientToAdditiveGroup(G) ) then return TrivialSubgroup(G); else return ChainSubgroup(G); fi; elif (HasIsNilpotentGroup(G) and IsNilpotentGroup(G)) or CanFindNilpotentClassTwoElement(G) then return MakeHomChain(G); CompleteChain(G); # elif IsSolvable(G) then return MakeHomChain(G); CompleteChain(G); else TryNextMethod(); fi; end ); ############################################################################# ## #M IN( , ) ## InstallMethod( IN, "for chain type group", true, [ IsMultiplicativeElementWithInverse, IsGroup and IsChainTypeGroup ], NICE_FLAGS, function( g, G ) if IsTrivial(G) then return IsOne(g); fi; if not HasChainSubgroup( G ) then Info( InfoChain, 2, "Creating chain subgroup" ); ChainSubgroup( G ); fi; Info( InfoChain, 2, "Sifting to test membership" ); return Sift( G, g ) = One( G ); end ); ############################################################################# ## #M Size( ) ## InstallMethod( Size, "for chain type group", true, [ IsGroup and IsChainTypeGroup and IsTrivial ], NICE_FLAGS+10, # + 10 for matrix groups G -> 1 ); InstallMethod( Size, "for chain type group", true, [ IsGroup and IsChainTypeGroup ], NICE_FLAGS+10, # + 10 for matrix groups function( G ) # Note that in GAP4r1, IsTrivial() calls Size(). Don't use IsTrivial() if not HasIsTrivial(G) or IsTrivial(G) then if IsTrivial(G) then SetIsTrivial(G,true); return Size(G); else SetIsTrivial(G,false); fi; fi; if not HasChainSubgroup( G ) then Info( InfoChain, 2, "Creating chain subgroup" ); ChainSubgroup( G ); fi; return Size( TransversalOfChainSubgroup( G ) ) * Size( ChainSubgroup( G ) ); end ); ############################################################################# ## #M Random( ) ## InstallMethod( Random, "for chain type group", true, [ IsGroup and IsChainTypeGroup ], NICE_FLAGS, function( G ) if not HasChainSubgroup( G ) then Info( InfoChain, 2, "Creating chain subgroup" ); ChainSubgroup( G ); fi; return Random( TransversalOfChainSubgroup( G ) ) * Random( ChainSubgroup( G ) ); end ); InstallMethod( Random, "for trivial chain type group", true, [ IsGroup and IsChainTypeGroup and IsTrivial ], NICE_FLAGS, function( G ) return One( G ); end ); ############################################################################# ## #M Enumerator( ) ## InstallMethod( Enumerator, "for chain type group", true, [ IsGroup and IsChainTypeGroup ], NICE_FLAGS, function( G ) local newG; if not HasIsTrivial( G ) then SetIsTrivial( G, IsTrivial(G) ); if IsTrivial( G ) then return Enumerator(G); fi; fi; if not HasChainSubgroup( G ) then Info( InfoChain, 2, "Creating chain subgroup" ); ChainSubgroup( G ); fi; if IsTransvByTrivSubgrp( TransversalOfChainSubgroup( G ) ) then TryNextMethod(); return; newG := Group( GeneratorsOfGroup( G ) ); UseIsomorphismRelation( G, newG ); return Enumerator(newG); fi; return ListX( Enumerator( TransversalOfChainSubgroup( G ) ), Enumerator( ChainSubgroup( G ) ), PROD ); end ); InstallMethod( Enumerator, "for trivial chain type group", true, [ IsGroup and IsChainTypeGroup and IsTrivial ], NICE_FLAGS, function( G ) #base of recursion -- probably unnecessary return [ One( G ) ]; end ); ## still to write: Iterator ############################################################################# ############################################################################# ## ## General group with chain utilities ## ############################################################################# ############################################################################# ############################################################################# ## #M GeneratingSetIsComplete( ) ## InstallMethod( GeneratingSetIsComplete, "for group", true, [ IsGroup ], 0, G -> false ); #generating sets assumed incomplete unless set to true. Should be #replaced by verifier. ############################################################################# ## #M SiftOneLevel( , ) ## InstallMethod( SiftOneLevel, "for group with chain and element", true, [ IsGroup and HasChainSubgroup, IsAssociativeElement ], 0, function( G, g ) if HasTransversal( ChainSubgroup( G ) ) then Info( InfoChain, 3, "Sifting ", g ); return SiftOneLevel( TransversalOfChainSubgroup( G ), g ); else return fail; fi; end ); ############################################################################# ## #M Sift( , ) ## InstallMethod( Sift, "for group with chain and element", true, [ IsGroup and HasChainSubgroup, IsAssociativeElement ], 0, function( G, g ) local s; s := SiftOneLevel( G, g ); if s = fail then # base case for incomplete chain return g; fi; return Sift( ChainSubgroup( G ), s ); end ); InstallMethod( Sift, "for group without chain and element", true, [ IsGroup, IsAssociativeElement ], 0, function( G, g ) #base case of recursion return g; end ); ############################################################################# ## #F SizeOfChainOfGroup( <> ) ## ## If chain stops at non-trivial subgroup with HasSize() false, ## this will assume subgroup is trivial. This is useful, ## for programs that construct a chain, and wish to test the ## "current size" to see if the chain is complete. ## InstallGlobalFunction( SizeOfChainOfGroup, function( G ) if not HasChainSubgroup( G ) then # base case if HasSize(G) then return Size(G); #Gene: BasisOfHomCosetAddMatrixGroup(G) computes Size() of # additive group more efficiently. A method for Size() # of additive groups should be based on this. But this # was added after "feature freeze". elif IsAdditiveGroup(G) or IsQuotientToAdditiveGroup(G) then BasisOfHomCosetAddMatrixGroup(G); if HasSize(G) then return Size(G); else return 1; fi; else return 1; #Note: may be incorrect for incomplete chains fi; fi; return Size( TransversalOfChainSubgroup( G ) ) * SizeOfChainOfGroup( ChainSubgroup( G ) ); end ); ############################################################################# ## #F ChainStatistics( ) ## InstallGlobalFunction( ChainStatistics, function( G ) local stats, transv; stats := rec( Size := 1, TransversalSizes := [], SchreierTreeDepths := [], DepthThreshold := [], NumberSifted := [], basePoints := [] ); while HasChainSubgroup( G ) do transv := TransversalOfChainSubgroup( G ); stats.Size := stats.Size * Size( transv ); Add( stats.TransversalSizes, Size( transv ) ); Add( stats.NumberSifted, transv!.NumberSifted ); if IsTransvBySchreierTree( transv ) then Add( stats.SchreierTreeDepths, SchreierTreeDepth( transv ) ); Add( stats.DepthThreshold, transv!.DepthThreshold ); Add( stats.basePoints, BasePointOfSchreierTransversal( transv ) ); else Add( stats.SchreierTreeDepths, "not Schr. tree" ); Add( stats.DepthThreshold, "not Schr. tree" ); Add( stats.basePoints, "not Schr. tree" ); fi; G := ChainSubgroup( G ); od; return stats; end ); ############################################################################# ## #F TransversalOfChainSubgroup( ) ## InstallGlobalFunction( TransversalOfChainSubgroup, function( G ) if not HasChainSubgroup( G ) then Error("Sorry this group does not have a chain subgroup"); fi; return Transversal( ChainSubgroup( G ) ); end ); ############################################################################# ## #F HasChainHomomorphicImage( ) ## InstallGlobalFunction( HasChainHomomorphicImage, G -> HasChainSubgroup(G) and HasTransversal(ChainSubgroup(G)) and IsBound(TransversalOfChainSubgroup(G)!.Homomorphism) and HasImagesSource(Homomorphism(TransversalOfChainSubgroup(G))) ); ############################################################################# ## #F ChainHomomorphicImage( ) ## InstallGlobalFunction( ChainHomomorphicImage, G -> Image(Homomorphism(TransversalOfChainSubgroup(G))) ); ############################################################################# ############################################################################# ## ## Stabiliser chain utilities ## ############################################################################# ############################################################################# ############################################################################# ## #F StrongGens( ) ## ## gdc - This should be converted into a method. ## It should then operate on a group or on a IsTransvBySchreierTree ## StrongGens will be a list of lists. ## InstallGlobalFunction( StrongGens, function( G ) if not IsBound( G!.strongGens ) then if IsIdenticalObj( G, Parent(G) ) then G!.strongGens := rec( Group := G, level := 1, gens := [ List( GeneratorsOfGroup(G) ) ], gensinv := [ List( GeneratorsOfGroup(G), INV ) ], lastOldGens := [0] ); else G!.strongGens := StrongGens(Parent(G)); Add( G!.strongGens.gens, [] ); Add( G!.strongGens.gensinv, [] ); G!.strongGens := rec( Group := G, level := Length( G!.strongGens.gens), gens := G!.strongGens.gens, gensinv := G!.strongGens.gensinv, lastOldGens := List(G!.strongGens.gens, i->0) ); fi; fi; return G!.strongGens; end ); ############################################################################# ## #F ChainSubgroupByStabiliser( , , ) ## InstallGlobalFunction( ChainSubgroupByStabiliser, function( G, basePoint, Action ) local subgp, ss; Info( InfoChain, 1, "Making stabiliser chain subgroup for basepoint ", basePoint ); subgp := TrivialSubgroup( G ); ss := SchreierTransversal( basePoint, Action, # computed from Parent(subgp) StrongGens(subgp) ); if Length( GeneratorsOfGroup(G) ) > 0 then ExtendSchreierTransversal( ss, GeneratorsOfGroup( G ) ); fi; SetTransversal( subgp, ss ); SetChainSubgroup( G, subgp ); return subgp; end ); ############################################################################# ## #M BaseOfGroup( ) ## InstallMethod( BaseOfGroup, "for group with chain", true, [ IsGroup and HasChainSubgroup ], 40, function( G ) return Concatenation( [ BasePointOfSchreierTransversal( TransversalOfChainSubgroup( G ) ) ], BaseOfGroup( ChainSubgroup( G ) ) ); end ); InstallMethod( BaseOfGroup, "for trivial group", true, [ IsTrivial and IsGroup and IsInChain ], 40, function( G ) #base case of recursion return [ ]; end ); ## gdc - These are experimental. ############################################################################# ## #M StabChainMutable( ) ## #InstallMethod( StabChainMutable, "Stab chain via chain subgroup", true, # [ IsPermGroup and IsChainTypeGroup and IsStabChainViaChainSubgroup], 0, # function(G) # RandomSchreierSims(G); # StabChainBaseStrongGenerators(Base(G), StrongGens(G),One(G)); # return StabChain(G); # end ); ############################################################################# ## #M StabChainOp( ) ## #InstallMethod( StabChainOp, "Stab chain via chain subgroup", true, # [ IsPermGroup and IsChainTypeGroup and IsStabChainViaChainSubgroup, # IsRecord], 0, # function(G,opt) return StabChainMutable(G); end ); ############################################################################# ## #M ExtendedGroup( , ) ## ## gdc - These functions should really call ExtendTransversal() ## and let ExtendTransversal() and ExtendTransversalOrbitGenerators() ## be a method for different kinds ## of transversals. For example, given an initial homomorphism transversal ## for a block action, why not extend such a transversal by taking ## the homomorphic image of the element, and then taking a stabilizer ## chain through the action on blocks, first.? ## InstallMethod( ExtendedGroup, "for group in chain", true, [ IsGroup and IsInChain, IsAssociativeElement ], 0, function( G, g ) local newG; Info( InfoChain, 1, "Extending stabiliser chain subgroup" ); newG := Group( Concatenation( GeneratorsOfGroup( G ), [g] ) ); if HasChainSubgroup( G ) then SetChainSubgroup( newG , ChainSubgroup( G ) ); if HasTransversal( ChainSubgroup( G ) ) and IsTransvBySchreierTree( TransversalOfChainSubgroup( newG ) ) then ExtendSchreierTransversal( TransversalOfChainSubgroup( newG ), [g] ); fi; fi; if HasTransversal( G ) then SetTransversal( newG, Transversal( G ) ); fi; # Really, want to transfer info from G to newG via SupersetRelation UseSubsetRelation( newG, G ); return newG; end ); InstallMethod( ExtendedGroup, "for group in chain", true, [ IsGroup and IsInChain and GeneratingSetIsComplete, IsAssociativeElement ], 0, function( G, g ) Info( InfoChain, 1, "Extending complete stabiliser chain subgroup" ); if HasChainSubgroup( G ) and HasTransversal( ChainSubgroup( G ) ) and IsTransvBySchreierTree( TransversalOfChainSubgroup( G ) ) then ExtendSchreierTransversal( TransversalOfChainSubgroup( G ), [g] ); # To make sure strong generators go up the chain, # in case we want to make a shallower tree. fi; return G; end ); ############################################################################# ## #M OrbitGeneratorsOfGroup( ) ## InstallMethod( OrbitGeneratorsOfGroup, "for groups with chain", true, [ IsGroup and HasChainSubgroup ], 0, function( G ) return Union( OrbitGenerators( TransversalOfChainSubgroup( G ) ), OrbitGeneratorsOfGroup( ChainSubgroup ( G ) ) ); end ); InstallMethod( OrbitGeneratorsOfGroup, "for trivial groups", true, [ IsGroup and IsTrivial ], 0, function( G ) return []; # base of recursion end ); ############################################################################# ############################################################################# ## ## Hom coset chains ## ############################################################################# ############################################################################# ############################################################################# ## #F ChainSubgroupByHomomorphism( ) ## InstallGlobalFunction( ChainSubgroupByHomomorphism, function( hom ) local transv, quotient; Info( InfoChain, 1, "Making homomorphism chain subgroup"); Info( InfoChain, 3, " for ", hom ); transv := HomTransversal( hom ); if HasKernelOfMultiplicativeGeneralMapping( hom ) then SetGeneratingSetIsComplete( KernelOfMultiplicativeGeneralMapping(hom), true ); SetTransversal( KernelOfMultiplicativeGeneralMapping(hom), transv ); SetChainSubgroup( Source(hom), KernelOfMultiplicativeGeneralMapping(hom) ); # These Use...Relation may be redundant. Don't know if GAP does it. UseSubsetRelation( Source(hom), KernelOfMultiplicativeGeneralMapping(hom) ); UseFactorRelation( Source(hom), KernelOfMultiplicativeGeneralMapping(hom), Image(hom) ); quotient := QuotientGroup( transv ); UseIsomorphismRelation( Image(hom), quotient ); else # else kernel has incomplete generating set SetChainSubgroup( Source(hom), SubgroupNC(Source(hom), []) ); SetTransversal( ChainSubgroup(Source(hom)), transv ); quotient := QuotientGroup( transv ); fi; return ChainSubgroup( Source( hom ) ); end ); ############################################################################# ## #F ChainSubgroupByProjectionFunction( <> ) ## InstallGlobalFunction( ChainSubgroupByProjectionFunction, function( G, kernelSubgp, imgSubgp, projFnc ) local hom; Info( InfoChain, 1, "Making homomorphism chain subgroup for projection", projFnc ); hom := GroupHomomorphismByFunction( G, imgSubgp, projFnc, g->g ); SetImagesSource( hom, imgSubgp ); if kernelSubgp <> fail then SetKernelOfMultiplicativeGeneralMapping( hom, kernelSubgp ); fi; #PERFORMANCE BUG: GAP doesn't know to use projFnc to quickly compute image # in ImageElm(hom, elt); # It lost projFnc. # It prefers to use NiceMonomorphism instead of DirectProductInfo return ChainSubgroupByHomomorphism( hom ); end ); ############################################################################# ## #F QuotientGroupByChainHomomorphicImage( [, ] ) ## ## This function creates quotient groups of quotient groups. ## InstallGlobalFunction( QuotientGroupByChainHomomorphicImage, function( arg ) local quo, quo2, hom, hom1, hom2, kernel; quo := arg[1]; if Length(arg) > 1 then quo2 := arg[2]; fi; # Homomorphic image of quo if not IsHomQuotientGroup(quo) then Error("group must be quotient group"); fi; if not HasChainHomomorphicImage(quo) and Length(arg) = 1 then Error("no homomorphic image"); fi; # compose homomorphisms; # Note Source(Hom(HomIm(quo)) = Im(Hom(quo)) by construction of quo # Composition: Needed so GAP won't complain about compatibility. hom1 := Homomorphism(quo); if Length(arg) > 1 then hom2 := Homomorphism(quo2); else hom2 := Homomorphism(TransversalOfChainSubgroup(quo)); fi; hom := GroupHomomorphismByFunction( Source(hom1), Range(hom2), g->hom2!.fun(hom1!.fun(g)) ); if HasImagesSource( hom2 ) then SetImagesSource( hom, ImagesSource(hom2) ); fi; quo := QuotientGroupByHomomorphism( hom ); if HasImagesSource( hom2 ) and HasGeneratorOfCyclicGroup(ImagesSource(hom2)) then SetGeneratorOfCyclicGroup(quo, HomCoset(hom,SourceElt(GeneratorOfCyclicGroup(ImagesSource(hom2))))); fi; return quo; end ); ############################################################################# ############################################################################# ## ## Direct sum chain utilities ## ############################################################################# ############################################################################# ############################################################################# ## #F ChainSubgroupByDirectProduct( , ) ## InstallGlobalFunction( ChainSubgroupByDirectProduct, function( proj, inj ) local transv, quotient; ## I probably need more Use commands here Info( InfoChain, 1, "Making direct sum chain subgroup for projection", proj ); transv := DirProdTransversal( proj, inj ); if HasKernelOfMultiplicativeGeneralMapping( proj ) then SetGeneratingSetIsComplete( KernelOfMultiplicativeGeneralMapping( proj ), true ); SetTransversal( KernelOfMultiplicativeGeneralMapping( proj ), transv ); SetChainSubgroup( Source( proj ), KernelOfMultiplicativeGeneralMapping( proj ) ); # These Use...Relation may be redundant. Don't know if GAP does it. UseSubsetRelation( Source( proj ), KernelOfMultiplicativeGeneralMapping( proj ) ); UseFactorRelation( Source( proj ), KernelOfMultiplicativeGeneralMapping( proj ), Image( proj ) ); elif HasImagesSource( inj ) then SetGeneratingSetIsComplete( Image( inj ), true ); SetTransversal( Image( inj ), transv ); SetChainSubgroup( Source( proj ), Image( inj ) ); # These Use...Relation may be redundant. Don't know if GAP does it. UseSubsetRelation( Source( proj ), Image( inj ) ); else # else kernel has incomplete generating set SetChainSubgroup( Source( proj ), SubgroupNC(Source( proj ), []) ); SetTransversal( ChainSubgroup(Source( proj )), transv ); fi; return ChainSubgroup( Source( proj ) ); end ); ############################################################################# ## #F ChainSubgroupByPSubgroupOfAbelian( ,

) ## InstallGlobalFunction( ChainSubgroupByPSubgroupOfAbelian, function( G, p ) local PPart, imgGroup, kerGroup, proj, inj; PPart := function( g ) local o; o := Order(g); while o mod p = 0 do o := o/p; od; return g ^ o; end; imgGroup := Group( List( GeneratorsOfGroup( G ), PPart ) ); kerGroup := Group( List( GeneratorsOfGroup( G ), g -> g * PPart(g)^(-1) ) ); proj := GroupHomomorphismByFunction( G, imgGroup, x -> PPart( x ) ); SetImagesSource( proj, imgGroup ); SetKernelOfMultiplicativeGeneralMapping( proj, kerGroup ); inj := GroupHomomorphismByFunction( imgGroup, G, x -> x ); SetImagesSource( proj, imgGroup ); SetKernelOfMultiplicativeGeneralMapping( inj, TrivialSubgroup( imgGroup ) ); return ChainSubgroupByDirectProduct( proj, inj ); end ); ############################################################################# ############################################################################# ## ## Trivial subgroup chain utilities ## ############################################################################# ############################################################################# ############################################################################# ## #F ChainSubgroupByTrivialSubgroup( ) ## InstallGlobalFunction( ChainSubgroupByTrivialSubgroup, function( G ) local triv; Info( InfoChain, 1, "Making trivial chain subgroup" ); triv := TrivialSubgroup( G ); SetChainSubgroup( G, triv ); SetTransversal( triv, TransversalByTrivial( G ) ); SetGeneratingSetIsComplete( triv, true ); return triv; end ); ############################################################################# ############################################################################# ## ## Sift function chain utilities ## ############################################################################# ############################################################################# ############################################################################# ## #F ChainSubgroupBySiftFunction( , , ) ## InstallGlobalFunction( ChainSubgroupBySiftFunction, function( G, subgroup, siftFnc ) Info( InfoChain, 1, "Making sift function subgroup" ); SetChainSubgroup( G, subgroup ); SetTransversal( subgroup, TransversalBySiftFunction( G, subgroup, siftFnc ) ); if HasSize(G) and HasSize(subgroup) then Transversal(subgroup)!.Size := Size(G)/Size(subgroup); fi; # gdc - If you set this false, you can't set it true later. # SetGeneratingSetIsComplete( subgroup, false ); return subgroup; end ); #E gap-4r6p5/lib/mat8bit.gi0000644000175000017500000007007712172557252013613 0ustar billbill############################################################################# ## #W mat8bit.gi GAP Library Steve Linton ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file is a first stab at a special posobj-based representation ## for 8 bit matrices, mimicking the one for GF(2) ## ## all rows must be the same length and written over the same field ## ############################################################################# ## #V TYPES_MAT8BIT . . . . . . . prepared types for compressed GF(q) matrices ## ## A length 2 list of length 257 lists. TYPES_MAT8BIT[0][q] will be the type ## of mutable matrices over GF(q), TYPES_MAT8BIT[1][q] is the type of ## immutable matrices. The 257th position is bound to 1 to stop the lists ## shrinking. ## ## It may later accessed directly by the kernel, so the format cannot be changed ## without changing the kernel. ## InstallValue(TYPES_MAT8BIT , [[],[]]); TYPES_MAT8BIT[1][257] := 1; TYPES_MAT8BIT[2][257] := 1; ############################################################################# ## #F TYPE_MAT8BIT( , ) . . computes type of compressed GF(q) matrices ## ## Normally called by the kernel, caches results in TYPES_MAT8BIT, ## which is directly accessed by the kernel ## InstallGlobalFunction(TYPE_MAT8BIT, function( q, mut) local col,filts; if mut then col := 1; else col := 2; fi; if not IsBound(TYPES_MAT8BIT[col][q]) then filts := IsHomogeneousList and IsListDefault and IsCopyable and Is8BitMatrixRep and IsSmallList and IsOrdinaryMatrix and IsRingElementTable and IsNoImmediateMethodsObject and HasIsRectangularTable and IsRectangularTable; if mut then filts := filts and IsMutable; fi; TYPES_MAT8BIT[col][q] := NewType(CollectionsFamily(FamilyObj(GF(q))),filts); fi; return TYPES_MAT8BIT[col][q]; end); ############################################################################# ## #M Length( ) ## InstallOtherMethod( Length, "For a compressed MatFFE", true, [IsList and Is8BitMatrixRep], 0, m->m![1]); ############################################################################# ## #M [ ] ## InstallOtherMethod( \[\], "For a compressed MatFFE", true, [IsList and Is8BitMatrixRep, IsPosInt], 0, function(m,i) return m![i+1]; end); ############################################################################# ## #M [ ] := ## ## This may involve turning into a plain list, if does ## not lie in the appropriate field. ## InstallOtherMethod( \[\]\:\=, "For a compressed MatFE", true, [IsMutable and IsList and Is8BitMatrixRep, IsPosInt, IsObject], 0, ASS_MAT8BIT ); ############################################################################# ## #M Unbind( [ ] ) ## ## Unless the last position is being unbound, this will result in ## turning into a plain list ## InstallOtherMethod( Unbind\[\], "For a compressed MatFFE", true, [IsMutable and IsList and Is8BitMatrixRep, IsPosInt], 0, function(m,p) if p = 1 or p <> m![1] then PLAIN_MAT8BIT(m); Unbind(m[p]); else m![1] := p-1; Unbind(m![p+1]); fi; end); ############################################################################# ## #M ViewObj( ) ## ## Up to 25 entries, GF(q) matrices are viewed in full, over that a ## description is printed ## InstallMethod( ViewObj, "For a compressed MatFFE", true, [Is8BitMatrixRep and IsSmallList], 0, function( m ) local r,c; r := m![1]; c := LEN_VEC8BIT(m![2]); if r*c > 25 then Print("< "); if not IsMutable(m) then Print("im"); fi; Print("mutable compressed matrix ",r,"x",c," over GF(",Q_VEC8BIT(m![2]),") >"); else PrintObj(m); fi; end); ############################################################################# ## #M PrintObj( ) ## ## Same method as for lists in internal rep. ## InstallMethod( PrintObj, "For a compressed MatFFE", true, [Is8BitMatrixRep and IsSmallList], 0, function( mat ) local i,l; Print("\>\>[ \>\>"); l := mat![1]; if l <> 0 then PrintObj(mat![2]); for i in [2..l] do Print("\<,\< \>\>"); PrintObj(mat![i+1]); od; fi; Print(" \<\<\<\<]"); end); ############################################################################# ## #M ShallowCopy() ## ## InstallMethod(ShallowCopy, "For a compressed MatFFE", true, [Is8BitMatrixRep and IsSmallList], 0, function(m) local c,i,l; l := m![1]; c := [l]; for i in [2..l+1] do c[i] := m![i]; od; Objectify(TYPE_MAT8BIT(Q_VEC8BIT(m![2]), true),c); return c; end ); ############################################################################# ## #M PositionCanonical( , ) ## InstallMethod( PositionCanonical, "for 8bit matrices lists, fall back on `Position'", true, # the list may be non-homogeneous. [ IsList and Is8BitMatrixRep, IsObject ], 0, function( list, obj ) return Position( list, obj, 0 ); end ); ############################################################################# ## #M + ## InstallMethod( \+, "For two 8 bit matrices in same characteristic", IsIdenticalObj, [IsMatrix and Is8BitMatrixRep, IsMatrix and Is8BitMatrixRep], 0, SUM_MAT8BIT_MAT8BIT ); ############################################################################# ## #M - ## InstallMethod( \-, "For two 8 bit matrices in same characteristic", IsIdenticalObj, [IsMatrix and Is8BitMatrixRep, IsMatrix and Is8BitMatrixRep], 0, DIFF_MAT8BIT_MAT8BIT ); ############################################################################# ## #M `PlainListCopyOp( ) ## ## Make the matrix into a plain list ## InstallMethod( PlainListCopyOp, "For an 8 bit vector", true, [IsSmallList and Is8BitMatrixRep], 0, function (m) PLAIN_MAT8BIT(m); return m; end); ############################################################################# ## #M ELM0_LIST( ) ## ## alternative element access interface, returns fail when unbound ## InstallMethod(ELM0_LIST, "For an 8 bit matrix", true, [IsList and Is8BitMatrixRep, IsPosInt], 0, function(m,p) if p > m![1] then return fail; fi; return m![p+1]; end); ############################################################################# ## #M ConvertToMatrixRepNC( , [, | ]) ## InstallGlobalFunction(ConvertToMatrixRep, function( arg ) local m,qs, v, q, givenq, q1, LeastCommonPower, lens; LeastCommonPower := function(qs) local p, d, x, i; if Length(qs) = 0 then return fail; fi; x := Z(qs[1]); p := Characteristic(x); d := DegreeFFE(x); for i in [2..Length(qs)] do x := Z(qs[i]); if p <> Characteristic(x) then return fail; fi; d := Lcm(d, DegreeFFE(x)); od; return p^d; end; qs := []; m := arg[1]; if Length(arg) > 1 then q1 := arg[2]; if not IsInt(q1) then if IsField(q1) then if Characteristic(q1) = 0 then return fail; fi; q1 := Size(q1); else return; # not a field -- exit fi; fi; givenq := true; Add(qs,q1); else givenq := false; fi; if Length(m) = 0 then if givenq then return q1; else return fail; fi; fi; # # If we are already compressed, then our rows are certainly # locked, so we will not be able to change representation # if Is8BitMatrixRep(m) then q := Q_VEC8BIT(m![2]); if not givenq or q = q1 then return q; else return fail; fi; fi; if IsGF2MatrixRep(m) then if not givenq or q1 = 2 then return 2; else return fail; fi; fi; # # Pass 1, get all rows compressed, and find out what fields we have # # mut := false; lens := []; for v in m do if IsGF2VectorRep(v) then AddSet(qs,2); elif Is8BitVectorRep(v) then AddSet(qs,Q_VEC8BIT(v)); elif givenq then AddSet(qs,ConvertToVectorRepNC(v,q1)); else AddSet(qs,ConvertToVectorRepNC(v)); fi; AddSet(lens, Length(v)); # mut := mut or IsMutable(v); od; # # We may know that there is no common field # or that we can't win for some other reason # if # mut or Length(lens) > 1 or lens[1] = 0 or fail in qs or true in qs then return fail; fi; # # or it may be easy # if Length(qs) = 1 then q := qs[1]; else # # Now work out the common field # q := LeastCommonPower(qs); if q = fail then return fail; fi; if givenq and q1 <> q then Error("ConvertTo8BitMatrixRep( , ): not all entries of written over "); fi; # # Now try and rewrite all the rows over this field # this may fail if some rows are locked over a smaller field # for v in m do if q <> ConvertToVectorRepNC(v,q) then return fail; fi; od; fi; if q <= 256 then ConvertToMatrixRepNC(m,q); fi; return q; end); InstallGlobalFunction(ConvertToMatrixRepNC, function(arg) local v, m, q, result; if Length(arg) = 1 then return ConvertToMatrixRep(arg[1]); else m := arg[1]; q := arg[2]; fi; if Length(m)=0 then return ConvertToMatrixRep(m,q); fi; if not IsInt(q) then q := Size(q); fi; if Is8BitMatrixRep(m) then return Q_VEC8BIT(m[1]); fi; if IsGF2MatrixRep(m) then return 2; fi; for v in m do result := ConvertToVectorRepNC(v,q); if result <> q then Error("ConvertToMatrixRep: Failed to convert a row"); fi; od; if q = 2 then CONV_GF2MAT(m); elif q <= 256 then CONV_MAT8BIT(m, q); fi; return q; end); ############################################################################# ## #M * ## InstallMethod( \*, "8 bit vector * 8 bit matrix", IsElmsColls, [ Is8BitVectorRep and IsRowVector and IsRingElementList, Is8BitMatrixRep and IsMatrix ], 0, PROD_VEC8BIT_MAT8BIT); ############################################################################# ## #M * ## InstallMethod( \*, "8 bit matrix * 8 bit vector", IsCollsElms, [ Is8BitMatrixRep and IsMatrix, Is8BitVectorRep and IsRowVector and IsRingElementList ], 0, PROD_MAT8BIT_VEC8BIT); ############################################################################# ## #M * ## InstallMethod( \*, "8 bit matrix * 8 bit matrix", IsIdenticalObj, [ Is8BitMatrixRep and IsMatrix, Is8BitMatrixRep and IsMatrix ], 0, PROD_MAT8BIT_MAT8BIT); ############################################################################# ## #M * ## InstallMethod( \*, "scalar * 8 bit matrix", IsElmsCollColls, [ IsFFE, Is8BitMatrixRep and IsMatrix ], 0, function(s,m) local q,i,l,r,pv; q := Q_VEC8BIT(m![2]); if not s in GF(q) then TryNextMethod(); fi; l := m![1]; r := [l]; for i in [2..l+1] do pv := s*m![i]; SetFilterObj(pv, IsLockedRepresentationVector); r[i] := pv; od; Objectify(TYPE_MAT8BIT(q, IsMutable(m)),r); return r; end); ############################################################################# ## #M * ## InstallMethod( \*, "scalar * 8 bit matrix", IsCollCollsElms, [ Is8BitMatrixRep and IsMatrix, IsFFE ], 0, function(m,s) local q,i,l,r,pv; q := Q_VEC8BIT(m![2]); if not s in GF(q) then TryNextMethod(); fi; l := m![1]; r := [l]; for i in [2..l+1] do pv := m![i]*s; SetFilterObj(pv, IsLockedRepresentationVector); r[i] := pv; od; Objectify(TYPE_MAT8BIT(q, IsMutable(m)),r); return r; end); ############################################################################# ## #M Additive Inverse ## InstallMethod(AdditiveInverseMutable, "8 bit matrix", true, [Is8BitMatrixRep and IsMatrix and IsAdditiveElementWithZero and IsSmallList ], 0, function(mat) local neg,i,negv; neg := [mat![1]]; for i in [2..mat![1]+1] do negv := AdditiveInverseMutable(mat![i]); SetFilterObj(negv, IsLockedRepresentationVector); neg[i] := negv; od; Objectify(TYPE_MAT8BIT(Q_VEC8BIT(mat![2]),true), neg); return neg; end); InstallMethod(AdditiveInverseImmutable, "8 bit matrix", true, [Is8BitMatrixRep and IsMatrix and IsAdditiveElementWithZero and IsSmallList ], 0, function(mat) local neg,i,negv; neg := [mat![1]]; for i in [2..mat![1]+1] do negv := AdditiveInverseImmutable(mat![i]); SetFilterObj(negv, IsLockedRepresentationVector); neg[i] := negv; od; Objectify(TYPE_MAT8BIT(Q_VEC8BIT(mat![2]),false), neg); return neg; end); InstallMethod(AdditiveInverseSameMutability, "8 bit matrix", true, [Is8BitMatrixRep and IsMatrix and IsAdditiveElementWithZero and IsSmallList ], 0, function(mat) local neg,i,negv; neg := [mat![1]]; for i in [2..mat![1]+1] do negv := AdditiveInverseSameMutability(mat![i]); SetFilterObj(negv, IsLockedRepresentationVector); neg[i] := negv; od; if IsMutable(mat) then Objectify(TYPE_MAT8BIT(Q_VEC8BIT(mat![2]),true), neg); else Objectify(TYPE_MAT8BIT(Q_VEC8BIT(mat![2]),false), neg); fi; return neg; end); ############################################################################# ## #M Zero InstallMethod( ZeroMutable, "8 bit matrix", true, [Is8BitMatrixRep and IsMatrix and IsAdditiveElementWithZero and IsSmallList ], 0, function(mat) local z, i,zv; z := [mat![1]]; for i in [2..mat![1]+1] do zv := ZERO_VEC8BIT(mat![i]); SetFilterObj(zv, IsLockedRepresentationVector); z[i] := zv; od; Objectify(TYPE_MAT8BIT(Q_VEC8BIT(mat![2]),true), z); return z; end); InstallMethod( ZeroImmutable, "8 bit matrix", true, [Is8BitMatrixRep and IsMatrix and IsAdditiveElementWithZero and IsSmallList ], 0, function(mat) local z, i,zv; z := [mat![1]]; zv := ZERO_VEC8BIT(mat![2]); SetFilterObj(zv, IsLockedRepresentationVector); MakeImmutable(zv); for i in [2..mat![1]+1] do z[i] := zv; od; Objectify(TYPE_MAT8BIT(Q_VEC8BIT(mat![2]),false), z); return z; end); InstallMethod( ZeroSameMutability, "8 bit matrix", true, [Is8BitMatrixRep and IsMatrix and IsAdditiveElementWithZero and IsSmallList ], 0, function(mat) local z, i,zv; z := [mat![1]]; if not IsMutable(mat![2]) then zv := ZERO_VEC8BIT(mat![2]); SetFilterObj(zv, IsLockedRepresentationVector); MakeImmutable(zv); for i in [2..mat![1]+1] do z[i] := zv; od; else for i in [2..mat![1]+1] do zv := ZERO_VEC8BIT(mat![i]); SetFilterObj(zv,IsLockedRepresentationVector); z[i] := zv; od; fi; if IsMutable(mat) then Objectify(TYPE_MAT8BIT(Q_VEC8BIT(mat![2]),true), z); else Objectify(TYPE_MAT8BIT(Q_VEC8BIT(mat![2]),false), z); fi; return z; end); ############################################################################# ## #M InverseOp() ## InstallMethod( InverseOp, "8 bit matrix", true, [Is8BitMatrixRep and IsMatrix and IsMultiplicativeElementWithInverse # the following are banalities, but they are required to get the # ranking right and IsOrdinaryMatrix and IsSmallList and IsCommutativeElementCollColl and IsRingElementTable and IsFFECollColl ], 0, INV_MAT8BIT_MUTABLE); ############################################################################# ## #M ^-1 ## InstallMethod( InverseSameMutability, "8 bit matrix", true, [Is8BitMatrixRep and IsMatrix and IsMultiplicativeElementWithInverse # the following are banalities, but they are required to get the # ranking right and IsOrdinaryMatrix and IsSmallList and IsCommutativeElementCollColl and IsRingElementTable and IsFFECollColl ], 0, INV_MAT8BIT_SAME_MUTABILITY); ############################################################################# ## #M ^0 ## InstallMethod( OneSameMutability, "8 bit matrix", true, [Is8BitMatrixRep and IsMatrix and IsMultiplicativeElementWithInverse # the following are banalities, but they are required to get the # ranking right and IsOrdinaryMatrix and IsSmallList and IsCommutativeElementCollColl and IsRingElementTable and IsFFECollColl ], 0, function(m) local v, o, one, i, w; v := ZeroOp(m![2]); o := []; one := Z(Q_VEC8BIT(v))^0; for i in [1..m![1]] do w := ShallowCopy(v); w[i] := one; Add(o,w); od; if not IsMutable(m![2]) then for i in [1..m![1]] do MakeImmutable(o[i]); od; fi; if not IsMutable(m) then MakeImmutable(o); fi; ConvertToMatrixRepNC(o, Q_VEC8BIT(v)); return o; end); InstallMethod( OneMutable, "8 bit matrix", true, [Is8BitMatrixRep and IsMatrix and IsMultiplicativeElementWithInverse # the following are banalities, but they are required to get the # ranking right and IsOrdinaryMatrix and IsSmallList and IsCommutativeElementCollColl and IsRingElementTable and IsFFECollColl ], 0, function(m) local v, o, one, i, w; v := ZeroOp(m![2]); o := []; one := Z(Q_VEC8BIT(v))^0; for i in [1..m![1]] do w := ShallowCopy(v); w[i] := one; Add(o,w); od; ConvertToMatrixRepNC(o, Q_VEC8BIT(v)); return o; end); ############################################################################# ## #M One() -- always immutable ## InstallMethod( One, "8 bit matrix", true, [Is8BitMatrixRep and IsMatrix and IsMultiplicativeElementWithInverse # the following are banalities, but they are required to get the # ranking right and IsOrdinaryMatrix and IsSmallList and IsCommutativeElementCollColl and IsRingElementTable and IsFFECollColl ], 0, function(m) local o; o := OneOp(m); MakeImmutable(o); ConvertToMatrixRepNC(o, Q_VEC8BIT(m![2])); return o; end ); ############################################################################# ## #F RepresentationsOfMatrix( ) ## ## InstallGlobalFunction( RepresentationsOfMatrix, function( m ) if not IsRowVector(m) then Print("Argument is not a matrix or vector\n"); fi; if IsMutable(m) then Print("Mutable "); else Print("Immutable "); fi; if not IsMatrix(m) then if IsMutable(m) then Print("Mutable "); else Print("Immutable "); fi; Print("Vector: "); if IsGF2VectorRep(m) then Print(" compressed over GF(2) "); elif Is8BitVectorRep(m) then Print(" compressed over GF(",Q_VEC8BIT(m),") "); elif IsPlistRep(m) then Print(" plain list, tnum: ",TNUM_OBJ(m)," "); if TNUM_OBJ_INT(m) in [54,55] then Print("known to be vecffe over GF(",CHAR_FFE_DEFAULT(m[1]),"^", DEGREE_FFE_DEFAULT(m[1]),") "); elif TNUM_OBJ_INT(m) in [48..53] then Print("known to be vector of cyclotomics "); else Print("TNUM: ",TNUM_OBJ(m), " "); fi; else Print(" not a compressed or plain list, representations: ", RepresentationsOfObject(m)," "); fi; if IsLockedRepresentationVector(m) then Print("locked\n"); else Print("unlocked\n"); fi; return; fi; if IsMutable(m) then if ForAll(m, IsMutable) then Print(" with mutable rows "); elif not ForAny(m, IsMutable) then Print(" with immutable rows "); else Print(" with mixed mutability rows!! "); fi; fi; if IsGF2MatrixRep(m) then Print(" Compressed GF2 representation "); elif Is8BitMatrixRep(m) then Print(" Compressed 8 bit rep over GF(",Q_VEC8BIT(m[1]), "), "); elif IsPlistRep(m) then Print(" plain list of vectors, tnum: ",TNUM_OBJ(m)," "); if ForAll(m, IsGF2VectorRep) then Print(" all rows GF2 compressed "); elif ForAll(m, Is8BitVectorRep) then Print(" all rows 8 bit compressed, fields ", Set(m,Q_VEC8BIT), " "); elif ForAll(m, IsPlistRep) then Print(" all rows plain lists, tnums: ", Set(m, TNUM_OBJ)," "); else Print(" mixed row representations or unusual row types "); fi; else Print(" unusual matrix representation: ", RepresentationsOfObject(m)," "); fi; if ForAll(m, IsLockedRepresentationVector) then Print(" all rows locked\n"); elif not ForAny(m, IsLockedRepresentationVector) then Print(" no rows locked\n"); else Print(" mixed lock status\n"); fi; return; end ); ############################################################################# ## #M ASS_LIST( , ) ## #InstallMethod(ASS_LIST, "empty list and 8 bit vector", true, # [IsEmpty and IsMutable and IsList and IsPlistRep, IsPosInt, Is8BitVectorRep], # 0, # function(l,p, v) # if p <> 1 then # PLAIN_MAT8BIT(l); # l[p] := v; # else # l[1] := 1; # l[2] := v; # SetFilterObj(v,IsLockedRepresentationVector); # Objectify(TYPE_MAT8BIT(Q_VEC8BIT(v), true), l); # fi; #end); ############################################################################# ## #M DefaultFieldOfMatrix( ) ## InstallMethod( DefaultFieldOfMatrix, "method for a compressed matrix over GF(q)", true, [ IsMatrix and IsFFECollColl and Is8BitMatrixRep ], 0, function( mat ) return GF(Q_VEC8BIT(mat![2])); end ); ############################################################################# ## #M < ## InstallMethod( \<, "for two compressed 8 bit matrices", IsIdenticalObj, [ IsMatrix and IsFFECollColl and Is8BitMatrixRep, IsMatrix and IsFFECollColl and Is8BitMatrixRep ], 0, LT_MAT8BIT_MAT8BIT); ############################################################################# ## #M = ## InstallMethod( \=, "for two compressed 8 bit matrices", IsIdenticalObj, [ IsMatrix and IsFFECollColl and Is8BitMatrixRep, IsMatrix and IsFFECollColl and Is8BitMatrixRep ], 0, EQ_MAT8BIT_MAT8BIT); ############################################################################# ## #M TransposedMat( ) #M MutableTransposedMat( ) ## InstallOtherMethod( TransposedMat, "for a compressed 8 bit matrix", true, [IsMatrix and IsFFECollColl and Is8BitMatrixRep ], 0, TRANSPOSED_MAT8BIT); InstallOtherMethod( MutableTransposedMat, "for a compressed 8 bit matrix", true, [IsMatrix and IsFFECollColl and Is8BitMatrixRep ], 0, TRANSPOSED_MAT8BIT); ############################################################################# ## #M SemiEchelonMat ## # # If mat is in the special representation, then we do # have to copy it, but we know that the rows of the result will # already be in special representation, so don't convert # InstallMethod(SemiEchelonMat, "shortcut method for 8bit matrices", true, [ IsMatrix and Is8BitMatrixRep and IsFFECollColl ], 0, function( mat ) local copymat, res; copymat := List(mat, ShallowCopy); res := SemiEchelonMatDestructive( copymat ); ConvertToMatrixRepNC(res.vectors,Q_VEC8BIT(mat![2])); return res; end); InstallMethod(SemiEchelonMatTransformation, "shortcut method for 8bit matrices", true, [ IsMatrix and Is8BitMatrixRep and IsFFECollColl ], 0, function( mat ) local copymat,res,q; copymat := List(mat, ShallowCopy); res := SemiEchelonMatTransformationDestructive( copymat ); q := Q_VEC8BIT(mat![2]); ConvertToMatrixRepNC(res.vectors,q); ConvertToMatrixRepNC(res.coeffs,q); ConvertToMatrixRepNC(res.relations,q); return res; end); InstallMethod(SemiEchelonMatDestructive, "kernel method for plain lists of 8bit vectors", true, [ IsPlistRep and IsMatrix and IsMutable and IsFFECollColl ], 0, SEMIECHELON_LIST_VEC8BITS ); InstallMethod(SemiEchelonMatTransformationDestructive, " kernel method for plain lists of 8 bit vectors", true, [ IsMatrix and IsFFECollColl and IsPlistRep and IsMutable], 0, SEMIECHELON_LIST_VEC8BITS_TRANSFORMATIONS); ############################################################################# ## #M TriangulizeMat( ) ## InstallMethod(TriangulizeMat, "kernel method for plain list of GF2 vectors", true, [IsMatrix and IsPlistRep and IsFFECollColl and IsMutable], 0, TRIANGULIZE_LIST_VEC8BITS); InstallMethod(TriangulizeMat, "method for compressed matrices", true, [IsMutable and IsMatrix and Is8BitMatrixRep and IsFFECollColl], 0, function(m) local q,i,imms; imms := []; q := Q_VEC8BIT(m![2]); PLAIN_MAT8BIT(m); for i in [1..Length(m)] do if not IsMutable(m[i]) then m[i] := ShallowCopy(m[i]); imms[i] := true; else imms[i] := false; fi; od; TRIANGULIZE_LIST_VEC8BITS(m); for i in [1..Length(m)] do if imms[i] then MakeImmutable(m[i]); fi; od; CONV_MAT8BIT(m,q); end); ############################################################################# ## #M DeterminantMatDestructive ( ) ## InstallMethod(DeterminantMatDestructive, "kernel method for plain list of GF2 vectors", true, [IsMatrix and IsPlistRep and IsFFECollColl and IsMutable], 0, DETERMINANT_LIST_VEC8BITS); ############################################################################# ## #M RankMatDestructive ( ) ## InstallMethod(RankMatDestructive, "kernel method for plain list of GF2 vectors", true, [IsMatrix and IsPlistRep and IsFFECollColl and IsMutable], 0, RANK_LIST_VEC8BITS); InstallMethod(NestingDepthM, [Is8BitMatrixRep], m->2); InstallMethod(NestingDepthA, [Is8BitMatrixRep], m->2); InstallMethod(NestingDepthM, [Is8BitVectorRep], m->1); InstallMethod(NestingDepthA, [Is8BitVectorRep], m->1); InstallMethod(PostMakeImmutable, [Is8BitMatrixRep], function(m) local i; for i in [2..m![1]] do MakeImmutable(m![i]); od; end); ############################################################################# ## #E ## gap-4r6p5/lib/grpperm.gi0000644000175000017500000017737512172557252013730 0ustar billbill############################################################################ ## #W grpperm.gi GAP library Heiko Theißen ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ############################################################################# ## #M CanEasilyTestMembership( ) ## InstallTrueMethod(CanEasilyTestMembership,IsPermGroup); ############################################################################# ## #M CanEasilyComputePcgs( ) ## ## solvable permgroups can compute a pcgs. (The group may have been told it ## is solvable without actually doing a solvability test, so we need the ## implication.) InstallTrueMethod(CanEasilyComputePcgs,IsPermGroup and IsSolvableGroup); #M CanComputeSizeAnySubgroup InstallTrueMethod(CanComputeSizeAnySubgroup,IsPermGroup); ############################################################################# ## #M AsSubgroup( , ) . . . . . . . . . . . . with stab chain transfer ## InstallMethod( AsSubgroup,"perm groups", IsIdenticalObj, [ IsPermGroup, IsPermGroup ], 0, function( G, U ) local S; # test if the parent is already alright if HasParent(U) and IsIdenticalObj(Parent(U),G) then return U; fi; if not IsSubset( G, U ) then return fail; fi; S:= SubgroupNC( G, GeneratorsOfGroup( U ) ); UseIsomorphismRelation( U, S ); UseSubsetRelation( U, S ); if HasStabChainMutable( U ) then SetStabChainMutable( S, StabChainMutable( U ) ); fi; return S; end ); ############################################################################# ## #M CanEasilyComputeWithIndependentGensAbelianGroup( ) ## InstallTrueMethod(CanEasilyComputeWithIndependentGensAbelianGroup, IsPermGroup and IsAbelian); ############################################################################# ## #F IndependentGeneratorsAbelianPPermGroup(

,

) . . . nice generators ## InstallGlobalFunction( IndependentGeneratorsAbelianPPermGroup, function ( P, p ) local inds, # independent generators, result pows, # their powers base, # the base of the vectorspace size, # the size of the group generated by orbs, # orbits trns, # transversal gens, # remaining generators one, # identity of `P' gens2, # remaining generators for next round exp, # exponent of

g, # one generator from h, # its power b, # basepoint c, # other point in orbit i, j, k; # loop variables # initialize the list of independent generators inds := []; pows := []; base := []; size := 1; orbs := []; trns := []; # gens are the generators for the remaining group gens := GeneratorsOfGroup( P ); one:= One( P ); # loop over the exponents exp := Maximum( List( gens, g -> LogInt( Order( g ), p ) ) ); for i in [exp,exp-1..1] do # loop over the remaining generators gens2 := []; for j in [1..Length(gens)] do g := gens[j]; h := g ^ (p^(i-1)); # reduce and while h <> h^0 and IsBound(trns[SmallestMovedPoint(h)^h]) do g := g / pows[ trns[SmallestMovedPoint(h)^h] ]; h := h / base[ trns[SmallestMovedPoint(h)^h] ]; od; # if this is linear indepenent, add it to the generators if h <> h^0 then Add( inds, g ); Add( pows, g ); Add( base, h ); size := size * p^i; b := SmallestMovedPoint(h); if not IsBound( orbs[b] ) then orbs[b] := [ b ]; trns[b] := [ one ]; fi; for c in ShallowCopy(orbs[b]) do for k in [1..p-1] do Add( orbs[b], c ^ (h^k) ); trns[c^(h^k)] := Length(base); od; od; # otherwise reduce and add to gens2 else Add( gens2, g ); fi; od; # prepare for the next round gens := gens2; pows := List( pows,i->i^ p ); od; # return the indepenent generators return inds; end ); ############################################################################# ## #M IndependentGeneratorsOfAbelianGroup( ) . . . . . . . nice generators ## InstallMethod( IndependentGeneratorsOfAbelianGroup, "for perm group", [ IsPermGroup and IsAbelian ], function ( G ) local inds, # independent generators, result one, # identity of `G' p, # prime factor of group size gens, # generators of

-Sylowsubgroup g, # one generator o; # its order # loop over all primes inds := []; one:= One( G ); for p in Union( List( GeneratorsOfGroup( G ), g -> Factors(Order(g)) ) ) do if p <> 1 then # compute the generators for the Sylow

subgroup gens := []; for g in GeneratorsOfGroup( G ) do o := Order(g); while o mod p = 0 do o := o / p; od; if g^o <> g^0 then Add( gens, g^o ); fi; od; # append the independent generators for the Sylow

subgroup Append( inds, IndependentGeneratorsAbelianPPermGroup( GroupByGenerators( gens, one ), p ) ); fi; od; # Sort the independent generators by increasing order Sort( inds, function (a,b) return Order(a) < Order(b); end ); # return the independent generators return inds; end ); ############################################################################# ## #F OrbitPerms( , ) . . . . . . . . . . . . . orbit of permutations ## InstallGlobalFunction( OrbitPerms, function( gens, d ) local max, orb, new, pnt, img, gen; # get the largest point moved by the group max := LargestMovedPoint( gens ); # handle fixpoints if not d in [1..max] then return [ d ]; fi; # start with the singleton orbit orb := [ d ]; new := BlistList( [1..max], [1..max] ); new[d] := false; # loop over all points found for pnt in orb do # apply all generators for gen in gens do img := pnt ^ gen; # add the image to the orbit if it is new if new[img] then Add( orb, img ); new[img] := false; fi; od; od; return orb; end ); ############################################################################# ## #F OrbitsPerms( , ) . . . . . . . . . . . orbits of permutations ## InstallGlobalFunction( OrbitsPerms, function( gens, D ) local max, dom, new, orbs, fst, orb, pnt, gen, img; # get the largest point moved by the group max := LargestMovedPoint( gens ); dom := BlistList( [1..max], D ); new := BlistList( [1..max], [1..max] ); orbs := []; # repeat until the domain is exhausted fst := Position( dom, true ); while fst <> fail do # start with the singleton orbit orb := [ fst ]; new[fst] := false; dom[fst] := false; # loop over all points found for pnt in orb do # apply all generators for gen in gens do img := pnt ^ gen; # add the image to the orbit if it is new if new[img] then Add( orb, img ); new[img] := false; dom[img] := false; fi; od; od; # add the orbit to the list of orbits and take next point Add( orbs, orb ); fst := Position( dom, true, fst ); od; # add the remaining points of , they are fixed for pnt in D do if pnt>max then Add( orbs, [ pnt ] ); fi; od; return orbs; end ); ############################################################################# ## #M SmallestMovedPoint( ) . . . . . . . for a collection of permutations ## SmallestMovedPointPerms := function( C ) local min, m, gen; min := infinity; for gen in C do if not IsOne( gen ) then m := SmallestMovedPointPerm( gen ); if m < min then min := m; fi; fi; od; return min; end; InstallMethod( SmallestMovedPoint, "for a collection of permutations", true, [ IsPermCollection ], 0, SmallestMovedPointPerms ); InstallMethod( SmallestMovedPoint, "for an empty list", true, [ IsList and IsEmpty ], 0, SmallestMovedPointPerms ); ############################################################################# ## #M LargestMovedPoint( ) . . . . . . . for a collection of permutations ## LargestMovedPointPerms := function( C ) local max, m, gen; max := 0; for gen in C do if not IsOne( gen ) then m := LargestMovedPointPerm( gen ); if max < m then max := m; fi; fi; od; return max; end; InstallMethod( LargestMovedPoint, "for a collection of permutations", true, [ IsPermCollection ], 0, LargestMovedPointPerms ); InstallMethod( LargestMovedPoint, "for an empty list", true, [ IsList and IsEmpty ], 0, LargestMovedPointPerms ); ############################################################################# ## #F MovedPoints( ) . . . . . . . . . . for a collection of permutations ## InstallGlobalFunction(MovedPointsPerms,function( C ) local mov, gen, pnt; mov := [ ]; for gen in C do if gen <> One( gen ) then for pnt in [ SmallestMovedPoint( gen ) .. LargestMovedPoint( gen ) ] do if pnt ^ gen <> pnt then mov[ pnt ] := pnt; fi; od; fi; od; return Set( mov ); end); InstallMethod( MovedPoints, "for a collection of permutations", true, [ IsPermCollection ], 0, MovedPointsPerms ); InstallMethod( MovedPoints, "for an empty list", true, [ IsList and IsEmpty ], 0, MovedPointsPerms ); InstallMethod( MovedPoints, "for a permutation", true, [ IsPerm ], 0, function(p) return MovedPointsPerms([p]); end); ############################################################################# ## #M NrMovedPoints( ) . . . . . . . . . for a collection of permutations ## NrMovedPointsPerms := function( C ) local mov, sma, pnt, gen; mov := 0; sma := SmallestMovedPoint( C ); if sma = infinity then return 0; fi; for pnt in [ sma .. LargestMovedPoint( C ) ] do for gen in C do if pnt ^ gen <> pnt then mov:= mov + 1; break; fi; od; od; return mov; end; InstallMethod( NrMovedPoints, "for a collection of permutations", [ IsPermCollection ], NrMovedPointsPerms ); InstallMethod( NrMovedPoints, "for an empty list", [ IsList and IsEmpty ], NrMovedPointsPerms ); ############################################################################# ## #M LargestMovedPoint( ) . . . . . . . . . . . . for a permutation group ## InstallMethod( LargestMovedPoint, "for a permutation group", true, [ IsPermGroup ], 0, G -> LargestMovedPoint( GeneratorsOfGroup( G ) ) ); ############################################################################# ## #M SmallestMovedPoint( ) . . . . . . . . . . . . for a permutation group ## InstallMethod( SmallestMovedPoint, "for a permutation group", true, [ IsPermGroup ], 0, G -> SmallestMovedPoint( GeneratorsOfGroup( G ) ) ); ############################################################################# ## #M MovedPoints( ) . . . . . . . . . . . . . . . for a permutation group ## InstallMethod( MovedPoints, "for a permutation group", true, [ IsPermGroup ], 0, G -> MovedPoints( GeneratorsOfGroup( G ) ) ); ############################################################################# ## #M NrMovedPoints( ) . . . . . . . . . . . . . . for a permutation group ## InstallMethod( NrMovedPoints, "for a permutation group", true, [ IsPermGroup ], 0, G -> NrMovedPoints( GeneratorsOfGroup( G ) ) ); ############################################################################# ## #M BaseOfGroup( ) ## InstallMethod( BaseOfGroup, "for a permutation group", true, [ IsPermGroup ], 0, G -> BaseStabChain( StabChainMutable( G ) ) ); ############################################################################# ## #M Size( ) . . . . . . . . . . . . . . . . . . size of permutation group ## InstallMethod( Size, "for a permutation group", true, [ IsPermGroup ], 0, G -> SizeStabChain( StabChainMutable( G ) ) ); ############################################################################# ## #M Enumerator( ) . . . . . . . . . . . . enumerator of permutation group ## BindGlobal( "ElementNumber_PermGroup", function( enum, pos ) local elm, S, len, n; S := enum!.stabChain; elm := S.identity; n:= pos; pos := pos - 1; while Length( S.genlabels ) <> 0 do len := Length( S.orbit ); elm := LeftQuotient( InverseRepresentative ( S, S.orbit[ pos mod len + 1 ] ), elm ); pos := QuoInt( pos, len ); S := S.stabilizer; od; if pos <> 0 then Error( "[", n, "] must have an assigned value" ); fi; return elm; end ); BindGlobal( "NumberElement_PermGroup", function( enum, elm ) local pos, val, S, img; if not IsPerm( elm ) then return fail; fi; pos := 1; val := 1; S := enum!.stabChain; while Length( S.genlabels ) <> 0 do img := S.orbit[ 1 ] ^ elm; #pos := pos + val * ( Position( S.orbit, img ) - 1 ); pos := pos + val * S.orbitpos[img]; #val := val * Length( S.orbit ); val := val * S.ol; elm := elm * InverseRepresentative( S, img ); S := S.stabilizer; od; if elm <> S.identity then return fail; fi; return pos; end ); InstallMethod( Enumerator, "for a permutation group", [ IsPermGroup ], function(G) local e,S,i,p; # get a good base S:=G; p:=[]; while Size(S)>1 do e:=Orbits(S,MovedPoints(S)); i:=List(e,Length); i:=Position(i,Maximum(i)); Add(p,e[i][1]); S:=Stabilizer(S,e[i][1]); od; Info(InfoGroup,1,"choose base ",p); S:=StabChainOp(G,rec(base:=p)); e:=EnumeratorByFunctions( G, rec( ElementNumber := ElementNumber_PermGroup, NumberElement := NumberElement_PermGroup, Length := enum -> SizeStabChain( enum!.stabChain ), PrintObj := function( G ) Print( "" ); end, stabChain := S ) ); while Length(S.genlabels)<>0 do S.ol:=Length(S.orbit); S.orbitpos:=[]; for i in [1..Maximum(S.orbit)] do p:=Position(S.orbit,i); if p<>fail then S.orbitpos[i]:=p-1; fi; od; S:=S.stabilizer; od; return e; end); ############################################################################# ## #M Random( ) . . . . . . . . . . . . . . . . . . . . . . random element ## InstallMethod( Random, "for a permutation group", [ IsPermGroup ], 10, function( G ) local S, rnd; # go down the stabchain and multiply random representatives S := StabChainMutable( G ); rnd := S.identity; while Length( S.genlabels ) <> 0 do rnd := LeftQuotient( InverseRepresentative( S, Random( S.orbit ) ), rnd ); S := S.stabilizer; od; # return the random element return rnd; end ); ############################################################################# ## #M in . . . . . . . . . . . . . . . . . . . . . . . membership test ## InstallMethod( \in, "for a permutation, and a permutation group", true, [ IsPerm, IsPermGroup and HasGeneratorsOfGroup], 0, function( g, G ) if g = One( G ) or g in GeneratorsOfGroup( G ) then return true; else G := StabChainMutable( G ); return SiftedPermutation( G, g ) = G.identity; fi; end ); ############################################################################# ## #M ClosureGroup( , , ) . . . . . . closure with options ## ## The following function implements the method and may be called even with ## incomplete (temp) stabilizer chains. BindGlobal("DoClosurePrmGp",function( G, gens, options ) local C, # closure of < , >, result P, inpar, # parent of the closure g, # an element of gens o, # order newgens, # new generator list chain; # the stabilizer chain created options:=ShallowCopy(options); # options will be overwritten # if all generators are in , is the closure gens := Filtered( gens, gen -> not gen in G ); if IsEmpty( gens ) then return G; fi; # is the closure normalizing? if Length(gens)=1 and ForAll(gens,i->ForAll(GeneratorsOfGroup(G),j->j^i in G)) then g:=gens[1]; if Size(G)>1 then o:=First(Difference(DivisorsInt(Order(g)),[1]),j->g^j in G); options.limit:=Size(G)*o; else o:=First(Difference(DivisorsInt(Order(g)),[1]),j->IsOne(g^j)); options.limit:=o; fi; options.size:=options.limit; #Print(options.limit,"<<\n"); fi; # otherwise decide between random and deterministic methods P := Parent( G ); inpar := IsSubset( P, gens ); while not inpar and not IsIdenticalObj( P, Parent( P ) ) do P := Parent( P ); inpar := IsSubset( P, gens ); od; if inpar then CopyOptionsDefaults( P, options ); elif not IsBound( options.random ) then options.random := DefaultStabChainOptions.random; fi; # perhaps is normal in with solvable factor group #AH 5-feb-96: Disabled (see gap-dev discussion). # if DefaultStabChainOptions.tryPcgs # and ForAll( gens, gen -> ForAll( GeneratorsOfGroup( G ), # g -> g ^ gen in G ) ) then # if inpar then # C := SubgroupNC( P, # Concatenation( GeneratorsOfGroup( G ), gens ) ); # else # C := GroupByGenerators # ( Concatenation( GeneratorsOfGroup( G ), gens ) ); # fi; # pcgs:=TryPcgsPermGroup( [ C, G ], false, false, false ); # if IsPcgs( pcgs ) then # chain:=pcgs!.stabChain; # if inpar then C := GroupStabChain( P, chain, true ); # else C := GroupStabChain( chain ); fi; # SetStabChainOptions( C, rec( random := options.random ) ); # # UseSubsetRelation( C, G ); # return C; # fi; # fi; # make the base of G compatible with options.base chain := StructuralCopy( StabChainMutable( G ) ); if IsBound( options.base ) then ChangeStabChain( chain, options.base, IsBound( options.reduced ) and options.reduced ); fi; if LargestMovedPoint( Concatenation( GeneratorsOfGroup( G ), gens ) ) <= 100 then options := ShallowCopy( options ); options.base := BaseStabChain( chain ); for g in gens do if SiftedPermutation( chain, g ) <> chain.identity then StabChainStrong( chain, [ g ], options ); fi; od; else chain := ClosureRandomPermGroup( chain, gens, options ); fi; newgens:=Concatenation(GeneratorsOfGroup(G),gens); if Length(chain.generators)<=Length(newgens) then if inpar then C := GroupStabChain( P, chain, true ); else C := GroupStabChain( chain ); fi; else if inpar then C := SubgroupNC(P,newgens); else C := Group( newgens,One(G) ); fi; SetStabChainMutable(C,chain); fi; SetStabChainOptions( C, rec( random := options.random ) ); UseSubsetRelation( C, G ); return C; end ); BindGlobal("PG_EMPTY_OPT",rec()); InstallOtherMethod( ClosureGroup,"permgroup, elements, options", true, [ IsPermGroup, IsList and IsPermCollection, IsRecord ], 0, DoClosurePrmGp); InstallOtherMethod( ClosureGroup, "empty list",true, [ IsPermGroup, IsList and IsEmpty ], 0, function( G, nogens ) return G; end ); InstallMethod( ClosureGroup, "permgroup, element",true, [ IsPermGroup, IsPerm ], 0, function( G, g ) return DoClosurePrmGp( G, [ g ], PG_EMPTY_OPT ); end ); InstallMethod( ClosureGroup, "permgroup, elements",true, [ IsPermGroup, IsList and IsPermCollection ], 0, function( G, gens ) return DoClosurePrmGp( G, gens, PG_EMPTY_OPT ); end ); InstallOtherMethod( ClosureGroup, "permgroup, element, options",true, [ IsPermGroup, IsPerm, IsRecord ], 0, function( G, g, options ) return DoClosurePrmGp( G, [ g ], options ); end ); InstallOtherMethod( ClosureGroup, "permgroup, permgroup, options", true, [ IsPermGroup, IsPermGroup, IsRecord ], 0, function( G, H, options ) return DoClosurePrmGp( G, GeneratorsOfGroup( H ), options ); end ); InstallOtherMethod( ClosureGroup, "empty list and options",true, [ IsPermGroup, IsList and IsEmpty, IsRecord ], 0, function( G, nogens, options ) return G; end ); ############################################################################# ## #M NormalClosureOp( , ) . . . . . . . . . . . . . . . . in perm group ## BindGlobal("DoNormalClosurePermGroup",function ( G, U ) local N, # normal closure of in , result chain, # stabilizer chain for the result rchain, # restored version of , for `VerifySGS' options, # options record for stabilizer chain construction gensG, # generators of the group genG, # one generator of the group gensN, # generators of the group genN, # one generator of the group cnj, # conjugated of a generator of random, k, # values measuring randomness of param, missing, correct, result, i, one; # get a set of monoid generators of gensG := GeneratorsOfGroup( G ); one:= One( G ); # make a copy of the group to be closed N := SubgroupNC( G, GeneratorsOfGroup(U) ); UseIsomorphismRelation(U,N); UseSubsetRelation(U,N); SetStabChainMutable( N, StabChainMutable( U ) ); options := ShallowCopy( StabChainOptions( U ) ); if IsBound( options.random ) then random := options.random; else random := 1000; fi; options.temp := true; # make list of conjugates to be added to N repeat gensN := [ ]; for i in [ 1 .. 10 ] do genG := SCRRandomSubproduct( gensG, One( G ) ); cnj := SCRRandomSubproduct( Concatenation( GeneratorsOfGroup( N ), gensN ), One( G ) ) ^ genG; if not cnj in N then Add( gensN, cnj ); fi; od; if not IsEmpty( gensN ) then N := ClosureGroup( N, gensN, options ); fi; until IsEmpty( gensN ); # Guarantee that all conjugates are in the normal closure: Loop over all # generators of N gensN := ShallowCopy( GeneratorsOfGroup( N ) ); for genN in gensN do # loop over the generators of G for genG in gensG do # make sure that the conjugated element is in the closure cnj := genN ^ genG; if not cnj in N then N := ClosureGroup( N, [ cnj ], options ); Add( gensN, cnj ); fi; od; od; # Verify the stabilizer chain. chain := StabChainMutable( N ); if not IsBound( chain.orbits ) then if IsBound( chain.aux ) then chain := SCRRestoredRecord( chain ); fi; result := chain.identity; elif random = 1000 then missing := chain.missing; correct := chain.correct; rchain := SCRRestoredRecord( chain ); result := VerifySGS( rchain, missing, correct ); if not IsPerm(result) then repeat result := SCRStrongGenTest2(chain,[0,0,1,10/chain.diam,0,0]); until result <> one; fi; chain := rchain; else k := First([0..14],x->(3/5)^x <= 1-random/1000); if IsBound(options.knownBase) then param := [k,4,0,0,0,0]; else param := [QuoInt(k,2),4,QuoInt(k+1,2),4,50,5]; fi; if options.random <= 200 then param[2] := 2; param[4] := 2; fi; result := SCRStrongGenTest( chain, param, chain.orbits, chain.basesize, chain.base, chain.correct, chain.missing ); if result = chain.identity and not chain.correct then result := SCRStrongGenTest2( chain, param ); fi; chain := SCRRestoredRecord( chain ); fi; SetStabChainMutable( N, chain ); if result <> chain.identity then N := ClosureGroup( N, [ result ] ); fi; # give N the proper randomness StabChainOptions(N).random:=random; # return the normal closure UseSubsetRelation( N, U ); return N; end ); InstallMethod( NormalClosureOp, "subgroup of perm group", IsIdenticalObj, [ IsPermGroup, IsPermGroup ], 0, function(G,U) # test applicability if not IsSubset(G,U) then TryNextMethod(); fi; return DoNormalClosurePermGroup(G,U); end); ############################################################################# ## #M ConjugateGroup( , ) . . . . . . . . . . . . of permutation group ## InstallMethod( ConjugateGroup, "

, ", true, [ IsPermGroup, IsPerm ], 0, function( G, g ) local H, S; H := GroupByGenerators( OnTuples( GeneratorsOfGroup( G ), g ), One( G ) ); if HasStabChainMutable(G) then S := EmptyStabChain( [ ], One( H ) ); ConjugateStabChain( StabChainMutable( G ), S, g, g ); SetStabChainMutable( H, S ); elif HasSize(G) then SetSize(H,Size(G)); fi; UseIsomorphismRelation( G, H ); return H; end ); ############################################################################# ## #M CommutatorSubgroup( , ) . . . . . . . . . . . . . for perm groups ## InstallMethod( CommutatorSubgroup, "permgroups", IsIdenticalObj, [ IsPermGroup, IsPermGroup ], 0, function( U, V ) local C, # the commutator subgroup CUV, # closure of U,V doneCUV, # boolean; true if CUV is computed u, # random subproduct of U.generators v, # random subproduct of V.generators comm, # commutator of u,v list, # list of commutators i; # loop variable # [ , ] = normal closure of < [ , ] >. C := TrivialSubgroup( U ); doneCUV := false; # if there are lot of generators, use random subproducts if Length( GeneratorsOfGroup( U ) ) * Length( GeneratorsOfGroup( V ) ) > 10 then repeat list := []; for i in [1..10] do u := SCRRandomSubproduct( GeneratorsOfGroup( U ), One( U ) ); v := SCRRandomSubproduct( GeneratorsOfGroup( V ), One( V ) ); comm := Comm( u, v ); if not comm in C then Add( list, comm ) ; fi; od; if Length(list) > 0 then C := ClosureGroup( C, list, rec( random := 0, temp := true ) ); if not doneCUV then CUV := ClosureGroup( U, V ); doneCUV := true; fi; # force closure test StabChainOptions(C).random:=DefaultStabChainOptions.random; C := DoNormalClosurePermGroup( CUV, C ); fi; until IsEmpty( list ); fi; # do the deterministic method; it will also check correctness list := []; for u in GeneratorsOfGroup( U ) do for v in GeneratorsOfGroup( V ) do comm := Comm( u, v ); if not comm in C then Add( list, comm ); fi; od; od; if not IsEmpty( list ) then C := ClosureGroup( C, list, rec( random := 0, temp := true ) ); if not doneCUV then CUV := ClosureGroup( U, V ); doneCUV := true; fi; # force closure test StabChainOptions(C).random:=DefaultStabChainOptions.random; C := DoNormalClosurePermGroup( CUV, C ); fi; return C; end ); ############################################################################# ## #M DerivedSubgroup( ) . . . . . . . . . . . . . . of permutation group ## InstallMethod( DerivedSubgroup,"permgrps",true, [ IsPermGroup ], 0, function( G ) local D, # derived subgroup of , result g, h, # random subproducts of generators comm, # their commutator list, # list of commutators i,j; # loop variables # find the subgroup generated by the commutators of the generators D := TrivialSubgroup( G ); # if there are >4 generators, use random subproducts if Length( GeneratorsOfGroup( G ) ) > 4 then repeat list := []; for i in [1..10] do g := SCRRandomSubproduct( GeneratorsOfGroup( G ), One( G ) ); h := SCRRandomSubproduct( GeneratorsOfGroup( G ), One( G ) ); comm := Comm( g, h ); if not comm in D then Add( list, comm ); fi; od; if Length(list) > 0 then D := ClosureGroup(D,list,rec( random := 0, temp := true ) ); # force closure test if IsBound(StabChainOptions(G).random) then StabChainOptions(D).random:=StabChainOptions(G).random; else StabChainOptions(D).random:=DefaultStabChainOptions.random; fi; D := DoNormalClosurePermGroup( G, D ); fi; until list = []; fi; # do the deterministic method; it will also check random result list := []; for i in [ 2 .. Length( GeneratorsOfGroup( G ) ) ] do for j in [ 1 .. i - 1 ] do comm := Comm( GeneratorsOfGroup( G )[i], GeneratorsOfGroup( G )[j] ); if not comm in D then Add( list, comm ); fi; od; od; if not IsEmpty( list ) then D := ClosureGroup(D,list,rec( random := 0, temp := true ) ); # give D a proper randomness if IsBound(StabChainOptions(G).random) then StabChainOptions(D).random:=StabChainOptions(G).random; else StabChainOptions(D).random:=DefaultStabChainOptions.random; fi; D := DoNormalClosurePermGroup( G, D ); fi; return D; end ); ############################################################################# ## #M IsSimpleGroup( ) . . . . . . . test if a permutation group is simple ## ## This is a most interesting function. It tests whether a permutation ## group is simple by testing whether the group is perfect and then only ## looking at the size of the group and the degree of a primitive operation. ## Basically it uses the O'Nan--Scott theorem, which gives a pretty clear ## description of perfect primitive groups. This algorithm is described in ## William M. Kantor, ## Finding Composition Factors of Permutation Groups of Degree $n\leq 10^6$, ## J. Symbolic Computation, 12:517--526, 1991. ## InstallMethod( IsSimpleGroup,"for permgrp", true, [ IsPermGroup ], 0, function ( G ) local D, # operation domain of hom, # transitive constituent or blocks homomorphism d, # degree of n, m, # $d = n^m$ simple, # list of orders of simple groups transperf, # list of orders of transitive perfect groups s, t; # loop variables # if is the trivial group, it is not simple if IsTrivial( G ) then return false; fi; # first find a transitive representation for D := Orbit( G, SmallestMovedPoint( G ) ); if not IsEqualSet( MovedPoints( G ), D ) then hom := ActionHomomorphism( G, D,"surjective" ); if Size( G ) <> Size( Image( hom ) ) then return false; fi; G := Image( hom ); fi; # next find a primitive representation for D := Blocks( G, MovedPoints( G ) ); while Length( D ) <> 1 do hom := ActionHomomorphism( G, D, OnSets,"surjective" ); if Size( G ) <> Size( Image( hom ) ) then return false; fi; G := Image( hom ); D := Blocks( G, MovedPoints( G ) ); od; # compute the degree $d$ and express it as $d = n^m$ D := MovedPoints( G ); d := Length( D ); n := SmallestRootInt( d ); m := LogInt( d, n ); if 10^6 < d then Error("cannot decide whether is simple or not"); fi; # if $G = C_p$, it is simple if IsPrimeInt( Size( G ) ) then return true; # if $G = A_d$, it is simple (unless $d < 5$) elif IsNaturalAlternatingGroup(G) then return 5 <= d; # if $G = S_d$, it is not simple (except $S_2$) elif IsNaturalSymmetricGroup(G) then return 2 = d; # if $G$ is not perfect, it is not simple (unless $G = C_p$, see above) elif Size( DerivedSubgroup( G ) ) < Size( G ) then return false; # if $\|G\| = d^2$, it is not simple (Kantor's Lemma 4) elif Size( G ) = d ^ 2 then return false; # if $d$ is a prime, is simple elif IsPrimeInt( d ) then return true; # if $G = U(4,2)$, it is simple (operation on 27 points) elif d = 27 and Size( G ) = 25920 then return true; # if $G = PSL(n,q)$, it is simple (operations on prime power points) elif ( (d = 8 and Size(G) = (7^3-7)/2 ) # PSL(2,7) or (d = 9 and Size(G) = (8^3-8) ) # PSL(2,8) or (d = 32 and Size(G) = (31^3-31)/2 ) # PSL(2,31) or (d = 121 and Size(G) = 237783237120) # PSL(5,3) or (d = 128 and Size(G) = (127^3-127)/2 ) # PSL(2,127) or (d = 8192 and Size(G) = (8191^3-8191)/2 ) # PSL(2,8191) or (d = 131072 and Size(G) = (131071^3-131071)/2) # PSL(2,131071) or (d = 524288 and Size(G) = (524287^3-524287)/2)) # PSL(2,524287) and IsTransitive( Stabilizer( G, D[1] ), Difference( D, [ D[1] ] ) ) then return true; # if $d$ is a prime power, is not simple (except the cases above) elif IsPrimePowerInt( d ) then return false; # if we don't have at least an $A_5$ acting on the top, is simple elif m < 5 then return true; # otherwise we must check for some special cases else # orders of simple subgroups of $S_n$ with primitive normalizer simple := [ ,,,,, [60,360],,,, # 5: A(5), A(6) [60,360,1814400],, # 10: A(5), A(6), A(10) [660,7920,95040,239500800],, # 12: PSL(2,11), M(11), M(12), A(12) [1092,43589145600], # 14: PSL(2,13), A(14) [360,2520,20160,653837184000] # 15: A(6), A(7), A(8), A(15) ]; # orders of transitive perfect subgroups of $S_m$ transperf := [ ,,,, [60], # 5: A(5) [60,360], # 6: A(5), A(6) [168,2520], # 7: PSL(3,2), A(7) [168,8168,20160] # 8: PSL(3,2), AGL(3,2), A(8) ]; # test the special cases (Kantor's Lemma 3) for s in simple[n] do for t in transperf[m] do if Size( G ) mod (t * s^m) = 0 and (((t * (2*s)^m) mod Size( G ) = 0 and s <> 360) or ((t * (4*s)^m) mod Size( G ) = 0 and s = 360)) then return false; fi; od; od; # otherwise is simple return true; fi; end ); ############################################################################# ## #M IsSolvableGroup( ) . . . . . . . . . . . . . . . . solvability test ## InstallMethod( IsSolvableGroup,"for permgrp", true, [ IsPermGroup ], 0, function(G) local pcgs; pcgs:=TryPcgsPermGroup( G, false, false, true ); if IsPcgs(pcgs) then SetIndicesEANormalSteps(pcgs,pcgs!.permpcgsNormalSteps); SetIsPcgsElementaryAbelianSeries(pcgs,true); if not HasPcgs(G) then SetPcgs(G,pcgs); fi; if not HasPcgsElementaryAbelianSeries(G) then SetPcgsElementaryAbelianSeries(G,pcgs); fi; return true; else return false; fi; end); ############################################################################# ## #M IsNilpotentGroup( ) . . . . . . . . . . . . . . . . . nilpotency test ## InstallMethod( IsNilpotentGroup,"for permgrp", true, [ IsPermGroup ], 0, G -> IsPcgs(PcgsCentralSeries(G) ) ); ############################################################################# ## #M PcgsCentralSeries( ) ## InstallOtherMethod( PcgsCentralSeries,"for permgrp", true, [ IsPermGroup ], 0, function(G) local pcgs; pcgs:=TryPcgsPermGroup( G, true, false, false ); if IsPcgs(pcgs) then SetIndicesCentralNormalSteps(pcgs,pcgs!.permpcgsNormalSteps); SetIsPcgsCentralSeries(pcgs,true); if not HasPcgs(G) then SetPcgs(G,pcgs); fi; fi; return pcgs; end); ############################################################################# ## #M PcgsPCentralSeriesPGroup( ) ## InstallOtherMethod( PcgsPCentralSeriesPGroup,"for permgrp", true, [ IsPermGroup ], 0, function(G) local pcgs; pcgs:=TryPcgsPermGroup( G, true, true, Factors(Size(G))[1] ); if IsPcgs(pcgs) then SetIndicesPCentralNormalStepsPGroup(pcgs,pcgs!.permpcgsNormalSteps); SetIsPcgsPCentralSeriesPGroup(pcgs,true); fi; if IsPcgs(pcgs) and not HasPcgs(G) then SetPcgs(G,pcgs); fi; return pcgs; end); #T AH, 3/26/07: This method triggers a bug with indices. It is not clear #T form the description why TryPcgs... should also give a drived series. Thus #T disabled. # ############################################################################# # ## # #M DerivedSeriesOfGroup( ) . . . . . . . . . . . . . . . derived series # ## # InstallMethod( DerivedSeriesOfGroup,"for permgrp", true, [ IsPermGroup ], 0, # function( G ) # local pcgs, series; # # if (not DefaultStabChainOptions.tryPcgs # or ( HasIsSolvableGroup( G ) and not IsSolvableGroup( G ) )) # and not (HasIsSolvableGroup(G) and IsSolvableGroup(G)) then # TryNextMethod(); # fi; # # pcgs := TryPcgsPermGroup( G, false, true, false ); # if not IsPcgs( pcgs ) then # TryNextMethod(); # fi; # SetIndicesEANormalSteps(pcgs,pcgs!.permpcgsNormalSteps); # series := EANormalSeriesByPcgs( pcgs ); # if not HasDerivedSubgroup( G ) then # if Length( series ) > 1 then SetDerivedSubgroup( G, series[ 2 ] ); # else SetDerivedSubgroup( G, G ); fi; # fi; # return series; # end ); ############################################################################# ## #M LowerCentralSeriesOfGroup( ) . . . . . . . . . lower central series ## InstallMethod( LowerCentralSeriesOfGroup,"for permgrp", true, [ IsPermGroup ], 0, function( G ) local pcgs, series; if not DefaultStabChainOptions.tryPcgs or HasIsNilpotentGroup( G ) and not IsNilpotentGroup( G ) and not (HasIsNilpotentGroup(G) and IsNilpotentGroup(G)) then TryNextMethod(); fi; pcgs := TryPcgsPermGroup( G, true, true, false ); if not IsPcgs( pcgs ) then TryNextMethod(); fi; SetIndicesCentralNormalSteps(pcgs,pcgs!.permpcgsNormalSteps); series := CentralNormalSeriesByPcgs( pcgs ); if not HasDerivedSubgroup( G ) then if Length( series ) > 1 then SetDerivedSubgroup( G, series[ 2 ] ); else SetDerivedSubgroup( G, G ); fi; fi; return series; end ); InstallOtherMethod( ElementaryAbelianSeries, "perm group", true, [ IsPermGroup and IsFinite], # we want this to come *before* the method for Pcgs computable groups RankFilter(IsPermGroup and CanEasilyComputePcgs and IsFinite) -RankFilter(IsPermGroup and IsFinite), function(G) local pcgs; pcgs:=PcgsElementaryAbelianSeries(G); if not IsPcgs(pcgs) then TryNextMethod(); fi; return EANormalSeriesByPcgs(pcgs); end); #InstallOtherMethod( ElementaryAbelianSeries, fam -> IsIdenticalObj # ( fam, CollectionsFamily( CollectionsFamily( PermutationsFamily ) ) ), # [ IsList ], 0, # function( list ) # local pcgs; # # if IsEmpty( list ) # or not DefaultStabChainOptions.tryPcgs # or ( HasIsSolvableGroup( list[ 1 ] ) # and not IsSolvableGroup( list[ 1 ] ) ) then # TryNextMethod(); ## fi; # ## pcgs := TryPcgsPermGroup( list, false, false, true ); # if not IsPcgs( pcgs ) then return fail; # else return ElementaryAbelianSeries( pcgs ); fi; #end ); ############################################################################# ## #M PCentralSeries( ,

) . . . . . . . . . . . . . . p-central series ## InstallMethod( PCentralSeriesOp,"for permgrp", true, [ IsPermGroup, IsPosInt ], 0, function( G, p ) local pcgs; if Length(Factors(Size(G)))>1 then TryNextMethod(); fi; pcgs:=PcgsPCentralSeriesPGroup(G); if not IsPcgs(pcgs) then TryNextMethod(); fi; return PCentralNormalSeriesByPcgsPGroup(pcgs); end); ############################################################################# ## #M SylowSubgroup( ,

) . . . . . . . . . . . . . . Sylow $p$-subgroup ## InstallMethod( SylowSubgroupOp,"permutation groups", true, [ IsPermGroup, IsPosInt ], 0, function( G, p ) local S; if not HasIsSolvableGroup(G) and IsSolvableGroup(G) then # enforce solvable methods if we detected anew that the group is # solvable. return SylowSubgroupOp(G,p); fi; S := SylowSubgroupPermGroup( G, p ); S := GroupStabChain( G, StabChainMutable( S ) ); SetIsNilpotentGroup( S, true ); if Size(S) > 1 then SetIsPGroup( S, true ); SetPrimePGroup( S, p ); fi; return S; end ); InstallGlobalFunction( SylowSubgroupPermGroup, function( G, p ) local S, #

-Sylow subgroup of , result q, # largest power of

dividing the size of D, # domain of operation of O, # one orbit of in this domain B, # blocks of the operation of on f, # action homomorphism of on or T, #

-Sylow subgroup in the image of g, g2, # one

element of C, C2; # centralizer of in # get the size of the

-Sylow subgroup q := 1; while Size( G ) mod (q * p) = 0 do q := q * p; od; # handle trivial subgroup if q = 1 then return TrivialSubgroup( G ); fi; # go down in stabilizers as long as possible S := StabChainMutable( G ); while Length( S.orbit ) mod p <> 0 do S := S.stabilizer; od; G := GroupStabChain( G, S, true ); # handle full group if q = Size( G ) then return G; fi; # handle

-Sylow subgroups of size

if q = p then repeat g := Random( G ); until Order( g ) mod p = 0; g := g ^ (Order( g ) / p); return SubgroupNC( G, [ g ] ); fi; # if the group is not transitive work with the transitive constituents D := MovedPoints( G ); if not IsTransitive( G, D ) then Info(InfoGroup,1,"PermSylow: transitive"); S := G; D := ShallowCopy( D ); while q < Size( S ) do O := Orbit( S, D[1] ); f := ActionHomomorphism( S, O,"surjective" ); T := SylowSubgroupPermGroup( Range( f ), p ); S := PreImagesSet( f, T ); SubtractSet( D, O ); od; return S; fi; # if the group is not primitive work in the image first B := Blocks( G, D ); if Length( B ) <> 1 then Info(InfoGroup,1,"PermSylow: blocks"); f := ActionHomomorphism( G, B, OnSets,"surjective" ); T := SylowSubgroupPermGroup( Range( f ), p ); if Size( T ) < Size( Range( f ) ) then T := PreImagesSet( f, T ); S := SylowSubgroupPermGroup( T , p) ; return S; fi; fi; # find a

element whose centralizer contains a full

-Sylow subgroup Info(InfoGroup,1,"PermSylow: element"); repeat g := Random( G ); until Order( g ) mod p = 0; g := g ^ (Order( g ) / p); C := Centralizer( G, g ); while GcdInt( q, Size( C ) ) < q do repeat g2 := Random( C ); until Order( g2 ) mod p = 0; g2 := g2 ^ (Order( g2 ) / p); C2 := Centralizer( G, g2 ); if GcdInt( q, Size( C ) ) < GcdInt( q, Size( C2 ) ) then C := C2; g := g2; fi; od; # the centralizer acts on the cycles of the

element B := List( Cycles( g, D ), Set ); Info(InfoGroup,1,"PermSylow: cycleaction"); f := ActionHomomorphism( C, B, OnSets,"surjective" ); T := SylowSubgroupPermGroup( Range( f ), p ); S := PreImagesSet( f, T ); return S; end ); ############################################################################# ## #M Socle( ) . . . . . . . . . . . socle of primitive permutation group ## InstallMethod( Socle,"for permgrp", true, [ IsPermGroup ], 0, function( G ) local Omega, deg, shortcut, coll, d, m, c, ds, L, z, ord, p, i; Omega := MovedPoints( G ); if not IsPrimitive( G, Omega ) then TryNextMethod(); fi; # Affine groups first. L := Earns( G, Omega ); if L <> fail then return L; fi; deg := Length( Omega ); if deg >= 6103515625 then TryNextMethod(); elif deg < 12960000 then shortcut := true; if deg >= 3125 then coll := Collected( FactorsInt( deg ) ); d := Gcd( List( coll, c -> c[ 2 ] ) ); if d mod 5 = 0 then m := 1; for c in coll do m := m * c[ 1 ] ^ ( c[ 2 ] / d ); od; if m >= 5 then shortcut := false; fi; fi; fi; if shortcut then ds := DerivedSeriesOfGroup( G ); return ds[ Length( ds ) ]; fi; fi; coll := Collected( FactorsInt( Size( G ) ) ); if deg < 78125 then p := coll[ Length( coll ) ][ 1 ]; else i := Length( coll ); while coll[ i ][ 2 ] = 1 do i := i - 1; od; p := coll[ i ][ 1 ]; fi; repeat repeat z := Random( G ); ord := Order( z ); until ord mod p = 0; z := z ^ ( ord / p ); until Index( G, Centralizer( G, z ) ) mod p <> 0; L := NormalClosure( G, SubgroupNC( G, [ z ] ) ); if deg >= 78125 then ds := DerivedSeriesOfGroup( L ); L := ds[ Length( ds ) ]; fi; if IsSemiRegular( L, Omega ) then L := ClosureSubgroup( L, Centralizer( G, L ) ); fi; return L; end ); ############################################################################# ## #M FrattiniSubgroup( ) . . . . . . . . . . . . for permutation p-groups ## InstallMethod( FrattiniSubgroup,"for permgrp", true, [ IsPermGroup ], 0, function( G ) local fac, p, l, k, i, j; fac := Set( FactorsInt( Size( G ) ) ); if Length( fac ) > 1 then TryNextMethod(); elif fac[1]=1 then return G; fi; p := fac[ 1 ]; l := GeneratorsOfGroup( G ); k := [ l[1]^p ]; for i in [ 2 .. Length(l) ] do for j in [ 1 .. i-1 ] do Add(k, Comm(l[i], l[j])); od; Add(k, l[i]^p); od; return SolvableNormalClosurePermGroup( G, k ); end ); ############################################################################# ## #M ApproximateSuborbitsStabilizerPermGroup(,) . . . approximation of ## the orbits of Stab_G(pnt) on all points of the orbit pnt^G. (As not ## all schreier generators are used, the results may be the orbits of a ## subgroup.) ## InstallGlobalFunction( ApproximateSuborbitsStabilizerPermGroup, function(G,punkt) local one, orbit, trans, stab, gen, pnt, img, norb, no, i, j, changed, processStabGen, StabGenAvailable, stgp, orblen, gens; one:= One( G ); if HasStabChainMutable( G ) and punkt in StabChainMutable(G).orbit then # if we already have a stab chain and bother computing the proper # stabilizer, a trivial orbit algorithm seems best. return Concatenation([[punkt]], OrbitsDomain(Stabilizer(G,punkt), Difference(MovedPoints(G),[punkt]))); # orbit:=Difference(StabChainMutable(G).orbit,[punkt]); # stab:=Stabilizer(G,punkt)); # # catch trivial case # if Length(stab)=0 then # stab:=[ one ]; # fi; # stgp:=1; # # processStabGen:=function() # stgp:=stgp+1; # if stgp>Length(stab) then # StabGenAvailable:=false; # fi; # return stab[stgp-1]; # end; else # compute orbit and transversal orbit := [ punkt ]; trans := []; trans[ punkt ] := one; stab:=[]; for pnt in orbit do for gen in GeneratorsOfGroup(G) do img:=pnt/gen; if not IsBound( trans[ img ] ) then Add( orbit, img ); trans[ img ] := gen; fi; od; od; orblen:=Length(orbit); orbit:=orbit{[2..Length(orbit)]}; processStabGen:=function() i:=orblen; gen:= one; while 1<=i do gen:=gen*Random(GeneratorsOfGroup(G)); i:=QuoInt(i,2); od; while punkt^gen<>punkt do gen:=gen*trans[punkt^gen]; od; return gen; end; fi; StabGenAvailable:=true; # as the first approximation take a subgroup generated by three nontrivial # Schreier generators changed:=0; gens:=[]; while changed<=3 and StabGenAvailable do gen:=processStabGen(); if gen = one then if Random([1..10])>1 then changed:=changed+1; fi; else changed:=changed+1; Add(gens,gen); fi; od; if Length(gens)=0 then orbit:=List(orbit,i->[i]); else orbit:=OrbitsPerms(gens,orbit); fi; orbit:=List(orbit,i->Immutable(Set(i))); #trivial case if Length(orbit)=0 then changed:=infinity; else changed:=0; fi; # compute suborbits, fusing iteratively under generators while changed<=2 and StabGenAvailable do gen:=processStabGen(); if gen = one then if Random([1..10])>1 then changed:=changed+1; fi; else changed:=changed+1; # fuse under gen-action norb:=[]; for i in [1..Length(orbit)] do if IsBound(orbit[i]) then no:=ShallowCopy(orbit[i]); Unbind(orbit[i]); i:=i+1; for pnt in no do img:=pnt^gen; if not img in no then img:=First([i..Length(orbit)],j->IsBound(orbit[j]) and img in orbit[j]); if img<>fail then changed:=0; UniteSet(no,orbit[img]); Unbind(orbit[img]); fi; fi; od; Add(norb,Immutable(no)); fi; od; orbit:=norb; fi; od; return Concatenation([[punkt]],orbit); end ); ############################################################################# ## #M AllBlocks . . . Representatives of all block systems ## InstallMethod( AllBlocks, "generic", [ IsPermGroup ], function(g) local gens, one, dom,DoBlocks,pool,subo; DoBlocks:=function(b) local bl,bld,i,t,n; # find representatives of all potential suborbits bld:=List(Filtered(subo,i->not ForAny(b,j->j in i)),i->i[1]); bl:=[]; if not IsPrime(Length(dom)/Length(b)) then for i in bld do t:=Union(b,[i]); n:=Blocks(g,dom,t); if Length(n)>1 and #ok durch pool:ForAll(Difference(n[1],t),j->j>i) and not n[1] in pool then t:=n[1]; Add(pool,t); bl:=Concatenation(bl,[t],DoBlocks(t)); fi; od; fi; return bl; end; one:= One( g ); gens:= Filtered( GeneratorsOfGroup(g), i -> i <> one ); if Length(gens)=0 then return []; fi; subo:=ApproximateSuborbitsStabilizerPermGroup(g, Minimum(List(gens,SmallestMovedPoint))); dom:=Union(subo); pool:=[]; return DoBlocks(subo[1]); end); ############################################################################# ## #F SignPermGroup ## InstallGlobalFunction( SignPermGroup, function(g) if ForAll(GeneratorsOfGroup(g),i->SignPerm(i)=1) then return 1; else return -1; fi; end ); CreateAllCycleStructures := function(n) local i,j,l,m; l:=[]; for i in Partitions(n) do m:=[]; for j in i do if j>1 then if IsBound(m[j-1]) then m[j-1]:=m[j-1]+1; else m[j-1]:=1; fi; fi; od; Add(l,m); od; return l; end; ############################################################################# ## #F CycleStructuresGroup(G) list of all cyclestructures occ. in a perm group ## InstallGlobalFunction( CycleStructuresGroup, function(g) local l,m,i, one; l:=CreateAllCycleStructures(Length(MovedPoints(g))); m:=List([1..Length(l)-1],i->0); one:= One( g ); for i in ConjugacyClasses(g) do if Representative(i) <> one then m[Position(l,CycleStructurePerm(Representative(i)))-1]:=1; fi; od; return m; end ); ############################################################################# ## #M SmallGeneratingSet() ## InstallMethod(SmallGeneratingSet,"random and generators subset, randsims",true, [IsPermGroup],0, function (G) local i, j, U, gens,o,v,a,sel; # remove obvious redundancies gens := ShallowCopy(Set(GeneratorsOfGroup(G))); o:=List(gens,Order); SortParallel(o,gens,function(a,b) return a>b;end); sel:=Filtered([1..Length(gens)],x->o[x]>1); for i in [1..Length(gens)] do if i in sel then U:=Filtered(sel,x->x>i and IsInt(o[i]/o[x])); # potential powers v:=[]; for j in U do a:=SmallestMovedPoint(gens[j]); if IsSubset(OrbitPerms([gens[i]],a),OrbitPerms([gens[j]],a)) then Add(v,j); fi; od; # v are the possible powers for j in v do a:=gens[i]^(o[i]/o[j]); if ForAny(Filtered([1..o[j]],z->Gcd(z,o[j])=1),x->a^x=gens[j]) then RemoveSet(sel,j); fi; od; fi; od; gens:=gens{sel}; # try pc methods first if Length(MovedPoints(G))<1000 and HasIsSolvableGroup(G) and IsSolvableGroup(G) and Length(gens)>3 then return MinimalGeneratingSet(G); fi; if Length(gens)>2 then i:=2; while i<=3 and iRandom(G))); StabChain(U,rec(random:=1)); if Size(U)=Size(G) then gens:=Set(GeneratorsOfGroup(U)); fi; j:=j+1; od; i:=i+1; od; fi; i := 1; if not IsAbelian(G) then i:=i+1; fi; while i < Length(gens) do # random did not improve much, try subsets U:=Subgroup(G,gens{Difference([1..Length(gens)],[i])}); if Size(U)) . . . . . . . . . . . . . for permutation groups ## DeclareGlobalFunction( "GeneratorsSmallestStab" ); InstallGlobalFunction( GeneratorsSmallestStab, function ( S ) local gens, # smallest generating system of , result gen, # one generator in orb, # basic orbit of pnt, # one point in T, # stabilizer in o2,img,oo,og; # private orbit algorithm # handle the anchor case if Length(S.generators) = 0 then return []; fi; # now get the smallest generating system of the stabilizer gens := GeneratorsSmallestStab( S.stabilizer ); # get the sorted orbit (the basepoint will be the first point) orb := Set( S.orbit ); SubtractSet( orb, [S.orbit[1]] ); # handle the other points in the orbit while Length(orb) <> 0 do # take the smallest point (coset) and one representative pnt := orb[1]; gen := S.identity; while S.orbit[1] ^ gen <> pnt do gen := LeftQuotient( S.transversal[ pnt / gen ], gen ); od; # the next generator is the smallest element in this coset T := S.stabilizer; while Length(T.generators) <> 0 do pnt := Minimum( OnTuples( T.orbit, gen ) ); while T.orbit[1] ^ gen <> pnt do gen := LeftQuotient( T.transversal[ pnt / gen ], gen ); od; T := T.stabilizer; od; # add this generator to the generators list and reduce orbit Add( gens, gen ); #SubtractSet( orb, # Orbit( GroupByGenerators( gens, S.identity ), S.orbit[1] ) ); # here we want to be really fast, so use a private orbit algorithm o2:=[S.orbit[1]]; RemoveSet(orb,S.orbit[1]); for oo in o2 do for og in gens do img:=oo^og; if img in orb then Add(o2,img); RemoveSet(orb,img); fi; od; od; od; # return the smallest generating system return gens; end ); InstallMethod(GeneratorsSmallest,"perm group via minimal stab chain", [IsPermGroup], function(G) # call the recursive function to do the work return GeneratorsSmallestStab(MinimalStabChain(G)); end); InstallMethod(LargestElementGroup,"perm group via minimal stab chain", [IsPermGroup], # call the recursive function to do the work G -> LargestElementStabChain( MinimalStabChain( G ), One( G ) ) ); ############################################################################# ## #M KnowsHowToDecompose( , ) ## InstallMethod(KnowsHowToDecompose, "perm group and generators: always true", IsIdenticalObj, [ IsPermGroup, IsList ], ReturnTrue); ############################################################################# ## #M ViewObj( ) ## InstallMethod( ViewObj, "for a permutation group", true, [ IsPermGroup and HasGeneratorsOfGroup ], 0, function(G) local gens; gens:= GeneratorsOfGroup( G ); if 30 < Length( gens ) * LargestMovedPoint( G ) / GAPInfo.ViewLength then Print("" ); else Print("Group("); if IsEmpty( gens ) or ForAll(gens,i->Order(i)=1) then ViewObj( One( G ) ); else ViewObj( gens ); fi; Print(")"); fi; end); ############################################################################# ## #M AsList( ) elements of perm group ## InstallMethod( AsList,"permgp: AsSSortedList", true, [ IsPermGroup ], 0, AsSSortedList ); ############################################################################# ## #M AsSSortedList( ) elements of perm group ## InstallMethod( AsSSortedList,"via stabchain",true, [ IsPermGroup ], 0, function( G ) return ElementsStabChain( StabChainMutable(G)); end ); InstallMethod( AsSSortedListNonstored,"via stabchain", true, [ IsPermGroup ], 0, function( G ) return ElementsStabChain( StabChainMutable(G)); end ); ############################################################################# ## #M ONanScottType( ) ## InstallMethod(ONanScottType,"primitive permgroups",true,[IsPermGroup],0, function(G) local dom,s,cs,t,ts,o; dom:=MovedPoints(G); if not IsPrimitive(G,dom) then Error(" must be primitive"); fi; s:=Socle(G); if IsAbelian(s) then return "1"; elif IsSimpleGroup(s) then return "2"; elif Length(dom)=Size(s) then return "5"; else # now get one simple factor of the socle cs:=CompositionSeries(s); # if the group is diagonal, the diagonal together with a maximal socle # normal subgroup generates the whole socle, so this normal subgroup # acts transitively. For product type this is not the case. t:=cs[Length(cs)-1]; if IsTransitive(t,dom) then # type 3 if Length(cs)=3 and IsNormal(G,t) then # intransitive on 2 components: return "3a"; else return "3b"; fi; else # type 4 ts:=Orbit(G,t); if Length(ts)=2 and NormalClosure(G,t)<>s then return "4a"; fi; # find the block on the T's first: Those t which keep the orbit are # glued together diagonally o:=Orbit(t,dom[1]); ts:=Filtered(ts,i->i=t or IsSubset(o,Orbit(i,dom[1]))); if Length(ts)=1 then return "4c"; else return "4b"; fi; fi; fi; end); ############################################################################# ## #M SocleTypePrimitiveGroup( ) ## InstallMethod(SocleTypePrimitiveGroup,"primitive permgroups",true, [IsPermGroup],0,function(G) local s,cs,t,id,r; s:=Socle(G); cs:=CompositionSeries(s); t:=cs[Length(cs)-1]; id:=IsomorphismTypeInfoFiniteSimpleGroup(t); r:=rec(series:=id.series, width:=Length(cs)-1, name:=id.name); if IsBound(id.parameter) then r.parameter:=id.parameter; else r.parameter:=id.name; fi; return r; end); # this function is needed for the transitive and primitive groups libraries BindGlobal("STGSelFunc",function(a,b) if IsFunction(b) then return b(a); elif IsList(b) and not IsString(b) then if IsList(a) and a=b then return true; fi; return a in b; else return a=b; fi; end); InstallGlobalFunction(DiagonalSocleAction,function(g,nr) local ran,d,emb,u,act; ran:=[1..nr]; d:=DirectProduct(List(ran,i->g)); emb:=List(ran,i->Embedding(d,i)); u:=List(GeneratorsOfGroup(g),i->Product(ran,j->Image(emb[j],i))); u:=SubgroupNC(d,u); act:=ActionHomomorphism(d,RightTransversal(d,u),OnRight,"surjective"); return Image(act,d); end); InstallGlobalFunction(ReducedPermdegree,function(g) local dom, deg, orb, gdeg, p, ndom, s,hom; dom:=MovedPoints(g); deg:=Length(dom); orb:=ShallowCopy(Orbits(g,dom)); if Length(orb)=1 then return fail;fi; gdeg:=20*LogInt(Size(g),2); # good degree Sort(orb,function(a,b) return Length(a)Length(i)>=gdeg); if p=fail then p:=Length(orb);fi; ndom:=orb[p]; if Length(ndom)*2>Length(dom) then return fail;fi; s:=Stabilizer(g,orb[p],OnTuples); p:=p+1; if p>Length(orb) then p:=1;fi; while Size(s)>1 do while not ForAny(orb[p],j->ForAny(GeneratorsOfGroup(s),k->j^k<>j)) do p:=p+1; if p>Length(orb) then p:=1;fi; od; ndom:=Union(ndom,orb[p]); s:=Stabilizer(s,orb[p],OnTuples); od; if Length(ndom)*2>Length(dom) then return fail;fi; hom:=ActionHomomorphism(g,ndom,"surjective"); SetIsInjective(hom,true); SetSize(Image(hom),Size(g)); return hom; end); ############################################################################# ## #E gap-4r6p5/lib/numtheor.gd0000644000175000017500000006665412172557252014105 0ustar billbill############################################################################# ## #W numtheor.gd GAP library Martin Schönert ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file declares operations for integer primes. ## <#GAPDoc Label="[1]{numtheor}"> ## &GAP; provides a couple of elementary number theoretic functions. ## Most of these deal with the group of integers coprime to m, ## called the prime residue group. ## The order of this group is \phi(m) (see ), ## and \lambda(m) (see ) is its exponent. ## This group is cyclic if and only if m is 2, 4, ## an odd prime power p^n, or twice an odd prime power 2 p^n. ## In this case the generators of the group, i.e., elements of order ## \phi(m), ## are called primitive roots ## (see ). ##

## Note that neither the arguments nor the return values of the functions ## listed below are groups or group elements in the sense of &GAP;. ## The arguments are simply integers. ## <#/GAPDoc> ## ########################################################################## ## #V InfoNumtheor ## ## <#GAPDoc Label="InfoNumtheor"> ## ## ## ## ## is the info class ## (see ) ## for the functions in the number theory chapter. ## ## ## <#/GAPDoc> ## DeclareInfoClass( "InfoNumtheor" ); ############################################################################# ## #F PrimeResidues( ) . . . . . . . integers relative prime to an integer ## ## <#GAPDoc Label="PrimeResidues"> ## ## ## ## ## returns the set of integers from the range ## [ 0 .. Abs( m )-1 ] ## that are coprime to the integer m. ##

## Abs(m) must be less than 2^{28}, ## otherwise the set would probably be too large anyhow. ##

## PrimeResidues( 0 ); PrimeResidues( 1 ); PrimeResidues( 20 ); ## [ ] ## [ 0 ] ## [ 1, 3, 7, 9, 11, 13, 17, 19 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "PrimeResidues" ); ############################################################################# ## #O Phi( ) . . . . . . . . . . . . . . . . . . Euler's totient function ## ## <#GAPDoc Label="Phi"> ## ## ## ## ## order ## prime residue group ## Euler's totient function ## returns the number \phi(m) of positive ## integers less than the positive integer m ## that are coprime to m. ##

## Suppose that m = p_1^{{e_1}} p_2^{{e_2}} \cdots p_k^{{e_k}}. ## Then \phi(m) is ## p_1^{{e_1-1}} (p_1-1) p_2^{{e_2-1}} (p_2-1) \cdots p_k^{{e_k-1}} (p_k-1). ## Phi( 12 ); ## 4 ## gap> Phi( 2^13-1 ); # this proves that 2^(13)-1 is a prime ## 8190 ## gap> Phi( 2^15-1 ); ## 27000 ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "Phi", [ IsObject ] ); ############################################################################# ## #O Lambda( ) . . . . . . . . . . . . . . . . . . . Carmichaels function ## ## <#GAPDoc Label="Lambda"> ## ## ## ## ## Carmichael's lambda function ## prime residue group ## exponent ## returns the exponent \lambda(m) ## of the group of prime residues modulo the integer m. ##

## \lambda(m) is the smallest positive integer l such that for every ## a relatively prime to m we have a^l \equiv 1 \pmod{m}. ## Fermat's theorem asserts ## a^{{\phi(m)}} \equiv 1 \pmod{m}; ## thus \lambda(m) divides \phi(m) (see ). ##

## Carmichael's theorem states that \lambda can be computed as follows: ## \lambda(2) = 1, \lambda(4) = 2 and ## \lambda(2^e) = 2^{{e-2}} ## if 3 \leq e, ## \lambda(p^e) = (p-1) p^{{e-1}} (i.e. \phi(m)) if p ## is an odd prime and ## \lambda(m*n) = Lcm( \lambda(m), \lambda(n) ) if m, n are coprime. ##

## Composites for which \lambda(m) divides m - 1 are called Carmichaels. ## If 6k+1, 12k+1 and 18k+1 are primes their product is such a number. ## There are only 1547 Carmichaels below 10^{10} but 455052511 primes. ## Lambda( 10 ); ## 4 ## gap> Lambda( 30 ); ## 4 ## gap> Lambda( 561 ); # 561 is the smallest Carmichael number ## 80 ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "Lambda", [ IsObject ] ); ############################################################################# ## #F OrderMod( , ) . . . . . . . . multiplicative order of an integer ## ## <#GAPDoc Label="OrderMod"> ## ## ## ## ## multiplicative order of an integer ## returns the multiplicative order of the integer ## n modulo the positive integer m. ## If n and m are not coprime the order of n is not ## defined and will return 0. ##

## If n and m are relatively prime the multiplicative order of ## n modulo m is the smallest positive integer i ## such that n^i \equiv 1 \pmod{m}. ## If the group of prime residues modulo m is cyclic then ## each element of maximal order is called a primitive root modulo m ## (see ). ##

## usually spends most of its time factoring m ## and \phi(m) (see ). ## OrderMod( 2, 7 ); ## 3 ## gap> OrderMod( 3, 7 ); # 3 is a primitive root modulo 7 ## 6 ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "OrderMod" ); ############################################################################# ## #F IsPrimitiveRootMod( , ) . . . . . . . . test for a primitive root ## ## <#GAPDoc Label="IsPrimitiveRootMod"> ## ## ## ## ## test ## prime residue group ## generator ## returns true if the integer ## r is a primitive root modulo the positive integer m, ## and false otherwise. ## If r is less than 0 or larger than m it is replaced by its ## remainder. ## IsPrimitiveRootMod( 2, 541 ); ## true ## gap> IsPrimitiveRootMod( -539, 541 ); # same computation as above; ## true ## gap> IsPrimitiveRootMod( 4, 541 ); ## false ## gap> ForAny( [1..29], r -> IsPrimitiveRootMod( r, 30 ) ); ## false ## gap> # there is no a primitive root modulo 30 ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "IsPrimitiveRootMod" ); ############################################################################# ## #F PrimitiveRootMod( [, ] ) . . primitive root modulo an integer ## ## <#GAPDoc Label="PrimitiveRootMod"> ## ## ## ## ## primitive root modulo an integer ## prime residue group ## generator ## returns the smallest primitive root modulo ## the positive integer m and fail if no such primitive root ## exists. ## If the optional second integer argument start is given ## returns the smallest primitive root that ## is strictly larger than start. ## # largest primitive root for a prime less than 2000: ## gap> PrimitiveRootMod( 409 ); ## 21 ## gap> PrimitiveRootMod( 541, 2 ); ## 10 ## gap> # 327 is the largest primitive root mod 337: ## gap> PrimitiveRootMod( 337, 327 ); ## fail ## gap> # there exists no primitive root modulo 30: ## gap> PrimitiveRootMod( 30 ); ## fail ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "PrimitiveRootMod" ); ############################################################################# ## #F GeneratorsPrimeResidues( ) . . . . . . generators of the Galois group ## ## <#GAPDoc Label="GeneratorsPrimeResidues"> ## ## ## ## ## Let n be a positive integer. ## returns a description of generators ## of the group of prime residues modulo n. ## The return value is a record with components ## ## primes: ## ## a list of the prime factors of n, ## ## exponents: ## ## a list of the exponents of these primes in the factorization of n, ## and ## ## generators: ## ## a list describing generators of the group of prime residues; ## for the prime factor 2, either a primitive root or a list of two ## generators is stored, ## for each other prime factor of n, a primitive root is stored. ## ## ## GeneratorsPrimeResidues( 1 ); ## rec( exponents := [ ], generators := [ ], primes := [ ] ) ## gap> GeneratorsPrimeResidues( 4*3 ); ## rec( exponents := [ 2, 1 ], generators := [ 7, 5 ], ## primes := [ 2, 3 ] ) ## gap> GeneratorsPrimeResidues( 8*9*5 ); ## rec( exponents := [ 3, 2, 1 ], ## generators := [ [ 271, 181 ], 281, 217 ], primes := [ 2, 3, 5 ] ) ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "GeneratorsPrimeResidues" ); ############################################################################# ## #F Jacobi( , ) . . . . . . . . . . . . . . . . . . . . Jacobi symbol ## ## <#GAPDoc Label="Jacobi"> ## ## ## ## ## quadratic residue ## residue ## returns the value of the ## Kronecker-Jacobi symbol J(n,m) of the integer ## n modulo the integer m. ## It is defined as follows: ##

## If n and m are not coprime then J(n,m) = 0. ## Furthermore, J(n,1) = 1 and J(n,-1) = -1 if m < 0 ## and +1 otherwise. ## And for odd n it is J(n,2) = (-1)^k with ## k = (n^2-1)/8. ## For odd primes m which are coprime to n the ## Kronecker-Jacobi symbol has the same value as the Legendre symbol ## (see ). ##

## For the general case suppose that m = p_1 \cdot p_2 \cdots p_k ## is a product of -1 and of primes, not necessarily distinct, ## and that n is coprime to m. ## Then J(n,m) = J(n,p_1) \cdot J(n,p_2) \cdots J(n,p_k). ##

## Note that the Kronecker-Jacobi symbol coincides with the Jacobi symbol ## that is defined for odd m in many number theory books. ## For odd primes m and n coprime to m it coincides ## with the Legendre symbol. ##

## is very efficient, even for large values of ## n and m, it is about as fast as the Euclidean algorithm ## (see ). ## ## Jacobi( 11, 35 ); # 9^2 = 11 mod 35 ## 1 ## gap> # this is -1, thus there is no r such that r^2 = 6 mod 35 ## gap> Jacobi( 6, 35 ); ## -1 ## gap> # this is 1 even though there is no r with r^2 = 3 mod 35 ## gap> Jacobi( 3, 35 ); ## 1 ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "Jacobi" ); ############################################################################# ## #F Legendre( , ) . . . . . . . . . . . . . . . . . . Legendre symbol ## ## <#GAPDoc Label="Legendre"> ## ## ## ## ## quadratic residue ## residue ## returns the value of the Legendre symbol ## of the integer n modulo the positive integer m. ##

## The value of the Legendre symbol L(n/m) is 1 if n is a ## quadratic residue modulo m, i.e., if there exists an integer r such ## that r^2 \equiv n \pmod{m} and -1 otherwise. ##

## If a root of n exists it can be found by . ##

## While the value of the Legendre symbol usually is only defined for m a ## prime, we have extended the definition to include composite moduli too. ## The Jacobi symbol (see ) is another generalization of the ## Legendre symbol for composite moduli that is much cheaper to compute, ## because it does not need the factorization of m (see ). ##

## A description of the Jacobi symbol, the Legendre symbol, and related ## topics can be found in . ## ## Legendre( 5, 11 ); # 4^2 = 5 mod 11 ## 1 ## gap> # this is -1, thus there is no r such that r^2 = 6 mod 11 ## gap> Legendre( 6, 11 ); ## -1 ## gap> # this is -1, thus there is no r such that r^2 = 3 mod 35 ## gap> Legendre( 3, 35 ); ## -1 ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "Legendre" ); ############################################################################# ## #F RootMod( [, ], ) . . . . . . . . . . . root modulo an integer ## ## <#GAPDoc Label="RootMod"> ## ## ## ## ## quadratic residue ## residue ## root ## computes a kth root of the integer n ## modulo the positive integer m, ## i.e., a r such that ## r^{k} \equiv n \pmod{m}. ## If no such root exists returns fail. ## If only the arguments n and m are given, ## the default value for k is 2. ##

## A square root of n exists only if Legendre(n,m) = 1 ## (see ). ## If m has r different prime factors then there are 2^r different ## roots of n mod m. ## It is unspecified which one returns. ## You can, however, use to compute the full set ## of roots. ##

## is efficient even for large values of m, ## in fact the most time is usually spent factoring m ## (see ). ## ## # note 'RootMod' does not return 8 in this case but -8: ## gap> RootMod( 64, 1009 ); ## 1001 ## gap> RootMod( 64, 3, 1009 ); ## 518 ## gap> RootMod( 64, 5, 1009 ); ## 656 ## gap> List( RootMod( 64, 1009 ) * RootsUnityMod( 1009 ), ## > x -> x mod 1009 ); # set of all square roots of 64 mod 1009 ## [ 1001, 8 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "RootMod" ); ############################################################################# ## #F RootsMod( [, ], ) . . . . . . . . . . . roots modulo an integer ## ## <#GAPDoc Label="RootsMod"> ## ## ## ## ## computes the set of kth roots of the ## integer n modulo the positive integer m, i.e., the list of ## all r such that r^{k} \equiv n \pmod{m}. ## If only the arguments n and m are given, ## the default value for k is 2. ## RootsMod( 1, 7*31 ); # the same as `RootsUnityMod( 7*31 )' ## [ 1, 92, 125, 216 ] ## gap> RootsMod( 7, 7*31 ); ## [ 21, 196 ] ## gap> RootsMod( 5, 7*31 ); ## [ ] ## gap> RootsMod( 1, 5, 7*31 ); ## [ 1, 8, 64, 78, 190 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "RootsMod" ); ############################################################################# ## #F RootsUnityMod( [,] ) . . . . . . roots of unity modulo an integer ## ## <#GAPDoc Label="RootsUnityMod"> ## ## ## ## ## modular roots ## root ## returns the set of k-th roots of unity ## modulo the positive integer m, i.e., ## the list of all solutions r of ## r^{k} \equiv n \pmod{m}. ## If only the argument m is given, ## the default value for k is 2. ##

## In general there are k^n such roots if the modulus m ## has n different prime factors p such that ## p \equiv 1 \pmod{k}. ## If k^2 divides m then there are ## k^{{n+1}} such roots; ## and especially if k = 2 and 8 divides m ## there are 2^{{n+2}} such roots. ##

## In the current implementation k must be a prime. ## RootsUnityMod( 7*31 ); RootsUnityMod( 3, 7*31 ); ## [ 1, 92, 125, 216 ] ## [ 1, 25, 32, 36, 67, 149, 156, 191, 211 ] ## gap> RootsUnityMod( 5, 7*31 ); ## [ 1, 8, 64, 78, 190 ] ## gap> List( RootMod( 64, 1009 ) * RootsUnityMod( 1009 ), ## > x -> x mod 1009 ); # set of all square roots of 64 mod 1009 ## [ 1001, 8 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "RootsUnityMod" ); ############################################################################# ## #F LogMod( , , ) . . . . . . discrete logarithm modulo an integer #F LogModShanks( , , ) ## ## <#GAPDoc Label="LogMod"> ## ## ## ## ## ## logarithm ## computes the discrete r-logarithm of the integer n ## modulo the integer m. ## It returns a number l such that ## r^{l} \equiv n \pmod{m} ## if such a number exists. ## Otherwise fail is returned. ##

## uses the Baby Step - Giant Step Method ## of Shanks (see for example ) ## and in general requires more memory than a call to . ## l:= LogMod( 2, 5, 7 ); 5^l mod 7 = 2; ## 4 ## true ## gap> LogMod( 1, 3, 3 ); LogMod( 2, 3, 3 ); ## 0 ## fail ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "LogMod" ); DeclareGlobalFunction( "LogModShanks" ); DeclareGlobalFunction( "DoLogModRho" ); ############################################################################# ## #O Sigma( ) . . . . . . . . . . . . . . . sum of divisors of an integer ## ## <#GAPDoc Label="Sigma"> ## ## ## ## ## returns the sum of the positive divisors of the ## nonzero integer n. ##

## is a multiplicative arithmetic function, i.e., ## if n and m are relatively prime we have that ## \sigma(n \cdot m) = \sigma(n) \sigma(m). ##

## Together with the formula \sigma(p^k) = (p^{{k+1}}-1) / (p-1) ## this allows us to compute \sigma(n). ##

## Integers n for which \sigma(n) = 2 n ## are called perfect. ## Even perfect integers are exactly of the form ## 2^{{n-1}}(2^{n}-1) ## where 2^{n}-1 is prime. ## Primes of the form 2^{n}-1 are called ## Mersenne primes, and ## 42 among the known Mersenne primes are obtained for n = 2, 3, 5, 7, 13, 17, 19, ## 31, 61, 89, 107, 127, 521, 607, 1279, 2203, 2281, 3217, 4253, 4423, 9689, ## 9941, 11213, 19937, 21701, 23209, 44497, 86243, 110503, 132049, 216091, ## 756839, 859433, 1257787, 1398269, 2976221, 3021377, 6972593, 13466917, ## 20996011, 24036583 and 25964951. Please find more up to date information ## about Mersenne primes at http://www.mersenne.org. ## It is not known whether odd perfect integers exist, ## however  show that any such integer must have ## at least 300 decimal digits. ##

## usually spends most of its time factoring n ## (see ). ##

## Sigma( 1 ); ## 1 ## gap> Sigma( 1009 ); # 1009 is a prime ## 1010 ## gap> Sigma( 8128 ) = 2*8128; # 8128 is a perfect number ## true ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "Sigma", [ IsObject ] ); ############################################################################# ## #O Tau( ) . . . . . . . . . . . . . . number of divisors of an integer ## ## <#GAPDoc Label="Tau"> ## ## ## ## ## returns the number of the positive divisors of the ## nonzero integer n. ##

## is a multiplicative arithmetic function, i.e., ## if n and m are relative prime we have ## \tau(n \cdot m) = \tau(n) \tau(m). ## Together with the formula \tau(p^k) = k+1 this allows us ## to compute \tau(n). ##

## usually spends most of its time factoring n ## (see ). ## Tau( 1 ); ## 1 ## gap> Tau( 1013 ); # thus 1013 is a prime ## 2 ## gap> Tau( 8128 ); ## 14 ## gap> # result is odd if and only if argument is a perfect square: ## gap> Tau( 36 ); ## 9 ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "Tau", [ IsObject ] ); ############################################################################# ## #F MoebiusMu( ) . . . . . . . . . . . . . . Moebius inversion function ## ## <#GAPDoc Label="MoebiusMu"> ## ## ## ## ## computes the value of Moebius inversion function ## for the nonzero integer n. ## This is 0 for integers which are not squarefree, i.e., ## which are divided by a square r^2. ## Otherwise it is 1 if n has a even number and -1 if n ## has an odd number of prime factors. ##

## The importance of \mu stems from the so called inversion formula. ## Suppose f is a multiplicative arithmetic function ## defined on the positive integers and let ## g(n) = \sum_{{d \mid n}} f(d). ## Then f(n) = \sum_{{d \mid n}} \mu(d) g(n/d). ## As a special case we have ## \phi(n) = \sum_{{d \mid n}} \mu(d) n/d ## since n = \sum_{{d \mid n}} \phi(d) ## (see ). ##

## usually spends all of its time factoring n ## (see ). ## MoebiusMu( 60 ); MoebiusMu( 61 ); MoebiusMu( 62 ); ## 0 ## -1 ## 1 ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "MoebiusMu" ); ############################################################################# ## #F TwoSquares( ) . . . . . repres. of an integer as a sum of two squares ## ## <#GAPDoc Label="TwoSquares"> ## ## ## ## ## representation ## returns a list of two integers x \leq y ## such that the sum of the squares of x and y is equal to the ## nonnegative integer n, i.e., n = x^2 + y^2. ## If no such representation exists ## will return fail. ## will return a representation for which the gcd ## of x and y is as small as possible. ## It is not specified which representation returns ## if there is more than one. ##

## Let a be the product of all maximal powers of primes of the form ## 4k+3 dividing n. ## A representation of n as a sum of two squares exists ## if and only if a is a perfect square. ## Let b be the maximal power of 2 dividing n or its ## half, whichever is a perfect square. ## Then the minimal possible gcd of x and y is the square root ## c of a \cdot b. ## The number of different minimal representation with x \leq y is ## 2^{{l-1}}, where l is the number of different prime factors ## of the form 4k+1 of n. ##

## The algorithm first finds a square root r of -1 modulo ## n / (a \cdot b), which must exist, ## and applies the Euclidean algorithm to r and n. ## The first residues in the sequence that are smaller than ## \sqrt{{n/(a \cdot b)}} times c are a possible pair ## x and y. ##

## Better descriptions of the algorithm and related topics can be found in ## and . ## ## TwoSquares( 5 ); ## [ 1, 2 ] ## gap> TwoSquares( 11 ); # there is no representation ## fail ## gap> TwoSquares( 16 ); ## [ 0, 4 ] ## gap> # 3 is the minimal possible gcd because 9 divides 45: ## gap> TwoSquares( 45 ); ## [ 3, 6 ] ## gap> # it is not [5,10] because their gcd is not minimal: ## gap> TwoSquares( 125 ); ## [ 2, 11 ] ## gap> # [10,11] would be the other possible representation: ## gap> TwoSquares( 13*17 ); ## [ 5, 14 ] ## gap> TwoSquares( 848654483879497562821 ); # argument is prime ## [ 6305894639, 28440994650 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "TwoSquares" ); ############################################################################# ## #E gap-4r6p5/lib/fpmon.gi0000644000175000017500000003432112172557252013352 0ustar billbill############################################################################# ## #W fpmon .gi GAP library Isabel Araújo ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ############################################################################# ## ## 1. methods for elements of fp monoids ## ############################################################################# ## #M ElementOfFpMonoid( , ) ## InstallMethod( ElementOfFpMonoid, "for a family of f.p. monoid elements, and an assoc. word", true, [ IsElementOfFpMonoidFamily, IsAssocWordWithOne ], 0, function( fam, elm ) return Objectify( fam!.defaultType, [ Immutable( elm ) ] ); end ); ############################################################################# ## #M UnderlyingElement( ) . . . . . . for element of fp monoid ## InstallMethod( UnderlyingElement, "for an element of an fp monoid (default repres.)", true, [ IsElementOfFpMonoid and IsPackedElementDefaultRep ], 0, obj -> obj![1] ); ############################################################################# ## #M \*( , ) ## InstallMethod( \*, "for two elements of a fp monoid", IsIdenticalObj, [ IsElementOfFpMonoid, IsElementOfFpMonoid], 0, function( x1, x2 ) return ElementOfFpMonoid(FamilyObj(x1), UnderlyingElement(x1)*UnderlyingElement(x2)); end ); ############################################################################# ## #M \<( , ) ## ## This method now uses the rws for monoids (30/01/2002) ## InstallMethod( \<, "for two elements of a f.p. monoid", IsIdenticalObj, [ IsElementOfFpMonoid, IsElementOfFpMonoid], 0, function( x1, x2 ) local s,rws ; s := CollectionsFamily(FamilyObj(x1))!.wholeMonoid; rws := ReducedConfluentRewritingSystem(s); return ReducedForm(rws, UnderlyingElement(x1)) < ReducedForm(rws, UnderlyingElement(x2)); end ); ############################################################################# ## #M \=( , ) ## InstallMethod( \=, "for two elements of a f.p. monoid", IsIdenticalObj, [ IsElementOfFpMonoid, IsElementOfFpMonoid], 0, function( x1, x2 ) local m,rws; m := CollectionsFamily(FamilyObj(x1))!.wholeMonoid; rws:= ReducedConfluentRewritingSystem(m); return ReducedForm(rws, UnderlyingElement(x1)) = ReducedForm(rws, UnderlyingElement(x2)); end ); ############################################################################# ## #M One( ) . . . . . . . . . . . . . for family of fp monoid elements ## InstallOtherMethod( One, "for a family of fp monoid elements", true, [ IsElementOfFpMonoidFamily ], 0, fam -> ElementOfFpMonoid( fam, One( fam!.freeMonoid) ) ); ############################################################################# ## #M One( ) . . . . . . . . . . . . . . . . . for element of fp monoid ## InstallMethod( One, "for an fp monoid element", true, [ IsElementOfFpMonoid ], 0, obj -> One( FamilyObj( obj ) ) ); # a^0 calls OneOp, so we have to catch this as well. InstallMethod( OneOp, "for an fp monoid element", true, [ IsElementOfFpMonoid ], 0, obj -> One( FamilyObj( obj ) ) ); ############################################################################# ## #M PrintObj( ) ## InstallMethod( PrintObj, "for an fp monoid element", true, [ IsElementOfFpMonoid], 0, function( elm ) PrintObj(elm![1]); end ); ############################################################################# ## #M String( ) ## InstallMethod( String, "for an fp monoid element", true, [ IsElementOfFpMonoid], 0, function( elm ) return String(elm![1]); end ); ############################################################################# ## #M FpMonoidOfElementOfFpMonoid( ) ## InstallMethod( FpMonoidOfElementOfFpMonoid, "for an fp monoid element", true, [IsElementOfFpMonoid], 0, elm -> CollectionsFamily(FamilyObj(elm))!.wholeMonoid); ############################################################################# ## #M FpGrpMonSmgOfFpGrpMonSmgElement( ) ## ## for an fp monoid element returns the fp monoid to which ## belongs to ## InstallMethod(FpGrpMonSmgOfFpGrpMonSmgElement, "for an element of an fp monoid", true, [IsElementOfFpMonoid], 0, x -> CollectionsFamily(FamilyObj(x))!.wholeMonoid); ############################################################################# ## ## 2. methods for fp monoids ## ############################################################################# ## #M FactorFreeMonoidByRelations(,) .. Create an FpMonoid ## ## Note: If the monoid has fewer relations than generators, ## then the monoid is certainly infinite. ## InstallGlobalFunction(FactorFreeMonoidByRelations, function( F, rels ) local s, fam, gens, r; # Check that the relations are all lists of length 2 for r in rels do if Length(r) <> 2 then Error("A relation should be a list of length 2"); fi; od; # Create a new family. fam := NewFamily( "FamilyElementsFpMonoid", IsElementOfFpMonoid); # Create the default type for the elements - # putting IsElementOfFpMonoid ensures that lists of these things # have CategoryCollections(IsElementOfFpMonoid). fam!.freeMonoid:= F; fam!.relations := Immutable( rels ); fam!.defaultType := NewType( fam, IsElementOfFpMonoid and IsPackedElementDefaultRep ); # Create the monoid s := Objectify( NewType( CollectionsFamily( fam ), IsMonoid and IsFpMonoid and IsAttributeStoringRep), rec() ); # Mark to be the 'whole monoid' of its later submonoids. FamilyObj( s )!.wholeMonoid:= s; SetOne(s,ElementOfFpMonoid(fam,One(F))); # Create generators of the monoid. gens:= List( GeneratorsOfMonoid( F ), s -> ElementOfFpMonoid( fam, s ) ); SetGeneratorsOfMonoid( s, gens ); if Length(gens) > Length(rels) then SetIsFinite(s, false); fi; return s; end); ############################################################################# ## #M ViewObj( S ) ## ## View an fp monoid S ## InstallMethod( ViewObj, "for a fp monoid with generators", true, [ IsSubmonoidFpMonoid and IsWholeFamily and IsMonoid and HasGeneratorsOfMagma ], 0, function( S ) Print( ""); end ); ############################################################################# ## #M FreeGeneratorsOfFpMonoid( S ) ## ## Generators of the underlying free monoid ## InstallMethod( FreeGeneratorsOfFpMonoid, "for a finitely presented monoid", true, [ IsSubmonoidFpMonoid and IsWholeFamily ], 0, T -> GeneratorsOfMonoid( FreeMonoidOfFpMonoid( T ) ) ); ############################################################################# ## #M FreeMonoidOfFpMonoid( S ) ## ## Underlying free monoid of an fpmonoid ## InstallMethod( FreeMonoidOfFpMonoid, "for a finitely presented monoid", true, [ IsSubmonoidFpMonoid and IsWholeFamily ], 0, T -> ElementsFamily( FamilyObj( T ) )!.freeMonoid); ############################################################################# ## #M RelationsOfFpMonoid( F ) ## InstallOtherMethod( RelationsOfFpMonoid, "method for a free monoid", true, [ IsFreeMonoid], 0, F -> [] ); InstallMethod( RelationsOfFpMonoid, "for finitely presented monoid", true, [ IsSubmonoidFpMonoid and IsWholeFamily ], 0, S -> ElementsFamily( FamilyObj( S ) )!.relations ); ############################################################################# ## #M HomomorphismFactorSemigroup(, ) ## ## for a free monoid and congruence ## InstallOtherMethod(HomomorphismFactorSemigroup, "for a free monoid and a congruence", true, [ IsFreeMonoid, IsMagmaCongruence ], 0, function(s, c) local fp; # the monoid under construction if not s = Source(c) then TryNextMethod(); fi; fp := FactorFreeMonoidByRelations(s, GeneratingPairsOfMagmaCongruence(c)); return MagmaHomomorphismByFunctionNC(s, fp, x->ElementOfFpMonoid(ElementsFamily(FamilyObj(fp)),x) ); end); ############################################################################# ## #M HomomorphismFactorSemigroup(, ) ## ## for fp monoid and congruence ## InstallMethod(HomomorphismFactorSemigroup, "for an fp monoid and a congruence", true, [ IsFpMonoid, IsSemigroupCongruence ], 0, function(s, c) local srels, # the relations of c frels, # srels converted into pairs of words in the free monoid fp; # the monoid under construction if not s = Source(c) then TryNextMethod(); fi; # make the relations, relations of the free monoid srels := GeneratingPairsOfMagmaCongruence(c); frels := List(srels, x->[UnderlyingElement(x[1]),UnderlyingElement(x[2])]); fp := FactorFreeMonoidByRelations(FreeMonoidOfFpMonoid(s), Concatenation(frels, RelationsOfFpMonoid(s))); return MagmaHomomorphismByFunctionNC(s, fp, x->ElementOfFpMonoid(ElementsFamily(FamilyObj(fp)),UnderlyingElement(x)) ); end); ############################################################################# ## #M NaturalHomomorphismByGenerators( S ) ## BindGlobal("FreeMonoidNatHomByGeneratorsNC", function(f, s) return MagmaHomomorphismByFunctionNC(f, s, function(w) local i, # loop var prodt, # product in the target monoid gens, # generators of the target monoid v; # ext rep as , pairs if Length(w) = 0 then return One(Representative(s)); fi; gens := GeneratorsOfMonoid(s); v := ExtRepOfObj(w); prodt := gens[v[1]]^v[2]; for i in [2 .. Length(v)/2] do prodt := prodt*gens[v[2*i-1]]^v[2*i]; od; return prodt; end); end); InstallMethod( NaturalHomomorphismByGenerators, "for a free monoid and monoid", true, [ IsFreeMonoid, IsMonoid and HasGeneratorsOfMagmaWithOne], 0, function(f, s) if Size(GeneratorsOfMagmaWithOne(f)) <> Size(GeneratorsOfMagmaWithOne(s)) then Error("Monoid must have the same rank."); fi; return FreeMonoidNatHomByGeneratorsNC(f, s); end); InstallMethod( NaturalHomomorphismByGenerators, "for an fp monoid and monoid", true, [ IsFpMonoid, IsMonoid and HasGeneratorsOfMonoid], 0, function(f, s) local psi; # the homom from the free monoid if Size(GeneratorsOfMonoid(f)) <> Size(GeneratorsOfMonoid(s)) then Error("Monoids must have the same rank."); fi; psi := FreeMonoidNatHomByGeneratorsNC(FreeMonoidOfFpMonoid(f), s); # check that the relations hold if Length( Filtered(RelationsOfFpMonoid(f), x->x[1]^psi <> x[2]^psi))>0 then return fail; fi; # now create the homomorphism from the fp mon return MagmaHomomorphismByFunctionNC(f, s, e->UnderlyingElement(e)^psi); end); ###################################################################### ## #M IsomorphismFpSemigroup() ## InstallMethod(IsomorphismFpSemigroup, "for an fp monoid", true, [ IsFpMonoid ],0, function(s) local fm, # free monoid underlying s fs, # free semigroup gensfreemon, # generators of fm freesmggens, # generators of fs idgen, # the generator of fs corresponding to the identity rels, # relations of the fp monoid s rel, # a relation from rels smgrels, # the fp monoid relations rewritten for semigroups smgrel, # a relation from smgrels i, # loop variable smg, # the fp semigroup gens, # generators of smg id, # identity of fm isomfun, # the isomorphism nat, # homomorphism from fm to s invfun, # the inverse of isomfun monword2smgword, smgword2monword; ################################################ # monword2smgword # Change a word in the free monoid into a word # in the free semigroup. ################################################ monword2smgword := function(id, w) local wlist, # external rep of the word i; # loop variable wlist := ShallowCopy(ExtRepOfObj(w)); if Length(wlist) = 0 then # it is the identity return id; fi; # have to increment the generators by one to shift # past the identity generator for i in [1..1/2*(Length(wlist))] do wlist[2*i-1] := wlist[2*i-1]+1; od; return ObjByExtRep(FamilyObj(id), wlist); end; ################################################ # smgword2monword # Change a word in the free semigroup into a word # in the free monoid. ################################################ smgword2monword := function(id,w) local wlist; # external rep of the word wlist := ExtRepOfObj(w); if Length(wlist)=0 or (wlist=[1,1]) then # it is the identity return id; fi; # have to decrease each entry by one because # of the identity generator return ObjByExtRep(FamilyObj(id),wlist); end; ################# # function proper # first we create the fp semigroup # get the free monoid underlying the given fp monoid fm := FreeMonoidOfFpMonoid(s); # build the free semigroup gensfreemon := List(GeneratorsOfSemigroup( fm ),String); fs := FreeSemigroup(gensfreemon); freesmggens := GeneratorsOfSemigroup(fs); idgen := freesmggens[1]; # now the relations that make idgen an identity smgrels := [[idgen*idgen,idgen]]; for i in [2..Length(freesmggens)] do Add(smgrels, [idgen*freesmggens[i],freesmggens[i]]); Add(smgrels, [freesmggens[i]*idgen,freesmggens[i]]); od; # now we have to rewrite each of the fp monoid relations # in terms of words in fs rels := RelationsOfFpMonoid(s); for rel in rels do smgrel := [monword2smgword(idgen,rel[1]),monword2smgword(idgen,rel[2])]; Add(smgrels,smgrel); od; # finally create the fp semigroup smg := FactorFreeSemigroupByRelations(fs,smgrels); gens := GeneratorsOfSemigroup(smg); isomfun := x -> ElementOfFpSemigroup( FamilyObj(gens[1] ), monword2smgword( idgen, UnderlyingElement(x))); id := One(fm); nat := NaturalHomomorphismByGenerators(fm,s); invfun := x-> Image( nat,smgword2monword(id,UnderlyingElement(x))); return MagmaIsomorphismByFunctionsNC(s,smg,isomfun,invfun); end); gap-4r6p5/lib/basicim.gd0000644000175000017500000002126412172557252013637 0ustar billbill############################################################################# ## #W basicim.gd GAP Library Gene Cooperman #W and Scott Murray ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1999 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## Allows elements of a group with stabiliser chain to be represented as ## a word in the strong generators and a basic image. This allows for ## more efficient computation in small base groups, provided the words ## do not get too long. ## ## Requires: chain ## Exports: BasicImageGroups ## ############################################################################# ############################################################################# ## ## Basic image group representation ## ############################################################################# ############################################################################# DeclareInfoClass( "InfoBasicImage" ); ############################################################################# ## #R IsBasicImageEltRep ## ## Representation of an element in terms of a word and base image. ## We also store pointers to the base and orbit generators. ## For an orbit generator orb, Image( HomFromFree, orb ) is the ## corresponding word of length one. ## DeclareRepresentation( "IsBasicImageEltRep", IsAssociativeElement, [ "Word", "Base", "BaseImage", "OrbitGenerators", "HomFromFree" ] ); DeclareCategoryCollections( "IsBasicImageEltRep" ); BasicImageEltRepFamily := NewFamily( "BasicImageEltRep", IsBasicImageEltRep ); DeclareSynonym( "IsBasicImageGroup", IsGroup and IsBasicImageEltRepCollection ); ############################################################################# ## #F ConvertToSiftGroup( , , ) ## ## The sift group is used to compute elements as words in the orbit ## generators by shadowed sifting. ## DeclareGlobalFunction( "ConvertToSiftGroup", [ IsGroup, IsList, IsGroupHomomorphism ] ); ############################################################################# ## #F BasicImageGroup( ) ## ## Return the basic image representation of the group . ## DeclareGlobalFunction( "BasicImageGroup", [ IsGroup and HasChainSubgroup ] ); ############################################################################# ## #O BasicImageGroupElement( , , , , #M ) ## ## Construct a basic image group element. ## DeclareOperation( "BasicImageGroupElement", [ IsWord, IsList, IsList, IsList, IsGroupHomomorphism ] ); ############################################################################# ## #O BasicImageGroupElement( , ) ## ## Strip and convert it to a basic image group element. ## DeclareOperation( "BasicImageGroupElement", [ IsBasicImageGroup, IsAssociativeElement ] ); ############################################################################# ## #O BasicImageGroupElement( <> ) ## ## Construct a basic image group element. ## DeclareOperation( "BasicImageGroupElement", [ IsGroup and HasChainSubgroup, IsGroupHomomorphism, IsList, IsAssociativeElement ] ); ############################################################################# ############################################################################# ## ## Attributes of basic image groups ## ## These attributes are set by the function BasicImageGroup. ## They cannot be computed, so there is no methods for them. ## ############################################################################# ############################################################################# ############################################################################# ## #A OrbitGeneratorsOfGroup( ) ## DeclareAttribute( "OrbitGeneratorsOfGroup", IsBasicImageGroup ); ############################################################################# ## #A BaseOfBasicImageGroup( ) ## DeclareAttribute( "BaseOfBasicImageGroup", IsBasicImageGroup ); ############################################################################# ## #A FreeGroupOfBasicImageGroup( ) ## DeclareAttribute( "FreeGroupOfBasicImageGroup", IsBasicImageGroup ); ############################################################################# ## #A SiftGroup( ) ## DeclareAttribute( "SiftGroup", IsBasicImageGroup ); ############################################################################# ## #A HomFromFreeOfBasicImageGroup( ) ## DeclareAttribute( "HomFromFreeOfBasicImageGroup", IsBasicImageGroup ); ############################################################################# ## #A FreeGroupOfBasicImageGroup( ) ## DeclareAttribute( "FreeGroupOfBasicImageGroup", IsBasicImageGroup ); ############################################################################# ############################################################################# ## ## Properties of basic image elements ## ############################################################################# ############################################################################# ############################################################################# ## #O Word( ) ## ## The word in the strong generators. ## DeclareOperation( "Word", [ IsBasicImageEltRep ] ); ############################################################################# ## #O BaseOfElt( ) ## DeclareOperation( "BaseOfElt", [ IsBasicImageEltRep ] ); ############################################################################# ## #O BaseImage( ) ## DeclareOperation( "BaseImage", [ IsBasicImageEltRep ] ); ############################################################################# ## #O OrbitGenerators( ) ## DeclareOperation( "OrbitGenerators", [ IsBasicImageEltRep ] ); ############################################################################# ## #O HomFromFree( ) ## DeclareOperation( "HomFromFree", [ IsBasicImageEltRep ] ); ############################################################################# ## #O FreeGroupOfElt( ) ## DeclareOperation( "FreeGroupOfElt", [ IsBasicImageEltRep ] ); ############################################################################# ############################################################################# ## ## Conversion to ordinary element ## ############################################################################# ############################################################################# ############################################################################# ## #A ConvertBasicImageGroupElement( ) ## ## Converts a basic image group element to an ordinary element. ## DeclareAttribute( "ConvertBasicImageGroupElement", IsBasicImageEltRep ); ############################################################################# ############################################################################# ## ## Basic operations ## ############################################################################# ############################################################################# ############################################################################# ## #O ONE( ) ## DeclareOperation( "ONE", [ IsBasicImageEltRep ] ); ############################################################################# ## #A One( ) ## DeclareAttribute( "One", IsBasicImageEltRep ); ############################################################################# ## #O INV( ) ## DeclareOperation( "INV", [ IsBasicImageEltRep ] ); ############################################################################# ## #A Inverse( ) ## DeclareAttribute( "Inverse", IsBasicImageEltRep ); ############################################################################# ## #O QUO( , ) ## DeclareOperation( "QUO", [ IsBasicImageEltRep, IsBasicImageEltRep ] ); ##DeclareOperation( "POW", [ IsBasicImageEltRep ] ); ############################################################################# ## #O COMM( , ) ## DeclareOperation( "COMM", [ IsBasicImageEltRep, IsBasicImageEltRep ] ); ############################################################################# ############################################################################# ## ## Computing presentations ## ## Basic images can be used to compute a presentation for the group . ## ############################################################################# ############################################################################# ############################################################################# ## #A Presentation( ) ## ## Computes a presentation for the group . ## DeclareAttribute( "Presentation", IsGroup ); #E gap-4r6p5/lib/orders.gd0000644000175000017500000006503412172557252013531 0ustar billbill############################################################################# ## #W orders.gd GAP library Isabel Araújo ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## These file contains declarations for orderings. ## ## <#GAPDoc Label="[1]{orders}"> ## In &GAP; an ordering is a relation defined on a family, which is ## reflexive, anti-symmetric and transitive. ## <#/GAPDoc> ############################################################################# ## #C IsOrdering( ) ## ## <#GAPDoc Label="IsOrdering"> ## ## ## ## ## returns true if and only if the object ord is an ordering. ## ## ## <#/GAPDoc> ## DeclareCategory( "IsOrdering" ,IsObject); ############################################################################# ## #A OrderingsFamily( ) . . . . . . . . . . make an orderings family ## ## <#GAPDoc Label="OrderingsFamily"> ## ## ## ## ## for a family fam, returns the family of all ## orderings on elements of fam. ## ## ## <#/GAPDoc> ## DeclareAttribute( "OrderingsFamily", IsFamily ); ############################################################################# ## ## General Properties for orderings ## ############################################################################# ## #P IsWellFoundedOrdering( ) ## ## <#GAPDoc Label="IsWellFoundedOrdering"> ## ## ## ## ## for an ordering ord, ## returns true if and only if the ordering is well founded. ## An ordering ord is well founded if it admits no infinite descending ## chains. ## Normally this property is set at the time of creation of the ordering ## and there is no general method to check whether a certain ordering ## is well founded. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsWellFoundedOrdering" ,IsOrdering); ############################################################################# ## #P IsTotalOrdering( ) ## ## <#GAPDoc Label="IsTotalOrdering"> ## ## ## ## ## for an ordering ord, ## returns true if and only if the ordering is total. ## An ordering ord is total if any two elements of the family ## are comparable under ord. ## Normally this property is set at the time of creation of the ordering ## and there is no general method to check whether a certain ordering ## is total. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsTotalOrdering" ,IsOrdering); ############################################################################# ## ## General attributes and operations ## ############################################################################# ## #A FamilyForOrdering( ) ## ## <#GAPDoc Label="FamilyForOrdering"> ## ## ## ## ## for an ordering ord, ## returns the family of elements that the ordering ord compares. ## ## ## <#/GAPDoc> ## DeclareAttribute( "FamilyForOrdering" ,IsOrdering); ############################################################################# ## #A LessThanFunction( ) ## ## <#GAPDoc Label="LessThanFunction"> ## ## ## ## ## for an ordering ord, ## returns a function f which takes two elements el1, ## el2 in FamilyForOrdering(ord) and returns ## true if el1 is strictly less than el2 ## (with respect to ord), and returns false otherwise. ## ## ## <#/GAPDoc> ## DeclareAttribute( "LessThanFunction" ,IsOrdering); ############################################################################# ## #A LessThanOrEqualFunction( ) ## ## <#GAPDoc Label="LessThanOrEqualFunction"> ## ## ## ## ## for an ordering ord, ## returns a function that takes two elements el1, el2 in ## FamilyForOrdering(ord) and returns true ## if el1 is less than or equal to el2 ## (with respect to ord), and returns false otherwise. ## ## ## <#/GAPDoc> ## DeclareAttribute( "LessThanOrEqualFunction" ,IsOrdering); ############################################################################# ## #O IsLessThanUnder( , , ) ## ## <#GAPDoc Label="IsLessThanUnder"> ## ## ## ## ## for an ordering ord on the elements of the family of el1 ## and el2, returns true if el1 is (strictly) less than ## el2 with respect to ord, and false otherwise. ## ## ## <#/GAPDoc> ## DeclareOperation( "IsLessThanUnder" ,[IsOrdering,IsObject,IsObject]); ############################################################################# ## #O IsLessThanOrEqualUnder( , , ) ## ## <#GAPDoc Label="IsLessThanOrEqualUnder"> ## ## ## ## ## for an ordering ord on the elements of the family of el1 ## and el2, returns true if el1 is less than or equal ## to el2 with respect to ord, and false otherwise. ## IsLessThanUnder(ord,a,a*b); ## true ## gap> IsLessThanOrEqualUnder(ord,a*b,a*b); ## true ## gap> IsIncomparableUnder(ord,a,b); ## true ## gap> FamilyForOrdering(ord) = FamilyObj(a); ## true ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "IsLessThanOrEqualUnder" ,[IsOrdering,IsObject,IsObject]); ############################################################################# ## #O IsIncomparableUnder( , , ) ## ## <#GAPDoc Label="IsIncomparableUnder"> ## ## ## ## ## for an ordering ord on the elements of the family of el1 ## and el2, returns true if el1 \neq el2 ## and IsLessThanUnder(ord,el1,el2), ## IsLessThanUnder(ord,el2,el1) are both ## false; and returns false otherwise. ## ## ## <#/GAPDoc> ## DeclareOperation( "IsIncomparableUnder" ,[IsOrdering,IsObject,IsObject]); ############################################################################# ## ## Building new orderings ## ############################################################################# ## #O OrderingByLessThanFunctionNC( , [, ] ) ## ## <#GAPDoc Label="OrderingByLessThanFunctionNC"> ## ## ## ## ## Called with two arguments, ## returns the ordering on the elements of the elements of the family ## fam, according to the value given ## by lt, ## where lt is a function that takes two ## arguments in fam and returns true or false. ##

## Called with three arguments, for a family fam, ## a function lt that takes two arguments in fam and returns ## true or false, and a list l ## of properties of orderings, ## returns the ordering on the elements of fam with ## value given by lt ## and with the properties from l set to true. ## ## ## <#/GAPDoc> ## DeclareOperation( "OrderingByLessThanFunctionNC" ,[IsFamily,IsFunction]); ############################################################################# ## #O OrderingByLessThanOrEqualFunctionNC( , [, ] ) ## ## <#GAPDoc Label="OrderingByLessThanOrEqualFunctionNC"> ## ## ## ## ## Called with two arguments, ## returns the ordering on ## the elements of the elements of the family fam according to ## the value given by lteq, ## where lteq is a function that takes two arguments in fam ## and returns true or false. ##

## Called with three arguments, for a family fam, ## a function lteq that takes two arguments in fam and returns ## true or false, and a list l ## of properties of orderings, ## ## returns the ordering on the elements of fam with ## value given by lteq ## and with the properties from l set to true. ##

## Notice that these functions do not check whether fam and lt ## or lteq are compatible, ## and whether the properties listed in l are indeed satisfied. ## f := FreeSemigroup("a","b");; ## gap> a := GeneratorsOfSemigroup(f)[1];; ## gap> b := GeneratorsOfSemigroup(f)[2];; ## gap> lt := function(x,y) return Length(x) fam := FamilyObj(a);; ## gap> ord := OrderingByLessThanFunctionNC(fam,lt); ## Ordering ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "OrderingByLessThanOrEqualFunctionNC" , [IsFamily,IsFunction]); ############################################################################ ## ## Orderings on families of associative words ## ## <#GAPDoc Label="[2]{orders}"> ## We now consider orderings on families of associative words. ##

## Examples of families of associative words are the families of elements ## of a free semigroup or a free monoid; ## these are the two cases that we consider mostly. ## Associated with those families is ## an alphabet, which is the semigroup (resp. monoid) generating set ## of the correspondent free semigroup (resp. free monoid). ## For definitions of the orderings considered, ## see Sims . ## <#/GAPDoc> ## ## The ordering on the letters of the alphabet is important when ## defining an order in such a family. ## An alphabet has a default ordering: the generators of a free semigroup ## or free monoid are indexed on [ 1, 2, \ldots, n ], ## where n is the size of the alphabet. ## Another ordering on the alphabet will always be given in terms ## of this one, either in terms of a list of length n, where position ## i (1 \leq i \leq n) indicates what is the i-th ## generator in the ordering, or else as a list of the generators, ## starting from the smallest one. ## ############################################################################# ## #P IsOrderingOnFamilyOfAssocWords( ) ## ## <#GAPDoc Label="IsOrderingOnFamilyOfAssocWords"> ## ## ## ## ## for an ordering ord, ## returns true if ord is an ordering over a family of associative ## words. ## ## ## <#/GAPDoc> ## DeclareProperty("IsOrderingOnFamilyOfAssocWords",IsOrdering); ############################################################################# ## #A LetterRepWordsLessFunc( ) ## ## ## ## ## ## If ord is an ordering for associative words, ## this attribute (if known) will hold a function which implements a ## less than function for words given by a list of letters ## (see ). ## ## ## DeclareAttribute( "LetterRepWordsLessFunc" ,IsOrderingOnFamilyOfAssocWords); ############################################################################# ## #P IsTranslationInvariantOrdering( ) ## ## <#GAPDoc Label="IsTranslationInvariantOrdering"> ## ## ## ## ## for an ordering ord on a family of associative words, ## returns true if and only if the ordering is translation invariant. ##

## This is a property of orderings on families of associative words. ## An ordering ord over a family F, with alphabet X ## is translation invariant if ## IsLessThanUnder( ord, u, v ) implies ## that for any a, b \in X^*, ## IsLessThanUnder( ord, a*u*b, a*v*b ). ## ## ## <#/GAPDoc> ## DeclareProperty( "IsTranslationInvariantOrdering" ,IsOrdering and IsOrderingOnFamilyOfAssocWords); ############################################################################# ## #P IsReductionOrdering( ) ## ## <#GAPDoc Label="IsReductionOrdering"> ## ## ## ## ## for an ordering ord on a family of associative words, ## returns true if and only if the ordering is a reduction ordering. ## An ordering ord is a reduction ordering ## if it is founded and translation invariant. ## ## ## <#/GAPDoc> ## DeclareSynonym( "IsReductionOrdering", IsTranslationInvariantOrdering and IsWellFoundedOrdering ); ## The ordering on the letters of the alphabet is important when ## defining an order in a family of associative words. ## An alphabet has a default ordering: the generators of a free semigroup ## or free monoid are indexed on [1,2,\ldots,n], where n is the size of ## the alphabet. Another ordering on the alphabet will always be given in terms ## of this one, either in terms of a list gensord of length n, ## where position i (1 \leq i \leq n) indicates what is the i-th ## generator in the ordering, or else as a list alphabet of the generators, ## starting from the smallest one. ############################################################################# ## #A OrderingOnGenerators( ) ## ## <#GAPDoc Label="OrderingOnGenerators"> ## ## ## ## ## for an ordering ord on a family of associative words, ## returns a list in which the generators are considered. ## This could be indeed the ordering of the generators in the ordering, ## but, for example, if a weight is associated to each generator ## then this is not true anymore. ## See the example for . ## ## ## <#/GAPDoc> ## DeclareAttribute("OrderingOnGenerators",IsOrdering and IsOrderingOnFamilyOfAssocWords); ############################################################################# ## #O LexicographicOrdering( [, ] ) ## ## <#GAPDoc Label="LexicographicOrdering"> ## ## ## ## ## Let D be a free semigroup, a free monoid, or the elements ## family of such a domain. ## Called with only argument D, ## returns the lexicographic ## ordering on the elements of D. ##

## The optional argument gens can be either the list of free ## generators of D, in the desired order, ## or a list of the positions of these generators, ## in the desired order, ## and returns the lexicographic ## ordering on the elements of D with the ordering on the ## generators as given. ## f := FreeSemigroup(3); ## ## gap> lex := LexicographicOrdering(f,[2,3,1]); ## Ordering ## gap> IsLessThanUnder(lex,f.2*f.3,f.3); ## true ## gap> IsLessThanUnder(lex,f.3,f.2); ## false ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation("LexicographicOrdering", [IsFamily and IsAssocWordFamily, IsList and IsAssocWordCollection]); ############################################################################# ## #O ShortLexOrdering( [, ] ) ## ## <#GAPDoc Label="ShortLexOrdering"> ## ## ## ## ## Let D be a free semigroup, a free monoid, or the elements ## family of such a domain. ## Called with only argument D, ## returns the shortlex ## ordering on the elements of D. ##

## The optional argument gens can be either the list of free ## generators of D, in the desired order, ## or a list of the positions of these generators, ## in the desired order, ## and returns the shortlex ## ordering on the elements of D with the ordering on the ## generators as given. ## ## ## <#/GAPDoc> ## DeclareOperation("ShortLexOrdering",[IsFamily and IsAssocWordFamily, IsList and IsAssocWordCollection]); ############################################################################# ## #P IsShortLexOrdering( ) ## ## <#GAPDoc Label="IsShortLexOrdering"> ## ## ## ## ## for an ordering ord of a family of associative words, ## returns true if and only if ord is a shortlex ordering. ## f := FreeSemigroup(3); ## ## gap> sl := ShortLexOrdering(f,[2,3,1]); ## Ordering ## gap> IsLessThanUnder(sl,f.1,f.2); ## false ## gap> IsLessThanUnder(sl,f.3,f.2); ## false ## gap> IsLessThanUnder(sl,f.3,f.1); ## true ## ]]> ## ## ## <#/GAPDoc> ## DeclareProperty("IsShortLexOrdering",IsOrdering and IsOrderingOnFamilyOfAssocWords); ############################################################################# ## #F IsShortLexLessThanOrEqual( , ) ## ## <#GAPDoc Label="IsShortLexLessThanOrEqual"> ## ## ## ## ## returns IsLessThanOrEqualUnder(ord, u, v) ## where ord is the short less ordering for the family of u ## and v. ## (This is here for compatibility with &GAP; 4.2.) ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "IsShortLexLessThanOrEqual" ); ############################################################################# ## #O WeightLexOrdering( , , ) ## ## <#GAPDoc Label="WeightLexOrdering"> ## ## ## ## ## Let D be a free semigroup, a free monoid, or the elements ## family of such a domain. gens can be either the list of free ## generators of D, in the desired order, ## or a list of the positions of these generators, in the desired order. ## Let wt be a list of weights. ## returns the weightlex ## ordering on the elements of D with the ordering on the ## generators and weights of the generators as given. ## ## ## <#/GAPDoc> ## DeclareOperation("WeightLexOrdering", [IsFamily and IsAssocWordFamily,IsList and IsAssocWordCollection,IsList]); ############################################################################# ## #A WeightOfGenerators( ) ## ## <#GAPDoc Label="WeightOfGenerators"> ## ## ## ## ## for a weightlex ordering ord, ## returns a list with length the size of the alphabet of the family. ## This list gives the weight of each of the letters of the alphabet ## which are used for weightlex orderings with respect to the ## ordering given by . ## f := FreeSemigroup(3); ## ## gap> wtlex := WeightLexOrdering(f,[f.2,f.3,f.1],[3,2,1]); ## Ordering ## gap> IsLessThanUnder(wtlex,f.1,f.2); ## true ## gap> IsLessThanUnder(wtlex,f.3,f.2); ## true ## gap> IsLessThanUnder(wtlex,f.3,f.1); ## false ## gap> OrderingOnGenerators(wtlex); ## [ s2, s3, s1 ] ## gap> WeightOfGenerators(wtlex); ## [ 3, 2, 1 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute("WeightOfGenerators",IsOrdering and IsOrderingOnFamilyOfAssocWords); ############################################################################# ## #P IsWeightLexOrdering( ) ## ## <#GAPDoc Label="IsWeightLexOrdering"> ## ## ## ## ## for an ordering ord on a family of associative words, ## returns true if and only if ord is a weightlex ordering. ## ## ## <#/GAPDoc> ## DeclareProperty("IsWeightLexOrdering",IsOrdering and IsOrderingOnFamilyOfAssocWords); ############################################################################# ## #O BasicWreathProductOrdering( [, ] ) ## ## <#GAPDoc Label="BasicWreathProductOrdering"> ## ## ## ## ## Let D be a free semigroup, a free monoid, or the elements ## family of such a domain. ## Called with only argument D, ## returns the basic wreath product ## ordering on the elements of D. ##

## The optional argument gens can be either the list of free ## generators of D, in the desired order, ## or a list of the positions of these generators, ## in the desired order, ## and returns the lexicographic ## ordering on the elements of D with the ordering on the ## generators as given. ## ## ## <#/GAPDoc> ## DeclareOperation("BasicWreathProductOrdering",[IsAssocWordFamily,IsList]); ############################################################################# ## #P IsBasicWreathProductOrdering( ) ## ## <#GAPDoc Label="IsBasicWreathProductOrdering"> ## ## ## ## ## f := FreeSemigroup(3); ## ## gap> basic := BasicWreathProductOrdering(f,[2,3,1]); ## Ordering ## gap> IsLessThanUnder(basic,f.3,f.1); ## true ## gap> IsLessThanUnder(basic,f.3*f.2,f.1); ## true ## gap> IsLessThanUnder(basic,f.3*f.2*f.1,f.1*f.3); ## false ## ]]> ## ## ## <#/GAPDoc> ## DeclareProperty("IsBasicWreathProductOrdering",IsOrdering); ############################################################################# ## #F IsBasicWreathLessThanOrEqual( , ) ## ## <#GAPDoc Label="IsBasicWreathLessThanOrEqual"> ## ## ## ## ## returns IsLessThanOrEqualUnder(ord, u, v) ## where ord is the basic wreath product ordering for the family of ## u and v. ## (This is here for compatibility with &GAP; 4.2.) ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "IsBasicWreathLessThanOrEqual" ); ############################################################################# ## #O WreathProductOrdering( [, ], ) ## ## <#GAPDoc Label="WreathProductOrdering"> ## ## ## ## ## Let D be a free semigroup, a free monoid, or the elements ## family of such a domain, ## let gens be either the list of free generators of D, ## in the desired order, ## or a list of the positions of these generators, in the desired order, ## and let levels be a list of levels for the generators. ## If gens is omitted then the default ordering is taken. ## returns the wreath product ## ordering on the elements of D with the ordering on the ## generators as given. ## ## ## <#/GAPDoc> ## DeclareOperation("WreathProductOrdering",[IsFamily,IsList,IsList]); ############################################################################# ## #P IsWreathProductOrdering( ) ## ## <#GAPDoc Label="IsWreathProductOrdering"> ## ## ## ## ## specifies whether an ordering is a wreath product ordering ## (see ). ## ## ## <#/GAPDoc> ## DeclareProperty("IsWreathProductOrdering",IsOrdering); ############################################################################# ## #A LevelsOfGenerators( ) ## ## <#GAPDoc Label="LevelsOfGenerators"> ## ## ## ## ## for a wreath product ordering ord, returns the levels ## of the generators as given at creation ## (with respect to ). ## f := FreeSemigroup(3); ## ## gap> wrp := WreathProductOrdering(f,[1,2,3],[1,1,2,]); ## Ordering ## gap> IsLessThanUnder(wrp,f.3,f.1); ## false ## gap> IsLessThanUnder(wrp,f.3,f.2); ## false ## gap> IsLessThanUnder(wrp,f.1,f.2); ## true ## gap> LevelsOfGenerators(wrp); ## [ 1, 1, 2 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute("LevelsOfGenerators",IsOrdering and IsWreathProductOrdering); ############################################################################# ## #E gap-4r6p5/lib/algfld.gd0000644000175000017500000001205312172557252013455 0ustar billbill############################################################################# ## #W algfld.gd GAP Library Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1999 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the categories, attributes, properties and operations ## for algebraic extensions of fields and their elements ############################################################################# ## #C IsAlgebraicElement() ## ## <#GAPDoc Label="IsAlgebraicElement"> ## ## ## ## ## is the category for elements of an algebraic extension. ## ## ## <#/GAPDoc> ## DeclareCategory( "IsAlgebraicElement", IsScalar and IsZDFRE and IsAssociativeElement and IsAdditivelyCommutativeElement and IsCommutativeElement); DeclareCategoryCollections( "IsAlgebraicElement"); DeclareCategoryCollections( "IsAlgebraicElementCollection"); DeclareCategoryCollections( "IsAlgebraicElementCollColl"); ############################################################################# ## #C IsAlgebraicElementFamily Category for Families of Algebraic Elements ## ## ## ## ## ## ## ## DeclareCategoryFamily( "IsAlgebraicElement" ); ############################################################################# ## #C IsAlgebraicExtension() ## ## <#GAPDoc Label="IsAlgebraicExtension"> ## ## ## ## ## is the category of algebraic extensions of fields. ## IsAlgebraicExtension(e); ## true ## gap> IsAlgebraicExtension(Rationals); ## false ## ]]> ## ## ## <#/GAPDoc> ## DeclareCategory( "IsAlgebraicExtension", IsField ); ############################################################################# ## #A AlgebraicElementsFamilies List of AlgElm. families to one poly over ## ## ## ## ## ## ## ## DeclareAttribute( "AlgebraicElementsFamilies", IsUnivariatePolynomial, "mutable" ); ############################################################################# ## #O AlgebraicElementsFamily Create Family of alg elms ## ## ## ## ## ## ## ## DeclareOperation( "AlgebraicElementsFamily", [IsField,IsUnivariatePolynomial]); ############################################################################# ## #O AlgebraicExtension(,) ## ## <#GAPDoc Label="AlgebraicExtension"> ## ## ## ## ## constructs an extension L of the field K by one root of the ## irreducible polynomial f, using Kronecker's construction. ## L is a field whose value is ## K. ## The polynomial f is the value ## of L and the attribute ## ## of L holds a root of f in L. ## x:=Indeterminate(Rationals,"x");; ## gap> p:=x^4+3*x^2+1;; ## gap> e:=AlgebraicExtension(Rationals,p); ## ## gap> IsField(e); ## true ## gap> a:=RootOfDefiningPolynomial(e); ## a ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "AlgebraicExtension", [IsField,IsUnivariatePolynomial]); ############################################################################# ## #F MaxNumeratorCoeffAlgElm() ## ## ## ## ## ## maximal (absolute value, in numerator) ## coefficient in the representation of algebraic elm. a ## ## ## DeclareOperation("MaxNumeratorCoeffAlgElm",[IsScalar]); ############################################################################# ## #F DefectApproximation( ) . . . . . . . approximation for defect K, i.e. #F denominators of integer elements in K ## ## ## ## ## ## ## ## DeclareAttribute("DefectApproximation",IsAlgebraicExtension); ############################################################################# ## #F AlgExtEmbeddedPol(,) ## ## ## ## ## ## ## ## DeclareGlobalFunction("AlgExtEmbeddedPol"); DeclareGlobalFunction("AlgExtSquareHensel"); gap-4r6p5/lib/ringpoly.gd0000644000175000017500000004354612172557254014104 0ustar billbill############################################################################# ## #W ringpoly.gd GAP Library Frank Celler ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1999 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the categories, attributes, properties and operations ## for polynomial rings and function fields. ## ############################################################################# ## #C IsPolynomialRing( ) ## ## <#GAPDoc Label="IsPolynomialRing"> ## ## ## ## ## is the category of polynomial rings ## ## ## <#/GAPDoc> ## DeclareCategory( "IsPolynomialRing", IsRing ); ############################################################################# ## #C IsFunctionField( ) ## ## <#GAPDoc Label="IsFunctionField"> ## ## ## ## ## is the category of function fields ## ## ## <#/GAPDoc> ## DeclareCategory("IsFunctionField",IsRing); ############################################################################# ## #C IsUnivariatePolynomialRing( ) ## ## <#GAPDoc Label="IsUnivariatePolynomialRing"> ## ## ## ## ## is the category of polynomial rings with one indeterminate. ## r:=UnivariatePolynomialRing(Rationals,"p"); ## Rationals[p] ## gap> r2:=PolynomialRing(Rationals,["q"]); ## Rationals[q] ## gap> IsUnivariatePolynomialRing(r); ## true ## gap> IsUnivariatePolynomialRing(r2); ## true ## ]]> ## ## ## <#/GAPDoc> ## DeclareCategory( "IsUnivariatePolynomialRing", IsPolynomialRing ); ############################################################################# ## #C IsFiniteFieldPolynomialRing( ) ## ## <#GAPDoc Label="IsFiniteFieldPolynomialRing"> ## ## ## ## ## is the category of polynomial rings over a finite field ## (see Chapter ). ## ## ## <#/GAPDoc> ## DeclareCategory( "IsFiniteFieldPolynomialRing", IsPolynomialRing ); ############################################################################# ## #C IsAbelianNumberFieldPolynomialRing( ) ## ## <#GAPDoc Label="IsAbelianNumberFieldPolynomialRing"> ## ## ## ## ## is the category of polynomial rings over a field of cyclotomics ## (see the chapters  and ). ## ## ## <#/GAPDoc> ## DeclareCategory( "IsAbelianNumberFieldPolynomialRing", IsPolynomialRing ); ############################################################################# ## #C IsAlgebraicExtensionPolynomialRing( ) ## ## ## ## ## ## is the category of polynomial rings over a field that has been formed as ## an AlgebraicExtension of a base field. ## (see chapter ). ## ## ## DeclareCategory( "IsAlgebraicExtensionPolynomialRing", IsPolynomialRing ); ############################################################################# ## #C IsRationalsPolynomialRing( ) ## ## <#GAPDoc Label="IsRationalsPolynomialRing"> ## ## ## ## ## is the category of polynomial rings over the rationals ## (see Chapter ). ## r := PolynomialRing(Rationals, ["a", "b"] );; ## gap> IsPolynomialRing(r); ## true ## gap> IsFiniteFieldPolynomialRing(r); ## false ## gap> IsRationalsPolynomialRing(r); ## true ## ]]> ## ## ## <#/GAPDoc> ## DeclareCategory( "IsRationalsPolynomialRing", IsAbelianNumberFieldPolynomialRing ); ############################################################################# ## #A CoefficientsRing( ) ## ## <#GAPDoc Label="CoefficientsRing"> ## ## ## ## ## returns the ring of coefficients of the polynomial ring pring, ## that is the ring over which pring was defined. ## r:=PolynomialRing(GF(7)); ## GF(7)[x_1] ## gap> r:=PolynomialRing(GF(7),3); ## GF(7)[x_1,x_2,x_3] ## gap> IndeterminatesOfPolynomialRing(r); ## [ x_1, x_2, x_3 ] ## gap> r2:=PolynomialRing(GF(7),[5,7,12]); ## GF(7)[x_5,x_7,x_12] ## gap> CoefficientsRing(r); ## GF(7) ## gap> r:=PolynomialRing(GF(7),3); ## GF(7)[x_1,x_2,x_3] ## gap> r2:=PolynomialRing(GF(7),3,IndeterminatesOfPolynomialRing(r)); ## GF(7)[x_4,x_5,x_6] ## gap> r:=PolynomialRing(GF(7),["x","y","z","z2"]); ## GF(7)[x,y,z,z2] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "CoefficientsRing", IsPolynomialRing ); ## <#GAPDoc Label="[1]{ringpoly}"> ## Internally, indeterminates are created for a family of objects ## (for example all elements of finite fields in characteristic 3 are in ## one family). Thus a variable x over the ## rationals is also an x over the integers, ## while an x over GF(3) is different. ##

## Within one family, every indeterminate has a number nr and as ## long as no other names have been assigned, this indeterminate will be ## displayed as ## x_nr. Indeterminate numbers can be arbitrary ## nonnegative integers. ##

## It is possible to assign names to indeterminates; these names are ## strings and only provide a means for printing the indeterminates in a ## nice way. Indeterminates that have not been assigned a name will be ## printed as x_nr. ##

## (Because of this printing convention, the name x_nr is interpreted ## specially to always denote the variable with internal number nr.) ##

## The indeterminate names have not necessarily any relations to variable ## names: this means that an indeterminate whose name is, say, x ## cannot be accessed using the variable x, unless x was defined to ## be that indeterminate. ## <#/GAPDoc> ## ## <#GAPDoc Label="[2]{ringpoly}"> ## When asking for indeterminates with certain ## names, &GAP; usually will take the first (with respect to the internal ## numbering) indeterminates that are not ## yet named, name these accordingly and return them. Thus when asking for ## named indeterminates, no relation between names and indeterminate ## numbers can be guaranteed. The attribute ## IndeterminateNumberOfLaurentPolynomial(indet) will return ## the number of the indeterminate indet. ##

## When asked to create an indeterminate with a name that exists already for ## the family, &GAP; will by default return this existing indeterminate. If ## you explicitly want a new indeterminate, distinct from the already ## existing one with the same name, you can add the new option ## to the function call. (This is in most cases not a good idea.) ##

## R:=PolynomialRing(GF(3),["x","y","z"]); ## GF(3)[x,y,z] ## gap> List(IndeterminatesOfPolynomialRing(R), ## > IndeterminateNumberOfLaurentPolynomial); ## [ 1, 2, 3 ] ## gap> R:=PolynomialRing(GF(3),["z"]); ## GF(3)[z] ## gap> List(IndeterminatesOfPolynomialRing(R), ## > IndeterminateNumberOfLaurentPolynomial); ## [ 3 ] ## gap> R:=PolynomialRing(GF(3),["x","y","z"]:new); ## GF(3)[x,y,z] ## gap> List(IndeterminatesOfPolynomialRing(R), ## > IndeterminateNumberOfLaurentPolynomial); ## [ 4, 5, 6 ] ## gap> R:=PolynomialRing(GF(3),["z"]); ## GF(3)[z] ## gap> List(IndeterminatesOfPolynomialRing(R), ## > IndeterminateNumberOfLaurentPolynomial); ## [ 3 ] ## ]]> ## <#/GAPDoc> ## ############################################################################# ## #O Indeterminate( [, ] ) #O Indeterminate( [, ][, ] ) #O Indeterminate( , ) #O X( ,[] ) #O X( ,[] ) #O X( ,[,] ) #O X( , ) ## ## <#GAPDoc Label="Indeterminate"> ## ## Indeterminate ## ## ## ## ## ## ## ## ## returns the indeterminate number nr over the ring R. ## If nr is not given it defaults to 1. ## If the number is not specified a list avoid of indeterminates ## may be given. ## The function will return an indeterminate that is guaranteed to be ## different from all the indeterminates in the list avoid. ## The third usage returns an indeterminate called name ## (also avoiding the indeterminates in avoid if given). ##

## is simply a synonym for ## . However, ## we do not recommend to use this synonym which is supported only for the ## backwards compatibility. ##

## x:=Indeterminate(GF(3),"x"); ## x ## gap> y:=X(GF(3),"y");z:=X(GF(3),"X"); ## y ## X ## gap> X(GF(3),2); ## y ## gap> X(GF(3),"x_3"); ## X ## gap> X(GF(3),[y,z]); ## x ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "Indeterminate", [IsRing,IsPosInt] ); DeclareSynonym( "X", Indeterminate ); ############################################################################# ## ## ############################################################################# ## #O UnivariatePolynomialRing( [, ] ) #O UnivariatePolynomialRing( [, ][, ] ) ## ## <#GAPDoc Label="UnivariatePolynomialRing"> ## ## UnivariatePolynomialRing ## ## ## ## ## returns a univariate polynomial ring in the indeterminate nr over ## the base ring R. ## If nr is not given it defaults to 1. ##

## If the number is not specified a list avoid of indeterminates may ## be given. ## Then the function will return a ring in an indeterminate that is ## guaranteed to be different from all the indeterminates in avoid. ##

## Also a string name can be prescribed as the name of the ## indeterminate chosen ## (also avoiding the indeterminates in the list avoid if given). ## ## ## <#/GAPDoc> ## DeclareOperation( "UnivariatePolynomialRing", [IsRing] ); ############################################################################# ## #A IndeterminatesOfPolynomialRing( ) #A IndeterminatesOfFunctionField( ) ## ## <#GAPDoc Label="IndeterminatesOfPolynomialRing"> ## ## ## ## ## ## returns a list of the indeterminates of the polynomial ring pring, ## respectively the function field ffield. ## ## ## <#/GAPDoc> ## DeclareAttribute( "IndeterminatesOfPolynomialRing", IsPolynomialRing ); DeclareSynonymAttr("IndeterminatesOfFunctionField", IndeterminatesOfPolynomialRing); ############################################################################# ## #O PolynomialRing( , [, ] ) #O PolynomialRing( , [, ] ) #O PolynomialRing( , ) #O PolynomialRing( , ) ## ## <#GAPDoc Label="PolynomialRing"> ## ## PolynomialRing ## ## ## ## ## ## ## creates a polynomial ring over the ring R. ## If a positive integer rank is given, ## this creates the polynomial ring in rank indeterminates. ## These indeterminates will have the internal index numbers 1 to ## rank. ## The second usage takes a list names of strings and returns a ## polynomial ring in indeterminates labelled by names. ## These indeterminates have new internal index numbers as if they ## had been created by calls to ## . ## (If the argument avoid is given it contains indeterminates that ## should be avoided, in this case internal index numbers are incremented ## to skip these variables.) ## In the third version, a list of indeterminates indets is given. ## This creates the polynomial ring in the indeterminates indets. ## Finally, the fourth version specifies indeterminates by their index ## numbers. ##

## To get the indeterminates of a polynomial ring use ## . ## (Indeterminates created independently with ## ## will usually differ, though they might be given the same name and display ## identically, see Section .) ## ## ## <#/GAPDoc> ## DeclareOperation( "PolynomialRing", [ IsRing, IsObject ] ); ############################################################################# ## #O MinimalPolynomial( , [, ] ) ## ## <#GAPDoc Label="MinimalPolynomial"> ## ## ## ## ## returns the minimal polynomial of elm over the ring R, ## expressed in the indeterminate number ind. ## If ind is not given, it defaults to 1. ##

## The minimal polynomial is the monic polynomial of smallest degree with ## coefficients in R that has value zero at elm. ## MinimalPolynomial(Rationals,[[2,0],[0,2]]); ## x-2 ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "MinimalPolynomial", [ IsRing, IsMultiplicativeElement and IsAdditiveElement, IsPosInt] ); ############################################################################# ## #O FunctionField( , [, ] ) #O FunctionField( , [, ] ) #O FunctionField( , ) #O FunctionField( , ) ## ## <#GAPDoc Label="FunctionField"> ## ## FunctionField ## ## ## ## ## ## ## creates a function field over the integral ring R. ## If a positive integer rank is given, ## this creates the function field in rank indeterminates. ## These indeterminates will have the internal index numbers 1 to ## rank. ## The second usage takes a list names of strings and returns a ## function field in indeterminates labelled by names. ## These indeterminates have new internal index numbers as if they ## had been created by calls to ## . ## (If the argument avoid is given it contains indeterminates that ## should be avoided, in this case internal index numbers are incremented ## to skip these variables.) ## In the third version, a list of indeterminates indets is given. ## This creates the function field in the indeterminates indets. ## Finally, the fourth version specifies indeterminates by their index ## number. ##

## To get the indeterminates of a function field use ## . ## (Indeterminates created independently with ## ## will usually differ, though they might be given the same name and display ## identically, see Section .) ## ## ## <#/GAPDoc> ## DeclareOperation("FunctionField",[IsRing,IsObject]); ############################################################################# ## #E gap-4r6p5/lib/grppcrep.gi0000644000175000017500000004730112172557252014057 0ustar billbill############################################################################# ## #W grppcrep.gd GAP library Bettina Eick ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ############################################################################# ## #F MappedVector( , ). . . . . . . . . . . . . . . . . . . . local ## MappedVector := function( exp, list ) local elm, i; if Length( list ) = 0 then Error("cannot compute this\n"); fi; elm := list[1]^exp[1]; for i in [2..Length(list)] do elm := elm * list[i]^exp[i]; od; return elm; end; ############################################################################# ## #F BlownUpMatrix( , ) . . . . . . . . . . blow up by field extension ## BlownUpMatrix := function ( B, mat ) local vec, d, tmp, big, i, j, k, new, l; # blow up each entry of mat vec := BasisVectors( B ); d := Length( vec ); tmp := []; big := []; for i in [ 1 .. Length( mat ) ] do big[i] := []; for j in [ 1 .. Length( mat ) ] do for k in [ 1 .. d ] do tmp[k] := Coefficients( B, mat[i][j] * vec[k] ); od; big[i][j] := TransposedMat( tmp ); od; od; # translate it into big matrix new := List( [1..Length(big)*d], x -> [] ); for i in [1..Length(big)] do for j in [1..Length(big)] do for k in [1..d] do for l in [1..d] do new[(i-1)*d + k][(j-1)*d + l] := big[i][j][k][l]; od; od; od; od; return new; end; ############################################################################# ## #F BlownUpModule( , , ) . . . . . . . blow up by field extension ## InstallGlobalFunction( BlownUpModule, function( modu, E, F ) local B, mats; # the trivial case B := AsField( F, E ); if Dimension( B ) = 1 then return modu; fi; B := Basis( B ); #mats := List( modu.generators, x -> TransposedMat(BlownUpMat(B, x))); mats:=List(modu.generators,x ->ImmutableMatrix(F,BlownUpMatrix(B,x))); return GModuleByMats( mats, F ); end ); ############################################################################# ## #F ConjugatedModule( , , ) . . . . . . . . conjugated module ## InstallGlobalFunction( ConjugatedModule, function( pcgsN, g, modu ) local mats, i, exp; mats := List(modu.generators, x -> false ); for i in [1..Length(mats)] do exp := ExponentsOfPcElement( pcgsN, pcgsN[i]^g ); mats[i] := ImmutableMatrix(modu.field,MappedVector(exp,modu.generators)); od; return GModuleByMats( mats, modu.field ); end ); ############################################################################# ## #F FpOfModules( , ) . . . . . . . . distinguish by chars ## InstallGlobalFunction( FpOfModules, function( pcgs, modus ) local words, traces, trset, word, exp, new, i, newset, n; n := Length( modus ); words := ShallowCopy( AsList( pcgs ) ); traces := List( modus, x -> Concatenation( [x.dimension], List(x.generators, y -> TraceMat( y )))); trset := Set( traces ); # iterate computation of elements while Length( trset ) < Length( modus ) do word := Random( GroupOfPcgs( pcgs ) ); if word <> OneOfPcgs( pcgs ) and not word in words then exp := ExponentsOfPcElement( pcgs, word ); new := List( modus, x->TraceMat(MappedVector(exp, x.generators))); for i in [1..n] do new[i] := Concatenation( traces[i], [new[i]] ); od; newset := Set( new ); if Length( newset ) > Length( trset ) then Add( words, word ); traces := ShallowCopy( new ); trset := ShallowCopy( newset ); fi; fi; od; words := List( words, x -> ExponentsOfPcElement( pcgs, x ) ); return rec( words := words, traces := traces ); end ); ############################################################################# ## #F EquivalenceType( , ) . . . . . . . . . . use chars to find type ## InstallGlobalFunction( EquivalenceType, function( fp, modu ) local trace; trace := List(fp.words, x -> TraceMat(MappedVector(x, modu.generators))); trace := Concatenation( [modu.dimension], trace ); return Position( fp.traces, trace ); end ); ############################################################################# ## #F IsEquivalentByFp( , , ) . . . . . . . equivalence type by chars ## InstallGlobalFunction( IsEquivalentByFp, function( fp, x, y ) # get the easy cases first if x.dimension <> y.dimension then return false; elif Dimension( x.field ) <> Dimension( y.field ) then return false; fi; # now it remains to check this really return EquivalenceType( fp, x ) = EquivalenceType( fp, y ); end ); ############################################################################# ## #F GaloisConjugates( , ) . . . . . . . . . . .apply frobenius autom ## InstallGlobalFunction( GaloisConjugates, function( modu, F ) local d, p, conj, k, mats, r, i, new; # set up d := Dimension( F ); p := Characteristic( F ); conj := [ modu ]; # conjugate for k in [1..d-1] do mats := List( modu.generators, x -> false ); r := RemInt( p^k, p^d-1 ); for i in [1..Length(mats)] do mats[i]:=ImmutableMatrix(F,List(modu.generators[i],x->List(x,y->y^r))); od; new := GModuleByMats( mats, F ); Add( conj, new ); od; return conj; end ); ############################################################################# ## #F TrivialModule( , ) . . . . . . . . . . . trivial module with n gens ## InstallGlobalFunction( TrivialModule, function( n, F ) return rec( field := F, dimension := 1, generators := ListWithIdenticalEntries( n, Immutable( IdentityMat( 1, F ) ) ), isMTXModule := true, basis := [[One(F)]] ); end ); ############################################################################# ## #F InducedModule( , ) . . . . . . . . . . . . . .induced module ## InstallGlobalFunction( InducedModule, function( pcgsS, modu ) local m, d, h, r, mat, i, j, mats, zero, id, exp, g; g := pcgsS[1]; m := Length( pcgsS ); d := modu.dimension; r := RelativeOrderOfPcElement( pcgsS, g ); zero := Immutable( NullMat( d, d, modu.field ) ); id := Immutable( IdentityMat( d, modu.field ) ); # the first matrix mat := List( [1..r], x -> List( [1..r], y -> zero ) ); exp := ExponentsOfPcElement( pcgsS, g^r, [2..m] ); mat[1][r] := MappedVector( exp, modu.generators ); for j in [2..r] do mat[j][j-1] := id; od; mats := [FlatBlockMat( mat )]; # the remaining ones for i in [2..m] do mat := List( [1..r], x -> List( [1..r], y -> zero ) ); for j in [1..r] do h := pcgsS[i]^(g^(j-1)); exp := ExponentsOfPcElement( pcgsS, h, [2..m] ); mat[j][j] := MappedVector( exp, modu.generators ); od; Add( mats, ImmutableMatrix(modu.field,FlatBlockMat( mat ) )); od; return GModuleByMats( mats, modu.field ); end ); ############################################################################# ## #F InducedModuleByFieldReduction( , , , , ) . . . ## ## The conjugated module is also galoisconjugate to modu. Thus we may use ## a field extension to induce. ## InstallGlobalFunction( InducedModuleByFieldReduction, function( pcgsS, modu, conj, gal, s ) local r, E, dE, p, l, K, EK, base, vecs, matsN, iso, coeffs, id, ch, matg, mats, newm, exp, e, k, q, c, m, gmat; # reduce field and increase dimension r := RelativeOrderOfPcElement( pcgsS, pcgsS[1] ); E := modu.field; dE := Dimension( E ); p := Characteristic( modu.field ); l := QuoInt( dE, r ); K := GF( p^l ); EK := AsField( K, E ); base := Basis( EK ); vecs := BasisVectors( base ); # blow up matrices in N matsN := List( modu.generators, x -> BlownUpMatrix( base, x ) ); # compute isomorphism MTX.IsIrreducible( conj ); iso := MTX.Isomorphism( conj, gal )^-1; # compute inverse galois automorphism and corresponding matrix exp := ExponentsOfPcElement( pcgsS, pcgsS[1]^r, [2..Length(pcgsS)] ); gmat := MappedVector( exp, modu.generators ); e := iso * gmat^-1; for k in [1..r-1] do q := RemInt( p^((s-1)*k), p^dE - 1); e := List( iso, x -> List( x, y -> y^q ) ) * e; od; e := e[1][1]; c := PrimitiveRoot( E ) ^ QuoInt( LogFFE( e, PrimitiveRoot(E) ), QuoInt( p^dE - 1, p^l - 1 ) ); # correct iso iso := c^-1 * iso; # compute base change m := p^(1-s) mod (p^dE - 1); coeffs := List( [1..r], j -> Coefficients( base, vecs[j]^m ) ); id := IdentityMat( modu.dimension, K ); ch := KroneckerProduct( id, TransposedMat( coeffs ) ); # construct matrix matg := ch * BlownUpMatrix( base, iso ); # construct module and return mats := List(Concatenation( [matg], matsN ),i->ImmutableMatrix(K,i)); newm := GModuleByMats( mats, K ); return newm; end ); ############################################################################# ## #F ExtensionsOfModule( , , , ) . . .extended modules ## InstallGlobalFunction( ExtensionsOfModule, function( pcgsS, modu, conj, dim ) local r, new, E, p, dE, exp, gmat, iso, e, c, mats, newm, f, d, b, L, j, w, g, k; # set up g := pcgsS[1]; r := RelativeOrderOfPcElement( pcgsS, g ); new := []; # set up fields E := modu.field; p := Characteristic( E ); dE := Dimension( E ); # compute matrix to g^r in N exp := ExponentsOfPcElement( pcgsS, g^r, [2..Length(pcgsS)] ); gmat := MappedVector( exp, modu.generators ); # we know that conj and modu are equivalent - compute e MTX.IsIrreducible( conj ); iso := MTX.Isomorphism( modu, conj ); e := (gmat * iso^(-r)); e := e[1][1]; if (p^dE - 1) mod r <> 0 then # compute rth root c of e in E c := e ^ (r^(-1) mod (p^dE - 1)); # this yields a unique extension of modu over E mats:=List(Concatenation([c*iso],modu.generators), i->ImmutableMatrix(E,i)); newm := GModuleByMats( mats, E ); Add( new, newm ); # if we have roots of unity in an extension of E if r <> p then f := Indeterminate( E ); f := Sum( List( [1..r], x -> f^(x-1) ) ); f := Factors( PolynomialRing( E ), f ); d := DegreeOfLaurentPolynomial( f[1] ); b := dE * d; # construct new field of dimension b if dim = 0 or b * modu.dimension <= dim then L := GF(p^b); for j in [1..Length(f)] do w := PrimitiveRoot( L ) ^ ((p^b - 1)/r); while Value( f[j], w ) <> Zero( E ) do w := w * PrimitiveRoot( L )^ ((p^b - 1)/r); od; mats:=List(Concatenation([w*c*iso],modu.generators), i->ImmutableMatrix(L,i)); newm := GModuleByMats( mats, L ); Add( new, newm ); od; fi; fi; return new; fi; # now we know that p^dE - 1 mod r = 0 k := 0; while (p^dE - 1) mod r^(k+1) = 0 do k := k + 1; od; # if we have r distinct rth roots of e in E if Order( e ) mod r^k <> 0 then c := PrimitiveRoot( E ) ^ QuoInt( LogFFE( e, PrimitiveRoot(E) ), r ); for j in [1..r] do mats:=List(Concatenation([c*iso],modu.generators), i->ImmutableMatrix(E,i)); newm := GModuleByMats( mats, E ); Add( new, newm ); c := c * PrimitiveRoot( E ) ^ QuoInt( p^dE-1, r ); od; return new; fi; # if we have we do not have any root in E, go over to extension # construct new field of dimension b b := dE * r; if dim = 0 or b * modu.dimension <= dim then L := GF( p^b ); c := PrimitiveRoot( L ) ^ QuoInt( LogFFE( e, PrimitiveRoot( L ) ), r ); mats:=List(Concatenation([c*iso],modu.generators), i->ImmutableMatrix(L,i)); newm := GModuleByMats( mats, L ); Add( new, newm ); fi; return new; end ); ############################################################################# ## #F InitAbsAndIrredModules( , , ) . . . . . . . . . . . . . local ## InstallGlobalFunction( InitAbsAndIrredModules, function( r, F, dim ) local new, mats, modu, f, l, E, w, j, d, p, b, irr, i; # set up new := []; p := Characteristic( F ); d := Dimension(F); if ( (p^d-1) mod r ) <> 0 then # construct a 1-dimensional module mats := [ ImmutableMatrix(F, IdentityMat( 1, F ) ) ]; modu := GModuleByMats( mats, F ); Add( new, modu ); if r <> p then f := Indeterminate( F ); f := Sum( List([1..r], x -> f^(x-1) ) ); f := Factors( PolynomialRing( F ), f ); l := DegreeOfLaurentPolynomial( f[1] ); b := l * d; # construct l-dimensional module if dim = 0 or b <= dim then E := GF( p^b ); for j in [ 1..Length( f ) ] do w := PrimitiveRoot(E)^QuoInt( p^b-1, r ); while Value( f[j], w ) <> Zero( F ) do w := w * PrimitiveRoot(E)^QuoInt( p^b-1, r ); od; modu := GModuleByMats( [ImmutableMatrix(E,[[w]])], E ); Add( new, modu ); od; fi; fi; else # construct 1-dimensional module w := PrimitiveRoot( F )^QuoInt( p^d - 1, r ); for j in [ 1..r ] do mats := [ ImmutableMatrix(F,[[w]]) ]; modu := GModuleByMats( mats, F ); Add( new, modu ); w := w * PrimitiveRoot( F )^QuoInt( p^d - 1, r ); od; fi; # blow modules up for i in [1..Length(new)] do irr := BlownUpModule( new[i], new[i].field, F ); new[i] := rec( irred := irr, absirr := new[i] ); od; # return return new; end ); ############################################################################# ## #F LiftAbsAndIrredModules( , , , ). . . . . local ## InstallGlobalFunction( LiftAbsAndIrredModules, function( pcgsS, pcgsN, modrec, dim ) local todo, fp, new, i, modu, E, conj, type, s, gal, types, r, un, j, g, galfp, small, sconj, irred, absirr, n, F, irr, dF; # split modules into parts irred := List( modrec, x -> x.irred ); absirr := List( modrec, x -> x.absirr ); n := Length( modrec ); F := irred[1].field; dF := Dimension( F ); # set up todo := [1..n]; fp := FpOfModules( pcgsN, irred ); g := pcgsS[1]; r := RelativeOrderOfPcElement( pcgsS, g ); new := []; # until we have all modules lifted while Length( todo ) > 0 do # choose a module i := todo[1]; todo := todo{[2..Length(todo)]}; modu := absirr[i]; E := modu.field; small := irred[i]; # compute its conjugate sconj := ConjugatedModule( pcgsN, g, small ); type := EquivalenceType( fp, sconj ); # if the are equivalent if type <> i then # absirr: dimension d := d * r -- field e := e # irr : dimension d := d * r if dim = 0 or r * dF * small.dimension <= dim then Add( new, InducedModule( pcgsS, modu ) ); fi; # filter out the modules also inducing to the new one un := [type]; for j in [1..r-2] do sconj := ConjugatedModule( pcgsN, g, sconj ); type := EquivalenceType( fp, sconj ); AddSet( un, type ); od; todo := Difference( todo, un ); else # compute galois conjugates and try to find equivalent one conj := ConjugatedModule( pcgsN, g, modu ); gal := GaloisConjugates( modu, AsField( F, E ) ); galfp := FpOfModules( pcgsN, gal ); s := EquivalenceType( galfp, conj ); if s = 1 then # absirr: dimension: d := d -- field e := e (1 or r mod) # e := e * l (f mod) # e := e * r (1 mod) Append( new, ExtensionsOfModule( pcgsS, modu, conj, dim ) ); else # absirr: dimension d := d * r -- field e := e / r # irr : dimension d := d Add( new, InducedModuleByFieldReduction( pcgsS, modu, conj, gal[s], s)); fi; fi; od; # now it remains to blow the modules up for i in [1..Length(new)] do E := new[i].field; irr := BlownUpModule( new[i], E, F ); new[i] := rec( irred := irr, absirr := new[i] ); od; # return return new; end ); ############################################################################# ## #F AbsAndIrredModules( , , ) . . . . . . . . . . . . . . . .local ## InstallGlobalFunction( AbsAndIrredModules, function( G, F, dim ) local pcgs, m, modrec, i, pcgsS, pcgsN, r, irr; # check if dim < 0 then Error("dimension limit must be non-negative"); fi; if dim > 0 and Dimension( F ) > dim then return [,[]]; fi; # set up pcgs := Pcgs( G ); m := Length( pcgs ); if m = 0 and (dim = 0 or Dimension( F ) <= dim) then return [rec( irred := TrivialModule( 0, F ), absirr := TrivialModule( 0, F ))]; elif m = 0 then return [pcgs,[]]; fi; # the first step is separated - too many problems with empty lists r := RelativeOrderOfPcElement( pcgs, pcgs[m] ); modrec := InitAbsAndIrredModules( r, F, dim ); # step up pc series for i in Reversed( [1..m-1] ) do pcgsS := InducedPcgsByPcSequence( pcgs, pcgs{[i..m]} ); pcgsN := InducedPcgsByPcSequence( pcgs, pcgs{[i+1..m]} ); modrec := LiftAbsAndIrredModules( pcgsS, pcgsN, modrec, dim ); od; # return return [pcgs,modrec]; end ); ############################################################################# ## #M AbsolutIrreducibleModules( , , ). . . . . . .up to equivalence ## ## is the limit of Dim( F ) * Dim( M ) for the modules M ## InstallMethod( AbsolutIrreducibleModules, "generic method for groups with pcgs", true, [ IsGroup and CanEasilyComputePcgs, IsField and IsFinite and IsPrimeField, IsInt ], 0, function( G, F, dim ) local modus; modus := AbsAndIrredModules( G, F, dim ); return [modus[1],List( modus[2], x -> x.absirr )]; end ); ############################################################################# ## #M IrreducibleModules( , , ) . . . . . . . . . .up to equivalence ## ## is the limit of Dim( F ) * Dim( M ) for the modules M ## InstallMethod( IrreducibleModules, "generic method for groups with pcgs", true, [ IsGroup and CanEasilyComputePcgs, IsField and IsFinite and IsPrimeField, IsInt ], 0, function( G, F, dim ) local modus, i, tmp,gens; modus := AbsAndIrredModules( G, F, dim ); gens:=modus[1]; modus:=modus[2]; for i in [1..Length(modus)] do tmp := modus[i].irred; tmp.absolutelyIrreducible := modus[i].absirr; modus[i] := tmp; od; return [gens,modus]; end ); gap-4r6p5/lib/grppc.gi0000644000175000017500000023350112172557252013347 0ustar billbill############################################################################# ## #W grppc.gi GAP Library Frank Celler #W & Bettina Eick ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the methods for groups with a polycyclic collector. ## ############################################################################# ## #M CanonicalPcgsWrtFamilyPcgs( ) ## InstallMethod( CanonicalPcgsWrtFamilyPcgs, true, [ IsGroup and HasFamilyPcgs ], 0, function( grp ) local cgs; cgs := CanonicalPcgs( InducedPcgsWrtFamilyPcgs(grp) ); if cgs = FamilyPcgs(grp) then SetIsWholeFamily( grp, true ); fi; return cgs; end ); ############################################################################# ## #M CanonicalPcgsWrtHomePcgs( ) ## InstallMethod( CanonicalPcgsWrtHomePcgs, true, [ IsGroup and HasHomePcgs ], 0, function( grp ) return CanonicalPcgs( InducedPcgsWrtHomePcgs(grp) ); end ); ############################################################################# ## #M InducedPcgsWrtFamilyPcgs( ) ## InstallMethod( InducedPcgsWrtFamilyPcgs, true, [ IsGroup and HasFamilyPcgs ], 0, function( grp ) local pa, igs; pa := FamilyPcgs(grp); if HasPcgs(grp) and IsInducedPcgs(Pcgs(grp)) then if pa = ParentPcgs(Pcgs(grp)) then return Pcgs(grp); fi; fi; igs := InducedPcgsByGenerators( pa, GeneratorsOfGroup(grp) ); if igs = pa then SetIsWholeFamily( grp, true ); fi; SetGroupOfPcgs (igs, grp); return igs; end ); InstallMethod( InducedPcgsWrtFamilyPcgs,"whole family", true, [ IsPcGroup and IsWholeFamily], 0, FamilyPcgs); ############################################################################# ## #M InducedPcgsWrtHomePcgs( ) ## InstallMethod( InducedPcgsWrtHomePcgs,"from generators", true, [ IsGroup ], 0, function( G ) local home, ind; home := HomePcgs( G ); if HasPcgs(G) and IsInducedPcgs(Pcgs(G)) then if IsIdenticalObj(home,ParentPcgs(Pcgs(G))) then return Pcgs(G); fi; fi; ind := InducedPcgsByGenerators( home, GeneratorsOfGroup( G ) ); SetGroupOfPcgs (ind, G); return ind; end ); InstallMethod( InducedPcgsWrtHomePcgs,"pc group: home=family", true, [ IsPcGroup ], 0, InducedPcgsWrtFamilyPcgs); ############################################################################# ## #M InducedPcgs( , ) ## InstallMethod( InducedPcgs, "cache pcgs", true, [ IsPcgs,IsGroup ], 0, function(pcgs, G ) local cache, i, igs; pcgs := ParentPcgs (pcgs); cache := ComputedInducedPcgses(G); i := 1; while i <= Length (cache) do if IsIdenticalObj (cache[i], pcgs) then return cache[i+1]; fi; i := i + 2; od; igs := InducedPcgsOp( pcgs, G ); SetGroupOfPcgs (igs, G); Append (cache, [pcgs, igs]); if not HasPcgs(G) then SetPcgs (G, igs); fi; # set home pcgs stuff if not HasHomePcgs(G) then SetHomePcgs (G, pcgs); fi; if IsIdenticalObj (HomePcgs(G), pcgs) then SetInducedPcgsWrtHomePcgs (G, igs); fi; return igs; end ); ADD_LIST(WRAPPER_OPERATIONS, InducedPcgs); ############################################################################# ## #M InducedPcgsOp ## InstallMethod (InducedPcgsOp, "generic method", IsIdenticalObj, [IsPcgs, IsGroup], function (pcgs, G) return InducedPcgsByGenerators( ParentPcgs(pcgs), GeneratorsOfGroup( G ) ); end); ############################################################################# ## #M InducedPcgsOp ## InstallMethod (InducedPcgsOp, "sift existing pcgs", IsIdenticalObj, [IsPcgs, IsGroup and HasPcgs], function (pcgs, G) local seq, # pc sequence wrt pcgs (and its parent) depths, # depths of this sequence len, # length of the sequence pos, # index x, # a group element d; # depth of x pcgs := ParentPcgs (pcgs); seq := []; depths := []; len := 0; for x in Reversed (Pcgs (G)) do # sift x through seq d := DepthOfPcElement (pcgs, x); pos := PositionSorted (depths, d); while pos <= len and depths[pos] = d do x := ReducedPcElement (pcgs, x, seq[pos]); d := DepthOfPcElement (pcgs, x); pos := PositionSorted (depths, d); od; if d> Length(pcgs) then Error ("Panic: Pcgs (G) does not seem to be a pcgs"); else seq{[pos+1..len+1]} := seq{[pos..len]}; depths{[pos+1..len+1]} := depths{[pos..len]}; seq[pos] := x; depths[pos] := d; len := len + 1; fi; od; return InducedPcgsByPcSequenceNC (pcgs, seq, depths); end); ############################################################################# ## #M ComputedInducedPcgses ## InstallMethod (ComputedInducedPcgses, "default method", [IsGroup], G -> []); ############################################################################# ## #F SetInducedPcgs( ,, ) ## InstallGlobalFunction(SetInducedPcgs,function(home,G,pcgs) home := ParentPcgs(home); if not HasHomePcgs(G) then SetHomePcgs(G,home); fi; if IsIdenticalObj(ParentPcgs(pcgs),home) then Append (ComputedInducedPcgses(G), [home, pcgs]); if IsIdenticalObj(HomePcgs(G),home) then SetInducedPcgsWrtHomePcgs(G,pcgs); fi; fi; SetGroupOfPcgs (pcgs, G); end); ############################################################################# ## #M Pcgs( ) ## InstallMethod( Pcgs, "fail if insolvable", true, [ HasIsSolvableGroup ], SUM_FLAGS, # for groups for which we know that they are not solvable # this is the best we can do. function( G ) if not IsSolvableGroup( G ) then return fail; else TryNextMethod(); fi; end ); ############################################################################# ## #M Pcgs( ) ## InstallMethod( Pcgs, "for a group with known family pcgs", true, [ IsGroup and HasFamilyPcgs ], 0, InducedPcgsWrtFamilyPcgs ); InstallMethod( Pcgs, "for a group with known home pcgs", true, [ IsGroup and HasHomePcgs ], 1, InducedPcgsWrtHomePcgs ); InstallMethod( Pcgs, "take induced pcgs", true, [ IsGroup and HasInducedPcgsWrtHomePcgs ], SUM_FLAGS, InducedPcgsWrtHomePcgs ); ############################################################################# ## #M Pcgs( ) ## InstallMethod( Pcgs, "for a group containing the whole family and with known family pcgs", true, [ IsGroup and HasFamilyPcgs and IsWholeFamily ], 0, FamilyPcgs ); ############################################################################# ## #M GeneralizedPcgs( ) ## InstallImmediateMethod( GeneralizedPcgs, IsGroup and HasPcgs, 0, Pcgs ); ############################################################################# ## #M HomePcgs( ) ## ## BH: changed Pcgs to G -> ParentPcgs (Pcgs(G)) ## InstallMethod( HomePcgs, true, [ IsGroup ], 0, G -> ParentPcgs( Pcgs( G ) ) ); ############################################################################# ## #M PcgsChiefSeries( ) ## InstallMethod( PcgsChiefSeries,"compute chief series and pcgs",true, [IsGroup],0, function(G) local p,cs,csi,l,i,pcs,ins,j,u; p:=Pcgs(G); if p=fail then Error(" must be solvable"); fi; if not HasParent(G) then SetParentAttr(G,Parent(G)); fi; cs:=ChiefSeries(G); csi:=List(cs,i->InducedPcgs(p,i)); l:=Length(cs); pcs:=[]; ins:=[0]; for i in [l-1,l-2..1] do # extend the pc sequence. We have a vector space factor, so we can # simply add *some* further generators. u:=AsSubgroup(Parent(G),cs[i+1]); for j in Reversed(Filtered(csi[i],k->not k in cs[i+1])) do if not j in u then Add(pcs,j); #NC is safe u:=ClosureSubgroupNC(u,j); fi; od; if Length(pcs)<>Length(csi[i]) then Error("pcgs length!"); fi; Add(ins,Length(pcs)); od; l:=Length(pcs)+1; pcs:=PcgsByPcSequenceNC(FamilyObj(OneOfPcgs(p)),Reversed(pcs)); SetGroupOfPcgs (pcs, G); # store the indices SetIndicesChiefNormalSteps(pcs,Reversed(List(ins,i->l-i))); return pcs; end); ############################################################################# ## #M GroupWithGenerators( ) . . . . . . . . . . . . group by generators #M GroupWithGenerators( , ) ## ## These methods override the generic code. They are installed for ## `IsMultiplicativeElementWithInverseByPolycyclicCollectorCollection' and ## automatically set family pcgs and home pcgs. ## InstallMethod( GroupWithGenerators, "method for pc elements collection", true, [ IsCollection and IsMultiplicativeElementWithInverseByPolycyclicCollectorCollection] , # override methods for `IsList' or `IsEmpty'. 10, function( gens ) local G,fam,typ,pcgs; fam:=FamilyObj(gens); if IsFinite(gens) then if not IsBound(fam!.defaultFinitelyGeneratedGroupType) then fam!.defaultFinitelyGeneratedGroupType:= NewType(fam,IsGroup and IsAttributeStoringRep and HasGeneratorsOfMagmaWithInverses and IsFinitelyGeneratedGroup and HasFamilyPcgs and HasHomePcgs); fi; typ:=fam!.defaultFinitelyGeneratedGroupType; else if not IsBound(fam!.defaultGroupType) then fam!.defaultGroupType:= NewType(fam,IsGroup and IsAttributeStoringRep and HasGeneratorsOfMagmaWithInverses and HasFamilyPcgs and HasHomePcgs); fi; typ:=fam!.defaultGroupType; fi; pcgs:=DefiningPcgs(ElementsFamily(fam)); G:=rec(); ObjectifyWithAttributes(G,typ,GeneratorsOfMagmaWithInverses,AsList(gens), FamilyPcgs,pcgs,HomePcgs,pcgs); SetGroupOfPcgs (pcgs, G); return G; end ); InstallOtherMethod( GroupWithGenerators, "method for pc collection and identity element", IsCollsElms, [ IsCollection and IsMultiplicativeElementWithInverseByPolycyclicCollectorCollection , IsMultiplicativeElementWithInverseByPolycyclicCollector] , 0, function( gens, id ) local G,fam,typ,pcgs; fam:=FamilyObj(gens); if IsFinite(gens) then if not IsBound(fam!.defaultFinitelyGeneratedGroupWithOneType) then fam!.defaultFinitelyGeneratedGroupWithOneType:= NewType(fam,IsGroup and IsAttributeStoringRep and HasGeneratorsOfMagmaWithInverses and IsFinitelyGeneratedGroup and HasOne and HasFamilyPcgs and HasHomePcgs); fi; typ:=fam!.defaultFinitelyGeneratedGroupWithOneType; else if not IsBound(fam!.defaultGroupWithOneType) then fam!.defaultGroupWithOneType:= NewType(fam,IsGroup and IsAttributeStoringRep and HasGeneratorsOfMagmaWithInverses and HasOne and HasFamilyPcgs and HasHomePcgs); fi; typ:=fam!.defaultGroupWithOneType; fi; pcgs:=DefiningPcgs(ElementsFamily(fam)); G:=rec(); ObjectifyWithAttributes(G,typ,GeneratorsOfMagmaWithInverses,AsList(gens), One,id,FamilyPcgs,pcgs,HomePcgs,pcgs); SetGroupOfPcgs (pcgs, G); return G; end ); InstallOtherMethod( GroupWithGenerators, "method for empty pc collection and identity element", true, [ IsList and IsEmpty, IsMultiplicativeElementWithInverseByPolycyclicCollector] , # override methods for `IsList' or `IsEmpty'. 10, function( gens, id ) local G,fam,typ,pcgs; fam:= CollectionsFamily( FamilyObj( id ) ); if not IsBound(fam!.defaultFinitelyGeneratedGroupWithOneType) then fam!.defaultFinitelyGeneratedGroupWithOneType:= NewType(fam,IsGroup and IsAttributeStoringRep and HasGeneratorsOfMagmaWithInverses and IsFinitelyGeneratedGroup and HasOne and HasFamilyPcgs and HasHomePcgs); fi; typ:=fam!.defaultFinitelyGeneratedGroupWithOneType; pcgs:=DefiningPcgs(ElementsFamily(fam)); G:=rec(); ObjectifyWithAttributes(G,typ,GeneratorsOfMagmaWithInverses,[], One,id,FamilyPcgs,pcgs,HomePcgs,pcgs); SetGroupOfPcgs (pcgs, G); return G; end ); ############################################################################# ## #M in ## InstallMethod( \in, "for pc group", IsElmsColls, [ IsMultiplicativeElementWithInverse, IsGroup and HasFamilyPcgs and CanEasilyComputePcgs ], 2, # rank this method higher than the following one function( elm, grp ) return SiftedPcElement(InducedPcgsWrtFamilyPcgs(grp),elm) = One(grp); end ); ############################################################################# ## #M in ## InstallMethod( \in, "for pcgs computable groups with home pcgs", IsElmsColls, [ IsMultiplicativeElementWithInverse, IsGroup and HasInducedPcgsWrtHomePcgs and CanEasilyComputePcgs ], 1, # rank this method higher than the following one function( elm, grp ) local pcgs, ppcgs; pcgs := InducedPcgsWrtHomePcgs (grp); ppcgs := ParentPcgs (pcgs); if Length (pcgs) = Length (ppcgs) or not CanEasilyTestMembership (GroupOfPcgs(ppcgs)) then TryNextMethod(); fi; if elm in GroupOfPcgs (ppcgs) then return SiftedPcElement(InducedPcgsWrtHomePcgs(grp),elm) = One(grp); else return false; fi; end ); ############################################################################# ## #M in ## InstallMethod( \in, "for pcgs computable groups with induced pcgs", IsElmsColls, [ IsMultiplicativeElementWithInverse, IsGroup and HasComputedInducedPcgses and CanEasilyComputePcgs ], 0, function( elm, grp ) local pcgs, ppcgs; for pcgs in ComputedInducedPcgses(grp) do ppcgs := ParentPcgs (pcgs); if Length (pcgs) < Length (ppcgs) and CanEasilyTestMembership (GroupOfPcgs(ppcgs)) then if elm in GroupOfPcgs (ppcgs) then return SiftedPcElement(pcgs, elm) = One(grp); else return false; fi; fi; od; TryNextMethod(); end ); ############################################################################# ## #M = ## InstallMethod( \=, "pcgs computable groups using home pcgs", IsIdenticalObj, [ IsGroup and HasHomePcgs and HasCanonicalPcgsWrtHomePcgs, IsGroup and HasHomePcgs and HasCanonicalPcgsWrtHomePcgs ], 0, function( left, right ) if HomePcgs(left) <> HomePcgs(right) then TryNextMethod(); fi; return CanonicalPcgsWrtHomePcgs(left) = CanonicalPcgsWrtHomePcgs(right); end ); ############################################################################# ## #M = ## InstallMethod( \=, "pcgs computable groups using family pcgs", IsIdenticalObj, [ IsGroup and HasFamilyPcgs and HasCanonicalPcgsWrtFamilyPcgs, IsGroup and HasFamilyPcgs and HasCanonicalPcgsWrtFamilyPcgs ], 0, function( left, right ) if FamilyPcgs(left) <> FamilyPcgs(right) then TryNextMethod(); fi; return CanonicalPcgsWrtFamilyPcgs(left) = CanonicalPcgsWrtFamilyPcgs(right); end ); ############################################################################# ## #M IsSubset( , ) ## ## This method is better than calling `\in' for all generators, ## since one has to fetch the pcgs only once. ## InstallMethod( IsSubset, "pcgs computable groups", IsIdenticalObj, [ IsGroup and HasFamilyPcgs and CanEasilyComputePcgs, IsGroup ], 0, function( grp, sub ) local pcgs, id, g; pcgs := InducedPcgsWrtFamilyPcgs(grp); id := One(grp); for g in GeneratorsOfGroup(sub) do if SiftedPcElement( pcgs, g ) <> id then return false; fi; od; return true; end ); ############################################################################# ## #M SubgroupByPcgs( , ) ## InstallMethod( SubgroupByPcgs, "subgroup with pcgs", true, [IsGroup, IsPcgs], 0, function( G, pcgs ) local U; U := SubgroupNC( G, AsList( pcgs ) ); SetPcgs( U, pcgs ); SetGroupOfPcgs (pcgs, U); # home pcgs will be inherited if HasHomePcgs(U) and IsIdenticalObj(HomePcgs(U),ParentPcgs(pcgs)) then SetInducedPcgsWrtHomePcgs(U,pcgs); fi; if HasIsInducedPcgsWrtSpecialPcgs( pcgs ) and IsInducedPcgsWrtSpecialPcgs( pcgs ) and HasSpecialPcgs( G ) then SetInducedPcgsWrtSpecialPcgs( U, pcgs ); fi; return U; end); ############################################################################# ## #F VectorSpaceByPcgsOfElementaryAbelianGroup( , ) ## InstallGlobalFunction( VectorSpaceByPcgsOfElementaryAbelianGroup, function( arg ) local pcgs, dim, field; pcgs := arg[1]; dim := Length( pcgs ); if IsBound( arg[2] ) then field := arg[2]; elif dim > 0 then field := GF( RelativeOrderOfPcElement( pcgs, pcgs[1] ) ); else Error("trivial vectorspace, need field \n"); fi; return VectorSpace( field, Immutable( IdentityMat( dim, field ) ) ); end ); ############################################################################# ## #F LinearActionLayer( , , ) ## InstallGlobalFunction( LinearActionLayer, function( arg ) local gens, pcgs, field, m,mat,i,j; # catch arguments if Length( arg ) = 2 then if IsGroup( arg[1] ) then gens := GeneratorsOfGroup( arg[1] ); elif IsPcgs( arg[1] ) then gens := AsList( arg[1] ); else gens := arg[1]; fi; pcgs := arg[2]; elif Length( arg ) = 3 then gens := arg[2]; pcgs := arg[3]; fi; # in case the layer is trivial if Length( pcgs ) = 0 then Error("pcgs is trivial - no field defined "); fi; # construct matrix rep field := GF( RelativeOrderOfPcElement( pcgs, pcgs[1] ) ); # the following code takes too much time, as it has to create obvious pc # elements again from vectors with 1 nonzero entry. # V := Immutable( IdentityMat(Length(pcgs),field) ); # linear := function( x, g ) # return ExponentsOfPcElement( pcgs, # PcElementByExponentsNC( pcgs, x )^g ) * One(field); # end; # return LinearAction( gens, V, linear ); #this is done much quicker by the following direct code: m:=[]; for i in gens do mat:=[]; for j in pcgs do Add(mat,ExponentsConjugateLayer(pcgs,j,i)*One(field)); od; mat:=ImmutableMatrix(field,mat,true); Add(m,mat); od; return m; end ); ############################################################################# ## #F AffineActionLayer( , , ) ## InstallGlobalFunction( AffineActionLayer, function( arg ) local gens, pcgs, transl, V, field, linear; # catch arguments if Length( arg ) = 3 then if IsPcgs( arg[1] ) then gens := AsList( arg[1] ); elif IsGroup( arg[1] ) then gens := GeneratorsOfGroup( arg[1] ); else gens := arg[1]; fi; pcgs := arg[2]; transl := arg[3]; elif Length( arg ) = 4 then gens := arg[2]; pcgs := arg[3]; transl := arg[4]; fi; # in the trivial case we cannot do anything if Length( pcgs ) = 0 then Error("layer is trivial . . . field is not defined \n"); fi; # construct matrix rep field := GF( RelativeOrderOfPcElement( pcgs, pcgs[1] ) ); V:= Immutable( IdentityMat(Length(pcgs),field) ); linear := function( x, g ) return ExponentsConjugateLayer(pcgs, PcElementByExponentsNC( pcgs, x ),g ) * One(field); end; return AffineAction( gens, V, linear, transl ); end ); ############################################################################# ## #M AffineAction( , , , ) ## InstallMethod( AffineAction,"generators", true, [ IsList, IsMatrix, IsFunction, IsFunction ], 0, function( Ggens, V, linear, transl ) local mats, gens, zero,one, g, mat, i, vec; mats := []; gens:=V; zero:=Zero(V[1][1]); one:=One(zero); for g in Ggens do mat := List( gens, x -> linear( x, g ) ); vec := ShallowCopy( transl(g) ); for i in [ 1 .. Length(mat) ] do mat[i] := ShallowCopy( mat[i] ); Add( mat[i], zero ); od; Add( vec, one ); Add( mat, vec ); mat:=ImmutableMatrix(Characteristic(one),mat,true); Add( mats, mat ); od; return mats; end ); InstallOtherMethod( AffineAction,"group", true, [ IsGroup, IsMatrix, IsFunction, IsFunction ], 0, function( G, V, linear, transl ) return AffineAction( GeneratorsOfGroup(G), V, linear, transl ); end ); InstallOtherMethod( AffineAction,"group2", true, [ IsGroup, IsList, IsMatrix, IsFunction, IsFunction ], 0, function( G, gens, V, linear, transl ) return AffineAction( gens, V, linear, transl ); end ); InstallOtherMethod( AffineAction,"pcgs", true, [ IsPcgs, IsMatrix, IsFunction, IsFunction ], 0, function( pcgsG, V, linear, transl ) return AffineAction( AsList( pcgsG ), V, linear, transl ); end ); ############################################################################# ## #M ClosureGroup( , ) ## ## use home pcgs ## InstallMethod( ClosureGroup, "groups with home pcgs", IsIdenticalObj, [ IsGroup and HasHomePcgs, IsGroup and HasHomePcgs ], 0, function( U, H ) local home, pcgsU, pcgsH, new, N; home := HomePcgs( U ); if home <> HomePcgs( H ) then TryNextMethod(); fi; pcgsU := InducedPcgs(home,U); pcgsH := InducedPcgs(home,H); if Length( pcgsU ) < Length( pcgsH ) then new := InducedPcgsByPcSequenceAndGenerators( home, pcgsH, GeneratorsOfGroup( U ) ); else new := InducedPcgsByPcSequenceAndGenerators( home, pcgsU, GeneratorsOfGroup( H ) ); fi; N := SubgroupByPcgs( GroupOfPcgs( home ), new ); # SetHomePcgs( N, home ); # SetInducedPcgsWrtHomePcgs( N, new ); return N; end ); ############################################################################# ## #M ClosureGroup( , ) ## ## use home pcgs ## InstallMethod( ClosureGroup, "groups with home pcgs", IsCollsElms, [ IsGroup and HasHomePcgs, IsMultiplicativeElementWithInverse ], 0, function( U, g ) local home, pcgsU, new, N; home := HomePcgs( U ); pcgsU := InducedPcgsWrtHomePcgs( U ); if not g in GroupOfPcgs( home ) then TryNextMethod(); fi; if g in U then return U; else new := InducedPcgsByPcSequenceAndGenerators( home, pcgsU, [g] ); N := SubgroupByPcgs( GroupOfPcgs(home), new ); # SetHomePcgs( N, home ); # SetInducedPcgsWrtHomePcgs( N, new ); return N; fi; end ); ############################################################################# ## #M CommutatorSubgroup( , ) ## InstallMethod( CommutatorSubgroup, "groups with home pcgs", true, [ IsGroup and HasHomePcgs, IsGroup and HasHomePcgs ], 0, function( U, V ) local pcgsU, pcgsV, home, C, u, v; # check home := HomePcgs(U); if home <> HomePcgs( V ) then TryNextMethod(); fi; pcgsU := InducedPcgsWrtHomePcgs(U); pcgsV := InducedPcgsWrtHomePcgs(V); # catch trivial cases if Length(pcgsU) = 0 or Length(pcgsV) = 0 then return TrivialSubgroup( GroupOfPcgs(home) ); fi; if U = V then return DerivedSubgroup(U); fi; # compute commutators C := []; for u in pcgsU do for v in pcgsV do AddSet( C, Comm( v, u ) ); od; od; C := Subgroup( GroupOfPcgs( home ), C ); C := NormalClosure( ClosureGroup(U,V), C ); # that's it return C; end ); ############################################################################# ## #M ConjugateGroup( , ) ## InstallMethod( ConjugateGroup, "groups with home pcgs", IsCollsElms, [ IsGroup and HasHomePcgs, IsMultiplicativeElementWithInverse ], 0, function( U, g ) local home, pcgs, id, pag, h, d, N; # must lie in the home home := HomePcgs(U); if not g in GroupOfPcgs(home) then TryNextMethod(); fi; # shift through pcgs := InducedPcgsWrtHomePcgs( U ); id := Identity( U ); g := SiftedPcElement( pcgs, g ); # catch trivial case if IsEmpty(pcgs) or g = id then return U; fi; # conjugate generators pag := []; for h in Reversed( pcgs ) do h := h ^ g; d := DepthOfPcElement( home, h ); while h <> id and IsBound( pag[d] ) do h := ReducedPcElement( home, h, pag[d] ); d := DepthOfPcElement( home, h ); od; if h <> id then pag[d] := h; fi; od; # is an induced system pag := Compacted( pag ); N := Subgroup( GroupOfPcgs(home), pag ); SetHomePcgs( N, home ); pag := InducedPcgsByPcSequenceNC( home, pag ); SetGroupOfPcgs (pag, N); SetInducedPcgsWrtHomePcgs( N, pag ); # maintain useful information UseIsomorphismRelation( U, N ); return N; end ); ############################################################################# ## #M ConjugateSubgroups( , ) ## InstallMethod( ConjugateSubgroups, "groups with home pcgs", IsIdenticalObj, [ IsGroup and HasHomePcgs, IsGroup and HasHomePcgs ], 0, function( G, U ) local pcgs, home, f, orb, i, L, res, H,ip; # check the home pcgs are compatible home := HomePcgs(U); if home <> HomePcgs(G) then TryNextMethod(); fi; H := GroupOfPcgs( home ); # get a canonical pcgs for pcgs := CanonicalPcgsWrtHomePcgs(U); # acts on this via conjugation f := function( c, g ) #was: CanonicalPcgs( HomomorphicInducedPcgs( home, c, g ) ); return CorrespondingGeneratorsByModuloPcgs(home,List(c,i->i^g)); end; # compute the orbit of on orb := Orbit( G, pcgs, f ); res := List( orb, x -> false ); for i in [1..Length(orb)] do L := Subgroup( H, orb[i] ); SetHomePcgs( L, home ); if not(IsPcgs(orb[i])) then ip:=InducedPcgsByPcSequenceNC(home,orb[i]); else ip:=orb[i]; fi; SetInducedPcgsWrtHomePcgs( L, ip ); SetGroupOfPcgs (ip, L); res[i] := L; od; return res; end ); ############################################################################# ## #M Core( , ) ## InstallMethod( CoreOp, "pcgs computable groups", true, [ IsGroup and CanEasilyComputePcgs, IsGroup ], 0, function( V, U ) local pcgsV, C, v, N; # catch trivial cases pcgsV := Pcgs(V); if IsSubset( U, V ) or IsTrivial(U) or IsTrivial(V) then return U; fi; # start with . C := U; # now compute intersection with all conjugate subgroups, conjugate with # all generators of V and its powers for v in Reversed(pcgsV) do repeat N := ConjugateGroup( C, v ); if C <> N then C := Intersection( C, N ); fi; until C = N; if IsTrivial(C) then return C; fi; od; return C; end ); ############################################################################# ## #M EulerianFunction( , ) ## InstallMethod( EulerianFunction, "pcgs computable groups using special pcgs", true, [ IsGroup and CanEasilyComputePcgs, IsPosInt ], 0, function( G, n ) local spec, first, weights, m, i, phi, start, next, p, d, r, j, pcgsS, pcgsN, pcgsL, mats, modu, max, series, comps, sub, new, index, order; spec := SpecialPcgs( G ); if Length( spec ) = 0 then return 1; fi; first := LGFirst( spec ); weights := LGWeights( spec ); m := Length( spec ); # the first head i := 1; phi := 1; while i <= Length(first)-1 and weights[first[i]][1] = 1 and weights[first[i]][2] = 1 do start := first[i]; next := first[i+1]; p := weights[start][3]; d := next - start; for j in [0..d-1] do phi := phi * (p^n - p^j); od; if phi = 0 then return 0; fi; i := i + 1; od; # the rest while i <= Length( first ) - 1 do start := first[i]; next := first[i+1]; p := weights[start][3]; d := next - start; if weights[start][2] = 1 then pcgsS := InducedPcgsByPcSequenceNC( spec, spec{[start..m]} ); pcgsN := InducedPcgsByPcSequenceNC( spec, spec{[next..m]} ); pcgsL := pcgsS mod pcgsN; mats := LinearActionLayer( spec, pcgsL ); modu := GModuleByMats( mats, GF(p) ); max := MTX.BasesMaximalSubmodules( modu ); # compute series series := [ Immutable( IdentityMat(d, GF(p)) ) ]; comps := []; sub := series[1]; while Length( max ) > 0 do sub := SumIntersectionMat( sub, max[1] )[2]; if Length( sub ) = 0 then new := max; else new := Filtered( max, x -> RankMat( Concatenation( x, sub ) ) < d ); fi; Add( comps, Sum( List( new, x -> p^(d - Length(x)) ) ) ); Add( series, sub ); max := Difference( max, new ); od; # run down series for j in [1..Length( series )-1] do index := Length( series[j] ) - Length( series[j+1] ); order := p^index; phi := phi * ( order^n - comps[j] ); if phi = 0 then return phi; fi; od; # only the radical is missing now index := Length( series[Length(series)] ); order := p^index; phi := phi * (order^n); if phi = 0 then return 0; fi; else order := p^d; phi := phi * ( order^n ); if phi = 0 then return 0; fi; fi; i := i + 1; od; return phi; end ); RedispatchOnCondition(EulerianFunction,true,[IsGroup,IsPosInt], [IsSolvableGroup,IsPosInt], 1 # make the priority higher than the default method computing # the table of marks ); ############################################################################# ## #M LinearAction( , , ) ## InstallMethod( LinearAction, true, [ IsList, IsMatrix, IsFunction ], 0, function( gens, base, linear ) local i,mats; # catch trivial cases if Length( gens ) = 0 then return []; fi; # compute matrices if Length(base)>0 then mats := List( gens, x -> ImmutableMatrix(Characteristic(base), List( base, y -> linear( y, x ) ),true )); else mats:=List(gens,i->[]); fi; MakeImmutable(mats); return mats; end ); InstallOtherMethod( LinearAction, true, [ IsGroup, IsMatrix, IsFunction ], 0, function( G, base, linear ) return LinearAction( GeneratorsOfGroup( G ), base, linear ); end ); InstallOtherMethod( LinearAction, true, [ IsPcgs, IsMatrix, IsFunction ], 0, function( pcgs, base, linear ) return LinearAction( pcgs, base, linear ); end ); InstallOtherMethod( LinearAction, true, [ IsGroup, IsList, IsMatrix, IsFunction ], 0, function( G, gens, base, linear ) return LinearAction( gens, base, linear ); end ); ############################################################################# ## #M NormalClosure( , ) ## InstallMethod( NormalClosureOp, "groups with home pcgs", true, [ IsGroup and HasHomePcgs, IsGroup and HasHomePcgs ], 0, function( G, U ) local pcgs, home, gens, subg, id, K, M, g, u, tmp; # catch trivial case pcgs := InducedPcgsWrtHomePcgs(U); if Length(pcgs) = 0 then return U; fi; home := HomePcgs(U); if home <> HomePcgs(G) then TryNextMethod(); fi; # get operating elements gens := GeneratorsOfGroup( G ); gens := Set( List( gens, x -> SiftedPcElement( pcgs, x ) ) ); subg := GeneratorsOfGroup( U ); id := Identity( G ); K := ShallowCopy( pcgs ); repeat M := []; for g in gens do for u in subg do tmp := Comm( g, u ); if tmp <> id then AddSet( M, tmp ); fi; od; od; tmp := InducedPcgsByPcSequenceAndGenerators( home, K, M ); tmp := CanonicalPcgs( tmp ); subg := Filtered( tmp, x -> not x in K ); K := tmp; until 0 = Length(subg); K := SubgroupByPcgs( GroupOfPcgs(home), tmp ); # SetHomePcgs( K, home ); # SetInducedPcgsWrtHomePcgs( K, tmp ); return K; end ); ############################################################################# ## #M Random( ) ## InstallMethod( Random, "pcgs computable groups", true, [ IsGroup and CanEasilyComputePcgs and IsFinite ], 0, function(grp) local p; p := Pcgs(grp); if Length( p ) = 0 then return One( grp ); else return Product( p, x -> x^Random(1,RelativeOrderOfPcElement(p,x)) ); fi; end ); BindGlobal( "CentralizerSolvableGroup", function(H,U,elm) local G, home, # the supergroup (of and ), the home pcgs Hp, # a pcgs for inequal, # G<>H flag eas, # elementary abelian series in through step, # counter looping over K, L, # members of Kp,Lp, # induced and modulo pcgs's KcapH,LcapH, # pcgs's of intersections with N, cent, # elementary abelian factor, for affine action cls, # classes in range/source of homomorphism opr, # (elm^opr)=cls.representative p, # prime dividing $|G|$ nexpo,indstep,Ldep,allcent; # Treat the case of a trivial group. if IsTrivial( U ) then return H; fi; if IsSubgroup(H,U) then G:=H; inequal:=false; else G:=ClosureGroup( H, U ); inequal:=true; fi; home:=HomePcgs(G); if not HasIndicesEANormalSteps(home) then home:=PcgsElementaryAbelianSeries(G); fi; # Calculate a (central) elementary abelian series with all pcgs induced # w.r.t. . if IsPrimePowerInt( Size( G ) ) then p:=FactorsInt( Size( G ) )[ 1 ]; home:=PcgsCentralSeries(G); eas:=CentralNormalSeriesByPcgs(home); cent:=ReturnTrue; else home:=PcgsElementaryAbelianSeries(G); eas:=EANormalSeriesByPcgs(home); # AH, 26-4-99: Test centrality not via `in' but via exponents cent:=function(pcgs,grpg,Npcgs,dep) local i,j; for i in grpg do for j in Npcgs do if DepthOfPcElement(pcgs,Comm(j,i)) G/K. # The actual computations are all done in , factors are # represented by modulo pcgs. K :=L; Kp:=Lp; L :=eas[ step ]; Ldep:=indstep[step]; Lp:=InducedPcgs(home,L ); N :=Kp mod Lp; # modulo pcgs representing the kernel allcent:=cent(home,home,N,Ldep); if allcent=false then nexpo:=LinearActionLayer(home{[1..indstep[step-1]-1]},N); fi; # #T What is this? Obviously it is needed somewhere, but it is # #T certainly not good programming style. AH # SetFilterObj( N, IsPcgs ); if inequal then KcapH :=LcapH; LcapH :=NormalIntersectionPcgs( home, Hp, Lp ); N!.capH:=KcapH mod LcapH; #T See above # SetFilterObj( N!.capH, IsPcgs ); else N!.capH:=N; fi; cls[ 1 ].candidates:=cls[ 1 ].representative; if allcent or cent(home, cls[ 1 ].centralizerpcgs, N, Ldep ) then cls:=CentralStepClEANS( home,H, U, N, cls[ 1 ],false ); else cls:=GeneralStepClEANS( home,H, U, N, nexpo,cls[ 1 ],false ); fi; opr:=opr * cls[ 1 ].operator; if IsModuloPcgs(cls[1].cengen) then cls[1].centralizerpcgs:=cls[1].cengen; else cls[1].centralizerpcgs:=InducedPcgsByPcSequenceNC(home,cls[1].cengen); fi; od; if not IsBound(cls[1].centralizer) then cls[1].centralizer:=SubgroupByPcgs(G,cls[1].centralizerpcgs); fi; cls:=ConjugateSubgroup( cls[ 1 ].centralizer, opr ^ -1 ); return cls; end ); ############################################################################# ## #M Centralizer( , ) . . . . . . . . . . . . . . using affine methods ## InstallMethod( CentralizerOp, "pcgs computable group and element", IsCollsElms, [ IsGroup and CanEasilyComputePcgs and IsFinite, IsMultiplicativeElementWithInverse ], 0, # in solvable permutation groups, backtrack seems preferable function( G, g ) return CentralizerSolvableGroup( G, GroupByGenerators( [ g ] ), g ); end ); InstallMethod( CentralizerOp, "pcgs computable groups", IsIdenticalObj, [ IsGroup and CanEasilyComputePcgs and IsFinite, IsGroup and CanEasilyComputePcgs and IsFinite ], 0, # in solvable permutation groups, backtrack seems preferable function( G, H ) local h,P; P:=Parent(G); for h in MinimalGeneratingSet( H ) do G := CentralizerSolvableGroup( G,H, h ); od; G:=AsSubgroup(P,G); Assert(2,ForAll(GeneratorsOfGroup(G),i->ForAll(GeneratorsOfGroup(H), j->Comm(i,j)=One(G)))); return G; end ); ############################################################################# ## #M RepresentativeAction( , , , OnPoints ) using affine methods ## InstallOtherMethod( RepresentativeActionOp, "element conjugacy in pcgs computable groups", IsCollsElmsElmsX, [ IsGroup and CanEasilyComputePcgs and IsFinite, IsMultiplicativeElementWithInverse, IsMultiplicativeElementWithInverse, IsFunction ], 0, function( G, d, e, opr ) if opr <> OnPoints or not (IsPcGroup(G) or (d in G and e in G)) or not (d in G and e in G) then TryNextMethod(); fi; return ClassesSolvableGroup( G, 4,rec(candidates:= [ d, e ] )); end ); ############################################################################# ## #M CentralizerModulo(,,) full preimage of C_(H/N)(elm.N) ## InstallMethod(CentralizerModulo,"pcgs computable groups, for elm", IsCollsCollsElms,[IsGroup and CanEasilyComputePcgs, IsGroup and CanEasilyComputePcgs, IsMultiplicativeElementWithInverse],0, function(H,NT,elm) local G, # common parent home,Hp, # the home pcgs, induced pcgs eas, step, # elementary abelian series in through ea2, # used for factor series K, L, # members of Kp,Lp, # induced and modulo pcgs's KcapH,LcapH, # pcgs's of intersections with N, cent, # elementary abelian factor, for affine action tra, # transversal for candidates p, # prime dividing $|G|$ nexpo,indstep,Ldep,allcent, cl, i; # loop variables # Treat trivial cases. if Index(H,NT)=1 or (HasAbelianFactorGroup(H,NT) and elm in H) or elm in NT then return H; fi; if elm in H then G:=H; else G:=ClosureGroup(H,elm); # is the subgroup still normal if not IsNormal(G,NT) then Error("subgroup not normal!"); fi; fi; home := HomePcgs( G ); if not HasIndicesEANormalSteps(home) then home:=PcgsElementaryAbelianSeries(G); fi; # Calculate a (central) elementary abelian series. eas:=fail; if IsPrimePowerInt( Size( G ) ) then p := FactorsInt( Size( G ) )[ 1 ]; home:=PcgsPCentralSeriesPGroup(G); eas:=PCentralNormalSeriesByPcgsPGroup(home); if NT in eas then cent := ReturnTrue; else eas:=fail; # useless fi; fi; if eas=fail then home:=PcgsElementaryAbelianSeries([G,NT]); eas:=EANormalSeriesByPcgs(home); cent:=function(pcgs,grpg,Npcgs,dep) local i,j; for i in grpg do for j in Npcgs do if DepthOfPcElement(pcgs,Comm(j,i))ClosureGroup(NT,i)); eas:=[]; for i in ea2 do if not i in eas then Add(eas,i); fi; od; for i in eas do if not HasHomePcgs(i) then SetHomePcgs(i,ParentPcgs(home)); fi; od; Hp:=InducedPcgs(home,H); # Initialize the algorithm for the trivial group. step := 1; while IsSubset( eas[ step + 1 ], H ) do step := step + 1; od; L := eas[ step ]; Lp := InducedPcgs(home, L ); if not IsIdenticalObj( G, H ) then LcapH := NormalIntersectionPcgs( home, Hp, Lp ); fi; cl := rec( representative := elm, centralizer := H, centralizerpcgs := InducedPcgs(home,H )); tra := One( H ); # cls := List( candidates, c -> cl ); # tra := List( candidates, c -> One( H ) ); tra:=One(H); # Now go back through the factors by all groups in the elementary abelian # series. for step in [ step + 1 .. Length( eas ) ] do K := L; Kp := Lp; L := eas[ step ]; Ldep:=indstep[step]; Lp := InducedPcgs(home, L ); N := Kp mod Lp; #SetFilterObj( N, IsPcgs ); allcent:=cent(home,home,N,Ldep); if allcent=false then nexpo:=LinearActionLayer(home{[1..indstep[step-1]-1]},N); fi; if not IsIdenticalObj( G, H ) then KcapH := LcapH; LcapH := NormalIntersectionPcgs( home, Hp, Lp ); N!.capH := KcapH mod LcapH; else N!.capH := N; fi; cl.candidates := cl.representative; if allcent or cent(home,cl.centralizerpcgs, N, Ldep) then cl := CentralStepClEANS( home,G, H, N, cl,true )[1]; else cl := GeneralStepClEANS( home,G, H, N,nexpo, cl,true )[1]; fi; tra := tra * cl.operator; if IsModuloPcgs(cl.cengen) then cl.centralizerpcgs:=cl.cengen; else cl.centralizerpcgs:=InducedPcgsByPcSequenceNC(home,cl.cengen); fi; od; if not IsBound(cl.centralizer) then cl.centralizer:=SubgroupByPcgs(G,cl.centralizerpcgs); fi; cl:=ConjugateSubgroup( cl.centralizer, tra ^ -1 ); Assert(2,ForAll(GeneratorsOfGroup(cl),i->Comm(elm,i) in NT)); Assert(2,IsSubset(G,cl)); return cl; end); InstallMethod(CentralizerModulo,"group centralizer via generators", IsFamFamFam,[IsGroup and CanEasilyComputePcgs, IsGroup and CanEasilyComputePcgs, IsGroup],0, function(G,NT,U) local i,P; P:=Parent(G); for i in GeneratorsOfGroup(U) do G:=CentralizerModulo(G,NT,i); od; G:=AsSubgroup(P,G); return G; end); # enforce solvability check. RedispatchOnCondition(CentralizerModulo,true,[IsGroup,IsGroup,IsObject], [IsGroup and IsSolvableGroup,IsGroup and IsSolvableGroup,IsObject],0); ############################################################################# ## #F ElementaryAbelianSeries( ) ## InstallOtherMethod( ElementaryAbelianSeries,"list of pcgs computable groups", true,[IsList and IsFinite], 1, # there is a generic groups function with value 0 function( S ) local home,i, N, O, I, E, L; if Length(S)=0 or not CanEasilyComputePcgs(S[1]) then TryNextMethod(); fi; # typecheck arguments if 1 < Size(S[Length(S)]) then S := ShallowCopy( S ); Add( S, TrivialSubgroup(S[1]) ); fi; # start with the elementary series of the first group of L := ElementaryAbelianSeries( S[ 1 ] ); # enforce the same parent for 'HomePcgs' purposes. home:=HomePcgs(S[1]); N := [ S[ 1 ] ]; for i in [ 2 .. Length( S ) - 1 ] do O := L; L := [ S[ i ] ]; for E in O do I := IntersectionSumPcgs(home, InducedPcgs(home,E), InducedPcgs(home,S[ i ]) ); I.sum:=SubgroupByPcgs(S[1],I.sum); I.intersection:=SubgroupByPcgs(S[1],I.intersection); if not I.sum in N then Add( N, I.sum ); fi; if not I.intersection in L then Add( L, I.intersection ); fi; od; od; for E in L do if not E in N then Add( N, E ); fi; od; return N; end); ############################################################################# ## #M \<(G,H) . . . . . . . . . . . . . . . . . comparison of pc groups by CGS ## InstallMethod(\<,"cgs comparison",IsIdenticalObj,[IsPcGroup,IsPcGroup],0, function( G, H ) return Reversed( CanonicalPcgsWrtFamilyPcgs(G) ) < Reversed( CanonicalPcgsWrtFamilyPcgs(H) ); end); ############################################################################# ## #F GapInputPcGroup( , ) . . . . . . . . . . . . gap input string ## ## Compute the pc-presentation for a finite polycyclic group as gap input. ## Return this input as string. The group will be named ,the ## generators "g". ## InstallGlobalFunction( GapInputPcGroup, function(U,name) local gens, wordString, newLines, lines, ne, i,j; # will hold the various lines of the input for gap,they are # concatenated later. lines:=[]; # Get the generators for the group . gens:=InducedPcgsWrtHomePcgs(U); # Initialize the group and the generators. Add(lines,name); Add(lines,":=function()\nlocal "); for i in [1 .. Length(gens)] do Add(lines,"g"); Add(lines,String(i)); Add(lines,","); od; Add(lines,"r,f,g,rws,x;\n"); Add(lines,"f:=FreeGroup(IsSyllableWordsFamily,"); Add(lines,String(Length(gens))); Add(lines,");\ng:=GeneratorsOfGroup(f);\n"); for i in [1 .. Length(gens)] do Add(lines,"g" ); Add(lines,String(i) ); Add(lines,":=g["); Add(lines,String(i) ); Add(lines,"];\n" ); od; Add(lines,"rws:=SingleCollector(f,"); Add(lines,String(List(gens,i->RelativeOrderOfPcElement(gens,i)))); Add(lines,");\n"); Add(lines,"r:=[\n"); # A function will yield the string for a word. wordString:=function(a) local k,l,list,str,count; list:=ExponentsOfPcElement(gens,a); k:=1; while k <= Length(list) and list[k] = 0 do k:=k + 1; od; if k > Length(list) then return "IdWord"; fi; if list[k] <> 1 then str:=Concatenation("g",String(k),"^", String(list[k])); else str:=Concatenation("g",String(k)); fi; count:=Length(str) + 15; for l in [k + 1 .. Length(list)] do if count > 60 then str :=Concatenation(str,"\n "); count:=4; fi; count:=count - Length(str); if list[l] > 1 then str:=Concatenation(str,"*g",String(l),"^", String(list[l])); elif list[l] = 1 then str:=Concatenation(str,"*g",String(l)); fi; count:=count + Length(str); od; return str; end; # Add the power presentation part. for i in [1 .. Length(gens)] do ne:=gens[i]^RelativeOrderOfPcElement(gens,gens[i]); if ne<>One(U) then Add(lines,Concatenation("[",String(i),",", wordString(ne),"]")); if iOne(U) then if i <> Length(gens) - 1 or j <> i + 1 then Add(lines,Concatenation("[",String(j),",",String(i),",", wordString(ne),"],\n")); else Add(lines,Concatenation("[",String(j),",",String(i),",", wordString(ne),"]\n")); fi; fi; od; od; Add(lines,"];\nfor x in r do SetCommutator(rws,x[1],x[2],x[3]);od;\n"); Add(lines,"return GroupByRwsNC(rws);\n"); Add(lines,"end;\n"); Add(lines,name); Add(lines,":="); Add(lines,name); Add(lines,"();\n"); Add(lines,"Print(\"#I A group of order \",Size("); Add(lines,name); Add(lines,"),\" has been defined.\\n\");\n"); Add(lines,"Print(\"#I It is called "); Add(lines,name); Add(lines,"\\n\");\n"); # Concatenate all lines and return. while Length(lines) > 1 do if Length(lines) mod 2 = 1 then Add(lines,""); fi; newLines:=[]; for i in [1 .. Length(lines) / 2] do newLines[i]:=Concatenation(lines[2*i-1],lines[2*i]); od; lines:=newLines; od; IsString(lines[1]); return lines[1]; end ); ############################################################################# ## #M Enumerator( ) . . . . . . . . . . . . . . . . . . enumerator by pcgs ## InstallMethod( Enumerator,"finite pc computable groups",true, [ IsGroup and CanEasilyComputePcgs and IsFinite ], 0, G -> EnumeratorByPcgs( Pcgs( G ) ) ); ############################################################################# ## #M KnowsHowToDecompose( , ) ## InstallMethod( KnowsHowToDecompose, "pc group and generators: always true", IsIdenticalObj, [ IsPcGroup, IsList ], 0, ReturnTrue); ############################################################################# ## #F CanonicalSubgroupRepresentativePcGroup( , ) ## InstallGlobalFunction( CanonicalSubgroupRepresentativePcGroup, function(G,U) local e, # EAS pcgs, # himself iso, # isomorphism to EAS group start, # index of largest abelian quotient i, # loop n, # e[i] m, # e[i+1] pcgsm, # pcgs(m) mpcgs, # pcgs mod pcgsm V, # canon. rep fv, # fvgens, # gens(fv) no, # its normalizer orb, # orbit o, # orb index nno, # growing normalizer min, minrep, # minimum indicator # p, # orbit pos. one, # 1 abc, # abelian case indicator nopcgs, #pcgs(no) te, # transversal exponents opfun, # operation function ce; # conj. elm if not IsSubgroup(G,U) then Error("#W CSR Closure\n"); G:=Subgroup(Parent(G),Concatenation(GeneratorsOfGroup(G), GeneratorsOfGroup(U))); fi; # compute a pcgs fitting the EAS pcgs:=PcgsChiefSeries(G); e:=ChiefNormalSeriesByPcgs(pcgs); if not IsBound(G!.chiefSeriesPcgsIsFamilyInduced) then # test whether pcgs is family induced m:=List(pcgs,i->ExponentsOfPcElement(FamilyPcgs(G),i)); G!.chiefSeriesPcgsIsFamilyInduced:= ForAll(m,i->Number(i,j->j<>0)=1) and ForAll(m,i->Number(i,j->j=1)=1) and m=Reversed(Set(m)); if not G!.chiefSeriesPcgsIsFamilyInduced then # compute isom. &c. V:=PcGroupWithPcgs(pcgs); iso:=GroupHomomorphismByImagesNC(G,V,pcgs,FamilyPcgs(V)); G!.isomorphismChiefSeries:=iso; G!.isomorphismChiefSeriesPcgs:=FamilyPcgs(Image(iso)); G!.isomorphismChiefSeriesPcgsSeries:=List(e,i->Image(iso,i)); fi; fi; if not G!.chiefSeriesPcgsIsFamilyInduced then iso:=G!.isomorphismChiefSeries; pcgs:=G!.isomorphismChiefSeriesPcgs; e:=G!.isomorphismChiefSeriesPcgsSeries; U:=Image(iso,U); G:=Image(iso); else iso:=false; fi; #pcgs:=Concatenation(List([1..Length(e)-1],i-> # InducedPcgs(home,e[i]) mod InducedPcgs(home,e[i+1]))); #pcgs:=PcgsByPcSequence(ElementsFamily(FamilyObj(G)),pcgs); ##AH evtl. noch neue Gruppe # find the largest abelian quotient start:=2; while startmin then # Error("hier1"); #fi; # trim m-part min:=List(min,i->CanonicalPcElement(pcgsm,i)); # operation function: operate on the cgs modulo m opfun:=function(u,e) u:=CorrespondingGeneratorsByModuloPcgs(mpcgs,List(u,j->j^e)); #UU:=ShallowCopy(u); # NORMALIZE_IGS(mpcgs,u); #if UU<>u then # Error("hier2"); #fi; # trim m-part u:=List(u,i->CanonicalPcElement(pcgsm,i)); return u; end; else min:=fv; opfun:=OnPoints; fi; # this function computes the orbit in a well-defined order that permits # to find a transversal cheaply orb:=Pcgs_OrbitStabilizer(nopcgs,false,min,nopcgs,opfun); nno:=orb.stabpcgs; abc:=orb.lengths; orb:=orb.orbit; #if Length(orb)<>Index(no,Normalizer(no,fv)) then # Error("len!"); #fi; # determine minimal conjugate minrep:=one; for o in [2..Length(orb)] do if orb[o]1 do while abc[o]>=minrep do o:=o+1; od; te[o-1]:=-QuoInt(minrep-1,abc[o]); minrep:=(minrep-1) mod abc[o]+1; od; te:=LinearCombinationPcgs(nopcgs,te)^-1; if opfun(orb[1],te)<>min then Error("wrong repres!"); fi; minrep:=te; fi; # # # nno:=Normalizer(no,fv); # # rep:=RightTransversal(no,nno); # #orb:=List(rep,i->CanonicalPcgs(InducedPcgs(pcgs,fv^i))); # # # try to cope with action on vector space (long orbit) ## abc:=false; ## if Index(fv,m)>1 and HasElementaryAbelianFactorGroup(fv,m) then ## nocl:=NormalClosure(no,fv); ## if HasElementaryAbelianFactorGroup(nocl,m) then ### abc:=true; # try el. ab. case ## fi;; ## fi; # # if abc then # nocl:=InducedPcgs(pcgs,nocl) mod pcgsm; # nopcgs:=InducedPcgs(pcgs,no) mod pcgsm; # lop:=LinearActionLayer(Group(nopcgs),nocl); #matrices for action # fvgens:=List(fvgens,i->ShallowCopy( # ExponentsOfPcElement(nocl,i)*Z(RelativeOrders(nocl)[1])^0)); # TriangulizeMat(fvgens); # canonize # min:=fvgens; # minrep:=one; # for o in rep do # if o<>one then # # matrix image of rep # orb:=ExponentsOfPcElement(nopcgs,o); # orb:=Product([1..Length(orb)],i->lop[i]^orb[i]); # orb:=List(fvgens*orb,ShallowCopy); # TriangulizeMat(orb); # if orbone then # if Length(fvgens)=1 then # orb:=fvgens[1]^o; # orb:=orb^(1/LeadingExponentOfPcElement(mpcgs,orb) # mod RelativeOrderOfPcElement(mpcgs,orb)); # orb:=[orb]; # else # orb:=CorrespondingGeneratorsByModuloPcgs(mpcgs,List(fvgens,j->j^o)); # NORMALIZE_IGS(mpcgs,orb); # fi; # if orbi^minrep)); ce:=ce*minrep; V:=V^minrep; od; if iso<>false then V:=PreImage(iso,V); no:=PreImage(iso,no); ce:=PreImagesRepresentative(iso,ce); fi; return [V,no,ce]; end ); ############################################################################# ## #M ConjugacyClassSubgroups(,) . . . . . . . constructor for pc groups ## This method installs 'CanonicalSubgroupRepresentativePcGroup' as ## CanonicalRepresentativeDeterminator ## InstallMethod(ConjugacyClassSubgroups,IsIdenticalObj,[IsPcGroup,IsPcGroup],0, function(G,U) local cl; cl:=Objectify(NewType(CollectionsFamily(FamilyObj(G)), IsConjugacyClassSubgroupsByStabilizerRep),rec()); SetActingDomain(cl,G); SetRepresentative(cl,U); SetFunctionAction(cl,OnPoints); SetCanonicalRepresentativeDeterminatorOfExternalSet(cl, CanonicalSubgroupRepresentativePcGroup); return cl; end); InstallOtherMethod(RepresentativeActionOp,"pc group on subgroups",true, [IsPcGroup,IsPcGroup,IsPcGroup,IsFunction],0, function(G,U,V,f) local c1,c2; if f<>OnPoints or not (IsSubset(G,U) and IsSubset(G,V)) then TryNextMethod(); fi; if Size(U)<>Size(V) then return fail; fi; c1:=CanonicalSubgroupRepresentativePcGroup(G,U); c2:=CanonicalSubgroupRepresentativePcGroup(G,V); if c1[1]<>c2[1] then return fail; fi; return c1[3]/c2[3]; end); ############################################################################# ## #F ChiefSeriesUnderAction( , ) ## InstallMethod( ChiefSeriesUnderAction, "method for a pcgs computable group", IsIdenticalObj, [ IsGroup, IsGroup and CanEasilyComputePcgs ], 0, function( U, G ) local home,e,ser,i,j,k,pcgs,mpcgs,op,m,cs,n; home:=HomePcgs(G); e:=ElementaryAbelianSeriesLargeSteps(G); # make the series U-invariant ser:=ShallowCopy(e); e:=[G]; n:=G; for i in [2..Length(ser)] do # check whether we actually stepped down (or did the intersection # already do it? if Size(ser[i])Length(b);end); cs:=cs{[2..Length(cs)]}; Info(InfoPcGroup,2,Length(cs)-1," compositionFactors"); for j in cs do n:=e[i]; for k in j do n:=ClosureGroup(n,PcElementByExponentsNC(mpcgs,List(k,IntFFE))); od; Add(ser,n); od; fi; od; return ser; end); InstallMethod(IsSimpleGroup,"for solvable groups",true, [IsSolvableGroup], # this is also better for permutation groups, so we increase the value to # be above the value for `IsPermGroup'. Maximum(RankFilter(IsSolvableGroup), RankFilter(IsPermGroup)+1) -RankFilter(IsSolvableGroup), function(G) return IsInt(Size(G)) and IsPrimeInt(Size(G)); end); ############################################################################# ## #M ViewObj() ## InstallMethod(ViewObj,"pc group",true,[IsPcGroup],0, function(G) if (not HasParent(G)) or Length(GeneratorsOfGroup(G))*Length(GeneratorsOfGroup(Parent(G))) / GAPInfo.ViewLength > 50 then Print(""); else Print("Group("); ViewObj(GeneratorsOfGroup(G)); Print(")"); fi; end); ############################################################################# ## #M CanEasilyComputePcgs( ) . . . . . . . . . . . . . . . . pc group ## InstallTrueMethod( CanEasilyComputePcgs, IsPcGroup ); # InstallTrueMethod( CanEasilyComputePcgs, HasPcgs ); # we cannot guarantee that computations with any pcgs is efficient InstallTrueMethod( CanEasilyComputePcgs, IsGroup and HasFamilyPcgs ); ############################################################################# ## #M CanEasilyTestMembership ## # InstallTrueMethod(CanEasilyTestMembership,CanEasilyComputePcgs); # we cannot test membership using a pcgs # InstallTrueMethod(CanComputeSize, CanEasilyComputePcgs); #unneccessary ############################################################################# ## #M IsSolvableGroup ## InstallTrueMethod(IsSolvableGroup, CanEasilyComputePcgs); ############################################################################# ## #M CanComputeSizeAnySubgroup ## InstallTrueMethod( CanComputeSizeAnySubgroup, CanEasilyComputePcgs ); ############################################################################# ## #M CanEasilyComputePcgs( ) . . . . . . . . . subset or factor relation ## ## Since factor groups might be in a different representation, ## they should *not* inherit `CanEasilyComputePcgs' automatically. ## #InstallSubsetMaintenance( CanEasilyComputePcgs, # IsGroup and CanEasilyComputePcgs, IsGroup ); ############################################################################# ## #M IsConjugatorIsomorphism( ) ## InstallMethod( IsConjugatorIsomorphism, "for a pc group general mapping", true, [ IsGroupGeneralMapping ], 1, # There is no filter to test whether source and range of a homomorphism # are pc groups. # So we have to test explicitly and make this method # higher ranking than the default one in `ghom.gi'. function( hom ) local s, r, G, genss, rep; s:= Source( hom ); if not IsPcGroup( s ) then TryNextMethod(); elif not ( IsGroupHomomorphism( hom ) and IsBijective( hom ) ) then return false; elif IsEndoGeneralMapping( hom ) and IsInnerAutomorphism( hom ) then return true; fi; r:= Range( hom ); # Check whether source and range are in the same family. if FamilyObj( s ) <> FamilyObj( r ) then return false; fi; # Compute a conjugator in the full pc group. G:= GroupOfPcgs( FamilyPcgs( s ) ); genss:= GeneratorsOfGroup( s ); rep:= RepresentativeAction( G, genss, List( genss, i -> ImagesRepresentative( hom, i ) ), OnTuples ); # Return the result. if rep <> fail then Assert( 1, ForAll( genss, i -> Image( hom, i ) = i^rep ) ); SetConjugatorOfConjugatorIsomorphism( hom, rep ); return true; else return false; fi; end ); ############################################################################# ## #M CanEasilyComputeWithIndependentGensAbelianGroup( ) ## InstallTrueMethod(CanEasilyComputeWithIndependentGensAbelianGroup, IsGroup and CanEasilyComputePcgs and IsAbelian); ############################################################################# ## #M IndependentGeneratorsOfAbelianGroup( ) ## InstallMethod(IndependentGeneratorsOfAbelianGroup, "Use Pcgs and NormalFormIntMat to find the independent generators", [IsGroup and CanEasilyComputePcgs and IsAbelian],0, function(G) local matrix, snf, base, ord, cti, row, g, o, cf, j, i; if IsTrivial(G) then return []; fi; matrix:=List([1..Size(Pcgs(G))],g->List(ExponentsOfRelativePower(Pcgs(G),g))); for i in [1..Size(Pcgs(G))] do matrix[i][i]:=-RelativeOrders(Pcgs(G))[i]; od; snf:=NormalFormIntMat(matrix,1+8+16); base:=[]; ord:=[]; cti:=snf.coltrans^-1; for i in [1..Length(cti)] do row:=cti[i]; g:=LinearCombinationPcgs(Pcgs(G),row,One(G)); if not IsOne(g) then # get the involved prime factors o:=snf.normal[i][i]; cf:=Collected(Factors(o)); if Length(cf)>1 then for j in cf do j:=j[1]^j[2]; Add(ord,j); Add(base,g^(o/j)); od; else Add(base,g); Add(ord,o); fi; fi; od; SortParallel(ord,base); return base; end); ############################################################################# ## #M MinimalGeneratingSet( ) ## InstallMethod(MinimalGeneratingSet, "compute via Smith normal form", [IsGroup and CanEasilyComputePcgs and IsAbelian], RankFilter (IsPcGroup), function(G) local pcgs, matrix, snf, gens, cti, row, g, i; if IsTrivial (G) then return []; fi; pcgs := Pcgs (G); matrix:=List([1..Length(pcgs)],i->List(ExponentsOfRelativePower(pcgs,i))); for i in [1..Length(pcgs)] do matrix[i][i]:=-RelativeOrders(pcgs)[i]; od; snf:=NormalFormIntMat(matrix,1+8+16); gens:=[]; cti:=snf.coltrans^-1; for i in [1..Length(cti)] do row:=cti[i]; g:=Product( List([1..Length(row)],j->pcgs[j]^row[j])); if not IsOne(g) then Add(gens,g); fi; od; return gens; end); ############################################################################# ## #M ExponentOfPGroupAndElm( , ) ## # Return exponent and probably also an element of high order. If exponent is # found to be larger than bound, just return the result found so far. # # JS: A result of Higman detailed on p564 of C. Sims Computation with # F. P. Groups shows that an element of maximal order in a p-group # exists where its weight with respect to a special pcgs is at most # the p-class of the group. Furthermore we need only check normed # row vectors as exponent vectors since every cyclic subgroup has a # generator with a normed row vector for exponents. # # This function just checks all such vectors using a simple backtrack # method. It handles the case of the trivial group and a regular # p-group specially. # # Assumed: G is a p-group, of max size p^30 or so. BindGlobal("ExponentOfPGroupAndElm", function(G,bound) local all,pcgs,monic,weights,pclass,p; monic := function(w,p,f) local a,ldim,c,M,M1; M := [0,0]; c := Maximum(w); for ldim in [1..Size(w)] do a := ListWithIdenticalEntries(Size(w),0); a[ldim] := 1; M1 := all(ldim,a,w,p,c-w[ldim],f); if M1[1] > M[1] then M:=M1; if M[1] > bound then return M; fi; fi; od; return M; end; all := function(ldim,a,w,p,c,f) local M,M1; if ldim = Size(a) then return [f(a),PcElementByExponents(pcgs,a)]; fi; M := [0,0]; a{[ldim+2..Size(a)]} := ListWithIdenticalEntries(Size(a)-ldim-1,0); a[ldim+1] := Minimum( p-1, Int(c/w[ldim+1]) ); while a[ldim+1] >= 0 do M1 := all(ldim+1,a,w,p,c-a[ldim+1]*w[ldim+1],f); if M1[1] > M[1] then M:=M1; if M[1] > bound then return M; fi; fi; a[ldim+1] := a[ldim+1]-1; od; return M; end; p := PrimePGroup(G); if p = fail then return [1,One(G)]; fi; # handle trivial p-group of size 1 pcgs := SpecialPcgs(G); weights := LGLayers(pcgs); pclass := Maximum(weights); if pclass < p then # Easily recognized regular p-group pclass := Maximum(List(pcgs,Order)); return [pclass,First(pcgs,g->Order(g)=pclass)]; fi; bound := Minimum(p^(pclass-1),bound); return monic(LGLayers(pcgs),PrimePGroup(G),a->Order(PcElementByExponents(pcgs,a))); end); InstallMethod( Exponent,"solvable group: does obvious bound work?", true,[IsGroup and IsSolvableGroup],0, #based on code by Jack Schmidt function(G) local L, upper, lower, cnts, cnt, a, i; if IsPGroup(G) then return ExponentOfPGroupAndElm(G,Size(G))[1]; fi; L:=DerivedSeriesOfGroup(G); upper:=1; for i in [1..Length(L)-1] do upper:=upper*Lcm(AbelianInvariants(L[i])); od; lower:=Lcm(List(Pcgs(G),Order)); cnts:=LogInt(Size(G),2); cnt:=cnts; repeat a:=Lcm(lower,Order(Random(G))); if a>lower then if a=upper then return upper; fi; lower:=a; cnt:=cnts; else cnt:=cnt-1; fi; until cnt<1; # fails TryNextMethod(); end); ############################################################################# ## #M AgemoOp( ) ## InstallMethod( AgemoOp, "PGroups",true,[ IsPGroup, IsPosInt, IsPosInt ],0, function( G, p, n ) local q, pcgs, sub, hom, f, ex, C; q := p ^ n; # if is abelian, raise the generators to the q.th power if IsAbelian(G) then return SubgroupNC( G,Filtered( List( GeneratorsOfGroup( G ), x -> x^q ),i->not IsOne(i)) ); fi; # based on Code by Jack Schmidt pcgs:=Pcgs(G); ex:=One(G); sub:=NormalClosure(G,SubgroupNC(G,Filtered(List(pcgs,i->i^q),x->x<>ex))); hom:=NaturalHomomorphismByNormalSubgroup(G,sub); f:=Range(hom); ex:=ExponentOfPGroupAndElm(f,q); while ex[1]>q do # take the element of highest order in f and take power of its preimage ex:=PreImagesRepresentative(hom,ex[2]^q); sub:=NormalClosure(G,ClosureSubgroupNC(sub,ex)); hom:=NaturalHomomorphismByNormalSubgroup(G,sub); f:=Range(hom); ex:=ExponentOfPGroupAndElm(f,q); od; return sub; # otherwise compute the conjugacy classes of elements C := Set( List( ConjugacyClasses(G), x -> Representative(x)^q ) ); return NormalClosure( G, SubgroupNC( G, C ) ); end ); InstallMethod(Socle,"for p-groups",true,[IsPGroup],0, function(G) if IsTrivial(G) then return G; fi; return Omega(Center(G),PrimePGroup(G),1); end); ############################################################################# ## #M OmegaOp( ,

, ) . . . . . . . . . . . . for p-groups ## ## The following method is due to Jack Schmidt ## Omega(G,p,e) is defined to be # Omega_LowerBound returns a subgroup of Omega(G,p,e) # Assumed: G is a p-group, e is a positive integer BindGlobal("Omega_LowerBound_RANDOM",100); # number of random elements to test BindGlobal("Omega_LowerBound", function(G,p,e) local gens,H,fix_order; fix_order:=function(g) while not IsOne(g^(p^e)) do g:=g^p; od; return g; end; H:=Subgroup(G,List(Pcgs(G),fix_order)); H:=ClosureGroup(H,List([1..Omega_LowerBound_RANDOM],i->fix_order(Random(G)))); return H; end); # Omega_Search is a brute force search for Omega. # One can search by coset if Omega(G) = { g in G : g^(p^e) = 1 } # This is the case in regular p-groups, and if nilclass(G) < p # then G is regular. # Assumed: G is a p-group, e is a positive integer BindGlobal("Omega_Search", function(G,p,e) local g,H,fix_order,T; H:=Omega_LowerBound(G,p,e); fix_order:=function(g) while not IsOne(g^(p^e)) do g:=g^p; od; return g; end; if NilpotencyClassOfGroup(G) < p then T:=RightTransversal(G,H); else T:=G; fi; for g in T do g:=fix_order(g); if(g in H) then continue; fi; H:=ClosureSubgroup(H,g); if(H=G) then return G; fi; od; return H; end); # Omega_UpperBoundAbelianQuotient(G,p,e) returns a subgroup K<=G # such that Omega(G,p,e) <= K. Then Omega(K,p,e)=Omega(G,p,e) # allowing other methods to work on a smaller group. # # It is not guaranteed that K is a proper subgroup of G. # # In detail: Omega(G/[G,G],p,e) = K/[G,G] and K is returned. # # Assumed: G is a p-group, e is a positive integer BindGlobal("Omega_UpperBoundAbelianQuotient", function(G,p,e) local f; f:=MaximalAbelianQuotient(G); IsAbelian(Image(f)); return SubgroupByPcgs(G,Pcgs(PreImagesSet(f,Omega(Image(f),p,e)))); end); # Efficiency notes: # # (1) "PreImagesSet" is used to find the preimage of Omega in G/[G,G]. # there may very well be faster ways of doing this. # # (2) "SubgroupByPcgs(G,Pcgs(...))" is used to give the returned subgroup # with natural standard generators. There may be better ways of doing this, # and this may not be needed at all. # Omega_UpperBoundCentralQuotient(G,p,e) returns # a subgroup K with Omega(G,p,e) <= K <= G. The # algorithm is (moderately) randomized. # # The algorithm is NOT fast. # # In detail a random central element, z, of order p is # selected and K is returned where K/ = Omega(G/,p,e). # # Assumed: G is a p-group, e is a positive integer BindGlobal("Omega_UpperBoundCentralQuotient", function(G,p,e) local z,f; z:=One(G); while(IsOne(z)) do z:=Random(Socle(G)); od; f:=NaturalHomomorphismByNormalSubgroup(G,Subgroup(G,[z])); IsAbelian(Image(f)); # Probably is not, but quick to check return SubgroupByPcgs(G,Pcgs(PreImagesSet(f,Omega(Image(f),p,e)))); end); # Efficiency Points: # # (1) "Omega" is used to compute Omega(G/,p,e). |G/| = |G|/p. # This is a very very tiny reduction AND it is very possible for # Omega(G/)=G/ for every nontrivial element z of the socle without # Omega(G)=G. Hence the calculation of Omega(G/) may take a very # long time AND may prove worthless. # # (2) "PreImagesSet" is used to calculate the preimage of Omega(G/) # there may be more efficient methods to do this. I have noticed a very # wide spread of times for the various PreImage functions. # Omega(G,p,e) is a normal, characteristic, fully invariant subgroup that # behaves nicely under group homomorphisms. In particular # if Omega(G/N)=K/N then Omega(G) <= K. If Omega(G) <= K, # then Omega(G)=Omega(K). # # Hence the general strategy is to find good upper bounds K for # Omega(G), and then compute Omega(K) instead. It is difficult # to tell when one's upper bound is actually equal to Omega(G), # so we attempt to terminate early by finding good lower bounds # H as well. # # Assumed: G is a p-group, e is a positive integer BindGlobal("Omega_Sims_CENTRAL",100); BindGlobal("Omega_Sims_RUNTIME",5000); #Choose a central element z of order p. Suppose that by induction #we know H = Omega(G/). Then Omega(G) is contained in the inverse #image K of H in G. Compute K/K'. If that quotient has elements of #order p^2, then we can cut K down a bit. Thus we may assume that we #know a normal subgroup K of G that contains Omega(G), K maps into #H, and K/K' has exponent p. One would hope that K is small enough #that random methods combined with deterministic computations would #make it possible to compute Omega(K) = Omega(G). #-Charles Sims BindGlobal("Omega_Sims", function(G,p,e) local H,K,Knew,fails,gens,r; if(IsTrivial(G)) then return G; fi; K:=G; H:=Omega_LowerBound(K,p,e); if(H=K) then return K; fi; # Step 1, reduce until K/K' = Omega(K/K') then Omega(G)=Omega(K) while (true) do # there is a `break' below Knew:=Omega_UpperBoundAbelianQuotient(K,p,e); if(Knew=K) then break; fi; K:=Knew; od; if (H=K) then return K; fi; # Step 2, reduce until we have fail lots of times in a row # or waste a lot of time. r:=Runtime(); fails:=0; while(failsG) then return Omega(K,p,e); fi; # Otherwise we try to search. if(Size(G)<2^24) then return Omega_Search(G,p,e); fi; # If the group is too big to search, just let the user know. If he wants # to continue we can try and return a lower bound, but this is too small # quite often. Error("Inductive method failed. You may 'return;' if you wish to use a\n", "(possible incorrect) lower bound ",H," for Omega."); return H; end); InstallMethod( OmegaOp, "for p groups", true, [ IsGroup, IsPosInt, IsPosInt ], 0, function( G, p, n ) local gens, q, gen, ord, o; # trivial cases if n=0 then return TrivialSubgroup(G);fi; if IsAbelian( G ) then q := p^n; gens := [ ]; for gen in IndependentGeneratorsOfAbelianGroup( G ) do ord := Order( gen ); o := GcdInt( ord, q ); if o <> 1 then Add( gens, gen ^ ( ord / o ) ); fi; od; return SubgroupNC( G, gens ); fi; if not PrimePGroup(G)=p then TryNextMethod(); fi; if ForAll(Pcgs(G),g->IsOne(g^(p^n))) then return G; elif(Size(G)<2^15) then return Omega_Search(G,p,n); else return Omega_Sims(G,p,n); fi; end); ############################################################################ ## #M HallSubgroupOp (, ) ## InstallMethod (HallSubgroupOp, "via IsomoprhismPcGroup", true, [IsGroup and IsSolvableGroup and IsFinite, IsList], 0, function (grp, pi) local iso; iso := IsomorphismPcGroup (grp); return PreImagesSet (iso, HallSubgroup (ImagesSource (iso), pi)); end); ############################################################################ ## #M HallSubgroupOp (, ) ## RedispatchOnCondition(HallSubgroupOp,true,[IsGroup,IsList], [IsSolvableGroup and IsFinite,],1); ############################################################################ ## #M SylowComplementOp (,

) ## InstallMethod (SylowComplementOp, "via IsomoprhismPcGroup", true, [IsGroup and IsSolvableGroup and IsFinite, IsPosInt], 0, function (grp, p) local iso; iso := IsomorphismPcGroup (grp); return PreImagesSet (iso, SylowComplement (ImagesSource (iso), p)); end); ############################################################################ ## #M SylowComplementOp (,

) ## RedispatchOnCondition(SylowComplementOp,true,[IsGroup,IsPosInt], [IsSolvableGroup and IsFinite, IsPosInt ],1); ############################################################################# ## #E gap-4r6p5/lib/polyrat.gi0000644000175000017500000016036412172557254013736 0ustar billbill############################################################################# ## #W polyrat.gi GAP Library Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1999 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains functions for polynomials over the rationals ## ############################################################################# ## #F APolyProd(,,

) . . . . . . . . . . polynomial product a*b mod p ## ##return a*b mod p; InstallGlobalFunction(APolyProd,function(a,b,p) local ac,bc,i,j,pc,pv,ci,fam; ci:=CIUnivPols(a,b); fam:=FamilyObj(a); a:=CoefficientsOfLaurentPolynomial(a); b:=CoefficientsOfLaurentPolynomial(b); pv:=a[2]+b[2]; #pc:=ProductCoeffs(a.coefficients,b.coefficients); ac:=List(a[1],i->i mod p); bc:=List(b[1],i->i mod p); if Length(ac)>Length(bc) then pc:=ac; ac:=bc; bc:=pc; fi; # prepare result list pc:=[]; for i in [1..Length(ac)+Length(bc)-1] do pc[i]:=0; od; for i in [1..Length(ac)] do #pc:=SumCoeffs(pc,i*bc) mod p; for j in [1..Length(bc)] do pc[i+j-1]:=(pc[i+j-1]+ac[i]*bc[j]) mod p; od; od; pv:=pv+RemoveOuterCoeffs(pc,fam!.zeroCoefficient); return LaurentPolynomialByExtRepNC(fam,pc,pv,ci); end); ############################################################################# ## #F BPolyProd(,,,

) . . . . . . polynomial product a*b mod m mod p ## ## return EuclideanRemainder(PolynomialRing(Rationals),a*b mod p,m) mod p; InstallGlobalFunction(BPolyProd,function(a,b,m,p) local ac,bc,mc,i,j,pc,ci,f,fam; ci:=CIUnivPols(a,b); fam:=FamilyObj(a); a:=CoefficientsOfLaurentPolynomial(a); b:=CoefficientsOfLaurentPolynomial(b); m:=CoefficientsOfLaurentPolynomial(m); # we shift as otherwise the mod will mess up valuations (should occur # rarely anyhow) ac:=List(a[1],i->i mod p); ac:=ShiftedCoeffs(ac,a[2]); bc:=List(b[1],i->i mod p); bc:=ShiftedCoeffs(bc,b[2]); mc:=List(m[1],i->i mod p); mc:=ShiftedCoeffs(mc,m[2]); ReduceCoeffsMod(ac,mc,p); ShrinkRowVector(ac); ReduceCoeffsMod(bc,mc,p); ShrinkRowVector(bc); if Length(ac)>Length(bc) then pc:=ac; ac:=bc; bc:=pc; fi; pc:=[]; f:=false; for i in ac do if f then # only do it 2nd time (here to avoin doing once too often) bc:=ShiftedCoeffs(bc,1); ReduceCoeffsMod(bc,mc,p); ShrinkRowVector(bc); else f:=true; fi; #pc:=SumCoeffs(pc,i*bc) mod p; for j in [Length(pc)+1..Length(bc)] do pc[j]:=0; od; for j in [1..Length(bc)] do pc[j]:=(pc[j]+i*bc[j] mod p) mod p; od; ShrinkRowVector(pc); ReduceCoeffsMod(pc,mc,p); ShrinkRowVector(pc); od; p:=RemoveOuterCoeffs(pc,fam!.zeroCoefficient); return LaurentPolynomialByExtRepNC(fam,pc,p,ci); end); ############################################################################# ## #F ApproxRational: approximativ k"urzen ## BindGlobal("ApproxRational",function(r,s) local n,d,u; n:=NumeratorRat(r); d:=DenominatorRat(r); u:=LogInt(d,10)-s+1; if u>0 then u:=10^u; return QuoInt(n,u)/QuoInt(d,u); else return r; fi; end); ############################################################################# ## #F ApproximateRoot(,[,]) . . approximate th n-th root of num ## numerically with a denominator of 'digits' digits. ## APPROXROOTS:=[]; BindGlobal("ApproximateRoot",function(arg) local r,e,f,x,nf,lf,c,store; r:=arg[1]; e:=arg[2]; store:= e<=10 and IsInt(r) and 0<=r and r<=100; if store and IsBound(APPROXROOTS[e]) and IsBound(APPROXROOTS[e][r+1]) then return APPROXROOTS[e][r+1]; fi; if Length(arg)>2 then f:=arg[3]; else f:=10; fi; x:=RootInt(NumeratorRat(r),e)/RootInt(DenominatorRat(r),e); nf:=r; c:=0; repeat lf:=nf; x:=ApproxRational(1/e*((e-1)*x+r/(x^(e-1))),f+6); nf:=AbsInt(x^e-r); if nf=0 then c:=6; else if nf>lf then lf:=nf/lf; else lf:=lf/nf; fi; if lf<2 then c:=c+1; else c:=0; fi; fi; # until 3 times no improvement until c>2; if store then if not IsBound(APPROXROOTS[e]) then APPROXROOTS[e]:=[]; fi; APPROXROOTS[e][r+1]:=x; fi; return x; end); ############################################################################# ## #F ApproxRootBound(f) Numerical approximation of RootBound (better, but ## may fail) ## BindGlobal("ApproxRootBound",function(f) local pl,x,p,tp,diff,app,d,scheit,v,nkon; x:=IndeterminateNumberOfLaurentPolynomial(f); p:=CoefficientsOfLaurentPolynomial(f); if p[2]<0 or not ForAll(p[1],IsRat) then # avoid complex conjugation etc. Error("only yet implemented for rational polynomials"); fi; # eliminate valuation f:=UnivariatePolynomialByCoefficients(CyclotomicsFamily,p[1],x); x:=UnivariatePolynomialByCoefficients(CyclotomicsFamily,[0,1],x); # probably first test, whether polynomial should be inverted. However, # we expect roots larger than one. d:=DegreeOfLaurentPolynomial(f); f:=Value(f,1/x)*x^d; app:=1/2; diff:=1/4; nkon:=true; repeat # pol, whose roots are the 1/app of the roots of f tp:=Value(f,x*app); tp:=CoefficientsOfLaurentPolynomial(tp)[1]; tp:=tp/tp[1]; tp:=List(tp,i->ApproxRational(i,10)); # now check, by using the Lehmer/Schur method, whether tp has a root # in the unit circle, i.e. f has a root in the app-circle repeat scheit:=false; p:=tp; repeat d:=Length(p); # compute T[p]=\bar a_n p-a_0 p*, everything rational. pl:=p; p:=p[1]*p-p[d]*Reversed(p); p:=List(p,i->ApproxRational(i,10)); d:=Length(p); while d>1 and p[d]=0 do Unbind(p[d]); d:=d-1; od; v:=p[1]; if v=0 then scheit:=nkon; fi; nkon:=ForAny(p{[2..Length(p)]},i->i<>0); until v<=0; if scheit then # we fail due to rounding errors return fail; else if v<0 then # zero in the unit circle, app smaller app:=app-diff; else # no zero in the unit circle, app larger app:=app+diff; fi; fi; until not scheit; diff:=diff/2; # until good circle found, which does not contain roots. until v=0 and (1-app/(app+diff))<1/40; # revert last enlargement and add accuracy to be secure app:=app-2*diff; return 1/app+1/20; end); ############################################################################# ## #F RootBound() . . . . bound for absolute value of (complex) roots of f ## InstallGlobalFunction(RootBound,function(f) local a,b,c,d; # valuation gives only 0 as zero, this can be neglected f:=CoefficientsOfLaurentPolynomial(f)[1]; # normieren f:=f/f[Length(f)]; f:=UnivariatePolynomialByCoefficients(CyclotomicsFamily,f,1); a:=ApproxRootBound(f); # did the numerical part fail? if a=fail then c:=CoefficientsOfLaurentPolynomial(f)[1]; c:=List(c,AbsInt); d:=Length(c); a:=Maximum(1,Sum(c{[1..d-1]})); b:=1+Maximum(c); if bRootInt(d*Int(AbsInt(c[d-i])+1/2),i)+1)); if bi<>0) then b:=List([3..d],i->2*AbsInt(c[i-1]/c[i])); Add(b,AbsInt(c[1]/c[2])); b:=Maximum(b); if bAbsInt(c[i]-c[i+1]))+AbsInt(c[1]); if bRootInt(Int(AbsInt(c[d-i]/Binomial(d-1,i))+1/2),i)+1)) /(ApproximateRoot(2,d-1)-1)+10^(-10); if b) . . . . . . . . . . . . compute weighted Norm [pol]_2 ## InstallGlobalFunction(BombieriNorm,function(f) local c,i,n,s; c:=CoefficientsOfLaurentPolynomial(f); c:=ShiftedCoeffs(c[1],c[2]); n:=Length(c)-1; s:=0; for i in [0..n] do s:=s+AbsInt(c[i+1])^2/Binomial(n,i); od; return ApproximateRoot(s,2); end); ############################################################################# ## #F MinimizedBombieriNorm() . . . . . . . minimize weighted Norm [pol]_2 ## by shifting roots ## InstallMethod(MinimizedBombieriNorm,true, [IsPolynomial and IsRationalFunctionsFamilyElement],0, function(f) local bn,bnf,a,b,c,d,bb,bf,bd,step,x,cnt; step:=1; bb:=infinity; bf:=f; bd:=0; bn:=[]; # evaluation of norm, including storing it (avoids expensive double evals) bnf := function(dis) local p,g; p:=Filtered(bn,i->i[1]=dis); if p=[] then g:=Value(f,x+dis); p:=[dis,BombieriNorm(g)]; Add(bn,p); if bb>p[2] then # note record bf:=g; bb:=p[2]; bd:=dis; fi; return p[2]; else return p[1][2]; fi; end; x:=UnivariatePolynomialByCoefficients(CyclotomicsFamily,[0,1], IndeterminateNumberOfLaurentPolynomial(f)); d:=0; cnt:=0; repeat cnt:=cnt+1; Info(InfoPoly,2,"Minimizing BombieriNorm, x->x+(",d,")"); # local parabola approximation a:=bnf(d-step); b:=bnf(d); c:=bnf(d+step); if ab and c>b) and (a+c<>2*b) then a:=-(c-a)/2/(a+c-2*b)*step; # stets aufrunden (wir wollen weg) a:=step*Int(AbsInt(a)/step+1)*SignInt(a); if a=0 then Error("???"); else d:=d+a; fi; fi; until (a>b and c>b) # no better can be reached or cnt>6 or ForAll([d-1,d,d+1],i->Filtered(bn,j->j[1]=i)<>[]); #or loop # best value return [bf,bd]; end); ############################################################################# ## #F BeauzamyBound() . . . . . Beauzamy's Bound for Factors Coefficients ## cf. JSC 13 (1992), 463-472 ## BindGlobal("BeauzamyBound",function(f) local n; n:=DegreeOfLaurentPolynomial(f); return Int( # the strange number in the next line is an (upper) rational approximation # for 3^{3/4}/2/\sqrt(\pi) 643038/1000000*ApproximateRoot(3^n,2)/ApproximateRoot(n,2)*BombieriNorm(f))+1; end); ############################################################################# ## #F OneFactorBound() . . . . . . . . . . . . Bound for one factor of pol ## InstallGlobalFunction(OneFactorBound,function(f) local d,n; n:=DegreeOfLaurentPolynomial(f); if n>=3 then # Single factor bound of Beauzamy, Trevisan and Wang (1993) return Int(10912/10000*(ApproximateRoot(2^n,2)/ApproximateRoot(n^3,8) *(ApproximateRoot(BombieriNorm(f),2))))+1; else # Mignotte's single factor bound d:=QuoInt(n,2); return Binomial(d,QuoInt(d,2)) *(1+RootInt(Sum(CoefficientsOfLaurentPolynomial(f)[1], i->i^2),2)); fi; end); ############################################################################# ## #F PrimitivePolynomial() . . . remove denominator and coefficients gcd ## InstallMethod(PrimitivePolynomial,"univariate polynomial",true, [IsUnivariatePolynomial],0, function(f) local lcm, c, fc,fac; fc:=CoefficientsOfLaurentPolynomial(f)[1]; # compute lcm of denominator lcm := 1; for c in fc do lcm := LcmInt(lcm,DenominatorRat(c)); od; # remove all denominators f := f*lcm; fac:=1/lcm; fc:=CoefficientsOfLaurentPolynomial(f)[1]; # remove gcd of coefficients if Length(fc)>0 then fc:=Gcd(fc); else fc:=1; fi; fac:=fac*fc; return [f*(1/fc),fac]; end); BindGlobal("PrimitiveFacExtRepRatPol",function(e) local d,lcm,i,fac; d:=e{[2,4..Length(e)]}; if not ForAll(d,IsRat) then TryNextMethod(); fi; lcm:=1; for i in d do lcm := LcmInt(lcm,DenominatorRat(i)); od; fac:=1/lcm; d:=d*lcm; if Length(d)>0 then fac:=fac*Gcd(d); fi; return fac; end); InstallMethod(PrimitivePolynomial,"rational polynomial",true, [IsPolynomial],0, function(f) local e,fac; e:=ExtRepPolynomialRatFun(f); fac:=PrimitiveFacExtRepRatPol(e); return [f/fac,fac]; end); ############################################################################# ## #F BeauzamyBoundGcd(,) . . . . . Beauzamy's Bound for Gcd Coefficients ## ## cf. JSC 13 (1992),463-472 ## BindGlobal("BeauzamyBoundGcd",function(f,g) local n, A, B,lf,lg; lf:=LeadingCoefficient(f); if not IsOne(lf) then f:=f/lf; fi; lg:=LeadingCoefficient(f); if not IsOne(lg) then g:=g/lg; fi; n := DegreeOfLaurentPolynomial(f); # the strange number in the next line is an (upper) rational # approximation for 3^{3/4}/2/\sqrt(\pi) A := Int(643038/1000000 * ApproximateRoot(3^n,2)/ApproximateRoot(n,2) * BombieriNorm(f))+1; # the strange number in the next line is an (upper) rational # approximation for 3^{3/4}/2/\sqrt(\pi) n := DegreeOfLaurentPolynomial(g); B := Int(643038/1000000 * ApproximateRoot(3^n,2)/ApproximateRoot(n,2) * BombieriNorm(g))+1; B:=Minimum(A,B); if not (IsOne(lf) or IsOne(lg)) then B:=B*GcdInt(lf,lg); fi; return B; end); ############################################################################# ## #F RPGcdModPrime(,,,

,,) . . gcd mod

## BindGlobal("RPGcdModPrime",function(R,f,g,p,a,brci) local fam,gcd, u, v, w, val, r, s; fam:=CoefficientsFamily(FamilyObj(f)); f:=CoefficientsOfLaurentPolynomial(f); g:=CoefficientsOfLaurentPolynomial(g); # compute in the finite field F_

val := Minimum(f[2], g[2]); s := ShiftedCoeffs(f[1],f[2]-val); r := ShiftedCoeffs(g[1],g[2]-val); ReduceCoeffsMod(s,p); ShrinkRowVector(s); ReduceCoeffsMod(r,p); ShrinkRowVector(r); # compute the gcd u := r; v := s; while 0 < Length(v) do w := v; ReduceCoeffsMod(u,v,p); ShrinkRowVector(u); v := u; u := w; od; #gcd := u * (a/u[Length(u)]); gcd:=u; MultRowVector(gcd,a/u[Length(u)]); ReduceCoeffsMod(gcd,p); # and return the polynomial return LaurentPolynomialByCoefficients(fam,gcd,val,brci); end); BindGlobal("RPGcdCRT",function(f,p,g,q,ci) local min, cf, lf, cg, lg, i, P, m, r, fam; fam := CoefficientsFamily(FamilyObj(f)); f:=CoefficientsOfLaurentPolynomial(f); g:=CoefficientsOfLaurentPolynomial(g); # remove valuation min := Minimum(f[2],g[2]); if f[2] <> min then cf := ShiftedCoeffs(f[1],f[2] - min); else cf := ShallowCopy(f[1]); fi; lf := Length(cf); if g[2] <> min then cg := ShiftedCoeffs(g[1],g[2] - min); else cg := ShallowCopy(g[1]); fi; lg := Length(cg); # use chinese remainder r := [ p,q ]; P := p * q; m := P/2; for i in [ 1 .. Minimum(lf,lg) ] do cf[i] := ChineseRem(r,[ cf[i],cg[i] ]); if m < cf[i] then cf[i] := cf[i] - P; fi; od; if lf < lg then for i in [ lf+1 .. lg ] do cf[i] := ChineseRem(r,[ 0,cg[i] ]); if m < cf[i] then cf[i] := cf[i] - P; fi; od; elif lg < lf then for i in [ lg+1 .. lf ] do cf[i] := ChineseRem(r,[ cf[i],0 ]); if m < cf[i] then cf[i] := cf[i] - P; fi; od; fi; # return the polynomial return LaurentPolynomialByCoefficients(fam,cf,min,ci); end); BindGlobal("RPGcd1",function(R,t,a,f,g) local G, P, l, m, i; #

will hold the product of primes use so far t.modulo := t.prime; # will hold the approximation of the gcd G := t.gcd; # use next prime until we reach the Beauzamy bound while t.modulo < t.bound do repeat t.prime := NextPrimeInt(t.prime); until a mod t.prime <> 0; # compute modular gcd t.gcd := RPGcdModPrime(R,f,g,t.prime,a,t.brci); Info(InfoPoly,3,"gcd mod ",t.prime," = ",t.gcd); # if the degree of is smaller we started with wrong

if DegreeOfLaurentPolynomial(t.gcd) < DegreeOfLaurentPolynomial(G) then Info(InfoPoly,3,"found lower degree,restarting"); return false; fi; # if the degrees of and are equal use chinese remainder if DegreeOfLaurentPolynomial(t.gcd) = DegreeOfLaurentPolynomial(G) then P := G; G := RPGcdCRT(G,t.modulo,t.gcd,t.prime,t.brci); t.modulo := t.modulo * t.prime; Info(InfoPoly,3,"gcd mod ",t.modulo," = ",G); if G = P then t.correct := Quotient(R,f,G)<>fail and Quotient(R,g,G)<>fail; if t.correct then Info(InfoPoly,3,"found correct gcd"); t.gcd := G; return true; fi; fi; fi; od; # get into the -/2 to + range G:=CoefficientsOfLaurentPolynomial(G); l := []; m := t.modulo/2; for i in [ 1 .. Length(G[1]) ] do if m < G[1][i] then l[i] := G[1][i] - t.modulo; else l[i] := G[1][i]; fi; od; G := LaurentPolynomialByExtRepNC(CoefficientsFamily(FamilyObj(f)), l,G[2],t.brci); Info(InfoPoly,3,"gcd mod ",t.modulo," = ",G); # check if is correct but return 'true' in any case t.correct := Quotient(R,f,G) <> fail and Quotient(R,g,G) <> fail; t.gcd := G; return true; end); BindGlobal("RPIGcd", function(R,f,g) local a,t; # special case zero: if IsZero(f) then return g; elif IsZero(g) then return f; fi; # compute the Beauzamy bound for the gcd t := rec(prime := 1000); t.brci:=CIUnivPols(f,g); t.bound := 2 * Int(BeauzamyBoundGcd(f,g)+1); Info(InfoPoly,3,"Beauzamy bound = ",t.bound/2); # avoid gcd of leading coefficients a := GcdInt(LeadingCoefficient(f),LeadingCoefficient(g)); repeat # start with first prime avoiding gcd of leading coefficients repeat t.prime := NextPrimeInt(t.prime); until a mod t.prime <> 0; # compute modular gcd with leading coefficient t.gcd := RPGcdModPrime(R,f,g,t.prime,a,t.brci); Info(InfoPoly,3,"gcd mod ",t.prime," = ",t.gcd); # loop until we have success repeat if 0 = DegreeOfLaurentPolynomial(t.gcd) then Info(InfoPoly,3," and are relative prime"); return One(f); fi; until RPGcd1(R,t,a,f,g); until t.correct; # return the gcd return t.gcd; end); ############################################################################# ## #F GcdOp( , , ) . . . . . . . for rational univariate polynomials ## InstallMethod( GcdOp, "rational univariate polynomials", IsCollsElmsElms, [IsRationalsPolynomialRing and IsEuclideanRing, IsUnivariatePolynomial,IsUnivariatePolynomial],0, function(R,f,g) local brci,gcd,fam,fc,gc; brci:=CIUnivPols(f,g); if brci=fail then TryNextMethod();fi; # check trivial cases if -1 = DegreeOfLaurentPolynomial(f) then return g; elif -1 = DegreeOfLaurentPolynomial(g) then return f; elif 0 = DegreeOfLaurentPolynomial(f) or 0 = DegreeOfLaurentPolynomial(g) then return One(f); fi; fam:=FamilyObj(f); # convert polynomials into integer polynomials f := PrimitivePolynomial(f)[1]; g := PrimitivePolynomial(g)[1]; Info(InfoPoly,3," = ",f); Info(InfoPoly,3," = ",g); fc:=CoefficientsOfLaurentPolynomial(f); gc:=CoefficientsOfLaurentPolynomial(g); # try heuristic method: gcd:=HeuGcdIntPolsCoeffs(fc[1],gc[1]); if gcd=fail then # fall back to the original version: return StandardAssociate(R,RPIGcd(R,f,g)); fi; fc:=Minimum(fc[2],gc[2]); fc:=fc+RemoveOuterCoeffs(gcd,fam!.zeroCoefficient); return StandardAssociate(R,LaurentPolynomialByExtRepNC(fam,gcd,fc,brci)); end); InstallMethod(\mod,"reduction of univariate rational polynomial at a prime", true,[IsUnivariatePolynomial,IsInt],0, function(f,p) local c; c:=CoefficientsOfLaurentPolynomial(f); if Length(c[1])>0 and ForAny(c[1],i->not (IsRat(i) or IsAlgebraicElement(i))) then TryNextMethod(); fi; return LaurentPolynomialByCoefficients( CoefficientsFamily(FamilyObj(f)),List(c[1],i->i mod p),c[2], IndeterminateNumberOfLaurentPolynomial(f)); end); InstallMethod(\mod,"reduction of general rational polynomial at a prime", true,[IsPolynomial,IsInt],0, function(f,p) local c,d,i,m; c:=ExtRepPolynomialRatFun(f); d:=[]; for i in [2,4..Length(c)] do if not (IsRat(c[i]) or IsAlgebraicElement(c[i])) then TryNextMethod(); fi; m:=c[i] mod p; if m<>0 then Add(d,c[i-1]); Add(d,m); fi; od; return PolynomialByExtRepNC(FamilyObj(f),d); end); ############################################################################# ## #F RPQuotientModPrime(,,,

) . . . quotient ## BindGlobal("RPQuotientModPrime",function(R,f,g,p) local m, n, i, k, c, q, val, fc,gc,brci,fam; # get base ring brci:=CIUnivPols(f,g); fam:=FamilyObj(f); # reduce and mod

f := f mod p; g := g mod p; fc:=CoefficientsOfLaurentPolynomial(f); gc:=CoefficientsOfLaurentPolynomial(g); # if is zero return it if 0 = Length(fc[1]) then return f; fi; # check the value of the valuation of and if fc[2] < gc[2] then return false; fi; val := fc[2]-gc[2]; # Try to divide by ,compute mod

q := []; n := Length(gc[1]); m := Length(fc[1]) - n; gc:=gc[1]; f := ShallowCopy(fc[1]); for i in [0..m] do c := f[m-i+n]/gc[n] mod p; for k in [1..n] do f[m-i+k] := (f[m-i+k] - c*gc[k]) mod p; od; q[m-i+1] := c; od; # Did the division work? for i in [ 1 .. m+n ] do if f[i] <> fam!.zeroCoefficient then return false; fi; od; val:=val+RemoveOuterCoeffs(q,fam!.zeroCoefficient); return LaurentPolynomialByExtRepNC(fam,q,val,brci); end); ############################################################################# ## #F RPGcdRepresentationModPrime(,,,

) . gcd ## BindGlobal("RPGcdRepresentationModPrime",function(R,f,g,p) local val, # the minimal valuation of and s, sx, # first line of gcd algorithm t, tx, # second line of gcd alogrithm h, hx, # temp for swapping lines q, # quotient n,m,r,c, # used in quotient brci, i,k; # loops Info(InfoPoly,3,"f=",f,"g=",g); # get base ring brci:=CIUnivPols(f,g); brci:=[CoefficientsFamily(FamilyObj(f)),brci]; # remove common x^i term f:=CoefficientsOfLaurentPolynomial(f); g:=CoefficientsOfLaurentPolynomial(g); val:=Minimum(f[2],g[2]); f :=ShiftedCoeffs(f[1],f[2]-val); g :=ShiftedCoeffs(g[1],g[2]-val); ReduceCoeffsMod(f,p); ShrinkRowVector(f); ReduceCoeffsMod(g,p); ShrinkRowVector(g); # compute the gcd and representation mod

s := ShallowCopy(f); sx := [ One(brci[1]) ]; t := ShallowCopy(g); tx := []; while 0 < Length(t) do Info(InfoPoly,3," = ",s,", = ",sx,"\n", "#I = ",t,", = ",tx); # compute the euclidean quotient of by q := []; n := Length(t); m := Length(s) - n; r := ShallowCopy(s); for i in [ 0 .. m ] do c := r[m-i+n] / t[n] mod p; for k in [ 1 .. n ] do r[m-i+k] := (r[m-i+k] - c * t[k]) mod p; od; q[m-i+1] := c; od; Info(InfoPoly,3," = ",q); # update representation h := t; hx := tx; t := s; AddCoeffs(t,ProductCoeffs(q,h),-1); ReduceCoeffsMod(t,p); ShrinkRowVector(t); tx := sx; AddCoeffs(tx,ProductCoeffs(q,hx),-1); ReduceCoeffsMod(tx,p); ShrinkRowVector(tx); s := h; sx := hx; od; Info(InfoPoly,3," = ",s,", = ",sx); # compute conversion for standard associate q := (1/s[Length(s)]) mod p; # convert and back into polynomials if 0 = Length(g) then #sx := q * sx; MultRowVector(sx,q); ReduceCoeffsMod(sx,p); return [ LaurentPolynomialByCoefficients(brci[1],sx,0,brci[2]), Zero(brci[1]) ]; else #hx := q * sx; hx:=ShallowCopy(sx); MultRowVector(hx,q); ReduceCoeffsMod(hx,p); hx := LaurentPolynomialByCoefficients(brci[1],hx,0,brci[2]); AddCoeffs(s,ProductCoeffs(sx,f),-1); #s := q * s; MultRowVector(s,q); ReduceCoeffsMod(s,p); s := LaurentPolynomialByCoefficients(brci[1],s,0,brci[2]); g := LaurentPolynomialByCoefficients(brci[1],g,0,brci[2]); q := RPQuotientModPrime(R,s,g,p); return [ hx,q ]; fi; end); ############################################################################# ## #F HenselBound(,[,]) . . . Bounds for Factor coefficients ## if the computation takes place over an algebraic extension, then ## minpol and denominator must be given ## InstallGlobalFunction(HenselBound,function(arg) local pol,n,nalpha,d,dis,rb,bound,a,i,j,k,l,w,bin,lm,lb,bea,polc,ro,rbpow; pol:=arg[1]; if Length(arg)>1 then n:=arg[2]; d:=arg[3]; dis:=Discriminant(n); nalpha:=RootBound(n); # bound for norm of \alpha. polc:=CoefficientsOfLaurentPolynomial(pol)[1]; if not ForAll(polc,IsRat) then # now try to bound the roots of f accordingly. As in all estimates by # RootBound only the absolute value of the coefficients is used, we will # estimate these first, and replace f by the polynomial # x^n-b_{n-1}x^(n-1)-...-b_0 whose roots are certainly larger a:=[]; for i in polc do # bound for coefficients of pol if IsRat(i) then Add(a,AbsInt(i)); else Add(a,Sum(ExtRepOfObj(i),AbsInt)*nalpha); fi; od; a:=-a; a[Length(a)]:=-a[Length(a)]; pol:=UnivariatePolynomialByCoefficients(CyclotomicsFamily,a,1); else pol:=UnivariatePolynomialByCoefficients(CyclotomicsFamily,polc,1); fi; n:=DegreeOfLaurentPolynomial(n); else n:=1; fi; bound:=[]; rb:=0; #BeauzamyBound bea:=BeauzamyBound(pol); # compute Landau-Mignotte bound for absolute values of # coefficients of any factor polc:=CoefficientsOfLaurentPolynomial(pol)[1]; w:=Sum(polc,i->i^2); # we want an upper bound of the root, RootInt will give a lower # bound. So we compute the root of w-1 (in case w is a perfect square) # and add 1. As we nowhere selected a specific galois representative, # this bound (which is rational!) will bound all conjugactes as well. lm:=(RootInt(Int(w)-1,2)+1); lb:=2^QuoInt(DegreeOfLaurentPolynomial(pol),2)*lm; for k in [1..DegreeOfLaurentPolynomial(pol)] do l:=2^k*lm; if l10^30 or n>1 then if bea>10^200 or n>1 then if rb=0 then rb:=RootBound(pol); if rb>1000 and not IsInt(rb) then rb:=Int(rb+1); fi; rbpow:=[rb]; a:=rb; fi; # now try factor deg k bin:=1; for j in [1..k] do bin:=bin*(k-j+1)/j; if not IsBound(rbpow[j]) then rbpow[j]:=rbpow[j-1]*rb; if rbpow[j]>10 and not IsInt(rbpow[j]) then rbpow[j]:=Int(rbpow[j]+1); fi; fi; w:=bin*rbpow[j]; if w>a then a:=w; fi; od; # select the better bound if a1 then # algebraic Extension case # finally we have to bound (again) the coefficients of \alpha when # writing the coefficients of the factor as \sum c_i/d\alpha^i. ro:=AbsInt(dis); ro:=RootInt(NumeratorRat(ro))/(1+RootInt(DenominatorRat(ro)-1)); w:=Int(d*w*Factorial(n)/ro*nalpha^(n*(n-1)/2))+1; fi; bound[k]:=Int(w)+1; od; return bound; end); ############################################################################# ## #F TrialQuotientRPF(,,) . . . . . . f/g if coeffbounds are given by b ## InstallGlobalFunction(TrialQuotientRPF,function(f,g,b) local fc,gc,a,m, n, i, k, c, q, val, brci,fam; brci:=CIUnivPols(f,g); a:=DegreeOfLaurentPolynomial(f)-DegreeOfLaurentPolynomial(g); fam:=FamilyObj(f); fc:=CoefficientsOfLaurentPolynomial(f); gc:=CoefficientsOfLaurentPolynomial(g); if a=0 then # Special case (that has to return 0) a:=b[1]; else a:=b[a]; fi; if 0=Length(fc[1]) then return f; fi; if fc[2]a then Info(InfoPoly,3,"early break"); return fail; fi; for k in [1..n] do f[m-i+k]:=f[m-i+k]-c*gc[k]; od; q[m-i+1]:=c; od; # else # for i in [0..m] do # c:=Quotient(R,f[m-i+n],gc[n]); # if c=fail then # return fail; # fi; # if MaxNumeratorCoeffAlgElm(c)>a then # Info(InfoPoly,3,"early break\n"); # return fail; # fi; # for k in [1..n] do # f[m-i+k]:=f[m-i+k]-c*g.coefficients[k]; # if MaxNumeratorCoeffAlgElm(f[m-i+k])>b then # Info(InfoPoly,3,"early break\n"); # return fail; # fi; # od; # q[m-i+1]:=c; # od; # fi; k:=Zero(f[1]); for i in [1..m+n] do if f[i]<>k then return fail; fi; od; val:=val+RemoveOuterCoeffs(q,fam!.zeroCoefficient); return LaurentPolynomialByExtRepNC(fam,q,val,brci); end); ############################################################################# ## #F TryCombinations(,...) . . . . . . . . . . . . . . . . try factors ## InstallGlobalFunction(TryCombinations,function(f,lc,l,p,t,bounds,opt,split,useonefacbound) local p2, res, j, i,ii,o,d,b,lco,degs, step, cnew, sel, deli, degf, good, act, da, prd, cof, q, combi,mind,binoli,alldegs; alldegs:=t.degrees; # contains the irr/reducible factors and the remaining ones res:=rec(irreducibles:=[], irrFactors :=[], reducibles :=[], redFactors :=[], remaining :=[ 1 .. Length(l) ]); # coefficients should be in -

/2 and

/2 p2 :=p/2; deli:=List(l,DegreeOfLaurentPolynomial); # sel are the still selected indices sel:=[ 1 .. Length(l) ]; # create List of binomial coefficients to speed up the 'Combinations' process binoli:=[]; for i in [0..Length(l)-1] do binoli[i+1]:=List([0..i],j->Binomial(i,j)); od; step:=0; act :=1; repeat # factors of larger than half remaining degree we will find as # final cofactor. This cannot be used if we factor only using the one # factor bound! if not useonefacbound then degf:=DegreeOfLaurentPolynomial(f); degs:=Filtered(alldegs,i -> 2*i<=degf); else degs:=alldegs; fi; if IsBound(opt.onlydegs) then degs:=Intersection(degs,opt.onlydegs); Info(InfoPoly,3,"degs=",degs); fi; if act in sel then # search all combinations of Length step+1 containing the act-th # factor,that are allowed good:=true; da:=List(degs,i -> i-deli[act]); # check,whether any combination will be of suitable degree cnew:=Set(deli{Filtered(sel,i->i>act)}); if ForAny(da,i->NrRestrictedPartitions(i,cnew,step)>0) then # as we have all combinations including < ,we can skip them Info(InfoPoly,2,"trying length ",step+1," containing ",act); cnew:=Filtered(sel,i -> i > act); else Info(InfoPoly,2,"length ",step+1," containing ",act," not feasible"); cnew:=[]; fi; mind:=Sum(deli); # the maximum of the possible degrees. We surely # will find something smaller lco:=Binomial(Length(cnew),step); if 0 = lco then # fix mind to make sure,we don't erroneously eliminate the factor mind:=0; else Info(InfoPoly,2,lco," combinations"); i:=1; while good and i<=lco do # try combination number i # combi:=CombinationNr(cnew,step,i); q:=i; d:=Length(cnew); # the remaining Length o:=0; combi:=[]; for ii in [step-1,step-2..0] do j:=1; b:=binoli[d][ii+1]; while q>b do q:=q-b; # compute b:=Binomial(d-(j+1),ii); b:=b*(d-j-ii)/(d-j); j:=j+1; od; o:=j+o; d:=d-j; Add(combi,cnew[o]); od; # check whether this yields a minimal degree d:=Sum(deli{combi}); if dCoefficientsOfLaurentPolynomial(i)[1][1]), p) * lc) mod p; if p2 < q then q:=q - p; fi; # As we don't know yet the gcd of all the products # coefficients (to make it primitive),we do a slightly # weaker test: (test of leading coeffs is first in # 'TrialQuotientRPF') this just should reduce the number of # 'ProductMod' neccessary. the absolute part of the # product must divide the absolute part of f up to a # divisor of q:=CoefficientsOfLaurentPolynomial(f)[1][1] / q * lc; if not IsInt(q) then Info(InfoPoly,3,"ignoring combination ",combi); q:=fail; else Info(InfoPoly,2,"testing combination ",combi); # compute the product and reduce prd:=ProductMod(l{combi},p); prd:=CoefficientsOfUnivariatePolynomial(prd); cof:=[]; for j in [ 1 .. Length(prd) ] do cof[j]:=(lc*prd[j]) mod p; if p2 < cof[j] then cof[j]:=cof[j] - p; fi; od; # make the product primitive cof:=cof * (1/Gcd(cof)); prd:=UnivariatePolynomialByCoefficients(CyclotomicsFamily, cof,t.ind); q:=TrialQuotientRPF(f,prd,bounds); fi; if q <> fail then f:=q; Info(InfoPoly,2,"found true factor of degree ", DegreeOfLaurentPolynomial(prd)); if Length(combi)=1 or split then q:=0; else q:=2*lc*OneFactorBound(prd); if q <= p then Info(InfoPoly,2,"proven irreducible by 'OneFactorBound'"); fi; fi; # for some reason,we know,the factor is irred. if q <= p then Append(res.irreducibles,combi); Add(res.irrFactors,prd); if IsBound(opt.stopdegs) and DegreeOfLaurentPolynomial(prd) in opt.stopdegs then Info(InfoPoly,2,"hit stopdegree"); Add(res.redFactors,f); res.stop:=true; return res; fi; else Add(res.reducibles,combi); Add(res.redFactors,prd); fi; SubtractSet(res.remaining,combi); good:=false; SubtractSet(sel,combi); fi; fi; i:=i+1; od; fi; # we can forget about the actual factor,as any longer combination # is too big if Length(degs)>1 and deli[act]+mind >= Maximum(degs) then Info(InfoPoly,2,"factor ",act," can be further neglected"); sel:=Difference(sel,[act]); fi; fi; # consider next factor act:=act + 1; if 0 < Length(sel) and act>Maximum(sel) then step:=step+1; act :=sel[1]; fi; # until nothing is left until 0 = Length(sel) or Length(sel) is true we *must* find a complete factorization. if split and 0 < Length(res.remaining) and f<>f^0 then #and not(IsBound(opt.onlydegs) or IsBound(opt.stopdegs)) then # the remaining f must be an irreducible factor,larger than deg/2 Append(res.irreducibles,res.remaining); res.remaining:=[]; Add(res.irrFactors,f); fi; # return the result return res; end); ############################################################################# ## #F RPSquareHensel(,,,) ## BindGlobal("RPSquareHensel",function(R,f,t,opt) local p, # prime q, # current modulus q1, # last modulus l, # factorization mod lc, # leading coefficient of bounds, # Bounds for Factor Coefficients ofb, # OneFactorBound k, # Lift boundary prd, # product of rep, # lifted representation of gcd() fcn, # index of true factor in dis, # distance of and cor, # correction max, # maximum absolute coefficient of res, # result gcd, # used in gcd representation i, j; # loop # get and

l:=t.factors; p:=t.prime; # get the leading coefficient of lc:=LeadingCoefficient(f); # and maximal coefficient max:=Maximum(List(CoefficientsOfUnivariatePolynomial(f),AbsInt)); # compute the factor coefficient bounds ofb:=2*AbsInt(lc)*OneFactorBound(f); Info(InfoPoly,2,"One factor bound = ",ofb); bounds:=2*AbsInt(lc)*HenselBound(f); k:=bounds[Maximum(Filtered(t.degrees, i-> 2*i<=DegreeOfLaurentPolynomial(f)))]; Info(InfoPoly,2,"Hensel bound = ",k); # compute a representation of the 1 mod

Info(InfoPoly,2,"computing gcd representation: ",Runtime()); prd:=(1/lc * f) mod p; gcd:=RPQuotientModPrime(R,prd,l[1],p); rep:=[ One(R) ]; for i in [ 2 .. Length(l) ] do dis:=RPQuotientModPrime(R,prd,l[i],p); cor:=RPGcdRepresentationModPrime(R,gcd,dis,p); gcd:=(cor[1] * gcd + cor[2] * dis) mod p; rep:=List(rep,z -> z * cor[1] mod p); Add(rep,cor[2]); od; Info(InfoPoly,2,"representation computed: ",Runtime()); # will hold our result res:=rec(irrFactors:=[], redFactors:=[], remaining:=[], bounds:=bounds); # start Hensel until is greater than k q :=p^2; q1 :=p; while q1 < k do Info(InfoPoly,2,"computing mod ",q); for i in [ 1 .. Length(l) ] do dis:=List(CoefficientsOfUnivariatePolynomial(f),i->i/lc mod q); ReduceCoeffsMod(dis,CoefficientsOfUnivariatePolynomial(l[i]),q); #dis:=EuclideanRemainder(PolynomialRing(Rationals),dis,l[i]) mod q; #dis:=CoefficientsOfUnivariatePolynomial(dis); dis:=UnivariatePolynomialByCoefficients(CyclotomicsFamily,dis,t.ind); l[i]:=l[i] + BPolyProd(rep[i],dis,l[i],q); od; # NOCH: Assert und leading coeff #if not ForAll(CoefficientsOfLaurentPolynomial(Product(l)-f)[1], # i->i mod q=0) then # Error("not product modulo q"); #fi; # if this is not the last step update and check for factors if q < k then # correct the inverses for i in [ 1 .. Length(l) ] do if Length(l)=1 then dis:=l[1]^0; else dis:=UnivariatePolynomialByCoefficients(CyclotomicsFamily, [1],t.ind); for j in Difference([1..Length(l)],[i]) do dis:=BPolyProd(dis,l[j],l[i],q); od; fi; rep[i]:=BPolyProd(rep[i], (2-APolyProd(rep[i],dis,q)), l[i], q); od; # try to find true factors if max <= q then Info(InfoPoly,2,"searching for factors: ",Runtime()); fcn:=TryCombinations(f,lc,l,q,t,bounds,opt,false,false); elif ofb < q then Info(InfoPoly,2,"searching for factors: ",Runtime()); fcn:=TryCombinations(f,lc,l,q,t,bounds,opt,false,true); #Info(InfoPoly,2,"finishing search: ",Runtime()); else fcn:=rec(irreducibles:=[], reducibles:=[]); fi; # if we have found a true factor update everything if 0 < Length(fcn.irreducibles)+Length(fcn.reducibles) then # append irreducible factors to .irrFactors Append(res.irrFactors,fcn.irrFactors); # append reducible factors to .redFactors Append(res.redFactors,fcn.redFactors); # compute new prd:=Product(fcn.redFactors) * Product(fcn.irrFactors); f :=Quotient(R,f,prd); if IsBound(fcn.stop) then res.stop:=true; return res; fi; lc :=LeadingCoefficient(f); ofb:=2*AbsInt(lc)*OneFactorBound(f); Info(InfoPoly,2,"new one factor bound = ",ofb); # degree arguments or OFB arguments prove f irreducible if (ForAll(t.degrees,i->i=0 or 2*i>=DegreeOfLaurentPolynomial(f)) or ofb0 then Add(fcn.irrFactors,f); Add(res.irrFactors,f); f:=f^0; fi; # if is trivial return if DegreeOfLaurentPolynomial(f) < 1 then Info(InfoPoly,2,"found non-trivial factorization"); return res; fi; # compute the factor coefficient bounds k:=HenselBound(f); bounds:=List([ 1 .. Length(k) ], i -> Minimum(bounds[i],k[i])); k:=2 * AbsInt(lc) * bounds[Maximum(Filtered(t.degrees, i-> 2*i<=DegreeOfLaurentPolynomial(f)))]; Info(InfoPoly,2,"new Hensel bound = ",k); # remove true factors from and corresponding prd:=(1/LeadingCoefficient(prd)) * prd mod q; l :=l{fcn.remaining}; rep:=List(rep{fcn.remaining},x -> prd * x); # reduce [i] mod [i] for i in [ 1 .. Length(l) ] do #rep[i]:=rep[i] mod l[i] mod q; rep[i]:=CoefficientsOfLaurentPolynomial(rep[i]); rep[i]:=ShiftedCoeffs(rep[i][1],rep[i][2]); j:=CoefficientsOfLaurentPolynomial(l[i]); j:=ReduceCoeffsMod(rep[i],ShiftedCoeffs(j[1],j[2]),q); # shrink the list rep[i], according to the 'j' value rep[i]:=rep[i]{[1..j]}; rep[i]:=LaurentPolynomialByCoefficients( CyclotomicsFamily,rep[i],0,t.ind); od; # if there was a factor,we ought to have found it elif ofb < q then Add(res.irrFactors,f); Info(InfoPoly,2,"f irreducible,since one factor would ", "have been found now"); return res; fi; fi; # square modulus q1:=q; q :=q^2; # avoid a modulus too big if q > k then q:=p^(LogInt(k,p)+1); fi; od; # return the remaining polynomials res.remPolynomial:=f; res.remaining :=l; res.primePower :=q1; res.lc :=lc; return res; end); ############################################################################# ## #F RPFactorsModPrime(,) find suitable prime and factor ## ## must be squarefree. We test 3 "small" and 2 "big" primes. ## BindGlobal("RPFactorsModPrime",function(R,f) local i, # loops fc, # f's coeffs lc, # leading coefficient of p, # current prime PR, # polynomial ring over F_

fp, # in lp, # factors of min, # minimal number of factors so far P, # best prime so far LP, # factorization of mod

deg, # possible degrees of factors t, # return record cof, # new coefficients tmp; fc:=CoefficientsOfLaurentPolynomial(f)[1]; # set minimal number of factors to the degree of min:=DegreeOfLaurentPolynomial(f)+1; lc :=LeadingCoefficient(f); # find a suitable prime t:=rec(ind:=IndeterminateNumberOfLaurentPolynomial(f)); p:=1; for i in [ 1 .. 5 ] do # reset

to big prime after first 3 test if i = 4 then p:=Maximum(p,1000); fi; # find a prime not dividing and _

squarefree repeat repeat p :=NextPrimeInt(p); until lc mod p <> 0 and fc[1] mod p <> 0; PR:=PolynomialRing(GF(p)); tmp:=1/lc mod p; fp :=UnivariatePolynomialByCoefficients(FamilyObj(Z(p)), List(fc,x->((tmp*x) mod p)* Z(p)^0),1); until 0 = DegreeOfLaurentPolynomial(Gcd(PR,fp,Derivative(fp))); # factorize modulo

Info(InfoPoly,2,"starting factorization mod p: ",Runtime()); lp:=Factors(PR,fp); Info(InfoPoly,2,"finishing factorization mod p: ",Runtime()); # if is irreducible so is if 1 = Length(lp) then Info(InfoPoly,2," mod ",p," is irreducible"); t.isIrreducible:=true; return t; else Info(InfoPoly,2,"found ",Length(lp)," factors mod ",p); Info(InfoPoly,2,"of degree ",List(lp,DegreeOfLaurentPolynomial)); fi; # choose a maximal prime with minimal number of factors if Length(lp) <= min then min:=Length(lp); P :=p; LP :=lp; fi; # compute the possible degrees tmp:=Set(List(Combinations(List(lp,DegreeOfLaurentPolynomial)), g -> Sum(g))); if 1 = i then deg:=tmp; else deg:=Intersection(deg,tmp); fi; # if there is only one possible degree != 0 then is irreducible if 2 = Length(deg) then Info(InfoPoly,2," must be irreducible,only one degree left"); t.isIrreducible:=true; return t; fi; od; # convert factors back to the integers lp:=ShallowCopy(LP); for i in [ 1 .. Length(LP) ] do cof:=CoefficientsOfUnivariatePolynomial(LP[i]); #cof:=IntVecFFE(cof); cof:=List(cof,IntFFE); LP[i]:=UnivariatePolynomialByCoefficients(CyclotomicsFamily,cof,t.ind); od; # return the chosen prime Info(InfoPoly,2,"choosing prime ",P," with ",Length(LP)," factors"); Info(InfoPoly,2,"possible degrees: ",deg); t.isIrreducible:=false; t.prime :=P; t.factors :=LP; t.degrees :=deg; return t; end); ############################################################################# ## #M FactorsSquarefree(,,) . factors of ## ## must be square free and must have a constant term. ## InstallMethod( FactorsSquarefree, "univariate rational poly", true, [IsRationalsPolynomialRing,IsUnivariatePolynomial,IsRecord],0, function(R,f,opt) local t, h, fac, g, tmp; # find a suitable prime,if is irreducible return t:=RPFactorsModPrime(R,f); if t.isIrreducible then return [f]; fi; Info(InfoPoly,2,"using prime ",t.prime," for factorization"); # for easy combining,we want large degree factors first Sort(t.factors, function(a,b) return DegreeOfLaurentPolynomial(a) > DegreeOfLaurentPolynomial(b); end); # start Hensel h:=RPSquareHensel(R,f,t,opt); # combine remaining factors fac:=[]; # first the factors found by hensel if 0 < Length(h.remaining) then Info(InfoPoly,2,"found ",Length(h.remaining)," remaining terms"); tmp:=TryCombinations( h.remPolynomial, h.lc, h.remaining, h.primePower, t, h.bounds, opt, true,false); Append(fac,tmp.irrFactors); Append(fac,tmp.redFactors); else tmp:=rec(); fi; # append the irreducible ones if 0 < Length(h.irrFactors) then Info(InfoPoly,2,"found ",Length(h.irrFactors)," irreducibles"); Append(fac,h.irrFactors); fi; # and try to factorize the (possible) reducible ones if 0 < Length(h.redFactors) then Info(InfoPoly,2,"found ",Length(h.redFactors)," reducibles"); if not (IsBound(tmp.stop) or IsBound(h.stop)) then # the stopping criterion has not yet been reached for g in h.redFactors do Append(fac,FactorsSquarefree(R,g,opt)); od; else Append(fac,h.redFactors); fi; fi; # and return return fac; end); BindGlobal("RPIFactors",function(R,f,opt) local fc,ind, v, g, q, s, r, x,shift; fc:=CoefficientsOfLaurentPolynomial(f); ind:=IndeterminateNumberOfLaurentPolynomial(f); # if is trivial return Info(InfoPoly,2,"starting integer factorization: ",Runtime()); if 0 = Length(fc[1]) then Info(InfoPoly,2," is trivial"); return [ f ]; fi; # remove a valuation v:=fc[2]; f:=UnivariatePolynomialByCoefficients(CyclotomicsFamily,fc[1],ind); x:=LaurentPolynomialByCoefficients(CyclotomicsFamily,[1],1,ind); # if is almost constant return if Length(fc[1])=1 then s:=List([1..fc[2]],i->x); s[1]:=s[1]*LeadingCoefficient(f); return s; fi; # if is almost linear return if 1 = DegreeOfLaurentPolynomial(f) then Info(InfoPoly,2," is almost linear"); s:=List([1..v],f -> x); Add(s,f); return s; fi; # shift the zeros of f if appropriate if DegreeOfLaurentPolynomial(f) > 20 then g:=MinimizedBombieriNorm(f); f:=g[1]; shift:=-g[2]; else shift:=0; fi; # make integral,primitive and square free g:=Gcd(R,f,Derivative(f)); q:=PrimitivePolynomial(Quotient(R,f,g))[1]; q:=q * SignInt(LeadingCoefficient(q)); Info(InfoPoly,3,"factorizing polynomial of degree ", DegreeOfLaurentPolynomial(q)); # and factorize if DegreeOfLaurentPolynomial(q) < 2 then Info(InfoPoly,2," is a linear power"); s:=[ q ]; else # treat zeroes (only one possible) s:=CoefficientsOfLaurentPolynomial(q)[2]; if s>0 then s:=[x]; q:=q/x; else s:=[]; fi; s:=Concatenation(s,FactorsSquarefree(R,q,opt)); fi; # find factors of for r in s do if 0 < DegreeOfLaurentPolynomial(g) and DegreeOfLaurentPolynomial(g) >= DegreeOfLaurentPolynomial(r) then q:=Quotient(R,g,r); while 0 < DegreeOfLaurentPolynomial(g) and q <> fail do Add(s,r); g:=q; if DegreeOfLaurentPolynomial(g)>=DegreeOfLaurentPolynomial(r) then q:=Quotient(R,g,r); else q:=fail; fi; od; fi; od; # reshift if shift<>0 then Info(InfoPoly,2,"shifting zeros back"); Apply(s,i->Value(i,x+shift)); fi; # sort the factors Append(s,List([1..v],f->x)); Sort(s); if not IsBound(opt.stopdegs) and Sum(s,DegreeOfLaurentPolynomial)<>DegreeOfLaurentPolynomial(f)+v then Error("degree discrepancy!"); fi; # return the (primitive) factors return s; end); ############################################################################# ## #M Factors(, ) . . factors of rational polynomial ## InstallMethod(Factors,"univariate rational polynomial",IsCollsElms, [IsRationalsPolynomialRing,IsUnivariatePolynomial],0, function(R,f) local r,cr,opt,irf,i; opt:=ValueOption("factoroptions"); PushOptions(rec(factoroptions:=rec())); # options do not hold for # subsequent factorizations if opt=fail then opt:=rec(); fi; cr:=CoefficientsRing(R); irf:=IrrFacsPol(f); i:=PositionProperty(irf,i->i[1]=cr); if i<>fail then # if we know the factors,return PopOptions(); return ShallowCopy(irf[i][2]); fi; # handle trivial case if DegreeOfLaurentPolynomial(f) < 2 then StoreFactorsPol(cr,f,[f]); PopOptions(); return [f]; fi; # compute the integer factors r:=RPIFactors(R,PrimitivePolynomial(f)[1],opt); # convert into standard associates and sort r:=List(r,x -> StandardAssociate(R,x)); Sort(r); if Length(r)>0 then # correct leading term r[1]:=r[1]*Quotient(R,f,Product(r)); fi; # and return if not IsBound(opt.onlydegs) and not IsBound(opt.stopdegs) then StoreFactorsPol(cr,f,r); for i in r do StoreFactorsPol(cr,i,[i]); od; fi; PopOptions(); return r; end); ############################################################################# ## #F SymAdic( , ) . . . . . . . . . . symmetric -adic expansion of #F ( and integers) ## SymAdic:=function(x,b) local l, b2, r; b2:=QuoInt(b,2); l:=[]; while x<>0 do r:=x mod b; if r>b2 then r:=r-b; fi; Add(l,r); x:=(x-r)/b; od; return l; end; ############################################################################# ## #F HeuGcdIntPolsExtRep(,,) ## ## takes two polynomials ext reps, primitivizes them with integer ## coefficients and tries to ## compute a Gcd expanding Gcds of specializations. ## Source: Geddes,Czapor,Labahn: Algorithm 7.4 #V MAXTRYGCDHEU: defines maximal number of attempts to find Gcd heuristically MAXTRYGCDHEU:=6; InstallGlobalFunction(HeuGcdIntPolsExtRep,function(fam,d,e) local x,xd,er,i,j,k,m,p,sel,xi,gamma,G,g,loop,zero,add; # find the indeterminates and their degrees: x:=[]; xd:=[[],[]]; er:=[d,e]; for k in [1,2] do for i in [1,3..Length(er[k])-1] do m:=er[k][i]; for j in [1,3..Length(m)-1] do p:=Position(x,m[j]); if p=fail then Add(x,m[j]); p:=Length(x); xd[1][p]:=0; xd[2][p]:=0; fi; xd[k][p]:=Maximum(xd[k][p],m[j+1]); od; od; od; # discard the indeterminates which occur in only one of the polynomials sel:=[]; for i in [1..Length(x)] do if xd[1][i]>0 and xd[2][i]>0 then Add(sel,i); fi; od; x:=x{sel}; xd:=List(xd,i->i{sel}); # are the variables disjoint or do we have no variables at all? if Length(x)=0 then # return the gcd of all coefficients involved G:=Gcd(Concatenation(d{[2,4..Length(d)]},e{[2,4..Length(e)]})); return G; fi; # pick the first indeterminate x:=x[1]; xd:=[xd[1][1],xd[2][1]]; xi:=2*Minimum(Maximum(List(d{[2,4..Length(d)]},AbsInt)), Maximum(List(e{[2,4..Length(e)]},AbsInt)))+2; for loop in [1..MAXTRYGCDHEU] do if LogInt(AbsInt(Int(xi)),10)*Maximum(xd)>5000 then return fail; fi; # specialize both polynomials at x=xi # and compute their heuristic Gcd gamma:=HeuGcdIntPolsExtRep(fam, SpecializedExtRepPol(fam,d,x,xi), SpecializedExtRepPol(fam,e,x,xi) ); if gamma<>fail then # generate G from xi-adic expansion G:=[]; i:=0; if IsInt(gamma) then zero:=Zero(gamma); else zero:=[]; fi; while gamma<>zero do if IsInt(gamma) then # gamma is an integer value g:=gamma mod xi; if g>xi/2 then g:=g-xi; # symmetric rep. fi; gamma:=(gamma-g)/xi; if i=0 then add:=[[],g]; else add:=[[x,i],g]; fi; else # gamma is an ext rep g:=[]; for j in [2,4..Length(gamma)] do k:=gamma[j] mod xi; if k>xi/2 then k:=k - xi; #symmetric rep fi; if k<>0*k then Add(g,gamma[j-1]); Add(g,k); fi; od; #gamma:=(gamma-g)/xi in ext rep; add:=ShallowCopy(g); add{[2,4..Length(add)]}:=-add{[2,4..Length(add)]}; #-g gamma:=ZippedSum(gamma,add,0,fam!.zippedSum); # gamma-g gamma{[2,4..Length(gamma)]}:=gamma{[2,4..Length(gamma)]}/xi; # /xi #add:=g*xp^i; in extrep add:=ZippedProduct(g,[[x,i],1],0,fam!.zippedProduct); fi; # G:=G+add in extrep G:=ZippedSum(G,add,0,fam!.zippedSum); i:=i+1; od; if Length(G)>0 and Length(G[1])>0 and QuotientPolynomialsExtRep(fam,d,G)<>fail and QuotientPolynomialsExtRep(fam,e,G)<>fail then return G; fi; fi; xi:=QuoInt(xi*73794,27011); #square of golden ratio od; return fail; end); # and the same in univariate InstallGlobalFunction(HeuGcdIntPolsCoeffs,function(f,g) local xi, t, h, i, lf, lg, lh,fr,gr; if IsEmpty(f) or IsEmpty(g) then return fail; fi; # first test value for heuristic gcd: xi:=2+2*Minimum(Maximum(List(f,AbsInt)),Maximum(List(g,AbsInt))); i:=0; lf:=f[Length(f)]; lg:=g[Length(g)]; # and now the tests: while i< MAXTRYGCDHEU do # xi-adic expansion of Gcd(f(xi),g(xi)) (regarded as coefficient list) h:=Gcd( ValuePol(f,xi), ValuePol(g,xi) ); h:=SymAdic(h,xi); # make it primitive: t:=Gcd(h); if t<>1 then h:=h/t; fi; lh:=h[Length(h)]; # check if it divides f and g: if yes, ready! if no, try larger xi ## this should be done more efficiently ! if RemInt(lg,lh)=0 and RemInt(lf,lh)=0 then fr:=ShallowCopy(f); ReduceCoeffs(fr,h); gr:=ShallowCopy(g); ReduceCoeffs(gr,h); t:=Set(Concatenation(fr,gr)); else t:=false; fi; if t=[0] then Info(InfoPoly,4,"GcdHeuPrimitiveList: tried ",i+1," values"); return h; else i:=i+1; xi:=QuoInt(xi*73794,27011); fi; od; Info(InfoPoly,2,"GcdHeuPrimitiveList: failed after trying ", MAXTRYGCDHEU," values"); return fail; end); InstallMethod(HeuristicCancelPolynomialsExtRep,"rationals",true, [IsRationalFunctionsFamily,IsList,IsList],0, function(fam,a,b) local nf,df,g; if not (HasCoefficientsFamily(fam) and IsIdenticalObj(CoefficientsFamily(fam),CyclotomicsFamily) and ForAll(a{[2,4..Length(a)]},IsRat) and ForAll(b{[2,4..Length(b)]},IsRat)) then # the coefficients are not all rationals TryNextMethod(); fi; # make numerator and denominator primitive with integer coefficients nf:=PrimitiveFacExtRepRatPol(a); if not IsOne(nf) then a:=ShallowCopy(a); a{[2,4..Length(a)]}:=a{[2,4..Length(a)]}/nf; fi; df:=PrimitiveFacExtRepRatPol(b); if not IsOne(df) then b:=ShallowCopy(b); b{[2,4..Length(b)]}:=b{[2,4..Length(b)]}/df; fi; # the remaining common factor nf:=nf/df; g:=HeuGcdIntPolsExtRep(fam,a,b); if IsList(g) and (Length(g)>2 or (Length(g)=2 and Length(g[1])>0)) then # make g primitive df:=PrimitiveFacExtRepRatPol(g); if not IsOne(df) then g:=ShallowCopy(g); g{[2,4..Length(g)]}:=g{[2,4..Length(g)]}/df; fi; Info(InfoPoly,3,"Heuristic integer gcd returns ",g); a:=QuotientPolynomialsExtRep(fam,a,g); b:=QuotientPolynomialsExtRep(fam,b,g); if a<>fail and b<>fail then a{[2,4..Length(a)]}:=a{[2,4..Length(a)]}*nf; g:=[a,b]; return g; fi; fi; return fail; end); InstallGlobalFunction(PolynomialModP,function(pol,p) local f, cof; f:=GF(p); cof:=CoefficientsOfUnivariatePolynomial(pol); return UnivariatePolynomial(f,cof*One(f), IndeterminateNumberOfUnivariateRationalFunction(pol)); end); ############################################################################# ## #E polyrat.gi . . . . . . . . . . . . . . . . . . . . . . . . . . ends here ## gap-4r6p5/lib/object.gd0000644000175000017500000007311312172557252013476 0ustar billbill############################################################################# ## #W object.gd GAP library Martin Schönert ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file declares the operations for all objects. ## #T Shall we add a check that no object ever lies in both #T `IsComponentObjectRep' and `IsPositionalObjectRep'? #T (A typical pitfall is that one decides to use `IsAttributeStoringRep' #T for storing attribute values, *and* `IsPositionalObjectRep' for #T convenience.) #T Could we use `IsImpossible' and an immediate method that signals an error? ############################################################################# ## #C IsObject( ) . . . . . . . . . . . . test if an object is an object ## ## <#GAPDoc Label="IsObject"> ## ## ## ## ## returns true if the object obj is an ## object. Obviously it can never return false. ##

## It can be used as a filter in ## when one of the arguments can be anything. ## ## ## <#/GAPDoc> ## DeclareCategoryKernel( "IsObject", IS_OBJECT, IS_OBJECT ); ############################################################################# ## #F IsIdenticalObj( , ) . . . . . . . are two objects identical ## ## <#GAPDoc Label="IsIdenticalObj"> ## ## ## ## ## tests whether the objects ## obj1 and obj2 are identical (that is they are either ## equal immediate objects or are both stored at the same location in ## memory. ##

## If two copies of a simple constant object ## (see section ) are created, ## it is not defined whether &GAP; will ## actually store two equal but non-identical objects, or just a single ## object. For mutable objects, however, it is important to know whether ## two values refer to identical or non-identical objects, and the ## documentation of operations that return mutable values should make ## clear whether the values returned are new, or may be identical to ## values stored elsewhere. ##

## IsIdenticalObj( 10^6, 10^6); ## true ## gap> IsIdenticalObj( 10^30, 10^30); ## false ## gap> IsIdenticalObj( true, true); ## true ## ]]> ##

## Generally, one may compute with objects but think of the results in ## terms of the underlying elements because one is not interested in ## locations in memory, data formats or information beyond underlying ## equivalence relations. But there are cases where it is important to ## distinguish the relations identity and equality. This is best ## illustrated with an example. (The reader who is not familiar with ## lists in &GAP;, in particular element access and assignment, is ## referred to Chapter .) ## l1:= [ 1, 2, 3 ];; l2:= [ 1, 2, 3 ];; ## gap> l1 = l2; ## true ## gap> IsIdenticalObj( l1, l2 ); ## false ## gap> l1[3]:= 4;; l1; l2; ## [ 1, 2, 4 ] ## [ 1, 2, 3 ] ## gap> l1 = l2; ## false ## ]]> ## The two lists l1 and l2 are equal but not identical. ## Thus a change in l1 does not affect l2. ## l1:= [ 1, 2, 3 ];; l2:= l1;; ## gap> l1 = l2; ## true ## gap> IsIdenticalObj( l1, l2 ); ## true ## gap> l1[3]:= 4;; l1; l2; ## [ 1, 2, 4 ] ## [ 1, 2, 4 ] ## gap> l1 = l2; ## true ## ]]> ## Here, l1 and l2 are identical objects, ## so changing l1 means a change to l2 as well. ## ## ## <#/GAPDoc> ## BIND_GLOBAL( "IsIdenticalObj", IS_IDENTICAL_OBJ ); ############################################################################# ## #F IsNotIdenticalObj( , ) . . . . are two objects not identical ## ## <#GAPDoc Label="IsNotIdenticalObj"> ## ## ## ## ## tests whether the objects obj1 and obj2 are not identical. ## ## ## <#/GAPDoc> ## BIND_GLOBAL( "IsNotIdenticalObj", function ( obj1, obj2 ) return not IsIdenticalObj( obj1, obj2 ); end ); ############################################################################# ## #o = . . . . . . . . . . . . . . . . . . are two objects equal ## DeclareOperationKernel( "=", [ IsObject, IsObject ], EQ ); ############################################################################# ## #o < . . . . . . . . . . . is one object smaller than another ## DeclareOperationKernel( "<", [ IsObject, IsObject ], LT ); ############################################################################# ## #o in . . . . . . . . . . . is one object a member of another ## DeclareOperationKernel( "in", [ IsObject, IsObject ], IN ); ############################################################################# ## #C IsCopyable( ) . . . . . . . . . . . . test if an object is copyable ## ## <#GAPDoc Label="IsCopyable"> ## ## ## ## ## If a mutable form of an object obj can be made in &GAP;, ## the object is called copyable. Examples of copyable objects are of ## course lists and records. A new mutable version of the object can ## always be obtained by the operation . ##

## Objects for which only an immutable form exists in &GAP; are called ## constants. ## Examples of constants are integers, permutations, and domains. ## Called with a constant as argument, ## and return this ## argument. ## ## ## <#/GAPDoc> ## DeclareCategoryKernel( "IsCopyable", IsObject, IS_COPYABLE_OBJ ); ############################################################################# ## #C IsMutable( ) . . . . . . . . . . . . test if an object is mutable ## ## <#GAPDoc Label="IsMutable"> ## ## ## ## ## tests whether obj is mutable. ##

## If an object is mutable then it is also copyable ## (see ), ## and a method should be supplied for it. ## Note that must not be implied by another filter, ## since otherwise would be able to create ## paradoxical objects in the sense that for such an ## object is false but the filter that implies ## is true. ##

## In many situations, however, one wants to ensure that objects are ## immutable. For example, take the identity of a matrix group. ## Since this matrix may be referred to as the identity of the group in ## several places, it would be fatal to modify its entries, ## or add or unbind rows. ## We can obtain an immutable copy of an object with ## . ## ## ## <#/GAPDoc> ## DeclareCategoryKernel( "IsMutable", IsObject, IS_MUTABLE_OBJ ); InstallTrueMethod( IsCopyable, IsMutable); ############################################################################# ## #O Immutable( ) ## ## <#GAPDoc Label="Immutable"> ## ## ## ## ## returns an immutable structural copy ## (see ) of obj ## in which the subobjects are immutable copies of the subobjects of ## obj. ## If obj is immutable then returns ## obj itself. ##

## &GAP; will complain with an error if one tries to change an ## immutable object. ## ## ## <#/GAPDoc> ## BIND_GLOBAL( "Immutable", IMMUTABLE_COPY_OBJ ); ############################################################################# ## #O ShallowCopy( ) . . . . . . . . . . . . . shallow copy of an object ## ## <#GAPDoc Label="ShallowCopy"> ## ## ## ## ## returns a new mutable object equal ## to its argument, if this is possible. ## The subobjects of ShallowCopy( obj ) are identical ## to the subobjects of obj. ##

## If &GAP; does not support a mutable form of the immutable object obj ## (see ) then ## returns obj itself. ##

## Since is an operation, the concrete meaning of ## subobject depends on the type of obj. ## But for any copyable object obj, the definition should reflect the ## idea of first level copying. ##

## The definition of for lists (in particular for ## matrices) can be found in . ## ## ## <#/GAPDoc> ## DeclareOperationKernel( "ShallowCopy", [ IsObject ], SHALLOW_COPY_OBJ ); ############################################################################# ## #F StructuralCopy( ) . . . . . . . . . . structural copy of an object ## ## <#GAPDoc Label="StructuralCopy"> ## ## ## ## ## In a few situations, one wants to make a structural copy ## scp of an object obj. ## This is defined as follows. ## scp and obj are identical if obj is immutable. ## Otherwise, scp is a mutable copy of obj such that ## each subobject of scp is a structural copy of the corresponding ## subobject of obj. ## Furthermore, if two subobjects of obj are identical then ## also the corresponding subobjects of scp are identical. ## obj:= [ [ 0, 1 ] ];; ## gap> obj[2]:= obj[1];; ## gap> obj[3]:= Immutable( obj[1] );; ## gap> scp:= StructuralCopy( obj );; ## gap> scp = obj; IsIdenticalObj( scp, obj ); ## true ## false ## gap> IsIdenticalObj( scp[1], obj[1] ); ## false ## gap> IsIdenticalObj( scp[3], obj[3] ); ## true ## gap> IsIdenticalObj( scp[1], scp[2] ); ## true ## ]]> ##

## That both and ## return the argument obj itself if it is not copyable ## is consistent with this definition, ## since there is no way to change obj by modifying the result of any ## of the two functions, ## because in fact there is no way to change this result at all. ## ## ## <#/GAPDoc> ## BIND_GLOBAL( "StructuralCopy", DEEP_COPY_OBJ ); ############################################################################# ## #A Name( ) . . . . . . . . . . . . . . . . . . . . . name of an object ## ## <#GAPDoc Label="Name"> ## ## ## ## ## returns the name, a string, previously assigned to obj via a call ## to . ## The name of an object is used only for viewing the object via this ## name. ##

## There are no methods installed for computing names of objects, ## but the name may be set for suitable objects, ## using . ## R := PolynomialRing(Integers,2); ## Integers[x_1,x_2] ## gap> SetName(R,"Z[x,y]"); ## gap> R; ## Z[x,y] ## gap> Name(R); ## "Z[x,y]" ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "Name", IsObject ); ############################################################################# ## #A String( [, ] ) formatted string representation of an object ## ## <#GAPDoc Label="String"> ## ## ## ## ## returns a representation of obj, ## which may be an object of arbitrary type, as a string. ## This string should approximate as closely as possible the character ## sequence you see if you print obj. ##

## If length is given it must be an integer. ## The absolute value gives the minimal length of the result. ## If the string representation of obj takes less than that many ## characters it is filled with blanks. ## If length is positive it is filled on the left, ## if length is negative it is filled on the right. ##

## In the two argument case, the string returned is a new mutable ## string (in particular not a part of any other object); ## it can be modified safely, ## and may be safely applied to it. ## String(123);String([1,2,3]); ## "123" ## "[ 1, 2, 3 ]" ## ]]> ## must not put in additional control ## characters \< (ASCII 1) and \> (ASCII 2) ## that allow proper line breaks. ## ## ## <#/GAPDoc> ## DeclareAttribute( "String", IsObject ); DeclareOperation( "String", [ IsObject, IS_INT ] ); ############################################################################# ## #O PrintObj( ) . . . . . . . . . . . . . . . . . . . . print an object ## ## ## ## ## ## prints information about the object obj. ## This information is in general more detailed as that obtained from ## , ## but still it need not be sufficient to construct obj from it, ## and in general it is not &GAP; readable. ##

## If obj has a name (see ) then it will be ## printed via this name, and a domain without name is in many cases printed ## via its generators. ## ## ## ## DeclareOperationKernel( "PrintObj", [ IsObject ], PRINT_OBJ ); # for technical reasons, this cannot be in `function.g' but must be after # the declaration. InstallMethod( PrintObj, "for an operation", true, [IsOperation], 0, function ( op ) Print(""); end); ############################################################################# ## #O PrintString( ) . . . . . . . . . . . string which would be printed ## ## <#GAPDoc Label="PrintString"> ## ## ## ## ## returns a representation of obj, ## which may be an object of arbitrary type, as a string. ## This string should approximate as closely as possible the character ## sequence you see if you print obj using . ##

## If length is given it must be an integer. ## The absolute value gives the minimal length of the result. ## If the string representation of obj takes less than that many ## characters it is filled with blanks. ## If length is positive it is filled on the left, ## if length is negative it is filled on the right. ##

## In the two argument case, the string returned is a new mutable ## string (in particular not a part of any other object); ## it can be modified safely, ## and may be safely applied to it. ## PrintString(123);PrintString([1,2,3]); ## "123" ## "[ 1, 2, 3 ]" ## ]]> ## is entitled to put in additional control ## characters \< (ASCII 1) and \> (ASCII 2) ## that allow proper line breaks. See ## for a function to get rid of these control characters. ## ## ## <#/GAPDoc> ## DeclareOperation( "PrintString", [ IsObject ] ); DeclareOperation( "PrintString", [ IsObject, IS_INT ] ); ############################################################################# ## #F StripLineBreakCharacters( ) . . . removes \< and \> characters ## ## <#GAPDoc Label="StripLineBreakCharacters"> ## ## ## ## ## This function takes a string st as an argument and removes all ## control characters \< (ASCII 1) and \> (ASCII 2) ## which are used by ## and to ensure proper ## line breaking. A new string with these characters removed is returned. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "StripLineBreakCharacters" ); ############################################################################# ## #O Display( ) . . . . . . . . . . . . . . . . . . . display an object ## ## <#GAPDoc Label="Display"> ## ## ## ## ## Displays the object obj in a nice, formatted way which is easy to ## read (but might be difficult for machines to understand). ## The actual format used for this depends on the type of obj. ## Each method should print a newline character as last character. ## Display( [ [ 1, 2, 3 ], [ 4, 5, 6 ] ] * Z(5) ); ## 2 4 1 ## 3 . 2 ## ]]> ##

## One can assign a string to an object that will use ## instead of the default used by , ## via . ## Also, returns the string previously assigned to ## the object for printing, via . ## The following is an example in the context of domains. ##

## g:= Group( (1,2,3,4) ); ## Group([ (1,2,3,4) ]) ## gap> SetName( g, "C4" ); g; ## C4 ## gap> Name( g ); ## "C4" ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "Display", [ IsObject ] ); ############################################################################# ## #O DisplayString( ) . . . . . . . . . . . . . . . . display an object ## ## <#GAPDoc Label="DisplayString"> ## ## ## ## ## Returns a string which could be used to ## display the object obj in a nice, formatted way which is easy to ## read (but might be difficult for machines to understand). ## The actual format used for this depends on the type of obj. ## Each method should include a newline character as last character. ## Note that no method for may delegate ## to any of the operations , ## or to avoid circular delegations. ## ## ## <#/GAPDoc> ## DeclareOperation( "DisplayString", [ IsObject ] ); ############################################################################# ## #O IsInternallyConsistent( ) ## ## <#GAPDoc Label="IsInternallyConsistent"> ## ## ## ## ## For debugging purposes, it may be useful to check the consistency of ## an object obj that is composed from other (composed) objects. ##

## There is a default method of , ## with rank zero, that returns true. ## So it is possible (and recommended) to check the consistency of ## subobjects of obj recursively by ## . ##

## (Note that is not an attribute.) ## ## ## <#/GAPDoc> ## DeclareOperation( "IsInternallyConsistent", [ IsObject ] ); ############################################################################# ## #A IsImpossible( ) ## ## ## ## ## ## For debugging purposes, it may be useful to install immediate methods ## that raise an error if an object lies in a filter which is impossible. ## For example, if a matrix is in the two fiters IsOrdinaryMatrix and ## IsLieMatrix then apparently something went wrong. ## Since we can install these immediate methods only for attributes ## (and not for the operation IsInternallyConsistent), ## we need such an attribute. ## ## ## DeclareAttribute( "IsImpossible", IsObject ); ############################################################################# ## #O ExtRepOfObj( ) . . . . . . . external representation of an object ## ## ## ## ## ## returns the external representation of the object obj. ## ## ## DeclareOperation( "ExtRepOfObj", [ IsObject ] ); ############################################################################# ## #O ObjByExtRep( , ) . object in family and ext. repr. ## ## ## ## ## ## creates an object in the family F which has the external ## representation descr. ## ## ## DeclareOperation( "ObjByExtRep", [ IsFamily, IsObject ] ); ############################################################################# ## #O KnownAttributesOfObject( ) . . . . . list of names of attributes ## ## <#GAPDoc Label="KnownAttributesOfObject"> ## ## ## ## ## returns a list of the names of the attributes whose values are known for ## object. ## g:=Group((1,2),(1,2,3));;Size(g);; ## gap> KnownAttributesOfObject(g); ## [ "Size", "OneImmutable", "NrMovedPoints", "MovedPoints", ## "GeneratorsOfMagmaWithInverses", "MultiplicativeNeutralElement", ## "HomePcgs", "Pcgs", "GeneralizedPcgs", "StabChainMutable", ## "StabChainOptions" ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "KnownAttributesOfObject", [ IsObject ] ); ############################################################################# ## #O KnownPropertiesOfObject( ) . . . . . list of names of properties ## ## <#GAPDoc Label="KnownPropertiesOfObject"> ## ## ## ## ## returns a list of the names of the properties whose values are known for ## object. ## ## ## <#/GAPDoc> ## DeclareOperation( "KnownPropertiesOfObject", [ IsObject ] ); ############################################################################# ## #O KnownTruePropertiesOfObject( ) list of names of true properties ## ## <#GAPDoc Label="KnownTruePropertiesOfObject"> ## ## ## ## ## returns a list of the names of the properties known to be true for ## object. ## g:=Group((1,2),(1,2,3));; ## gap> KnownPropertiesOfObject(g); ## [ "IsFinite", "CanEasilyCompareElements", "CanEasilySortElements", ## "IsDuplicateFree", "IsGeneratorsOfMagmaWithInverses", ## "IsAssociative", "IsSimpleSemigroup", "IsFinitelyGeneratedGroup", ## "IsSubsetLocallyFiniteGroup", "KnowsHowToDecompose", ## "IsNilpotentByFinite" ] ## gap> Size(g); ## 6 ## gap> KnownPropertiesOfObject(g); ## [ "IsEmpty", "IsTrivial", "IsNonTrivial", "IsFinite", ## "CanEasilyCompareElements", "CanEasilySortElements", ## "IsDuplicateFree", "IsGeneratorsOfMagmaWithInverses", ## "IsAssociative", "IsSimpleSemigroup", "IsFinitelyGeneratedGroup", ## "IsSubsetLocallyFiniteGroup", "KnowsHowToDecompose", ## "IsPerfectGroup", "IsSolvableGroup", "IsPolycyclicGroup", ## "IsNilpotentByFinite", "IsTorsionFree", "IsFreeAbelian" ] ## gap> KnownTruePropertiesOfObject(g); ## [ "IsNonTrivial", "IsFinite", "CanEasilyCompareElements", ## "CanEasilySortElements", "IsDuplicateFree", ## "IsGeneratorsOfMagmaWithInverses", "IsAssociative", ## "IsSimpleSemigroup", "IsFinitelyGeneratedGroup", ## "IsSubsetLocallyFiniteGroup", "KnowsHowToDecompose", ## "IsSolvableGroup", "IsPolycyclicGroup", "IsNilpotentByFinite" ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "KnownTruePropertiesOfObject", [ IsObject ] ); ############################################################################# ## #O CategoriesOfObject( ) . . . . . . . list of names of categories ## ## <#GAPDoc Label="CategoriesOfObject"> ## ## ## ## ## returns a list of the names of the categories in which object lies. ## g:=Group((1,2),(1,2,3));; ## gap> CategoriesOfObject(g); ## [ "IsListOrCollection", "IsCollection", "IsExtLElement", ## "CategoryCollections(IsExtLElement)", "IsExtRElement", ## "CategoryCollections(IsExtRElement)", ## "CategoryCollections(IsMultiplicativeElement)", ## "CategoryCollections(IsMultiplicativeElementWithOne)", ## "CategoryCollections(IsMultiplicativeElementWithInverse)", ## "CategoryCollections(IsAssociativeElement)", ## "CategoryCollections(IsFiniteOrderElement)", "IsGeneralizedDomain", ## "CategoryCollections(IsPerm)", "IsMagma", "IsMagmaWithOne", ## "IsMagmaWithInversesIfNonzero", "IsMagmaWithInverses" ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "CategoriesOfObject", [ IsObject ] ); ############################################################################# ## #O RepresentationsOfObject( ) . . list of names of representations ## ## <#GAPDoc Label="RepresentationsOfObject"> ## ## ## ## ## returns a list of the names of the representations object has. ## g:=Group((1,2),(1,2,3));; ## gap> RepresentationsOfObject(g); ## [ "IsComponentObjectRep", "IsAttributeStoringRep" ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "RepresentationsOfObject", [ IsObject ] ); ############################################################################# ## #R IsPackedElementDefaultRep( ) ## ## ## ## ## ## An object obj in this representation stores a related object as ## obj![1]. ## This representation is used for example for elements in f.p. groups ## or f.p. algebras, where the stored object is an element of a ## corresponding free group or algebra, respectively; ## it is also used for Lie objects created from objects with an associative ## multiplication. ## ## ## DeclareRepresentation( "IsPackedElementDefaultRep", IsPositionalObjectRep, [ 1 ] ); ############################################################################# ## #O PostMakeImmutable( ) clean-up after MakeImmutable ## ## ## ## ## ## This operation is called by the kernel immediately after making ## any COM_OBJ or POS_OBJ immutable using MakeImmutable ## It is intended that objects should have methods for this operation ## which make any appropriate subobjects immutable (eg list entries) ## other subobjects (eg MutableAttributes) need not be made immutable. ##

## A default method does nothing. ## ## ## DeclareOperation( "PostMakeImmutable", [IsObject]); ############################################################################# ## #F NewObjectMarker( ) #F MarkObject( , ) #F UnmarkObject( , ) #F ClearObjectMarker( ) DeclareGlobalFunction( "NewObjectMarker" ); DeclareGlobalFunction( "MarkObject" ); DeclareGlobalFunction( "UnmarkObject" ); DeclareGlobalFunction( "ClearObjectMarker" ); ############################################################################# ## #O MemoryUsage( ) ## ## ## ## ## ## Returns the amount of memory in bytes used by the object obj ## and its subobjects. Note that in general, objects can reference ## each other in very difficult ways such that determining the memory ## usage is a recursive procedure. In particular, computing the memory ## usage of a complicated structure itself uses some additional memory, ## which is however no longer used after completion of this operation. ## This procedure descents into lists and records, positional and ## component objects, however it does not take into account the type ## and family objects! For functions, it only takes the memory usage of ## the function body, not of the local context the function was created ## in, although the function keeps a reference to that as well! ## ## ## DeclareOperation( "MemoryUsage", [IsObject] ); DeclareGlobalFunction( "MU_AddToCache" ); DeclareGlobalFunction( "MU_Finalize" ); BIND_GLOBAL( "MU_MemPointer", GAPInfo.BytesPerVariable ); if GAPInfo.BytesPerVariable = 4 then BIND_GLOBAL( "MU_MemBagHeader", 12 ); else BIND_GLOBAL( "MU_MemBagHeader", 16 ); fi; ############################################################################# ## #E gap-4r6p5/lib/partitio.gi0000644000175000017500000003303412172557252014066 0ustar billbill############################################################################# ## #W partitio.gi GAP library Heiko Theißen ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the functions that construct and modify ordered ## partitions. These functions are used in the backtrack algorithms for ## permutation groups. ## ## A *partition* is a mutable record with the following components. ## \beginitems ## `points': & ## a list of all points contained in the partition, such that ## points from the same cell are neighboured ## ## `cellno': & ## a list whose th entry is the number of the cell which ## contains the point ## ## `firsts': & ## a list such that is the first point in ## which is in cell ## ## `lengths': & ## a list of the cell lengths ## \enditems ## ############################################################################# ## #F Partition( ) . . . . . . . . . . . . . . . . partition constructor ## InstallGlobalFunction( Partition, function( list ) local P, i, c; P := rec( points := Concatenation( list ), firsts := [ ], lengths := [ ] ); if Length(list)>0 then P.cellno := ListWithIdenticalEntries( Maximum( P.points ), 0 ); else Info(InfoWarning,2,"empty partition created!"); P.cellno:=[]; fi; i := 1; for c in [ 1 .. Length( list ) ] do if Length( list[ c ] ) = 0 then Error( "Partition: cells must not be empty" ); fi; Add( P.firsts, i ); Add( P.lengths, Length( list[ c ] ) ); i := i + Length( list[ c ] ); P.cellno{ list[ c ] } := c + 0 * list[ c ]; od; return P; end ); ############################################################################# ## #F IsPartition(

) . . . . . . . . . . . . test if object is a partition ## InstallGlobalFunction( IsPartition, P -> IsRecord( P ) and IsBound( P.cellno ) ); #T state this in the definition of a partition! ############################################################################# ## #F NumberCells(

) . . . . . . . . . . . . . . . . . . . number of cells ## InstallGlobalFunction( NumberCells, P -> Length( P.firsts ) ); ############################################################################# ## #F Cell(

, ) . . . . . . . . . . . . . . . . . . . . . cell as list ## InstallGlobalFunction( Cell, function( P, m ) return P.points{ [ P.firsts[m] .. P.firsts[m] + P.lengths[m] - 1 ] }; end ); ############################################################################# #F Cells( ) . . . . . . . . . . . . . . . . . partition as list of sets ## InstallGlobalFunction( Cells, function( Pi ) local cells, i; cells := [ ]; for i in Reversed( [ 1 .. NumberCells( Pi ) ] ) do cells[ i ] := Cell( Pi, i ); od; return cells; end ); ############################################################################# ## #F CellNoPoint( , ) ## InstallGlobalFunction( CellNoPoint,function(part,pt) return part.cellno[pt]; end ); ############################################################################# ## #F CellNoPoints( , ) ## InstallGlobalFunction( CellNoPoints,function(part,pts) return part.cellno{pts}; end ); ############################################################################# ## #F PointInCellNo( ,, ) ## InstallGlobalFunction( PointInCellNo,function(part,pt,no) return part.cellno[pt]=no; end ); ############################################################################# ## #F Fixcells(

) . . . . . . . . . . . . . . . . . . . . fixcells as list ## ## Returns a list of the points along in their cell, ordered as these cells ## are ordered ## InstallGlobalFunction( Fixcells, function( P ) local fix, i; fix := [ ]; for i in [ 1 .. Length( P.lengths ) ] do if P.lengths[ i ] = 1 then Add( fix, P.points[ P.firsts[ i ] ] ); fi; od; return fix; end ); ############################################################################# ## #F SplitCell(

, , , , , ) . . . . . . . . split a cell ## ## Splits

[ ], by taking out all the points that are also contained ## in [ ] ^ g. The new cell is appended to

unless it would be ## empty. If the old cell would remain empty, nothing is changed either. ## ## Returns the length of the new cell, or `false' if nothing was changed. ## ## Shortcuts of the splitting algorithm: If the last argument is ## `true', at least one point will move out. If is a number, at most ## points will move out. ## ## Q is either a partition or a single cell. ## BindGlobal("SplitCellTestfun1",function(Q,pt,no) return PointInCellNo(Q,pt,no); end); BindGlobal("SplitCellTestfun2",function(Q,pt,no) if no=1 then return pt in Q; else return not (pt in Q); fi; end); InstallGlobalFunction( SplitCell, function( P, i, Q, j, g, out ) local a, b, l, B, tmp, m, x, inflag, outflag,test,k,Pcop,acop,maxmov; # If none or all points are moved out, do not change

and return # 'false'. a := P.firsts[ i ]; b := a + P.lengths[ i ]; l := b - 1; # Collect the points to be moved out of the th cell of

at the # right. # if B is passed, we moved too many (or all) points if IsInt(out) then maxmov:=out; else maxmov:=P.lengths[i]-1; # maximum number to be moved out: Cellength-1 fi; if IsPartition(Q) # if P.points is a range, or g not internal, we would crash and IsPlistRep(P.points) and IsInternalRep(g) then a:=SPLIT_PARTITION(P.points,Q.cellno,j,g,[a,l,maxmov]); if a<0 then return false; fi; else # library version if IsPartition(Q) then test:=SplitCellTestfun1; else test:=SplitCellTestfun2; fi; B:=l-maxmov; a := a - 1; # Points left of remain in the cell, points right of move # out. while a < b do # Decrease until a point remains in the cell. repeat b := b - 1; # $b < B$ means that more than points move out. if b < B then return false; fi; until not test(Q,P.points[ b ] ^ g,j); # Increase until a point moved out. repeat a := a + 1; until (a>b) or test(Q,P.points[ a ] ^ g,j); # Swap the points. if a < b then tmp := P.points[ a ]; P.points[ a ] := P.points[ b ]; P.points[ b ] := tmp; fi; od; fi; if a>l then # no point moved out return false; fi; # Split the cell and introduce a new cell into

. m := Length( P.firsts ) + 1; P.cellno{ P.points{ [ a .. l ] } } := m + 0 * [ a .. l ]; P.firsts[ m ] := a; P.lengths[ m ] := l - a + 1; P.lengths[ i ] := P.lengths[ i ] - P.lengths[ m ]; return P.lengths[ m ]; end ); ############################################################################# ## #F IsolatePoint(

, ) . . . . . . . . . . . . . . . . isolate a point ## ## Takes point out of its cell in

, putting it into a new cell, which ## is appended to

. However, does nothing, if was already isolated. ## ## Returns the number of the cell from was taken out, or `false' if ## nothing was changed. ## InstallGlobalFunction( IsolatePoint, function( P, a ) local i, pos, l, m; i := P.cellno[ a ]; if P.lengths[ i ] = 1 then return false; fi; pos := Position( P.points, a, P.firsts[ i ] - 1 ); l := P.firsts[ i ] + P.lengths[ i ] - 1; P.points[ pos ] := P.points[ l ]; P.points[ l ] := a; m := Length( P.firsts ) + 1; P.cellno[ a ] := m; P.firsts[ m ] := l; P.lengths[ m ] := 1; P.lengths[ i ] := P.lengths[ i ] - 1; return i; end ); ############################################################################# ## #F UndoRefinement(

) . . . . . . . . . . . . . . . . . undo a refinement ## ## Undoes the effect of the last cell-splitting actually performed by ## `SplitCell' or `IsolatePoint'. (This means that if the last call of such ## a function had no effect, `UndoRefinement' looks at the second-last etc.) ## This fuses the last cell of

with an earlier cell. ## ## Returns the number of the cell with which the last cell was fused, or ## `false' if the last cell starts at `

.points[1]', because then it ## cannot have been split off. ## ## May behave undefined if there was no splitting before. ## InstallGlobalFunction( UndoRefinement, function( P ) local M, pfm, plm, m; M := Length( P.firsts ); pfm:=P.firsts[M]; if pfm = 1 then return false; fi; plm:=P.lengths[M]; # Fuse the last cell with the one stored before it in `

.points'. m := P.cellno[ P.points[ pfm - 1 ] ]; P.lengths[ m ] := P.lengths[ m ] + plm; P.cellno{ P.points { [ pfm .. pfm + plm - 1 ] } } := m + 0 * [ 1 .. plm ]; Unbind( P.firsts[ M ] ); Unbind( P.lengths[ M ] ); return m; end ); ############################################################################# ## #F FixpointCellNo(

, ) . . . . . . . . . fixpoint from cell no. ## ## Returns the first point of

[ ] (should be a one-point cell). ## InstallGlobalFunction( FixpointCellNo, function( P, i ) return P.points[ P.firsts[ i ] ]; end ); ############################################################################# ## #F FixcellPoint(

, ) . . . . . . . . . . . . . . . . . . . . local ## ## Returns a random cell number which is not yet contained in and has ## length 1. ## ## Adds this cell number to . ## InstallGlobalFunction( FixcellPoint, function( P, old ) local lens, poss, p; lens := P.lengths; poss := Filtered( [ 1 .. Length( lens ) ], i -> not i in old and lens[ i ] = 1 ); if Length( poss ) = 0 then return false; else p := Random( poss ); AddSet( old, p ); return p; fi; end ); ############################################################################# ## #F FixcellsCell(

, , ) . . . . . . . . . . . local ## ## Returns [ , ] such that for j=1,...|K|=|I|, all points in cell ##

[ [j] ] have value [j] in (i.e., ## lie in cell [j] of the partition . ## Returns `false' if and are empty. ## InstallGlobalFunction( FixcellsCell, function( P, Q, old ) local K, I, i, k, start; K := [ ]; I := [ ]; for i in [ 1 .. NumberCells( P ) ] do start := P.firsts[ i ]; k := CellNoPoint(Q,P.points[ start ]); if not k in old and ForAll( start + [ 1 .. P.lengths[ i ] - 1 ], j -> CellNoPoint(Q,P.points[ j ]) = k ) then AddSet( old, k ); Add( K, k ); Add( I, i ); fi; od; if Length( K ) = 0 then return false; else return [ K, I ]; fi; end ); ############################################################################# ## #F TrivialPartition( ) . . . . . . . . . one-cell partition of a set ## InstallGlobalFunction( TrivialPartition, function( Omega ) return Partition( [ Omega ] ); end ); ############################################################################# ## #F OrbitsPartition( , ) partition determined by the orbits of ## InstallGlobalFunction( OrbitsPartition, function( G, Omega ) if IsGroup( G ) then return Partition( OrbitsDomain( G, Omega ) ); else return Partition( OrbitsPerms( G.generators, Omega ) ); fi; end ); ############################################################################# ## #F SmallestPrimeDivisor( ) . . . . . . . . . smallest prime divisor ## InstallGlobalFunction( SmallestPrimeDivisor, function( size ) local i; i := 0; if size = 1 then return 1; else repeat i := i + 1; until i > Length( Primes ) or size mod Primes[ i ] = 0; if i > Length( Primes ) then return FactorsInt( size )[ 1 ]; else return Primes[ i ]; fi; fi; end ); ############################################################################# ## #F CollectedPartition(

, ) . orbits on cells under group of ## ## Returns a partition into unions of cells of

of equal length, sorted ## by this length. However, if there are $n$ cells of equal length, which ## cannot be fused under the action of a group of order (because $n$ ## < SmallestPrimeDivisor( )), leaves these $n$ cells unfused. ## ( = 1 suppresses this extra feature.) ## InstallGlobalFunction( CollectedPartition, function( P, size ) local lens, C, div, typ, p, i; lens := P.lengths; C := [ ]; div := SmallestPrimeDivisor( size ); for typ in Collected( lens ) do p := [ ]; for i in [ 1 .. Length( lens ) ] do if lens[ i ] = typ[ 1 ] then Add( p, Cell( P, i ) ); fi; od; if typ[ 2 ] < div then Append( C, p ); else Add( C, Concatenation( p ) ); fi; od; return Partition( C ); end ); ############################################################################# ## #E gap-4r6p5/lib/alglie.gi0000644000175000017500000055673112172557252013506 0ustar billbill############################################################################# ## #W alglie.gi GAP library Thomas Breuer #W and Willem de Graaf ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains methods for Lie algebras. ## ############################################################################# ## #M LieUpperCentralSeries( ) . . . . . . . . . . for a Lie algebra ## InstallMethod( LieUpperCentralSeries, "for a Lie algebra", true, [ IsAlgebra and IsLieAlgebra ], 0, function( L ) local S, # upper central series of , result C, # Lie centre hom; # homomorphisms of to `/' S := [ TrivialSubalgebra( L ) ]; C := LieCentre( L ); while C <> S[ Length(S) ] do # Replace `L' by `L / C', compute its centre, and get the preimage # under the natural homomorphism. Add( S, C ); hom:= NaturalHomomorphismByIdeal( L, C ); C:= PreImages( hom, LieCentre( Range( hom ) ) ); #T we would like to get ideals! #T is it possible to teach the hom. that the preimage of an ideal is an ideal? od; # Return the series when it becomes stable. return Reversed( S ); end ); ############################################################################# ## #M LieLowerCentralSeries( ) . . . . . . . . . . for a Lie algebra ## InstallMethod( LieLowerCentralSeries, "for a Lie algebra", true, [ IsAlgebra and IsLieAlgebra ], 0, function( L ) local S, # lower central series of , result C; # commutator subalgebras # Compute the series by repeated calling of `ProductSpace'. S := [ L ]; C := LieDerivedSubalgebra( L ); while C <> S[ Length(S) ] do Add( S, C ); C:= ProductSpace( L, C ); od; # Return the series when it becomes stable. return S; end ); ############################################################################# ## #M LieDerivedSubalgebra( ) ## ## is the (Lie) derived subalgebra of the Lie algebra . ## This is the ideal/algebra/subspace (equivalent in this case) ## generated/spanned by all products $uv$ ## where $u$ and $v$ range over a basis of . ## InstallMethod( LieDerivedSubalgebra, "for a Lie algebra", true, [ IsAlgebra and IsLieAlgebra ], 0, L -> ProductSpace( L, L ) ); ############################################################################# ## #M LieDerivedSeries( ) ## InstallMethod( LieDerivedSeries, "for a Lie algebra", true, [ IsAlgebra and IsLieAlgebra ], 0, function ( L ) local S, # (Lie) derived series of , result D; # (Lie) derived subalgebras # Compute the series by repeated calling of `LieDerivedSubalgebra'. S := [ L ]; D := LieDerivedSubalgebra( L ); while D <> S[ Length(S) ] do Add( S, D ); D:= LieDerivedSubalgebra( D ); od; # Return the series when it becomes stable. return S; end ); ############################################################################# ## #M IsLieSolvable( ) . . . . . . . . . . . . . . . for a Lie algebra ## InstallMethod( IsLieSolvable, "for a Lie algebra", true, [ IsAlgebra and IsLieAlgebra ], 0, function( L ) local D; D:= LieDerivedSeries( L ); return Dimension( D[ Length( D ) ] ) = 0; end ); InstallTrueMethod( IsLieSolvable, IsLieNilpotent ); ############################################################################# ## #M IsLieNilpotent( ) . . . . . . . . . . . . . . . for a Lie algebra ## InstallMethod( IsLieNilpotent, "for a Lie algebra", true, [ IsAlgebra and IsLieAlgebra ], 0, function( L ) local D; D:= LieLowerCentralSeries( L ); return Dimension( D[ Length( D ) ] ) = 0; end ); InstallTrueMethod( IsLieNilpotent, IsLieAbelian ); ############################################################################# ## #M IsLieAbelian( ) . . . . . . . . . . . . . . for a Lie algebra ## ## It is of course sufficient to check products of algebra generators, ## no basis and structure constants of are needed. ## But if we have already a structure constants table we use it. ## InstallMethod( IsLieAbelian, "for a Lie algebra with known basis", true, [ IsAlgebra and IsLieAlgebra and HasBasis ], 0, function( L ) local B, # basis of `L' T, # structure constants table w.r.t. `B' i, # loop variable j; # loop variable B:= Basis( L ); if not HasStructureConstantsTable( B ) then TryNextMethod(); fi; T:= StructureConstantsTable( B ); for i in T{ [ 1 .. Length( T ) - 2 ] } do for j in i do if not IsEmpty( j[1] ) then return false; fi; od; od; return true; end ); InstallMethod( IsLieAbelian, "for a Lie algebra", true, [ IsAlgebra and IsLieAlgebra ], 0, function( L ) local i, # loop variable j, # loop variable zero, # zero of `L' gens; # algebra generators of `L' zero:= Zero( L ); gens:= GeneratorsOfAlgebra( L ); for i in [ 1 .. Length( gens ) ] do for j in [ 1 .. i-1 ] do if gens[i] * gens[j] <> zero then return false; fi; od; od; # The algebra multiplication is trivial, and the algebra does # not know about a basis. # Here we know at least that the algebra generators are space # generators. if not HasGeneratorsOfLeftModule( L ) then SetGeneratorsOfLeftModule( L, gens ); fi; # Return the result. return true; end ); InstallTrueMethod( IsLieAbelian, IsAlgebra and IsZeroMultiplicationRing ); ############################################################################## ## #M LieCentre( ) . . . . . . . . . . . . . . . . . . . for a Lie algebra ## ## We solve the system ## $\sum_{i=1}^n a_i c_{ijk} = 0$ for $1 \leq j, k \leq n$ ## (instead of $\sum_{i=1}^n a_i ( c_{ijk} - c_{jik} ) = 0$). ## ## Additionally we know that the centre of a Lie algebra is an ideal. ## InstallMethod( LieCentre, "for a Lie algebra", true, [ IsAlgebra and IsLieAlgebra ], 0, function( A ) local R, # left acting domain of `A' C, # Lie centre of `A', result B, # a basis of `A' T, # structure constants table w.r. to `B' n, # dimension of `A' M, # matrix of the equation system zerovector, # i, j, # loop over ... row; # one row of `M' R:= LeftActingDomain( A ); if Characteristic( R ) <> 2 and HasCentre( A ) then C:= Centre( A ); #T change it to an ideal! else # Catch the trivial case. n:= Dimension( A ); if n = 0 then return A; fi; # Construct the equation system. B:= Basis( A ); T:= StructureConstantsTable( B ); M:= []; zerovector:= [ 1 .. n*n ] * Zero( R ); for i in [ 1 .. n ] do row:= ShallowCopy( zerovector ); for j in [ 1 .. n ] do if IsBound( T[i][j] ) then row{ (j-1)*n + T[i][j][1] }:= T[i][j][2]; fi; od; M[i]:= row; od; # Solve the equation system. M:= NullspaceMat( M ); # Get the generators from the coefficient vectors. M:= List( M, x -> LinearCombination( B, x ) ); # Construct the Lie centre. C:= IdealNC( A, M, "basis" ); fi; # Return the Lie centre. return C; end ); ############################################################################## ## #M LieCentralizer( , ) . . . . . for a Lie algebra and a vector space ## ## Let $(b_1, \ldots, b_n)$ be a basis of , and $(s_1, \ldots, s_m)$ ## be a basis of , with $s_j = \sum_{l=1}^m v_{jl} b_l$. ## The structure constants of are $c_{ijk}$ with ## $b_i b_j = \sum_{k=1}^n c_{ijk} b_k$. ## Then we compute a basis of the solution space of the system ## $\sum_{i=1}^n a_i \sum_{l=1}^m v_{jl} c_{ilk} = 0$ for ## $1 \leq j \leq m$ and $1 \leq k \leq n$. ## ## (left null space of an $n \times (nm)$ matrix) ## InstallMethod( LieCentralizer, "for an abelian Lie algebra and a vector space", IsIdenticalObj, [ IsAlgebra and IsLieAlgebra and IsLieAbelian, IsVectorSpace ], 0, function( A, S ) if IsSubset( A, S ) then return A; else TryNextMethod(); fi; end ); InstallMethod( LieCentralizer, "for a Lie algebra and a vector space", IsIdenticalObj, [ IsAlgebra and IsLieAlgebra, IsVectorSpace ], 0, function( A, S ) local R, # left acting domain of `A' B, # basis of `A' T, # structure constants table w. r. to `B' n, # dimension of `A' m, # dimension of `S' M, # matrix of the equation system v, # coefficients of basis vectors of `S' w.r. to `B' zerovector, # initialize one row of `M' row, # one row of `M' i, j, k, l, # loop variables cil, # offset, vjl, pos; # catch trivial case if Dimension(S) = 0 then return A; fi; R:= LeftActingDomain( A ); B:= Basis( A ); T:= StructureConstantsTable( B ); n:= Dimension( A ); m:= Dimension( S ); M:= []; v:= List( BasisVectors( Basis( S ) ), x -> Coefficients( B, x ) ); zerovector:= [ 1 .. n*m ] * Zero( R ); # Column $(j-1)*n + k$ contains in row $i$ the value # $\sum_{l=1}^m v_{jl} c_{ilk}$ for i in [ 1 .. n ] do row:= ShallowCopy( zerovector ); for l in [ 1 .. n ] do cil:= T[i][l]; for j in [ 1 .. m ] do offset := (j-1)*n; vjl := v[j][l]; for k in [ 1 .. Length( cil[1] ) ] do pos:= cil[1][k] + offset; row[ pos ]:= row[ pos ] + vjl * cil[2][k]; od; od; od; Add( M, row ); od; # Solve the equation system. M:= NullspaceMat( M ); # Construct the generators from the coefficient vectors. M:= List( M, x -> LinearCombination( B, x ) ); # Return the subalgebra. return SubalgebraNC( A, M, "basis" ); end ); ############################################################################## ## #M LieNormalizer( , ) . . . . . . for a Lie algebra and a vector space ## ## If $(x_1, \ldots, x_n)$ is a basis of $L$ and $(u_1, \ldots, u_s)$ is ## a basis of $U$, then $x = \sum_{i=1}^n a_i x_i$ is an element of $N_L(U)$ ## iff $[x,u_j] = \sum_{k=1}^s b_{j,k} u_k$ for $j = 1, \ldots, s$. ## This leads to a set of $n s$ equations for the $n + s^2$ unknowns $a_i$ ## and $b_{jk}$. ## If $u_k= \sum_{l=1}^n v_{kl} x_l$, then these equations can be written as ## $\sum_{i=1}^n (\sum_{j=1}^n v_{lj} c_{ijk} a_i - ## \sum_{i=1}^s v_{ik} b_{li} = 0$, ## for $1 \leq k \leq n$ and $1 \leq j \leq s$, ## where the $c_{ilp}$ are the structure constants of $L$. ## From the solution we only need the "normalizer part" (i.e., ## the $a_i$ part). ## InstallMethod( LieNormalizer, "for a Lie algebra and a vector space", IsIdenticalObj, [ IsAlgebra and IsLieAlgebra, IsVectorSpace ], 0, function( L, U ) local R, # left acting domain of `L' B, # a basis of `L' T, # the structure constants table of `L' w.r.t. `B' n, # the dimension of `L' s, # the dimension of `U' A, # the matrix of the equation system i, j, k, l, # loop variables v, # the coefficients of the basis of `U' wrt `B' cij, bas, b, pos; # catch trivial case if Dimension(U) = 0 then return L; fi; # We need not work if `U' knows to be an ideal in its parent `L'. if HasParent( U ) and IsIdenticalObj( L, Parent( U ) ) and HasIsLeftIdealInParent( U ) and IsLeftIdealInParent( U ) then return L; fi; R:= LeftActingDomain( L ); B:= Basis( L ); T:= StructureConstantsTable( B ); n:= Dimension( L ); s:= Dimension( U ); if s = 0 or n = 0 then return L; fi; v:= List( BasisVectors( Basis( U ) ), x -> Coefficients( B, x ) ); # The equations. # First the normalizer part, \ldots A:= NullMat( n + s*s, n*s, R ); for i in [ 1..n ] do for j in [ 1..n ] do cij:= T[i][j]; for l in [ 1..s ] do for k in [ 1..Length( cij[1] ) ] do pos:= (l-1)*n+cij[1][k]; A[i][pos]:= A[i][pos]+v[l][j]*cij[2][k]; od; od; od; od; # \ldots and then the "superfluous" part. for k in [1..n] do for l in [1..s] do for i in [1..s] do A[ n+(l-1)*s+i ][ (l-1)*n+k ]:= -v[i][k]; od; od; od; # Solve the equation system. b:= NullspaceMat(A); # Extract the `normalizer part' of the solution. l:= Length(b); bas:= NullMat( l, n, R ); for i in [ 1..l ] do for j in [ 1..n ] do bas[i][j]:= b[i][j]; od; od; # Construct the generators from the coefficients list. bas:= List( bas, x -> LinearCombination( B, x ) ); # Return the subalgebra. return SubalgebraNC( L, bas, "basis" ); end ); ############################################################################## ## #M KappaPerp( , ) . . . . . . . . for a Lie algebra and a vector space ## #T Should this better be `OrthogonalSpace( , )' where is a #T bilinear form? #T How to represent forms in GAP? #T (Clearly the form must know about the space .) ## ## If $(x_1,\ldots, x_n)$ is a basis of $L$ and $(u_1,\ldots, u_s)$ is a ## basis of $U$ such that $u_k = \sum_{j=1}^n v_{kj} x_j$ then an element ## $x = \sum_{i=1}^n a_i x_i$ is an element of $U^{\perp}$ iff the $a_i$ ## satisfy the equations ## $\sum_{i=1}^n ( \sum_{j=1}^n v_{kj} \kappa(x_i,x_j) ) a_i = 0$ for ## $k = 1, \ldots, s$. ## InstallMethod( KappaPerp, "for a Lie algebra and a vector space", IsIdenticalObj, [ IsAlgebra and IsLieAlgebra, IsVectorSpace ], 0, function( L, U ) local R, # left acting domain of `L' B, # a basis of L kap, # the matrix of the Killing form w.r.t. `B' A, # the matrix of the equation system n, # the dimension of L s, # the dimension of U v, # coefficient list of the basis of U w.r.t. the basis of L i,j,k, # loop variables bas; # the basis of the solution space R:= LeftActingDomain( L ); B:= Basis( L ); n:= Dimension( L ); s:= Dimension( U ); if s = 0 or n = 0 then return L; fi; v:= List( BasisVectors( Basis( U ) ), x -> Coefficients( B, x ) ); A:= NullMat( n, s, R ); kap:= KillingMatrix( B ); # Compute the equations that define the subspace. for k in [ 1..s ] do for i in [ 1..n ] do for j in [ 1..n ] do A[i][k]:= A[i][k] + v[k][j] * kap[i][j]; od; od; od; # Solve the equation system. bas:= NullspaceMat( A ); # Extract the generators. bas:= List( bas, x -> LinearCombination( B, x ) ); return SubspaceNC( L, bas, "basis" ); end ); ############################################################################# ## #M AdjointMatrix( , ) ## ## If the basis vectors are $(b-1, b_2, \ldots, b_n)$, and ## $x = \sum_{i=1}^n x_i b_i$ then $b_j$ is mapped to ## $[ x, b_j ] = \sum_{i=1}^n x_i [ b_i b_j ] ## = \sum_{k=1}^n ( \sum_{i=1}^n x_i c_{ijk} ) b_k$, ## so the entry in the $k$-th row and the $j$-th column of the adjoint ## matrix is $\sum_{i=1}^n x_i c_{ijk}$. ## ## Note that $ad_x$ is a left multiplication, so also the action of the ## adjoint matrix is from the left (i.e., on column vectors). ## InstallMethod( AdjointMatrix, "for a basis of a Lie algebra, and an element", IsCollsElms, [ IsBasis, IsRingElement ], 0, function( B, x ) local n, # dimension of the algebra T, # structure constants table w.r. to `B' zerovector, # zero of the field M, # adjoint matrix, result j, i, l, # loop variables cij, # structure constants vector k, # one position in structure constants vector row; # one row of `M' x:= Coefficients( B, x ); n:= Length( BasisVectors( B ) ); T:= StructureConstantsTable( B ); zerovector:= [ 1 .. n ] * T[ Length( T ) ]; M:= []; for j in [ 1 .. n ] do row:= ShallowCopy( zerovector ); for i in [ 1 .. n ] do cij:= T[i][j]; for l in [ 1 .. Length( cij[1] ) ] do k:= cij[1][l]; row[k]:= row[k] + x[i] * cij[2][l]; od; od; M[j]:= row; od; return TransposedMat( M ); end ); #T general function for arbitrary algebras? (right/left multiplication) #T RegularRepresentation: right multiplication satisfies M_{xy} = M_x M_y #T is just the negative of the adjoint ... ############################################################################# ## #M RightDerivations( ) ## ## Let $n$ be the dimension of $A$. ## We start with $n^2$ indeterminates $D = [ d_{i,j} ]_{i,j}$ which ## means that $D$ maps $b_i$ to $\sum_{j=1}^n d_{ij} b_j$. ## ## (Note that this is row convention.) ## ## This leads to the following linear equation system in the $d_{ij}$. ## $\sum_{k=1}^n ( c_{ijk} d_{km} - c_{kjm} d_{ik} - c_{ikm} d_{jk} ) = 0$ ## for all $1 \leq i, j, m \leq n$. ## The solution of this system gives us a vector space basis of the ## algebra of derivations. ## InstallMethod( RightDerivations, "method for a basis of an algebra", true, [ IsBasis ], 0, function( B ) local T, # structure constants table w.r. to 'B' L, # underlying Lie algebra R, # left acting domain of 'L' n, # dimension of 'L' eqno,offset, A, i, j, k, m, M; # the Lie algebra of derivations if not IsAlgebra( UnderlyingLeftModule( B ) ) then Error( " must be a basis of an algebra" ); fi; if IsLieAlgebra( UnderlyingLeftModule( B ) ) then offset:= 1; else offset:= 0; fi; T:= StructureConstantsTable( B ); L:= UnderlyingLeftModule( B ); R:= LeftActingDomain( L ); n:= Dimension( L ); if n = 0 then return NullAlgebra( R ); fi; # The rows in the matrix of the equation system are indexed # by the $d_{ij}$; the $((i-1) n + j)$-th row belongs to $d_{ij}$. # Construct the equation system. if offset = 1 then A:= NullMat( n^2, (n-1)*n*n/2, R ); else A:= NullMat( n^2, n^3, R ); fi; eqno:= 0; for i in [ 1 .. n ] do for j in [ offset*i+1 .. n ] do for m in [ 1 .. n ] do eqno:= eqno+1; for k in [ 1 .. n ] do A[ (k-1)*n+m ][eqno]:= A[ (k-1)*n+m ][eqno] + SCTableEntry( T,i,j,k ); A[ (i-1)*n+k ][eqno]:= A[ (i-1)*n+k ][eqno] - SCTableEntry( T,k,j,m ); A[ (j-1)*n+k ][eqno]:= A[ (j-1)*n+k ][eqno] - SCTableEntry( T,i,k,m ); od; od; od; od; # Solve the equation system. # Note that if `L' is a Lie algebra and $n = 1$ the matrix is empty. if n = 1 and offset = 1 then A:= [ [ One( R ) ] ]; else A:= NullspaceMatDestructive( A ); fi; # Construct the generating matrices from the vectors. A:= List( A, v -> List( [ 1 .. n ], i -> v{ [ (i-1)*n + 1 .. i*n ] } ) ); # Construct the Lie algebra. if IsEmpty( A ) then M:= AlgebraByGenerators( R, [], LieObject( Immutable( NullMat( n, n, R ) ) ) ); else A:= List( A, LieObject ); M:= AlgebraByGenerators( R, A ); UseBasis( M, A ); fi; # Return the derivations. return M; end ); ############################################################################# ## #M LeftDerivations( ) ## ## Let $n$ be the dimension of $A$. ## We start with $n^2$ indeterminates $D = [ d_{i,j} ]_{i,j}$ which ## means that $D$ maps $b_i$ to $\sum_{j=1}^n d_{ji} b_j$. ## ## (Note that this is column convention.) ## InstallMethod( LeftDerivations, "method for a basis of an algebra", true, [ IsBasis ], 0, function( B ) local T, # structure constants table w.r. to 'B' L, # underlying Lie algebra R, # left acting domain of 'L' n, # dimension of 'L' eqno,offset, A, i, j, k, m, M; # the Lie algebra of derivations if not IsAlgebra( UnderlyingLeftModule( B ) ) then Error( " must be a basis of an algebra" ); fi; if IsLieAlgebra( UnderlyingLeftModule( B ) ) then offset:= 1; else offset:= 0; fi; T:= StructureConstantsTable( B ); L:= UnderlyingLeftModule( B ); R:= LeftActingDomain( L ); n:= Dimension( L ); if n = 0 then return NullAlgebra( R ); fi; # The rows in the matrix of the equation system are indexed # by the $d_{ij}$; the $((i-1) n + j)$-th row belongs to $d_{ij}$. # Construct the equation system. if offset = 1 then A:= NullMat( n^2, (n-1)*n*n/2, R ); else A:= NullMat( n^2, n^3, R ); fi; eqno:= 0; for i in [ 1 .. n ] do for j in [ offset*i+1 .. n ] do for m in [ 1 .. n ] do eqno:= eqno+1; for k in [ 1 .. n ] do A[ (m-1)*n+k ][eqno]:= A[ (m-1)*n+k ][eqno] + SCTableEntry( T,i,j,k ); A[ (k-1)*n+i ][eqno]:= A[ (k-1)*n+i ][eqno] - SCTableEntry( T,k,j,m ); A[ (k-1)*n+j ][eqno]:= A[ (k-1)*n+j ][eqno] - SCTableEntry( T,i,k,m ); od; od; od; od; # Solve the equation system. # Note that if `L' is a Lie algebra and $n = 1$ the matrix is empty. if n = 1 and offset = 1 then A:= [ [ One( R ) ] ]; else A:= NullspaceMatDestructive( A ); fi; # Construct the generating matrices from the vectors. A:= List( A, v -> List( [ 1 .. n ], i -> v{ [ (i-1)*n + 1 .. i*n ] } ) ); # Construct the Lie algebra. if IsEmpty( A ) then M:= AlgebraByGenerators( R, [], LieObject( Immutable( NullMat( n, n, R ) ) ) ); else A:= List( A, LieObject ); M:= AlgebraByGenerators( R, A ); UseBasis( M, A ); fi; # Return the derivations. return M; end ); ############################################################################# ## #M KillingMatrix( ) ## ## We have $\kappa_{i,j} = \sum_{k,l=1}^n c_{jkl} c_{ilk}$ if $c_{ijk}$ ## are the structure constants w.r. to . ## ## (The matrix is symmetric, no matter whether the multiplication is ## (anti-)symmetric.) ## InstallMethod( KillingMatrix, "for a basis of a Lie algebra", true, [ IsBasis ], 0, function( B ) local T, # s.c. table w.r. to `B' L, # the underlying algebra R, # left acting domain of `L' kappa, # the matrix of the killing form, result n, # dimension of `L' zero, # the zero of `R' i, j, k, t, # loop variables row, # one row of `kappa' val, # one entry of `kappa' cjk; # `T[j][k]' T:= StructureConstantsTable( B ); L:= UnderlyingLeftModule( B ); R:= LeftActingDomain( L ); n:= Dimension( L ); kappa:= []; zero:= Zero( R ); for i in [ 1 .. n ] do row:= []; for j in [ 1 .. i ] do val:= zero; for k in [ 1 .. n ] do cjk:= T[j][k]; for t in [ 1 .. Length( cjk[1] ) ] do val:= val + cjk[2][t] * SCTableEntry( T, i, cjk[1][t], k ); od; od; row[j]:= val; if i <> j then kappa[j][i]:= val; fi; od; kappa[i]:= row; od; # Return the result. return kappa; end ); ############################################################################## ## #M AdjointBasis( ) ## ## The input is a basis of a (Lie) algebra $L$. ## This function returns a particular basis $C$ of the matrix space generated ## by $ad L$, namely a basis consisting of elements of the form $ad x_i$ ## where $x_i$ is a basis element of . ## An extra component `indices' is added to this space. ## This is a list of integers such that `ad .basisVectors[ indices[i] ]' ## is the `i'-th basis vector of , for i in [1..Length(indices)]. ## (This list is added in order to be able to identify the basis element of ## with the property that its adjoint matrix is equal to a given basis ## vector of .) ## InstallMethod( AdjointBasis, "for a basis of a Lie algebra", true, [ IsBasis ], 0, function( B ) local bb, # the basis vectors of `B' n, # the dimension of `B' F, # the field over which the algebra is defined adL, # a list of matrices that form a basis of adLsp adLsp, # the matrix space spanned by ad L inds, # the list of indices i, # loop variable adi, # the adjoint matrix of the i-th basis vector of `B' adLbas; # the basis of `adLsp' compatible with `adL' bb:= BasisVectors( B ); n:= Length( bb ); F:= LeftActingDomain( UnderlyingLeftModule( B ) ); adL:= []; adLsp:= MutableBasis( F, [ NullMat(n,n,F) ] ); #T better declare the zero ? inds:= []; for i in [1..n] do adi:= AdjointMatrix( B, bb[i] ); if not IsContainedInSpan( adLsp, adi ) then Add( adL, adi ); Add( inds, i ); CloseMutableBasis( adLsp, adi ); fi; od; if adL = [ ] then adLbas:= Basis( VectorSpace( F, [ ], NullMat( n, n, F ) ) ); else adLbas:= Basis( VectorSpace( F, adL ), adL ); fi; SetIndicesOfAdjointBasis( adLbas, inds ); return adLbas; end ); ############################################################################## ## #M IsRestrictedLieAlgebra( ) . . . . . . . . . . . . . for a Lie algebra ## ## A Lie algebra is defined to be {\em restricted} when it is defined ## over a field of characteristic $p \neq 0$, and for every basis element ## $x$ of there exists $y\in $ such that $(ad x)^p = ad y$ ## (see Jacobson, p. 190). ## InstallMethod( IsRestrictedLieAlgebra, "for a Lie algebra", true, [ IsAlgebra and IsLieAlgebra ], 0, function( L ) local F, # the field over which L is defined B, # the basis of L p, # the characteristic of F adL, # basis for the (matrix) vector space generated by ad L v; # loop over basis vectors of adL F:= LeftActingDomain( L ); p:= Characteristic( F ); if p = 0 then return false; fi; B:= Basis( L ); adL:= AdjointBasis( B ); # Check if ad(L) is closed under the p-th power operation. for v in BasisVectors( adL ) do if not v^p in UnderlyingLeftModule( adL ) then return false; fi; od; return true; end ); ############################################################################# ## #F PowerSi( , ) ## InstallGlobalFunction( PowerSi, function( F, i ) local si, # a function of two arguments: seqs, a list of sequences, # and l, a list containing the two arguments of the # function s_i. The list seqs contains # all possible sequences of i-1 1's and p-2-i+1 2's # This function returns the value of s_i(l[1],l[2]) j,k, # loop variables p, # the characteristic of F combs, # the list of all i-1 element subsets of {1,2,\ldots, p-2} # it serves to make the list seqs v, # a vector of 1's and 2's seqs; # the list of all sequences of 1's and 2's of length p-2, # with i-1 1's and p-2 2's serving as input for si # for example, the sequence [1,1,2] means the element # [[[[x,y],x],x],y] (the first element [x,y] is present # 1 1 2 in all terms of the sum s_i(x,y)). si:= function( seqs, l ) local x, j,k, sum; for j in [1..Length(seqs)] do x:= l[1]*l[2]; for k in seqs[j] do x:= x*l[k]; od; if j=1 then sum:= x; else sum:= sum+x; fi; od; return ( i * One( F ) )^(-1)*sum; end; p:= Characteristic( F ); combs:= Combinations( [1..p-2], i-1 ); # Now all sequences of 1's and 2's of length p and containing i-1 1's # are constructed the 1's in the jth sequence are put at the positions # contained in combs[j]. seqs:=[]; for j in [1..Length( combs )] do v:= List( [1..p-2], x -> 2); for k in combs[j] do v[k]:= 1; od; Add( seqs, v ); od; return arg -> si( seqs, arg ); end ); ############################################################################# ## #F PowerS( ) ## InstallMethod( PowerS, "for a Lie algebra", true, [ IsLieAlgebra ], 0, function( L ) local F, # the coefficients domain p; # the characteristic of `F' F:= LeftActingDomain( L ); p:= Characteristic( F ); return List( [ 1 .. p-1 ], i -> PowerSi( F , i ) ); end ); ############################################################################## ## #F PthPowerImage( , ) ## BindGlobal("PTHPOWERIMAGE_PPI_VEC", function(L,zero,p,bv,pmap,cf,x) local n, # the dimension of L s, # the list of s_i functions im, # the image of x under the p-th power map i,j; # loop variables n:= Dimension( L ); s:= PowerS( L ); im:= Zero( L ); # First the sum of all $\alpha_i^p x_i^{[p]}$ is calculated. for i in [1..n] do im:= im + cf[i]^p * pmap[i]; od; # To this the double sum of all # $s_i(\alpha_j x_j, \sum_{k=j+1}^n \alpha_k x_k)$ # is added. for j in [1..n-1] do if cf[j] <> zero then x:= x - cf[j] * bv[j]; for i in [1..p-1] do im:= im + s[i]( [cf[j]*bv[j],x] ); od; fi; od; return im; end); InstallMethod( PthPowerImage, "for a basis of an algebra, and a ring element", IsCollsElms, [ IsBasis, IsRingElement ], 0, function( B, x ) local L, # the Lie algebra of which B is a basis F, # the coefficients domain of `L' n, # the dimension of L p, # the characteristic of the ground field s, # the list of s_i functions pmap, # the list containing x_i^{[p]} cf, # the coefficients of x wrt the basis of L im, # the image of x under the p-th power map i,j, # loop variables zero, # zero of `F' bv, # basis vectors of `B' adx, # adjoint matrix of x adL; # a basis of the matrix space ad L L:= UnderlyingLeftModule( B ); if not IsLieAlgebra( L ) then TryNextMethod(); fi; F:= LeftActingDomain( L ); p:= Characteristic( F ); if Dimension( LieCentre( L ) ) = 0 then # We calculate the inverse image $ad^{-1} ((ad x)^p)$. adx:= AdjointMatrix( B, x ); adL:= AdjointBasis( B ); adx:= adx^p; cf:= Coefficients( adL, adx ); return LinearCombination( B, cf ); else return PTHPOWERIMAGE_PPI_VEC(L,Zero(F),p,BasisVectors(B),PthPowerImages(B),Coefficients(B,x),x); fi; end ); InstallMethod( PthPowerImage, "for an element of a restricted Lie algebra", [ IsJacobianElement ], # weaker filter, we maybe only discovered later # that the algebra is restricted function(x) local fam; fam := FamilyObj(x); if not IsBound(fam!.pMapping) then TryNextMethod(); fi; return PTHPOWERIMAGE_PPI_VEC(fam!.fullSCAlgebra,fam!.zerocoeff,Characteristic(fam),fam!.basisVectors,fam!.pMapping,ExtRepOfObj(x),x); end); InstallMethod( PthPowerImage, "for an element of a restricted Lie algebra and an integer", [ IsJacobianElement, IsInt ], function(x,n) local fam; fam := FamilyObj(x); if not IsBound(fam!.pMapping) then TryNextMethod(); fi; while n>0 do x := PTHPOWERIMAGE_PPI_VEC(fam!.fullSCAlgebra,fam!.zerocoeff,Characteristic(fam),fam!.basisVectors,fam!.pMapping,ExtRepOfObj(x),x); n := n-1; od; return x; end); InstallMethod( PClosureSubalgebra, "for a subalgebra of restricted jacobian elements", [ IsLieAlgebra and IsJacobianElementCollection ], function(A) local i, p, oldA; repeat oldA := A; for i in Basis(oldA) do A := ClosureLeftModule(A,PthPowerImage(i)); od; until A=oldA; return A; end); ############################################################################# ## #M PthPowerImages( ) . . . . . . . . . . . for a basis of a Lie algebra ## InstallMethod( PthPowerImages, "for a basis of a Lie algebra", true, [ IsBasis ], 0, function( B ) local L, # the underlying algebra p, # the characteristic of `L' adL, # a basis of the matrix space spanned by ad L basL; # the list of basis vectors `b' of `B' such that # `ad b' is a basis vector of `adL' L:= UnderlyingLeftModule( B ); if not IsRestrictedLieAlgebra( L ) then Error( " must be a restricted Lie algebra" ); fi; p:= Characteristic( LeftActingDomain( L ) ); adL:= AdjointBasis( B ); if Dimension( UnderlyingLeftModule( adL ) ) = 0 then # The algebra is abelian. return List( BasisVectors( B ), x -> Zero( L ) ); fi; # Now `IndicesOfAdjointBasis( adL )' is a list of indices with `i'-th # entry the position of the basis vector of `B' # whose adjoint matrix is the `i'-th basis vector of `adL'. basL:= BasisVectors( B ){ IndicesOfAdjointBasis( adL ) }; # We calculate the coefficients of $x_i^{[p]}$ wrt the basis basL. return List( BasisVectors( B ), x -> Coefficients( adL, AdjointMatrix( B, x ) ^ p ) * basL ); #T And why do you compute the adjoint matrices again? #T Aren't they stored as basis vectors in adL ? end ); ############################################################################ ## #M CartanSubalgebra( ) ## ## A Cartan subalgebra of the Lie algebra is by definition a nilpotent ## subalgebra equal to its own normalizer in . ## ## By defintion, an Engel subalgebra of is the generalized eigenspace ## of a non nilpotent element, corresponding to the eigenvalue 0. ## In a restricted Lie algebra of characteristic p we have that every Cartan ## subalgebra of an Engel subalgebra of is a Cartan subalgebra of . ## Hence in this case we construct a decreasing series of Engel subalgebras. ## When it becomes stable we have found a Cartan subalgebra. ## On the other hand, when is not restricted and is defined over a field ## $F$ of cardinality greater than the dimension of we can proceed as ## follows. ## Let $a$ be a non nilpotent element of and $K$ the corresponding ## Engel subalgebra. Furthermore, let $b$ be a non nilpotent element of $K$. ## Then there is an element $c \in F$ such that $a + c ( b - a )$ has an ## Engel subalgebra strictly contained in $K$ ## (see Humphreys, proof of Lemma A, p 79). ## InstallMethod( CartanSubalgebra, "for a Lie algebra", true, [ IsLieAlgebra ], 0, function( L ) local n, # the dimension of L F, # coefficients domain of `L' root, # prim. root of `F' if `F' is finite K, # a subalgebra of L (on termination a Cartan subalg.) a,b, # (non nilpotent) elements of L A, # matrix of the equation system (ad a)^n(x)=0 bas, # basis of the solution space of Ax=0 sp, # the subspace of L generated by bas found,ready, # boolean variables c, # an element of `F' newelt, # an element of L of the form a+c*(b-a) i; # loop variable n:= Dimension(L); F:= LeftActingDomain( L ); if IsRestrictedLieAlgebra( L ) then K:= L; while true do a:= NonNilpotentElement( K ); if a = fail then # `K' is a nilpotent Engel subalgebra, hence a Cartan subalgebra. return K; fi; # `a' is a non nilpotent element of `K'. # We construct the generalized eigenspace of this element w.r.t. # the eigenvalue 0. This is a subalgebra of `K' and of `L'. A:= TransposedMat( AdjointMatrix( Basis( K ), a)); A:= A ^ Dimension( K ); bas:= NullspaceMat( A ); bas:= List( bas, x -> LinearCombination( Basis( K ), x ) ); K:= SubalgebraNC( L, bas, "basis"); od; elif n < Size( F ) then # We start with an Engel subalgebra. If it is nilpotent # then it is a Cartan subalgebra and we are done. # Otherwise we make it smaller. a:= NonNilpotentElement( L ); if a = fail then # `L' is nilpotent. return L; fi; # `K' will be the Engel subalgebra corresponding to `a'. A:= TransposedMat( AdjointMatrix( Basis( L ), a ) ); A:= A^n; bas:= NullspaceMat( A ); bas:= List( bas, x -> LinearCombination( Basis( L ), x ) ); K:= SubalgebraNC( L, bas, "basis"); # We locate a nonnilpotent element in this Engel subalgebra. b:= NonNilpotentElement( K ); # If `b = fail' then `K' is nilpotent and we are done. ready:= ( b = fail ); while not ready do # We locate an element $a + c*(b-a)$ such that the Engel subalgebra # belonging to this element is smaller than the Engel subalgebra # belonging to `a'. # We do this by checking a few values of `c' # (At most `n' values of `c' will not yield a smaller subalgebra.) sp:= VectorSpace( F, BasisVectors( Basis(K) ), "basis"); found:= false; if Characteristic( F ) = 0 then c:= 0; else root:= PrimitiveRoot( F ); c:= root; fi; while not found do if Characteristic( F ) = 0 then c:= c+1; else c:= c*root; fi; newelt:= a+c*(b-a); # Calculate the Engel subalgebra belonging to `newelt'. A:= TransposedMat( AdjointMatrix( Basis( K ), newelt ) ); A:= A^Dimension( K ); bas:= NullspaceMat( A ); bas:= List( bas, x -> LinearCombination( Basis( K ), x ) ); # We have found a smaller subalgebra if the dimension is smaller # and new basis elements are contained in the old space. found:= Length( bas ) < Dimension( K ); i:= 1; while i <= Length( bas ) and found do if not bas[i] in sp then found:= false; fi; i:= i+1; od; od; a:= newelt; K:= SubalgebraNC( L, bas, "basis"); b:= NonNilpotentElement( K ); # If `b = fail' then `K' is nilpotent and we are done. ready:= b = fail; od; return K; else # the field over which is defined is too small TryNextMethod(); fi; end ); ############################################################################## ## #M AdjointAssociativeAlgebra( , ) ## ## This function calculates a basis of the associative matrix algebra ## generated by ad_L K, where is a subalgebra of . ## If {x_1,\ldots ,x_n} is a basis of K, then this algebra is spanned ## by all words ## ad x_{i_1}\cdots ad x_{i_t} ## where t>0. ## The degree of such a word is t. ## The algorithm first calculates a maximal linearly independent set ## of words of degree 1, then of degree 2 and so on. ## Since ad x ad y -ady ad x = ad [x,y], we have that we only have ## to consider words where i_1\leq i_2\leq \cdots \leq i_t. ## InstallMethod( AdjointAssociativeAlgebra, "for a Lie algebra and a subalgebra", true, [ IsAlgebra and IsLieAlgebra, IsAlgebra and IsLieAlgebra ], 0, function( L, K ) local n, # the dimension of L F, # the field of L asbas, # a list containing the basis elts. of the assoc. alg. highdeg, # a list of the elements of the highest degree computed # so far degree1, # a list of elements of degree 1 (i.e. ad x_i) lowinds, # a list of indices such that lowinds[i] is the smallest # index in the word highdeg[i] hdeg, # the new highdeg constructed each step linds, # the new lowinds constructed each step i,j,k, # loop variables ind, # an index m, # a matrix posits, # a list of positions in matrices: # posits[i] is a list of the form [p,q] such that # the matrix asbas[i] has a nonzero entry at position # [p][q] and furthermore the matrices asbas[j] with j>i # will have a zero at that position (so the basis # constructed will be in `upper triangular form') l1,l2, # loop variables found; # a boolean F:= LeftActingDomain( L ); if Dimension( K ) = 0 then return Algebra( F, [ [ [ Zero(F) ] ] ] ); elif IsLieAbelian( L ) then return Algebra( F, [ AdjointMatrix( Basis( L ), GeneratorsOfAlgebra( K )[1] ) ] ); fi; n:= Dimension( L ); # Initialisations that ensure that the first step of the loop will select # a maximal linearly independent set of matrices of degree 1. degree1:= List( BasisVectors( Basis(K) ), x -> AdjointMatrix( Basis(L), x ) ); posits := [ [ 1, 1 ] ]; highdeg := [ IdentityMat( n, F ) ]; asbas := [ Immutable( highdeg[1] ) ]; lowinds := [ Dimension( K ) ]; # If after some steps all words of degree t (say) can be reduced modulo # lower degree, then all words of degree >t can be reduced to linear # combinations of words of lower degree. # Hence in that case we are done. while not IsEmpty( highdeg ) do hdeg:= []; linds:= []; for i in [1..Length(highdeg)] do # Now we multiply all elements `highdeg[i]' with all possible # elements of degree 1 (i.e. elements having an index <= the lowest # index of the word `highdeg[i]') ind:= lowinds[i]; for j in [1..ind] do m:= degree1[j]*highdeg[i]; # Now we first reduce `m' on the basis computed so far # and then add it to the basis. for k in [1..Length(posits)] do l1:= posits[k][1]; l2:= posits[k][2]; m:= m-(m[l1][l2]/asbas[k][l1][l2])*asbas[k]; od; if not IsZero( m ) then #'m' is not an element of the span of `asbas' Add( hdeg, m ); Add( linds, j ); Add( asbas, m); # Now we look for a nonzero entry in `m' # and add the position of that entry to `posits'. found:= false; l1:= 1; l2:= 1; while not found do if m[l1][l2] <> Zero( F ) then Add( posits, [l1,l2] ); found:= true; else if l2 = n then l1:= l1+1; l2:= 1; else l2:= l2+1; fi; fi; od; fi; od; od; if lowinds = [Dimension(K)] then # We are in the first step and hence `degree1' must be made # equal to the linearly independent set that we have just calculated. degree1:= ShallowCopy( hdeg ); linds:= [1..Length(degree1)]; fi; highdeg:= ShallowCopy( hdeg ); lowinds:= ShallowCopy( linds ); od; return Algebra( F, asbas, "basis" ); end ); ############################################################################## ## #M LieNilRadical( ) ## ## Let $p$ be the characteristic of the coefficients field of . ## If $p=0$ the we use the following characterisation of the LieNilRadical: ## Let $S$ be the solvable radical of . And let $H$ be a Cartan subalgebra ## of $S$. Decompose $S$ as $S = H \oplus S_1(H)$, where $S_1(H)$ is the ## Fitting 1-component of the adjoint action of $H$ on $S$. Let $H*$ be the ## associative algebra generated by $ad H$, then $S_1(H)$ is the intersection ## of the spaces $H*^i( S )$ for $i>0$. Let $R$ be the radical of the ## algebra $H*$. Then the LieNilRadical of consists of $S_1(H)$ together ## with all elements $x$ in $H$ such that $ad x\in R$. This last space ## is also characterised as the space of all elements $x$ such that ## $ad x$ lies in the vector space spanned by all nilpotent parts of all ## $ad h$ for $h\in H$. ## ## In the case where $p>0$ we calculate the radical of the associative ## matrix algebra $A$ generated by $ad `L'$. ## The nil radical is then equal to $\{ x\in L \mid ad x \in A \}$. ## InstallMethod( LieNilRadical, "for a Lie algebra", true, [ IsAlgebra and IsLieAlgebra ], 0, function( L ) local F, # the coefficients domain of `L' p, # the characteristic of `F' bv, # basis vectors of a basis of `L' S, # the solvable radical of `L' H, # Cartan subalgebra of `S' HS, # Fitting 1-component of `S' wrt `H' adH, # list of ad x for x in a basis of `H' n, # dimension of `L' t, # the dimension of an ideal eqs, # equation set I, # basis vectors of an ideal of `L' i,j,k, # loop variables sol, # solution set adL, # list of matrices ad x where x runs through a basis of # `L' A, # an associative algebra R, # the radical of this algebra B; # list of basis vectors of R F:= LeftActingDomain( L ); p:= Characteristic( F ); if p = 0 then # The LieNilRadical of is equal to # the LieNilRadical of its solvable radical. S:= LieSolvableRadical( L ); n:= Dimension( S ); if n in [ 0, 1 ] then return S; fi; H:= CartanSubalgebra(S); if Dimension(H) = n then return S; fi; # We calculate the Fitting 1-component $S_1(H)$. HS:= ProductSpace( H, S ); while Dimension( HS ) + Dimension( H ) <> n do HS:= ProductSpace( H, HS ); od; if Dimension( H ) = 1 then return IdealNC( L, BasisVectors(Basis(HS)), "basis" ); fi; # Now we compute the intersection of `R' and `'. adH:= List( BasisVectors(Basis(H)), x -> AdjointMatrix(Basis(S),x)); R:= RadicalOfAlgebra( AdjointAssociativeAlgebra( S, H ) ); B:= BasisVectors( Basis( R ) ); eqs:= NullMat(Dimension(H)+Dimension(R),n^2,F); for i in [1..n] do for j in [1..n] do for k in [1..Dimension(H)] do eqs[k][j+(i-1)*n]:= adH[k][i][j]; od; for k in [1..Dimension(R)] do eqs[Dimension(H)+k][j+(i-1)*n]:= B[k][i][j]; od; od; od; sol:= NullspaceMat( eqs ); I:= List( sol, x-> LinearCombination( Basis(H), x{[1..Dimension(H)]} ) ); Append( I, BasisVectors( Basis( HS ) ) ); return IdealNC( L, I, "basis" ); else n:= Dimension( L ); bv:= BasisVectors( Basis(L) ); adL:= List( bv, x -> AdjointMatrix(Basis(L),x) ); A:= AdjointAssociativeAlgebra( L, L ); R:= RadicalOfAlgebra( A ); if Dimension( R ) = 0 then # In this case the intersection of `ad L' and `R' is the centre of L. return LieCentre( L ); fi; B:= BasisVectors( Basis( R ) ); t:= Dimension( R ); # Now we compute the intersection of `R' and `'. eqs:= NullMat(n+t,n*n,F); for i in [1..n] do for j in [1..n] do for k in [1..n] do eqs[k][j+(i-1)*n]:= adL[k][i][j]; od; for k in [1..t] do eqs[n+k][j+(i-1)*n]:= -B[k][i][j]; od; od; od; sol:= NullspaceMat( eqs ); I:= List( sol, x-> LinearCombination( bv, x{[1..n]} ) ); return SubalgebraNC( L, I, "basis" ); fi; end ); ############################################################################## ## #M LieSolvableRadical( ) ## ## In characteristic zero, the solvable radical of the Lie algebra is ## just the orthogonal complement of $[ ]$ w.r.t. the Killing form. ## ## In characteristic $p > 0$, the following fact is used: ## $R( / NR( ) ) = R( ) / NR( )$ where ## $R( )$ denotes the solvable radical of $L$ and $NR( )$ its ## nil radical). ## InstallMethod( LieSolvableRadical, "for a Lie algebra", true, [ IsLieAlgebra ], 0, function( L ) local LL, # the derived algebra of L n, # the nil radical of L B, # a basis of the solvable radical of L quo, # the quotient L/n r1, # the solvable radical of L/n hom; # the canonical map L -> L/n if Characteristic( LeftActingDomain( L ) ) = 0 then LL:= LieDerivedSubalgebra( L ); B:= BasisVectors( Basis( KappaPerp( L, LL ) ) ); else n:= LieNilRadical( L ); if Dimension( n ) = 0 or Dimension( n ) = Dimension( L ) then return n; fi; hom:= NaturalHomomorphismByIdeal( L, n ); quo:= ImagesSource( hom ); r1:= LieSolvableRadical( quo ); B:= BasisVectors( Basis( r1 ) ); B:= List( B, x -> PreImagesRepresentative( hom, x ) ); Append( B, BasisVectors( Basis( n ) ) ); fi; SetIsLieSolvable( L, Length( B ) = Dimension( L ) ); return IdealNC( L, B, "basis"); end ); ############################################################################## ## #M DirectSumDecomposition( ) ## ## This function calculates a list of ideals of `L' such that `L' is equal ## to the direct sum of them. ## The existence of a decomposition of `L' is equivalent to the existence ## of a nontrivial idempotent in the centralizer of `ad L' in the full ## matrix algebra `M_n(F)'. In the general case we try to find such ## idempotents. ## In the case where the Killing form of `L' is nondegenerate we can use ## a more elegant method. In this case the action of the Cartan subalgebra ## will `identify' the direct summands. ## InstallMethod( DirectSumDecomposition, "for a Lie algebra", true, [ IsAlgebra and IsLieAlgebra ], 0, function( L ) local F, # The field of `L'. BL, # basis of `L' bvl, # basis vectors of `BL' n, # The dimension of `L'. m, # An integer. set, # A list of integers. C, # The centre of `L'. bvc, # basis vectors of a basis of `C' D, # The derived subalgebra of `L'. CD, # The intersection of `C' and `D'. H, # A Cartan subalgebra of `L'. BH, # basis of `H' B, # A list of bases of subspaces of `L'. cf, # Coefficient list. comlist, # List of commutators. ideals, # List of ideals. bb, # List of basis vectors. B1,B2, # Bases of the ideals. sp, # A vector space. x, # An element of `sp'. b, # A list of basis vectors. bas,res, # Bases of associative algebras. i,j,k,l, # Loop variables. centralizer, # The centralizer of `adL' in the matrix algebra. Rad, # The radical of `centralizer'. M,mat, # Matrices. facs, # A list of factors of a polynomial. f, # Polynomial. contained, # Boolean variable. adL, # A basis of the matrix space `ad L'. Q, # The factor algebra `centralizer/Rad' q, # Number of elements of the field of `L'. ei,ni,E, # Elements from `centralizer' hom, # A homomorphism. id, # A list of idempotents. vv; # A list of vectors. F:= LeftActingDomain( L ); n:= Dimension( L ); if n=0 then return [ L ]; fi; if RankMat( KillingMatrix( Basis( L ) ) ) = n then # The algorithm works as follows. # Let `H' be a Cartan subalgebra of `L'. # First we decompose `L' into a direct sum of subspaces `B[i]' # such that the minimum polynomial of the adjoint action of an element # of `H' restricted to `B[i]' is irreducible. # If `L' is a direct sum of ideals, then each of these subspaces # will be contained in precisely one ideal. # If the field `F' is big enough then we can look for a splitting # element in `H'. # This is an element `h' such that the minimum polynomial of `ad h' # has degree `dim L - dim H + 1'. # If the size of the field is bigger than `2*m' then there is a # powerful randomised algorithm (Las Vegas type) for finding such an # element. We just take a random element from `H' and with probability # > 1/2 this will be a splitting element. # If the field is small, then we use decomposable elements instead. H:= CartanSubalgebra( L ); BH:= Basis( H ); BL:= Basis( L ); m:= (( n - Dimension(H) ) * ( n - Dimension(H) + 2 )) / 8; if 2*m < Size(F) and ( not Characteristic( F ) in [2,3] ) then set:= [ -m .. m ]; repeat cf:= List([ 1 .. Dimension( H ) ], x -> Random( set ) ); x:= LinearCombination( BH, cf ); M:= AdjointMatrix( BL, x ); f:= CharacteristicPolynomial( F, F, M ); f:= f/Gcd( f, Derivative( f ) ); until DegreeOfLaurentPolynomial( f ) = Dimension( L ) - Dimension( H ) + 1; # We decompose the action of the splitting element: facs:= Factors( PolynomialRing( F ), f ); B:= []; for i in facs do Add( B, List( NullspaceMat( TransposedMat( Value( i, M ) ) ), x -> LinearCombination( BL, x ) ) ); od; B:= Filtered( B, x -> not ( x[1] in H ) ); else # Here `L' is a semisimple Lie algebra over a small field or a field # of characteristic 2 or 3. This means that # the existence of splitting elements is not assured. So we work # with decomposable elements rather than with splitting ones. # A decomposable element is an element from the associative # algebra `T' generated by `ad H' that has a reducible minimum # polynomial. Let `V' be a stable subspace (under the action of `H') # computed in the process. Then we proceed as follows. # We choose a random element from `T' and restrict it to `V'. If this # element has an irreducible minimum polynomial of degree equal to # the dimension of the associative algebra `T' restricted to `V', # then `V' is irreducible. On the other hand, # if this polynomial is reducible, then we decompose `V'. # `bas' will be a basis of the associative algebra generated by # `ad H'. The computation of this basis is facilitated by the fact # that we know the dimension of this algebra. bas:= List( BH, x -> AdjointMatrix( Basis( L ), x ) ); sp:= MutableBasis( F, bas ); k:=1; l:=1; while k<=Length(bas) do if Length(bas)=Dimension(L)-Dimension(H) then break; fi; M:= bas[ k ]*bas[ l ]; if not IsContainedInSpan( sp, M ) then CloseMutableBasis( sp, M ); Add( bas, M ); fi; if l < Length(bas) then l:=l+1; else k:=k+1; l:=1; fi; od; Add( bas, Immutable( IdentityMat( Dimension( L ), F ) ) ); # Now `B' will be a list of subspaces of `L' stable under `H'. # We stop once every element from `B' is irreducible. cf:= AsList( F ); B:= [ ProductSpace( H, L ) ]; k:= 1; while k <= Length( B ) do if Dimension( B[k] ) = 1 then k:=k+1; else b:= BasisVectors( Basis( B[k] ) ); M:= LinearCombination( bas, List( bas, x -> Random( cf ) ) ); # Now we restrict `M' to the space `B[k]'. mat:= [ ]; for i in [1..Length(b)] do x:= LinearCombination( BL, M*Coefficients( BL, b[i] ) ); Add( mat, Coefficients( Basis( B[k], b ), x ) ); od; M:= TransposedMat( mat ); f:= MinimalPolynomial( F, M ); facs:= Factors( PolynomialRing( F ), f ); if Length(facs)=1 then # We restrict the basis `bas' to the space `B[k]'. If the length # of the result is equal to the degree of `f' then `B[k]' is # irreducible. sp:= MutableBasis( F, [ Immutable( IdentityMat( Dimension(B[k]), F ) ) ] ); for j in [1..Length(bas)] do mat:= [ ]; for i in [1..Length(b)] do x:= LinearCombination( BL, bas[j]*Coefficients( BL, b[i] ) ); Add( mat, Coefficients( Basis( B[k], b ), x ) ); od; mat:= TransposedMat( mat ); if not IsContainedInSpan( sp, mat ) then CloseMutableBasis( sp, mat ); fi; od; res:= BasisVectors( sp ); if Length( res ) = DegreeOfLaurentPolynomial( f ) then # The space is irreducible. k:=k+1; fi; else # We decompose. for i in facs do vv:= List( NullspaceMat( TransposedMat( Value( i, M ) ) ), x -> LinearCombination( b, x ) ); sp:= VectorSpace( F, vv ); if not sp in B then Add( B, sp ); fi; od; # We remove the old space from the list; B:= Filtered( B, x -> (x <> B[k]) ); fi; fi; od; B:= List( B, x -> BasisVectors( Basis( x ) ) ); fi; # Now the pieces in `B' are grouped together. ideals:=[]; while B <> [ ] do # Check whether `B[1]' is contained in any of # the ideals obtained so far. contained := false; i:=1; while not contained and i <= Length(ideals) do if B[1][1] in ideals[i] then contained:= true; fi; i:=i+1; od; if contained then # we do not need B[1] any more B:= Filtered( B, x -> x<> B[1] ); else # `B[1]' generates a new ideal. # We form this ideal by taking `B[1]' together with # all pieces from `B' that do not commute with `B[1]'. # At the end of this process, `bb' will be a list of elements # commuting with all elements of `B'. # From this it follows that `bb' will generate # a subalgebra that is a simple ideal. (No remaining piece of `B' # can be in this ideal because in that case this piece would # generate a smaller ideal inside this one.) bb:= ShallowCopy( B[1] ); B:= Filtered( B, x -> x<> B[1] ); i:=1; while i<= Length( B ) do comlist:= [ ]; for j in [1..Length(bb)] do Append( comlist, List( B[i], y -> bb[j]*y ) ); od; if not ForAll( comlist, x -> x = Zero(L) ) then Append( bb, B[i] ); B:= Filtered( B, x -> x <> B[i] ); i:= 1; else i:=i+1; fi; od; Add( ideals, SubalgebraNC( L, bb ) ); fi; od; return List( ideals, I -> IdealNC( L, BasisVectors( Basis( I ) ), "basis" )); else # First we try to find a central component, i.e., a decomposition # `L=I_1 \oplus I_2' such that `I_1' is contained in the center of `L'. # Such a decomposition exists if and only if the center of `L' is not # contained in the derived subalgebra of `L'. C:= LieCentre( L ); bvc:= BasisVectors( Basis( C ) ); if Dimension( C ) = Dimension( L ) then #Now `L' is abelian; hence `L' is the direct sum of `dim L' ideals. return List( bvc, v -> IdealNC( L, [ v ], "basis" ) ); fi; BL:= Basis( L ); bvl:= BasisVectors( BL ); if 0 < Dimension( C ) then D:= LieDerivedSubalgebra( L ); CD:= Intersection2( C, D ); if Dimension( CD ) < Dimension( C ) then # The central component is the complement of `C \cap D' in `C'. B1:=[]; k:=1; sp:= MutableBasis( F, BasisVectors( Basis( CD ) ), Zero( CD ) ); while Length( B1 ) + Dimension( CD ) <> Dimension( C ) do x:= bvc[k]; if not IsContainedInSpan( sp, x ) then Add( B1, x ); CloseMutableBasis( sp, x ); fi; k:=k+1; od; # The second ideal is a complement of the central component # in `L' containing `D'. #W next statement modified: B2:= ShallowCopy( BasisVectors( Basis( D ) ) ); k:= 1; b:= ShallowCopy( B1 ); Append( b, B2 ); sp:= MutableBasis( F, b ); while Length( B2 )+Length( B1 ) <> n do x:= bvl[k]; if not IsContainedInSpan( sp, x ) then Add( B2, x ); CloseMutableBasis( sp, x ); fi; k:= k+1; od; ideals:= Flat([ DirectSumDecomposition(IdealNC( L, B1, "basis" )), DirectSumDecomposition(IdealNC( L, B2, "basis" )) ]); return ideals; fi; fi; # Now we assume that `L' does not have a central component # and compute the centralizer of `ad L' in `M_n(F)'. adL:= List( bvl, x -> AdjointMatrix( BL, x ) ); centralizer:= FullMatrixAlgebraCentralizer( F, adL ); Rad:= RadicalOfAlgebra( centralizer ); if Dimension( centralizer ) - Dimension( Rad ) = 1 then return [ L ]; fi; # We calculate a complete set of orthogonal primitive idempotents # in the Abelian algebra `centralizer/Rad'. hom:= NaturalHomomorphismByIdeal( centralizer, Rad ); Q:= ImagesSource( hom ); SetCentre( Q, Q ); SetRadicalOfAlgebra( Q, Subalgebra( Q, [ Zero( Q ) ] ) ); id:= List( CentralIdempotentsOfAlgebra( Q ), x->PreImagesRepresentative(hom,x)); # Now we lift the idempotents to the big algebra `A'. The # first idempotent is lifted as follows: # We have that `id[1]^2-id[1]' is an element of `Rad'. # We construct the sequences e_{i+1} = e_i + n_i - 2e_in_i, # and n_{i+1}=e_{i+1}^2-e_{i+1}, starting with e_0=id[1]. # It can be proved by induction that e_q is an idempotent in `A' # because n_0^{2^q}=0. # Now `E' will be the sum of all idempotents lifted so far. # Then the next lifted idempotent is obtained by setting # `ei:=id[i]-E*id[i]-id[i]*E+E*id[i]*E;' # and lifting as above. It can be proved that in this manner we # get an orthogonal system of primitive idempotents. E:= Zero( F )*id[1]; for i in [1..Length(id)] do ei:= id[i]-E*id[i]-id[i]*E+E*id[i]*E; q:= 0; while 2^q <= Dimension( Rad ) do q:= q+1; od; ni:= ei*ei-ei; for j in [1..q] do ei:= ei+ni-2*ei*ni; ni:= ei*ei-ei; od; id[i]:= ei; E:= E+ei; od; # For every idempotent of `centralizer' we calculate # a direct summand of `L'. ideals:= List( id, e -> List( TransposedMat( e ), v -> LinearCombination( BL, v ) ) ); ideals:= List( ideals, ii -> BasisVectors( Basis( VectorSpace( F, ii ) ) ) ); return List( ideals, ii -> IdealNC( L, ii, "basis" ) ); fi; end ); ############################################################################## ## #M IsSimpleAlgebra( ) . . . . . . . . . . . . . . . . for a Lie algebra ## ## A test whether is simple. ## It works only over fields of characteristic 0. ## InstallMethod( IsSimpleAlgebra, "for a Lie algebra in characteristic zero", true, [ IsAlgebra and IsLieAlgebra ], 0, function( L ) if Characteristic( LeftActingDomain( L ) ) <> 0 then TryNextMethod(); elif DeterminantMat( KillingMatrix( Basis( L ) ) ) = 0 then return false; else return Length( DirectSumDecomposition( L ) ) = 1; fi; end ); ############################################################################## ## #F FindSl2( , ) ## InstallGlobalFunction( FindSl2, function( L, x ) local n, # the dimension of `L' F, # the field of `L' B, # basis of `L' T, # the table of structure constants of `L' xc, # coefficient vector eqs, # a system of equations i,j,k,l, # loop variables cij, # the element `T[i][j]' b, # the right hand side of the equation system v, # solution of the equations z, # element of `L' h, # element of `L' R, # centralizer of `x' in `L' BR, # basis of `R' Rvecs, # basis vectors of `R' H, # the matrix of `ad H' restricted to `R' e0, # coefficient vector e1, # coefficient vector y; # element of `L' if not IsNilpotentElement( L, x ) then Error( " must be a nilpotent element of the Lie algebra " ); fi; n:= Dimension( L ); F:= LeftActingDomain( L ); B:= Basis( L ); T:= StructureConstantsTable( B ); xc:= Coefficients( B, x ); eqs:= NullMat( 2*n, 2*n, F ); # First we try to find elements `z' and `h' such that `[x,z]=h' # and `[h,x]=2x' (i.e., such that two of the three defining equations # of sl_2 are satisfied). # This results in a system of `2n' equations for `2n' variables. for i in [1..n] do for j in [1..n] do cij:= T[i][j]; for k in [1..Length(cij[1])] do l:= cij[1][k]; eqs[i][l] := eqs[i][l] + xc[j]*cij[2][k]; eqs[n+i][n+l]:= eqs[n+i][n+l] + xc[j]*cij[2][k]; od; od; eqs[n+i][i]:= One( F ); od; b:= []; for i in [1..n] do b[i]:= Zero( F ); b[n+i]:= 2*One( F )*xc[i]; od; v:= SolutionMat( eqs, b ); if v = fail then # There is no sl_2 containing . return fail; fi; z:= LinearCombination( B, v{ [ 1 .. n ] } ); h:= LinearCombination( B, v{ [ n+1 .. 2*n ] } ); R:= LieCentralizer( L, SubalgebraNC( L, [ x ] ) ); BR:= Basis( R ); Rvecs:= BasisVectors( BR ); # `ad h' maps `R' into `R'. `H' will be the matrix of that map. H:= List( Rvecs, v -> Coefficients( BR, h * v ) ); # By the proof of the lemma of Jacobson-Morozov (see Jacobson, # Lie Algebras, p. 98) there is an element `e1' in `R' such that # `(H+2)e1=e0' where `e0=[h,z]+2z'. # If we set `y=z-e1' then `x,h,y' will span a subalgebra of `L' # isomorphic to sl_2. H:= H+2*IdentityMat( Dimension( R ), F ); #T cheaper! e0:= Coefficients( BR, h * z + 2*z ); e1:= SolutionMat( H, e0 ); if e1 = fail then # There is no sl_2 containing . return fail; fi; y:= z-LinearCombination(Rvecs,e1); return SubalgebraNC( L, [x,h,y], "basis" ); end ); ############################################################################# ## #M SemiSimpleType( ) ## ## This function works for Lie algebras over a field of characteristic not ## 2 or 3, having a nondegenerate Killing form. Such Lie algebras are ## semisimple. They are characterized as direct sums of simple Lie algebras, ## and these have been classified: a simple Lie algebra is either an element ## of the "great" classes of simple Lie algebas (A_n, B_n, C_n, D_n), or ## an exceptional algebra (E_6, E_7, E_8, F_4, G_2). This function finds ## the type of the semisimple Lie algebra `L'. Since for the calculations ## eigenvalues and eigenvectors of the action of a Cartan subalgebra are ## needed, we reduce the Lie algebra mod p (if it is of characteristic 0). ## The p may not divide the determinant of the matrix of the Killing form, ## nor may it divide the last nonzero coefficient of a minimum polynomial ## of an element of the basis of the Cartan subalgebra. ## InstallMethod( SemiSimpleType, "for a Lie algebra", true, [ IsAlgebra and IsLieAlgebra ], 0, function( L ) local CartanInteger, # Function that computes the Cartan integer. bvl, # basis vectors of a basis of `L' a, # Element of `L'. T,S,S1, # Structure constants tables. den, # Denominator of a structure constant. denoms, # List of denominators. i,j,k, # Loop variables. scal, # A scalar. K, # A Lie algebra. BK, # basis of `K' d, # The determinant of the Killing form of `K'. p, # A prime. H, # Cartan subalgebra. s, # An integer. mp, # List of minimum polynomials. F, # Field. bas, # List of basis vectors. simples, # List of simple subalgebras. types, # List of the types of the elements of simples. I, # An element of simples. BI, # basis of `I' bvi, # basis vectors of `BI' HI, # Cartan subalgebra of `I'. rk, # The rank of `I'. adH, # List of adjoint matrices. R, # Root system. basR, # Basis of `R'. posR, # List of the positive roots. fundR, # A fundamental system. r,r1,r2,rt, # Roots. Rvecs, # List of root vectors. basH, # List of basis vectors of a Cartan subalg. of `I' sp, # Vector space. h, # Element of a Cartan subalgebra of `I'. cf, # Coefficient. issum, # Boolean. CM, # Cartan Matrix. endpts; # The endpoints of the Dynkin diagram of `I'. if Characteristic( LeftActingDomain( L ) ) in [ 2, 3 ] then Info( InfoAlgebra, 1, "The field of must not have characteristic 2 or 3." ); return fail; fi; # The following function computes the Cartan integer of two roots # `r1' and `r2'. # If `s' and `t' are the largest integers such that `r1 - s*r2' and # `r1 + t*r2' are elements of the root system `R', # then the Cartan integer of `r1' and `r2' is `s-t'. CartanInteger := function( R, r1, r2 ) local R1,s,t,rt; R1:= ShallowCopy( R ); Add( R1, R[1]-R[1] ); s:= 0; t:= 0; rt:= r1-r2; while rt in R1 do rt:= rt-r2; s:= s+1; od; rt:= r1+r2; while rt in R1 do rt:= rt+r2; t:= t+1; od; return s-t; end; # We test whether the Killing form of `L' is nondegenerate. d:= DeterminantMat( KillingMatrix( Basis( L ) ) ); if IsZero( d ) then Info( InfoAlgebra, 1, "The Killing form of is degenerate." ); return fail; fi; # First we produce a basis of `L' such that the first basis elements # form a basis of a Cartan subalgebra of `L'. Then if `L' is defined # over a field of characteristic 0 we do the following. We # multiply by an integer in order to ensure that the structure # constants are integers. # Finally we reduce modulo an appropriate prime `p'. H:= CartanSubalgebra( L ); rk:= Dimension( H ); bas:= ShallowCopy( BasisVectors( Basis( H ) ) ); sp:= MutableBasis( LeftActingDomain( L ), bas ); k:= 1; bvl:= BasisVectors( Basis( L ) ); while Length( bas ) < Dimension( L ) do a:= bvl[k]; if not IsContainedInSpan( sp, a ) then Add( bas, a ); CloseMutableBasis( sp, a ); fi; k:= k+1; od; T:= StructureConstantsTable( BasisNC( L, bas ) ); p:= Characteristic( LeftActingDomain( L ) ); if p = 0 then denoms:=[]; for i in [1..Dimension(L)] do for j in [1..Dimension(L)] do for k in [1..Length(T[i][j][2])] do den:= DenominatorRat( T[i][j][2][k] ); if (den <> 1) and (not den in denoms) then Add( denoms, den ); fi; od; od; od; if denoms <> [] then S:= EmptySCTable( Dimension( L ), 0, "antisymmetric" ); scal:= Lcm( denoms ); for i in [1..Dimension(L)] do for j in [1..Dimension(L)] do S[i][j]:= [T[i][j][1],scal*T[i][j][2]]; od; od; else S:=T; fi; K:= LieAlgebraByStructureConstants( LeftActingDomain( L ), S ); BK:= Basis( K ); d:= DeterminantMat( KillingMatrix( BK ) ); F:= LeftActingDomain( L ); # `mp' will be a list of minimum polynomials of basis elements of the # Cartan subalgebra. mp:= List( BasisVectors( BK ){[1..rk]}, x -> CharacteristicPolynomial( F, F, AdjointMatrix( BK, x ) ) ); mp:= List( mp, x -> x/Gcd( Derivative( x ), x ) ); d:= d * Product( List( mp, p -> CoefficientsOfLaurentPolynomial(p)[1][1] ) ); p:= 5; s:=7; # We determine a prime `p>5' not dividing `d' and an integer `s' # such that the minimum polynomials of the basis elements # of the Cartan subalgebra will split into linear factors # over the field of `p^s' elements, # and such that `p^s<=2^16' # (the maximum size of a finite field in GAP). while p^s > 65536 do while d mod p = 0 do p:= NextPrimeInt( p ); od; F:= GF( p ); S1:= EmptySCTable( Dimension( K ), Zero( F ), "antisymmetric" ); for i in [1..Dimension(K)] do for j in [1..Dimension(K)] do S1[i][j]:= [S[i][j][1], One( F )*List( S[i][j][2], x -> x mod p)]; od; od; K:= LieAlgebraByStructureConstants( F, S1 ); BK:= Basis( K ); mp:= List( BasisVectors( BK ){[1..rk]}, x -> CharacteristicPolynomial( F, F, AdjointMatrix( BK, x ) ) ); s:= Lcm( Flat( List( mp, p -> List( Factors( p ), DegreeOfLaurentPolynomial ) ))); if p=65521 then p:= 1; fi; od; if p = 1 then Info( InfoAlgebra, 1, "We cannot find a small modular splitting field for " ); return fail; fi; else # Here `L' is defined over a field of characteristic p>0. We determine # an integer `s' such that the Cartan subalgebra splits over # `GF( p^s )'. F:= LeftActingDomain( L ); K:= LieAlgebraByStructureConstants( F, T ); BK:= Basis( K ); mp:= List( BasisVectors( BK ){[1..rk]}, x -> CharacteristicPolynomial( F, F, AdjointMatrix( BK, x ) ) ); s:= Lcm( Flat( List( mp, p -> List( Factors( p ), DegreeOfLaurentPolynomial ) ))); s:= s*Dimension( LeftActingDomain( L ) ); if p^s > 2^16 then Info( InfoAlgebra, 1, "We cannot find a small modular splitting field for " ); return fail; fi; S1:= T; fi; F:= GF( p^s ); K:= LieAlgebraByStructureConstants( F, S1 ); # We already know a Cartan subalgebra of `K'. BK:= Basis( K ); H:= SubalgebraNC( K, BasisVectors( BK ){ [ 1 .. rk ] }, "basis" ); SetCartanSubalgebra( K, H ); simples:= DirectSumDecomposition( K ); types:= ""; # Now for every simple Lie algebra in simples we have to determine # its type. # For Lie algebras not equal to B_l, C_l or E_6, # this is determined by the dimension and the rank. # In the other cases we have to examine the root system. for I in simples do if not IsEmpty( types ) then Append( types, " " ); fi; HI:= Intersection2( H, I ); rk:= Dimension( HI ); if Dimension( I ) = 133 and rk = 7 then Append( types, "E7" ); elif Dimension( I ) = 248 and rk = 8 then Append( types, "E8" ); elif Dimension( I ) = 52 and rk = 4 then Append( types, "F4" ); elif Dimension( I ) = 14 and rk = 2 then Append( types, "G2" ); else if Dimension( I ) = rk^2 + 2*rk then Append( types, "A" ); Append( types, String( rk ) ); elif Dimension( I ) = 2*rk^2-rk then Append( types, "D" ); Append( types, String( rk ) ); elif Dimension( I ) = 10 then Append( types, "B2" ); else # We now determine the list of roots and the corresponding # root vectors. # Since the minimum polynomials of the elements of the # Cartan subalgebra split completely, # after the call of DirectSumDecomposition, # the root vectors are contained in the basis of `I'. BI:= Basis( I ); bvi:= BasisVectors( BI ); adH:= List( BasisVectors(Basis(HI)), x->AdjointMatrix(BI,x)); #T better! R:=[]; Rvecs:=[]; for i in [ 1 .. Dimension( I ) ] do rt:= List( adH, x -> x[i][i] ); if not IsZero( rt ) then Add( R, rt ); Add( Rvecs, bvi[i] ); fi; od; # A set of roots `basR' is determined such that the set # { [x_r,x_{-r}] | r\in basR } is a basis of `HI'. basH:= [ ]; basR:= [ ]; sp:= MutableBasis( F, [], Zero(I) ); i:= 1; while Length( basH ) < Dimension( HI ) do r:= R[i]; k:= Position( R, -r ); h:= Rvecs[i] * Rvecs[k]; if not IsContainedInSpan( sp, h ) then Add( basH, h ); CloseMutableBasis( sp, h ); Add( basR, r ); fi; i:= i+1; od; # `posR' will be the set of positive roots. # A root `r' is called positive if in the list # [ < r, basR[i] >, i=1...Length(basR) ] the first nonzero # coefficient is positive # (< r_1, r_2 > is the Cartan integer of r_1 and r_2). posR:= [ ]; for r in R do if (not r in posR) and (not -r in posR) then cf:= 0; i:= 0; while cf = 0 do i:= i+1; cf:= CartanInteger( R, r, basR[i] ); od; if 0 < cf then Add( posR, r ); else Add( posR, -r ); fi; fi; od; # A positive root is a fundamental root if it is not # the sum of two other positive roots. fundR:= [ ]; for r in posR do issum:= false; for r1 in posR do for r2 in posR do if r = r1+r2 then issum:= true; break; fi; od; if issum then break; fi; od; if not issum then Add( fundR, r ); fi; od; # `CM' will be the matrix of Cartan integers # of the fundamental roots. CM:= List( fundR, ri -> List( fundR, rj -> CartanInteger( R, ri, rj ) ) ); # Finally the properties of the endpoints determine # the type of the root system. endpts:= [ ]; for i in [ 1 .. Length(CM) ] do if Number( CM[i], x -> x <> 0 ) = 2 then Add( endpts, i ); fi; od; if Length( endpts ) = 3 then Append( types, "E6" ); elif Sum( CM[ endpts[1] ] ) = 0 or Sum( CM[ endpts[2] ] ) = 0 then Append( types, "C" ); Append( types, String( rk ) ); else Append( types, "B" ); Append( types, String( rk ) ); fi; fi; fi; od; return types; end ); ############################################################################## ## #M NonNilpotentElement( ) ## InstallMethod( NonNilpotentElement, "for a Lie algebra", true, [ IsAlgebra and IsLieAlgebra ], 0, function( L ) local n, # the dimension of `L' F, # the field over which `L' is defined bvecs, # a list of the basisvectors of `L' D, # a list of elements of `L', forming a basis of a nilpotent # subspace sp, # the space spanned by `D' r, # the dimension of `sp' found, # a Boolean variable i, j, # loop variables b, c, # elements of `L' elm; # # First rule out some trivial cases. n:= Dimension( L ); if n = 1 or n = 0 then return fail; fi; F:= LeftActingDomain( L ); bvecs:= BasisVectors( Basis( L ) ); if Characteristic( F ) <> 0 then # `D' will be a basis of a nilpotent subalgebra of L. if IsNilpotentElement( L, bvecs[1] ) then D:= [ bvecs[1] ]; else return bvecs[1]; fi; # `r' will be the dimension of the span of `D'. # If `r = n' then `L' is nilpotent and hence does not contain # non nilpotent elements. r:= 1; while r < n do sp:= VectorSpace( F, D, "basis" ); # We first find an element `b' of `L' that does not lie in `sp'. found:= false; i:= 2; while not found do b:= bvecs[i]; if b in sp then i:= i+1; else found:= true; fi; od; # We now replace `b' by `b * D[i]' if # `b * D[i]' lies outside `sp' in order to ensure that # `[b,sp] \subset sp'. # Because `sp' is a nilpotent subalgebra we only need # a finite number of replacement steps. i:= 1; while i <= r do c:= b*D[i]; if c in sp then i:= i+1; else b:= c; i:= 1; fi; od; if IsNilpotentElement( L, b ) then Add( D, b ); r:= r+1; else return b; fi; od; else # Now `char F =0'. # In this case either `L' is nilpotent or one of the # elements $L.1, \ldots , L.n, L.i + L.j; 1 \leq i < j$ # is non nilpotent. for i in [ 1 .. n ] do if not IsNilpotentElement( L, bvecs[i] ) then return bvecs[i]; fi; od; for i in [ 1 .. n ] do for j in [ i+1 .. n ] do elm:= bvecs[i] + bvecs[j]; if not IsNilpotentElement( L, elm ) then return elm; fi; od; od; fi; # A non nilpotent element has not been found, # hence `L' is nilpotent. return fail; end ); ############################################################################ ## #M PrintObj( ) . . . . . . . . . . . . . . . . . . for a root system ## InstallMethod( PrintObj, "for a root system", true, [ IsRootSystem ], 0, function( R ) if HasCartanMatrix( R ) then Print(""); else Print(""); fi; end ); ############################################################################ ## #M \.( , ) . . . . . . . record component access for a root system ## InstallMethod( \., "for a root system and a record component", true, [ IsRootSystem, IsObject ], 0, function( R, name ) name:= NameRNam( name ); if name = "roots" then return Concatenation( PositiveRoots(R), NegativeRoots(R) ); elif name = "rootvecs" then return Concatenation( PositiveRootVectors(R), NegativeRootVectors(R) ); elif name = "fundroots" then return SimpleSystem( R ); elif name = "cartanmat" then return CartanMatrix(R); else TryNextMethod(); fi; end ); ############################################################################## ## #M RootSystem( ) . . . . . . . . . . . . . . . . . . . for a Lie algebra ## InstallMethod( RootSystem, "for a (semisimple) Lie algebra", true, [ IsAlgebra and IsLieAlgebra ], 0, function( L ) local F, # coefficients domain of `L' BL, # basis of `L' H, # A Cartan subalgebra of `L' basH, # A basis of `H' sp, # A vector space B, # A list of bases of subspaces of `L' whose direct sum # is equal to `L' newB, # A new version of `B' being constructed i,j,l, # Loop variables facs, # List of the factors of `p' V, # A basis of a subspace of `L' M, # A matrix cf, # A scalar a, # A root vector ind, # An index basR, # A basis of the root system h, # An element of `H' posR, # A list of the positive roots fundR, # A list of the fundamental roots issum, # A boolean CartInt, # The function that calculates the Cartan integer of # two roots C, # The Cartan matrix S, # A list of the root vectors zero, # zero of `F' hts, # A list of the heights of the root vectors sorh, # The set `Set( hts )' sorR, # The soreted set of roots R, # The root system. Rvecs, # The root vectors. x,y, # Canonical generators. noPosR; # Number of positive roots. # Let `a' and `b' be two roots of the rootsystem `R'. # Let `s' and `t' be the largest integers such that `a-s*b' and `a+t*b' # are roots. # Then the Cartan integer of `a' and `b' is `s-t'. CartInt := function( R, a, b ) local s,t,rt; s:=0; t:=0; rt:=a-b; while (rt in R) or (rt=0*R[1]) do rt:=rt-b; s:=s+1; od; rt:=a+b; while (rt in R) or (rt=0*R[1]) do rt:=rt+b; t:=t+1; od; return s-t; end; F:= LeftActingDomain( L ); if DeterminantMat( KillingMatrix( Basis( L ) ) ) = Zero( F ) then Info( InfoAlgebra, 1, "the Killing form of is degenerate" ); return fail; fi; # First we compute the common eigenvectors of the adjoint action of a # Cartan subalgebra `H'. Here `B' will be a list of bases of subspaces # of `L' such that `H' maps each element of `B' into itself. # Furthermore, `B' has maximal length w.r.t. this property. H:= CartanSubalgebra( L ); BL:= Basis( L ); B:= [ ShallowCopy( BasisVectors( BL ) ) ]; basH:= BasisVectors( Basis( H ) ); for i in basH do newB:= [ ]; for j in B do V:= Basis( VectorSpace( F, j, "basis" ), j ); M:= List( j, x -> Coefficients( V, i*x ) ); facs:= Factors( MinimalPolynomial( F, M ) ); for l in facs do V:= NullspaceMat( Value( l, M ) ); Add( newB, List( V, x -> LinearCombination( j, x ) ) ); od; od; B:= newB; od; # Now we throw away the subspace `H'. B:= Filtered( B, x -> ( not x[1] in H ) ); # If an element of `B' is not one dimensional then `H' does not split # completely, and hence we cannot compute the root system. for i in [ 1 .. Length(B) ] do if Length( B[i] ) <> 1 then Info( InfoAlgebra, 1, "the Cartan subalgebra of in not split" ); return fail; fi; od; # Now we compute the set of roots `S'. # A root is just the list of eigenvalues of the basis elements of `H' # on an element of `B'. S:= []; zero:= Zero( F ); for i in [ 1 .. Length(B) ] do a:= [ ]; ind:= 0; cf:= zero; while cf = zero do ind:= ind+1; cf:= Coefficients( BL, B[i][1] )[ ind ]; od; for j in [1..Length(basH)] do Add( a, Coefficients( BL, basH[j]*B[i][1] )[ind] / cf ); od; Add( S, a ); od; Rvecs:= List( B, x -> x[1] ); # A set of roots `basR' is calculated such that the set # { [ x_r, x_{-r} ] | r\in R } is a basis of `H'. basH:= [ ]; basR:= [ ]; sp:= MutableBasis( F, [], Zero(L) ); i:=1; while Length( basH ) < Dimension( H ) do a:= S[i]; j:= Position( S, -a ); h:= B[i][1]*B[j][1]; if not IsContainedInSpan( sp, h ) then CloseMutableBasis( sp, h ); Add( basR, a ); Add( basH, h ); fi; i:=i+1; od; # A root `a' is said to be positive if the first nonzero element of # `[ CartInt( S, a, basR[j] ) ]' is positive. # We calculate the set of positive roots. posR:= [ ]; i:=1; while Length( posR ) < Length( S )/2 do a:= S[i]; if (not a in posR) and (not -a in posR) then cf:= zero; j:= 0; while cf = zero do j:= j+1; cf:= CartInt( S, a, basR[j] ); od; if 0 < cf then Add( posR, a ); else Add( posR, -a ); fi; fi; i:=i+1; od; # A positive root is called simple if it is not the sum of two other # positive roots. # We calculate the set of simple roots `fundR'. fundR:= [ ]; for a in posR do issum:= false; for i in [1..Length(posR)] do for j in [i+1..Length(posR)] do if a = posR[i]+posR[j] then issum:=true; fi; od; od; if not issum then Add( fundR, a ); fi; od; # Now we calculate the Cartan matrix `C' of the root system. C:= List( fundR, i -> List( fundR, j -> CartInt( S, i, j ) ) ); # Every root can be written as a sum of the simple roots. # The height of a root is the sum of the coefficients appearing # in that expression. # We order the roots according to increasing height. V:= BasisNC( VectorSpace( F, fundR ), fundR ); hts:= List( posR, r -> Sum( Coefficients( V, r ) ) ); sorh:= Set( hts ); sorR:= [ ]; for i in [1..Length(sorh)] do Append( sorR, Filtered( posR, r -> hts[Position(posR,r)] = sorh[i] ) ); od; Append( sorR, -1*sorR ); Rvecs:= List( sorR, r -> Rvecs[ Position(S,r) ] ); # We calculate a set of canonical generators of `L'. Those are elements # x_i, y_i, h_i such that h_i=x_i*y_i, h_i*x_j = c_{ij} x_j, # h_i*y_j = -c_{ij} y_j for i \in {1..rank} x:= Rvecs{[1..Length(C)]}; noPosR:= Length( Rvecs )/2; y:= Rvecs{[1+noPosR..Length(C)+noPosR]}; for i in [1..Length(x)] do V:= VectorSpace( LeftActingDomain(L), [ x[i] ] ); B:= Basis( V, [x[i]] ); y[i]:= y[i]*2/Coefficients( B, (x[i]*y[i])*x[i] )[1]; od; h:= List([1..Length(C)], j -> x[j]*y[j] ); # Now we construct the root system, and install as many attributes # as possible. The roots are represented als lists [ \alpha(h_1),.... # ,\alpha(h_l)], where the h_i form the `Cartan' part of the canonical # generators. R:= Objectify( NewType( NewFamily( "RootSystemFam", IsObject ), IsAttributeStoringRep and IsRootSystemFromLieAlgebra ), rec() ); SetCanonicalGenerators( R, [ x, y, h ] ); SetUnderlyingLieAlgebra( R, L ); SetPositiveRootVectors( R, Rvecs{[1..noPosR]}); SetNegativeRootVectors( R, Rvecs{[noPosR+1..2*noPosR]} ); SetCartanMatrix( R, C ); posR:= [ ]; for i in [1..noPosR] do B:= Basis( VectorSpace( F, [ Rvecs[i] ] ), [ Rvecs[i] ] ); posR[i]:= List( h, hj -> Coefficients( B, hj*Rvecs[i] )[1] ); od; SetPositiveRoots( R, posR ); SetNegativeRoots( R, -posR ); SetSimpleSystem( R, posR{[1..Length(C)]} ); return R; end ); ############################################################################## ## #M CanonicalGenerators( ) . . . . for a root system from a Lie algebra ## InstallMethod( CanonicalGenerators, "for a root system from a (semisimple) Lie algebra", true, [ IsRootSystemFromLieAlgebra ], 0, function( R ) local L, rank, x, y, i, V, b, c; L:= UnderlyingLieAlgebra( R ); rank:= Length( CartanMatrix( R ) ); x:= PositiveRootVectors( R ){[1..rank]}; y:= NegativeRootVectors( R ){[1..rank]}; for i in [1..Length(x)] do V:= VectorSpace( LeftActingDomain(L), [ x[i] ] ); b:= Basis( V, [x[i]] ); c:= Coefficients( b, (x[i]*y[i])*x[i] )[1]; y[i]:= y[i]*2/c; od; return [ x, y, List([1..rank], j -> x[j]*y[j] ) ]; end ); ############################################################################# ## #M ChevalleyBasis( ) . . . . . . for a semisimple Lie algebra ## InstallMethod( ChevalleyBasis, "for a semisimple Lie algebra with a split Cartan subalgebra", true, [ IsLieAlgebra ], 0, function( L ) local R, n, cg, b1p, b1m, b2p, b2m, k, r, i, r1, pos, b1, b2, f, cfs, bHa, posRV, negRV, x, y, ha, cf, F, T, K, B, BK; # We first calculate an automorphism `f' of `L' such that # F(L_{\alpha}) = L_{-\alpha}, and f(H)=H, and f acts as multiplication # by -1 on H. For this we take the canonical generators of `L', # map its `x'-part onto its `y' part (and vice versa), and map # the `h'-part on minus itself. The automorphism is determined by this. R:= RootSystem( L ); n:= Length( PositiveRoots( R ) ); cg:= CanonicalGenerators( R ); b1p:= ShallowCopy( cg[1] ); b1m:= ShallowCopy( cg[2] ); b2p:= ShallowCopy( cg[2] ); b2m:= ShallowCopy( cg[1] ); k:= 1; while k <= n do r:= PositiveRoots( R )[k]; for i in [1..Length( CartanMatrix( R ) )] do r1:= r + SimpleSystem( R )[i]; pos:= Position( PositiveRoots( R ), r1 ); if pos<>fail and not IsBound( b1p[pos] ) then b1p[pos]:= cg[1][i]*b1p[k]; b1m[pos]:= cg[2][i]*b1m[k]; b2p[pos]:= cg[2][i]*b2p[k]; b2m[pos]:= cg[1][i]*b2m[k]; fi; od; k:= k+1; od; b1:= b1p; Append( b1, b1m ); Append( b1, cg[3] ); b2:= b2p; Append( b2, b2m ); Append( b2, -cg[3] ); f:= LeftModuleHomomorphismByImages( L, L, b1, b2 ); # Now for every positive root vector `x' we set `y= -Image( f, x )'. # We compute a scalar `cf' such that `[x,y]=h', where `h' is the # canonical Cartan element corresponding to the root (unquely determined). # Then we have to multiply `x' and `y' by Sqrt( 2/cf ), in order to get # elements of a Chevalley basis. cfs:= [ ]; bHa:= [ ]; posRV:= [ ]; negRV:= [ ]; for i in [1..n] do x:= PositiveRootVectors( R )[i]; y:= -Image( f, x ); ha:= x*y; cf:= Coefficients( Basis( VectorSpace( LeftActingDomain(L), [x] ), [x] ), ha*x )[1]; if i <= Length( CartanMatrix( R ) ) then Add( bHa, (2/cf)*ha ); fi; Add( cfs, Sqrt( 2/cf ) ); posRV[i]:= x; negRV[i]:= y; od; # In general the `cfs' will lie in a field extension of the ground field. # We construct the Lie algebra over that field with the same structure # constants as `L'. Then we map the Chevalley basis elements into # this new Lie algebra. Then we take the structure constants table of # this new Lie algebra with respect to the Chevalley basis, and # form a new Lie algebra over the same field as `L' with this table. F:= DefaultField( cfs ); T:= StructureConstantsTable( Basis( L ) ); K:= LieAlgebraByStructureConstants( F, T ); BK:= CanonicalBasis( K ); B:= [ ]; for i in [1..n] do B[i]:= LinearCombination( BK, cfs[i]*Coefficients( Basis(L), posRV[i] ) ); B[n+i]:= LinearCombination( BK, cfs[i]*Coefficients( Basis(L), negRV[i] ) ); od; for i in [1..Length(bHa)] do B[2*n+i]:= LinearCombination( BK, Coefficients( Basis(L), bHa[i] ) ); od; T:= StructureConstantsTable( Basis( K, B ) ); K:= LieAlgebraByStructureConstants( LeftActingDomain(L), T ); B:= BasisVectors( CanonicalBasis( K ) ); # Now the basis elements of `K' form a Chevalley basis. Furthermore, # `K' is isomorphic to `L'. We construct the isomorphism, and map # the basis elements of `K' into `L', thus getting a Chevalley basis # in `L'. b1p:= B{[1..Length(CartanMatrix(R))]}; b1m:= B{[n+1..n+Length(CartanMatrix(R))]}; b2p:= ShallowCopy( cg[1] ); b2m:= ShallowCopy( cg[2] ); k:= 1; while k <= n do r:= PositiveRoots( R )[k]; for i in [1..Length( CartanMatrix( R ) )] do r1:= r + SimpleSystem( R )[i]; pos:= Position( PositiveRoots( R ), r1 ); if pos<>fail and not IsBound( b1p[pos] ) then b1p[pos]:= b1p[i]*b1p[k]; b1m[pos]:= b1m[i]*b1m[k]; b2p[pos]:= b2p[i]*b2p[k]; b2m[pos]:= b2m[i]*b2m[k]; fi; od; k:= k+1; od; b1:= b1p; Append( b1, b1m ); Append( b1, B{[2*n+1..Length(B)]} ); b2:= b2p; Append( b2, b2m ); Append( b2, cg[3] ); f:= LeftModuleHomomorphismByImages( K, L, b1, b2 ); return [ List( B{[1..n]}, x -> Image( f, x ) ), List( B{[n+1..2*n]}, y -> Image( f, y ) ), cg[3] ]; end); ############################################################################# ## #F DescriptionOfNormalizedUEAElement( , ) ## InstallGlobalFunction( DescriptionOfNormalizedUEAElement, function( T, listofpairs ) local normalized, # ordered list of normalized coeff./monom. pairs indices, # list that stores at position $i$ up to what # position the $i$-th monomial is known to be # normalized s, i, j, k, l, # loop variables 2i, # `2*i' scalar, # coefficient of the monomial under work mon, # monomial under work len, # length of the monomial under work head, # initial part of the monomial under work middle, # middle part of the monomial under work tail, # trailing part of the monomial under work index, # new value of `indices[i]' Tcoeffs, # one entry in `T' lennorm, # length of `normalized' at the moment zero; # zero coefficient normalized := []; while not IsEmpty( listofpairs ) do listofpairs:= Compacted( listofpairs ); # `indices' is a list of positive integers $[ j_1, j_2, \ldots, j_m ]$ # s.t. the initial part $x_{i_1}^{e_1} \cdots x_{i_{j_k}}^{e_{j_k}}$ # of the $k$-th monomial is known to be normalized, # i.e., $i_1 < i_2 < \cdots < i_{j_k}$. # (So $j_k = 1$ for all $k$ will always be correct.) indices:= ListWithIdenticalEntries( Length( listofpairs )/2, 1 ); # Loop over the monomials that shall be normalized. for i in [ 1, 2 .. Length( indices ) ] do # If the `i'-th monomial is already normalized, # put it into `normalized'. # Otherwise swap the first non-ordered generators. 2i:= 2*i; scalar:= listofpairs[ 2i ]; mon:= listofpairs[ 2i-1 ]; len:= Length( mon ); j:= 2 * indices[i] - 1; while j < len - 2 do if mon[j] < mon[ j+2 ] then # `mon' is better normalized than `indices' tells. j:= j+2; indices[i]:= indices[i] + 1; elif mon[j] = mon[ j+2 ] then # absorption mon[ j+1 ]:= mon[ j+1 ] + mon[ j+3 ]; for k in [ j+2 .. len-2 ] do mon[k]:= mon[ k+2 ]; od; Unbind( mon[ len ] ); Unbind( mon[ len-1 ] ); len:= len - 2; else # We must swap two generators. # First construct head and tail of the arising monomials. head:= mon{ [ 1 .. j-1 ] }; middle:= [ mon[ j+2 ], mon[j+3], mon[j], mon[j+1] ]; tail:= mon{ [ j+4 .. len ] }; # Adjust `indices[i]'. index:= indices[i] - 1; if index = 0 then index:= 1; fi; indices[i]:= index; # Replace the monomial by the swapped one. listofpairs[ 2i-1 ]:= Concatenation( head, middle, tail ); # Add the coeffs/monomials that are given by the commutator. # The part between `head' and `tail' of these listofpairs is # $a_{ji}=\sum_{k=1}^d c_{ijk} x_d$. # Here we use the following formula (which is easily proved # by induction): # # x_j^m x_i^n = x_i^n x_j^m + \sum_{l=0}^{m-1} \sum_{k=0}^{n-1} # x_j^l x_i^k a_{ji} x_i^{n-1-k} x_j^{m-1-l} # # # where x_jx_i = x_ix_j + a_{ji} # Tcoeffs:= T[ mon[j] ][ mon[ j+2 ] ]; for s in [ 1 .. Length( Tcoeffs[1] ) ] do for l in [ 0 .. mon[j+1] - 1 ] do for k in [ 0 .. mon[j+3] - 1 ] do middle:= [ ]; if l > 0 then middle:= [ mon[j], l ]; fi; if k > 0 then Append( middle, [ mon[j+2], k ] ); fi; Append( middle, [ Tcoeffs[1][s], 1 ] ); if mon[j+3]-1-k > 0 then Append( middle, [ mon[j+2], mon[j+3]-1-k ] ); fi; if mon[j+1]-1-l > 0 then Append( middle, [ mon[j], mon[j+1]-1-l ] ); fi; Append( listofpairs, [ Concatenation( head, middle, tail ), scalar * Tcoeffs[2][s] ] ); Add( indices, index ); od; od; od; break; fi; od; # If the monomial is normalized then move it to `normalized'. if len - 2 <= j then # Find the correct position in `normalized', # and insert the monomial. lennorm:= Length( normalized ); k:= 2; while k <= lennorm do if listofpairs[ 2i-1 ] < normalized[ k-1 ] then for l in [ lennorm, lennorm-1 .. k-1 ] do normalized[l+2]:= normalized[l]; od; normalized[ k-1 ]:= listofpairs[ 2i-1 ]; normalized[ k ]:= scalar; break; elif listofpairs[ 2i-1 ] = normalized[ k-1 ] then normalized[k]:= normalized[k] + scalar; break; fi; k:= k+2; od; if lennorm < k then normalized[ lennorm+1 ]:= listofpairs[ 2i-1 ]; normalized[ lennorm+2 ]:= scalar; fi; # Remove the monomial from `listofpairs'. Unbind( listofpairs[ 2i-1 ] ); Unbind( listofpairs[ 2i ] ); fi; od; od; # Remove monomials with multiplicity zero; if not IsEmpty( normalized ) then zero:= Zero( normalized[2] ); for i in [ 2, 4 .. Length( normalized ) ] do if normalized[i] = zero then Unbind( normalized[ i-1 ] ); Unbind( normalized[ i ] ); fi; od; normalized:= Compacted( normalized ); fi; # Return the normal form. return normalized; end ); ############################################################################# ## #M UniversalEnvelopingAlgebra( ) . . . . . . . . . . . for a Lie algebra ## InstallOtherMethod( UniversalEnvelopingAlgebra, "for a finite dimensional Lie algebra and a basis of it", true, [ IsLieAlgebra, IsBasis ], 0, function( L, B ) local F, # free associative algebra U, # universal enveloping algebra, result gen, # loop over algebra generators of `U' Fam, # elements family of `U' T, # s.c. table of a basis of `L' FamMon, # family of monomials FamFree; # elements family of `F' # Check the argument. if not IsFiniteDimensional( L ) then Error( " must be finite dimensional" ); fi; # Construct the universal enveloping algebra. F:= FreeAssociativeAlgebraWithOne( LeftActingDomain( L ), Dimension( L ), "x" ); U:= FactorFreeAlgebraByRelators( F, [ Zero( F ) ] ); #T do not cheat here! # Enter knowledge about `U'. SetDimension( U, infinity ); for gen in GeneratorsOfLeftOperatorRingWithOne( U ) do SetIsNormalForm( gen, true ); od; SetIsNormalForm( Zero( U ), true ); # Enter data to handle elements. Fam:= ElementsFamily( FamilyObj( U ) ); Fam!.normalizedType:= NewType( Fam, IsElementOfFpAlgebra and IsPackedElementDefaultRep and IsNormalForm ); T:= StructureConstantsTable( B ); FamMon:= ElementsFamily( FamilyObj( UnderlyingMagma( F ) ) ); FamFree:= ElementsFamily( FamilyObj( F ) ); SetNiceNormalFormByExtRepFunction( Fam, function( Fam, extrep ) local zero, i; zero:= extrep[1]; extrep:= DescriptionOfNormalizedUEAElement( T, extrep[2] ); for i in [ 1, 3 .. Length( extrep ) - 1 ] do extrep[i]:= ObjByExtRep( FamMon, extrep[i] ); od; return Objectify( Fam!.normalizedType, [ Objectify( FamFree!.defaultType, [ zero, extrep ] ) ] ); end ); SetOne( U, ElementOfFpAlgebra( Fam, One( F ) ) ); # Enter `L'; it is used to set up the embedding (as a vector space). Fam!.liealgebra:= L; #T is not allowed ... # Return the universal enveloping algebra. return U; end ); #T missing: embedding of the Lie algebra (as vector space) #T missing: relators (only compute them if they are explicitly wanted) #T (attribute `Relators'?) InstallMethod( UniversalEnvelopingAlgebra, "for a finite dimensional Lie algebra", true, [ IsLieAlgebra ], 0, function( L ) return UniversalEnvelopingAlgebra( L, Basis(L) ); end ); ############################################################################# ## #F IsSpaceOfUEAElements( ) ## ## If is a space of elements of a universal enveloping algebra, ## then the `NiceFreeLeftModuleInfo' value of is a record with the ## following components. ## \beginitems ## `family' & ## the elements family of , ## ## `monomials' & ## a list of monomials occurring in the generators of , ## ## ## `zerocoeff' & ## the zero coefficient of elements in , ## ## `zerovector' & ## the zero row vector in the nice free left module, ## ## `characteristic' & ## the characteristic of the ground field. ## \enditems ## The `NiceVector' value of $v \in $ is defined as the row vector of ## coefficients of $v$ w.r.t. the list `monomials'. ## ## DeclareHandlingByNiceBasis( "IsSpaceOfUEAElements", "for free left modules of elements of a universal enveloping algebra" ); ############################################################################# ## #M NiceFreeLeftModuleInfo( ) #M NiceVector( , ) #M UglyVector( , ) ## InstallHandlingByNiceBasis( "IsSpaceOfUEAElements", rec( detect := function( F, gens, V, zero ) return IsElementOfFpAlgebraCollection( V ); end, NiceFreeLeftModuleInfo := function( V ) local gens, monomials, gen, list, zero, info; gens:= GeneratorsOfLeftModule( V ); monomials:= []; for gen in gens do list:= ExtRepOfObj( gen )[2]; UniteSet( monomials, list{ [ 1, 3 .. Length( list ) - 1 ] } ); od; zero:= Zero( LeftActingDomain( V ) ); info:= rec( monomials := monomials, zerocoeff := zero, characteristic:= Characteristic( LeftActingDomain( V ) ), family := ElementsFamily( FamilyObj( V ) ) ); # For the zero row vector, catch the case of empty `monomials' list. if IsEmpty( monomials ) then info.zerovector := [ zero ]; else info.zerovector := ListWithIdenticalEntries( Length( monomials ), zero ); fi; return info; end, NiceVector := function( V, v ) local info, c, monomials, i, pos; info:= NiceFreeLeftModuleInfo( V ); c:= ShallowCopy( info.zerovector ); v:= ExtRepOfObj( v )[2]; monomials:= info.monomials; for i in [ 2, 4 .. Length( v ) ] do pos:= Position( monomials, v[ i-1 ] ); if pos = fail then return fail; fi; c[ pos ]:= v[i]; od; return c; end, UglyVector := function( V, r ) local info, list, i; info:= NiceFreeLeftModuleInfo( V ); if Length( r ) <> Length( info.zerovector ) then return fail; elif IsEmpty( info.monomials ) then if IsZero( r ) then return Zero( V ); else return fail; fi; fi; list:= []; for i in [ 1 .. Length( r ) ] do if r[i] <> info.zerocoeff then Add( list, info.monomials[i] ); Add( list, r[i] ); fi; od; return ObjByExtRep( info.family, [ info.characteristic, list ] ); end ) ); ############################################################################# ## #F FreeLieAlgebra( , ) #F FreeLieAlgebra( , , ) #F FreeLieAlgebra( , , , ... ) ## InstallGlobalFunction( FreeLieAlgebra, function( arg ) local R, # coefficients ring names, # names of the algebra generators M, # free magma F, # family of magma ring elements one, # identity of `R' zero, # zero of `R' L; # free Lie algebra, result # Check the argument list. if Length( arg ) = 0 or not IsRing( arg[1] ) then Error( "first argument must be a ring" ); fi; R:= arg[1]; # Construct names of generators. if Length( arg ) = 2 and IsInt( arg[2] ) then names:= List( [ 1 .. arg[2] ], i -> Concatenation( "x", String(i) ) ); MakeImmutable( names ); elif Length( arg ) = 2 and IsList( arg[2] ) and ForAll( arg[2], IsString ) then names:= arg[2]; elif Length( arg ) = 3 and IsInt( arg[2] ) and IsString( arg[3] ) then names:= List( [ 1 .. arg[2] ], x -> Concatenation( arg[3], String(x) ) ); MakeImmutable( names ); elif ForAll( arg{ [ 2 .. Length( arg ) ] }, IsString ) then names:= arg{ [ 2 .. Length( arg ) ] }; else Error( "usage: FreeLieAlgebra( , )\n", "or FreeLieAlgebra( , , ... )" ); fi; # Construct the algebra as magma algebra modulo relations # over a free magma. M:= FreeMagma( names ); # Construct the family of elements of our ring. F:= NewFamily( "FreeLieAlgebraObjFamily", IsElementOfMagmaRingModuloRelations, IsJacobianElement and IsZeroSquaredElement ); SetFilterObj( F, IsFamilyElementOfFreeLieAlgebra ); one:= One( R ); zero:= Zero( R ); F!.defaultType := NewType( F, IsMagmaRingObjDefaultRep ); F!.familyRing := FamilyObj( R ); F!.familyMagma := FamilyObj( M ); F!.zeroRing := zero; #T no !! F!.names := names; # Set the characteristic. if HasCharacteristic( R ) or HasCharacteristic( FamilyObj( R ) ) then SetCharacteristic( F, Characteristic( R ) ); fi; # Make the magma ring object. L:= Objectify( NewType( CollectionsFamily( F ), IsMagmaRingModuloRelations and IsAttributeStoringRep ), rec() ); # Set the necessary attributes. SetLeftActingDomain( L, R ); SetUnderlyingMagma( L, M ); # Deduce useful information. SetIsFiniteDimensional( L, false ); if HasIsWholeFamily( R ) and HasIsWholeFamily( M ) then SetIsWholeFamily( L, IsWholeFamily( R ) and IsWholeFamily( M ) ); fi; # Construct the generators. SetGeneratorsOfLeftOperatorRing( L, List( GeneratorsOfMagma( M ), x -> ElementOfMagmaRing( F, zero, [ one ], [ x ] ) ) ); # Install grading SetGrading( L, rec( min_degree := 1, max_degree := infinity, source := Integers, hom_components := function(degree) local B, d, i, x, y, z; B := GeneratorsOfMagma(M); B := [List([1..Length(B)],i->[[i],fail,B[i]])]; for d in [2..degree] do Add(B,[]); for i in [1..d-1] do for x in B[i] do for y in B[d-i] do z := Concatenation(x[1],y[1]); if z=y[1]) then Add(B[d],[z,y[1],x[3]*y[3]]); fi; od; od; od; od; return VectorSpace( R, List( B[degree], p->ElementOfMagmaRing( F, zero, [ one ], [ p[3] ] ))); end) ); # Return the ring. return L; end ); ############################################################################# ## #M NormalizedElementOfMagmaRingModuloRelations( , ) ## ## is a list of the form `[ , ]', being the zero ## coefficient of the ring, and being the list of monomials and ## their coefficients. ## This function returns the element described in expanded on ## the Lyndon basis of the free Lie algebra. In order to do this we do not ## need to know this basis; we only need a test whether something is a ## Lyndon element (this is done in the function `IsLyndonT'). ## For the algorithm we refer to C. Reutenauer, Free Lie Algebras, Clarendon ## Press, Oxford, 1993. ## InstallMethod( NormalizedElementOfMagmaRingModuloRelations, "for family of free Lie algebra elements, and list", true, [ IsFamilyElementOfFreeLieAlgebra, IsList ], 0, function( Fam, descr ) local todo, #The list of elements that are to be expanded k,i, #Loop variables z,s,u,v,x,y,w, #Bracketed expressions (or `trees') cf, #Coefficient found, #Boolean ll, #List zero, #The zero element of the field tlist, #List of elements of the free Lie algebra Dcopy,IsLyndonT; #Two functions Dcopy:=function( l ) if not IsList(l) then return ShallowCopy( l ); fi; return List( l, Dcopy ); end; IsLyndonT:= function( t ) # This function tests whether the bracketed expression `t' is # a Lyndon tree. local w,w1,w2,b,y; if not IsList( t ) then return true; fi; w:= Flat( t ); if IsList( t[1] ) then w1:= Flat( t[1] ); b:= false; else w1:= [ t[1] ]; b:=true; fi; if IsList( t[2] ) then w2:= Flat( t[2] ); else w2:= [ t[2] ]; fi; if w x<> k); todo:= todo{ll}; elif todo[k][1] then # we already dealt with `s' k:=k+1; elif IsLyndonT( s ) then # we do not need to expand `s' todo[k][1]:=true; k:=k+1; else #we expand `s' found:= false; u:=s; z:= Dcopy( s ); v:= z; # we look for a subtree `u' such that is not a Lyndon tree # such that its left and right subtrees are Lyndon trees. while not found do if IsLyndonT(u[1]) then if IsLyndonT(u[2]) then found:=true; else u:= u[2]; v:=v[2]; fi; else u:= u[1]; v:=v[1]; fi; od; if u[1]=u[2] then # the whole expression `s' reduces to zero. ll:= Filtered([1..Length(todo)], x->x<>k); todo:= todo{ll}; else if Flat([u[1]]) > Flat([u[2]]) then # interchange u[1] and u[2]; this introduces a -. w:=u[1]; u[1]:=u[2]; u[2]:=w; i:= 1; found:= false; while i<= Length( todo ) and not found do if todo[i][3] = s and k<>i then todo[i][2]:= todo[i][2]-cf; if todo[i][2] = zero then ll:=Filtered([1..Length(todo)],x->(x<>k and x<>i )); else ll:=Filtered([1..Length(todo)],x->x<>k); fi; todo:= todo{ll}; found:= true; fi; i:=i+1; od; if not found then todo[k][2]:=-todo[k][2]; fi; else #use the Jacobi identity. x:=u[1][1]; y:=u[1][2]; w:= u[2]; u[1]:=[x,w]; u[2]:=y; i:= 1; found:= false; while i<= Length( todo ) and not found do if todo[i][3] = s and k<>i then todo[i][2]:= todo[i][2]+cf; if todo[i][2] = zero then ll:=Filtered([1..Length(todo)],x->(x<>k and x<>i )); else ll:=Filtered([1..Length(todo)],x->x<>k); fi; todo:= todo{ll}; found:= true; fi; i:=i+1; od; x:=v[1][1]; y:=v[1][2]; w:=v[2]; v[1]:=x; v[2]:=[y,w]; i:= 1; found:= false; while i<= Length( todo ) and not found do if todo[i][3] = z then todo[i][2]:= todo[i][2]+cf; found:= true; fi; i:= i+1; od; if not found then Add( todo, [false,cf,z] ); fi; fi; k:=1; fi; fi; od; # wrap the list `todo' into an element of the free Lie algebra. todo:= List( todo, x -> [x[3],x[2]] ); Sort( todo, function( x, y) return x < y; end ); tlist:= []; for i in [1..Length(todo)] do Append( tlist, todo[i] ); od; return ObjByExtRep( Fam, [ zero, tlist ] ); end ); ############################################################################## ## #M ImageElm( , ) #M ImagesRepresentative( , ) ## ## A special method for calculating the (unique) image of an element ## under an FptoSCAMorphism . The fact that knows the images of the ## generators together with the fact that is an algebra morphism is used ## (rather than the linearity of ). ## BindGlobal( "FptoSCAMorphismImageElm", function( h, x ) local EvalProduct,gens,imgs,im,e,k; EvalProduct:= function( prod, ims ) if not IsList(prod) then return ims[prod]; else return EvalProduct( prod[1], ims )*EvalProduct( prod[2], ims ); fi; end; e:=MappingGeneratorsImages(h); gens:= e[1]; imgs:= e[2]; e:= ExtRepOfObj(x)[2]; im:= 0*imgs[1]; k:= 1; while k <= Length(e) do im:= im + e[k+1]*EvalProduct( e[k], imgs ); k:= k+2; od; return im; end ); InstallMethod( ImageElm, "for Fp to SCA mapping, and element", FamSourceEqFamElm, [ IsFptoSCAMorphism, IsElementOfFpAlgebra ], 0, FptoSCAMorphismImageElm ); InstallMethod( ImagesRepresentative, "for Fp to SCA mapping, and element", FamSourceEqFamElm, [ IsFptoSCAMorphism, IsElementOfFpAlgebra ], 0, FptoSCAMorphismImageElm ); ########################################################################### ## #M PreImagesRepresentative( f, x ) ## InstallMethod( PreImagesRepresentative, "for Fp to SCA mapping, and element", FamRangeEqFamElm, [ IsFptoSCAMorphism, IsSCAlgebraObj ], 0, function( f, x ) local IsLyndonT, dim, e, gens, imgs, b1, b2, levs, brackets, sp, deg, newlev, newbracks, d, br1, br2, i, j, a, b, c, z, imz, cf; IsLyndonT:= function( t ) # This function tests whether the bracketed expression `t' is # a Lyndon tree. local w,w1,w2,b,y; if not IsList( t ) then return true; fi; w:= Flat( t ); if IsList( t[1] ) then w1:= Flat( t[1] ); b:= false; else w1:= [ t[1] ]; b:=true; fi; if IsList( t[2] ) then w2:= Flat( t[2] ); else w2:= [ t[2] ]; fi; if w dim do deg:= deg+1; newlev:= [ ]; newbracks:= [ ]; # get all Lyndon elements of degree deg: for d in [1..Length(brackets)] do if Length( b1 ) = dim then break; fi; br1:= brackets[d]; br2:= brackets[deg-d]; for i in [1..Length(br1)] do if Length( b1 ) = dim then break; fi; for j in [1..Length(br2)] do if Length( b1 ) = dim then break; fi; a:= br1[i]; b:= br2[j]; if IsLyndonT( [a,b] ) then c:= [a,b]; z:= levs[d][i]*levs[deg-d][j]; elif IsLyndonT( [b,a] ) then c:= [b,a]; z:= levs[deg-d][j]*levs[d][i]; else c:= [ ]; fi; if c <> [] then imz:= Image( f, z ); if not IsContainedInSpan( sp, imz ) then CloseMutableBasis( sp, imz ); Add( b1, z ); Add( newlev, z ); Add( newbracks, c ); Add( b2, imz ); fi; fi; od; od; od; Add( levs, newlev ); Add( brackets, newbracks ); od; f!.bases:= [ b1, Basis( Range(f), b2 ) ]; fi; cf:= Coefficients( f!.bases[2], x ); return cf*f!.bases[1]; end); ############################################################################# ## #M Dimension( ) ## ## A method for the dimension of a finitely-presented Lie algebra. ## InstallMethod( Dimension, "for a f.p. Lie algebra", true, [ IsLieAlgebra and IsSubalgebraFpAlgebra], 0, function( L ) local h; h:= NiceAlgebraMonomorphism( L ); if h <> fail then return Dimension( Range( h ) ); else TryNextMethod(); fi; end); ############################################################################## ## #M IsFiniteDimensional( ) ## ## For finitely-presented Lie algebras. ## InstallMethod( IsFiniteDimensional, "for a f.p. Lie algebra", true, [ IsLieAlgebra and IsSubalgebraFpAlgebra], 0, function( L ) local h; h:= NiceAlgebraMonomorphism( L ); if h <> fail then return Dimension( Range( h ) ) < infinity; else TryNextMethod(); fi; end); ############################################################################## ## ## FpLieAlgebraEnumeration( ) Juergen Wisliceny ## Willem de Graaf ## ## This function calculates a homomorphism of a finitely presented ## Lie algebra onto a structure constants algebra. ## The algorithm is guaranteed to terminate when the algebra is finite ## dimensional. In full length the list contains `FpL', a ## finitely presented Lie algebra, `MAX_WEIGHT', a bound on the length ## of the monomials (used for nilpotent quotients), `weights' (a list ## of weights of the variables) and finally a boolean indicating ## whether the relations are homogeneous (if so then the nilpotent ## quotient will be graded, the grading is set as an attribute of the ## range of the homomorphism). ## ## By a straightforward application of the Jacobi identity (see also the ## comments to the sub-function `LeftNormalization'), it can be seen that ## the space of all commutators of degree `n' is spanned by all left ## normed commutators (i.e., commutators of the form [[[[a,b],c],d]...]). ## By antisymmetry we have that a and b can be chosen such that a > b. ## This is the format for elements of the free Lie algebra used in the ## program. A left-normed commutator is represented by a list ## `[a,b,c,d,..]', meaning `[[[[a,b],c],d]...]'. A monomial is such a list ## together with a coefficient, e.g., `[ [a,b,c,d..], -2/3 ]'. Finally, a ## polynomial is a list of monomials. InstallGlobalFunction( FpLieAlgebraEnumeration, function( arg ) local ReductionModuloTable, # LeftNormalization, # SubsVarInRels, # CollectPolynomial, # Sub-functions. UpdateTable, # RemoveComm, # RemoveEntry, # SubstituteVariable, # Dcopy, # gradorder, # grado, # vg, # List of pairs (newly defined commutators) i,j,k,l,s, # Loop variables. end_reached, # table_init, # Booleans relation_found, # u,v,rr, # Lists of relations. r,u1,r1,r2,k1,k2,k11, # Polynomials, monomials etc. S,_T, # Structure constants tables. rowS, # A row of the multiplication table. sij,tij, # Entries of the multiplication table. inds, # Indices (list of integers). tab_pols, # List of polynomials of degree two. intrel, # Initial relations (after first conversion). pp, # Ext rep of a polynomial. cf, # Coefficient. t1,t2, # Indices. max, # Maximum. R, # Lists of commtators that have been defined. Rw1, # A new roe of `R'. one, # One of the field. zero, # Zero of the field. d, # maximum of the list of (pseudo-)generators e, # Flat(e) is the list of (pseudo-)generators w,ww, # Weights. temp, defs, # Definitions of generators in terms of other # generators. FL, # The free Lie algebra. rels, # Relators. bound, # Bound for `w'. gens, # Generators of `FpL'. imgs, # Images. map, # The map that is constructed. im, # An image. Fam, # Elements family of `FpL'. K, # Structure constants algebra. FpL,wts,wght,pos,fle,weight,MAX_WEIGHT,genweights,comp_grad,is_hom, bas,gradcomps,degs,bgc; FpL:= arg[1]; if Length( arg ) >= 2 then MAX_WEIGHT:= arg[2]; else MAX_WEIGHT:= infinity; fi; Fam:= ElementsFamily( FamilyObj( FpL ) ); FL:= Fam!.freeAlgebra; rels:= Fam!.relators; if Length( arg ) >= 3 then genweights:= arg[3]; else genweights:= List( GeneratorsOfAlgebra( FL ), x -> 1 ); fi; if Length( arg ) = 4 then is_hom:= arg[4]; else is_hom:= false; fi; bound:= infinity; _T:=[]; one:= One( LeftActingDomain( FL ) ); zero:= Zero( LeftActingDomain( FL ) ); # Some small functions..... Dcopy:= function( l ) # Deep copying, also copying the holes... local m,i; if not IsList(l) then return ShallowCopy(l); fi; m:=[]; for i in [1..Length(l)] do if IsBound(l[i]) then m[i]:= Dcopy(l[i]); fi; od; return m; end; ############################################################## ############################################################## # v, w are associative monomials. is v>w? ## ## v > w if and only if 1) Length(v)>Length(w) or ## 2) Length(v)=Length(w) and Length(v) > 1 and ## v[2] > w[2] or ## 3) Length(v)=Length(w) and v[2]=w[2] and ## v>w alphabetically. ## gradorder:=function(v,w) local k,l; k:=Length(v[1]); l:=Length(w[1]); if k<>l then return k>l; elif k>1 and v[1][2]<>w[1][2] then return v[1][2]>w[1][2]; else return v>w; fi; end; grado:= function( v, w ) # tries to mimic gradorder for monomials of deg 2. if v[2]<>w[2] then return v[2]>w[2]; else return v>w; fi; end; ######################################################################## CollectPolynomial:= function( r ) # A function that collects equal things together, and gets rid of # things in the polynomial r that are zero. local i,n,t; if r <> [ ] then # first regularize... for i in r do if Length(i[1])>1 and i[1][1]1 and r[i][1][1]=r[i][1][2]) then #the thing is zero; get rid of it. Unbind(r[i]); elif r[i][1] = r[i+1][1] then #the monomials are equal; collect them together. r[i+1][2]:=r[i][2]+r[i+1][2]; Unbind(r[i]); fi; od; if r[n][2]=0*r[n][2] or (Length(r[n][1])>1 and r[n][1][1]=r[n][1][2]) then #the thing is zero; get rid of it. Unbind(r[n]); fi; r:= Filtered( r, x -> IsBound(x) ); fi; return r; end; ReductionModuloTable := function( k ) # In this function a Lie polynomial `k' in standard form is # reduced by one step modulo the commutators already known by the # table. So if [x_i,x_j]= c*z is a relation in the table, and `k' # contains a monomial of the form [ [i,j,k,....], cf ] then this # monomial is replaced by [ [z,k,...], -c*cf ] local i,j,k1,l,m,tst,t,s,cf,p,q,a; a:= Dcopy( k ); for i in [1..Length(a)] do l:=Length(a[i][1]); if l>1 then s:= a[i][1][1]; t:=a[i][1][2]; if s < t then p:= t; q:= s; else p:=s; q:=t; fi; if IsBound( _T[p] ) and IsBound( _T[p][q] ) then k1:= [ ]; tst:= _T[p][q]; if s <> p then cf:= -1; else cf:= 1; fi; for j in [1..Length(tst[1])] do Add( k1, [[tst[1][j]], cf*a[i][2]*tst[2][j]] ); od; if l>2 then m:=a[i][1]{[3..l]}; for j in [1..Length(k1)] do Append(k1[j][1],m); od; fi; Unbind(a[i]); Append(a,k1); fi; fi; od; a:=Filtered(a,x -> IsBound(x)); a:= CollectPolynomial( a ); if a = [ ] or a[1][2] = one then return a; else cf:= 1/a[1][2]; return List( a, x -> [x[1],x[2]*cf] ); fi; end; LeftNormalization:= function( rel ) # a left-normed monomial is of the form # # [a,b,c,d,e,...], meaning [[[[[a,b],c],d],e],...] # # Using the Jacobi identity every commutator can be represented # as a linear combination of left-normed commutators. # # In this function a polynomial `rel' is left normed. # The Jacobi identity is applied successively to achieve this. # This means that an expression of the form # # [a,b,c,[d,e],f] (where a,b,c are generators (this part is already # `done') and [d,e] is any bracketed expression having d and e as # left and right subtrees, # # to a sum # # [a,b,c,d,e,f] - [a,b,c,e,d,f]. # # Justification: # # [a,b,c,[d,e]]=[[[a,b],c],[d,e]] = [X,[d,e]] (with X=[[a,b],c]) # =-[d,[e,X]]-[e,[X,d]] # =[[e,X],d]+[[X,d],e] # =-[[X,e],d]+[[X,d],e]. # local i,j,s,s1,s2,t,step_occurred; step_occurred:= true; while step_occurred do # if there no longer occur any Jacobi steps, then we stop. i:=0; step_occurred:= false; while i < Length( rel ) do i:=i+1; j:=0; while j [x,y,b]). if j>1 then Add(rel,[s2,-rel[i][2]]); fi; fi; od; od; od; return rel; end; SubsVarInRels:= function( rels, rs ) # Here `rs' is a relation of the form `var = othervars', and `rels' is # a list of Lie polynomials. This function substitutes `var' # everywhere in the polynomials `rels'. local i,j,p,s,s1,s2,result,rel,cf; result:= [ ]; for rel in rels do i:= 1; while i <= Length(rel) do p:= Position( rel[i][1], rs[1][1][1] ); if p <> fail then # s will be the polynomial that is gotten from r by substituting # `the rest of rs' for the variable rs[1][1][1] on the position p # in r. s:= Dcopy( rs{[2..Length(rs)]} ); s1:= rel[i][1]{[1..p-1]}; s2:= rel[i][1]{[p+1..Length(rel[i][1])]}; for j in [1..Length(s)] do s[j][1]:=Concatenation(s1,s[j][1],s2); od; s:= List( s, x -> [ x[1], -rel[i][2]*x[2] ] ); Append( rel, s ); Unbind( rel[i] ); rel:= Filtered( rel, x -> IsBound( x ) ); else i:= i+1; fi; od; #collect the result... rel:= CollectPolynomial( rel ); if rel <> [ ] and rel[1][2] <> one then cf:= 1/rel[1][2]; rel:= List( rel, x -> [x[1],cf*x[2]] ); fi; if rel <> [ ] then AddSet( result, rel ); fi; od; return result; end; UpdateTable:= function( i, j, p ) # Sets the commutator [xi,xj] in the table equal to the polynomial `p'. local inds,cfs,k,s,t; inds:=[]; cfs:=[]; for k in [1..Length(p)] do inds[k]:= p[k][1][1]; cfs[k]:= p[k][2]; od; if i < j then s:= j; t:= i; else s:=i; t:= j; fi; if s = i then cfs:= -cfs; fi; if not IsBound(_T[s]) then _T[s]:=[]; fi; _T[s][t]:= [inds,cfs]; end; RemoveEntry:= function( k ) # Removes all occurences of the variable xk in the commutators # of the table. local i; Unbind(_T[k]); for i in [1..Length(_T)] do if IsBound( _T[i] ) then Unbind(_T[i][k]); fi; od; end; RemoveComm:= function( k, l ) # Removes the commutator [xk,xl] from the table. local s,t; s:= Maximum( k, l ); t:= Minimum( k, l ); if IsBound(_T[s][t]) then Unbind(_T[s][t]); fi; end; SubstituteVariable:= function( coms, rel ) # Here `rel' is a polynomial of the form `var = othervars'; this # function substitutes `var' for `othervar' in the commutators of # the table prescribed by `coms'. local var,inds,i,cfs,c,Tij,pos,cf,ii,cc,ind,s,t; var := rel[1][1][1]; inds:= [ ]; cfs:= [ ]; for i in [2..Length(rel)] do Add( inds, rel[i][1][1] ); Add( cfs, -rel[i][2] ); od; cfs:= cfs/rel[1][2]; for c in coms do s:= Maximum( c ); t:= Minimum( c ); Tij:= _T[s][t]; pos:= Position( Tij[1], var ); if pos <> fail then Unbind( Tij[1][pos] ); cf:= Tij[2][pos]; if s <> c[1] then cf:= -cf; fi; Unbind( Tij[2][pos] ); Tij[1]:= Filtered( Tij[1], x -> IsBound(x) ); Tij[2]:= Filtered( Tij[2], x -> IsBound(x) ); Append( Tij[1], inds ); Append( Tij[2], cf*cfs ); ii:= [ ]; cc:= [ ]; if Tij[1] <> [ ] then SortParallel( Tij[1], Tij[2] ); ind:= Tij[1][1]; cf:= Tij[2][1]; ii:= [ ]; cc:= [ ]; for i in [2..Length(Tij[1])] do if Tij[1][i] = ind then cf:= Tij[2][i] + cf; else Add( ii, ind ); Add( cc, cf ); ind:= Tij[1][i]; cf:= Tij[2][i]; fi; od; Add( ii, ind ); Add( cc, cf ); fi; _T[s][t]:= [ ii, cc ]; fi; od; end; wght:= function( e, wts, var ) local p,q; p:= PositionProperty( e, x -> var in x ); q:= Position( e[p], var ); return wts[p][q]; end; ############################################################################## # # The program starts. First the relations are transformed into internal format. # That is: represented as lists of lists etc., and left-normalized. # # `intrel' will be the set of relations, but represented in # `internal form'; meaning [ [ [[1,2],3], 1 ], [[4],-1] ], instead # of (x1*x2)*x3-x4 etc. intrel:= [ ]; for r in rels do pp:= Dcopy( ExtRepOfObj( r )[2] ); Add( intrel, List( [1,3..Length(pp)-1], x -> [ pp[x], pp[x+1] ] ) ); od; ############################################################################# # now we left normalize the relations, using `LeftNormalization', i.e., # the relations are written as [ [ [1,2,5], -1], [.....], [......],.... ] # furthermore, all relations of degree at most two will go into `pr' # (those will be used to initialize the table). All the others go into # `u'. tab_pols:= [ ]; u:= [ ]; for r in intrel do max:= 0; for j in [1..Length(r)] do if not IsList(r[j][1]) then #transform [ i, cst ] into [ [i], cst ] r[j][1]:= [ r[j][1] ]; fi; if Length(Flat(r[j][1])) >= 2 and r[j][1][1]=r[j][1][2] then Unbind(r[j]); else max:= Maximum( max, Length( Flat(r[j][1]) ) ); fi; od; r:= Filtered( r, x -> IsBound(x) ); r:= LeftNormalization( r ); r:= CollectPolynomial( r ); if not max = 0 then if max <= 2 then cf:= 1/r[1][2]; r:= List( r, x -> [x[1],cf*x[2]] ); Add( tab_pols, r); # So if the relation only # involves monomials of deg # at most two, then this relation # goes into the 'tab_pols'. else Add( u, r ); fi; fi; od; e:= [ List( [1..Length( GeneratorsOfAlgebra( FL ) )], x -> x ), [ ] ]; if MAX_WEIGHT < infinity then wts:= [ genweights, [] ]; comp_grad:= true; else wts:= [ ]; comp_grad:= false; fi; if e[1] = [ ] then K:= LieAlgebraByStructureConstants( LeftActingDomain( FL ), EmptySCTable( 0, zero, "antisymmetric" ) ); gens:= GeneratorsOfAlgebra( FpL ); imgs:= List( gens, x -> Zero( K ) ); map:= Objectify( TypeOfDefaultGeneralMapping( FpL, K, IsSPGeneralMapping and IsAlgebraGeneralMapping and IsFptoSCAMorphism and IsAlgebraGeneralMappingByImagesDefaultRep ), rec( generators := gens, genimages := imgs ) ); SetMappingGeneratorsImages(map,[Immutable(gens),Immutable(imgs)]); return map; fi; # `v' will be a history of relations, i.e., `v[w]' will be the relations # as they were when the program was dealing with weight `w'. This is # used to reset the relations if a collision among variables is found. v:= [ Dcopy( u ) ]; d:= Maximum( e[1] ); R:= [ [], [] ]; end_reached:= false; w:= 0; defs:= [ ]; while w < bound do table_init:= false; while not table_init do ####################################################################### # Initialize the table.... # Meaning: fill in all possible commutators of generators using the # relations, make definitions for the commutators that cannot be decided # upon by using the relations. If this leads to a relation among the variables, # then that relation is substituted first, and the process is started all # over again. relation_found:= false; for r in tab_pols do r1:= ReductionModuloTable( r ); if r1<>[] then if Length(r1[1][1])=1 then relation_found:= true; break; else for k in [2..Length(r1)] do if Length(r1[k][1])=2 then d:=d+1; Add(e[2],d); if comp_grad then Add(wts[2],wght(e,wts,r1[k][1][1])+ wght(e,wts,r1[k][1][2]) ); fi; UpdateTable( r1[k][1][1], r1[k][1][2], [ [[d],-one] ] ); Add(R[2],r1[k][1]); r1[k][1]:=[d]; fi; od; UpdateTable( r1[1][1][1], r1[1][1][2], r1{[2..Length(r1)]} ); fi; Add(R[2],r1[1][1]); fi; od; if not relation_found then # i.e., the previous loop has been executed without breaking # caused by finding a relation among the generators. vg:=Difference( List( Combinations(e[1],2), x -> Reversed(x) ), R[2] ); Append( R[2], vg ); for i in [1..Length(vg)] do d:=d+1; Add(e[2],d); if comp_grad then Add(wts[2],wght(e,wts,vg[i][1])+wght(e,wts,vg[i][2])); fi; UpdateTable( vg[i][1], vg[i][2], [ [[d],-one] ] ); od; rr:= [ ]; for i in [1..Length(u)] do r:= Dcopy( u[i] ); while true do r1:= ReductionModuloTable( r ); if r1 = r then break; else r:= r1; fi; od; if r <> [ ] then if Length(r[1][1]) = 1 and r[1][1][1] in e[1] then relation_found:= true; break; else Add( rr, r ); fi; fi; od; fi; if relation_found then # i.e., a relation among the variables has been found in the # previous piece of code. w:= Position( List( e, x -> r1[1][1][1] in x ), true ); if w = 1 then if comp_grad then pos:= Position( e[1], r1[1][1][1] ); Remove( wts[1], pos ); Remove( e[1], pos); else RemoveSet( e[1], r1[1][1][1] ); fi; Add( defs, r1 ); if e[1] = [ ] then K:= LieAlgebraByStructureConstants( LeftActingDomain( FL ), EmptySCTable( 0, zero, "antisymmetric" ) ); gens:= GeneratorsOfAlgebra( FpL ); imgs:= List( gens, x -> Zero( K ) ); map:= Objectify( TypeOfDefaultGeneralMapping( FpL, K, IsSPGeneralMapping and IsAlgebraGeneralMapping and IsFptoSCAMorphism and IsAlgebraGeneralMappingByImagesDefaultRep ), rec( generators := gens, genimages := imgs ) ); SetMappingGeneratorsImages(map,[Immutable(gens),Immutable(imgs)]); return map; fi; e[2]:= [ ]; if comp_grad then wts[2]:= [ ]; fi; tab_pols:= SubsVarInRels( tab_pols, r1 ); u:= SubsVarInRels( u, r1 ); _T:= [ ]; R:= [ [], [] ]; else if comp_grad then pos:= Position( e[w], r1[1][1][1] ); Remove( wts[w], pos ); Remove( e[w], pos); else RemoveSet( e[w], r1[1][1][1]); fi; u:= SubsVarInRels( v[w-1], r1 ); SubstituteVariable( R[w], r1 ); fi; else u:= rr; table_init:= true; fi; od; ########################################################################## # # The table has been initialized, and the commutators of weight 2 # have been defined. Now the process of increasing the weight starts. # w:=1; while w < bound do w:=w+1; Sort( R[w], grado ); if comp_grad then fle:= Flat(e); for i in [1..Length(fle)] do for j in [i+1..Length(fle)] do if wght(e,wts,fle[i])+wght(e,wts,fle[j])>MAX_WEIGHT then UpdateTable( fle[i], fle[j], [] ); fi; od; od; fi; ############################################################################# # reduction modulo relations and Jacobi identity.... # # In this function also _T is changed; but if the function # exits with a relation among the vars, then we change `_T' back to its # old value (the copy `S'). # S:= Dcopy( _T ); rr:= Dcopy( u ); Rw1:= [ ]; e[w+1]:= [ ]; if comp_grad then wts[w+1]:= [ ]; fi; d:= Maximum( Flat( e ) ); relation_found:= false; for r in R[w] do t1:=r[1]; t2:=r[2]; if t1 > t2 then tij:= _T[t1][t2]; else tij:= ShallowCopy( _T[t2][t1] ); tij[2]:= -ShallowCopy( tij[2] ); fi; r1:= List( [1..Length(tij[1])], k -> [ [tij[1][k]], tij[2][k] ] ); for j in e[1] do # The Jacobi identity that will be inspected reads as # [ [ t1, t2 ], j ] - [ [ t1, j ], t2 ] + [ [ t2, j ], t1 ] = 0 # This relation can be evaluated (using the partial table) to a # polynomial of degree <=2. This will lead to new definitions # (in the case of deg. = 2), or collisions (in the case of # deg. = 1). if t2 > j then if t1 > j then tij:= _T[t1][j]; else tij:= ShallowCopy( _T[j][t1] ); tij[2]:= -ShallowCopy( tij[2] ); fi; k1:= List( [1..Length(tij[1])], i->[ [tij[1][i],t2],-tij[2][i] ]); if t2 > j then tij:= _T[t2][j]; else tij:= ShallowCopy( _T[j][t2] ); tij[2]:= -ShallowCopy( tij[2] ); fi; k2:= List( [1..Length(tij[1])], i->[ [tij[1][i],t1],tij[2][i] ]); r2:= Dcopy(r1); for i in r2 do Add( i[1], j ); od; k:= Concatenation( k1, k2, r2 ); k:= CollectPolynomial( k ); k:= ReductionModuloTable( k ); if k <> [ ] then # Produce a relation of the form a = c1*var1+c2*var2... # by making new definitions. (Where a is either a commutator # or a variable). i:= 2; while i <= Length( k ) do if Length(k[i][1]) = 2 then if comp_grad then weight:= wght(e,wts,k[i][1][1])+ wght(e,wts,k[i][1][2]); else weight:= 0; fi; if weight <= MAX_WEIGHT then if comp_grad then Add( wts[w+1], weight ); fi; d:= d+1; Add( e[w+1], d ); UpdateTable( k[i][1][1], k[i][1][2], [ [[d],-one] ] ); Add( Rw1, k[i][1] ); k[i][1]:= [ d ]; else Remove( k, i ); fi; fi; i:= i+1; od; k11:= k[1][1]; if Length(k11) = 2 then # The `a' in the comment above is a commutator; hence a new # entry for the table has been found. UpdateTable( k11[1], k11[2], k{[2..Length(k)]} ); Add( Rw1, k11 ); elif Length(k11) = 1 then ww:= 0; for i in [1..Length(e)] do if k11[1] in e[i] then ww:=i; break; fi; od; if ww = w+1 then # A collision (among the new basis elements) has been found. if comp_grad then pos:= Position( e[w+1], k11[1] ); Remove( wts[w+1], pos ); fi; RemoveSet( e[w+1], k11[1] ); RemoveEntry( k11[1] ); SubstituteVariable( Rw1, k ); rr:= SubsVarInRels( rr, k ); elif ww > 0 then _T:=S; relation_found:= true; r1:= [ ww, k ]; break; fi; fi; i:= 0; while i < Length(rr) do i:= i+1; # Reduce the relations modulo the table and process them. while true do u1:= ReductionModuloTable( rr[i] ); if u1 = rr[i] then break; else rr[i]:=u1; fi; od; if rr[i]=[] then Unbind( rr[i] ); elif Length(rr[i][1][1])=1 then ww:= 0; temp:= rr[i][1][1][1]; for l in [1..Length(e)] do if temp in e[l] then ww:=l; break; fi; od; if ww = w+1 then if comp_grad then pos:= Position( e[w+1],rr[i][1][1][1] ); Remove( wts[w+1], pos ); fi; RemoveSet(e[w+1],rr[i][1][1][1]); RemoveEntry(rr[i][1][1][1]); SubstituteVariable( Rw1, rr[i] ); temp:= rr[i]; Remove( rr, i ); rr:= SubsVarInRels( rr, temp ); i:= i-1; # (last call removed holes...). elif ww > 0 then _T:=S; relation_found:= true; r1:= [ww,rr[i]]; break; fi; elif Length(rr[i][1][1])=2 then max := 0; for s in rr[i] do ww:= 0; for l in [1..Length(e)] do if s[1][1] in e[l] then ww:=l; break; fi; od; if Length(s[1]) = 1 then max:= Maximum(max,ww); else # We calculate the weight of `s[1][1]' + the weight # of `s[1][2]' i.e., the weight of `[s[1][1], s[1][2]]' for l in [1..Length(e)] do if s[1][2] in e[l] then ww:=ww+l; break; fi; od; max:= Maximum(max,ww); fi; od; if max = w+1 then s:= 2; while s <= Length( rr[i] ) do if Length(rr[i][s][1]) = 2 then if wts <> [ ] then weight:= wght(e,wts,rr[i][s][1][1])+ wght(e,wts,rr[i][s][1][2] ); else weight:= 0; fi; if weight <= MAX_WEIGHT then d:= d+1; Add( e[w+1], d ); if wts <> [ ] then Add( wts[w+1], weight ); fi; UpdateTable( rr[i][s][1][1], rr[i][s][1][2], [ [[d], -one] ] ); Add(Rw1,rr[i][s][1]); rr[i][s][1]:= [ d ]; else Remove( rr[i], s ); fi; fi; s:= s+1; od; Add(Rw1,rr[i][1][1]); UpdateTable( rr[i][1][1][1], rr[i][1][1][2], rr[i]{[2..Length(rr[i])]}); Unbind(rr[i]); fi; fi; od; if relation_found then break; fi; rr:=Filtered(rr,x -> IsBound(x)); fi; fi; od; if relation_found then break; fi; od; ########################################################################## if relation_found then # Here `r1[2]' is a relation among basis elements. # `r1[1]' is the weight of the homogeneous component containing # the first variable (variable of highest weight). w:= r1[1]; if w = 1 then # A relation among the variables of weight 1 has been found. # We reset everything and return to the point where the table # is initialized. if comp_grad then pos:= Position( e[1], r1[2][1][1][1] ); Remove( wts[1], pos ); fi; RemoveSet( e[1], r1[2][1][1][1] ); Add( defs, r1[2] ); if e[1]=[] then K:= LieAlgebraByStructureConstants( LeftActingDomain( FL ), EmptySCTable( 0, zero, "antisymmetric" ) ); gens:= GeneratorsOfAlgebra( FpL ); imgs:= List( gens, x -> Zero( K ) ); map:= Objectify( TypeOfDefaultGeneralMapping( FpL, K, IsSPGeneralMapping and IsAlgebraGeneralMapping and IsFptoSCAMorphism and IsAlgebraGeneralMappingByImagesDefaultRep ), rec( generators := gens, genimages := imgs ) ); SetMappingGeneratorsImages(map,[Immutable(gens),Immutable(imgs)]); return map; fi; e:=[ e[1], [] ]; if comp_grad then wts:= [ wts[1], [] ]; fi; u:= SubsVarInRels( v[1], r1[2] ); tab_pols:= SubsVarInRels( tab_pols, r1[2] ); _T:=[]; R:=[ [ ], List( tab_pols, x -> x[1][1] ) ]; v[1]:= Dcopy( u ); # We break to the principal loop. break; else # here `r1[2]' is of the form `var=something' where `var' is of weight # `w', and `w>1'. This means that `var' was introduced somewhere; namely # on level `w'. Hence the definition was [x_i,x_j]=var, where w(x_i)+ # w(x_j)=w. Hence `var' only appears in tails (right hand sides) of commutators # of weight `>= w'. Now `var' is substituted in all products of weight `w', # and the program starts again on that level. if comp_grad then pos:= Position( e[w], r1[2][1][1][1] ); Remove( wts[w], pos ); fi; RemoveSet(e[w], r1[2][1][1][1]); u:= SubsVarInRels( v[w-1], r1[2]); v[w-1]:=u; w:= w-1; SubstituteVariable( R[w+1], r1[2] ); for i in [w+2..Length(e)] do e[i]:=[]; od; for i in [w+2..Length(R)] do for j in [1..Length(R[i])] do RemoveComm( R[i][j][1], R[i][j][2] ); od; R[i]:= [ ]; od; fi; else # Here Jacobi identities have been applied # without finding collisions between variables. if e[w] = [ ] and not end_reached then bound:= 2*w; end_reached:= true; elif w = bound and not end_reached then return fail; fi; R[w+1]:= Rw1; v[w]:= rr; u:= rr; if Flat( e ) = [ ] then K:= LieAlgebraByStructureConstants( LeftActingDomain( FL ), EmptySCTable( 0, zero, "antisymmetric" ) ); gens:= GeneratorsOfAlgebra( FpL ); imgs:= List( gens, x -> Zero( K ) ); map:= Objectify( TypeOfDefaultGeneralMapping( FpL, K, IsSPGeneralMapping and IsAlgebraGeneralMapping and IsFptoSCAMorphism and IsAlgebraGeneralMappingByImagesDefaultRep ), rec( generators := gens, genimages := imgs ) ); SetMappingGeneratorsImages(map,[Immutable(gens),Immutable(imgs)]); return map; fi; d:= Maximum( Flat( e ) ); vg:= [ ]; for i in e[w] do for j in e[1] do if i>j then AddSet( vg, [i,j] ); fi; od; od; vg:= Difference( vg, R[w+1] ); Append( R[w+1], vg ); for i in [1..Length(vg)] do if comp_grad then weight:= wght(e,wts,vg[i][1])+wght(e,wts,vg[i][2]); else weight:= 0; fi; if weight <= MAX_WEIGHT then d:= d+1; Add( e[w+1], d ); if comp_grad then Add( wts[w+1], weight ); fi; Add( R[w+1], vg[i] ); UpdateTable( vg[i][1], vg[i][2], [ [[d],-1*one] ]); else UpdateTable( vg[i][1], vg[i][2], [ ] ); fi; od; fi; od; # end of the loop in which `w' is successively increased. od; # end of the main loop, # Now we construct a table of structure constants from `_T'. e:=Filtered(e,x->x<>[]); inds:=Flat(e); S:=[]; for i in inds do rowS:= [ ]; for j in inds do if i=j then Add( rowS, [ [], [] ] ); else if i < j then tij:= ShallowCopy( _T[j][i] ); tij[2]:= -ShallowCopy( tij[2] ); else tij:= _T[i][j]; fi; sij:=[[],[]]; for k in [1..Length(tij[1])] do sij[1][k]:= Position( inds, tij[1][k] ); sij[2][k]:= tij[2][k]; od; Add( rowS, sij ); fi; od; Add( S, rowS ); od; Add( S, -1 ); Add( S, zero ); K:= LieAlgebraByStructureConstants( LeftActingDomain( FL ), S ); if is_hom then wts:= Flat( wts ); bas:= [1..Dimension(K)]; SortParallel( wts, bas ); gradcomps:= [ ]; degs:= [ ]; k:= 1; while k <= Length(wts) do bgc:= [ Basis( K )[bas[k]] ]; Add( degs, wts[k] ); while k < Length( wts ) and wts[k]=wts[k+1] do k:= k+1; Add( bgc, Basis(K)[bas[k]] ); od; Add( gradcomps, VectorSpace( LeftActingDomain( K ), bgc ) ); k:= k+1; od; Add( gradcomps, Subspace( K, [ ] ) ); SetGrading( K, rec( min_degree:= Minimum( wts ), max_degree:= Maximum( wts ), source:= Integers, hom_components:= function( d ) if d in degs then return gradcomps[Position(degs,d)]; else return gradcomps[Length(gradcomps)]; fi; end ) ); fi; gens:= GeneratorsOfAlgebra( FpL ); if Dimension( K ) = 0 then #trivial case imgs:= List( gens, x -> Zero(K) ); else # We process the definitions, (of generators as linear combinations # of other generators). i:= Length( defs ); while i > 1 do for j in [1..i-1] do for k in [1..Length(defs[j])] do if defs[j][k][1] = defs[i][1][1] then Append( defs[j], List( defs[i]{[2..Length(defs[i])]}, x -> [ x[1], -defs[j][k][2]*x[2] ] ) ); Unbind( defs[j][k] ); fi; od; defs[j]:= Filtered( defs[j], x -> IsBound( x ) ); od; i:= i-1; od; imgs:= [ ]; #For every generator of the Fp Lie algebra we calculate an image... for i in [1..Length(gens)] do if i in e[1] then Add( imgs, Basis( K )[Position( inds, i )] ); else for j in [1..Length(defs)] do if defs[j][1][1][1] = i then break; fi; od; im:= Zero( K ); for k in [2..Length(defs[j])] do im:= im + -defs[j][k][2]*Basis( K )[defs[j][k][1][1]]; od; Add (imgs, im ); fi; od; fi; # Construct the map... map:= Objectify( TypeOfDefaultGeneralMapping( FpL, K, IsSPGeneralMapping and IsAlgebraGeneralMapping and IsFptoSCAMorphism and IsAlgebraGeneralMappingByImagesDefaultRep ), rec( generators := gens, genimages := imgs ) ); SetMappingGeneratorsImages(map,[Immutable(gens),Immutable(imgs)]); return map; end ); InstallMethod( NiceAlgebraMonomorphism, "for a f.p. Lie algebra", true, [ IsLieAlgebra and IsSubalgebraFpAlgebra], 0, function( FpL ) return FpLieAlgebraEnumeration( FpL ); end ); InstallGlobalFunction( NilpotentQuotientOfFpLieAlgebra, function( arg ) local FpL,L,weights,is_homogeneous,rels,weight,w,r,k,j,er,fol,maxw,N; # unwrapping the arguments... if Length( arg ) = 2 then FpL:= arg[1]; maxw:= arg[2]; L:= ElementsFamily( FamilyObj( FpL ) )!.freeAlgebra; weights:= List( GeneratorsOfAlgebra( L ), x -> 1 ); elif Length( arg ) = 3 then FpL:= arg[1]; maxw:= arg[2]; weights:= arg[3]; else Error("Number of arguments must be two or three"); fi; # checking whether the relations are homogeneous; if so then # the resulting structure constants Lie algebra will have a # natural grading. is_homogeneous:= true; rels:= ElementsFamily( FamilyObj( FpL ) )!.relators; for r in rels do weight:= infinity; er:= ExtRepOfObj( r )[2]; for k in [1,3..Length(er)-1] do fol:= Flat( [ er[k] ] ); w:= 0; for j in fol do w:= w+weights[j]; od; if weight = infinity then weight:= w; elif weight <> w then is_homogeneous:= false; break; fi; od; if not is_homogeneous then break; fi; od; N:= FpLieAlgebraEnumeration( FpL, maxw, weights, is_homogeneous ); SetIsLieNilpotent( Range(N), true ); return N; end ); ############################################################################## ## #F FpLieAlgebraByCartanMatrix( ) ## ## InstallGlobalFunction( FpLieAlgebraByCartanMatrix, function( C ) local i,j,k, # Loop variables. l, # The rank. L, # The free Lie algebra. g, # Generators of `L'. x,h,y, # Lists of generators of `L'. rels, # List of relations. rx,ry; # Relations. l:= Length( C ); L:= FreeLieAlgebra( Rationals, 3*l ); g:= GeneratorsOfAlgebra( L ); x:= g{[1..l]}; h:= g{[l+1..2*l]}; y:= g{[2*l+1..3*l]}; rels:= [ ]; for i in [1..l] do for j in [i+1..l] do Add( rels, h[i]*h[j] ); od; od; for i in [1..l] do for j in [1..l] do if i=j then Add( rels, x[i]*y[j]-h[i] ); else Add( rels, x[i]*y[j] ); fi; od; od; for i in [1..l] do for j in [1..l] do Add( rels, h[i]*x[j]-C[j][i]*x[j] ); Add( rels, h[i]*y[j]+C[j][i]*y[j] ); od; od; for i in [1..l] do for j in [1..l] do if i <> j then rx:= x[j]; ry:= y[j]; for k in [1..1-C[j][i]] do rx:= x[i]*rx; ry:= y[i]*ry; od; Add( rels, rx ); Add( rels, ry ); fi; od; od; return L/rels; end ); ############################################################################# ## #M JenningsLieAlgebra( ) ## ## The Jennings Lie algebra of the p-group G. ## ## InstallMethod( JenningsLieAlgebra, "for a p-group", true, [IsGroup], 0, function ( G ) local J, # Jennings series of G Homs, # Homomorphisms of J[i] onto the quotient J[i]/J[i+1] grades, # List of the full images of the maps in Homs gens, # List of the generators of the quotients J[i]/J[i+1], # i.e., a basis of the Lie algebra. pos, # list of positions: if pos[j] = p, then the element # gens[j] belongs to grades[p] i,j,k, # loop variables tempgens, t, # integer T, # multiplication table of the Lie algebra dim, # dimension of the Lie algebra a,b,c,f, # group elements e, # ext rep of a group element co, # entry of the multiplication table p, # the prime of G F, # ground field L, # the Lie algebra to be constructed pimgs, # pth-power images B, # Basis of L vv, x, # elements of L comp, # homogeneous component grading, # list of homogeneous components pcgps, # list of pc groups, isom to the elts of `grades'. hom_pcg, # list of isomomorphisms of `grades[i]' to `pcgps[i]'. enum_gens, # List of numbers of elts of `gens' in extrep. pp, # Position in a list. hm; # We do not know the characteristic if `G' is trivial. if IsTrivial( G ) then Error( " must be a nontrivial p-group" ); fi; # Construct the homogeneous components of `L': J:=JenningsSeries ( G ); Homs:= List ( [1..Length(J)-1] , x -> NaturalHomomorphismByNormalSubgroupNC( J[x], J[x+1] )); grades := List ( Homs , Range ); hom_pcg:= List( grades, IsomorphismSpecialPcGroup ); pcgps:= List( hom_pcg, Range ); gens := []; enum_gens:= [ ]; pos := []; for i in [1.. Length(grades)] do tempgens:= GeneratorsOfGroup( pcgps[i] ); Append ( gens , tempgens); # Record the number that each generator has in extrep. Add( enum_gens, List( tempgens, x -> ExtRepOfObj( x )[1] ) ); Append ( pos , List ( tempgens , x-> i ) ); od; # Construct the field and the multiplication table: dim:= Length(gens); p:= PrimePGroup( G ); F:= GF( p ); T:= EmptySCTable( dim , Zero(F) , "antisymmetric" ); pimgs := []; for i in [1..dim] do a:= PreImagesRepresentative( Homs[pos[i]] , PreImagesRepresentative( hom_pcg[pos[i]], gens[i] ) ); # calculate the p-th power image of `a': if pos[i]*p <= Length(Homs) then Add( pimgs, Image( hom_pcg[pos[i]*p], Image( Homs[pos[i]*p], a^p) ) ); else Add( pimgs, "zero" ); fi; for j in [i+1.. dim] do if pos[i]+pos[j] <= Length( Homs ) then # Calculate the commutator [a,b], and map the result into # the correct homogeneous component. b:= PreImagesRepresentative( Homs[pos[j]], PreImagesRepresentative( hom_pcg[pos[j]], gens[j] )); c:= Image( hom_pcg[pos[i] + pos[j]], Image(Homs[pos[i] + pos[j]], a^-1*b^-1*a*b) ); e:= ExtRepOfObj(c); co:=[]; for k in [1,3..Length(e)-1] do pp:= Position( enum_gens[pos[i]+pos[j]], e[k] ); f:= GeneratorsOfGroup( pcgps[pos[i]+pos[j]] )[pp]; t:= Position( gens, f ); Add( co, One( F )*e[k+1] ); Add( co, t ); od; SetEntrySCTable( T, i, j, co ); fi; od; od; L:= LieAlgebraByStructureConstants( F, T ); B:= Basis( L ); # Now we compute the natural grading of `L'. grading:= [ ]; k:= 1; for i in [1..Length(enum_gens)] do comp:= [ ]; for j in [1..Length(enum_gens[i])] do Add( comp, B[k] ); k:= k+1; od; Add( grading, Subspace( L, comp ) ); od; Add( grading, Subspace( L, [ ] ) ); SetGrading( L, rec( min_degree:= 1, max_degree:= Length( grading ) - 1, source:= Integers, hom_components:= function( d ) if d in [1..Length(grading)] then return grading[d]; else return grading[Length(grading)]; fi; end ) ); vv:= BasisVectors( B ); # Set the pth-power images of the basis elements of `B': for i in [1..Length(pimgs)] do if pimgs[i] = "zero" then pimgs[i]:= Zero( L ); else e:= ExtRepOfObj( pimgs[i] ); x:= Zero( L ); for k in [1,3..Length(e)-1] do pp:= Position( enum_gens[pos[i]*p], e[k] ); f:= GeneratorsOfGroup( pcgps[pos[i]*p] )[pp]; t:= Position( gens, f ); x:= x+ One( F )*e[k+1]*vv[t]; od; pimgs[i]:= x; fi; od; SetPthPowerImages( B, pimgs ); SetIsRestrictedLieAlgebra( L, true ); FamilyObj(Representative(L))!.pMapping := pimgs; SetIsLieNilpotent( L, true ); hm:= function( g, i ) local h, e, x, k, pp, f, t; if not g in J[i] then Error(" is not an element of the i-th term of the series used to define "); fi; h:= Image( hom_pcg[i], Image(Homs[i], g )); e:= ExtRepOfObj(h); x:= Zero(L); for k in [1,3..Length(e)-1] do pp:= Position( enum_gens[i], e[k] ); f:= GeneratorsOfGroup( pcgps[i] )[pp]; t:= Position( gens, f ); x:= x + e[k+1]*Basis(L)[t]; od; return x; end ; SetNaturalHomomorphismOfLieAlgebraFromNilpotentGroup( L, hm ); return L; end ); ############################################################################# ## #M PCentralLieAlgebra( ) ## ## The p-central Lie algebra of the p-group G. ## ## InstallMethod( PCentralLieAlgebra, "for a p-group", true, [IsGroup], 0, function ( G ) local J, # p-central series of G Homs, # Homomorphisms of J[i] onto the quotient J[i]/J[i+1] grades, # List of the full images of the maps in Homs gens, # List of the generators of the quotients J[i]/J[i+1], # i.e., a basis of the Lie algebra. pos, # list of positions: if pos[j] = p, then the element # gens[j] belongs to grades[p] i,j,k, # loop variables tempgens, t, # integer T, # multiplication table of the Lie algebra dim, # dimension of the Lie algebra a,b,c,f, # group elements e, # ext rep of a group element co, # entry of the multiplication table p, # the prime of G F, # ground field L, # the Lie algebra to be constructed B, # Basis of L vv, x, # elements of L comp, # homogeneous component grading, # list of homogeneous components pcgps, # list of pc groups, isom to the elts of `grades'. hom_pcg, # list of isomomorphisms of `grades[i]' to `pcgps[i]'. enum_gens, # List of numbers of elts of `gens' in extrep. pp, # Position in a list. pimgs, # pth power images hm; # We do not know the characteristic if `G' is trivial. if IsTrivial( G ) then Error( " must be a nontrivial p-group" ); fi; # Construct the homogeneous components of `L': p:= PrimePGroup( G ); J:= PCentralSeries( G, p ); Homs:= List ( [1..Length(J)-1] , x -> NaturalHomomorphismByNormalSubgroupNC( J[x], J[x+1] )); grades := List ( Homs , Range ); hom_pcg:= List( grades, IsomorphismSpecialPcGroup ); pcgps:= List( hom_pcg, Range ); gens := []; enum_gens:= [ ]; pos := []; for i in [1.. Length(grades)] do tempgens:= GeneratorsOfGroup( pcgps[i] ); Append ( gens , tempgens); # Record the number that each generator has in extrep. Add( enum_gens, List( tempgens, x -> ExtRepOfObj( x )[1] ) ); Append ( pos , List ( tempgens , x-> i ) ); od; # Construct the field and the multiplication table: dim:= Length(gens); F:= GF( p ); T:= EmptySCTable( dim , Zero(F) , "antisymmetric" ); pimgs := []; for i in [1..dim] do a:= PreImagesRepresentative( Homs[pos[i]] , PreImagesRepresentative( hom_pcg[pos[i]], gens[i] ) ); # calculate the p-th power image of `a': if pos[i]+1 <= Length(Homs) then Add( pimgs, Image( hom_pcg[pos[i]+1], Image( Homs[pos[i]+1], a^p) ) ); else Add( pimgs, "zero" ); fi; for j in [i+1.. dim] do if pos[i]+pos[j] <= Length( Homs ) then # Calculate the commutator [a,b], and map the result into # the correct homogeneous component. b:= PreImagesRepresentative( Homs[pos[j]], PreImagesRepresentative( hom_pcg[pos[j]], gens[j] )); c:= Image( hom_pcg[pos[i] + pos[j]], Image(Homs[pos[i] + pos[j]], a^-1*b^-1*a*b) ); e:= ExtRepOfObj(c); co:=[]; for k in [1,3..Length(e)-1] do pp:= Position( enum_gens[pos[i]+pos[j]], e[k] ); f:= GeneratorsOfGroup( pcgps[pos[i]+pos[j]] )[pp]; t:= Position( gens, f ); Add( co, One( F )*e[k+1] ); Add( co, t ); od; SetEntrySCTable( T, i, j, co ); fi; od; od; L:= LieAlgebraByStructureConstants( F, T ); B:= Basis( L ); # Now we compute the natural grading of `L'. grading:= [ ]; k:= 1; for i in [1..Length(enum_gens)] do comp:= [ ]; for j in [1..Length(enum_gens[i])] do Add( comp, B[k] ); k:= k+1; od; Add( grading, Subspace( L, comp ) ); od; Add( grading, Subspace( L, [ ] ) ); SetGrading( L, rec( min_degree:= 1, max_degree:= Length( grading ) - 1, source:= Integers, hom_components:= function( d ) if d in [1..Length(grading)] then return grading[d]; else return grading[Length(grading)]; fi; end ) ); vv:= BasisVectors( B ); # Set the pth-power images of the basis elements of `B': for i in [1..Length(pimgs)] do if pimgs[i] = "zero" then pimgs[i]:= Zero( L ); else e:= ExtRepOfObj( pimgs[i] ); x:= Zero( L ); for k in [1,3..Length(e)-1] do pp:= Position( enum_gens[pos[i]+1], e[k] ); f:= GeneratorsOfGroup( pcgps[pos[i]+1] )[pp]; t:= Position( gens, f ); x:= x+ One( F )*e[k+1]*vv[t]; od; pimgs[i]:= x; fi; od; SetPthPowerImages( B, pimgs ); SetIsRestrictedLieAlgebra( L, true ); SetIsLieNilpotent( L, true ); hm:= function( g, i ) local h, e, x, k, pp, f, t; if not g in J[i] then Error(" is not an element of the i-th term of the series used to define "); fi; h:= Image( hom_pcg[i], Image(Homs[i], g )); e:= ExtRepOfObj(h); x:= Zero(L); for k in [1,3..Length(e)-1] do pp:= Position( enum_gens[i], e[k] ); f:= GeneratorsOfGroup( pcgps[i] )[pp]; t:= Position( gens, f ); x:= x + e[k+1]*Basis(L)[t]; od; return x; end ; SetNaturalHomomorphismOfLieAlgebraFromNilpotentGroup( L, hm ); return L; end ); ############################################################################# ## #E gap-4r6p5/lib/semigrp.gi0000644000175000017500000010220112172557254013674 0ustar billbill############################################################################# ## #W semigrp.gi GAP library Thomas Breuer ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains generic methods for semigroups. ## ############################################################################# ## ## Compute a data structure that can be used to compute the ## CayleyGraph of a semigroup. This data structure is essentially ## a list of lists of points each list recording the action of the ## generators of the semigroup on every element in the semigroup. ## The points represent the elements of the semigroup in sorted order. ## This representation is so a more condensed list of elements can be ## used rather than the elements of the semigroup. ## ## Similarly for the dual of the semigroup. ## ## Clearly, these graphs can be computed only for finite semigroups ## which can be enumerated. Other methods will be needed for very large ## semigroups or the infinite cases. ## #A CayleyGraphSemigroup() #A CayleyGraphDualSemigroup() ## InstallMethod(CayleyGraphSemigroup, "for generic finite semigroups", [IsSemigroup and IsFinite], function(s) FroidurePinExtendedAlg(s); return CayleyGraphSemigroup(s); end); InstallMethod(CayleyGraphDualSemigroup, "for generic finite semigroups", [IsSemigroup and IsFinite], function(s) FroidurePinExtendedAlg(s); return CayleyGraphDualSemigroup(s); end); ############################################################################# ## #M PrintObj( ) . . . . . . . . . . . . . . . . . . . . print a semigroup ## InstallMethod( PrintObj, "for a semigroup", [ IsSemigroup ], function( S ) Print( "Semigroup( ... )" ); end ); InstallMethod( String, "for a semigroup", [ IsSemigroup ], function( S ) return "Semigroup( ... )"; end ); InstallMethod( PrintObj, "for a semigroup with known generators", [ IsSemigroup and HasGeneratorsOfMagma ], function( S ) Print( "Semigroup( ", GeneratorsOfMagma( S ), " )" ); end ); InstallMethod( String, "for a semigroup with known generators", [ IsSemigroup and HasGeneratorsOfMagma ], function( S ) return STRINGIFY( "Semigroup( ", GeneratorsOfMagma( S ), " )" ); end ); InstallMethod( PrintString, "for a semigroup with known generators", [ IsSemigroup and HasGeneratorsOfMagma ], function( S ) return PRINT_STRINGIFY( "Semigroup( ", GeneratorsOfMagma( S ), " )" ); end ); ############################################################################# ## #M ViewObj( ) . . . . . . . . . . . . . . . . . . . . view a semigroup ## InstallMethod( ViewObj, "for a semigroup", [ IsSemigroup ], function( S ) Print( "" ); end ); InstallMethod( ViewObj, "for a semigroup with generators", [ IsSemigroup and HasGeneratorsOfMagma ], function( S ) if Length(GeneratorsOfMagma(S)) = 1 then Print( "" ); else Print( "" ); fi; end ); ############################################################################# ## #M DisplaySemigroup( ) ## InstallMethod(DisplaySemigroup, "for finite semigroups", [IsSemigroup], function(S) local dc, i, len, sh, D, layer, displayDClass; displayDClass:= function(D) local h, sh; h:= GreensHClassOfElement(AssociatedSemigroup(D),Representative(D)); if IsRegularDClass(D) then Print("*"); fi; Print("[H size = ", Size(h),", ", Size(GreensRClassOfElement(AssociatedSemigroup(D), Representative(h)))/Size(h), " L classes, ", Size(GreensLClassOfElement(AssociatedSemigroup(D), Representative(h)))/Size(h)," R classes]"); Print("\n"); end; ######################################################################### ## ## Function Proper ## ######################################################################### # check finiteness if not IsFinite(S) then TryNextMethod(); fi; # determine D classes and sort according to rank. layer:= List([1..DegreeOfTransformationSemigroup(S)], x->[]); for D in GreensDClasses(S) do Add(layer[RankOfTransformation(Representative(D))], D); od; # loop over the layers. len:= Length(layer); for i in [len, len-1..1] do if layer[i] <> [] then # loop over D classes. for D in layer[i] do Print("Rank ", i, ": \c"); displayDClass(D); od; fi; od; end); ############################################################################# ## #M SemigroupByGenerators( ) . . . . . . semigroup generated by ## InstallMethod( SemigroupByGenerators, "for a collection", [ IsCollection ], function( gens ) local S; S:= Objectify( NewType( FamilyObj( gens ), IsSemigroup and IsAttributeStoringRep ), rec() ); SetGeneratorsOfMagma( S, AsList( gens ) ); return S; end ); ############################################################################# ## #M AsSemigroup( ) . . . . . . . . . . . domain , viewed as semigroup ## InstallMethod( AsSemigroup, "for a semigroup", [ IsSemigroup ], 100, IdFunc ); InstallMethod( AsSemigroup, "generic method for collections", [ IsCollection ], function ( D ) local S, L; D := AsSSortedList( D ); L := ShallowCopy( D ); S := Submagma( SemigroupByGenerators( D ), [] ); SubtractSet( L, AsSSortedList( S ) ); while not IsEmpty(L) do S := ClosureMagmaDefault( S, L[1] ); SubtractSet( L, AsSSortedList( S ) ); od; if Length( AsSSortedList( S ) ) <> Length( D ) then return fail; fi; S := SemigroupByGenerators( GeneratorsOfSemigroup( S ) ); SetAsSSortedList( S, D ); SetIsFinite( S, true ); SetSize( S, Length( D ) ); # return the semigroup return S; end ); ############################################################################# ## #F Semigroup( , ... ) . . . . . . . . semigroup generated by collection #F Semigroup( ) . . . . . . . . . . semigroup generated by collection ## InstallGlobalFunction( Semigroup, function( arg ) # special case for matrices, because they may look like lists if Length( arg ) = 1 and IsMatrix( arg[1] ) then return SemigroupByGenerators( [ arg[1] ] ); # list of generators elif Length( arg ) = 1 and IsList( arg[1] ) and 0 < Length( arg[1] ) then return SemigroupByGenerators( arg[1] ); # generators elif 0 < Length( arg ) then return SemigroupByGenerators( arg ); # no argument given, error else Error("usage: Semigroup(,...),Semigroup(),Semigroup()"); fi; end ); ############################################################################# ## #M AsSubsemigroup( , ) ## InstallMethod( AsSubsemigroup, "generic method for a domain and a collection", IsIdenticalObj, [ IsDomain, IsCollection ], function( G, U ) local S; if not IsSubset( G, U ) then return fail; fi; if IsMagma( U ) then if not IsAssociative( U ) then return fail; fi; S:= SubsemigroupNC( G, GeneratorsOfMagma( U ) ); else S:= SubmagmaNC( G, AsList( U ) ); if not IsAssociative( S ) then return fail; fi; fi; UseIsomorphismRelation( U, S ); UseSubsetRelation( U, S ); return S; end ); ############################################################################# ## #M Enumerator( ) #M Enumerator( : Side:= "left" ) #M Enumerator( : Size:= "right") ## ## Creates a naive semigroup enumerator. By default this enumerates the ## right semigroup ideal of the set of generators. This is the same as ## the third form. ## ## In the second form it enumerates the left semigroup ideal generated by ## the semigroup generators. ## InstallMethod( Enumerator, "for a generic semigroup", [ IsSemigroup and HasGeneratorsOfSemigroup ], function( s ) if ValueOption( "Side" ) = "left" then return EnumeratorOfSemigroupIdeal( s, s, IsBound_LeftSemigroupIdealEnumerator, GeneratorsOfSemigroup( s ) ); else return EnumeratorOfSemigroupIdeal( s, s, IsBound_RightSemigroupIdealEnumerator, GeneratorsOfSemigroup( s ) ); fi; end ); ############################################################################# ## #M IsSimpleSemigroup( ) . . . . . . . . . . . . . . . . . . for a group #M IsSimpleSemigroup( ) . . . . . . . . . . . . for a trivial semigroup ## ## All groups are simple semigroups. ## A trivial semigroup is a simple semigroup. ## InstallTrueMethod( IsSimpleSemigroup, IsGroup ); InstallTrueMethod( IsSimpleSemigroup, IsSemigroup and IsTrivial ); ############################################################################# ## #M IsSimpleSemigroup( ) . . . . . . . for semigroup which has generators ## ## In such a case the semigroup is simple iff all generators are ## Greens J less than or equal to any element of the semigroup. ## ## Proof: ## (->) Suppose is simple; equivalently this means than ## for all element of , . So let be an ## arbitrary element of and let be any generator of . ## Then $S^1xS^1 \subseteq S = StS \subseteq S^1tS^1$ and this ## means that is J less than or equal to t. ## ## (<-) Conversely. ## Recall that simple is equivalent to J being ## the universal relation in . So that is what we have to proof. ## All elements of the semigroup are J less than or equal to the generators ## since they are products of generators. But since by the condition ## given all generators are less than or equal to all other elements ## it follows that all elements of the semigroup are J related, and ## hence J is universal. ## QED ## ## In order to apply the above result we are going to check that ## one of the generators is J-minimal and that all other generators are ## J-less than or equal to that first generator. ## ## It returns true if the semigroup is finite and is simple. ## It returns false if the semigroup is not simple and is finite. ## It might return false if the semigroup is not simple and infinite. ## It does not terminate if the semigroup although simple, is infinite ## InstallMethod(IsSimpleSemigroup, "for semigroup with generators", [ IsSemigroup and HasGeneratorsOfSemigroup], function(s) local it, # the iterator of the semigroup s t, # an element of the semigroup J, # Greens J relation of the semigroup gens, # a set of generators of the semigroup a, # a generator i, # loop variable jt,ja,jx; # J classes # the iterator, the J-relation and a generating set for the semigroup it:=Iterator(s); J:=GreensJRelation(s); gens:=GeneratorsOfSemigroup(s); # pick a generator, gens[1], and build its J class jx:=EquivalenceClassOfElementNC(J,gens[1]); # check whether gens[1] is J less than or equal to all other els of the smg while not(IsDoneIterator(it)) do # pick the next element of the semigroup t:=NextIterator(it); # if gens[1] is not J-less than or equal to t then S is not simple jt:=EquivalenceClassOfElementNC(J,t); if not(IsGreensLessThanOrEqual(jx,jt)) then return false; fi; od; # notice that the above cycle only terminates without returning false # when the semigroup is finite # now check whether all other generators are J less than or equal # the first one. No need to compare with first one (itself), so start in the # second one. Also, no need to compare with any other generator equal # to first one i:=2; while i in [1..Length(gens)] do a:=gens[i]; ja:=EquivalenceClassOfElementNC(J,a); if not(IsGreensLessThanOrEqual(ja,jx)) then return false; fi; i:=i+1; od; # hence the semigroup is simple return true; end); ############################################################################# ## #M IsSimpleSemigroup( ) ## ## for a semigroup which has a MultiplicativeNeutralElement. ## ## In this case is enough to show that the MultiplicativeNeutralElement ## is J-less than or equal to all other elements. ## This is because a MultiplicativeNeutralElement is J greater than or ## equal to any other element and hence by showing that is less than ## or equal any other element it follows that J is universal, and ## therefore the semigroup is simple. ## ## If the semigroup is finite it returns true if the semigroup is ## simple and false otherwise. ## If the semigroup is infinite and simple it does not terminate. It ## might terminate and return false if the semigroup is not simple. ## InstallMethod( IsSimpleSemigroup, "for a semigroup with a MultiplicativeNeutralElement", [ IsSemigroup and HasMultiplicativeNeutralElement ], function(s) local it,# the iterator of the semigroup S J,# Green's J relation on the semigroup jn,jt,# J-classes t,# an element of the semigroup neutral;# the MultiplicativeNeutralElement of s # the iterator and the J-relation on S it:=Iterator(s); J:=GreensJRelation(s); # the multiplicative neutral element and its J class neutral:=MultiplicativeNeutralElement(s); jn:=EquivalenceClassOfElementNC(J,neutral); while not(IsDoneIterator(it)) do t:=NextIterator(it); jt:=EquivalenceClassOfElementNC(J,t); # if neutral is not J less than or equal to t then S is not simple if not(IsGreensLessThanOrEqual(jn,jt)) then return false; fi; od; # notice that the above cycle only terminates without returning # false if the semigroup is finite # hence s is simple return true; end); ############################################################################# ## #M IsSimpleSemigroup( ) . . . . . . . . . . . . . . . . for a semigroup ## ## This is the general case for a semigroup. ## ## A semigroup is simple iff J is the universal relation in S. ## So we are going to fix a J class and look throught the semigroup ## to check whether there are other J-classes. ## ## It returns false if it finds a new J-class. ## It returns true if is finite and only finds one J-class. ## It does not terminate if simple but infinite. ## InstallMethod(IsSimpleSemigroup, "for a semigroup", [ IsSemigroup ], function(s) local it,# the iterator of the semigroup s J,# J relation on s a,b,# elements of the semigroup ja,jb;# J-classes # the J-relation on s and the iterator of s J:=GreensJRelation(s); it:=Iterator(s); # pick an element of the semigroup a:=NextIterator(it); # and build its J class ja:=EquivalenceClassOfElementNC(J,a); # if IsDoneIterator(it) it means that the semigroup is trivial, and hence simple if IsDoneIterator(it) then return true; fi; # look through all elements of s # to find out if there are more J classes while not(IsDoneIterator(it)) do b:=NextIterator(it); jb:=EquivalenceClassOfElementNC(J,b); # if a and b are not in the same J class then the smg is not simple if not(IsGreensLessThanOrEqual(ja,jb)) then return false; elif not (IsGreensLessThanOrEqual(jb,ja)) then return false; fi; od; # notice that the above cycle only terminates without returning # false if the semigroup is finite # hence the semigroup is simple return true; end); ############################################################################# ## #M IsZeroSimpleSemigroup( ) . . . . . . . . . . . . . . for a zero group ## ## All groups are simple semigroups. Hence all zero groups are 0-simple. ## InstallTrueMethod( IsZeroSimpleSemigroup, IsZeroGroup ); ############################################################################# ## #M IsZeroSimpleSemigroup( ) . . . . . . . . . . . . . . . . for a group ## ## A group is not a zero simple semigroup because does not have a zero. ## InstallMethod( IsZeroSimpleSemigroup, "for a ZeroGroup", [ IsGroup], ReturnFalse ); ############################################################################# ## #M IsZeroSimpleSemigroup( ) . . . . . . . . . . for a trivial semigroup ## ## a trivial semigroup is not 0 simple, since S^2=0 ## Moreover is not representable by a Rees Matrix semigroup ## over a zero group (which has at least two elements) ## InstallMethod(IsZeroSimpleSemigroup, "for a trivial semigroup", [ IsSemigroup and IsTrivial], ReturnFalse ); ############################################################################# ## #M IsZeroSimpleSemigroup( ) . . . . for a semigroup which has generators ## ## In such a case if the semigroup has more than two elements it is ## 0-simple iff ## (i) is non equal to the singleton set consisting of zero; and ## (ii) all generators are Greens J less than or equal to any non zero ## element of the semigroup. ## If the semigroup has exactly two elements then it is simple ## iff the square of the nonzero element is nonzero ## Is the semigroup has only one element then it is not 0-simple. ## ## Proof: ## The last sentence, about a semigroup with only two elements is obvious. ## ## So suppose has more than two elements. ## (->) Suppose is 0-simple; ## Equivalently this means than for all non zero element of , ## . ## So let be a nonzero arbitrary element of and let be ## any generator of . ## Then $S^1xS^1 \subseteq S = StS \subseteq S^1tS^1$ and this ## means that is J less than or equal to t. ## Condition (i) follows from the definition of being 0-simple. ## ## (<-) Conversely. ## Recall that 0-simple is equivalent to J ## having has equivalence classes and 0 itself, and nonzero. ## So that is what we have to proof. ## That is not equal to zero is immediate. ## Now, all nonzero elements of the semigroup are J less than or equal ## the generators since they are products of generators. ## But since by condition (ii) all generators are J-less than or equal ## all other nonzero elements it follows that all non-zero elements of the ## semigroup are J related, and hence J has only two classes. QED ## ## To check that (ii) holds is enough to show that one of the generators ## is J less than or equal to every other non zero element of and ## then show that all other generators are J-less than or equal to that ## generator. ## InstallMethod(IsZeroSimpleSemigroup, "for a semigroup with generators", [ IsSemigroup and HasGeneratorsOfSemigroup ], function(s1) local e, # enumerator for the semigroup s1 s, # isomorphic image as transformation semigroup gens,# a set of generators of the semigroup x,# a non zero generators of s zero,# the multiplicative zero of the semigroup nonzero,# nonzero element of s in case s has two elements J, # Greens J relation of the semigroup a, # a generator i,j,# loop variables jx,jt,ja; # J classes s := Range(IsomorphismTransformationSemigroup(s1)); # the enumerator, the set of generators and the zero for s e:=Enumerator(s); # if e[2] is not bound then s is trivial, hence is not 0 simple if not (IsBound(e[2])) then return false; fi; zero:=MultiplicativeZero(s); # next check that if S has two elements, whether the square of the # nonzero one is nonzero # If all squares are zero then the semigroup is not 0-simple if not(IsBound(e[3])) then if e[1]<>zero then nonzero:=e[1]; else nonzero:=e[2]; fi; if nonzero^2=zero then # then this means that S^2 is the zero set, and hence # S is not 0-simple return false; else # S is 0-simple return true; fi; fi; # otherwise if the semigroup has more than 2 els, start by # fixing a generator; # we know that there is a nonzero generator as there are at least # three elements in S, so we look for such a generator gens:=GeneratorsOfSemigroup(s); x:=zero; i:=1; while ( x=zero and (i in [1..Length(gens)]) ) do if gens[i]<>zero then x:=gens[i]; fi; i:=i+1; od; # and check that x is J less than or equal to every other nonzero # element of the semigroup # Notice that x is at this point gens[i-1] #J:=GreensJRelation(s); #jx:=EquivalenceClassOfElementNC(J,x); jx := GreensJClassOfElement(s,x); j:=1; while IsBound(e[j]) do if e[j]<>zero then #jt:=EquivalenceClassOfElementNC(J,e[j]); jt := GreensJClassOfElement(s,e[j]); if not(IsGreensLessThanOrEqual(jx,jt)) then return false; fi; fi; j:=j+1; od; # notice that if we arrive here is because the semigroup is # finite for otherwise the above cycle does not stop # (unless the semigroup is not simple, when it ends returning false) # the last thing we have to check is that all other # nonzero generators are J less than or equal to x # Recall that from the way we have found x, x is gen[i-1] and # all previous gens are zero # So we can start comparing x from gens[i] onwards while i<=Length(gens) do a:=gens[i]; if a<>zero then #ja:=EquivalenceClassOfElementNC(J,a); ja := GreensJClassOfElement(s,a); if not(IsGreensLessThanOrEqual(ja,jx)) then return false; fi; fi; i:=i+1; od; return true; end); ############################################################################# ## #M IsZeroSimpleSemigroup( ) ## ## for a semigroup with zero which has a MultiplicativeNeutralElement. ## ## In this case is enough to show that the MultiplicativeNeutralElement ## is J-less than or equal to all other non-zero elements of S and ## that if S has only two elements, s^2 is non zero. ## This is because a MultiplicativeNeutralElement is J greater than or ## equal to any other element and hence by showing that is less than ## or equal any other element it follows that J is universal, and ## therefore the semigroup is simple. ## ## This time if the semigroup only has two elements than it ## is simple since for sure the square of the Neutral Element ## is itself, and hence is non-zero ## InstallMethod( IsZeroSimpleSemigroup, "for a semigroup with a MultiplicativeNeutralElement", [ IsSemigroup and HasMultiplicativeNeutralElement ], function(s) local e, # the enumerator of the semigroup s J, # Green's J relation on the semigroup jn,ji, # J-classes zero,# the zero element of s i,# loop variable neutral; # the MultiplicativeNeutralElement of s e:=Enumerator(s); # the trivial semigroup is not 0-simple if not(IsBound(e[2])) then return false; fi; # as remarked above, if the semigroup has a neutral element then # if it has two elements it is simple if not(IsBound(e[3])) then return true; fi; neutral:=MultiplicativeNeutralElement(s); zero:=MultiplicativeZero(s); J:=GreensJRelation(s); jn:=EquivalenceClassOfElementNC(J,neutral); i:=1; while IsBound(e[i]) do if e[i]<>zero then ji:=EquivalenceClassOfElementNC(J,e[i]); if not(IsGreensLessThanOrEqual(jn,ji)) then return false; fi; fi; i:=i+1; od; return true; end); ############################################################################# ## #M IsZeroSimpleSemigroup( ) . . . . . . . . for a semigroup with a zero ## ## This is the general case for a semigroup with a zero. ## ## A semigroup is 0-simple iff ## (i) S has two elements and S^2<>0 ## (ii) S has more than two elements and its only J classes are ## S-0 and 0 ## ## So, in the case when we have at least three elements we are going ## to fix a non-zero J class and look throught the semigroup ## to check whether there are other non-zero J-classes. ## ## It returns false if it finds a new non-zero J-class, ie, smg is ## not 0-simple. ## It returns true if is finite and only finds one nonzero J-class, ## that is, the semigroup is 0-simple. ## It does not terminate if 0-simple but infinite. ## InstallMethod( IsZeroSimpleSemigroup, "for a semigroup", [ IsSemigroup ], function(s) local e, # the enumerator of the semigroup s zero,# the multiplicative zero of the semigroup nonzero,# the nonzero el of a semigroup with two elements J, # J relation on s b, # elements of the semigroup i,# loop variable ja,jb; # J-classes # the enumerator and the multiplicative zero of s e:=Enumerator(s); zero:=MultiplicativeZero(s); # the trivial semigroup is not 0-simple if not(IsBound(e[2])) then return false; fi; # next check that if S has two elements, whether the square of the # nonzero one is nonzero if not(IsBound(e[3])) then if e[1]<>zero then nonzero:=e[1]; else nonzero:=e[2]; fi; if nonzero^2=zero then # then this means that S^2 is the zero set, and hence # S is not 0-simple return false; else # S is 0-simple return true; fi; fi; # so by now we know that s has at least three elements # the J relation on s J:=GreensJRelation(s); # look for the first non zero element and build its J class if e[1]<>zero then ja:=EquivalenceClassOfElementNC(J,e[1]); else ja:=EquivalenceClassOfElementNC(J,e[2]); fi; # look through all nonzero elements of s # to find out if there are more nonzero J classes # We do not have to start looking from the fisrt one, since the first # one is either zero or else is the element we started with. # In the case the first one is zero we can start looking by the 3rd one. if e[1]=zero then i:=3; else i:=2; fi; while IsBound(e[i]) do b:=e[i]; if b<>zero then jb:=EquivalenceClassOfElementNC(J,b); # if ja and jb are not the same J class then the smg is not simple if not(IsGreensLessThanOrEqual(ja,jb)) then return false; elif not (IsGreensLessThanOrEqual(jb,ja)) then return false; fi; fi; i:=i+1; od; # notice that the above cycle only terminates without returning # false if the semigroup is finite # hence the semigroup is 0-simple return true; end); ############################################################################ ## #A ANonReesCongruenceOfSemigroup( ) . . . . for a finite semigroup ## ## In this case the following holds: ## Proposition (A.Solomon): S is Rees Congruence <-> ## Every congruence generated by a pair is Rees. ## Proof: -> is immediate. ## <- Let \rho be some non-Rees congruence in S. ## Let [a] and [b] be distinct nontrivial congruence classes of \rho. ## Let a, a' \in [a]. By assumption, the congruence generated ## by the pair (a, a') is a Rees congruence. ## Thus, since the kernel K is contained ## in the nontrivial congruence class of <(a,a')>, and similarly K is contained ## in the nontrivial congruence class of <(b,b')> for any b, b' \in [b]. Thus ## we must have that (a,b) \in \rho, contradicting the assumption. \QED ## ## So, to find a non rees congruence we only have to look within the ## congruences generated by a pair of elements of . If all ## of these are Rees it menas that there are no Non-rees congruences. ## ## This method returns a non rees congruence if it exists and ## fail otherwise ## ## So we look through all possible pairs of elements of s. ## We do this by using an iterator for N times N. ## Notice that for this iterator IsDoneIterator is always false, ## since there are always a next element in N times N. ## InstallMethod( ANonReesCongruenceOfSemigroup, "for a semigroup", [IsSemigroup and IsFinite], function( s ) local e,x,y,i,j; e := EnumeratorSorted(s); for i in [1 .. Length(e)] do for j in [i+1 .. Length(e)] do x := e[i]; y := e[j]; if not IsReesCongruence( SemigroupCongruenceByGeneratingPairs(s, [[x,y]])) then return SemigroupCongruenceByGeneratingPairs(s, [[x,y]]); fi; od; od; return fail; end); RedispatchOnCondition( ANonReesCongruenceOfSemigroup, true, [IsSemigroup], [IsFinite], 0); ############################################################################ ## #P IsReesCongruenceSemigroup( ) ## InstallMethod( IsReesCongruenceSemigroup, "for a (possibly infinite) semigroup", [ IsSemigroup], s -> ANonReesCongruenceOfSemigroup(s) = fail ); ############################################################################# ## #O HomomorphismFactorSemigroup( , ) #O HomomorphismFactorSemigroupByClosure( , ) #O FactorSemigroup( , ) #O FactorSemigroupByClosure( , ) ## ## In the first form is a congruence and HomomorphismFactorSemigroup, ## returns a homomorphism $ \rightarrow / ## ## This is the only one which should do any work and is installed ## in all the appropriate places. ## ## All implementations of \/ should be done in terms of the above ## four operations. ## InstallMethod( HomomorphismFactorSemigroupByClosure, "for a semigroup and generating pairs of a congruence", IsElmsColls, [ IsSemigroup, IsList ], function(s, l) return HomomorphismFactorSemigroup(s, SemigroupCongruenceByGeneratingPairs(s,l) ); end); InstallMethod( HomomorphismFactorSemigroupByClosure, "for a semigroup and empty list", [ IsSemigroup, IsList and IsEmpty ], function(s, l) return HomomorphismFactorSemigroup(s, SemigroupCongruenceByGeneratingPairs(s,l) ); end); InstallMethod( FactorSemigroup, "for a semigroup and a congruence", [ IsSemigroup, IsSemigroupCongruence ], function(s, c) if not s = Source(c) then TryNextMethod(); fi; return Range(HomomorphismFactorSemigroup(s, c)); end); InstallMethod( FactorSemigroupByClosure, "for a semigroup and generating pairs of a congruence", IsElmsColls, [ IsSemigroup, IsList ], function(s, l) return Range(HomomorphismFactorSemigroup(s, SemigroupCongruenceByGeneratingPairs(s,l) )); end); InstallMethod( FactorSemigroupByClosure, "for a semigroup and empty list", [ IsSemigroup, IsEmpty and IsList], function(s, l) return Range(HomomorphismFactorSemigroup(s, SemigroupCongruenceByGeneratingPairs(s,l) )); end); ############################################################################# ## #M \/( , ) . . . . for semigroup and empty list ## InstallOtherMethod( \/, "for a semigroup and an empty list", [ IsSemigroup, IsEmpty ], FactorSemigroupByClosure ); ############################################################################# ## #M \/( , ) . . . . for semigroup and list of pairs of elements ## InstallOtherMethod( \/, "for semigroup and list of pairs", IsElmsColls, [ IsSemigroup, IsList ], FactorSemigroupByClosure ); ############################################################################# ## #M \/( , ) . . . . for semigroup and congruence ## InstallOtherMethod( \/, "for a semigroup and a congruence", [ IsSemigroup, IsSemigroupCongruence ], FactorSemigroup ); ############################################################################# ## #M IsRegularSemigroupElement( , ) ## ## A semigroup element is regular if and only if its DClass is regular, ## which in turn is regular if and only if every R and L class contains ## an idempotent. In the generic case, therefore, we iterate over an ## elements R class, and look for idempotents. ## InstallMethod(IsRegularSemigroupElement, "for generic semigroup", IsCollsElms, [IsSemigroup, IsAssociativeElement], function(S, x) local r, i; if not x in S then return false; fi; r:= EquivalenceClassOfElementNC(GreensRRelation(S), x); for i in Iterator(r) do if i*i=i then # we have found an idempotent. return true; fi; od; # no idempotents in R class implies not regular. return false; end); ############################################################################# ## #M IsRegularSemigroup( ) ## InstallMethod(IsRegularSemigroup, "for generic semigroup", [ IsSemigroup ], S -> ForAll( GreensDClasses(S), IsRegularDClass ) ); ############################################################################# ## #E gap-4r6p5/lib/gprdperm.gi0000644000175000017500000010500312172557252014047 0ustar billbill############################################################################# ## #W gprdperm.gi GAP library Heiko Theißen ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ############################################################################# ## #M DirectProductOp( , ) . . . . . . direct product of perm groups ## InstallMethod( DirectProductOp, "for a list of permutation groups, and a permutation group", IsCollsElms, [ IsList and IsPermCollColl, IsPermGroup ], 0, function( grps, G ) local oldgrps, olds, news, perms, gens, deg, grp, old, new, perm, gen, D, info; # Check the arguments. if not ForAll( grps, IsGroup ) then TryNextMethod(); fi; oldgrps := [ ]; olds := [ ]; news := [ ]; perms := [ ]; gens := [ ]; deg := 0; # loop over the groups for grp in grps do # find old domain, new domain, and conjugating permutation old := MovedPoints( grp ); new := [deg+1..deg+Length(old)]; perm := MappingPermListList( old, new ); deg := deg + Length(old); Add( oldgrps, grp ); Add( olds, old ); Add( news, new ); Add( perms, perm ); # map all the generators of for gen in GeneratorsOfGroup( grp ) do Add( gens, gen ^ perm ); od; od; D:= GroupWithGenerators( gens, One( grps[1] ) ); info := rec( groups := oldgrps, olds := olds, news := news, perms := perms, embeddings := [], projections := [] ); SetDirectProductInfo( D, info ); return D; end ); ############################################################################# ## #M Size( ) . . . . . . . . . . . . . . . . . . . . . . of direct product ## InstallMethod( Size, "for a permutation group that knows to be a direct product", true, [ IsPermGroup and HasDirectProductInfo ], 0, D -> Product( List( DirectProductInfo( D ).groups, Size ) ) ); ############################################################################# ## #R IsEmbeddingDirectProductPermGroup( ) . embedding of direct factor ## DeclareRepresentation( "IsEmbeddingDirectProductPermGroup", IsAttributeStoringRep and IsGroupHomomorphism and IsInjective and IsSPGeneralMapping, [ "component" ] ); ############################################################################# ## #R IsEmbeddingWreathProductPermGroup( ) . embedding of wreath factor ## DeclareRepresentation( "IsEmbeddingWreathProductPermGroup", IsAttributeStoringRep and IsGroupHomomorphism and IsInjective and IsSPGeneralMapping, [ "component" ] ); ############################################################################# ## #R IsEmbeddingImprimitiveWreathProductPermGroup( ) ## ## special for case of imprimitive wreath product DeclareRepresentation( "IsEmbeddingImprimitiveWreathProductPermGroup", IsEmbeddingWreathProductPermGroup, [ "component" ] ); ############################################################################# ## #R IsEmbeddingProductActionWreathProductPermGroup( ) ## ## special for case of product action wreath product DeclareRepresentation( "IsEmbeddingProductActionWreathProductPermGroup", IsEmbeddingWreathProductPermGroup and IsGroupGeneralMappingByAsGroupGeneralMappingByImages,["component"]); ############################################################################# ## #M Embedding( , ) . . . . . . . . . . . . . . . . . . make embedding ## InstallMethod( Embedding,"perm direct product", true, [ IsPermGroup and HasDirectProductInfo, IsPosInt ], 0, function( D, i ) local emb, info; info := DirectProductInfo( D ); if IsBound( info.embeddings[i] ) then return info.embeddings[i]; fi; emb := Objectify( NewType( GeneralMappingsFamily( PermutationsFamily, PermutationsFamily ), IsEmbeddingDirectProductPermGroup ), rec( component := i ) ); SetRange( emb, D ); info.embeddings[i] := emb; return emb; end ); ############################################################################# ## #M Source( ) . . . . . . . . . . . . . . . . . . . . . . of embedding ## InstallMethod( Source,"perm direct product embedding", true, [ IsEmbeddingDirectProductPermGroup ], 0, emb -> DirectProductInfo( Range( emb ) ).groups[ emb!.component ] ); ############################################################################# ## #M ImagesRepresentative( , ) . . . . . . . . . . . . of embedding ## InstallMethod( ImagesRepresentative,"perm direct product embedding", FamSourceEqFamElm, [ IsEmbeddingDirectProductPermGroup, IsMultiplicativeElementWithInverse ], 0, function( emb, g ) return g ^ DirectProductInfo( Range( emb ) ).perms[ emb!.component ]; end ); ############################################################################# ## #M PreImagesRepresentative( , ) . . . . . . . . . . . of embedding ## InstallMethod( PreImagesRepresentative, "perm direct product embedding", FamRangeEqFamElm, [ IsEmbeddingDirectProductPermGroup, IsMultiplicativeElementWithInverse ], function( emb, g ) local info; info := DirectProductInfo( Range( emb ) ); #T Make this more efficient: #T Creating the restricted permutation could be avoided #T if there would be an efficient (kernel) function that tests whether #T a permutation moves points outside a given set. #T Inverting the mapping permutation in each call could be avoided #T by storing also the inverse, and the conjugation could be improved. if g = RestrictedPermNC( g, info.news[ emb!.component ] ) then return g ^ (info.perms[ emb!.component ] ^ -1); else return fail; fi; end ); ############################################################################# ## #M ImagesSource( ) . . . . . . . . . . . . . . . . . . . of embedding ## InstallMethod( ImagesSource,"perm direct product embedding", true, [ IsEmbeddingDirectProductPermGroup ], 0, function( emb ) local D, I, info; D := Range( emb ); info := DirectProductInfo( D ); I := SubgroupNC( D, OnTuples ( GeneratorsOfGroup( info.groups[ emb!.component ] ), info.perms[ emb!.component ] ) ); SetIsNormalInParent( I, true ); return I; end ); ############################################################################# ## #M ViewObj( ) . . . . . . . . . . . . . . . . . . . . view embedding ## InstallMethod( ViewObj, "for embedding into direct product", true, [ IsEmbeddingDirectProductPermGroup ], 0, function( emb ) Print( Ordinal( emb!.component ), " embedding into " ); View( Range( emb ) ); end ); ############################################################################# ## #M PrintObj( ) . . . . . . . . . . . . . . . . . . . . print embedding ## InstallMethod( PrintObj, "for embedding into direct product", true, [ IsEmbeddingDirectProductPermGroup ], 0, function( emb ) Print( "Embedding( ", Range( emb ), ", ", emb!.component, " )" ); end ); ############################################################################# ## #R IsProjectionDirectProductPermGroup( ) projection onto direct factor ## DeclareRepresentation( "IsProjectionDirectProductPermGroup", IsAttributeStoringRep and IsGroupHomomorphism and IsSurjective and IsSPGeneralMapping, [ "component" ] ); ############################################################################# ## #M Projection( , ) . . . . . . . . . . . . . . . . . make projection ## InstallMethod( Projection,"perm direct product", true, [ IsPermGroup and HasDirectProductInfo, IsPosInt ], 0, function( D, i ) local prj, info; info := DirectProductInfo( D ); if IsBound( info.projections[i] ) then return info.projections[i]; fi; prj := Objectify( NewType( GeneralMappingsFamily( PermutationsFamily, PermutationsFamily ), IsProjectionDirectProductPermGroup ), rec( component := i ) ); SetSource( prj, D ); info.projections[i] := prj; return prj; end ); ############################################################################# ## #M Range( ) . . . . . . . . . . . . . . . . . . . . . . of projection ## InstallMethod( Range, "perm direct product projection",true, [ IsProjectionDirectProductPermGroup ], 0, prj -> DirectProductInfo( Source( prj ) ).groups[ prj!.component ] ); ############################################################################# ## #M ImagesRepresentative( , ) . . . . . . . . . . . . of projection ## InstallMethod( ImagesRepresentative,"perm direct product projection", FamSourceEqFamElm, [ IsProjectionDirectProductPermGroup, IsMultiplicativeElementWithInverse ], 0, function( prj, g ) local info; info := DirectProductInfo( Source( prj ) ); return RestrictedPermNC( g, info.news[ prj!.component ] ) ^ ( info.perms[ prj!.component ] ^ -1 ); end ); ############################################################################# ## #M PreImagesRepresentative( , ) . . . . . . . . . . . of projection ## InstallMethod( PreImagesRepresentative,"perm direct product projection", FamRangeEqFamElm, [ IsProjectionDirectProductPermGroup, IsMultiplicativeElementWithInverse ], 0, function( prj, g ) return g ^ DirectProductInfo( Source( prj ) ).perms[ prj!.component ]; end ); ############################################################################# ## #M KernelOfMultiplicativeGeneralMapping( ) . . . . . . . of projection ## InstallMethod( KernelOfMultiplicativeGeneralMapping, "perm direct product projection", true, [ IsProjectionDirectProductPermGroup ], 0, function( prj ) local D, gens, i, K, info; D := Source( prj ); info := DirectProductInfo( D ); gens := [ ]; for i in [ 1 .. Length( info.groups ) ] do if i <> prj!.component then Append( gens, OnTuples( GeneratorsOfGroup( info.groups[ i ] ), info.perms[ i ] ) ); fi; od; K := SubgroupNC( D, gens ); SetIsNormalInParent( K, true ); return K; end ); ############################################################################# ## #M ViewObj( ) . . . . . . . . . . . . . . . . . . . . view projection ## InstallMethod( ViewObj, "for projection from a direct product", true, [ IsProjectionDirectProductPermGroup ], 0, function( prj ) Print( Ordinal( prj!.component ), " projection of " ); View( Source( prj ) ); end ); ############################################################################# ## #M PrintObj( ) . . . . . . . . . . . . . . . . . . . print projection ## InstallMethod( PrintObj, "for projection from a direct product", true, [ IsProjectionDirectProductPermGroup ], 0, function( prj ) Print( "Projection( ", Source( prj ), ", ", prj!.component, " )" ); end ); InstallGlobalFunction(SubdirectDiagonalPerms,function(l,m) local n,o,p; n:=LargestMovedPoint(l); o:=LargestMovedPoint(m); p:=MappingPermListList([1..o],[n+1..n+o]); return List([1..Length(l)],i->l[i]*m[i]^p); end); ############################################################################# ## #M SubdirectProduct( , , , ) . . . . . . . constructor ## InstallMethod( SubdirectProductOp,"permgroup", true, [ IsPermGroup, IsPermGroup, IsGroupHomomorphism, IsGroupHomomorphism ], 0, function( G1, G2, phi1, phi2 ) local S, # subdirect product of and , result gens, # generators of D, # direct product of and emb1, emb2, # embeddings of and into info, Dinfo,# info records gen; # one generator of or kernel of # make the direct product and the embeddings D := DirectProduct( G1, G2 ); emb1 := Embedding( D, 1 ); emb2 := Embedding( D, 2 ); # the subdirect product is generated by $(g_1,x_{g_1})$ where $g_1$ loops # over the generators of $G_1$ and $x_{g_1} \in G_2$ is abitrary such # that $g_1^{phi_1} = x_{g_1}^{phi_2}$ and by $(1,k_2)$ where $k_2$ loops # over the generators of the kernel of $phi_2$. gens := []; for gen in GeneratorsOfGroup( G1 ) do Add( gens, gen^emb1 * PreImagesRepresentative(phi2,gen^phi1)^emb2 ); od; for gen in GeneratorsOfGroup( KernelOfMultiplicativeGeneralMapping( phi2 ) ) do Add( gens, gen ^ emb2 ); od; # and make the subdirect product S := GroupByGenerators( gens ); SetParent( S, D ); Dinfo := DirectProductInfo( D ); info := rec( groups := [G1, G2], homomorphisms := [phi1, phi2], olds := Dinfo.olds, news := Dinfo.news, perms := Dinfo.perms, projections := [] ); SetSubdirectProductInfo( S, info ); return S; end ); ############################################################################# ## #R IsProjectionSubdirectProductPermGroup( ) . projection onto factor ## DeclareRepresentation( "IsProjectionSubdirectProductPermGroup", IsAttributeStoringRep and IsGroupHomomorphism and IsSurjective and IsSPGeneralMapping, [ "component" ] ); ############################################################################# ## #M Projection( , ) . . . . . . . . . . . . . . . . . make projection ## InstallMethod( Projection,"perm subdirect product",true, [ IsPermGroup and HasSubdirectProductInfo, IsPosInt ], 0, function( S, i ) local prj, info; info := SubdirectProductInfo( S ); if IsBound( info.projections[i] ) then return info.projections[i]; fi; prj := Objectify( NewType( GeneralMappingsFamily( PermutationsFamily, PermutationsFamily ), IsProjectionSubdirectProductPermGroup ), rec( component := i ) ); SetSource( prj, S ); info.projections[i] := prj; SetSubdirectProductInfo( S, info ); return prj; end ); ############################################################################# ## #M Range( ) . . . . . . . . . . . . . . . . . . . . . . of projection ## InstallMethod( Range,"perm subdirect product projection", true, [ IsProjectionSubdirectProductPermGroup ], 0, prj -> SubdirectProductInfo( Source( prj ) ).groups[ prj!.component ] ); ############################################################################# ## #M ImagesRepresentative( , ) . . . . . . . . . . . . of projection ## InstallMethod( ImagesRepresentative,"perm subdirect product projection", FamSourceEqFamElm, [ IsProjectionSubdirectProductPermGroup, IsMultiplicativeElementWithInverse ], 0, function( prj, g ) local info; info := SubdirectProductInfo( Source( prj ) ); return RestrictedPermNC( g, info.news[ prj!.component ] ) ^ ( info.perms[ prj!.component ] ^ -1 ); end ); ############################################################################# ## #M PreImagesRepresentative( , ) . . . . . . . . . . . of projection ## InstallMethod( PreImagesRepresentative,"perm subdirect product projection", FamRangeEqFamElm, [ IsProjectionSubdirectProductPermGroup, IsMultiplicativeElementWithInverse ], 0, function( prj, img ) local S, elm, # preimage of under , result info, # info record phi1, phi2; # homomorphisms of components S := Source( prj ); info := SubdirectProductInfo( S ); # get the homomorphism phi1 := info.homomorphisms[1]; phi2 := info.homomorphisms[2]; # compute the preimage if 1 = prj!.component then elm := img ^ info.perms[1] * PreImagesRepresentative(phi2,img^phi1) ^ info.perms[2]; else elm := img ^ info.perms[2] * PreImagesRepresentative(phi1,img^phi2) ^ info.perms[1]; fi; # return the preimage return elm; end ); ############################################################################# ## #M KernelOfMultiplicativeGeneralMapping( ) . . . . . . . of projection ## InstallMethod( KernelOfMultiplicativeGeneralMapping, "perm subdirect product projection",true, [ IsProjectionSubdirectProductPermGroup ], 0, function( prj ) local D, i, info; D := Source( prj ); info := SubdirectProductInfo( D ); i := 3 - prj!.component; return SubgroupNC( D, OnTuples ( GeneratorsOfGroup( KernelOfMultiplicativeGeneralMapping( info.homomorphisms[ i ] ) ), info.perms[ i ] ) ); end ); ############################################################################# ## #M ViewObj( ) . . . . . . . . . . . . . . . . . . . . view projection ## InstallMethod( ViewObj, "for projection from subdirect product", true, [ IsProjectionSubdirectProductPermGroup ], 0, function( prj ) Print( Ordinal( prj!.component ), " projection of " ); View( Source( prj ) ); end ); ############################################################################# ## #M PrintObj( ) . . . . . . . . . . . . . . . . . . . print projection ## InstallMethod( PrintObj, "for projection from subdirect product", true, [ IsProjectionSubdirectProductPermGroup ], 0, function( prj ) Print( "Projection( ", Source( prj ), ", ", prj!.component, " )" ); end ); ############################################################################# ## #M WreathProductImprimitiveAction( , [,] ) ## InstallGlobalFunction(WreathProductImprimitiveAction,function( arg ) local G,H, # factors GP, # preimage of (if homomorphism) Ggens,Igens,#permutation images of generators alpha, # action homomorphism for permimpr, # product is pure permutation groups imprimitive I, # image of grp, # wreath product of and , result gens, # generators of the wreath product gen, # one generator domG, # domain of operation of degG, # degree of domI, # domain of operation of degI, # degree of shift, # permutation permuting the blocks perms, # component permutating permutations basegens, # generators of base subgroup hgens, # complement generators components, # components (points) of base group rans, # list of arguments that have '.sCO.random' info, # info record i, k, l; # loop variables G:=arg[1]; H:=arg[2]; # get the domain of operation of and if IsPermGroup( G ) then permimpr:=true; domG := MovedPoints( G ); GP:=G; Ggens:=GeneratorsOfGroup(G); elif IsGroupHomomorphism( G ) and IsPermGroup( Range( G ) ) then permimpr:=false; GP:=Source(G); domG := MovedPoints( Range( G ) ); Ggens:=List(GeneratorsOfGroup(GP),i->ImageElm(G,i)); G := Image( G ); else Error( "WreathProduct: must be perm group or homomorphism" ); fi; degG := Length( domG ); if Length(arg)=2 then domI := MovedPoints( H ); I := H; alpha := IdentityMapping( H ); Igens:=GeneratorsOfGroup(H); elif IsGroupHomomorphism(arg[3]) and IsPermGroup(Range(arg[3])) then permimpr:=false; # also will fail the permutation imprimitive case alpha := arg[3]; I := Image( alpha ); domI := MovedPoints( Range( alpha) ); Igens:=List(GeneratorsOfGroup(H),i->ImageElm(alpha,i)); else Error( "WreathProduct: must be perm group or homomorphism" ); fi; if IsEmpty( domI ) then domI := [ 1 ]; fi; degI := Length( domI ); # make the generators of the direct product of copies of components:=[]; gens := []; perms:= []; # force trivial group to act on 1 point if degG = 0 then domG := [1]; degG := 1; fi; for i in [1..degI] do components[i]:=[(i-1)*degG+1..i*degG]; shift := MappingPermListList( domG, components[i] ); Add(perms,shift); for gen in Ggens do Add( gens, gen ^ shift ); od; od; basegens:=ShallowCopy(gens); # add the generators of hgens:=[]; for gen in Igens do shift := []; for i in [1..degI] do k := Position( domI, domI[i]^gen ); for l in [1..degG] do shift[(i-1)*degG+l] := (k-1)*degG+l; od; od; shift:=PermList(shift); Add( gens, shift ); Add(hgens, shift ); od; # make the group generated by those generators grp := GroupWithGenerators( gens, () ); # `gens' arose from `PermList' # enter the size SetSize( grp, Size( G ) ^ degI * Size( I ) ); # note random method rans := Filtered( [ G, I ], i -> IsBound( StabChainOptions( i ).random ) ); if Length( rans ) > 0 then SetStabChainOptions( grp, rec( random := Minimum( List( rans, i -> StabChainOptions( i ).random ) ) ) ); fi; info := rec( groups := [GP,H], alpha := alpha, perms := perms, base := SubgroupNC(grp,basegens), basegens:=basegens, I := I, degI := degI, hgens := hgens, components := components, embeddingType := NewType( GeneralMappingsFamily(PermutationsFamily,PermutationsFamily), IsEmbeddingImprimitiveWreathProductPermGroup), embeddings := [], permimpr:=permimpr); SetWreathProductInfo( grp, info ); # return the group return grp; end); InstallMethod( WreathProduct,"permgroups: imprimitive", true, [ IsPermGroup, IsPermGroup ], 0, WreathProductImprimitiveAction); InstallOtherMethod( WreathProduct,"permgroups and action", true, [ IsPermGroup, IsPermGroup, IsSPGeneralMapping ], 0, WreathProductImprimitiveAction); ############################################################################# ## #M Embedding( , ) . . . . . . . . . . . . . . . . . . make embedding ## InstallMethod( Embedding,"perm wreath product", true, [ IsPermGroup and HasWreathProductInfo, IsPosInt ], 0, function( W, i ) local emb, info; info := WreathProductInfo( W ); if IsBound( info.embeddings[i] ) then return info.embeddings[i]; fi; if i<=info.degI then emb := Objectify( info.embeddingType , rec( component := i ) ); if IsBound(info.productType) and info.productType=true then SetAsGroupGeneralMappingByImages(emb,GroupHomomorphismByImagesNC( info.groups[1],W,GeneratorsOfGroup(info.groups[1]), info.basegens[i])); fi; elif i=info.degI+1 then emb:= GroupHomomorphismByImagesNC(info.I,W,GeneratorsOfGroup(info.I), info.hgens); emb:= GroupHomomorphismByImagesNC(info.groups[2],W, GeneratorsOfGroup(info.groups[2]), List(GeneratorsOfGroup(info.groups[2]), i->ImageElm(emb,ImageElm(info.alpha,i)))); SetIsInjective(emb,true); else Error("no embedding defined"); fi; SetRange( emb, W ); info.embeddings[i] := emb; return emb; end ); ############################################################################# ## #M Source( ) . . . . . . . . . . . . . . . . . . . . . . of embedding ## InstallMethod( Source,"perm wreath product embedding", true, [ IsEmbeddingWreathProductPermGroup ], 0, emb -> WreathProductInfo( Range( emb ) ).groups[1] ); ############################################################################# ## #M ImagesRepresentative( , ) . . . . . . . . . . . . of embedding ## InstallMethod( ImagesRepresentative, "imprim perm wreath product embedding",FamSourceEqFamElm, [ IsEmbeddingImprimitiveWreathProductPermGroup, IsMultiplicativeElementWithInverse ], 0, function( emb, g ) return g ^ WreathProductInfo( Range( emb ) ).perms[ emb!.component ]; end ); ############################################################################# ## #M PreImagesRepresentative( , ) . . . . . . . . . . . of embedding ## InstallMethod( PreImagesRepresentative, "imprim perm wreath product embedding", FamRangeEqFamElm, [ IsEmbeddingImprimitiveWreathProductPermGroup, IsMultiplicativeElementWithInverse ], 0, function( emb, g ) local info; info := WreathProductInfo( Range( emb ) ); if not g in info.base then return fail; fi; return RestrictedPermNC( g, info.components[ emb!.component ] ) ^ (info.perms[ emb!.component ] ^ -1); end ); ############################################################################# ## #M ViewObj( ) . . . . . . . . . . . . . . . . . . . . view embedding ## InstallMethod( ViewObj, "for embedding into wreath product", true, [ IsEmbeddingWreathProductPermGroup ], 0, function( emb ) Print( Ordinal( emb!.component ), " embedding into ", Range( emb ) ); end ); ############################################################################# ## #M PrintObj( ) . . . . . . . . . . . . . . . . . . . . print embedding ## InstallMethod( PrintObj, "for embedding into wreath product", true, [ IsEmbeddingWreathProductPermGroup ], 0, function( emb ) Print( "Embedding( ", Range( emb ), ", ", emb!.component, " )" ); end ); ############################################################################# ## #M Projection( ) . . . . . . . . . . . . . . projection of wreath on top ## InstallOtherMethod( Projection,"perm wreath product", true, [ IsPermGroup and HasWreathProductInfo ],0, function( W ) local info,proj,H; info := WreathProductInfo( W ); if IsBound( info.projection ) then return info.projection; fi; if IsBound(info.permimpr) and info.permimpr=true then proj:=ActionHomomorphism(W,info.components,OnSets,"surjective"); else H:=info.groups[2]; proj:=List(info.basegens,i->One(H)); proj:=GroupHomomorphismByImagesNC(W,H, Concatenation(info.basegens,info.hgens), Concatenation(proj,GeneratorsOfGroup(H))); fi; SetKernelOfMultiplicativeGeneralMapping(proj,info.base); info.projection:=proj; return proj; end); ############################################################################# ## #F WreathProductProductAction( , ) wreath product in product action ## InstallGlobalFunction( WreathProductProductAction, function( G, H ) local W, domG, domI, map, I, deg, n, N, gens, gen, i, list, p, adic, q, Val, val, rans,basegens,hgens,info,degI; # get the domain of operation of and if IsPermGroup( G ) then domG := MovedPoints( G ); elif IsGroupHomomorphism( G ) and IsPermGroup( Range( G ) ) then domG := MovedPoints( Range( G ) ); G := Image( G ); else Error( "WreathProductProductAction: must be perm group or homomorphism" ); fi; deg := Length( domG ); if IsPermGroup( H ) then domI := MovedPoints( H ); map := IdentityMapping( H ); elif IsGroupHomomorphism( H ) and IsPermGroup( Range( H ) ) then map := H; domI := MovedPoints( Range( H ) ); H := Source( H ); else Error( "WreathProductProductAction: must be perm group or homomorphism" ); fi; I := Image( map ); if IsEmpty( domI ) then domI := [ 1 ]; fi; degI := Length( domI ); n := Length( domI ); N := deg ^ n; gens := [ ]; basegens:=List([1..n],i->[]); for gen in GeneratorsOfGroup( G ) do val := 1; for i in [ 1 .. n ] do Val := val * deg; list := [ ]; for p in [ 0 .. N - 1 ] do q := QuoInt( p mod Val, val ) + 1; Add( list, p + ( Position( domG, domG[ q ] ^ gen ) - q ) * val ); od; q:=PermList( list + 1 ); Add(gens,q); Add(basegens[i],q); val := Val; od; od; hgens:=[]; for gen in GeneratorsOfGroup( I ) do list := [ ]; for p in [ 0 .. N - 1 ] do adic := [ ]; for i in [ 0 .. n - 1 ] do adic[ Position( domI, domI[ n - i ] ^ gen ) ] := p mod deg; p := QuoInt( p, deg ); od; q := 0; for i in adic do q := q * deg + i; od; Add( list, q ); od; q:=PermList( list + 1 ); Add(gens,q); Add(hgens,q); od; W := GroupByGenerators( gens, () ); # `gens' arose from `PermList' SetSize( W, Size( G ) ^ n * Size( I ) ); # note random method rans := Filtered( [ G, H ], i -> IsBound( StabChainOptions( i ).random ) ); if Length( rans ) > 0 then SetStabChainOptions( W, rec( random := Minimum( List( rans, i -> StabChainOptions( i ).random ) ) ) ); fi; info := rec( groups := [G,H], alpha := map, I := I, degI := degI, productType:=true, basegens := basegens, base := SubgroupNC(W,Flat(basegens)), hgens := hgens, embeddingType := NewType( GeneralMappingsFamily(PermutationsFamily,PermutationsFamily), IsEmbeddingProductActionWreathProductPermGroup), embeddings := []); SetWreathProductInfo( W, info ); return W; end ); ############################################################################## ## #M SemidirectProduct for permutation groups ## ## Use regular action ## Original version by Derek Holt, 6/9/96, in first GAP3 version of xmod ## InstallMethod( SemidirectProduct, "generic method for permutation groups", [ IsPermGroup, IsGroupHomomorphism, IsPermGroup ], function( R, map, S ) local P, genP, genR, genS, L3, perm, r, s, ordS, genno, LS, info, aut; # Take the action of R on S by conjugation. LS := AsSSortedList( S ); genP := [ ]; genR := GeneratorsOfGroup( R ); genS := GeneratorsOfGroup( S ); for r in genR do aut:= Image( map, r ); L3 := List( LS, x -> Position( LS, Image( aut, x ) ) ); Add( genP, PermList( L3 ) ); od; # Check order of group at this stage, to see if the action is faithful. # If not, adjoin the action of R as a permutation group. P := Group( genP, () ); # `genP' arose from `PermList' if ( Size( P ) <> Size( R ) ) then ordS := Size( S ); genno := 0; for r in genR do genno := genno + 1; genP[ genno ] := genP[ genno ] * PermList( Concatenation( [1..ordS], ListPerm( r ) + ordS ) ); od; fi; # Take the action of S on S by right multiplication. for s in genS do L3 := List( LS, x -> Position( LS, x*s ) ); Add( genP, PermList( L3 ) ); od; P := Group( genP, () ); # `genP' arose from `PermList' info := rec( groups := [ R, S ], lenlist := [ 0, Length( genR ), Length( genP ) ], embeddings := [ ], projections := true ); SetSemidirectProductInfo( P, info ); return P; end ); InstallMethod( SemidirectProduct, "Induced permutation automorphisms", [ IsPermGroup, IsGroupHomomorphism, IsPermGroup ], function( U, map, N ) local Ugens,imgs,conj,cg,auc,cghom,d,embn,embs,l,u,P,info; Ugens:=GeneratorsOfGroup(U); imgs:=List(Ugens,x->Image(map,x)); if ForAll(imgs,IsConjugatorIsomorphism) then conj:=List(imgs,ConjugatorOfConjugatorIsomorphism); cg:=Group(conj,()); auc:=ClosureGroup(N,conj); cghom:=GroupHomomorphismByImagesNC(U,cg,Ugens,conj); d:=DirectProduct(U,auc); embn:=Embedding(d,2); embs:=Embedding(d,1); # images of generators of U l:=List([1..Length(imgs)],x->Image(embn,conj[x])*Image(embs,Ugens[x])); u:=SubgroupNC(d,l); if Size(u)=Size(U) then # so the conjugating elements don't generate # something extra # (i.e. the map U->S_N, u->conj.perm. of auto is # a hom.) P:=ClosureGroup(Image(embn,N),l); embs:=GroupHomomorphismByImagesNC(U,P,Ugens,l); info := rec( groups := [ U, N ], embeddings := [embs,RestrictedMapping(embn,N) ], projections := RestrictedMapping(Projection(d,1),P)); SetSemidirectProductInfo( P, info ); return P; fi; fi; TryNextMethod(); end); ############################################################################## ## #M Embedding for permutation semidirect products ## InstallMethod( Embedding, "generic method for perm semidirect products", true, [ IsPermGroup and HasSemidirectProductInfo, IsPosInt ], 0, function( D, i ) local info, G, genG, imgs, hom; info := SemidirectProductInfo( D ); if IsBound( info.embeddings[i] ) then return info.embeddings[i]; fi; G := info.groups[i]; genG := GeneratorsOfGroup( G ); imgs := GeneratorsOfGroup( D ){[info.lenlist[i]+1 .. info.lenlist[i+1]]}; hom := GroupHomomorphismByImages( G, D, genG, imgs ); SetIsInjective( hom, true ); info.embeddings[i] := hom; return hom; end ); ############################################################################## ## #M Projection for permutation semidirect products ## InstallOtherMethod( Projection, "generic method for perm semidirect products", true, [ IsPermGroup and HasSemidirectProductInfo ], 0, function( D ) local info, genD, G, genG, imgs, hom, ker, list; info := SemidirectProductInfo( D ); if not IsBool( info.projections ) then return info.projections; fi; G := info.groups[1]; genG := GeneratorsOfGroup( G ); genD := GeneratorsOfGroup( D ); list := [ info.lenlist[2]+1 .. info.lenlist[3] ]; imgs := Concatenation( genG, List( list, j -> One( G ) ) ); hom := GroupHomomorphismByImagesNC( D, G, genD, imgs ); SetIsSurjective( hom, true ); ker := Subgroup( D, genD{ list } ); SetKernelOfMultiplicativeGeneralMapping( hom, ker ); info.projections := hom; return hom; end ); ############################################################################# ## #E gap-4r6p5/lib/ratfun.gd0000644000175000017500000017147612172557254013544 0ustar billbill############################################################################# ## #W ratfun.gd GAP Library Frank Celler #W Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the categories, attributes, properties and operations ## for rational functions, Laurent polynomials and polynomials and their ## families. ## Warning: ## If the mechanism for storing attributes is changed, ## `LaurentPolynomialByExtRep' must be changed as well. ## Also setter methods for coefficients and/or indeterminate number will be ## ignored when creating Laurent polynomials. ## (This is ugly and inconsistent, but crucial to get speed. ahulpke, May99) ############################################################################# ## #I InfoPoly ## ## <#GAPDoc Label="InfoPoly"> ## ## ## ## ## is the info class for univariate polynomials. ## ## ## <#/GAPDoc> ## DeclareInfoClass( "InfoPoly" ); ############################################################################# ## #C IsPolynomialFunction() #C IsRationalFunction() ## ## <#GAPDoc Label="IsPolynomialFunction"> ## ## ## ## ## ## A rational function is an element of the quotient field of a polynomial ## ring over an UFD. It is represented as a quotient of two polynomials, ## its numerator (see ) and ## its denominator (see ) ##

## A polynomial function is an element of a polynomial ring (not ## necessarily an UFD), or a rational function. ##

## &GAP; considers as a subcategory of ## . ## ## ## <#/GAPDoc> ## DeclareCategory( "IsPolynomialFunction", IsRingElementWithInverse and IsZDFRE); DeclareCategory( "IsRationalFunction", IsPolynomialFunction); DeclareCategoryCollections( "IsPolynomialFunction" ); DeclareCategoryCollections( "IsRationalFunction" ); ############################################################################# ## #C IsPolynomialFunctionsFamilyElement() #C IsRationalFunctionsFamilyElement() ## ## ## ## ## ## ## A polynomial is an element of a polynomial functions family. If the ## underlying domain is an UFD, it is even a ## . ## ## ## DeclareCategory("IsPolynomialFunctionsFamilyElement",IsPolynomialFunction); DeclareCategory("IsRationalFunctionsFamilyElement", IsRationalFunction and IsPolynomialFunctionsFamilyElement ); ############################################################################# ## #C IsPolynomialFunctionsFamily() #C IsRationalFunctionsFamily() ## ## <#GAPDoc Label="IsPolynomialFunctionsFamily"> ## ## ## ## ## ## is the category of a family of ## polynomials. ## For families over an UFD, the category becomes ## (as rational functions and ## quotients are only provided for families over an UFD.) ## ##

## fam:=RationalFunctionsFamily(FamilyObj(1)); ## NewFamily( "RationalFunctionsFamily(...)", [ 618, 620 ], ## [ 82, 85, 89, 93, 97, 100, 103, 107, 111, 618, 620 ] ) ## ]]> ## ## ## <#/GAPDoc> ## DeclareCategory( "IsPolynomialFunctionsFamily", IsFamily ); DeclareCategory( "IsRationalFunctionsFamily", IsPolynomialFunctionsFamily and IsUFDFamily ); ############################################################################# ## #C IsRationalFunctionOverField() ## ## ## ## ## ## Indicates that the coefficients family for the rational function obj ## is a field. In this situation it is permissible to move coefficients ## from the denominator in the numerator, in particular the quotient of a ## polynomial by a coefficient is again a polynomial. This last property ## does not necessarily hold for polynomials over arbitrary rings. ## ## ## DeclareCategory("IsRationalFunctionOverField", IsRationalFunction ); ############################################################################# ## #A RationalFunctionsFamily( ) ## ## <#GAPDoc Label="RationalFunctionsFamily"> ## ## ## ## ## creates a family containing rational functions with coefficients ## in fam. ## All elements of the are ## rational functions (see ). ## ## ## <#/GAPDoc> ## DeclareAttribute( "RationalFunctionsFamily", IsFamily ); ############################################################################# ## #A CoefficientsFamily( ) ## ## <#GAPDoc Label="CoefficientsFamily"> ## ## ## ## ## If rffam has been created as ## RationalFunctionsFamily(cfam) this attribute holds the ## coefficients family cfam. ##

## &GAP; does not embed the base ring in the polynomial ring. While ## multiplication and addition of base ring elements to rational functions ## return the expected results, polynomials and rational functions are not ## equal. ## 1=Indeterminate(Rationals)^0; ## false ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "CoefficientsFamily", IsFamily ); ############################################################################# ## #A NumeratorOfRationalFunction( ) ## ## <#GAPDoc Label="NumeratorOfRationalFunction"> ## ## ## ## ## returns the numerator of the rational function ratfun. ##

## As no proper multivariate gcd has been implemented yet, numerators and ## denominators are not guaranteed to be reduced! ## ## ## <#/GAPDoc> ## DeclareAttribute( "NumeratorOfRationalFunction", IsPolynomialFunction); ############################################################################# ## #A DenominatorOfRationalFunction( ) ## ## <#GAPDoc Label="DenominatorOfRationalFunction"> ## ## ## ## ## returns the denominator of the rational function ratfun. ##

## As no proper multivariate gcd has been implemented yet, numerators and ## denominators are not guaranteed to be reduced! ## x:=Indeterminate(Rationals,1);;y:=Indeterminate(Rationals,2);; ## gap> DenominatorOfRationalFunction((x*y+x^2)/y); ## y ## gap> NumeratorOfRationalFunction((x*y+x^2)/y); ## x^2+x*y ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "DenominatorOfRationalFunction", IsRationalFunction ); ############################################################################# ## #P IsPolynomial( ) ## ## <#GAPDoc Label="IsPolynomial"> ## ## ## ## ## A polynomial is a rational function whose denominator is one. (If the ## coefficients family forms a field this is equivalent to the denominator ## being constant.) ##

## If the base family is not a field, it may be impossible to represent the ## quotient of a polynomial by a ring element as a polynomial again, but it ## will have to be represented as a rational function. ## IsPolynomial((x*y+x^2*y^3)/y); ## true ## gap> IsPolynomial((x*y+x^2)/y); ## false ## ]]> ## ## ## <#/GAPDoc> ## DeclareProperty( "IsPolynomial", IsPolynomialFunction ); ############################################################################# ## #A AsPolynomial( ) ## ## <#GAPDoc Label="AsPolynomial"> ## ## ## ## ## If poly is a rational function that is a polynomial this attribute ## returns an equal rational function p such that p is equal ## to its numerator and the denominator of p is one. ## AsPolynomial((x*y+x^2*y^3)/y); ## x^2*y^2+x ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "AsPolynomial", IsPolynomialFunction and IsPolynomial); ############################################################################# ## #P IsUnivariateRationalFunction( ) ## ## <#GAPDoc Label="IsUnivariateRationalFunction"> ## ## ## ## ## A rational function is univariate if its numerator and its denominator ## are both polynomials in the same one indeterminate. The attribute ## can be used to obtain ## the number of this common indeterminate. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsUnivariateRationalFunction", IsRationalFunction ); ############################################################################# ## #P IsUnivariatePolynomial( ) ## ## <#GAPDoc Label="IsUnivariatePolynomial"> ## ## ## ## ## A univariate polynomial is a polynomial in only one indeterminate. ## ## ## <#/GAPDoc> ## DeclareSynonymAttr("IsUnivariatePolynomial", IsPolynomial and IsUnivariateRationalFunction); ############################################################################# ## #P IsLaurentPolynomial( ) ## ## <#GAPDoc Label="IsLaurentPolynomial"> ## ## ## ## ## A Laurent polynomial is a univariate rational function whose denominator ## is a monomial. Therefore every univariate polynomial is a ## Laurent polynomial. ##

## The attribute gives a ## compact representation as Laurent polynomial. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsLaurentPolynomial", IsPolynomialFunction ); InstallTrueMethod( IsUnivariateRationalFunction,IsLaurentPolynomial ); InstallTrueMethod( IsLaurentPolynomial, IsUnivariatePolynomial ); ############################################################################# ## #P IsConstantRationalFunction( ) ## ## <#GAPDoc Label="IsConstantRationalFunction"> ## ## ## ## ## A constant rational function is a function whose numerator and ## denominator are polynomials of degree 0. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsConstantRationalFunction", IsPolynomialFunction ); InstallTrueMethod( IsUnivariateRationalFunction, IsConstantRationalFunction ); ############################################################################# ## #P IsZeroRationalFunction( ) ## ## ## ## ## ## This property indicates whether ratfun is the zero element of the ## field of rational functions. ## ## ## DeclareSynonymAttr("IsZeroRationalFunction",IsZero and IsPolynomialFunction); InstallTrueMethod( IsConstantRationalFunction,IsZeroRationalFunction ); ############################################################################# ## #R IsRationalFunctionDefaultRep() ## ## <#GAPDoc Label="IsRationalFunctionDefaultRep"> ## ## ## ## ## is the default representation of rational functions. A rational function ## in this representation is defined by the attributes ## and ## , ## the values of which are external representations of polynomials. ## ## ## <#/GAPDoc> ## DeclareRepresentation("IsRationalFunctionDefaultRep", IsComponentObjectRep and IsAttributeStoringRep and IsRationalFunction, ["zeroCoefficient","numerator","denominator"] ); ############################################################################# ## #R IsPolynomialDefaultRep() ## ## <#GAPDoc Label="IsPolynomialDefaultRep"> ## ## ## ## ## is the default representation of polynomials. A polynomial ## in this representation is defined by the components ## and where ## is the ## external representation of the polynomial. ## ## ## <#/GAPDoc> ## DeclareRepresentation("IsPolynomialDefaultRep", IsComponentObjectRep and IsAttributeStoringRep and IsPolynomialFunction and IsPolynomial,["zeroCoefficient","numerator"]); ############################################################################# ## #R IsLaurentPolynomialDefaultRep() ## ## <#GAPDoc Label="IsLaurentPolynomialDefaultRep"> ## ## ## ## ## This representation is used for Laurent polynomials and univariate ## polynomials. It represents a Laurent polynomial via the attributes ## and ## . ## ## ## <#/GAPDoc> ## DeclareRepresentation("IsLaurentPolynomialDefaultRep", IsComponentObjectRep and IsAttributeStoringRep and IsPolynomialFunction and IsLaurentPolynomial, [] ); ############################################################################# ## #R IsUnivariateRationalFunctionDefaultRep() ## ## ## ## ## ## This representation is used for univariate rational functions ## polynomials. It represents a univariate rational function via the attributes ## and ## . ## ## ## DeclareRepresentation("IsUnivariateRationalFunctionDefaultRep", IsComponentObjectRep and IsAttributeStoringRep and IsPolynomialFunction and IsUnivariateRationalFunction, [] ); ## <#GAPDoc Label="[1]{ratfun}"> ## External representation of polynomials ## The representation of a polynomials is a list of the form ## [mon,coeff,mon,coeff,...] where mon is a monomial in ## expanded form (that is given as list) and coeff its coefficient. The ## monomials must be sorted according to the total degree/lexicographic ## order (This is the same as given by the grlex monomial ordering, ## see ). We call ## this the external representation of a polynomial. (The ## reason for ordering is that addition of polynomials becomes linear in ## the number of monomials instead of quadratic; the reason for the ## particular ordering chose is that it is compatible with multiplication ## and thus gives acceptable performance for quotient calculations.) ## <#/GAPDoc> ## ## <#GAPDoc Label="[3]{ratfun}"> ## The operations , ## and ## are used to ## construct objects in the three basic representations for rational ## functions. ## <#/GAPDoc> ############################################################################# ## #A ExtRepNumeratorRatFun( ) ## ## <#GAPDoc Label="ExtRepNumeratorRatFun"> ## ## ## ## ## returns the external representation of the numerator polynomial of the ## rational function ratfun. Numerator and denominator are not guaranteed ## to be cancelled against each other. ## ## ## <#/GAPDoc> ## DeclareAttribute("ExtRepNumeratorRatFun",IsPolynomialFunction); ############################################################################# ## #A ExtRepDenominatorRatFun( ) ## ## <#GAPDoc Label="ExtRepDenominatorRatFun"> ## ## ## ## ## returns the external representation of the denominator polynomial of the ## rational function ratfun. Numerator and denominator are not guaranteed ## to be cancelled against each other. ## ## ## <#/GAPDoc> ## DeclareAttribute("ExtRepDenominatorRatFun",IsRationalFunction); ############################################################################# ## #O ZeroCoefficientRatFun( ) ## ## <#GAPDoc Label="ZeroCoefficientRatFun"> ## ## ## ## ## returns the zero of the coefficient ring. This might be needed to ## represent the zero polynomial for which the external representation of ## the numerator is the empty list. ## ## ## <#/GAPDoc> ## DeclareOperation("ZeroCoefficientRatFun",[IsPolynomialFunction]); ############################################################################# ## #A ExtRepPolynomialRatFun( ) ## ## <#GAPDoc Label="ExtRepPolynomialRatFun"> ## ## ## ## ## returns the external representation of a polynomial. The difference to ## is that rational functions might know ## to be a polynomial but can still have a non-vanishing denominator. ## In this case ## has to call a quotient routine. ## ## ## <#/GAPDoc> ## DeclareAttribute("ExtRepPolynomialRatFun",IsPolynomialFunction and IsPolynomial); ############################################################################# ## #A CoefficientsOfLaurentPolynomial( ) ## ## <#GAPDoc Label="CoefficientsOfLaurentPolynomial"> ## ## ## ## ## For a Laurent polynomial laurent, this function returns a pair ## [cof, val], ## consisting of the coefficient list (in ascending order) cof and the ## valuation val of laurent. ## p:=LaurentPolynomialByCoefficients(FamilyObj(1), ## > [1,2,3,4,5],-2); ## 5*x^2+4*x+3+2*x^-1+x^-2 ## gap> NumeratorOfRationalFunction(p);DenominatorOfRationalFunction(p); ## 5*x^4+4*x^3+3*x^2+2*x+1 ## x^2 ## gap> CoefficientsOfLaurentPolynomial(p*p); ## [ [ 1, 4, 10, 20, 35, 44, 46, 40, 25 ], -4 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "CoefficientsOfLaurentPolynomial", IsLaurentPolynomial ); DeclareSynonym( "CoefficientsOfUnivariateLaurentPolynomial", CoefficientsOfLaurentPolynomial); ############################################################################# ## #A IndeterminateNumberOfUnivariateRationalFunction( ) ## ## <#GAPDoc Label="IndeterminateNumberOfUnivariateRationalFunction"> ## ## ## ## ## returns the number of the indeterminate in which the univariate rational ## function rfun is expressed. (This also provides a way to obtain the ## number of a given indeterminate.) ##

## A constant rational function might not possess an indeterminate number. In ## this case ## will default to a value of 1. ## Therefore two univariate polynomials may be considered to be in the same ## univariate polynomial ring if their indeterminates have the same number ## or one if of them is constant. (see also  ## and ). ## ## ## <#/GAPDoc> ## DeclareAttribute( "IndeterminateNumberOfUnivariateRationalFunction", IsUnivariateRationalFunction ); ## <#GAPDoc Label="[2]{ratfun}"> ## Algorithms should use only the attributes ## , ## , ## , ## and ## –if the univariate function is not constant– ## as the ## low-level interface to work with a polynomial. ## They should not refer to the actual representation used. ## <#/GAPDoc> ############################################################################# ## #O LaurentPolynomialByCoefficients( , , [,] ) ## ## <#GAPDoc Label="LaurentPolynomialByCoefficients"> ## ## ## ## ## constructs a Laurent polynomial over the coefficients ## family fam and in the indeterminate ind (defaulting to 1) ## with the coefficients given by coefs and valuation val. ## ## ## <#/GAPDoc> ## DeclareOperation( "LaurentPolynomialByCoefficients", [ IsFamily, IsList, IsInt, IsInt ] ); DeclareSynonym( "UnivariateLaurentPolynomialByCoefficients", LaurentPolynomialByCoefficients); ############################################################################# ## #F LaurentPolynomialByExtRep( , , , ) #F LaurentPolynomialByExtRepNC( , , , ) ## ## <#GAPDoc Label="LaurentPolynomialByExtRep"> ## ## ## ## ## ## creates a Laurent polynomial in the family fam with [cofs,val] as ## value of . No coefficient shifting is ## performed. This is the lowest level function to create a Laurent ## polynomial but will rely on the coefficients being shifted properly and ## will not perform any tests. Unless this is guaranteed for the ## parameters, ## should be used. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "LaurentPolynomialByExtRepNC"); DeclareSynonym("LaurentPolynomialByExtRep",LaurentPolynomialByExtRepNC); ############################################################################# ## #F PolynomialByExtRep( , ) #F PolynomialByExtRepNC( , ) ## ## <#GAPDoc Label="PolynomialByExtRep"> ## ## ## ## ## ## constructs a polynomial ## (in the representation ) ## in the rational function family rfam, the polynomial itself is given ## by the external representation extrep. ##

## The variant does not perform any test ## of the arguments and thus potentially can create invalid objects. It only ## should be used if speed is required and the arguments are known to be ## in correct form. ## fam:=RationalFunctionsFamily(FamilyObj(1));; ## gap> p:=PolynomialByExtRep(fam,[[1,2],1,[2,1,15,7],3]); ## 3*y*x_15^7+x^2 ## gap> q:=p/(p+1); ## (3*y*x_15^7+x^2)/(3*y*x_15^7+x^2+1) ## gap> ExtRepNumeratorRatFun(q); ## [ [ 1, 2 ], 1, [ 2, 1, 15, 7 ], 3 ] ## gap> ExtRepDenominatorRatFun(q); ## [ [ ], 1, [ 1, 2 ], 1, [ 2, 1, 15, 7 ], 3 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "PolynomialByExtRep" ); DeclareGlobalFunction( "PolynomialByExtRepNC" ); ############################################################################# ## #F RationalFunctionByExtRep( , , ) #F RationalFunctionByExtRepNC( , , ) ## ## <#GAPDoc Label="RationalFunctionByExtRep"> ## ## ## ## ## ## constructs a rational function (in the representation ## ) in the rational function ## family rfam, ## the rational function itself is given by the external representations ## num and den for numerator and denominator. ## No cancellation takes place. ##

## The variant does not perform any ## test of the arguments and thus potentially can create illegal objects. ## It only should be used if speed is required and the arguments are known ## to be in correct form. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "RationalFunctionByExtRep" ); DeclareGlobalFunction( "RationalFunctionByExtRepNC" ); ############################################################################# ## #F UnivariateRationalFunctionByExtRep(,,, , ) #F UnivariateRationalFunctionByExtRepNC(,,, , ) ## ## ## ## ## ## ## creates a univariate rational function in the family fam with ## [ncof,dcof,val] as ## value of . ## No coefficient shifting is performed. ## This is the lowest level function to create a ## univariate rational function but will rely on the coefficients being ## shifted properly. Unless this is ## guaranteed for the parameters, ## should be used. ## No cancellation is performed. ##

## The variant does not ## perform any test of ## the arguments and thus potentially can create invalid objects. It only ## should be used if speed is required and the arguments are known to be ## in correct form. ## ## ## DeclareGlobalFunction( "UnivariateRationalFunctionByExtRepNC"); DeclareSynonym("UnivariateRationalFunctionByExtRep", UnivariateRationalFunctionByExtRepNC); ############################################################################# ## #F RationalFunctionByExtRepWithCancellation( , , ) ## ## <#GAPDoc Label="RationalFunctionByExtRepWithCancellation"> ## ## ## ## ## constructs a rational function as ## does but tries to cancel out common factors of numerator and denominator, ## calling . ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "RationalFunctionByExtRepWithCancellation" ); ############################################################################# ## #A IndeterminateOfUnivariateRationalFunction( ) ## ## <#GAPDoc Label="IndeterminateOfUnivariateRationalFunction"> ## ## ## ## ## returns the indeterminate in which the univariate rational ## function rfun is expressed. (cf. ## .) ## IndeterminateNumberOfUnivariateRationalFunction(z); ## 3 ## gap> IndeterminateOfUnivariateRationalFunction(z^5+z); ## X ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "IndeterminateOfUnivariateRationalFunction", IsUnivariateRationalFunction ); DeclareSynonym("IndeterminateOfLaurentPolynomial", IndeterminateOfUnivariateRationalFunction); ############################################################################# ## #F IndeterminateNumberOfLaurentPolynomial() ## ## <#GAPDoc Label="IndeterminateNumberOfLaurentPolynomial"> ## ## ## ## ## Is a synonym for ## . ## ## ## <#/GAPDoc> ## DeclareSynonymAttr("IndeterminateNumberOfLaurentPolynomial", IndeterminateNumberOfUnivariateRationalFunction); DeclareSynonymAttr("IndeterminateNumberOfUnivariateLaurentPolynomial", IndeterminateNumberOfUnivariateRationalFunction); ############################################################################# ## #O IndeterminateName(,) #O HasIndeterminateName(,) #O SetIndeterminateName(,,) ## ## <#GAPDoc Label="IndeterminateName"> ## ## ## ## ## ## ## assigns the name name to ## indeterminate nr in the rational functions family fam. ## It issues an error if the indeterminate was already named. ##

## returns the name of the nr-th ## indeterminate (and returns fail if no name has been assigned). ##

## tests whether indeterminate nr ## has already been assigned a name. ##

## IndeterminateName(FamilyObj(x),2); ## "y" ## gap> HasIndeterminateName(FamilyObj(x),4); ## false ## gap> SetIndeterminateName(FamilyObj(x),10,"bla"); ## gap> Indeterminate(GF(3),10); ## bla ## ]]> ##

## As a convenience there is a special method installed for SetName ## that will assign a name to an indeterminate. ##

## a:=Indeterminate(GF(3),5); ## x_5 ## gap> SetName(a,"ah"); ## gap> a^5+a; ## ah^5+ah ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "IndeterminateName", [IsPolynomialFunctionsFamily,IsPosInt]); DeclareOperation( "HasIndeterminateName", [IsPolynomialFunctionsFamily,IsPosInt]); DeclareOperation( "SetIndeterminateName", [IsPolynomialFunctionsFamily,IsPosInt,IsString]); ############################################################################# ## #A CoefficientsOfUnivariatePolynomial( ) ## ## <#GAPDoc Label="CoefficientsOfUnivariatePolynomial"> ## ## ## ## ## returns the coefficient ## list of the polynomial pol, sorted in ascending order. ## (It returns the empty list if pol is 0.) ## ## ## <#/GAPDoc> ## DeclareAttribute("CoefficientsOfUnivariatePolynomial",IsUnivariatePolynomial); ############################################################################# ## #A DegreeOfLaurentPolynomial( ) ## ## <#GAPDoc Label="DegreeOfLaurentPolynomial"> ## ## ## ## ## The degree of a univariate (Laurent) polynomial pol is the largest ## exponent n of a monomial x^n of pol. The degree of ## a zero polynomial is defined to be -infinity. ## p:=UnivariatePolynomial(Rationals,[1,2,3,4],1); ## 4*x^3+3*x^2+2*x+1 ## gap> UnivariatePolynomialByCoefficients(FamilyObj(1),[9,2,3,4],73); ## 4*x_73^3+3*x_73^2+2*x_73+9 ## gap> CoefficientsOfUnivariatePolynomial(p); ## [ 1, 2, 3, 4 ] ## gap> DegreeOfLaurentPolynomial(p); ## 3 ## gap> DegreeOfLaurentPolynomial(Zero(p)); ## -infinity ## gap> IndeterminateNumberOfLaurentPolynomial(p); ## 1 ## gap> IndeterminateOfLaurentPolynomial(p); ## x ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "DegreeOfLaurentPolynomial", IsLaurentPolynomial ); DeclareSynonym( "DegreeOfUnivariateLaurentPolynomial", DegreeOfLaurentPolynomial); BindGlobal("DEGREE_ZERO_LAURPOL",Ninfinity); ############################################################################# ## #O UnivariatePolynomialByCoefficients( , , ) ## ## <#GAPDoc Label="UnivariatePolynomialByCoefficients"> ## ## ## ## ## constructs an univariate polynomial over the coefficients family ## fam and in the indeterminate ind with the coefficients given by ## coefs. This function should be used in algorithms to create ## polynomials as it avoids overhead associated with ## . ## ## ## <#/GAPDoc> ## DeclareOperation( "UnivariatePolynomialByCoefficients", [ IsFamily, IsList, IsInt ] ); ############################################################################# ## #O UnivariatePolynomial( , [, ] ) ## ## <#GAPDoc Label="UnivariatePolynomial"> ## ## ## ## ## constructs an univariate polynomial over the ring ring in the ## indeterminate ind with the coefficients given by coefs. ## ## ## <#/GAPDoc> ## DeclareOperation( "UnivariatePolynomial", [ IsRing, IsRingElementCollection, IsPosInt ] ); ############################################################################# ## #A CoefficientsOfUnivariateRationalFunction( ) ## ## <#GAPDoc Label="CoefficientsOfUnivariateRationalFunction"> ## ## ## ## ## if rfun is a univariate rational function, this attribute ## returns a list [ ncof, dcof, val ] ## where ncof and dcof are coefficient lists of univariate ## polynomials n and d and a valuation val such that ## rfun = x^{val} \cdot n / d ## where x is the variable with the number given by ## . ## Numerator and denominator are guaranteed to be cancelled. ## ## ## <#/GAPDoc> ## DeclareAttribute( "CoefficientsOfUnivariateRationalFunction", IsUnivariateRationalFunction ); ############################################################################# ## #O UnivariateRationalFunctionByCoefficients(,,,[,]) ## ## <#GAPDoc Label="UnivariateRationalFunctionByCoefficients"> ## ## ## ## ## constructs a univariate rational function over the coefficients ## family fam and in the indeterminate ind (defaulting to 1) with ## numerator and denominator coefficients given by ncof and dcof and ## valuation val. ## ## ## <#/GAPDoc> ## DeclareOperation( "UnivariateRationalFunctionByCoefficients", [ IsFamily, IsList, IsList, IsInt, IsInt ] ); ############################################################################# ## #O Value(,,[,]) #O Value(,[,]) ## ## <#GAPDoc Label="Value"> ## ## Value ## ## ## ## ## The first variant takes a rational function ratfun and specializes ## the indeterminates given in indets to the values given in ## vals, ## replacing the i-th entry in indets by the i-th entry ## in vals. ## If this specialization results in a constant polynomial, ## an element of the coefficient ring is returned. ## If the specialization would specialize the denominator of ratfun ## to zero, an error is raised. ##

## A variation is the evaluation at elements of another ring R, ## for which a multiplication with elements of the coefficient ring of ## ratfun are defined. ## In this situation the identity element of R may be given by a ## further argument one which will be used for x^0 for any ## specialized indeterminate x. ##

## The second version takes an univariate rational function and specializes ## the value of its indeterminate to val. ## Again, an optional argument one may be given. ##

## Value(x*y+y+x^7,[x,y],[5,7]); ## 78167 ## ]]> ##

## Note that the default values for one can lead to different results ## than one would expect: ## For example for a matrix M, the values M+M^0 and M+1 ## are different. ## As ## defaults to the one of the coefficient ring, ## when evaluating matrices in polynomials always the correct one ## should be given! ## ## ## <#/GAPDoc> ## DeclareOperation("Value",[IsPolynomialFunction,IsList,IsList]); ############################################################################# ## #F OnIndeterminates(,) ## ## <#GAPDoc Label="OnIndeterminates"> ## ## ## ## ## A permutation perm acts on the multivariate polynomial poly ## by permuting the indeterminates as it permutes points. ## x:=Indeterminate(Rationals,1);; y:=Indeterminate(Rationals,2);; ## gap> OnIndeterminates(x^7*y+x*y^4,(1,17)(2,28)); ## x_17^7*x_28+x_17*x_28^4 ## gap> Stabilizer(Group((1,2,3,4),(1,2)),x*y,OnIndeterminates); ## Group([ (1,2), (3,4) ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("OnIndeterminates"); ############################################################################# ## #F ConstituentsPolynomial() ## ## ## ## ## ## Given a polynomial pol this function returns a record with ## components ## ## variables: ## ## A list of the variables occuring in pol, ## ## monomials: ## ## A list of the monomials in pol, and ## ## coefficients: ## ## A (corresponding) list of coefficients. ## ## ## ## ## DeclareGlobalFunction("ConstituentsPolynomial"); ## <#GAPDoc Label="[4]{ratfun}"> ## Expanded form of monomials ## A monomial is a product of powers of indeterminates. A monomial is ## stored as a list (we call this the expanded form of the monomial) ## of the form [inum,exp,inum,exp,...] where each inum ## is the number of an indeterminate and exp the corresponding exponent. ## The list must be sorted according to the numbers of the indeterminates. ## Thus for example, if x, y and z are the first three indeterminates, ## the expanded form of the monomial x^5 z^8 = z^8 x^5 is ## [ 1, 5, 3, 8 ]. ## <#/GAPDoc> ############################################################################# ## #F MonomialExtGrlexLess(,) ## ## <#GAPDoc Label="MonomialExtGrlexLess"> ## ## ## ## ## implements comparison of monomial in their external representation by a ## grlex order with x_1>x_2 ## (This is exactly the same as the ordering by ## , ## see  ). ## The function takes two ## monomials a and b in expanded form and returns whether the first is ## smaller than the second. (This ordering is also used by &GAP; ## internally for representing polynomials as a linear combination of ## monomials.) ##

## See section  for details ## on the expanded form of monomials. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("MonomialExtGrlexLess"); ############################################################################# ## #F LeadingMonomial() . . . . . . . . leading monomial of a polynomial ## ## <#GAPDoc Label="LeadingMonomial"> ## ## ## ## ## returns the leading monomial (with respect to the ordering given by ## ) of the polynomial pol as a list ## containing indeterminate numbers and exponents. ## LeadingCoefficient(f,1); ## 1 ## gap> LeadingCoefficient(f,2); ## 9 ## gap> LeadingMonomial(f); ## [ 2, 7 ] ## gap> LeadingCoefficient(f); ## 9 ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "LeadingMonomial", [ IsPolynomialFunction ] ); ############################################################################# ## #O LeadingCoefficient( ) ## ## <#GAPDoc Label="LeadingCoefficient"> ## ## ## ## ## returns the leading coefficient (that is the coefficient of the leading ## monomial, see ) of the polynomial pol. ## ## ## <#/GAPDoc> ## DeclareOperation("LeadingCoefficient", [IsPolynomialFunction]); ############################################################################# ## #F LeadingMonomialPosExtRep(,,) ## ## ## ## ## ## This function takes an external representation ext of a polynomial in ## family fam and returns the position of the leading monomial in ext ## with respect to the monomial order implemented by the function order. ##

## See section  for details ## on the external representation. ## ## ## DeclareGlobalFunction("LeadingMonomialPosExtRep"); ## The following set of functions consider one indeterminate of a multivariate ## polynomial specially ############################################################################# ## #O PolynomialCoefficientsOfPolynomial( , ) ## ## <#GAPDoc Label="PolynomialCoefficientsOfPolynomial"> ## ## ## ## ## returns the ## coefficient list (whose entries are polynomials not involving the ## indeterminate ind) describing the polynomial pol viewed as ## a polynomial in ind. ## Instead of the indeterminate, ## ind can also be an indeterminate number. ## PolynomialCoefficientsOfPolynomial(f,2); ## [ x^5+2, 3*x+3, 0, 0, 0, 4*x, 0, 9 ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "PolynomialCoefficientsOfPolynomial", [ IsPolynomial,IsPosInt]); ############################################################################# ## #O DegreeIndeterminate( , ) ## ## <#GAPDoc Label="DegreeIndeterminate"> ## ## ## ## ## returns the degree of the polynomial pol in the indeterminate ## (or indeterminate number) ind. ## f:=x^5+3*x*y+9*y^7+4*y^5*x+3*y+2; ## 9*y^7+4*x*y^5+x^5+3*x*y+3*y+2 ## gap> DegreeIndeterminate(f,1); ## 5 ## gap> DegreeIndeterminate(f,y); ## 7 ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation("DegreeIndeterminate",[IsPolynomial,IsPosInt]); ############################################################################# ## #A Derivative( [, ] ) ## ## <#GAPDoc Label="Derivative"> ## ## ## ## ## If ratfun is a univariate rational function then ## returns the derivative of ufun by ## its indeterminate. ## For a rational function ratfun, ## the derivative by the indeterminate ind is returned, ## regarding ratfun as univariate in ind. ## Instead of the desired indeterminate, also the number of this ## indeterminate can be given as ind. ## Derivative(f,2); ## 63*y^6+20*x*y^4+3*x+3 ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute("Derivative",IsUnivariateRationalFunction); DeclareOperation("Derivative",[IsPolynomialFunction,IsPosInt]); ############################################################################# ## #O Resultant( , , ) ## ## <#GAPDoc Label="Resultant"> ## ## ## ## ## computes the resultant of the polynomials pol1 and pol2 ## with respect to the indeterminate ind, ## or indeterminate number ind. ## The resultant considers pol1 and pol2 as univariate in ## ind and returns an element of the corresponding base ring ## (which might be a polynomial ring). ## Resultant(x^4+y,y^4+x,1); ## y^16+y ## gap> Resultant(x^4+y,y^4+x,2); ## x^16+x ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "Resultant",[ IsPolynomial, IsPolynomial, IsPosInt]); ############################################################################# ## #O Discriminant( [, ] ) ## ## <#GAPDoc Label="Discriminant"> ## ## ## ## ## If pol is a univariate polynomial then ## returns the discriminant of pol ## by its indeterminate. ## The two-argument form returns the discriminant of a polynomial pol ## by the indeterminate number ind, regarding pol as univariate ## in this indeterminate. Instead of the indeterminate number, the ## indeterminate itself can also be given as ind. ## Discriminant(f,1); ## 20503125*y^28+262144*y^25+27337500*y^22+19208040*y^21+1474560*y^17+136\ ## 68750*y^16+18225000*y^15+6075000*y^14+1105920*y^13+3037500*y^10+648972\ ## 0*y^9+4050000*y^8+900000*y^7+62208*y^5+253125*y^4+675000*y^3+675000*y^\ ## 2+300000*y+50000 ## gap> Discriminant(f,1) = Discriminant(f,x); ## true ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "Discriminant", IsPolynomial ); DeclareOperation( "Discriminant", [ IsPolynomial, IsPosInt ] ); ## Technical functions for rational functions ############################################################################# ## #F CIUnivPols( , ) ## ## <#GAPDoc Label="CIUnivPols"> ## ## ## ## ## This function (whose name stands for ## common indeterminate of univariate polynomials) takes two ## univariate polynomials as arguments. ## If both polynomials are given in the same indeterminate number ## indnum (in this case they are compatible as ## univariate polynomials) it returns indnum. ## In all other cases it returns fail. ## also accepts if either polynomial is constant ## but formally expressed in another indeterminate, in this situation the ## indeterminate of the other polynomial is selected. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("CIUnivPols"); ############################################################################# ## #F TryGcdCancelExtRepPolynomials(,,); ## ## <#GAPDoc Label="TryGcdCancelExtRepPolynomials"> ## ## ## ## ## Let a and b be the external representations of two ## polynomials. ## This function tries to cancel common factors between the corresponding ## polynomials and returns a list [ a', b' ] of ## external representations of cancelled polynomials. ## As there is no proper multivariate GCD ## cancellation is not guaranteed to be optimal. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("TryGcdCancelExtRepPolynomials"); ############################################################################# ## #O HeuristicCancelPolynomials(,,) ## ## <#GAPDoc Label="HeuristicCancelPolynomials"> ## ## ## ## ## is called by to perform the ## actual work. ## It will return either fail or a new list of of external ## representations of cancelled polynomials. ## The cancellation performed is not necessarily optimal. ## ## ## <#/GAPDoc> ## DeclareOperation("HeuristicCancelPolynomialsExtRep", [IsRationalFunctionsFamily,IsList,IsList]); ############################################################################# ## #F QuotientPolynomialsExtRep(,,) ## ## <#GAPDoc Label="QuotientPolynomialsExtRep"> ## ## ## ## ## Let a and b the external representations of two polynomials ## in the rational functions family fam. ## This function computes the external representation of the quotient of ## both polynomials, ## it returns fail if the polynomial described by b does not ## divide the polynomial described by a. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("QuotientPolynomialsExtRep"); ############################################################################# ## #F QuotRemLaurpols(,,) ## ## <#GAPDoc Label="QuotRemLaurpols"> ## ## ## ## ## This internal function for euclidean division of polynomials ## takes two polynomials left and right ## and computes their quotient. No test is performed whether the arguments ## indeed are polynomials. ## Depending on the integer variable mode, which may take values in ## a range from 1 to 4, it returns respectively: ## ## ## the quotient (there might be some remainder), ## ## ## the remainder, ## ## ## a list [q,r] of quotient and remainder, ## ## ## the quotient if there is no remainder and fail otherwise. ## ## ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("QuotRemLaurpols"); ############################################################################# ## #F GcdCoeffs(,) ## ## ## ## ## ## computes the univariate gcd coefficient list from coefficient lists. ## ## ## DeclareGlobalFunction("GcdCoeffs"); ############################################################################# ## #F UnivariatenessTestRationalFunction() ## ## <#GAPDoc Label="UnivariatenessTestRationalFunction"> ## ## ## ## ## takes a rational function f and tests whether it is univariate ## rational function (or even a Laurent polynomial). It returns a list ## [isunivariate, indet, islaurent, cofs]. ##

## If f is a univariate rational function then isunivariate ## is true and indet is the number of the appropriate ## indeterminate. ##

## Furthermore, if f is a Laurent polynomial, then islaurent ## is also true. In this case the fourth entry, cofs, is ## the value of the attribute ## for f. ##

## If isunivariate is true but islaurent is ## false, then cofs is the value of the attribute ## for f. ##

## Otherwise, each entry of the returned list is equal to fail. ## As there is no proper multivariate gcd, this may also happen for the ## rational function which may be reduced to univariate (see example). ## UnivariatenessTestRationalFunction( 50-45*x-6*x^2+x^3 ); ## [ true, 1, true, [ [ 50, -45, -6, 1 ], 0 ] ] ## gap> UnivariatenessTestRationalFunction( (-6*y^2+y^3) / (y+1) ); ## [ true, 2, false, [ [ -6, 1 ], [ 1, 1 ], 2 ] ] ## gap> UnivariatenessTestRationalFunction( (-6*y^2+y^3) / (x+1)); ## [ fail, fail, fail, fail ] ## gap> UnivariatenessTestRationalFunction( ((y+2)*(x+1)) / ((y-1)*(x+1)) ); ## [ fail, fail, fail, fail ] ## ]]> ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("UnivariatenessTestRationalFunction"); ############################################################################# ## #F SpecializedExtRepPol(,,,) ## ## ## ## ## ## specializes the indeterminate ind in the polynomial ext rep to val ## and returns the resulting polynomial ext rep. ## ## ## DeclareGlobalFunction("SpecializedExtRepPol"); ############################################################################# ## #F RandomPol(,[,]) ## ## ## ## ## ## ## ## DeclareGlobalFunction("RandomPol"); ############################################################################# ## #O ZippedSum( , , , ) ## ## <#GAPDoc Label="ZippedSum"> ## ## ## ## ## computes the sum of two external representations of polynomials ## z1 and z2. ## czero is the appropriate coefficient zero and funcs a list ## [ monomial_less, coefficient_sum ] containing a monomial ## comparison and a coefficient addition function. ## This list can be found in the component fam!.zippedSum ## of the rational functions family. ##

## Note that coefficient_sum must be a proper summation ## function, not a function computing differences. ## ## ## <#/GAPDoc> ## DeclareOperation( "ZippedSum", [ IsList, IsList, IsObject, IsList ] ); ############################################################################# ## #O ZippedProduct( , , , ) ## ## <#GAPDoc Label="ZippedProduct"> ## ## ## ## ## computes the product of two external representations of polynomials ## z1 and z2. ## czero is the appropriate coefficient zero and funcs a list ## [ monomial_prod, monomial_less, coefficient_sum, ## coefficient_prod] containing functions to multiply and compare ## monomials, to add and to multiply coefficients. ## This list can be found in the component fam!.zippedProduct ## of the rational functions family. ## ## ## <#/GAPDoc> ## DeclareOperation( "ZippedProduct", [ IsList, IsList, IsObject, IsList ] ); DeclareGlobalFunction( "ProdCoefRatfun" ); DeclareGlobalFunction( "SumCoefRatfun" ); DeclareGlobalFunction( "SumCoefPolynomial" ); ## The following functions are intended to permit the calculations with ## (Laurent) Polynomials over Rings which are not an UFD. In this case it ## is not possible to create the field of rational functions (and thus no ## rational functions family exists. ############################################################################# ## #C IsLaurentPolynomialsFamilyElement ## ## ## ## ## ## constructs a family containing all Laurent polynomials with coefficients ## in family for a family which has a one and is commutative. The ## external representation looks like the one for RationalsFunctionsFamily ## so if one really wants rational functions where the denominator is a ## non-zero-divisor LaurentPolynomialFunctionsFamily can easily be changed ## to RestrictedRationalsFunctionsFamily. ## ## ## DeclareCategory( "IsLaurentPolynomialsFamilyElement", IsRationalFunction ); ############################################################################# ## #C IsUnivariatePolynomialsFamilyElement ## ## ## ## ## ## ## ## DeclareCategory( "IsUnivariatePolynomialsFamilyElement", IsRationalFunction ); ############################################################################# ## #C IsLaurentPolynomialsFamily() ## ## ## ## ## ## At present Laurent polynomials families only exist if the coefficients ## family is commutative and has a one. ##

## ## ## ## DeclareCategory( "IsLaurentPolynomialsFamily", IsFamily and HasOne and IsCommutativeFamily ); ############################################################################# ## #C IsUnivariatePolynomialsFamily ## ## ## ## ## ## At present univariate polynomials families only exist if the coefficients ## family is a skew field. ##

## ## ## ## DeclareCategory( "IsUnivariatePolynomialsFamily", IsFamily ); ## `IsRationalFunctionsFamilyElement', an element of a Laurent ## polynomials family has category `IsLaurentPolynomialsFamilyElement', and ## an element of a univariate polynomials family has category ## `IsUnivariatePolynomialsFamilyElement'. They all lie in the super ## category `IsRationalFunction'. ## ## `IsPolynomial', `IsUnivariatePolynomials', `IsLaurentPolynomial', and ## `IsUnivariateLaurentPolynomial' are properties of rational functions. ## ## The basic operations for rational functions are: ## ## `ExtRepOfObj' ## `ObjByExtRep'. ## ## The basic operations for rational functions which are univariate Laurent ## polynomials are: ## ## `UnivariateLaurentPolynomialByCoefficients' ## `CoefficientsOfUnivariateLaurentPolynomial' ## `IndeterminateNumberOfUnivariateLaurentPolynomial' ## #needed as ``forward''-declaration. DeclareGlobalFunction("MultivariateFactorsPolynomial"); ############################################################################# ## #E gap-4r6p5/lib/grppccom.gi0000644000175000017500000011136312172557252014047 0ustar billbill############################################################################# ## #W grppccom.gi GAP Library Frank Celler #W Alexander Hulpke ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the methods for complements in pc groups ## BindGlobal("HomomorphismsSeries",function(G,h) local r,img,i,gens,img2; r:=ShallowCopy(h); img:=Image(h[Length(h)],G); for i in [Length(h)-1,Length(h)-2..1] do gens:=GeneratorsOfGroup(img); img2:=Image(h[i],G); r[i]:=GroupHomomorphismByImagesNC(img,img2,gens,List(gens,j-> Image(h[i],PreImagesRepresentative(h[i+1],j)))); SetKernelOfMultiplicativeGeneralMapping(r[i], Image(h[i+1],KernelOfMultiplicativeGeneralMapping(h[i]))); img:=img2; od; return r; end); # test function for relators BindGlobal("OCTestRelators",function(ocr) if not IsBound(ocr.relators) then return true;fi; return ForAll(ocr.relators,i->ExponentsOfPcElement(ocr.generators, Product(List([1..Length(i.generators)], j->ocr.generators[i.generators[j]]^i.powers[j]))) =List(ocr.generators,i->0)); end); ############################################################################# ## #F COAffineBlocks( ,,, ) ## ## Divide the vectorspace into blocks using the affine operations of ## described by . Return representative for these blocks and their ## normalizers in . ## if is true orbits are kept. ## InstallGlobalFunction( COAffineBlocks, function( S, Sgens,mats,orbs ) local dim, p, nul, one, C, L, blt, B, O, Q, i, j, v, w, n, z, root,r; # The affine operation of is described via as # # ( lll 0 ) # ( lll 0 ) # ( ttt 1 ) # # where l describes the linear operation and t the translation the # dimension of the vectorspace is of dimension one less than the # matrices . # dim:=Length(mats[1]) - 1; one:=One(mats[1][1][1]); nul:=0 * one; root:=Z(Characteristic(one)); p:=Characteristic( mats[1][1][1] ); C:=List( [1..dim], x -> p ); Q:=List( [0..dim-1], x -> p ^x ); L:=[]; for i in [1..p-1] do L[LogFFE( one * i,root ) + 1]:=i; od; # Make a boolean list of length

^ . blt:=BlistList( [1..p ^ dim], [] ); Info(InfoComplement,3,"COAffineBlocks: ", p^dim, " elements in H^1" ); i:=1; # was: Position( blt, false ); B:=[]; # Run through this boolean list. while i <> fail do v:=CoefficientsQadic(i-1,p); while Length(v) nul then n:=n + Q[j] * L[LogFFE( z,root ) + 1]; fi; od; blt[n]:=true; od; Info(InfoComplement,3,"COAffineBlocks: |block| = ", Length(O.orbit)); r:=rec( vector:=w, stabilizer:=O.stabilizer ); if orbs=true then r.orbit:=O.orbit;fi; Add( B, r); i:=Position( blt, false ); od; Info(InfoComplement,3,"COAffineBlocks: ", Length( B ), " blocks found" ); return B; end ); ############################################################################# ## #F CONextCentralizer( , , ) . . . . . . . . . . . . . . . local ## ## Correct the blockstabilizer and return the stabilizer of in ## InstallGlobalFunction( CONextCentralizer, function( ocr, Spcgs, H ) local gens, pnt, i; # Get the generators of and correct them. Info(InfoComplement,3,"CONextCentralizer: correcting blockstabilizer" ); gens:=ShallowCopy( Spcgs ); pnt :=ocr.complementToCocycle( H ); for i in [1..Length( gens )] do gens[i]:=gens[i] * OCConjugatingWord( ocr, ocr.complementToCocycle( H ^ gens[i] ), pnt ); od; Info(InfoComplement,3,"CONextCentralizer: blockstabilizer corrected" ); return ClosureGroup( ocr.centralizer, gens ); end ); #ocr is oc record, acts are elements that act via ^ on group elements, B #is the result of BaseSteinitzVectors on the 1-cocycles in ocr. InstallGlobalFunction(COAffineCohomologyAction,function(ocr,relativeGens,acts,B) local tau, phi, mats; # Get the matrices describing the affine operations. The linear part # of the operation is just conjugation of the entries of cocycle. The # translation are commuators with the generators. So check if # has a small generating set. Use only these to form the commutators. # Translation: (.. h ..) -> (.. [h,c] ..) if IsBound( ocr.smallGeneratingSet ) then Error("not yet implemented"); tau:=function( c ) local l, i, j, z, v; l:=[]; for i in ocr.smallGeneratingSet do Add( l, Comm( ocr.generators[i], c ) ); od; l:=ocr.listToCocycle( l ); v:=ShallowCopy( B.factorzero ); for i in [1..Length(l)] do if l[i] <> ocr.zero then z:=l[i]; j:=B.heads[i]; if j > 0 then l:=l - z * B.factorspace[j]; v[j]:=z; else l:=l - z * B.subspace[-j]; fi; fi; od; IsRowVector( v ); return v; end; else tau:=function( c ) local l, i, j, z, v; l:=[]; for i in relativeGens do #Add( l, LeftQuotient(i,i^c)); Add( l, Comm(i,c)); od; l:=ocr.listToCocycle( l ); v:=ListWithIdenticalEntries(Length(B.factorspace),ocr.zero); for i in [1..Length(l)] do if l[i] <> ocr.zero then z:=l[i]; j:=B.heads[i]; if j > 0 then l:=l - z * B.factorspace[j]; v[j]:=z; else l:=l - z * B.subspace[-j]; fi; fi; od; IsRowVector( v ); return v; end; fi; # Linear Operation: (.. hm ..) -> (.. (hm)^c ..) phi:=function( z, c ) local l, i, j, v; l:=ocr.listToCocycle( List( ocr.cocycleToList(z), x -> x ^ c ) ); v:=ListWithIdenticalEntries(Length(B.factorspace),ocr.zero); for i in [1..Length( l )] do if l[i] <> ocr.zero then z:=l[i]; j:=B.heads[i]; if j > 0 then l:=l - z * B.factorspace[j]; v[j]:=z; else l:=l - z * B.subspace[-j]; fi; fi; od; IsRowVector( v ); return v; end; # Construct the affine operations and blocks under them. mats:=AffineAction( acts,B.factorspace, phi, tau ); Assert(2,ForAll(mats,i->ForAll(i,j->Length(i)=Length(j)))); return mats; end); ############################################################################# ## #F CONextCocycles( , , ) . . . . . . . . . . . . . . . . local ## ## Get the next conjugacy classes of complements under operation of ## using affine operation on the onecohomologygroup of and , where ## :=rec( group:=, module:= ). ## ## is a record as described in 'OCOneCocycles'. The classes are ## returned as list of records rec( complement, centralizer ). ## InstallGlobalFunction( CONextCocycles, function( cor, ocr, S ) local K, N, Z, SN, B, L, LL, SNpcgs, mats, i; # Try to split over , if it does not split return. Info(InfoComplement,3,"CONextCocycles: computing cocycles" ); K:=ocr.group; N:=ocr.module; Z:=OCOneCocycles( ocr, true ); if IsBool( Z ) then if IsBound( ocr.normalIn ) then Info(InfoComplement,3,"CONextCocycles: no normal complements" ); else Info(InfoComplement,3,"CONextCocycles: no split extension" ); fi; return []; fi; ocr.generators:=CanonicalPcgs(InducedPcgs(ocr.pcgs,ocr.complement)); Assert(2,OCTestRelators(ocr)); # If there is only one complement this is normal. if Dimension( Z ) = 0 then Info(InfoComplement,3,"CONextCocycles: group of cocycles is trivial" ); K:=ocr.complement; if IsBound(cor.condition) and not cor.condition(cor, K) then return []; else return [rec( complement:=K, centralizer:=S )]; fi; fi; # If the one cohomology group is trivial, there is only one class of # complements. Correct the blockstabilizer and return. If we only want # normal complements, this case cannot happen, as cobounds are trivial. SN:=SubgroupNC( S, Filtered(GeneratorsOfGroup(S),i-> not i in N)); if Dimension(ocr.oneCoboundaries)=Dimension(ocr.oneCocycles) then Info(InfoComplement,3,"CONextCocycles: H^1 is trivial" ); K:=ocr.complement; if IsBound(cor.condition) and not cor.condition(cor, K) then return []; fi; S:=CONextCentralizer( ocr, InducedPcgs(cor.pcgs,SN), ocr.complement); return [rec( complement:=K, centralizer:=S )]; fi; # If = , there are no new blocks under the operation of , so # get all elements of the one cohomology group and return. If we only # want normal complements, there also are no blocks under the operation # of . B:=BaseSteinitzVectors(BasisVectors(Basis(ocr.oneCocycles)), BasisVectors(Basis(ocr.oneCoboundaries))); if Size(SN) = 1 or IsBound(ocr.normalIn) then L:=VectorSpace(ocr.field,B.factorspace, B.factorzero); Info(InfoComplement,3,"CONextCocycles: ",Size(L)," complements found"); if IsBound(ocr.normalIn) then Info(InfoComplement,3,"CONextCocycles: normal complements, using H^1"); LL:=[]; if IsBound(cor.condition) then for i in L do K:=ocr.cocycleToComplement(i); if cor.condition(cor, K) then Add(LL, rec(complement:=K, centralizer:=S)); fi; od; else for i in L do K:=ocr.cocycleToComplement(i); Add(LL, rec(complement:=K, centralizer:=S)); od; fi; return LL; else Info(InfoComplement,3,"CONextCocycles: S meets N, using H^1"); LL:=[]; if IsBound(cor.condition) then for i in L do K:=ocr.cocycleToComplement(i); if cor.condition(cor, K) then S:=ocr.centralizer; Add(LL, rec(complement:=K, centralizer:=S)); fi; od; else for i in L do K:=ocr.cocycleToComplement(i); S:=ocr.centralizer; Add(LL, rec(complement:=K, centralizer:=S)); od; fi; return LL; fi; fi; # The situation is as follows. # # S As does act trivial on the onecohomology # \ K group, compute first blocks of this group under # \ / \ the operation of /. But as / acts # N ? affine, this can be done using affine operation # \ / (given as matrices). # 1 SNpcgs:=InducedPcgs(cor.pcgs,SN); mats:=COAffineCohomologyAction(ocr,ocr.generators,SNpcgs,B); L :=COAffineBlocks( SN, SNpcgs,mats,false ); Info(InfoComplement,3,"CONextCocycles:", Length( L ), " complements found" ); # choose a representative from each block and correct the blockstab LL:=[]; for i in L do K:=ocr.cocycleToComplement(i.vector*B.factorspace); if not IsBound(cor.condition) or cor.condition(cor, K) then if Z = [] then S:=ClosureGroup( ocr.centralizer, i.stabilizer ); else S:=CONextCentralizer(ocr, InducedPcgs(cor.pcgs, i.stabilizer), K); fi; Add(LL, rec(complement:=K, centralizer:=S)); fi; od; return LL; end ); ############################################################################# ## #F CONextCentral( , , ) . . . . . . . . . . . . . . . . local ## ## Get the conjugacy classes of complements in case is central. ## InstallGlobalFunction( CONextCentral, function( cor, ocr, S ) local z,K,N,zett,SN,B,L,tau,gens,imgs,A,T,heads,dim,s,v,j,i,root; # Try to split K:=ocr.group; N:=ocr.module; # If is no split extension of return the trivial list, as there # are no complements. We compute the cocycles only if the extenstion # splits. zett:=OCOneCocycles( ocr, true ); if IsBool( zett ) then if IsBound( ocr.normalIn ) then Info(InfoComplement,3,"CONextCentral: no normal complements" ); else Info(InfoComplement,3,"CONextCentral: no split extension" ); fi; return []; fi; ocr.generators:=CanonicalPcgs(InducedPcgs(ocr.pcgs,ocr.complement)); Assert(2,OCTestRelators(ocr)); # if there is only one complement it must be normal if Dimension(zett) = 0 then Info(InfoComplement,3,"CONextCentral: Z^1 is trivial"); K:=ocr.complement; if IsBound(cor.condition) and not cor.condition(cor, K) then return []; else return [rec(complement:=K, centralizer:=S)]; fi; fi; # If the one cohomology group is trivial, there is only one class of # complements. Correct the blockstabilizer and return. If we only want # normal complements, this cannot happen, as the cobounds are trivial. SN:=SubgroupNC( S, Filtered(GeneratorsOfGroup(S),i-> not i in N)); if Dimension(ocr.oneCoboundaries)=Dimension(ocr.oneCocycles) then Info(InfoComplement,3,"CONextCocycles: H^1 is trivial" ); K:=ocr.complement; if IsBound(cor.condition) and not cor.condition(cor, K) then return []; else S:=CONextCentralizer( ocr, InducedPcgs(cor.pcgs,SN),ocr.complement); return [rec(complement:=K, centralizer:=S)]; fi; fi; # If = , there are no new blocks under the operation of , so # get all elements of the onecohomologygroup and return. If we only want # normal complements, there also are no blocks under the operation of # . B:=BaseSteinitzVectors(BasisVectors(Basis(ocr.oneCocycles)), BasisVectors(Basis(ocr.oneCoboundaries))); if Size(SN)=1 or IsBound( ocr.normalIn ) then if IsBound( ocr.normalIn ) then Info(InfoComplement,3,"CONextCocycles: normal complements, using H^1"); else Info(InfoComplement,3,"CONextCocycles: S meets N, using H^1" ); S:=ocr.centralizer; fi; L:=VectorSpace(ocr.field,B.factorspace, B.factorzero); T:=[]; for i in L do K:=ocr.cocycleToComplement(i); if not IsBound(cor.condition) or cor.condition(cor, K) then Add(T, rec(complement:=K, centralizer:=S)); fi; od; Info(InfoComplement,3,"CONextCocycles: ",Length(T)," complements found" ); return T; fi; # The conjugacy classes of complements are cosets of the cocycles of # 0^S. If 'smallGeneratingSet' is given, do not use this gens. # Translation: (.. h ..) -> (.. [h,c] ..) if IsBound( ocr.smallGeneratingSet ) then tau:=function( c ) local l; l:=[]; for i in ocr.smallGeneratingSet do Add( l, Comm( ocr.generators[i], c ) ); od; return ocr.listToCocycle( l ); end; else tau:=function( c ) local l; l:=[]; for i in ocr.generators do Add( l, Comm( i, c ) ); od; return ocr.listToCocycle( l ); end; fi; gens:=InducedPcgs(cor.pcgs,SN); imgs:=List( gens, tau ); # Now get a base for the subspace 0^S. For those zero images which are # not part of a base a generators of the stabilizer can be generated. # B holds the base, # A holds the correcting elements for the base vectors, # T holds the stabilizer generators. dim:=Length( imgs[1] ); A:=[]; B:=[]; T:=[]; heads:=ListWithIdenticalEntries(dim,0); root:=Z(ocr.char); # Get the base starting with the last one and go up. for i in Reversed( [1..Length(imgs)] ) do s:=gens[i]; v:=imgs[i]; j:=1; # was:while j <= dim and IntFFE(v[j]) = 0 do while j <= dim and v[j] = ocr.zero do j:=j + 1; od; while j <= dim and heads[j] <> 0 do z:=v[j] / B[heads[j]][j]; if z <> 0*z then s:=s / A[heads[j]] ^ ocr.logTable[LogFFE(z,root)+1]; fi; v:=v - v[j] / B[heads[j]][j] * B[heads[j]]; # was: while j <= dim and IntFFE(v[j]) = 0 do while j <= dim and v[j] = ocr.zero do j:=j + 1; od; od; if j > dim then Add( T, s ); else Add( B, v ); Add( A, s ); heads[j]:=Length( B ); fi; od; # So now holds a reversed list of generators for a stabilizer. # is a base for 0^ and /0^ are the conjugacy classes of # complements. S:=ClosureGroup(N,T); if B = [] then B:=zett; else B:=BaseSteinitzVectors(BasisVectors(Basis(zett)),B); B:=VectorSpace(ocr.field,B.factorspace, B.factorzero); fi; L:=[]; for i in B do K:=ocr.cocycleToComplement(i); if not IsBound(cor.condition) or cor.condition(cor, K) then Add(L, rec(complement:=K, centralizer:=S)); fi; od; Info(InfoComplement,3,"CONextCentral: ", Length(L), " complements found"); return L; end ); ############################################################################# ## #F CONextComplements( , , , ) . . . . . . . . . . . . . local ## S: fuser, K: Complements in, M: Complements to ## InstallGlobalFunction( CONextComplements, function( cor, S, K, M ) local p, ocr; Assert(1,IsSubgroup(K,M)); if IsTrivial(M) then if IsBound(cor.condition) and not cor.condition(cor, K) then return []; else return [rec( complement:=K, centralizer:=S )]; fi; elif IsEmpty(Intersection( Factors(Size(M)), Factors(Index(K,M)))) then # If and are coprime, splits. Info(InfoComplement,3,"CONextComplements: coprime case, splits" ); ocr:=rec( group:=K, module:=M, modulePcgs:=InducedPcgs(cor.pcgs,M), pcgs:=cor.pcgs, inPcComplement:=true); if IsBound( cor.generators ) then ocr.generators:=cor.generators; Assert(2,OCTestRelators(ocr)); Assert(1,IsModuloPcgs(ocr.generators)); fi; if IsBound( cor.smallGeneratingSet ) then ocr.smallGeneratingSet:=cor.smallGeneratingSet; ocr.generatorsInSmall :=cor.generatorsInSmall; elif IsBound( cor.primes ) then p:=Factors(Size( M.generators))[1]; if p in cor.primes then ocr.pPrimeSet:=cor.pPrimeSets[Position( cor.primes, p )]; fi; fi; if IsBound( cor.relators ) then ocr.relators:=cor.relators; Assert(2,OCTestRelators(ocr)); fi; #was: ocr.complement:=CoprimeComplement( K, M ); OCOneCocycles( ocr, true ); OCOneCoboundaries( ocr ); if IsBound( cor.normalComplements ) and cor.normalComplements and Dimension( ocr.oneCoboundaries ) <> 0 then return []; else K:=ocr.complement; if IsBound(cor.condition) and not cor.condition(cor, K) then return []; fi; S:=SubgroupNC( S, Filtered(GeneratorsOfGroup(S),i->not i in M)); S:=CONextCentralizer( ocr, InducedPcgs(cor.pcgs,S), K ); return [rec( complement:=K, centralizer:=S )]; fi; else # In the non-coprime case, we must construct cocycles. ocr:=rec( group:=K, module:=M, modulePcgs:=InducedPcgs(cor.pcgs,M), pcgs:=cor.pcgs, inPcComplement:=true); if IsBound( cor.generators ) then ocr.generators:=cor.generators; Assert(2,OCTestRelators(ocr)); Assert(1,IsModuloPcgs(ocr.generators)); fi; if IsBound( cor.normalComplement ) and cor.normalComplements then ocr.normalIn:=S; fi; # if IsBound( cor.normalSubgroup ) then # L:=cor.normalSubgroup( S, K, M ); # if IsTrivial(L) = [] then # return CONextCocycles(cor, ocr, S); # else # return CONextNormal(cor, ocr, S, L); # fi; # else if IsBound( cor.smallGeneratingSet ) then ocr.smallGeneratingSet:=cor.smallGeneratingSet; ocr.generatorsInSmall :=cor.generatorsInSmall; elif IsBound( cor.primes ) then p:=Factors(Size( M.generators))[1]; if p in cor.primes then ocr.pPrimeSet:=cor.pPrimeSets[Position(cor.primes,p)]; fi; fi; if IsBound( cor.relators ) then ocr.relators:=cor.relators; Assert(2,OCTestRelators(ocr)); fi; if ( cor.useCentral and IsCentral( Parent(M), M ) ) or ( cor.useCentralSK and IsCentral(S,M) and IsCentral(K,M) ) then return CONextCentral(cor, ocr, S); else return CONextCocycles(cor, ocr, S); fi; fi; end ); ############################################################################# ## #F COComplements( , , , ) . . . . . . . . . . . . . . local ## ## Compute the complements in of the normal subgroup N[1]. N is a list ## of normal subgroups of G s.t. N[i]/N[i+1] is elementary abelian. ## If is true, find all (conjugacy classes of) complements. ## Otherwise try to find just one complement. ## InstallGlobalFunction( COComplements, function( cor, G, E, all ) local r,a,a0,FG,nextStep,C,found,i,time,hpcgs,ipcgs; # give some information and start timing Info(InfoComplement,3,"Complements: initialize factorgroups" ); time:=Runtime(); # we only need the series beginning from position r:=Length(E); # Construct the homomorphisms [i] = /[i+1] -> /[i]. a0:=[]; for i in [1..Length(E)-1] do # to get compatibility we must build the natural homomorphisms # ourselves. ipcgs:=InducedPcgs(cor.home,E[i]); hpcgs:=cor.home mod ipcgs; FG:=PcGroupWithPcgs(hpcgs); a:=GroupHomomorphismByImagesNC(G,FG,cor.home, Concatenation(FamilyPcgs(FG),List(ipcgs,i->One(FG)))); SetKernelOfMultiplicativeGeneralMapping( a, E[i] ); Add(a0,a); od; # hope that NHBNS deals with the trivial subgroup sensibly # a0:=List(E{[1..Length(E)-1]},i->NaturalHomomorphismByNormalSubgroup(G,i)); hpcgs:=List([1..Length(E)-1], i->PcgsByPcSequenceNC(FamilyObj(One(Image(a0[i]))), List(cor.home mod InducedPcgs(cor.home,E[i]), j->Image(a0[i],j)))); Add(hpcgs,cor.home); cor.hpcgs:=hpcgs; a :=HomomorphismsSeries( G, a0 ); a0:=a0[1]; # contains the factorgroups /[1], ..., /[]. FG:=List( a, Range ); Add( FG, G ); # As all entries in are optional, initialize them if they are not # present in with the following defaults. # # 'generators' : standard generators # 'relators' : pc-relators # 'useCentral' : false # 'useCentralSK' : false # 'normalComplements' : false # if not IsBound( cor.useCentral ) then cor.useCentral:=false; fi; if not IsBound( cor.useCentralSK ) then cor.useCentralSK:=false; fi; if not IsBound( cor.normalComplements ) then cor.normalComplements:=false; fi; if IsBound( cor.generators ) then cor.generators:= InducedPcgsByGeneratorsNC(cor.hpcgs[1], List(cor.generators,x->Image(a0,x))); else cor.generators:=CanonicalPcgs( InducedPcgs(cor.hpcgs[1],FG[1] )); fi; cor.gele:=Length(cor.generators); Assert(1,cor.generators[1] in FG[1]); #if not IsBound( cor.normalSubgroup ) then cor.group :=FG[1]; cor.module:=TrivialSubgroup( FG[1] ); cor.modulePcgs:=InducedPcgs(cor.hpcgs[1],cor.module); OCAddRelations(cor,cor.generators); #fi; Assert(2,OCTestRelators(cor)); # The following function will be called recursively in order to descend # the tree and reach a complement. is the current level. # it lifts the complement K over the nr-th step and fuses under the action # of (the full preimage of) S nextStep:=function( S, K, nr ) local M, NC, X; # give information about the level reached Info(InfoComplement,2,"Complements: reached level ", nr, " of ", r); # if this is the last level we have a complement, add it to if nr = r then Add( C, rec( complement:=K, centralizer:=S ) ); Info(InfoComplement,3,"Complements: next class found, ", "total ", Length(C), " complement(s), ", "time=", Runtime() - time); found:=true; # otherwise try to split over = [+1] else S:=PreImage( a[nr], S ); M:=KernelOfMultiplicativeGeneralMapping(a[nr]); cor.module:=M; cor.pcgs:=cor.hpcgs[nr+1]; cor.modulePcgs:=InducedPcgs(cor.pcgs,M); # we cannot take the 'PreImage' as this changes the gens cor.oldK:=K; cor.oldgens:=cor.generators; K:=PreImage(a[nr],K); cor.generators:=CanonicalPcgs(InducedPcgs(cor.pcgs,K)); cor.generators:=cor.generators mod InducedPcgs(cor.pcgs,cor.module); Assert(1,Length(cor.generators)=cor.gele); Assert(2,OCTestRelators(cor)); # now 'CONextComplements' will try to find the complements NC:=CONextComplements( cor, S, K, M ); Assert(1,cor.pcgs=cor.hpcgs[nr+1]); # try to step down as fast as possible for X in NC do Assert(2,OCTestRelators(rec( generators:=CanonicalPcgs(InducedPcgs(cor.hpcgs[nr+1],X.complement)), relators:=cor.relators))); nextStep( X.centralizer, X.complement, nr+1 ); if found and not all then return; fi; od; fi; end; # in we will collect the complements at the last step C:=[]; # ok, start 'nextStep' with trivial module Info(InfoComplement,2," starting search, time=",Runtime()-time); found:=false; nextStep( TrivialSubgroup( FG[1] ), SubgroupNC( FG[1], cor.generators ), 1 ); # some timings Info(InfoComplement,2,"Complements: ",Length(C)," complement(s) found, ", "time=", Runtime()-time ); # add the normalizer Info(InfoComplement,3,"Complements: adding normalizers" ); for i in [1..Length(C)] do C[i].normalizer:=ClosureGroup( C[i].centralizer, C[i].complement ); od; return C; end ); ############################################################################# ## #M COComplementsMain( , , , ) . . . . . . . . . . . . . local ## ## Prepare arguments for 'ComplementCO'. ## InstallGlobalFunction( COComplementsMain, function( G, N, all, fun ) local H, E, cor, a, i, fun2,pcgs,home; home:=HomePcgs(G); pcgs:=home; # Get the elementary abelian series through . E:=ElementaryAbelianSeriesLargeSteps( [G,N,TrivialSubgroup(G)] ); E:=Filtered(E,i->IsSubset(N,i)); # we require that the subgroups of E are subgroups of the Pcgs-Series if Length(InducedPcgs(home,G))Size(i)>1 and not i=SubgroupNC(G,home{[DepthOfPcElement(home, InducedPcgs(home,i)[1])..Length(home)]})) then Info(InfoComplement,3,"Computing better pcgs" ); # create a better pcgs pcgs:=InducedPcgs(home,G) mod InducedPcgs(home,N); for i in [2..Length(E)] do pcgs:=Concatenation(pcgs, InducedPcgs(home,E[i-1]) mod InducedPcgs(home,E[i])); od; if not IsPcGroup(G) then # for non-pc groups arbitrary pcgs may become unfeasibly slow, so # convert to a pc group in this case pcgs:=PcgsByPcSequenceCons(IsPcgsDefaultRep, IsPcgs and IsPrimeOrdersPcgs,FamilyObj(One(G)),pcgs,[]); H:=PcGroupWithPcgs(pcgs); home:=pcgs; # this is our new home pcgs a:=GroupHomomorphismByImagesNC(G,H,pcgs,GeneratorsOfGroup(H)); E:=List(E,i->Image(a,i)); if IsFunction(fun) then fun2:=function(x) return fun(PreImage(a,x)); end; else pcgs:=home; fun2:=fun; fi; Info(InfoComplement,3,"transfer back" ); return List( COComplementsMain( H, Image(a,N), all, fun2 ), x -> rec( complement :=PreImage( a, x.complement ), centralizer:=PreImage( a, x.centralizer ) ) ); else pcgs:=PcgsByPcSequenceNC(FamilyObj(home[1]),pcgs); IsPrimeOrdersPcgs(pcgs); # enforce setting H:= GroupByGenerators( pcgs ); home:=pcgs; fi; fi; # if and are coprime splits over if false and Intersection( Factors(Size(N)), Factors(Index(G,N))) = [] then Info(InfoComplement,3,"Complements: coprime case, splits" ); cor:=rec(); # otherwise we compute a hall system for / else #AH #Info(InfoComplement,2,"Complements: computing p prime sets" ); #a :=NaturalHomomorphism( G, G / N ); #cor:=PPrimeSetsOC( Image( a ) ); #cor.generators:=List( cor.generators, x -> # PreImagesRepresentative( a, x ) ); cor:=rec(home:=home,generators:=pcgs mod InducedPcgs(pcgs,N)); cor.useCentralSK:=true; fi; # if a condition was given use it if IsFunction(fun) then cor.condition:=fun; fi; # 'COComplements' will do most of the work return COComplements( cor, G, E, all ); end ); InstallMethod( ComplementClassesRepresentativesSolvableNC, "pc groups", IsIdenticalObj, [CanEasilyComputePcgs,CanEasilyComputePcgs], 0, function(G,N) return List( COComplementsMain(G, N, true, false), G -> G.complement ); end); # Solvable factor group case # find complements to (N\cap H)M/M in H/M where H=N_G(M), assuming factor is # solvable InstallGlobalFunction(COSolvableFactor,function(arg) local G,N,M,keep,H,K,f,primes,p,A,S,L,hom,c,cn,nc,ncn,lnc,lncn,q,qs,qn,ser, pos,i,pcgs,z,qk,j,ocr,bas,mark,k,orb,shom,shomgens,subbas,elm, acterlist,free,nz,gp,actfun,mat,cond,pos2; G:=arg[1]; N:=arg[2]; M:=arg[3]; if Length(arg)>3 then keep:=arg[4]; else keep:=false;; fi; H:=Normalizer(G,M); Info(InfoComplement,2,"Call COSolvableFactor ",Index(G,N)," ", Size(N)," ",Size(M)," ",Size(H)); if Size(ClosureGroup(N,H))0 do p:=primes[1]; A:=ClosureGroup(K,SylowSubgroup(H,p)); #Print(Index(A,K)," in ",Index(H,K),"\n"); A:=Core(H,A); if Size(A)>Size(K) then # found one. Doesn't need to be elementary abelian if Length(Set(Factors(Size(A)/Size(K))))>1 then Error("multiple primes"); else primes:=[]; fi; else primes:=primes{[2..Length(primes)]}; # next one fi; od; fi; #if HasAbelianFactorGroup(A,K) then # pcgs:=ModuloPcgs(A,K); # S:=LinearActionLayer(H,pcgs); # S:=GModuleByMats(S,GF(p)); # L:=MTX.BasesMinimalSubmodules(S); # if Length(L)>0 then # Sort(L,function(a,b) return Length(a)PcElementByExponents(pcgs,x)); # A:=ClosureGroup(K,L); ## fi; #else # Print("IDX",Index(A,K),"\n"); #fi; S:=ClosureGroup(M,SylowSubgroup(A,p)); L:=Normalizer(H,S); # determine complements up to L-conjugacy. Currently brute-force hom:=NaturalHomomorphismByNormalSubgroup(L,M); q:=Image(hom); if IsSolvableGroup(q) and not IsPcGroup(q) then hom:=hom*IsomorphismSpecialPcGroup(q); q:=Image(hom); fi; #q:=Group(SmallGeneratingSet(q),One(q)); qs:=Image(hom,S); qn:=Image(hom,Intersection(L,K)); qk:=Image(hom,Intersection(S,K)); shom:=NaturalHomomorphismByNormalSubgroup(qs,qk); ser:=ElementaryAbelianSeries([q,qs,qk]); pos:=Position(ser,qk); Info(InfoComplement,2,"Series ",List(ser,Size),pos); c:=[qs]; cn:=[q]; for i in [pos+1..Length(ser)] do pcgs:=ModuloPcgs(ser[i-1],ser[i]); nc:=[]; ncn:=[]; for j in [1..Length(c)] do ocr:=OneCocycles(c[j],pcgs); shomgens:=List(ocr.generators,x->Image(shom,x)); if ocr.isSplitExtension then subbas:=Basis(ocr.oneCoboundaries); bas:=BaseSteinitzVectors(BasisVectors(Basis(ocr.oneCocycles)), BasisVectors(subbas)); lnc:=[]; lncn:=[]; Info(InfoComplement,2,"Step ",i,",",j,": ", p^Length(bas.factorspace)," Complements"); elm:=VectorSpace(GF(p),bas.factorspace,Zero(ocr.oneCocycles)); if Length(bas.factorspace)=0 then elm:=Elements(elm); else elm:=Enumerator(elm); fi; mark:=BlistList([1..Length(elm)],[]); # we act on cocycles, not cocycles modulo coboundaries. This is # because orbits are short, and we otherwise would have to do a # double stabilizer calculation to obtain the normalizer. acterlist:=[]; free:=FreeGroup(Length(ocr.generators)); #cn[j]:=Group(SmallGeneratingSet(cn[j])); for z in GeneratorsOfGroup(cn[j]) do nz:=[z]; gp:=List(ocr.generators,x->Image(shom,x^z)); if gp=shomgens then # no action on qs/qk -- action on cohomology is affine # linear part mat:=[]; for k in BasisVectors(Basis(GF(p)^Length(Zero(ocr.oneCocycles)))) do k:=ocr.listToCocycle(List(ocr.cocycleToList(k),x->x^z)); Add(mat,k); od; mat:=ImmutableMatrix(GF(p),mat); Add(nz,mat); # affine part mat:=ocr.listToCocycle(List(ocr.complementGens,x->Comm(x,z))); ConvertToVectorRep(mat,GF(p)); MakeImmutable(mat); Add(nz,mat); if IsOne(nz[2]) and IsZero(nz[3]) then nz[4]:=fail; # indicate that element does not act fi; else gp:=GroupWithGenerators(gp); SetEpimorphismFromFreeGroup(gp,GroupHomomorphismByImages(free, gp,GeneratorsOfGroup(free),GeneratorsOfGroup(gp))); Add(nz,List(shomgens,x->Factorization(gp,x))); fi; Add(acterlist,nz); od; actfun:=function(cy,a) local genpos,l; genpos:=PositionProperty(acterlist,x->a=x[1]); if genpos=fail then if IsOne(a) then # the action test always does the identity, so its worth # catching this as we have many short orbits return cy; else return ocr.complementToCocycle(ocr.cocycleToComplement(cy)^a); fi; elif Length(acterlist[genpos])=4 then # no action return cy; elif Length(acterlist[genpos])=3 then # affine case l:=cy*acterlist[genpos][2]+acterlist[genpos][3]; else l:=ocr.cocycleToList(cy); l:=List([1..Length(l)],x->(ocr.complementGens[x]*l[x])^a); if acterlist[genpos][2]<>fail then l:=List(acterlist[genpos][2], x->MappedWord(x,GeneratorsOfGroup(free),l)); fi; l:=List([1..Length(l)],x->LeftQuotient(ocr.complementGens[x],l[x])); l:=ocr.listToCocycle(l); fi; #if l<>ocr.complementToCocycle(ocr.cocycleToComplement(cy)^a) then Error("ACT");fi; return l; end; pos:=1; repeat #z:=ClosureGroup(ser[i],ocr.cocycleToComplement(elm[pos])); orb:=OrbitStabilizer(cn[j],elm[pos],actfun); mark[pos]:=true; #cnt:=1; for k in [2..Length(orb.orbit)] do pos2:=Position(elm,SiftedVector(subbas,orb.orbit[k])); #if mark[pos2]=false then cnt:=cnt+1;fi; mark[pos2]:=true; # mark orbit off od; #Print(cnt,"/",Length(orb.orbit),"\n"); if IsSubset(orb.stabilizer,qn) then cond:=Size(orb.stabilizer)=Size(q); else cond:=Size(ClosureGroup(qn,orb.stabilizer))=Size(q); fi; if cond then # normalizer is still large enough to keep the complement Add(lnc,ClosureGroup(ser[i],ocr.cocycleToComplement(elm[pos]))); Add(lncn,orb.stabilizer); fi; pos:=Position(mark,false); until pos=fail; Info(InfoComplement,2,Length(lnc)," good normalizer orbits"); Append(nc,lnc); Append(ncn,lncn); fi; od; c:=nc; cn:=ncn; od; c:=List(c,x->PreImage(hom,x)); #c:=SubgroupsOrbitsAndNormalizers(K,c,false); #c:=List(c,x->x.representative); nc:=PermPreConjtestGroups(K,c); Info(InfoComplement,2,Length(c)," Preimages in ",Length(nc)," clusters "); c:=[]; for i in nc do cn:=SubgroupsOrbitsAndNormalizers(i[1],i[2],false); Add(c,List(cn,x->x.representative)); od; Info(InfoComplement,1,"Overall ",Sum(c,Length)," Complements ", Size(qs)/Size(qk)); if keep then return c; else c:=Concatenation(c); fi; if Size(A)COSolvableFactor(G,N,x)); nc:=Concatenation(cn); c:=nc; fi; return c; end); ############################################################################# ## #M ComplementClassesRepresentatives( , ) . . . . find all complement ## InstallMethod( ComplementClassesRepresentatives, "solvable normal subgroup or factor group", IsIdenticalObj, [IsGroup,IsGroup],0, function( G, N ) local C; # if and are equal the only complement is trivial if G = N then C:=[TrivialSubgroup(G)]; # if is trivial the only complement is elif Size(N) = 1 then C:=[G]; elif not IsNormal(G,N) then Error("N must be normal in G"); elif IsSolvableGroup(N) then # otherwise we have to work C:=ComplementClassesRepresentativesSolvableNC(G,N); elif HasSolvableFactorGroup(G,N) then C:=COSolvableFactor(G,N,TrivialSubgroup(G)); else TryNextMethod(); fi; # return what we have found return C; end); ############################################################################# ## #M ComplementcClassesRepresentatives( , ) ## InstallMethod( ComplementClassesRepresentatives, "tell that the normal subgroup must be solvable",IsIdenticalObj, [IsGroup,IsGroup],-2*RankFilter(IsGroup), function( G, N ) if IsSolvableGroup(N) then TryNextMethod(); fi; Error("Cannot compute complement classes for nonsolvable normal subgroups"); end); ############################################################################# ## #E grppccom.gi . . . . . . . . . . . . . . . . . . . . . . . . . . ends here ## gap-4r6p5/lib/randiso2.gi0000644000175000017500000002744112172557254013763 0ustar billbill############################################################################# ## #W randiso2.gi GAP library Hans Ulrich Besche ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ############################################################################# ## #F EvalFpCoc( coc, desc ). . . . . . . . . . . . . . . . . . . . . . . local ## EvalFpCoc := function( coc, desc ) local powers, exp, targets, result, i, j, g1, g2, fcd4, pos, map; if desc[ 1 ] = 1 then # test, if g^i in cl(g) return List( coc[ desc[ 2 ] ], function( x ) if x[ 1 ] ^ desc[ 3 ] in x then return 1; fi; return 0; end ); elif desc[ 1 ] = 2 then # test, if cl(g) is root of cl(h) exp := QuoInt( Order( coc[ desc[ 2 ] ][ 1 ][ 1 ] ), Order( coc[ desc[ 3 ] ][ 1 ][ 1 ] ) ); powers := Flat( coc[ desc[ 3 ] ] ); return List( coc[ desc[ 2 ] ], function(x) if x[ 1 ] ^ exp in powers then return 1; fi; return 0; end ); elif desc[ 1 ] = 3 then # test, if cl(g) is power of cl(h) exp := QuoInt( Order( coc[ desc[ 3 ] ][ 1 ][ 1 ] ), Order( coc[ desc[ 2 ] ][ 1 ][ 1 ] ) ); # just one representative for each class of power-candidates powers := List( coc[ desc[ 2 ] ], x -> x[ 1 ] ); result := List( powers, x -> 0 ); for i in List( Flat( coc[ desc[ 3 ] ] ), x -> x ^ exp ) do for j in [ 1 .. Length( powers ) ] do if i = powers[ j ] then result[ j ] := result[ j ] + 1; fi; od; od; return result; else # test how often the word [ a, b ] * a^2 is hit targets := List( coc[ desc[ 2 ] ], x -> x[ 1 ] ); map := [ 1 .. Length( targets ) ]; SortParallel( targets, map ); result := List( targets, x -> 0 ); fcd4 := Flat( coc[ desc[ 4 ] ] ); for g1 in Flat( coc[ desc[ 3 ] ] ) do for g2 in fcd4 do if desc[ 1 ] = 4 then pos := Position( targets, Comm( g1, g2 ) * g1 ^ 2 ); else # desc[ 1 ] = 5 pos := Position( targets, Comm( g1, g2 ) * g1 ^ 3 ); fi; if not IsBool( pos ) then result[ map[ pos ] ] := result[ map[ pos ] ] + 1; fi; od; od; return result; fi; end; ############################################################################# ## #F CocGroup( G ). . . . . . . . . . . . . . . . . . . . . . . . . . . . local ## CocGroup := function( g ) local orbs, typs, styps, coc, i, j; # compute the conjugacy classes of G as lists of elements and # classify them according to representative order and length orbs := OrbitsDomain( g, AsList( g ) ); typs := List( orbs, x -> [ Order( x[ 1 ] ), Length( x ) ] ); styps := Set( typs ); coc := List( styps, x-> [ ] ); for i in [ 1 .. Length( styps ) ] do for j in [ 1 .. Length( orbs ) ] do if styps[ i ] = typs[ j ] then Add( coc[ i ], orbs[ j ] ); fi; od; od; return coc; end; ############################################################################# ## #F DiffCoc( coc, pos, finps ) . . . . . . . . . . . . . . . . . . . . . local ## DiffCoc := function( coc, pos, finps ) local tmp, sfinps, i, j; # split up the pos-th cluster of coc using the fingerprint-values finps sfinps := Set( finps ); tmp := List( sfinps, x -> [ ] ); for i in [ 1 .. Length( sfinps ) ] do for j in [ 1 .. Length( finps ) ] do if sfinps[ i ] = finps[ j ] then Add( tmp[ i ], coc[ pos ][ j ] ); fi; od; od; return Concatenation( coc{[1..pos-1]}, tmp, coc{[pos+1..Length(coc)]} ); end; ############################################################################# ## #F SplitUpSublistsByFpFunc( list ). . . . . . . . . . . . . . . . . . . local ## SplitUpSublistsByFpFunc := function( list ) local result, finp, finps, i, g, j; result := [ ]; finps := [ ]; for i in [ 1 .. Length( list ) ] do if list[ i ].isUnique then Add( result, [ list [ i ] ] ); Add( finps, false ); else g := PcGroupCodeRec( list[i] ); finp := FingerprintFF( g ); j := Position( finps, finp ); if IsBool( j ) then Add( result, [ list[ i ] ] ); Add( finps, finp ); Info( InfoRandIso, 3, "split into ", Length( finps ), " classes within ", i, " of ", Length( list ), " tests" ); else Add( result[ j ], list[ i ] ); if i mod 50 = 0 then Info( InfoRandIso, 3, "still ", Length( finps ), " classes after ", i, " of ", Length( list ), " tests" ); fi; fi; fi; od; for i in [ 1 .. Length( result ) ] do if Length( result[ i ] ) = 1 then result[ i ] := result[ i ][ 1 ]; result[ i ].isUnique := true; fi; od; Info( InfoRandIso, 2, " Iso: found ", Length(result)," classes incl. ", Length( Filtered( result, IsRecord ) )," unique groups"); return result; end; ############################################################################# ## #F CodeGenerators( gens, spcgs ). . . . . . . . . . . . . . . . . . . . local ## CodeGenerators := function( gens, spcgs ) local layers, first, one, pcgs, sgrps, dep, lay, numf, pos, e, tpos, found, et, p; gens := ShallowCopy( gens ); layers := LGLayers( spcgs ); first := LGFirst( spcgs ); one := OneOfPcgs( spcgs ); pcgs := [ ]; sgrps := [ ]; numf := 0; pos := 0; while numf < Length( spcgs ) do pos := pos + 1; e := gens[ pos ]; while e <> one do dep := DepthOfPcElement( spcgs, e ); lay := layers[ dep ]; tpos := first[ lay + 1 ]; found := false; while tpos > first[ lay ] and not found and e <> one do tpos := tpos - 1; if not IsBound( pcgs[ tpos ] ) then pcgs[ tpos ] := e; sgrps[ tpos ] := GroupByGenerators( Concatenation( [ e ], pcgs{[ tpos + 1 .. first[ lay + 1 ] - 1 ]}, spcgs{[ first[lay+1] .. Length(spcgs) ]} ) ); for p in Set( FactorsInt( Order( e ) ) ) do et := e ^ p; if et <> one and not et in gens then Add( gens, et ); fi; od; for p in Compacted( pcgs ) do et := Comm( e, p ); if et <> one and not et in gens then Add( gens, et ); fi; od; e := one; numf := numf + 1; else if e in sgrps[ tpos ] then found := true; fi; fi; od; if found then while tpos < first[ lay + 1 ] do if tpos + 1 = first[ lay + 1 ] then while e <> one and lay = layers[ DepthOfPcElement( spcgs, e ) ] do e := pcgs[ tpos ] ^ -1 * e; od; else while not e in sgrps[ tpos + 1 ] do e := pcgs[ tpos ] ^ -1 * e; od; fi; tpos := tpos + 1; od; fi; od; od; pcgs := PcgsByPcSequenceNC( ElementsFamily( FamilyObj( spcgs ) ), pcgs ); SetRelativeOrders( pcgs, RelativeOrders( spcgs ) ); return rec( pcgs := pcgs, code := CodePcgs( pcgs ) ); end; ############################################################################# ## #F IsomorphismSolvableSmallGroups( G, H ). . . . . isomorphism from G onto H ## IsomorphismSolvableSmallGroups := function( g, h ) local size, coc1, coc2, lcoc, coclen, p, poses, nposes, i, qual, nqual, lmin, spcgs1, spcgs2, gens, code, gens1, gens2, codes1, codes2, G, H, iso, iso1, iso2; size := Size( g ); if size <> Size( h ) then return fail; fi; if size = 1 then return GroupHomomorphismByImagesNC( g, h, [], [] ); fi; if ID_AVAILABLE( size ) = fail or size > 2000 then Error( "IsomorphismSmallSolvableGroups: groups are not small" ); fi; if IdGroup( g ) <> IdGroup( h ) then return fail; fi; if not IsSolvableGroup( g ) then Error( "IsomorphismSmallSolvableGroups: groups are not solvable" ); fi; if IsPcGroup( g ) then G := g; else iso1 := IsomorphismPcGroup( g ); G := Image( iso1 ); fi; if IsPcGroup( h ) then H := h; else iso2 := IsomorphismPcGroup( h ); H := Image( iso2 ); fi; coc1 := CocGroup( G ); coc1 := List( coc1{[ 2 .. Length( coc1 ) ]}, Concatenation ); coc2 := CocGroup( H ); coc2 := List( coc2{[ 2 .. Length( coc2 ) ]}, Concatenation ); lcoc := Length( coc1 ); coclen := List( coc1, Length ); lmin := Length( MinimalGeneratingSet( G ) ); qual := size ^ lmin; poses := fail; i := - Length( FactorsInt( size ) ) * 5 - lcoc * 8 - lmin * 12; Info( InfoRandIso, 3, "testing ", -i, " generating strategies" ); while poses = fail or i < 0 do i := i + 1; nposes := List( [ 1 .. lmin ], x -> Random( [ 1 .. lcoc ] ) ); nqual := Product( coclen{ nposes } ); if nqual < qual and Size( Group( List( coc1{ nposes }, Random ) ) ) = size then qual := nqual; poses := nposes; fi; od; Info( InfoRandIso, 2, "strategy with ",qual," generating set candidates"); coc1 := coc1{ poses }; coc2 := coc2{ poses }; gens1 := []; gens2 := []; codes1 := []; codes2 := []; spcgs1 := SpecialPcgs( G ); spcgs2 := SpecialPcgs( H ); iso := fail; i := 0; while iso = fail do i := i + 1; if i mod 10 = 0 then Info( InfoRandIso, 3, i, " test on generating set candidates" ); fi; if gens1 = [] then gens := ShallowCopy( GeneratorsOfGroup( G ) ); else gens := List( coc1, Random ); fi; if Size( Group( gens ) ) = size then code := CodeGenerators( gens, spcgs1 ); p := Position( codes2, code.code ); if p <> fail then iso := GroupHomomorphismByImagesNC( G, H, code.pcgs, CodeGenerators( gens2[ p ], spcgs2 ).pcgs ); fi; if not code.code in codes1 then Add( codes1, code.code ); Add( gens1, gens ); fi; fi; if iso = fail then if gens2 = [] then gens := ShallowCopy( GeneratorsOfGroup( H ) ); else gens := List( coc2, Random ); fi; if Size( Group( gens ) ) = size then code := CodeGenerators( gens, spcgs2 ); p := Position( codes1, code.code ); if p <> fail then iso := GroupHomomorphismByImagesNC( G, H, CodeGenerators( gens1[ p ], spcgs1 ).pcgs, code.pcgs); fi; if not code.code in codes2 then Add( codes2, code.code ); Add( gens2, gens ); fi; fi; fi; od; gens := GeneratorsOfGroup( g ); if IsBound( iso1 ) then gens := List( gens, x -> Image( iso1, x ) ); fi; gens := List( gens, x -> Image( iso, x ) ); if IsBound( iso2 ) then gens := List( gens, x -> PreImage( iso2, x ) ); fi; return GroupHomomorphismByImagesNC( g, h, GeneratorsOfGroup( g ), gens ); end; gap-4r6p5/lib/clashom.gi0000644000175000017500000015722212172557252013667 0ustar billbill############################################################################# ## #W clashom.gi GAP library Alexander Hulpke ## ## #Y (C) 1999 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains functions that compute the conjugacy classes of a ## finite group by homomorphic images. ## Literature: A.H: Conjugacy classes in finite permutation groups via ## homomorphic images, MathComp, to appear. ## ############################################################################# ## #F GeneralStepClEANSNonsolv( ,,, ) ## BindGlobal("GeneralStepClEANSNonsolv",function( H, N,NT, cl ) local classes, # classes to be constructed, the result field, # field over which is a vector space one, h, # preimage `cl.representative' under cNh, # centralizer of in C, gens, # preimage `Centralizer( cl )' under r, # dimension of ran, # constant range `[ 1 .. r ]' aff, # as affine space xset, # affine operation of on eo, # xorbits/stabilizers imgs, M, # generating matrices for affine operation orb, # orbit of affine operation rep,# set of classes with canonical representatives c, i, # loop variables reduce, stabsub, comm,s,stab;# for class correction #NT:=AsSubgroup(H,NT); C := cl[2]; field := GF( RelativeOrders( N )[ 1 ] ); one:=One(field); h := cl[1]; reduce:=ReducedPermdegree(C); if reduce<>fail then C:=Image(reduce,C); Info(InfoHomClass,4,"reduced to deg:",NrMovedPoints(C)); h:=Image(reduce,h); NT:=Image(reduce,NT); N:=ModuloPcgs(SubgroupNC(C,Image(reduce,NumeratorOfModuloPcgs(N))),NT); fi; # Determine the subspace $[h,N]$ and calculate the centralizer of . #cNh := ExtendedPcgs( DenominatorOfModuloPcgs( N!.capH ), # KernelHcommaC( N, h, N!.capH ) ); N!.capH:=N; cNh:=KernelHcommaC( N, h, N!.capH,2 ); r := Length( N!.subspace.baseComplement ); ran := [ 1 .. r ]; # Construct matrices for the affine operation on $N/[h,N]$. aff := ExtendedVectors( field ^ r ); if IsSolvableGroup(C) then gens:=Pcgs(C); else gens:=GeneratorsOfGroup(C); fi; imgs := [ ]; for c in gens do M := [ ]; for i in [ 1 .. r ] do M[ i ] := Concatenation( ExponentsConjugateLayer( N, N[ N!.subspace.baseComplement[ i ] ] , c ) * N!.subspace.projection, [ Zero( field ) ] ); od; M[ r + 1 ] := Concatenation( ExponentsOfPcElement ( N, Comm( h, c ) ) * N!.subspace.projection, [ One( field ) ] ); M:=ImmutableMatrix(field,M); Add( imgs, M ); od; xset := ExternalSet( C, aff, gens, imgs ); classes := [ ]; # NC is safe stabsub:=ClosureSubgroupNC(NT,cNh); SetActionKernelExternalSet(xset,stabsub); eo:=ExternalOrbitsStabilizers( xset ); for orb in eo do rep := PcElementByExponentsNC( N, N{ N!.subspace.baseComplement }, Representative( orb ){ ran } ); Assert(2,ForAll(GeneratorsOfGroup(stabsub),i->Comm(i,h*rep) in NT)); # filter those we don't get anyhow. stab:=Filtered(GeneratorsOfGroup(StabilizerOfExternalSet(orb)), i->not i in stabsub); comm := [ ]; for s in [ 1 .. Length( stab ) ] do comm[ s ] := ExponentsOfPcElement( N, Comm( rep, stab[ s ] ) * Comm( h, stab[ s ] ) )*one; od; comm:=ImmutableMatrix(field,comm); comm := comm * N!.subspace.inverse; for s in [ 1 .. Length( comm ) ] do stab[ s ] := stab[ s ] / PcElementByExponentsNC ( N, N{ N!.subspace.needed }, comm[ s ] ); #( N!.capH, N!.capH{ N!.subspace.needed }, comm[ s ] ); Assert(2,Comm(h*rep,stab[s]) in NT); od; # NC is safe stab:=ClosureSubgroupNC(stabsub,stab); if IsSolvableGroup(C) then SetIsSolvableGroup(stab,true); fi; c := [h * rep,stab]; Assert(2,ForAll(GeneratorsOfGroup(stab),i->Comm(i,c[1]) in NT)); if reduce<>fail then Add(classes,[PreImagesRepresentative(reduce,c[1]), PreImage(reduce,c[2])]); else Add(classes,c); fi; od; Assert(1,ForAll(classes,i->i[1] in H and IsSubset(H,i[2]))); return classes; end); # new version, no subspace ############################################################################# ## #F GeneralStepCanEANSNonsolv( ,,,, ) ## ## canonical rep BindGlobal("GeneralStepCanEANSNonsolv",function( H, N,NT, C,h,reps,repo,nostab ) local SchreierVectorProduct, field, one, r, ran, gens, imgs, M, invimgs, repvec, repgps, newreps, aff, sel, i, repsofi, orb, rep, dict, q, stab, sti, stabgens, p, img, mi, os, a, mipo, mimap, map, ngrp, c, j; SchreierVectorProduct:=function(n) local w,q,a; w:=One(C); while n<>1 do q:=rep[n]; w:=gens[q]*w; n:=LookupDictionary(dict,orb[n]*invimgs[q]); od; return w; end; #NT:=AsSubgroup(H,NT); field := GF( RelativeOrders( N )[ 1 ] ); one:=One(field); #reduce:=ReducedPermdegree(C); #if reduce<>fail then # C:=Image(reduce,C); # Info(InfoHomClass,4,"reduced to deg:",NrMovedPoints(C)); # h:=Image(reduce,h); # NT:=Image(reduce,NT); # N:=ModuloPcgs(SubgroupNC(C,Image(reduce,NumeratorOfModuloPcgs(N))),NT); #fi; r := Length(N); ran := [ 1 .. r ]; # Construct matrices for the affine operation on $N/[h,N]$. gens:=Filtered(GeneratorsOfGroup(C),i->not i in NT); if Length(gens)>20 then gens:=Filtered(SmallGeneratingSet(C),i->not i in NT); fi; imgs := [ ]; for c in gens do M := [ ]; for i in ran do #M[i]:=Concatenation(ExponentsConjugateLayer(N,N[i],c)*one,[Zero(field)]); M[i]:=Concatenation(ExponentsOfPcElement(N,N[i]^c)*one,[Zero(field)]); od; M[r+1]:=Concatenation(ExponentsOfPcElement(N,Comm(h,c))*one,[One(field)]); M:=ImmutableMatrix(field,M); Add( imgs, M ); od; invimgs:=List(imgs,Inverse); # get vectors for reps repvec:=List(repo,i->Concatenation( ExponentsOfPcElement(N,LeftQuotient(h,reps[i][1]))*one,[one])); for i in repvec do ConvertToVectorRep(i,field); od; repgps:=[]; newreps:=[]; aff:=field^(r+1); sel:=[1..Length(repo)]; while Length(sel)>0 do i:=sel[1]; repsofi:=reps[repo[i]]; RemoveSet(sel,i); # since we want representatives as well, recode the orbit algorithm. orb:=[repvec[i]]; rep:=[0]; dict:=NewDictionary(repvec[i],true,aff); AddDictionary(dict,repvec[i],1); # get stabilizing generators q:=gens{Filtered([1..Length(gens)],i->orb[1]*imgs[i]=orb[1])}; if q=gens or nostab then stab:=C; else stab:=ClosureGroup(NT,q); fi; sti:=5; if nostab then sti:=-1;fi; stabgens:=[]; p:=1; while p<=Length(orb) do for j in [1..Length(gens)] do img:=orb[p]*imgs[j]; q:=LookupDictionary(dict,img); if q=fail then Add(orb,img); AddDictionary(dict,img,Length(orb)); Add(rep,j); elif Size(C)/Size(stab)>Length(orb) then if sti=0 then Add(stabgens,[p,j,q]); if Random([1..QuoInt(Length(orb),5)])=1 then os:=Random([1..Length(stabgens)]); mi:=stabgens[os]; stabgens[os]:=stabgens[Length(stabgens)]; Unbind(stabgens[Length(stabgens)]); os:=Size(stab); stab:=ClosureGroup(stab,SchreierVectorProduct(mi[1])*gens[mi[2]] / SchreierVectorProduct(mi[3])); if Size(stab)>os then sti:=1; fi; fi; else os:=Size(stab); stab:=ClosureGroup(stab,SchreierVectorProduct(p)*gens[j] / SchreierVectorProduct(q)); if Size(stab)=os then sti:=sti-1; fi; fi; fi; od; p:=p+1; od; # add missing schreier gens a:=Size(C)/Length(orb); while Size(stab)Comm(x,h*mi) in NT)); ngrp:=[[repo[i]],h*mi,stab]; Add(repgps,ngrp); newreps[repo[i]]:=[repsofi[1]^map,repsofi[2]*map,Length(repgps)]; Assert(1,LeftQuotient(h*mi*One(NT),repsofi[1]^map) in NT); for i in ShallowCopy(sel) do q:=LookupDictionary(dict,repvec[i]); if q<>fail then RemoveSet(sel,i); repsofi:=reps[repo[i]]; Add(ngrp[1],repo[i]); map:=LeftQuotient(SchreierVectorProduct(q),mimap); newreps[repo[i]]:=[repsofi[1]^map,repsofi[2]*map,Length(repgps)]; Assert(1,LeftQuotient(h*mi,repsofi[1]^map) in NT); fi; od; od; return [repgps,newreps]; end); ############################################################################# ## #F CentralStepClEANSNonsolv( , , ) ## # the version for pc groups implicitly uses a pc-group orbit-stabilizer # algorithm. We can't do this but have to use a more simple-minded # orbit/stabilizer approach. BindGlobal("CentralStepClEANSNonsolv",function( H, N, cl ) local classes, # classes to be constructed, the result f, # field over which is a vector space o, n,r, # dimensions space, com, comms, mats, decomp, reduce, v, h, # preimage `cl.representative' under C, # preimage `Centralizer( cl )' under w, # coefficient vectors for projection along $[h,N]$ c; # loop variable C:=cl[2]; h := cl[1]; reduce:=ReducedPermdegree(C); if reduce<>fail then C:=Image(reduce,C); Info(InfoHomClass,4,"reduced to deg:",NrMovedPoints(C)); h:=Image(reduce,h); N:=ModuloPcgs(SubgroupNC(C,Image(reduce,NumeratorOfModuloPcgs(N))), SubgroupNC(C,Image(reduce,DenominatorOfModuloPcgs(N)))); fi; # centrality still means that conjugation by c is multiplication with # [h,c] and that the complement space is generated by commutators [h,c] # for a generating set {c|...} of C. f:=GF(RelativeOrders(N)[1]); n:=Length(N); o:=One(f); # commutator space basis comms:=List(GeneratorsOfGroup(C),c->o*ExponentsOfPcElement(N,Comm(h,c))); List(comms,x->ConvertToVectorRep(x,f)); space:=List(comms,ShallowCopy); TriangulizeMat(space); space:=Filtered(space,i->i<>Zero(i)); # remove spurious columns com:=BaseSteinitzVectors(IdentityMat(n,f),space); # decomposition of vectors into the subspace basis r:=Length(com.subspace); if r>0 then # if the subspace is trivial, everything stabilizes decomp:=Concatenation(com.subspace,com.factorspace)^-1; decomp:=decomp{[1..Length(decomp)]}{[1..r]}; decomp:=ImmutableMatrix(f,decomp); # build matrices for the affine action mats:=[]; for w in comms do c:=IdentityMat(r+1,o); c[r+1]{[1..r]}:=w*decomp; # translation bit c:=ImmutableMatrix(f,c); Add(mats,c); od; #subspace affine enumerator v:=ExtendedVectors(f^r); C := Stabilizer( C, v, v[1],GeneratorsOfGroup(C), mats,OnPoints ); fi; Assert(1,Size(cl[2])/Size(C)=Size(f)^r); if Length(com.factorspace)=0 then if reduce<>fail then classes:=[[PreImagesRepresentative(reduce,h),PreImage(reduce,C)]]; else classes:=[[h,C]]; fi; else classes:=[]; # enumerator of complement v:=f^Length(com.factorspace); for w in v do c := [h * PcElementByExponentsNC( N,w*com.factorspace),C ]; if reduce<>fail then Add(classes,[PreImagesRepresentative(reduce,c[1]), PreImage(reduce,c[2])]); else Add(classes,c); fi; od; fi; Assert(1,ForAll(classes,i->i[1] in H and IsSubset(H,i[2]))); return classes; end); ############################################################################# ############################################################################# ## #F ClassRepsPermutedTuples(,) ## ## computes representatives of the colourbars with colours selected from ## . BindGlobal("ClassRepsPermutedTuples",function(g,ran) local anz,erg,pat,pat2,sym,nrcomp,coldist,stab,dc,i,j,k,sum,schieb,lstab, stabs,p; anz:=NrMovedPoints(g); sym:=SymmetricGroup(anz); erg:=[]; stabs:=[]; for nrcomp in [1..anz] do # all sorted colour distributions coldist:=Combinations(ran,nrcomp); for pat in OrderedPartitions(anz,nrcomp) do Info(InfoHomClass,3,"Pattern: ",pat); # compute the partition stabilizer stab:=[]; sum:=0; for i in pat do schieb:=MappingPermListList([1..i],[sum+1..sum+i]); sum:=sum+i; stab:=Concatenation(stab, List(GeneratorsOfGroup(SymmetricGroup(i)),j->j^schieb)); od; stab:=Subgroup(sym,stab); dc:=List(DoubleCosetRepsAndSizes(sym,stab,g),i->i[1]); # compute expanded pattern pat2:=[]; for i in [1..nrcomp] do for j in [1..pat[i]] do Add(pat2,i); od; od; for j in dc do # the new bar's stabilizer lstab:=Intersection(g,ConjugateSubgroup(stab,j)); p:=Position(stabs,lstab); if p=fail then Add(stabs,lstab); else lstab:=stabs[p]; fi; # the new bar j:=Permuted(pat2,j); for k in coldist do Add(erg,[List(j,i->k[i]),lstab]); od; od; od; od; return erg; end); ############################################################################# ## #F ConjugacyClassesSubwreath(,,,,,,,,) ## InstallGlobalFunction(ConjugacyClassesSubwreath, function(F,M,n,autT,T,Lloc,components,embeddings,projections) local clT, # classes T lcl, # Length(clT) clTR, # classes under other group (autT,centralizer) fus, # class fusion sci, # |centralizer_i| oci, # |reps_i| i,j,k,l, # loop pfus, # potential fusion op, # operation of F on components ophom, # F -> op clF, # classes of F clop, # classes of op bars, # colour bars barsi, # partial bars lallcolors,# |all colors| reps,Mproj,centralizers,centindex,emb,pi,varpi,newreps,newcent, newcentindex,centimages,centimgindex,C,p,P,selectcen,select, cen,eta,newcentlocal,newcentlocalindex,d,dc,s,t,elm,newcen,shift, cengen,b1,ore, # as in paper colourbar,newcolourbar,possiblecolours,potentialbars,bar,colofclass, clin,clout, etas, # list of etas opfun, # operation function r,rp, # op-element complement in F cnt, brp,bcen, centralizers_r, # centralizers of r newcent_r,# new list to buid centrhom, # projection \rest{centralizer of r} localcent_r, # image cr, isdirprod,# is just M a direct product genpos, # generator index genpos2, gen, # generator stab, # stabilizer stgen, # local stabilizer generators trans, repres, img, limg, con, pf, orb, # orbit orpo, # orbit position minlen, # minimum orbit length remainlen,#list of remaining lengths gcd, # gcd of remaining orbit lengths stabtrue, diff, possible, combl, smacla, smare, ppos, maxdiff, again, # run orbit again to get all trymap, # operation to try skip, # skip (if u=ug) ug, # u\cap u^{gen^-1} scj, # size(centralizers[j]) dsz; # Divisors(scj); Info(InfoHomClass,1, "ConjugacyClassesSubwreath called for almost simple group of size ", Size(T)); isdirprod:=Size(M)=Size(autT)^n; # classes of T if IsNaturalSymmetricGroup(T) or IsNaturalAlternatingGroup(T) then clT:=ConjugacyClasses(T); else clT:=ConjugacyClassesByRandomSearch(T); fi; clT:=List(clT,i->[Representative(i),Centralizer(i)]); lcl:=Length(clT); Info(InfoHomClass,1,"found ",lcl," classes in almost simple"); clTR:=List(clT,i->ConjugacyClass(autT,i[1])); # possible fusion under autT fus:=List([1..lcl],i->[i]); for i in [1..lcl] do sci:=Size(clT[i][2]); # we have taken a permutation representation that prolongates to autT! oci:=CycleStructurePerm(clT[i][1]); # we have tested already the smaller-# classes pfus:=Filtered([i+1..lcl],j->CycleStructurePerm(clT[j][1])=oci and Size(clT[j][2])=sci); pfus:=Difference(pfus,fus[i]); if Length(pfus)>0 then Info(InfoHomClass,3,"possible fusion ",pfus); for j in pfus do if clT[j][1] in clTR[i] then fus[i]:=Union(fus[i],fus[j]); # fuse the entries for k in fus[i] do fus[k]:=fus[i]; od; fi; od; fi; od; fus:=Set(fus); # throw out duplicates colofclass:=List([1..lcl],i->PositionProperty(fus,j->i in j)); Info(InfoHomClass,2,"fused to ",Length(fus)," colours"); # get the allowed colour bars ophom:=ActionHomomorphism(F,components,OnSets,"surjective"); op:=Image(ophom); lallcolors:=Length(fus); bars:=ClassRepsPermutedTuples(op,[1..lallcolors]); Info(InfoHomClass,1,"classes in normal subgroup"); # inner classes reps:=[One(M)]; centralizers:=[M]; centindex:=[1]; colourbar:=[[]]; Mproj:=[]; varpi:=[]; for i in [1..n] do Info(InfoHomClass,1,"component ",i); barsi:=Set(Immutable(List(bars,j->j[1]{[1..i]}))); emb:=embeddings[i]; pi:=projections[i]; Add(varpi,ActionHomomorphism(M,Union(components{[1..i]}),"surjective")); Add(Mproj,Image(varpi[i],M)); newreps:=[]; newcent:=[]; newcentindex:=[]; centimages:=[]; centimgindex:=[]; newcolourbar:=[]; etas:=[]; # etas for the centralizers # fuse centralizers that become the same for j in [1..Length(centralizers)] do C:=Image(pi,centralizers[j]); p:=Position(centimages,C); if p=fail then Add(centimages,C); p:=Length(centimages); fi; Add(centimgindex,p); # #force 'centralizers[j]' to have its base appropriate to the component # # (this will speed up preimages) # cen:=centralizers[j]; # d:=Size(cen); # cen:=Group(GeneratorsOfGroup(cen),()); # StabChain(cen,rec(base:=components[i],size:=d)); # centralizers[j]:=cen; # etas[j]:=ActionHomomorphism(cen,components[i],"surjective"); od; Info(InfoHomClass,2,Length(centimages)," centralizer images"); # consider previous centralizers for j in [1..Length(centimages)] do # determine all reps belonging to this centralizer C:=centimages[j]; selectcen:=Filtered([1..Length(centimgindex)],k->centimgindex[k]=j); Info(InfoHomClass,2,"Number ",j,": ",Length(selectcen), " previous centralizers to consider"); # 7' select:=Filtered([1..Length(centindex)],k->centindex[k] in selectcen); # Determine the addable colours if i=1 then possiblecolours:=[1..Length(fus)]; else possiblecolours:=[]; #for k in select do # bar:=colourbar[k]; k:=1; while k<=Length(select) and Length(possiblecolours)j[1]{[1..i-1]}=bar); UniteSet(possiblecolours, potentialbars{[1..Length(potentialbars)]}[1][i]); k:=k+1; od; fi; for k in Union(fus{possiblecolours}) do # double cosets if Size(C)=Size(T) then dc:=[One(T)]; else Assert(1,IsSubgroup(T,clT[k][2])); Assert(1,IsSubgroup(T,C)); dc:=List(DoubleCosetRepsAndSizes(T,clT[k][2],C),i->i[1]); fi; for t in selectcen do # continue partial rep. # #force 'centralizers[j]' to have its base appropriate to the component # # (this will speed up preimages) # if not (HasStabChainMutable(cen) # and i<=Length(centralizers) # and BaseStabChain(StabChainMutable(cen))[1] in centralizers[i]) # then # d:=Size(cen); # cen:= Group( GeneratorsOfGroup( cen ), One( cen ) ); # StabChain(cen,rec(base:=components[i],size:=d)); # #centralizers[t]:=cen; # fi; cen:=centralizers[t]; if not IsBound(etas[t]) then if Number(etas,i->IsBound(i))>500 then for d in Filtered([1..Length(etas)],i->IsBound(etas[i])){[1..500]} do Unbind(etas[d]); od; fi; etas[t]:=ActionHomomorphism(cen,components[i],"surjective"); fi; eta:=etas[t]; select:=Filtered([1..Length(centindex)],l->centindex[l]=t); Info(InfoHomClass,3,"centralizer nr.",t,", ", Length(select)," previous classes"); newcentlocal:=[]; newcentlocalindex:=[]; for d in dc do for s in select do # test whether colour may be added here bar:=Concatenation(colourbar[s],[colofclass[k]]); bar:=ShallowCopy(colourbar[s]); Add(bar,colofclass[k]); MakeImmutable(bar); #if ForAny(bars,j->j[1]{[1..i]}=bar) then if bar in barsi then # new representative elm:=reps[s]*Image(emb,clT[k][1]^d); if elm in Mproj[i] then # store the new element Add(newreps,elm); Add(newcolourbar,bar); if ig^d)); p:=Position(newcentlocal,newcen); if p=fail then Add(newcentlocal,newcen); p:=Length(newcentlocal); fi; Add(newcentlocalindex,p); else Add(newcentlocalindex,1); # dummy, just for counting fi; #else # Info(InfoHomClass,5,"not in"); fi; #else # Info(InfoHomClass,5,bar,"not minimal"); fi; # end the loops from step 9 od; od; Info(InfoHomClass,2,Length(newcentlocalindex), " new representatives"); if icolourbar[i]=b1); if Length(select)>1 then Info(InfoHomClass,2,"test ",Length(select)," classes for fusion"); fi; newcentlocal:=[]; for i in [1..Length(select)] do if not ForAny(newcentlocal,j->reps[select[i]] in j) then #AH we could also compute the centralizer C:=Centralizer(F,reps[select[i]]); Add(newreps,[reps[select[i]],C]); if i1 then # there are other reps with the same bar left and the bar # stabilizer is bigger than M if not IsBound(bar[2]!.colstabprimg) then # identical stabilizers have the same link. Therefore store the # preimage in them bar[2]!.colstabprimg:=PreImage(ophom,bar[2]); fi; # any fusion would take place in the stabilizer preimage # we know that C must fix the bar, so it is the centralizer there. r:=ConjugacyClass(bar[2]!.colstabprimg,reps[select[i]],C); Add(newcentlocal,r); fi; fi; od; od; Info(InfoHomClass,1,"fused to ",Length(newreps)," inner classes"); clF:=newreps; clin:=ShallowCopy(clF); Assert(1,Sum(clin,i->Index(F,i[2]))=Size(M)); clout:=[]; # outer classes clop:=Filtered(ConjugacyClasses(op),i->Order(Representative(i))>1); for k in clop do Info(InfoHomClass,1,"lifting class ",Representative(k)); r:=PreImagesRepresentative(ophom,Representative(k)); # try to make r of small order rp:=r^Order(Representative(k)); rp:=RepresentativeAction(M,Concatenation(components), Concatenation(OnTuples(components[1],rp^-1), Concatenation(components{[2..n]})),OnTuples); if rp<>fail then r:=r*rp; else Info(InfoHomClass,2, "trying random modification to get large centralizer"); cnt:=LogInt(Size(autT),2)*10; brp:=(); bcen:=Size(Centralizer(F,r)); repeat rp:=Random(M); cengen:=Size(Centralizer(M,r*rp)); if cengen>bcen then bcen:=cengen; brp:=rp; cnt:=LogInt(Size(autT),2)*10; else cnt:=cnt-1; fi; until cnt<0; r:=r*brp; Info(InfoHomClass,2,"achieved centralizer size ",bcen); fi; Info(InfoHomClass,2,"representative ",r); cr:=Centralizer(M,r); # first look at M-action reps:=[One(M)]; centralizers:=[M]; centralizers_r:=[cr]; for i in [1..n] do; newreps:=[]; newcent:=[]; newcent_r:=[]; opfun:=function(a,m) return Comm(r,m)*a^m; end; for j in [1..Length(reps)] do scj:=Size(centralizers[j]); dsz:=0; centrhom:=ActionHomomorphism(centralizers_r[j],components[i], "surjective"); localcent_r:=Image(centrhom); Info(InfoHomClass,4,i,":",j); Info(InfoHomClass,3,"acting: ",Size(centralizers[j])," minimum ", Int(Size(Image(projections[i]))/Size(centralizers[j])), " orbits."); # compute C(r)-classes clTR:=[]; for l in clT do Info(InfoHomClass,4,"DC",Index(T,l[2])," ",Index(T,localcent_r)); dc:=DoubleCosetRepsAndSizes(T,l[2],localcent_r); clTR:=Concatenation(clTR,List(dc,i->l[1]^i[1])); od; orb:=[]; for p in [1..Length(clTR)] do repres:=PreImagesRepresentative(projections[i],clTR[p]); if i=1 or isdirprod or reps[j]*RestrictedPermNC(repres,components[i]) in Mproj[i] then stab:=Centralizer(localcent_r,clTR[p]); if Index(localcent_r,stab)clTR[p] then genpos:=Position(img,clTR[p]); img:=Permuted(img,(1,genpos)); fi; else img:=ConjugacyClass(localcent_r,clTR[p],stab); fi; Add(orb,[repres,PreImage(centrhom,stab),img,localcent_r]); fi; od; clTR:=orb; #was: #clTR:=List(clTR,i->ConjugacyClass(localcent_r,i)); #clTR:=List(clTR,j->[PreImagesRepresentative(projections[i], # Representative(j)), # PreImage(centrhom,Centralizer(j)), # j]); # put small classes to the top (to be sure to hit them and make # large local stabilizers) Sort(clTR,function(a,b) return Size(a[3])not i in localcent_r); while Length(clTR)>0 do # orbit algorithm on classes stab:=clTR[1][2]; orb:=[clTR[1]]; #repres:=RestrictedPermNC(clTR[1][1],components[i]); repres:=clTR[1][1]; trans:=[One(M)]; select:=[2..Length(clTR)]; orpo:=1; minlen:=Size(orb[1][3]); possible:=false; stabtrue:=false; pf:=infinity; maxdiff:=Size(T); again:=0; trymap:=false; ug:=[]; # test whether we have full orbit and full stabilizer while Size(centralizers[j])>(Sum(orb,i->Size(i[3]))*Size(stab)) do genpos:=1; while genpos<=Length(cengen) and Size(centralizers[j])>(Sum(orb,i->Size(i[3]))*Size(stab)) do gen:=cengen[genpos]; skip:=false; if trymap<>false then orpo:=trymap[1]; gen:=trymap[2]; trymap:=false; elif again>0 then if not IsBound(ug[genpos]) then ug[genpos]:=Intersection(centralizers_r[j], ConjugateSubgroup(centralizers_r[j],gen^-1)); fi; if again<500 and ForAll(GeneratorsOfGroup(centralizers_r[j]), i->i in ug[genpos]) then # the random elements will give us nothing new skip:=true; else # get an element not in ug[genpos] repeat img:=Random(centralizers_r[j]); until not img in ug[genpos] or again>=500; gen:=img*gen; fi; fi; if not skip then img:=Image(projections[i],opfun(orb[orpo][1],gen)); smacla:=select; if not stabtrue then p:=PositionProperty(orb,i->img in i[3]); ppos:=fail; else # we have the stabilizer and thus are only interested in # getting new elements. ppos:=PositionProperty(select, i->Size(clTR[i][3])<=maxdiff and img in clTR[i][3]); if ppos=fail then p:="ignore"; #to avoid the first case else ppos:=select[ppos]; # get the right value p:=fail; # go to first case fi; fi; if p=fail then if ppos=fail then p:=First(select, i->Size(clTR[i][3])<=maxdiff and img in clTR[i][3]); else p:=ppos; fi; RemoveSet(select,p); Add(orb,clTR[p]); #change the transversal element to map to the representative con:=trans[orpo]*gen; limg:=opfun(repres,con); con:=con*PreImagesRepresentative(centrhom, RepresentativeAction(localcent_r, Image(projections[i],limg), Representative(clTR[p][3]))); Assert(1,Image(projections[i],opfun(repres,con)) =Representative(clTR[p][3])); Add(trans,con); for stgen in GeneratorsOfGroup(clTR[p][2]) do Assert( 1, IsOne( Image( projections[i], opfun(repres,con*stgen/con)/repres ) ) ); stab:=ClosureGroup(stab,con*stgen/con); od; # compute new minimum length if Length(select)>0 then remainlen:=List(clTR{select},i->Size(i[3])); gcd:=Gcd(remainlen); diff:=minlen-Sum(orb,i->Size(i[3])); if diff<0 then # only go through this if the orbit actually grew # larger minlen:=Sum(orb,i->Size(i[3])); repeat if dsz=0 then dsz:=DivisorsInt(scj); fi; while not minlen in dsz do # minimum gcd multiple to get at least the # smallest divisor minlen:=minlen+ (QuoInt((First(dsz,i->i>=minlen)-minlen-1), gcd)+1)*gcd; od; # now try whether we actually can add orbits to make up # that length diff:=minlen-Sum(orb,i->Size(i[3])); Assert(1,diff>=0); # filter those remaining classes small enough to make # up the length smacla:=Filtered(select,i->Size(clTR[i][3])<=diff); remainlen:=List(clTR{smacla},i->Size(i[3])); combl:=1; possible:=false; if diff=0 then possible:=fail; fi; while gcd*combl<=diff and combl<=Length(remainlen) and possible=false do if NrCombinations(remainlen,combl)<100 then possible:=ForAny(Combinations(remainlen,combl), i->Sum(i)=diff); else possible:=fail; fi; combl:=combl+1; od; if possible=false then minlen:=minlen+gcd; fi; until possible<>false; fi; # if minimal orbit length grew Info(InfoHomClass,5,"Minimum length of this orbit ", minlen," (",diff," missing)"); fi; if minlen*Size(stab)=Size(centralizers[j]) then #Assert(1,Length(smacla)>0); maxdiff:=diff; stabtrue:=true; fi; elif not stabtrue then # we have an element that stabilizes the conjugacy class. # correct this to an element that fixes the representative. # (As we have taken already the centralizer in # centralizers_r, it is sufficient to correct by # centralizers_r-conjugation.) con:=trans[orpo]*gen; limg:=opfun(repres,con); con:=con*PreImagesRepresentative(centrhom, RepresentativeAction(localcent_r, Image(projections[i],limg), Representative(orb[p][3]))); stab:=ClosureGroup(stab,con/trans[p]); if Size(stab)*2*minlen>Size(centralizers[j]) then Info(InfoHomClass,3, "true stabilizer found (cannot grow)"); minlen:=Size(centralizers[j])/Size(stab); maxdiff:=minlen-Sum(orb,i->Size(i[3])); stabtrue:=true; fi; fi; if stabtrue then smacla:=Filtered(select,i->Size(clTR[i][3])<=maxdiff); if Length(smacla)Size(i[3])); Info(InfoHomClass,3, "This is the true orbit length (missing ", maxdiff,")"); if Size(stab)*Sum(orb,i->Size(i[3])) =Size(centralizers[j]) then maxdiff:=0; elif Sum(remainlen)=maxdiff then Info(InfoHomClass,2, "Full possible remainder must fuse"); orb:=Concatenation(orb,clTR{smacla}); select:=Difference(select,smacla); else # test whether there is only one possibility to get # this length if Length(smacla)<20 and Sum(List([1..Minimum(Length(smacla), Int(maxdiff/gcd+1))], x-> NrCombinations(smacla,x)))<10000 then # get all reasonable combinations smare:=[1..Length(smacla)]; #range for smacla combl:=Concatenation(List([1..Int(maxdiff/gcd+1)], i->Combinations(smare,i))); # pick those that have the correct length combl:=Filtered(combl,i->Sum(remainlen{i})=maxdiff); if Length(combl)>1 then Info(InfoHomClass,3,"Addendum not unique (", Length(combl)," possibilities)"); if (maxdiff<10 or again>0) and ForAll(combl,i->Length(i)<=5) then # we have tried often enough, now try to pick the # right ones possible:=false; combl:=Union(combl); combl:=smacla{combl}; genpos2:=1; smacla:=[]; while possible=false and Length(combl)>0 do img:=Image(projections[i], opfun(clTR[combl[1]][1],cengen[genpos2])); p:=PositionProperty(orb,i->img in i[3]); if p<>fail then # it is! Info(InfoHomClass,4,"got one!"); # remember the element to try trymap:=[p,(cengen[genpos2]* PreImagesRepresentative( RestrictedMapping(projections[i], centralizers[j]), RepresentativeAction( orb[p][4], img,Representative(orb[p][3])) ))^-1]; Add(smacla,combl[1]); combl:=combl{[2..Length(combl)]}; if Sum(clTR{smacla},i->Size(i[3]))=maxdiff then # bingo! possible:=true; fi; fi; genpos2:=genpos2+1; if genpos2>Length(cengen) then genpos2:=1; combl:=combl{[2..Length(combl)]}; fi; od; if possible=false then Info(InfoHomClass,4,"Even test failed!"); else orb:=Concatenation(orb,clTR{smacla}); select:=Difference(select,smacla); Info(InfoHomClass,3,"Completed orbit (hard)"); fi; fi; else combl:=combl[1]; orb:=Concatenation(orb,clTR{smacla{combl}}); select:=Difference(select,smacla{combl}); Info(InfoHomClass,3,"Completed orbit"); fi; fi; fi; fi; fi; else Info(InfoHomClass,5,"skip"); fi; # if not skip genpos:=genpos+1; od; orpo:=orpo+1; if orpo>Length(orb) then Info(InfoHomClass,3,"Size factor:",EvalF( (Sum(orb,i->Size(i[3]))*Size(stab))/Size(centralizers[j])), " orbit consists of ",Length(orb)," suborbits, iterating"); orpo:=1; again:=again+1; fi; od; Info(InfoHomClass,2,"Stabsize = ",Size(stab), ", centstabsize = ",Size(orb[1][2])); clTR:=clTR{select}; Info(InfoHomClass,2,"orbit consists of ",Length(orb)," suborbits,", Length(clTR)," classes left."); Info(InfoHomClass,3,List(orb,i->Size(i[2]))); Info(InfoHomClass,4,List(orb,i->Size(i[3]))); # select the orbit element with the largest local centralizer orpo:=1; p:=2; while p<=Length(orb) do if IsBound(trans[p]) and Size(orb[p][2])>Size(orb[orpo][2]) then orpo:=p; fi; p:=p+1; od; if orpo<>1 then Info(InfoHomClass,3,"switching to orbit position ",orpo); repres:=opfun(repres,trans[orpo]); #repres:=RestrictedPermNC(clTR[1][1],repres); stab:=stab^trans[orpo]; fi; Assert(1,ForAll(GeneratorsOfGroup(stab), j -> IsOne( Image(projections[i],opfun(repres,j)/repres) ))); # correct stabilizer to element stabilizer Add(newreps,reps[j]*RestrictedPermNC(repres,components[i])); Add(newcent,stab); Add(newcent_r,orb[orpo][2]); od; od; reps:=newreps; centralizers:=newcent; centralizers_r:=newcent_r; Info(InfoHomClass,2,Length(reps)," representatives"); od; select:=Filtered([1..Length(reps)],i->reps[i] in M); reps:=reps{select}; reps:=List(reps,i->r*i); centralizers:=centralizers{select}; centralizers_r:=centralizers_r{select}; Info(InfoHomClass,1,Length(reps)," in M"); # fuse reps if necessary cen:=PreImage(ophom,Centralizer(k)); newreps:=[]; newcentlocal:=[]; for i in [1..Length(reps)] do bar:=CycleStructurePerm(reps[i]); ore:=Order(reps[i]); newcentlocal:=Filtered(newreps, i->Order(Representative(i))=ore and i!.elmcyc=bar); if not ForAny(newcentlocal,j->reps[i] in j) then C:=Centralizer(cen,reps[i]); # AH can we use centralizers[i] here ? Add(clF,[reps[i],C]); Add(clout,[reps[i],C]); bar:=ConjugacyClass(cen,reps[i],C); bar!.elmcyc:=CycleStructurePerm(reps[i]); Add(newreps,bar); fi; od; Info(InfoHomClass,1,"fused to ",Length(newreps)," classes"); od; Assert(1,Sum(clout,i->Index(F,i[2]))=Size(F)-Size(M)); Info(InfoHomClass,2,Length(clin)," inner classes, total size =", Sum(clin,i->Index(F,i[2]))); Info(InfoHomClass,2,Length(clout)," outer classes, total size =", Sum(clout,i->Index(F,i[2]))); Info(InfoHomClass,3," Minimal ration for outer classes =", EvalF(Minimum(List(clout,i->Index(F,i[2])/(Size(F)-Size(M)))),30)); Info(InfoHomClass,1,"returning ",Length(clF)," classes"); Assert(1,Sum(clF,i->Index(F,i[2]))=Size(F)); return clF; end); InstallGlobalFunction(ConjugacyClassesFittingFreeGroup,function(G) local cs, # chief series of G i, # index cs cl, # list [classrep,centralizer] hom, # G->G/cs[i] M, # cs[i-1] N, # cs[i] subN, # maximan normal in M over N csM, # orbit of nt in M under G n, # Length(csM) T, # List of T_i Q, # Action(G,T) Qhom, # G->Q and F->Q S, # PreImage(Qhom,Stab_Q(1)) S1, # Action of S on T[1] deg1, # deg (s1) autos, # automorphism for action arhom, # autom permrep list Thom, # S->S1 T1, # T[1] Thom w, # S1\wrQ wbas, # base of w emb, # embeddings of w proj, # projections of wbas components, # components of w reps, # List reps in G for 1->i in Q F, # action of G on M/N Fhom, # G -> F FQhom, # Fhom*Qhom genimages,# G.generators Fhom img, # gQhom gimg, # gFhom act, # component permcation to 1 j,k, # loop C, # Ker(Fhom) clF, # classes of F ncl, # new classes FM, # normal subgroup in F, Fhom(M) FMhom, # M->FM dc, # double cosets jim, # image of j Cim, CimCl, p, l,lj, l1, elm, zentr, onlysizes, good,bad, lastM; onlysizes:=ValueOption("onlysizes"); # we assume the group has no solvable normal subgroup. Thus we get all # classes by lifts via nonabelian factors and can disregard all abelian # factors. # we will give classes always by their representatives in G and # centralizers by their full preimages in G. cs:= ChiefSeriesOfGroup( G ); # the first step is always simple if HasAbelianFactorGroup(G,cs[2]) then # try to get the largest abelian factor i:=2; while i[i,G]); else # compute the classes of the simple nonabelian factor by random search hom:=NaturalHomomorphismByNormalSubgroupNC(G,cs[2]); cl:=ConjugacyClasses(Image(hom)); cl:=List(cl,i->[PreImagesRepresentative(hom,Representative(i)), PreImage(hom,StabilizerOfExternalSet(i))]); fi; lastM:=cs[2]; for i in [3..Length(cs)] do # we assume that cl contains classreps/centralizers for G/cs[i-1] # we want to lift to G/cs[i] M:=cs[i-1]; N:=cs[i]; Info(InfoHomClass,1,i,":",Index(M,N),"; ",Size(N)); if HasAbelianFactorGroup(M,N) then Info(InfoHomClass,2,"abelian factor ignored"); else # nonabelian factor. Now it means real work. # 1) compute the action for the factor # first, we obtain the simple factors T_i/N. # we get these as intersections of the conjugates of the subnormal # subgroup csM:=CompositionSeries(M); # stored attribute if not IsSubset(csM[2],N) then # the composition series goes the wrong way. Now take closures of # its steps with N to get a composition series for M/N, take the # first proper factor for subN. n:=3; subN:=fail; while n<=Length(csM) and subN=fail do subN:=ClosureGroup(N,csM[n]); if Index(M,subN)=1 then subN:=fail; # still wrong fi; n:=n+1; od; else subN:=csM[2]; fi; if IsNormal(G,subN) then # only one -> Call standard process Fhom:=fail; # is this an almost top factor? if Index(G,M)<10 then Thom:=NaturalHomomorphismByNormalSubgroupNC(G,subN); T1:=Image(Thom,M); S1:=Image(Thom); if Size(Centralizer(S1,T1))=1 then deg1:=NrMovedPoints(S1); Info(InfoHomClass,2, "top factor gives conjugating representation, deg ",deg1); Fhom:=Thom; fi; else Thom:=NaturalHomomorphismByNormalSubgroupNC(M,subN); T1:=Image(Thom,M); fi; if Fhom=fail then autos:=List(GeneratorsOfGroup(G), i->GroupHomomorphismByImagesNC(T1,T1,GeneratorsOfGroup(T1), List(GeneratorsOfGroup(T1), j->Image(Thom,PreImagesRepresentative(Thom,j)^i)))); # find (probably another) permutation rep for T1 for which all # automorphisms can be represented by permutations arhom:=AutomorphismRepresentingGroup(T1,autos); S1:=arhom[1]; deg1:=NrMovedPoints(S1); Fhom:=GroupHomomorphismByImagesNC(G,S1,GeneratorsOfGroup(G),arhom[3]); fi; C:=KernelOfMultiplicativeGeneralMapping(Fhom); F:=Image(Fhom,G); if IsNaturalSymmetricGroup(F) or IsNaturalAlternatingGroup(F) then clF:=ConjugacyClasses(F); else clF:=ConjugacyClassesByRandomSearch(F); fi; clF:=List(clF,j->[Representative(j),StabilizerOfExternalSet(j)]); else csM:=Orbit(G,subN); # all conjugates n:=Length(csM); if n=1 then Error("this cannot happen"); T:=M; fi; T:=Intersection(csM{[2..Length(csM)]}); # one T_i if Length(GeneratorsOfGroup(T))>5 then T:=Group(SmallGeneratingSet(T)); fi; T:=Orbit(G,T); # get all the t's # now T[1] is a complement to csM[1] in G/N. # now compute the operation of G on M/N Qhom:=ActionHomomorphism(G,T,"surjective"); Q:=Image(Qhom,G); S:=PreImage(Qhom,Stabilizer(Q,1)); # find a permutation rep. for S-action on T[1] Thom:=NaturalHomomorphismByNormalSubgroupNC(T[1],N); T1:=Image(Thom,T[1]); autos:=List(GeneratorsOfGroup(S), i->GroupHomomorphismByImagesNC(T1,T1,GeneratorsOfGroup(T1), List(GeneratorsOfGroup(T1), j->Image(Thom,PreImagesRepresentative(Thom,j)^i)))); # find (probably another) permutation rep for T1 for which all # automorphisms can be represented by permutations arhom:=AutomorphismRepresentingGroup(T1,autos); S1:=arhom[1]; deg1:=NrMovedPoints(S1); Thom:=GroupHomomorphismByImagesNC(S,S1,GeneratorsOfGroup(S),arhom[3]); T1:=Image(Thom,T[1]); # now embed into wreath w:=WreathProduct(S1,Q); wbas:=DirectProduct(List([1..n],i->S1)); emb:=List([1..n+1],i->Embedding(w,i)); proj:=List([1..n],i->Projection(wbas,i)); components:=WreathProductInfo(w).components; # define isomorphisms between the components reps:=List([1..n],i-> PreImagesRepresentative(Qhom,RepresentativeAction(Q,1,i))); genimages:=[]; for j in GeneratorsOfGroup(G) do img:=Image(Qhom,j); gimg:=Image(emb[n+1],img); for k in [1..n] do # look at part of j's action on the k-th factor. # we get this by looking at the action of # reps[k] * j * reps[k^img]^-1 # 1 -> k -> k^img -> 1 # on the first component. act:=reps[k]*j*(reps[k^img]^-1); # this must be multiplied *before* permuting gimg:=ImageElm(emb[k],ImageElm(Thom,act))*gimg; gimg:=RestrictedPermNC(gimg,MovedPoints(w)); od; Add(genimages,gimg); od; F:=Subgroup(w,genimages); if AssertionLevel()>0 then Fhom:=GroupHomomorphismByImages(G,F,GeneratorsOfGroup(G),genimages); Assert(1,fail<>Fhom); else Fhom:=GroupHomomorphismByImagesNC(G,F,GeneratorsOfGroup(G),genimages); fi; C:=KernelOfMultiplicativeGeneralMapping(Fhom); Info(InfoHomClass,1,"constructed Fhom"); # 2) compute the classes for F if n>1 then #if IsPermGroup(F) and NrMovedPoints(F)<18 then # # the old Butler/Theissen approach is still OK # clF:=[]; # for j in # Concatenation(List(RationalClasses(F),DecomposedRationalClass)) do # Add(clF,[Representative(j),StabilizerOfExternalSet(j)]); # od; #else FM:=F; for j in components do FM:=Stabilizer(FM,j,OnSets); od; clF:=ConjugacyClassesSubwreath(F,FM,n,S1, Action(FM,components[1]),T1,components,emb,proj); #fi; else FM:=Image(Fhom,M); Info(InfoHomClass,1, "classes by random search in almost simple group"); if IsNaturalSymmetricGroup(F) or IsNaturalAlternatingGroup(F) then clF:=ConjugacyClasses(F); else clF:=ConjugacyClassesByRandomSearch(F); fi; clF:=List(clF,j->[Representative(j),StabilizerOfExternalSet(j)]); fi; fi; # true orbit of T. Assert(1,Sum(clF,i->Index(F,i[2]))=Size(F)); Assert(1,ForAll(clF,i->Centralizer(F,i[1])=i[2])); # 3) combine to form classes of sdp # the length(cl)=1 gets rid of solvable stuff on the top we got ``too # early''. if IsSubgroup(N,KernelOfMultiplicativeGeneralMapping(Fhom)) then Info(InfoHomClass,1, "homomorphism is faithful for relevant factor, take preimages"); if Size(N)=1 and onlysizes=true then cl:=List(clF,i->[PreImagesRepresentative(Fhom,i[1]),Size(i[2])]); else cl:=List(clF,i->[PreImagesRepresentative(Fhom,i[1]), PreImage(Fhom,i[2])]); fi; else Info(InfoHomClass,1,"forming subdirect products"); FM:=Image(Fhom,lastM); FMhom:=RestrictedMapping(Fhom,lastM); if Index(F,FM)=1 then Info(InfoHomClass,1,"degenerated to direct product"); ncl:=[]; for j in cl do for k in clF do # modify the representative with a kernel elm. to project # correctly on the second component elm:=j[1]*PreImagesRepresentative(FMhom, LeftQuotient(Image(Fhom,j[1]),k[1])); zentr:=Intersection(j[2],PreImage(Fhom,k[2])); Assert(2,ForAll(GeneratorsOfGroup(zentr), i->Comm(i,elm) in N)); Add(ncl,[elm,zentr]); od; od; cl:=ncl; else # first we add the centralizer closures and sort by them # (this allows to reduce the number of double coset calculations) ncl:=[]; for j in cl do Cim:=Image(Fhom,j[2]); CimCl:=Cim; #CimCl:=ClosureGroup(FM,Cim); # should be unnecessary, as we took # the full preimage p:=PositionProperty(ncl,i->i[1]=CimCl); if p=fail then Add(ncl,[CimCl,[j]]); else Add(ncl[p][2],j); fi; od; Qhom:=NaturalHomomorphismByNormalSubgroupNC(F,FM); Q:=Image(Qhom); FQhom:=Fhom*Qhom; # now construct the sdp's cl:=[]; for j in ncl do lj:=List(j[2],i->Image(FQhom,i[1])); for k in clF do # test whether the classes are potential mates elm:=Image(Qhom,k[1]); if not ForAll(lj,i->RepresentativeAction(Q,i,elm)=fail) then #l:=Image(Fhom,j[1]); if Index(F,j[1])=1 then dc:=[()]; else dc:=List(DoubleCosetRepsAndSizes(F,k[2],j[1]),i->i[1]); fi; good:=0; bad:=0; for l in j[2] do jim:=Image(FQhom,l[1]); for l1 in dc do elm:=k[1]^l1; if Image(Qhom,elm)=jim then # modify the representative with a kernel elm. to project # correctly on the second component elm:=l[1]*PreImagesRepresentative(FMhom, LeftQuotient(Image(Fhom,l[1]),elm)); zentr:=PreImage(Fhom,k[2]^l1); zentr:=Intersection(zentr,l[2]); Assert(2,ForAll(GeneratorsOfGroup(zentr), i->Comm(i,elm) in N)); Info(InfoHomClass,4,"new class, order ",Order(elm), ", size=",Index(G,zentr)); Add(cl,[elm,zentr]); good:=good+1; else Info(InfoHomClass,5,"not in"); bad:=bad+1; fi; od; od; Info(InfoHomClass,4,good," good, ",bad," bad of ",Length(dc)); fi; od; od; fi; # real subdirect product fi; # else Fhom not faithful on factor # uff. That was hard work. We're finally done with this layer. lastM:=N; fi; # else nonabelian Info(InfoHomClass,1,"so far ",Length(cl)," classes computed"); od; if Length(cs)<3 then Info(InfoHomClass,1,"Fitting free factor returns ",Length(cl)," classes"); fi; Assert( 1, Sum( List( cl, pair -> Size(G) / Size( pair[2] ) ) ) = Size(G) ); return cl; end); InstallGlobalFunction(ConjugacyClassesViaRadical,function (G) local r, #radical f, # G/r hom, # G->f pcgs,mpcgs, #(modulo) pcgs ser, # series M,N, # normal subgrops ind, # indices i, #loop new, # new classes cl,ncl; # classes # it seems to be cleaner (and avoids deferring abelian factors) if we # factor out the radical first. (Note: The radical method for perm groups # stores the nat hom.!) ser:=PermliftSeries(G); pcgs:=ser[2]; ser:=ser[1]; r:=ser[1]; if Size(r)1 then hom:=NaturalHomomorphismByNormalSubgroupNC(G,r); f:=Image(hom); # we need centralizers cl:=ConjugacyClassesFittingFreeGroup(f:onlysizes:=false); else hom:=SmallerDegreePermutationRepresentation(G); f:=Image(hom); cl:=ConjugacyClassesFittingFreeGroup(f); fi; if not IsOne(hom) then ncl:=[]; for i in cl do new:=[PreImagesRepresentative(hom,i[1])]; if not IsInt(i[2]) then Add(new,PreImage(hom,i[2])); fi; Add(ncl,new); od; cl:=ncl; fi; else cl:=[[One(G),G]]; fi; for i in [2..Length(ser)] do M:=ser[i-1]; N:=ser[i]; # abelian factor, use affine methods Info(InfoHomClass,1,"abelian factor: ",Size(M),"->",Size(N)); if pcgs=false then mpcgs:=ModuloPcgs(M,N); else mpcgs:=pcgs[i-1] mod pcgs[i]; fi; ncl:=[]; for i in cl do Assert(2,ForAll(GeneratorsOfGroup(i[2]),j->Comm(i[1],j) in M)); if ForAll(GeneratorsOfGroup(i[2]), i->ForAll(mpcgs,j->Comm(i,j) in N)) then Info(InfoHomClass,3,"central step"); new:=CentralStepClEANSNonsolv(G,mpcgs,i); else new:=GeneralStepClEANSNonsolv(G,mpcgs,AsSubgroup(G,N),i); fi; Assert(1,ForAll(new, i->ForAll(GeneratorsOfGroup(i[2]),j->Comm(j,i[1]) in N))); Info(InfoHomClass,2,Length(new)," new classes"); ncl:=Concatenation(ncl,new); od; cl:=ncl; Info(InfoHomClass,1,"Now: ",Length(cl)," classes"); od; if Order(cl[1][1])>1 then # the idenity is not in first position Info(InfoHomClass,2,"identity not first, sorting"); Sort(cl,function(a,b) return Order(a[1])Size(G) then ncl:=List(ncl,x->ConjugacyClass(G,Representative(x))); if Sum(ncl,Size)<>Size(G) then Error("wrong classes"); fi; fi; return ncl; end); ############################################################################# ## #M ConjugacyClasses( ) . . . . . . . . . . . . . . . . . . of perm group ## InstallMethod( ConjugacyClasses, "perm group", true, [ IsPermGroup ], 0, function( G ) local cl; if (not HasIsNaturalSymmetricGroup(G) and IsNaturalSymmetricGroup(G)) or (not HasIsNaturalAlternatingGroup(G) and IsNaturalAlternatingGroup(G)) then # we found out anew that the group is symmetric or alternating -> # Redispatch return ConjugacyClasses(G); fi; cl:=ConjugacyClassesForSmallGroup(G); if cl<>fail then return cl; elif IsSimpleGroup( G ) then return ConjugacyClassesByRandomSearch( G ); else return ConjugacyClassesViaRadical(G); fi; end ); BindGlobal("CanonicalClassRepsViaRadical",function (G,reps) local r, #radical f, # G/r hom, # G->f pcgs,mpcgs, #(modulo) pcgs data, # stored data ser, # series M,N, # normal subgrops ind, # indices i,j,q, #loop can, # canonicals list pos, # position conj, # conjugating elements imgs, # images in factor new, # new classes gps,sel, # grouping gpnum, ngps,off, cl,ncl; # classes if IsBound(G!.canClassRepData) then data:=G!.canClassRepData; else # use the stored permlift series to stay consistent amongst calls ser:=PermliftSeries(G); data:=rec(pcgs:=ser[2], ser:=ser[1], mpcgs:=[]); G!.canClassRepData:=data; pcgs:=data!.pcgs; ser:=data!.ser; data.hom:=NaturalHomomorphismByNormalSubgroupNC(G,ser[1]); for i in [2..Length(ser)] do M:=ser[i-1]; N:=ser[i]; if pcgs=false then mpcgs:=ModuloPcgs(M,N); else mpcgs:=pcgs[i-1] mod pcgs[i]; fi; data.mpcgs[i]:=mpcgs; od; fi; pcgs:=data!.pcgs; ser:=data!.ser; r:=ser[1]; gps:=[]; if Size(r)[i,Representative(i),Centralizer(i)]); data.factorcanonicalclasses:=can; fi; can:=data.factorcanonicalclasses; imgs:=List(reps,i->Image(hom,i)); pos:=[]; cl:=[]; gps:=[]; gpnum:=[]; for i in [1..Length(imgs)] do j:=0; while not IsBound(pos[i]) do j:=j+1; if Order(imgs[i])=Order(can[j][2]) and ((not IsPermGroup(f)) or CycleStructurePerm(imgs[i])=CycleStructurePerm(can[j][2])) then conj:=RepresentativeAction(f,imgs[i],can[j][2]); else conj:=fail; fi; if conj<>fail then pos[i]:=j; if IsBound(gpnum[j]) then q:=gpnum[j]; Add(gps[q][1],i); else Add(gps,[[i],PreImagesRepresentative(hom,can[j][2]), PreImage(hom,can[j][3])]); q:=Length(gps); gpnum[j]:=q; fi; conj:=PreImagesRepresentative(hom,conj); cl[i]:=[reps[i]^conj,conj,q]; fi; od; od; else gps:=[[1..Length(reps)],One(G),G]; cl:=List(reps,i->[i,One(G),G,1]); fi; for i in [2..Length(ser)] do M:=ser[i-1]; N:=ser[i]; # abelian factor, use affine methods Info(InfoHomClass,1,"abelian factor: ",Size(M),"->",Size(N)); mpcgs:=data.mpcgs[i]; ngps:=[]; ncl:=[]; for i in gps do if false and ForAll(GeneratorsOfGroup(i[2]), i->ForAll(mpcgs,j->Comm(i,j) in N)) then Info(InfoHomClass,3,"central step"); new:=CentralStepClEANSNonsolv(G,mpcgs,i); else new:=GeneralStepCanEANSNonsolv(G,mpcgs,AsSubgroup(G,N), i[3], # previous centralizer i[2], # previous rep cl, i[1], i=Length(ser) ); fi; off:=Length(ngps); Append(ngps,new[1]); new:=new[2]; for j in [1..Length(reps)] do if IsBound(new[j]) then new[j][3]:=new[j][3]+off; # correct group indices ncl[j]:=new[j]; fi; od; od; cl:=ncl; gps:=ngps; od; Assert(1,ForAll([1..Length(reps)],i->reps[i]^cl[i][2]=cl[i][1])); return List(cl,i->i{[1,2]}); end); ############################################################################# ## #E gap-4r6p5/lib/algmat.gi0000644000175000017500000015553512172557252013513 0ustar billbill############################################################################# ## #W algmat.gi GAP library Thomas Breuer #W Willem de Graaf ## ## #Y Copyright (C) 1997, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains those functions that mainly deal with matrix algebras, ## that is, associative matrix algebras and matrix Lie algebras. ## ############################################################################# ## #M RingByGenerators( ) . . . . ring generated by a list of matrices ## ## If is a list of matrices over a field then we construct a matrix ## algebra over its prime field. ## InstallOtherMethod( RingByGenerators, "for a list of matrices over a finite field", true, [ IsFFECollCollColl ], 0, mats -> FLMLORByGenerators( GF( Characteristic( mats ) ), mats ) ); InstallOtherMethod( RingByGenerators, "for a list of matrices over the Cyclotomics", true, [ IsCyclotomicCollCollColl ], 0, mats -> FLMLORByGenerators( Integers, mats ) ); ############################################################################# ## #M DefaultRingByGenerators( ) . . ring containing a list of matrices ## ## If is a list of matrices over a field then we construct a matrix ## algebra over its prime field. ## (So this may differ from the result of `RingByGenerators' if the ## characteristic is zero.) ## InstallOtherMethod( DefaultRingByGenerators, "for a list of matrices over a finite field", true, [ IsFFECollCollColl ], 0, mats -> FLMLORByGenerators( GF( Characteristic( mats ) ), mats ) ); InstallOtherMethod( DefaultRingByGenerators, "for a list of matrices over the Cyclotomics", true, [ IsCyclotomicCollCollColl ], 0, mats -> FLMLORByGenerators( Rationals, mats ) ); ############################################################################# ## #M RingByGenerators( ) . . ring generated by a list of Lie matrices ## ## If is a list of Lie matrices over a finite field then we construct ## a matrix Lie algebra over its prime field. ## InstallOtherMethod( RingByGenerators, "for a list of Lie matrices over a finite field", true, [ IsLieObjectCollection and IsMatrixCollection ], 0, function( mats ) local Fam; # Check whether the matrices lie in the Lie family of a family of # ordinary matrices. Fam:= UnderlyingFamily( ElementsFamily( FamilyObj( mats ) ) ); if not HasElementsFamily( Fam ) then TryNextMethod(); fi; Fam:= ElementsFamily( Fam ); if not HasElementsFamily( Fam ) then TryNextMethod(); fi; Fam:= ElementsFamily( Fam ); # Handle the cases that the entries of the matrices # are FFEs or cyclotomics. if IsFFEFamily( Fam ) then return FLMLORByGenerators( GF( Characteristic( Fam ) ), mats ); elif IsIdenticalObj( Fam, CyclotomicsFamily ) then return FLMLORByGenerators( Integers, mats ); else TryNextMethod(); fi; end ); ############################################################################# ## #M DefaultRingByGenerators( ) . . ring cont. a list of Lie matrices ## ## If is a list of Lie matrices over a field then we construct ## a matrix Lie algebra over its prime field. ## (So this may differ from the result of `RingByGenerators' if the ## characteristic is zero.) ## InstallOtherMethod( DefaultRingByGenerators, "for a list of Lie matrices", true, [ IsLieObjectCollection and IsMatrixCollection ], 0, function( mats ) local Fam; # Check whether the matrices lie in the Lie family of a family of # ordinary matrices. Fam:= UnderlyingFamily( ElementsFamily( FamilyObj( mats ) ) ); if not HasElementsFamily( Fam ) then TryNextMethod(); fi; Fam:= ElementsFamily( Fam ); if not HasElementsFamily( Fam ) then TryNextMethod(); fi; Fam:= ElementsFamily( Fam ); # Handle the cases that the entries of the matrices # are FFEs or cyclotomics. if IsFFEFamily( Fam ) then return AlgebraByGenerators( GF( Characteristic( Fam ) ), mats ); elif IsIdenticalObj( Fam, CyclotomicsFamily ) then return AlgebraByGenerators( Rationals, mats ); else TryNextMethod(); fi; end ); ############################################################################# ## #M RingWithOneByGenerators( ) ring-with-one gen. by list of matrices ## ## If is a list of matrices over a field then we construct a matrix ## algebra over its prime field. ## InstallOtherMethod( RingWithOneByGenerators, "for a list of matrices over a finite field", true, [ IsFFECollCollColl ], 0, mats -> FLMLORWithOneByGenerators( GF( Characteristic(mats) ), mats ) ); InstallOtherMethod( RingWithOneByGenerators, "for a list of matrices over the Cyclotomics", true, [ IsCyclotomicCollCollColl ], 0, mats -> FLMLORWithOneByGenerators( Integers, mats ) ); #T how to formulate this for any field? ############################################################################# ## #M FLMLORByGenerators( , ) #M FLMLORByGenerators( , , ) #M FLMLORByGenerators( , , ) ## InstallMethod( FLMLORByGenerators, "for division ring and list of ordinary matrices over it", IsElmsCollColls, [ IsDivisionRing, IsCollection and IsList ], 0, function( F, mats ) local dims, A; # Check that all entries in `mats' are square matrices of the same shape. if not IsOrdinaryMatrix( mats[1] ) then TryNextMethod(); fi; dims:= DimensionsMat( mats[1] ); if dims[1] <> dims[2] or not ForAll( mats, mat -> IsOrdinaryMatrix( mat ) and DimensionsMat( mat ) = dims ) then TryNextMethod(); fi; if ForAll( mats, mat -> ForAll( mat, row -> IsSubset( F, row ) ) ) then A:= Objectify( NewType( FamilyObj( mats ), IsFLMLOR and IsGaussianMatrixSpace and IsAttributeStoringRep ), rec() ); else A:= Objectify( NewType( FamilyObj( mats ), IsFLMLOR and IsVectorSpace and IsNonGaussianMatrixSpace and IsAttributeStoringRep ), rec() ); fi; SetLeftActingDomain( A, F ); SetGeneratorsOfLeftOperatorRing( A, AsList( mats ) ); SetDimensionOfVectors( A, dims ); # If the generators are associative elements then so is `A'. if ForAll( mats, IsAssociativeElement ) then SetIsAssociative( A, true ); fi; # Return the result. return A; end ); InstallOtherMethod( FLMLORByGenerators, "for division ring, empty list, and square ordinary matrix", function( FamF, Famempty, Famzero ) return IsElmsColls( FamF, Famzero ); end, [ IsDivisionRing, IsList and IsEmpty, IsOrdinaryMatrix ], 0, function( F, empty, zero ) local dims, A; # Check whether this method is the right one. dims:= DimensionsMat( zero ); if dims[1] <> dims[2] then Error( " must be a square matrix" ); fi; A:= Objectify( NewType( CollectionsFamily( FamilyObj( zero ) ), IsFLMLOR and IsGaussianMatrixSpace and IsTrivial and IsAttributeStoringRep ), rec() ); SetLeftActingDomain( A, F ); SetGeneratorsOfLeftModule( A, empty ); SetZero( A, zero ); SetDimensionOfVectors( A, dims ); # Return the result. return A; end ); InstallOtherMethod( FLMLORByGenerators, "for division ring, list of matrices over it, and ordinary matrix", function( FamF, Fammats, Famzero ) return IsElmsCollColls( FamF, Fammats ); end, [ IsDivisionRing, IsCollection and IsList, IsOrdinaryMatrix ], 0, function( F, mats, zero ) local dims, A; # Check that all entries in `mats' are matrices of the same shape. if not IsOrdinaryMatrix( mats[1] ) then TryNextMethod(); fi; dims:= DimensionsMat( mats[1] ); if dims[1] <> dims[2] or not ForAll( mats, mat -> IsOrdinaryMatrix( mat ) and DimensionsMat( mat ) = dims ) then TryNextMethod(); fi; if ForAll( mats, mat -> ForAll( mat, row -> IsSubset( F, row ) ) ) then A:= Objectify( NewType( FamilyObj( mats ), IsFLMLOR and IsGaussianMatrixSpace and IsAttributeStoringRep ), rec() ); else A:= Objectify( NewType( FamilyObj( mats ), IsFLMLOR and IsVectorSpace and IsNonGaussianMatrixSpace and IsAttributeStoringRep ), rec() ); fi; SetLeftActingDomain( A, F ); SetGeneratorsOfLeftOperatorRing( A, AsList( mats ) ); SetZero( A, zero ); SetDimensionOfVectors( A, dims ); # If the generators are associative elements then so is `A'. if ForAll( mats, IsAssociativeElement ) then SetIsAssociative( A, true ); fi; # Return the result. return A; end ); ############################################################################# ## #M FLMLORByGenerators( , ) #M FLMLORByGenerators( , , ) #M FLMLORByGenerators( , , ) ## InstallMethod( FLMLORByGenerators, "for division ring and list of Lie matrices over it", IsElmsCollLieColls, [ IsDivisionRing, IsLieObjectCollection and IsList ], 0, function( F, mats ) local dims, A; # Check that all entries in `mats' are square matrices of the same shape. if not IsLieMatrix( mats[1] ) then TryNextMethod(); fi; dims:= DimensionsMat( mats[1] ); if dims[1] <> dims[2] or not ForAll( mats, mat -> IsLieMatrix( mat ) and DimensionsMat( mat ) = dims ) then TryNextMethod(); fi; if ForAll( mats, mat -> ForAll( mat, row -> IsSubset( F, row ) ) ) then A:= Objectify( NewType( FamilyObj( mats ), IsFLMLOR and IsGaussianMatrixSpace and IsAttributeStoringRep ), rec() ); else A:= Objectify( NewType( FamilyObj( mats ), IsFLMLOR and IsVectorSpace and IsNonGaussianMatrixSpace and IsAttributeStoringRep ), rec() ); fi; SetLeftActingDomain( A, F ); SetGeneratorsOfLeftOperatorRing( A, AsList( mats ) ); SetDimensionOfVectors( A, dims ); # `A' consists of Lie objects, so it is a Lie algebra. SetIsLieAlgebra( A, true ); # Return the result. return A; end ); InstallOtherMethod( FLMLORByGenerators, "for division ring, empty list, and Lie matrix", function( FamF, Famempty, Famzero ) return IsElmsLieColls( FamF, Famzero ); end, [ IsDivisionRing, IsList and IsEmpty, IsLieMatrix and IsLieObject ], 0, function( F, empty, zero ) local dims, A; # Check whether this method is the right one. dims:= DimensionsMat( zero ); if dims[1] <> dims[2] then Error( " must be a square matrix" ); fi; A:= Objectify( NewType( CollectionsFamily( FamilyObj( zero ) ), IsFLMLOR and IsGaussianMatrixSpace and IsTrivial and IsAttributeStoringRep ), rec() ); SetLeftActingDomain( A, F ); SetGeneratorsOfLeftModule( A, empty ); SetZero( A, zero ); SetDimensionOfVectors( A, dims ); # Return the result. return A; end ); InstallOtherMethod( FLMLORByGenerators, "for division ring, list of Lie matrices over it, and Lie matrix", function( FamF, Fammats, Famzero ) return IsElmsCollLieColls( FamF, Fammats ); end, [ IsDivisionRing, IsLieObjectCollection and IsList, IsLieObject and IsLieMatrix ], 0, function( F, mats, zero ) local dims, A; # Check that all entries in `mats' are matrices of the same shape. if not IsLieMatrix( mats[1] ) then TryNextMethod(); fi; dims:= DimensionsMat( mats[1] ); if dims[1] <> dims[2] or not ForAll( mats, mat -> IsLieMatrix( mat ) and DimensionsMat( mat ) = dims ) then TryNextMethod(); fi; if ForAll( mats, mat -> ForAll( mat, row -> IsSubset( F, row ) ) ) then A:= Objectify( NewType( FamilyObj( mats ), IsFLMLOR and IsGaussianMatrixSpace and IsAttributeStoringRep ), rec() ); else A:= Objectify( NewType( FamilyObj( mats ), IsFLMLOR and IsVectorSpace and IsNonGaussianMatrixSpace and IsAttributeStoringRep ), rec() ); fi; SetLeftActingDomain( A, F ); SetGeneratorsOfLeftOperatorRing( A, AsList( mats ) ); SetZero( A, zero ); SetDimensionOfVectors( A, dims ); # `A' consists of Lie objects, so it is a Lie algebra. SetIsLieAlgebra( A, true ); # Return the result. return A; end ); ############################################################################# ## #M FLMLORWithOneByGenerators( , ) #M FLMLORWithOneByGenerators( , , ) #M FLMLORWithOneByGenerators( , , ) ## InstallMethod( FLMLORWithOneByGenerators, "for division ring and list of ordinary matrices over it", IsElmsCollColls, [ IsDivisionRing, IsCollection and IsList ], 0, function( F, mats ) local dims, A; # Check that all entries in `mats' are square matrices of the same shape. if not IsOrdinaryMatrix( mats[1] ) then TryNextMethod(); fi; dims:= DimensionsMat( mats[1] ); if dims[1] <> dims[2] or not ForAll( mats, mat -> IsOrdinaryMatrix( mat ) and DimensionsMat( mat ) = dims ) then TryNextMethod(); fi; if ForAll( mats, mat -> ForAll( mat, row -> IsSubset( F, row ) ) ) then A:= Objectify( NewType( FamilyObj( mats ), IsFLMLORWithOne and IsGaussianMatrixSpace and IsAttributeStoringRep ), rec() ); else A:= Objectify( NewType( FamilyObj( mats ), IsFLMLORWithOne and IsVectorSpace and IsNonGaussianMatrixSpace and IsAttributeStoringRep ), rec() ); fi; SetLeftActingDomain( A, F ); SetGeneratorsOfLeftOperatorRingWithOne( A, AsList( mats ) ); SetDimensionOfVectors( A, dims ); # If the generators are associative elements then so is `A'. if ForAll( mats, IsAssociativeElement ) then SetIsAssociative( A, true ); fi; # Return the result. return A; end ); InstallOtherMethod( FLMLORWithOneByGenerators, "for division ring, empty list, and square ordinary matrix", function( FamF, Famempty, Famzero ) return IsElmsColls( FamF, Famzero ); end, [ IsDivisionRing, IsList and IsEmpty, IsOrdinaryMatrix ], 0, function( F, empty, zero ) local A; # Check whether this method is the right one. if Length( zero ) <> Length( zero[1] ) then Error( " must be a square matrix" ); fi; A:= Objectify( NewType( CollectionsFamily( FamilyObj( zero ) ), IsFLMLORWithOne and IsGaussianMatrixSpace and IsAssociative and IsAttributeStoringRep ), rec() ); SetLeftActingDomain( A, F ); SetGeneratorsOfLeftOperatorRingWithOne( A, empty ); SetZero( A, zero ); SetDimensionOfVectors( A, DimensionsMat( zero ) ); # Return the result. return A; end ); InstallOtherMethod( FLMLORWithOneByGenerators, "for division ring, list of matrices over it, and ordinary matrix", function( FamF, Fammats, Famzero ) return HasCollectionsFamily( FamF ) and IsElmsColls( CollectionsFamily( FamF ), Fammats ); end, [ IsDivisionRing, IsCollection and IsList, IsOrdinaryMatrix ], 0, function( F, mats, zero ) local dims, A; # Check that all entries in `mats' are matrices of the same shape. if not IsOrdinaryMatrix( mats[1] ) then TryNextMethod(); fi; dims:= DimensionsMat( mats[1] ); if dims[1] <> dims[2] or not ForAll( mats, mat -> IsOrdinaryMatrix( mat ) and DimensionsMat( mat ) = dims ) then TryNextMethod(); fi; if ForAll( mats, mat -> ForAll( mat, row -> IsSubset( F, row ) ) ) then A:= Objectify( NewType( FamilyObj( mats ), IsFLMLORWithOne and IsGaussianMatrixSpace and IsAttributeStoringRep ), rec() ); else A:= Objectify( NewType( FamilyObj( mats ), IsFLMLORWithOne and IsVectorSpace and IsNonGaussianMatrixSpace and IsAttributeStoringRep ), rec() ); fi; SetLeftActingDomain( A, F ); SetGeneratorsOfLeftOperatorRingWithOne( A, AsList( mats ) ); SetZero( A, zero ); SetDimensionOfVectors( A, dims ); # If the generators are associative elements then so is `A'. if ForAll( mats, IsAssociativeElement ) then SetIsAssociative( A, true ); fi; # Return the result. return A; end ); ############################################################################# ## #M TwoSidedIdealByGenerators( , ) ## InstallMethod( TwoSidedIdealByGenerators, "for Gaussian matrix algebra and list of matrices", IsIdenticalObj, [ IsMatrixFLMLOR and IsGaussianMatrixSpace, IsCollection and IsList ], 0, function( A, mats ) local dims, I; # Check that all entries in `mats' are square matrices of the same shape. dims:= DimensionOfVectors( A ); if not ForAll( mats, mat -> IsMatrix( mat ) and DimensionsMat( mat ) = dims ) then Error( "entries of do not have the right dimension" ); fi; I:= Objectify( NewType( FamilyObj( mats ), IsFLMLOR and IsGaussianMatrixSpace and IsAttributeStoringRep ), rec() ); SetLeftActingDomain( I, LeftActingDomain( A ) ); SetGeneratorsOfTwoSidedIdeal( I, mats ); SetLeftActingRingOfIdeal( I, A ); SetRightActingRingOfIdeal( I, A ); SetDimensionOfVectors( I, dims ); # Return the result. return I; end ); InstallMethod( TwoSidedIdealByGenerators, "for non-Gaussian matrix algebra and list of matrices", IsIdenticalObj, [ IsMatrixFLMLOR and IsNonGaussianMatrixSpace, IsCollection and IsList ], 0, function( A, mats ) local dims, I; # Check that all entries in `mats' are square matrices of the same shape. dims:= DimensionOfVectors( A ); if not ForAll( mats, mat -> IsMatrix( mat ) and DimensionsMat( mat ) = dims ) then Error( "entries of do not have the right dimension" ); fi; I:= Objectify( NewType( FamilyObj( mats ), IsFLMLOR and IsVectorSpace and IsNonGaussianMatrixSpace and IsAttributeStoringRep ), rec() ); SetLeftActingDomain( I, LeftActingDomain( A ) ); SetGeneratorsOfTwoSidedIdeal( I, mats ); SetLeftActingRingOfIdeal( I, A ); SetRightActingRingOfIdeal( I, A ); SetDimensionOfVectors( I, dims ); # Return the result. return I; end ); InstallMethod( TwoSidedIdealByGenerators, "for matrix algebra and empty list", true, [ IsMatrixFLMLOR, IsList and IsEmpty ], 0, function( A, mats ) local I; I:= Objectify( NewType( FamilyObj( mats ), IsFLMLOR and IsGaussianMatrixSpace and IsTrivial and IsAttributeStoringRep ), rec() ); SetLeftActingDomain( I, LeftActingDomain( A ) ); SetGeneratorsOfTwoSidedIdeal( I, mats ); SetGeneratorsOfLeftOperatorRing( I, mats ); SetGeneratorsOfLeftModule( I, mats ); SetLeftActingRingOfIdeal( I, A ); SetRightActingRingOfIdeal( I, A ); SetDimensionOfVectors( I, DimensionOfVectors( A ) ); # Return the result. return I; end ); ############################################################################# ## #M LeftIdealByGenerators( , ) ## InstallMethod( LeftIdealByGenerators, "for Gaussian matrix algebra and list of matrices", IsIdenticalObj, [ IsMatrixFLMLOR and IsGaussianMatrixSpace, IsCollection and IsList ], 0, function( A, mats ) local dims, I; # Check that all entries in `mats' are square matrices of the same shape. dims:= DimensionOfVectors( A ); if not ForAll( mats, mat -> IsMatrix( mat ) and DimensionsMat( mat ) = dims ) then Error( "entries of do not have the right dimension" ); fi; I:= Objectify( NewType( FamilyObj( mats ), IsFLMLOR and IsGaussianMatrixSpace and IsAttributeStoringRep ), rec() ); SetLeftActingDomain( I, LeftActingDomain( A ) ); SetGeneratorsOfLeftIdeal( I, AsList( mats ) ); SetLeftActingRingOfIdeal( I, A ); SetDimensionOfVectors( I, dims ); # Return the result. return I; end ); InstallMethod( LeftIdealByGenerators, "for non-Gaussian matrix algebra and list of matrices", IsIdenticalObj, [ IsMatrixFLMLOR and IsNonGaussianMatrixSpace, IsCollection and IsList ], 0, function( A, mats ) local dims, I; # Check that all entries in `mats' are square matrices of the same shape. dims:= DimensionOfVectors( A ); if not ForAll( mats, mat -> IsMatrix( mat ) and DimensionsMat( mat ) = dims ) then Error( "entries of do not have the right dimension" ); fi; I:= Objectify( NewType( FamilyObj( mats ), IsFLMLOR and IsVectorSpace and IsNonGaussianMatrixSpace and IsAttributeStoringRep ), rec() ); SetLeftActingDomain( I, LeftActingDomain( A ) ); SetGeneratorsOfLeftIdeal( I, AsList( mats ) ); SetLeftActingRingOfIdeal( I, A ); SetDimensionOfVectors( I, dims ); # Return the result. return I; end ); InstallMethod( LeftIdealByGenerators, "for matrix algebra and empty list", true, [ IsMatrixFLMLOR, IsList and IsEmpty ], 0, function( A, mats ) local I; I:= Objectify( NewType( FamilyObj( mats ), IsFLMLOR and IsGaussianMatrixSpace and IsTrivial and IsAttributeStoringRep ), rec() ); SetLeftActingDomain( I, LeftActingDomain( A ) ); SetGeneratorsOfLeftIdeal( I, mats ); SetGeneratorsOfLeftOperatorRing( I, mats ); SetGeneratorsOfLeftModule( I, mats ); SetLeftActingRingOfIdeal( I, A ); SetDimensionOfVectors( I, DimensionOfVectors( A ) ); # Return the result. return I; end ); ############################################################################# ## #M RightIdealByGenerators( , ) ## InstallMethod( RightIdealByGenerators, "for Gaussian matrix algebra and list of matrices", IsIdenticalObj, [ IsMatrixFLMLOR and IsGaussianMatrixSpace, IsCollection and IsList ], 0, function( A, mats ) local dims, I; # Check that all entries in `mats' are square matrices of the same shape. dims:= DimensionOfVectors( A ); if not ForAll( mats, mat -> IsMatrix( mat ) and DimensionsMat( mat ) = dims ) then Error( "entries of do not have the right dimension" ); fi; I:= Objectify( NewType( FamilyObj( mats ), IsFLMLOR and IsGaussianMatrixSpace and IsAttributeStoringRep ), rec() ); SetLeftActingDomain( I, LeftActingDomain( A ) ); SetGeneratorsOfRightIdeal( I, mats ); SetRightActingRingOfIdeal( I, A ); SetDimensionOfVectors( I, dims ); # Return the result. return I; end ); InstallMethod( RightIdealByGenerators, "for non-Gaussian matrix algebra and list of matrices", IsIdenticalObj, [ IsMatrixFLMLOR and IsNonGaussianMatrixSpace, IsCollection and IsList ], 0, function( A, mats ) local dims, I; # Check that all entries in `mats' are square matrices of the same shape. dims:= DimensionOfVectors( A ); if not ForAll( mats, mat -> IsMatrix( mat ) and DimensionsMat( mat ) = dims ) then Error( "entries of do not have the right dimension" ); fi; I:= Objectify( NewType( FamilyObj( mats ), IsFLMLOR and IsVectorSpace and IsNonGaussianMatrixSpace and IsAttributeStoringRep ), rec() ); SetLeftActingDomain( I, LeftActingDomain( A ) ); SetGeneratorsOfRightIdeal( I, mats ); SetRightActingRingOfIdeal( I, A ); SetDimensionOfVectors( I, dims ); # Return the result. return I; end ); InstallMethod( RightIdealByGenerators, "for matrix algebra and empty list", true, [ IsMatrixFLMLOR, IsList and IsEmpty ], 0, function( A, mats ) local I; I:= Objectify( NewType( FamilyObj( mats ), IsFLMLOR and IsGaussianMatrixSpace and IsTrivial and IsAttributeStoringRep ), rec() ); SetLeftActingDomain( I, LeftActingDomain( A ) ); SetGeneratorsOfRightIdeal( I, mats ); SetGeneratorsOfLeftOperatorRing( I, mats ); SetGeneratorsOfLeftModule( I, mats ); SetRightActingRingOfIdeal( I, A ); SetDimensionOfVectors( I, DimensionOfVectors( A ) ); # Return the result. return I; end ); ############################################################################# ## #M IsUnit( , ) . . . . . . . . . . . for matrix FLMLOR and matrix ## InstallMethod( IsUnit, "for matrix FLMLOR and matrix", IsCollsElms, [ IsMatrixFLMLOR, IsMatrix ], 0, function ( A, m ) m:= m^-1; return m <> fail and m in A; end ); ############################################################################# ## #M RadicalOfAlgebra( ) . . . . . . . . for an associative matrix algebra ## ## The radical of an associative algebra defined as the ideal of all ## elements $x$ of such that $x y$ is nilpotent for all $y$ in . ## ## For Gaussian matrix algebras this is easy to calculate, ## for arbitrary associative algebras the task is reduced to the ## Gaussian matrix algebra case. ## ## The implementation of the characterisitc p>0 part is by Craig Struble. ## InstallMethod( RadicalOfAlgebra, "for associative Gaussian matrix algebra", true, [ IsAlgebra and IsGaussianMatrixSpace and IsMatrixFLMLOR ], 0, function( A ) local F, # the field of A p, # the characteristic of F q, # the size of F n, # the dimension of A ident, # the identity matrix bas, # a list of basis vectors of A minusOne, # -1 in F eqs, # equation set i,j, # loop variables G, # Gram matrix I, # a list of basis vectors of an ideal of A I_prime, # I \cup ident changed, # flag denoted if $I_i <> I_{i-1}$ in ideal sequence pexp, # a power of the prime p dim, # the dimension of the vector space where A acts on charPoly, # characteristic polynomials of elements in A invFrob, # inverse of the Frobenius map of F invFrobexp, # a power of the invFrob r, r_prime; # the length of I and I_prime # Check associativity. if not IsAssociative( A ) then TryNextMethod(); fi; if Dimension( A ) = 0 then return A; fi; F:= LeftActingDomain( A ); p:= Characteristic( F ); n:= Dimension( A ); bas:= BasisVectors( Basis( A ) ); if p = 0 then # First we treat the characteristic 0 case. # According to Dickson's theorem we have that in this case # the radical of `A' is $\{ x\in A \mid Tr(xy) = 0 \forall y \in A \}$, # so it can be computed by solving a system of linear equations. eqs:= List( [ 1 .. n ], x -> [] ); for i in [1..n] do for j in [i..n] do eqs[i][j]:= TraceMat( bas[i] * bas[j] ); eqs[j][i]:= eqs[i][j]; od; od; return SubalgebraNC( A, List( NullspaceMat( eqs ), x -> LinearCombination( bas, x ) ), "basis" ); else # If `p' is greater than 0, then the situation is more difficult. # We implement the algorithm presented in # "Cohen, Arjeh M, G\'{a}bor Ivanyos, and David B. Wales, # 'Finding the radical of an algebra of linear transformations,' # Journal of Pure and Applied Algebra 117 & 118 (1997), 177-193". q := Size( F ); dim := Length( bas[1] ); pexp := 1; invFrob := InverseGeneralMapping(FrobeniusAutomorphism(F)); invFrobexp := IdentityMapping(F); minusOne := -One(F); ident := IdentityMat( dim, F ); changed := true; I := ShallowCopy( bas ); # Compute the sequence of ideals $I_i$ (see the paper by Cohen, et.al.) while pexp <= dim do # These values need recomputation only when $I_i <> I_{i-1}$ if changed then I_prime := ShallowCopy( I ); if not ident in I_prime then Add( I_prime, ident ); fi; r := Length( I ); r_prime := Length( I_prime ); eqs := NullMat( r, r_prime, F ); charPoly := List( [1..r], x -> [] ); for i in [1..r] do for j in [1..r_prime] do charPoly[i][j] := CoefficientsOfUnivariatePolynomial( CharacteristicPolynomial( F, F, I[i]*I_prime[j] ) ); od; od; changed := false; fi; for i in [1..r] do for j in [1..r_prime] do eqs[i][j] := minusOne^pexp * charPoly[i][j][dim-pexp+1]; od; od; G := NullspaceMat( eqs ); if Length( G ) = 0 then return TrivialSubalgebra( A ); elif Length( G ) <> r then # $I_i <> I_{i-1}$, so compute the basis for $I_i$ changed := true; G := List( G, x -> List( x, y -> y^invFrobexp ) ); I := List( G, x -> LinearCombination( I, x ) ); fi; # prepare for next step invFrobexp := invFrobexp * invFrob; pexp := pexp*p; od; return SubalgebraNC( A, I, "basis" ); fi; end ); ############################################################################# ## #F CentralizerInAssociativeGaussianMatrixAlgebra( , ) ## ## is a list of basis vectors of the $R$-FLMLOR that is the centralizer ## of the $R$-FLMLOR with generators in the $R$-FLMLOR ## with $R$-basis vectors . ## ## View the centralizer condition for the matrix $a$ as an equation system ## \[ \sum_{b\in B} c_b ( b a - a b ) = 0 \ , \] ## where $B$ is a basis of and $c_b$ in the coefficients field. ## Then the centralizer is spanned by the matrices ## $\sum_{b\in B} c_b b$ where the vector $c$ is a basis vector of ## the solution space. ## CentralizerInAssociativeGaussianMatrixAlgebra := function( base, gens ) #T better use structure constants ? local gen, mat, sol; for gen in gens do mat:= List( base, b -> Concatenation( b * gen - gen * b ) ); sol:= NullspaceMat( mat ); # Replace `base' by a vector space base of the centralizer. base:= List( sol, x -> LinearCombination( base, x ) ); od; return base; end; ############################################################################# ## #M Centralizer( , ) . . . . . . . . . for matrix FLMLOR and matrix ## InstallMethod( CentralizerOp, "for associative Gaussian matrix FLMLOR, and ordinary matrix", IsCollsElms, [ IsMatrixFLMLOR and IsAssociative and IsGaussianSpace, IsOrdinaryMatrix ], 0, function( A, mat ) return SubalgebraNC( A, CentralizerInAssociativeGaussianMatrixAlgebra( BasisVectors( Basis( A ) ), [ mat ] ), "basis" ); end ); ############################################################################# ## #M Centralizer( , ) . . . . . . . for matrix FLMLOR and matrix FLMLOR ## InstallMethod( CentralizerOp, "for associative Gaussian matrix FLMLOR, and FLMLOR", IsIdenticalObj, [ IsMatrixFLMLOR and IsAssociative and IsGaussianSpace, IsMatrixFLMLOR ], 0, function( A, C ) return SubalgebraNC( A, CentralizerInAssociativeGaussianMatrixAlgebra( BasisVectors( Basis( A ) ), GeneratorsOfAlgebra( C ) ), "basis" ); end ); ############################################################################# ## #M Centralizer( , ) . . . . . for matrix FLMLOR-with-one and matrix ## InstallMethod( CentralizerOp, "for associative Gaussian matrix FLMLOR-with-one, and ordinary matrix", IsCollsElms, [ IsMatrixFLMLOR and IsFLMLORWithOne and IsAssociative and IsGaussianSpace, IsOrdinaryMatrix ], 0, function( A, mat ) return SubalgebraWithOneNC( A, CentralizerInAssociativeGaussianMatrixAlgebra( BasisVectors( Basis( A ) ), [ mat ] ), "basis" ); end ); ############################################################################# ## #M Centralizer( , ) . . for matrix FLMLOR-with-one and matrix FLMLOR ## InstallMethod( CentralizerOp, "for associative Gaussian matrix FLMLOR-with-one, and FLMLOR", IsIdenticalObj, [ IsMatrixFLMLOR and IsFLMLORWithOne and IsAssociative and IsGaussianSpace, IsMatrixFLMLOR ], 0, function( A, C ) return SubalgebraWithOneNC( A, CentralizerInAssociativeGaussianMatrixAlgebra( BasisVectors( Basis( A ) ), GeneratorsOfAlgebra( C ) ), "basis" ); end ); ############################################################################# ## #F FullMatrixAlgebraCentralizer( , ) ## ## Compute the centralizer of the list of matrices in the full ## matrix algebra over . ## InstallGlobalFunction( FullMatrixAlgebraCentralizer, function( F, lst ) local len, # length of `lst' dims, # dimensions of the matrices n, # number of rows/columns n2, # square of `n' eq, # equation system u,i,j,k, # loop variables bc, # basis of solutions of the equation system Bcen, # basis vectors of the centralizer M; # one centralizing matrix len:= Length( lst ); if len = 0 then Error( "cannot compute the centralizer of an empty set" ); elif not (IsSubset( F, DefaultScalarDomainOfMatrixList( lst ) ) or IsSubset( F, FieldOfMatrixList( lst ) ) ) then Error( "not all entries of the matrices in lie in " ); fi; dims:= DimensionsMat( lst[1] ); n:= dims[1]; n2:= n*n; # In the equations matrices are viewed as vectors of length `n*n'. # Position `(i,j)' in the matrix corresponds with position `(i-1)*n+j' # in the vector. eq:= NullMat( n2, n2 * len, F ); for u in [ 1 .. len ] do for i in [1..n] do for j in [1..n] do for k in [1..n] do eq[(i-1)*n+k][(u-1)*n2+(i-1)*n+j]:= eq[(i-1)*n+k][(u-1)*n2+(i-1)*n+j] + lst[u][k][j]; eq[(k-1)*n+j][(u-1)*n2+(i-1)*n+j]:= eq[(k-1)*n+j][(u-1)*n2+(i-1)*n+j] - lst[u][i][k]; od; od; od; od; # Translate the vectors back to matrices. bc:= NullspaceMat( eq ); Bcen:= []; for i in bc do M:= []; for j in [ 1 .. n ] do M[j]:= i{ [ (j-1)*n+1 .. j*n ] }; od; Add( Bcen, M ); od; return AlgebraWithOne( F, Bcen, "basis" ); end ); ############################################################################# ## #M CentralizerOp( , ) . . . . . . for full associative matrix algebra ## InstallMethod( CentralizerOp, "for full (associative) matrix FLMLOR, and FLMLOR", IsIdenticalObj, [ IsMatrixFLMLOR and IsFLMLORWithOne and IsAssociative and IsGaussianSpace and IsFullMatrixModule, IsMatrixFLMLOR ], 0, function( A, S ) if not IsAssociative( A ) then TryNextMethod(); fi; return FullMatrixAlgebraCentralizer( LeftActingDomain( A ), GeneratorsOfAlgebra( S ) ); end ); InstallMethod( CentralizerOp, "for full (associative) matrix FLMLOR, and left module", IsIdenticalObj, [ IsMatrixFLMLOR and IsFLMLORWithOne and IsAssociative and IsGaussianSpace and IsFullMatrixModule, IsLeftModule ], 0, function( A, S ) if not IsAssociative( A ) then TryNextMethod(); fi; return FullMatrixAlgebraCentralizer( LeftActingDomain( A ), GeneratorsOfLeftModule( S ) ); end ); InstallMethod( CentralizerOp, "for full (associative) matrix FLMLOR, and list of matrices", IsIdenticalObj, [ IsMatrixFLMLOR and IsFLMLORWithOne and IsAssociative and IsGaussianSpace and IsFullMatrixModule, IsCollection and IsList ], 0, function( A, S ) if not IsAssociative( A ) then TryNextMethod(); fi; return FullMatrixAlgebraCentralizer( LeftActingDomain( A ), S ); end ); InstallMethod( CentralizerOp, "for full (associative) matrix FLMLOR, and empty list", true, [ IsMatrixFLMLOR and IsFullMatrixModule, IsList and IsEmpty ], 0, function( A, S ) if not IsAssociative( A ) then TryNextMethod(); fi; return A; end ); ############################################################################# ## #F FullMatrixFLMLOR( , ) . . . FLMLOR of -dim. matrices over ## ## Let $E_{i,j}$ be the matrix with value 1 in row $i$ and $column $j$, and ## zero otherwise. ## Clearly the full associative matrix algebra is generated by all ## $E_{i,j}$, $i$ and $j$ ranging from 1 to . ## Define the matrix $F$ as permutation matrix for the permutation ## $(1, 2, \ldots, n)$. Then $E_{i,j} = F^{i-1} E_{1,1} F^{1-j}$. ## Thus $F$ and $E_{1,1}$ are sufficient to generate the algebra. ## InstallGlobalFunction( FullMatrixFLMLOR, function( R, n ) local i, # loop over the rows gens, # list of generators one, # the identity of the field A; # algebra, result gens:= NullMat( n, n, R ); gens:= [ gens, List( gens, ShallowCopy ) ]; one:= One( R ); # Construct the generators. gens[1][1][1]:= one; gens[2][1][n]:= one; for i in [ 2 .. n ] do gens[2][i][i-1]:= one; od; # Construct the FLMLOR. A:= AlgebraWithOneByGenerators( R, gens ); SetIsFullMatrixModule( A, true ); SetRadicalOfAlgebra( A, TrivialSubalgebra( A ) ); # Return the FLMLOR. return A; end ); ############################################################################# ## #F FullMatrixLieAlgebra( , ) #F . . full matrix Lie algebra of -dim. matrices over ## ## The set $\{ E_{1,j}, E_{k,1}; 1 \leq j, k \leq n \}$ is a generating ## system. #T What is a nicer generating system ? ## InstallGlobalFunction( FullMatrixLieFLMLOR, function( F, n ) local null, # null matrix one, # identity of `F' gen, # one generator gens, # list of generators i, # loop over the rows A; # algebra, result # Construct the generators. null:= NullMat( n, n, F ); one:= One( F ); gen:= List( null, ShallowCopy ); gen[1][1]:= one; gens:= [ LieObject( gen ) ]; for i in [ 2 .. n ] do gen:= List( null, ShallowCopy ); gen[1][i]:= one; Add( gens, LieObject( gen ) ); gen:= List( null, ShallowCopy ); gen[i][1]:= one; Add( gens, LieObject( gen ) ); od; # construct the algebra A:= AlgebraByGenerators( F, gens ); SetIsFullMatrixModule( A, true ); # return the algebra return A; end ); ############################################################################# ## #M DirectSumOfAlgebras( , ) . . for two associative matrix FLMLORs ## ## Construct an associative matrix FLMLOR. ## #T embeddings/projections should be provided! ## InstallOtherMethod( DirectSumOfAlgebras, "for two associative matrix FLMLORs", IsIdenticalObj, [ IsMatrixFLMLOR and IsAssociative, IsMatrixFLMLOR and IsAssociative ], 0, function( A1, A2 ) local b1, # Basis vectors of `A1'. b2, # Basis vectors of `A2'. p1, # Length of the matrices of `b1'. p2, # Length of the matrices of `b2'. B, # A basis of `A1 \oplus A2'. i, # Loop variable. Q, # A matrix. A; # result if LeftActingDomain( A1 ) <> LeftActingDomain( A2 ) then Error( " and must be written over the same domain" ); fi; # We do not really need a basis for the arguments # but if we have one then we use it. #T Do we really have so many algebra generators? (distinguish from basis?) if HasBasis( A1 ) and HasBasis( A2 ) then b1:= BasisVectors( Basis( A1 ) ); b2:= BasisVectors( Basis( A2 ) ); else b1:= GeneratorsOfAlgebra( A1 ); b2:= GeneratorsOfAlgebra( A2 ); fi; p1:= DimensionOfVectors( A1 )[1]; p2:= DimensionOfVectors( A2 )[1]; B:= []; for i in b1 do Q:= NullMat( p1+p2, p1+p2, LeftActingDomain( A1 ) ); Q{ [ 1 .. p1 ] }{ [ 1 .. p1 ] }:= i; Add( B, Q ); od; for i in b2 do Q:= NullMat( p1+p2, p1+p2, LeftActingDomain( A1 ) ); Q{ [ p1+1 .. p1+p2 ] }{ [ p1+1 .. p1+p2 ] }:= i; Add( B, Q ); od; A:= AlgebraByGenerators( LeftActingDomain( A1 ), B ); if HasBasis( A1 ) and HasBasis( A2 ) then UseBasis( A, B ); fi; SetIsAssociative( A, true ); #T nec. ? return A; end ); ############################################################################# ## #M DirectSumOfAlgebras( , ) . . . . . . for two matrix Lie FLMLORs ## ## Construct a matrix Lie FLMLOR. ## #T embeddings/projections should be provided! ## InstallOtherMethod( DirectSumOfAlgebras, "for two matrix Lie FLMLORs", IsIdenticalObj, [ IsMatrixFLMLOR and IsLieAlgebra, IsMatrixFLMLOR and IsLieAlgebra ], 0, function( A1, A2 ) local b1, # Basis vectors of `A1'. b2, # Basis vectors of `A2'. p1, # Length of the matrices of `b1'. p2, # Length of the matrices of `b2'. B, # A basis of `A1 \oplus A2'. i, # Loop variable. Q, # A matrix. A; # result if LeftActingDomain( A1 ) <> LeftActingDomain( A2 ) then Error( " and must be written over the same domain" ); fi; # We do not really need a basis for the arguments # but if we have one then we use it. #T Do we really have so many algebra generators? (distinguish from basis?) if HasBasis( A1 ) and HasBasis( A2 ) then b1:= BasisVectors( Basis( A1 ) ); b2:= BasisVectors( Basis( A2 ) ); else b1:= GeneratorsOfAlgebra( A1 ); b2:= GeneratorsOfAlgebra( A2 ); fi; p1:= DimensionOfVectors( A1 )[1]; p2:= DimensionOfVectors( A2 )[1]; B:= []; for i in b1 do Q:= NullMat( p1+p2, p1+p2, LeftActingDomain( A1 ) ); Q{ [ 1 .. p1 ] }{ [ 1 .. p1 ] }:= i; Add( B, LieObject( Q ) ); od; for i in b2 do Q:= NullMat( p1+p2, p1+p2, LeftActingDomain( A1 ) ); Q{ [ p1+1 .. p1+p2 ] }{ [ p1+1 .. p1+p2 ] }:= i; Add( B, LieObject( Q ) ); od; A:= AlgebraByGenerators( LeftActingDomain( A1 ), B ); if HasBasis( A1 ) and HasBasis( A2 ) then UseBasis( A, B ); fi; SetIsLieAlgebra( A, true ); return A; end ); ############################################################################# ## #M Units( ) . . . . . . for a full matrix algebra (over a finite field) ## InstallMethod( Units, "for a full matrix algebra (over a finite field)", [ IsAlgebra and IsFullMatrixModule and IsFFECollCollColl ], function( A ) local F; F:= LeftActingDomain( A ); if IsField( F ) and IsFinite( F ) then return GL( DimensionOfVectors( A )[1], Size( F ) ); else TryNextMethod(); fi; end ); ############################################################################# ## #F EmptyMatrix( ) ## InstallGlobalFunction( EmptyMatrix, function( char ) local Fam, mat; # Get the right family. if char = 0 then Fam:= CollectionsFamily( CollectionsFamily( CyclotomicsFamily ) ); else Fam:= CollectionsFamily( CollectionsFamily( FFEFamily( char ) ) ); fi; # Construct the matrix. mat:= Objectify( NewType( Fam, IsList and IsEmpty and IsOrdinaryMatrix and IsZero and IsAssociativeElement and IsCommutativeElement and IsJacobianElement and IsAttributeStoringRep ), rec() ); SetName( mat, Concatenation( "EmptyMatrix( ", String( char ), " )" ) ); SetInverse( mat, mat ); SetAdditiveInverse( mat, mat ); SetDimensionsMat( mat, [ 0, 0 ] ); SetLength( mat, 0 ); return mat; end ); InstallMethod( \+, "for two empty matrices", IsIdenticalObj, [ IsMatrix and IsEmpty, IsMatrix and IsEmpty ], 0, function( m1, m2 ) return m1; end ); InstallOtherMethod( \*, "for two empty matrices", IsIdenticalObj, [ IsMatrix and IsEmpty, IsMatrix and IsEmpty ], 0, function( m1, m2 ) return m1; end ); InstallOtherMethod( \*, "for empty matrix, and empty list", true, [ IsMatrix and IsEmpty, IsList and IsEmpty ], 0, function( m1, m2 ) return []; end ); InstallOtherMethod( \*, "for empty list, and empty matrix", true, [ IsList and IsEmpty, IsMatrix and IsEmpty ], 0, function( m1, m2 ) return []; end ); InstallOtherMethod( \*, "for empty matrix, and ring element", true, [ IsMatrix and IsEmpty, IsRingElement ], 0, function( m, scalar ) return m; end ); InstallOtherMethod( \*, "for ring element, and empty matrix", true, [ IsRingElement, IsMatrix and IsEmpty ], 0, function( scalar, m ) return m; end ); InstallMethod( \^, "for empty matrix, and integer", true, [ IsMatrix and IsEmpty, IsInt ], 0, function( emptymat, n ) return emptymat; end ); ############################################################################# ## #M NullAlgebra( ) . . . . . . . . . . . . . null algebra over ring ## InstallMethod( NullAlgebra, "for a ring", true, [ IsRing ], 0, R -> FLMLORByGenerators( R, [], EmptyMatrix( Characteristic( R ) ) ) ); #T ############################################################################# #T ## #T #F Fingerprint( ) . . . . . . . . . . . . . . fingerprint of algebra #T #F Fingerprint( , ) . . . . . . . . . . fingerprint of algebra #T ## #T ## If there is only one argument then the standard fingerprint is computed. #T ## This works for two-generator algebras acting only. #T ## #T Fingerprint := function( arg ) #T #T # Check the arguments. #T if Length( arg ) = 0 or Length( arg ) > 2 then #T Error( "usage: Fingerprint( [, ] )" ); #T fi; #T #T if Length( arg ) = 2 then #T #T return arg[1].operations.Fingerprint( arg[1], arg[2] ); #T #T elif Length( arg ) = 1 then #T #T if not IsBound( arg[1].fingerprint ) then #T arg[1].fingerprint:= #T arg[1].operations.Fingerprint( arg[1], "standard" ); #T fi; #T return arg[1].fingerprint; #T #T else #T Error( "number of generating matrices must be 2" ); #T fi; #T end; #T #T ############################################################################# #T ## #T #F Nullity( ) #T ## #T Nullity := function( mat ) #T return Dimensions( BaseNullspace( mat ) )[1]; #T end; #T #T ############################################################################# #T ## #T #F MatrixAssociativeAlgebraOps.Fingerprint( , ) #T ## #T MatrixAssociativeAlgebraOps.Fingerprint := function( A, list ) #T #T local fp, # fingerprint, result #T a, # first generator #T b, # second generator #T ab, # product of `a' and `b' #T word; # actual word #T #T if list = "standard" then #T #T if Length( AlgebraGenerators( A ) ) <> 2 then #T Error( "exactly two generators needed for standard finger print" ); #T fi; #T #T # Compute the nullities of the 6 standard elements. #T fp:= []; #T a:= AlgebraGenerators( A )[1]; #T b:= AlgebraGenerators( A )[2]; #T ab:= a * b; #T word:= ab + a + b; fp[1]:= Nullity( word ); #T word:= word + ab * b; fp[2]:= Nullity( word ); #T word:= a + b * word; fp[3]:= Nullity( word ); #T word:= b + word; fp[4]:= Nullity( word ); #T word:= ab + word; fp[5]:= Nullity( word ); #T word:= a + word; fp[6]:= Nullity( word ); #T #T else #T #T # Compute the nullities of the words with numbers in the list. #T fp:= List( list, x -> Nullity( ElementAlgebra( A, x ) ) ); #T #T fi; #T return fp; #T end; ############################################################################# ## #M RepresentativeLinearOperation( , , , ) . . for matrix alg. ## ## Let be a finite dimensional algebra over the ring $R$, ## and and vectors such that acts on them via the *linear* ## operation . ## We compute an element of that maps to . ## ## We compute the coefficients $a_i$ in the equation system ## $\sum_{i=1}^n a_i ( , b_i ) = $, ## where $(b_1, b_2, \ldots, b_n)$ is a basis of . ## ## For a tuple $(v_1, \ldots, v_k)$ of vectors we simply replace $v b_i$ by ## the concatenation of the $v_j b_i$ for all $j$, and replace $w$ by the ## concatenation $(w_1, \ldots, w_k)$, and solve this system. ## ## (Here we install methods for matrix algebras, acting on row vectors. ## There are also generic algebra methods for algebras acting on themselves ## or on their free modules via `OnRight' or `OnTuples'.) ## InstallMethod( RepresentativeLinearOperation, "for a matrix FLMLOR, two row vectors, and `OnRight'", IsCollCollsElmsElmsX, [ IsMatrixFLMLOR, IsRowVector, IsRowVector, IsFunction ], 0, function( A, v, w, opr ) local B, vectors, a; if not ( opr = OnRight or opr = OnPoints ) then TryNextMethod(); fi; if IsTrivial( A ) then if IsZero( w ) then return Zero( A ); else return fail; fi; fi; B:= Basis( A ); vectors:= BasisVectors( B ); # Compute the matrix of the equation system, # the coefficient vector $a$, \ldots a:= SolutionMat( List( vectors, x -> v * x ), w ); if a = fail then return fail; fi; # \ldots and the representative. return LinearCombination( B, a ); end ); InstallMethod( RepresentativeLinearOperation, "for a matrix FLMLOR, two lists of row vectors, and `OnTuples'", IsCollsElmsElmsX, [ IsFLMLOR, IsMatrix, IsMatrix, IsFunction ], 0, #T IsOrdinaryMatrix? function( A, vs, ws, opr ) local B, vectors, a; if not ( opr = OnTuples or opr = OnPairs ) then TryNextMethod(); fi; if IsTrivial( A ) then if IsZero( ws ) then return Zero( A ); else return fail; fi; fi; B:= Basis( A ); vectors:= BasisVectors( B ); # Compute the matrix of the equation system, # the coefficient vector $a$, \ldots a:= SolutionMat( List( vectors, x -> Concatenation( vs * x ) ), Concatenation( ws ) ); if a = fail then return fail; fi; # \ldots and the representative. return LinearCombination( B, a ); end ); ############################################################################# ## #M IsomorphismMatrixFLMLOR( ) . . . . . . . . . . . for a matrix FLMLOR ## InstallMethod( IsomorphismMatrixFLMLOR, "for a matrix FLMLOR", true, [ IsMatrixFLMLOR ], 0, IdentityMapping ); #T ############################################################################# #T ## #T #F MatrixAssociativeAlgebraOps.NaturalModule( ) #T ## #T MatrixAssociativeAlgebraOps.NaturalModule := function( A ) #T #T local gens, # module generators #T N; # natural module, result #T #T if Length( AlgebraGenerators( Parent( A ) ) ) = 0 then #T gens:= IdentityMat( A.field, Length( Zero( Parent( A ) ) ) ); #T else #T gens:= Parent( A ).algebraGenerators[1]^0; #T fi; #T #T wirklich Erzeuger angeben ? #T N:= Module( A, gens ); #T N.isNaturalModule:= true; #T N.spaceGenerators:= gens; #T return N; #T end; ############################################################################# ## #E gap-4r6p5/lib/pcgsind.gd0000644000175000017500000003424412172557252013661 0ustar billbill############################################################################# ## #W pcgsind.gd GAP Library Frank Celler ## ## #Y Copyright (C) 1996, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1998 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the operations for induced polycylic generating ## systems. ## ############################################################################# ## #C IsInducedPcgs() ## ## <#GAPDoc Label="IsInducedPcgs"> ## ## ## ## ## The category of induced pcgs. This a subcategory of pcgs. ## ## ## <#/GAPDoc> ## DeclareCategory( "IsInducedPcgs", IsPcgs ); ############################################################################# ## #O InducedPcgsByPcSequence( , ) #O InducedPcgsByPcSequenceNC( , [, ] ) ## ## <#GAPDoc Label="InducedPcgsByPcSequence"> ## ## ## ## ## ## If pcs is a list of elements that form an induced pcgs ## with respect to pcgs this operation returns an induced pcgs ## with these elements. ##

## In the third version, the depths of pcs with respect to ## pcgs can be given (they are computed anew otherwise). ## ## ## <#/GAPDoc> ## DeclareOperation( "InducedPcgsByPcSequence", [ IsPcgs, IsList ] ); DeclareOperation( "InducedPcgsByPcSequenceNC", [ IsPcgs, IsList ] ); ############################################################################# ## #A LeadCoeffsIGS( ) ## ## <#GAPDoc Label="LeadCoeffsIGS"> ## ## ## ## ## This attribute is used to store leading coefficients with respect to the ## parent pcgs. the i-th entry –if bound– is the leading ## exponent of the element of igs that has depth i in the ## parent. ## (It cannot be assigned to a component in the object created by ## as the ## permutation group methods call it from within the postprocessing, ## before this postprocessing however no coefficients may be computed.) ## ## ## <#/GAPDoc> ## DeclareAttribute( "LeadCoeffsIGS", IsInducedPcgs ); ############################################################################# ## #O InducedPcgsByPcSequenceAndGenerators( , , ) ## ## <#GAPDoc Label="InducedPcgsByPcSequenceAndGenerators"> ## ## ## ## ## returns an induced pcgs with respect to pcgs of the subgroup ## generated by ind and gens. ## Here ind must be an induced pcgs with respect to ## pcgs (or a list of group elements that form such an igs) ## and it will be used as initial sequence for the computation. ## ## G := Group( (1,2,3,4),(1,2) );; P := Pcgs(G);; ## gap> I := InducedPcgsByGenerators( P, [(1,2,3,4)] ); ## Pcgs([ (1,2,3,4), (1,3)(2,4) ]) ## gap> J := InducedPcgsByPcSequenceAndGenerators( P, I, [(1,2)] ); ## Pcgs([ (1,2,3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareOperation( "InducedPcgsByPcSequenceAndGenerators", [ IsPcgs, IsList, IsList ] ); ############################################################################# ## #O InducedPcgsByGenerators( , ) #O InducedPcgsByGeneratorsNC( , ) ## ## <#GAPDoc Label="InducedPcgsByGenerators"> ## ## ## ## ## ## returns an induced pcgs with respect to pcgs ## for the subgroup generated by gens. ## ## ## <#/GAPDoc> ## DeclareOperation( "InducedPcgsByGenerators", [ IsPcgs, IsCollection ] ); DeclareOperation( "InducedPcgsByGeneratorsNC", [ IsPcgs, IsCollection ] ); ############################################################################# ## #O InducedPcgsByGeneratorsWithImages( , , ) ## ## ## ## ## ## ## ## DeclareOperation( "InducedPcgsByGeneratorsWithImages", [ IsPcgs, IsCollection, IsCollection ] ); ############################################################################# ## #O CanonicalPcgsByGeneratorsWithImages( , , ) ## ## <#GAPDoc Label="CanonicalPcgsByGeneratorsWithImages"> ## ## ## ## ## computes a canonical, pcgs-induced pcgs for the span of ## gens and simultaneously does the same transformations on ## imgs, preserving thus a correspondence between gens and ## imgs. ## This operation is used to represent homomorphisms from a pc group. ## ## ## <#/GAPDoc> ## DeclareOperation( "CanonicalPcgsByGeneratorsWithImages", [ IsPcgs, IsCollection, IsCollection ] ); ############################################################################# ## #O AsInducedPcgs( , ) ## ## ## ## ## ## Obsolete function, potentially erraneous. DO NOT USE! ## returns an induced pcgs with parent as parent pcgs and to the ## sequence of elements pcs. ## ## ## DeclareOperation( "AsInducedPcgs", [ IsPcgs, IsList ] ); ############################################################################# ## #A ParentPcgs( ) ## ## <#GAPDoc Label="ParentPcgs"> ## ## ## ## ## returns the pcgs by which pcgs was induced. ## If pcgs was not induced, it simply returns pcgs. ## G := Group( (1,2,3,4),(1,2) );; ## gap> P := Pcgs(G);; ## gap> K := InducedPcgsByPcSequence( P, [(1,2,3,4),(1,3)(2,4)] ); ## Pcgs([ (1,2,3,4), (1,3)(2,4) ]) ## gap> ParentPcgs( K ); ## Pcgs([ (3,4), (2,4,3), (1,4)(2,3), (1,3)(2,4) ]) ## gap> IsInducedPcgs( K ); ## true ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "ParentPcgs", IsInducedPcgs ); ############################################################################# ## #A CanonicalPcgs( ) ## ## <#GAPDoc Label="CanonicalPcgs"> ## ## ## ## ## returns the canonical pcgs corresponding to the induced pcgs pcgs. ## G := Group((1,2,3,4),(5,6,7)); ## Group([ (1,2,3,4), (5,6,7) ]) ## gap> P := Pcgs(G); ## Pcgs([ (5,6,7), (1,2,3,4), (1,3)(2,4) ]) ## gap> I := InducedPcgsByPcSequence(P, [(5,6,7)*(1,3)(2,4),(1,3)(2,4)] ); ## Pcgs([ (1,3)(2,4)(5,6,7), (1,3)(2,4) ]) ## gap> CanonicalPcgs(I); ## Pcgs([ (5,6,7), (1,3)(2,4) ]) ## ]]> ## ## ## <#/GAPDoc> ## DeclareAttribute( "CanonicalPcgs", IsInducedPcgs ); ############################################################################# ## #P IsCanonicalPcgs( ) ## ## <#GAPDoc Label="IsCanonicalPcgs"> ## ## ## ## ## An induced pcgs is canonical if the matrix of the exponent vectors of ## the elements of pcgs with respect to the ## value of pcgs is in Hermite normal form ## (see ). While a subgroup can have various ## induced pcgs with respect to a parent pcgs a canonical pcgs is unique. ## ## ## <#/GAPDoc> ## DeclareProperty( "IsCanonicalPcgs", IsInducedPcgs ); ############################################################################# ## #P IsParentPcgsFamilyPcgs( ) ## ## <#GAPDoc Label="IsParentPcgsFamilyPcgs"> ## ## ## ## ## This property indicates that the pcgs pcgs is induced with respect ## to a family pcgs. ##

## This property is needed to distinguish between different independent ## polycyclic generating sequences which a pc group may have, since ## the elementary operations for a non-family pcgs may not be as efficient ## as the elementary operations for the family pcgs. ##

## This can have a significant influence on the performance of algorithms ## for polycyclic groups. ## Many algorithms require a pcgs that corresponds to an ## elementary abelian series ## (see ) ## or even a special pcgs (see ). ## If the family pcgs has the required ## properties, it will be used for these purposes, if not &GAP; has to work ## with respect to a new pcgs which is not the family pcgs and thus ## takes longer for elementary calculations like ## . ##

## Therefore, if the family pcgs chosen for arithmetic is not of importance ## it might be worth to change to another, nicer, pcgs to speed up ## calculations. ## This can be achieved, for example, by using the ## value ## of the isomorphism obtained by . ## ## ## <#/GAPDoc> ## DeclareProperty( "IsParentPcgsFamilyPcgs", IsInducedPcgs, 20 # we want this to be larger than filters like `PrimeOrderPcgs' # (cf. rank for `IsFamilyPcgs' in pcgsind.gd) ); ############################################################################# ## #A ElementaryAbelianSubseries( ) ## ## ## ## ## ## ## ## DeclareAttribute( "ElementaryAbelianSubseries", IsPcgs ); ############################################################################# ## #O CanonicalPcElement( , ) ## ## <#GAPDoc Label="CanonicalPcElement"> ## ## ## ## ## reduces elm at the induces pcgs ipcgs such that the ## exponents of the reduced result r are zero at the depths ## for which there are generators in ipcgs. ## Elements, whose quotient lies in the group generated by ## ipcgs yield the same canonical element. ## ## ## <#/GAPDoc> ## DeclareOperation( "CanonicalPcElement", [ IsInducedPcgs, IsObject ] ); ############################################################################# ## #O SiftedPcElement( , ) ## ## <#GAPDoc Label="SiftedPcElement"> ## ## ## ## ## sifts elm through pcgs, reducing it if the depth is the ## same as the depth of one of the generators in pcgs. ## Thus the identity is returned if elm lies in the group generated ## by pcgs. ## pcgs must be an induced pcgs (see section ## ) ## and elm must lie in the span of the parent of pcgs. ## ## ## <#/GAPDoc> ## DeclareOperation( "SiftedPcElement", [ IsInducedPcgs, IsObject ] ); ############################################################################# ## #O HomomorphicCanonicalPcgs( , ) ## ## ## ## ## ## It is important that imgs are the images of an induced generating ## system in their natural order, i. e. they must not be sorted according to ## their depths in the new group, they must be sorted according to their ## depths in the old group. ## ## ## DeclareOperation( "HomomorphicCanonicalPcgs", [ IsPcgs, IsList ] ); ############################################################################# ## #O HomomorphicInducedPcgs( , ) ## ## ## ## ## ## It is important that imgs are the images of an induced generating ## system in their natural order, i. e. they must not be sorted according to ## their depths in the new group, they must be sorted according to their ## depths in the old group. ## ## ## DeclareOperation( "HomomorphicInducedPcgs", [ IsPcgs, IsList ] ); ############################################################################# ## #O CorrespondingGeneratorsByModuloPcgs( , ) ## ## <#GAPDoc Label="CorrespondingGeneratorsByModuloPcgs"> ## ## ## ## ## Let mpcgs be a modulo pcgs for a factor of a group G ## and let U be a subgroup of G generated by imgs ## such that U covers the factor for the modulo pcgs. ## Then this function computes elements in U corresponding to the ## generators of the modulo pcgs. ##

## Note that the computation of induced generating sets is not possible ## for some modulo pcgs. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction("CorrespondingGeneratorsByModuloPcgs"); ############################################################################# ## #F NORMALIZE_IGS( , ) ## ## ## ## ## ## Obsolete function, potentially erraneous. DO NOT USE! ## ## ## DeclareGlobalFunction("NORMALIZE_IGS"); ############################################################################# ## #E gap-4r6p5/lib/straight.gd0000644000175000017500000010546212172557254014062 0ustar billbill############################################################################# ## #W straight.gd GAP library Thomas Breuer #W Alexander Hulpke #W Max Neunhöffer ## ## #Y Copyright (C) 1999, Lehrstuhl D für Mathematik, RWTH Aachen, Germany #Y (C) 1999 School Math and Comp. Sci., University of St Andrews, Scotland #Y Copyright (C) 2002 The GAP Group ## ## This file contains the declarations of the operations ## for straight line programs. ## ## 1. Functions for straight line programs ## 2. Functions for elements represented by straight line programs ## ############################################################################# ## ## 1. Functions for straight line programs ## ############################################################################# ## ## <#GAPDoc Label="[1]{straight}"> ## Straight line programs describe an efficient way for evaluating an ## abstract word at concrete generators, ## in a more efficient way than with . ## For example, ## the associative word ababbab of length 7 can be computed ## from the generators a, b with only four multiplications, ## by first computing c = ab, then d = cb, ## and then cdc; ## Alternatively, one can compute c = ab, e = bc, ## and aee. ## In each step of these computations, one forms words in terms of the ## words computed in the previous steps. ##

## A straight line program in &GAP; is represented by an object in the ## category ) ## that stores a list of lines ## each of which has one of the following three forms. ## ## ## a nonempty dense list l of integers, ## ## ## a pair [ l, i ] ## where l is a list of form 1. ## and i is a positive integer, ## ## ## a list [ l_1, l_2, \ldots, l_k ] ## where each l_i is a list of form 1.; ## this may occur only for the last line of the program. ## ## ##

## The lists of integers that occur are interpreted as external ## representations of associative words (see Section  ## ); ## for example, the list [ 1, 3, 2, -1 ] represents the word ## g_1^3 g_2^{{-1}}, with g_1 and g_2 the first and ## second abstract generator, respectively. ##

## For the meaning of the list of lines, see ## . ##

## Straight line programs can be constructed using ## . ##

## Defining attributes for straight line programs are ## ## and . ## Another operation for straight line programs is ## . ##

## Special methods applicable to straight line programs are installed for ## the operations , ## , , ## and . ##

## For a straight line program prog, ## the default method prints the interpretation ## of prog as a sequence of assignments of associative words; ## a record with components gensnames (with value a list of strings) ## and listname (a string) may be entered as second argument of ## , ## in this case these names are used, the default for gensnames is ## [ g1, g2, \ldots ], ## the default for listname is r. ## <#/GAPDoc> ## ############################################################################# ## #C IsStraightLineProgram( ) ## ## <#GAPDoc Label="IsStraightLineProgram"> ## ## ## ## ## Each straight line program in &GAP; lies in the category ## . ## ## ## <#/GAPDoc> ## DeclareCategory( "IsStraightLineProgram", IsObject ); ############################################################################# ## #F StraightLineProgram( [, ] ) #F StraightLineProgram( , ) #F StraightLineProgramNC( [, ] ) #F StraightLineProgramNC( , ) ## ## <#GAPDoc Label="StraightLineProgram"> ## ## ## ## ## ## ## ## In the first form, lines must be a list of lists that defines ## a unique straight line program ## (see ); in this case ## ## returns this program, otherwise an error is signalled. ## The optional argument nrgens specifies the number of input ## generators of the program; ## if a line of form 1. (that is, a list of integers) occurs in lines ## except in the last position, ## this number is not determined by lines and therefore must ## be specified by the argument nrgens; ## if not then ## ## returns fail. ##

## In the second form, string must be a string describing an ## arithmetic expression in terms of the strings in the list gens, ## where multiplication is denoted by concatenation, powering is denoted by ## ^, and round brackets (, ) may be used. ## Each entry in gens must consist only of uppercase or lowercase ## letters (i.e., letters in ) ## such that no entry is an initial part of another one. ## Called with this input, ## ## returns a straight line program that evaluates to the word corresponding ## to string when called with generators corresponding to ## gens. ##

## The NC variant does the same, ## except that the internal consistency of the program is not checked. ## ## ## <#/GAPDoc> ## DeclareGlobalFunction( "StraightLineProgram" ); DeclareGlobalFunction( "StraightLineProgramNC" ); ############################################################################# ## #F StringToStraightLineProgram( , ,